Produzzjoni: Skalar u Caching
F'din il-paġna
Għanijiet
- Ottimizza l-prestazzjoni ta’ sistema ta’ embeddings fil-produzzjoni
- Implimenta caching biex tnaqqas l-ispejjeż u l-latency
- Immaniġġja l-iskalar u d-disponibbiltà għolja
Sfidi tal-Produzzjoni
Waqt l-iżvilupp, is-sejħa tal-API ta’ OpenAI għal kull talba mhix problema: tista’ tagħmel għaxar sejħat kuljum. Fil-produzzjoni, dak l-istess kodiċi jolqot tliet ħitan fl-istess ħin. L-ewwel, l-ispiża: kull sejħa tiġi ffatturata, u re-indiċjar sħiħ ta’ corpus jitħallas kompletament kull darba li jinxtegħel. It-tieni, il-latency: vjaġġ ta’ netwerk (round trip) ta’ 100 sa 300 ms għal kull talba jiżdied mal-ħin tat-tfittxija u tal-ġenerazzjoni, u l-utent iħoss is-somma tat-tlieta. Fl-aħħar nett, il-limiti tar-rata (rate limits): OpenAI tillimita n-numru ta’ sejħat kull minuta—limitu li qatt ma tara fl-iżvilupp iżda li se tilħaq fil-jum tal-ħruġ.
It-tliet problemi kollha għandhom l-istess soluzzjoni fil-biċċa l-kbira: issejjaħx l-API meta mhux meħtieġ.
Caching tal-Embeddings
Embedding huwa deterministiku: l-istess test bl-istess mudell dejjem jirritorna l-istess vettur. Dan jagħmel il-caching effettiv ħafna hawnhekk, ferm aktar milli għal LLM ġenerattiv. Għal applikazzjoni b’traffiku moderat, id-dekoratur lru_cache tal-librerija standard huwa biżżejjed u jieħu biss żewġ linji. Il-valur ta’ ritorn jiġi kkonvertit f’tuple għax lru_cache jeħtieġ valuri hashable; dik hija l-unika diffikultà li għandek tkun taf.
from functools import lru_cache
from openai import OpenAI
import hashlib
import json
client = OpenAI()
@lru_cache(maxsize=10_000)
def embedding_cache(text: str, model: str = "text-embedding-3-large") -> tuple:
"""LRU cache għall-embeddings (tuple għax hija hashable)."""
response = client.embeddings.create(input=text, model=model)
return tuple(response.data[0].embedding)
# Użu - it-2 sejħa hija istantanja
emb1 = embedding_cache("Hello world") # Sejħa tal-API
emb2 = embedding_cache("Hello world") # Mill-cache
Dan il-cache jisparixxi fuq kwalunkwe riavvju u ma huwiex kondiviż bejn il-proċessi: hekk kif tħaddem żewġ istanzi wara load balancer, kull waħda tibni mill-ġdid tiegħu stess. Redis isolvi ż-żewġ problemi. Iċ-ċavetta hija hash tal-par mudell-test, li jipprevjeni li bidla fil-mudell isservi vetturi antiki, u TTL ta’ tletin jum jillimita t-tkabbir tal-ħażna.
Il-metodu get_embeddings_batch jistħoqqilu attenzjoni mill-qrib, peress li huwa dak li jagħmel id-differenza waqt l-ingestjoni. Ma jiċċekkjax il-cache test b’test biss: jifred dawk li ma nstabux (misses), jibgħathom f’sejħa waħda tal-API, imbagħad jerġa’ jdaħħal kull riżultat fil-pożizzjoni oriġinali tiegħu bl-użu ta’ indices_a_calculer. Fuq batch ta’ elf dokument fejn disa’ mija diġà huma magħrufa, tmur minn sejħa waħda għal kull dokument għal sejħa waħda biss għall-mija li fadal.
import redis
import numpy as np
import json
class EmbeddingCacheRedis:
def __init__(self, redis_url: str = "redis://localhost:6379"):
self.redis = redis.from_url(redis_url)
self.client = OpenAI()
self.ttl = 86400 * 30 # 30 jum
def _cache_key(self, text: str, model: str) -> str:
h = hashlib.md5(f"{model}:{text}".encode()).hexdigest()
return f"emb:{h}"
def get_embedding(
self, text: str, model: str = "text-embedding-3-large"
) -> list[float]:
key = self._cache_key(text, model)
# Iċċekkja l-cache
cached = self.redis.get(key)
if cached:
return json.loads(cached)
# Iġġenera u cache
response = self.client.embeddings.create(
input=text, model=model
)
embedding = response.data[0].embedding
self.redis.setex(key, self.ttl, json.dumps(embedding))
return embedding
def get_embeddings_batch(
self, texts: list[str], model: str = "text-embedding-3-large"
) -> list[list[float]]:
"""Batch b'caching parzjali."""
results = [None] * len(texts)
to_calculate = []
indices_to_calculate = []
# Iċċekkja l-cache għal kull test
for i, text in enumerate(texts):
key = self._cache_key(text, model)
cached = self.redis.get(key)
if cached:
results[i] = json.loads(cached)
else:
to_calculate.append(text)
indices_to_calculate.append(i)
# Ikkalkula l-misses f'sejħa waħda
if to_calculate:
response = self.client.embeddings.create(
input=to_calculate, model=model
)
for resp_item in sorted(response.data, key=lambda x: x.index):
idx = indices_to_calculate[resp_item.index]
text = to_calculate[resp_item.index]
embedding = resp_item.embedding
results[idx] = embedding
key = self._cache_key(text, model)
self.redis.setex(key, self.ttl, json.dumps(embedding))
print(f"Cache: {len(texts) - len(to_calculate)}/{len(texts)} hits")
return results
# Użu
cache = EmbeddingCacheRedis()
emb = cache.get_embedding("cache test")
Immaniġġjar tal-Limiti tar-Rata
Il-caching inaqqas it-traffiku iżda ma jeliminax, u qasma fit-traffiku eventwalment se ttriggerja RateLimitError. Ir-risposta korretta mhix li tipprova mill-ġdid immedjatament—li jaggravaw il-konġestjoni—iżda li tistenna, tirdoppja d-dewmien kull darba: sekonda, tnejn, erbgħa, tmienja, sittax. Ħames tentattivi għalhekk ikopru madwar tletin sekonda, li jassorbu l-biċċa l-kbira tal-qċaċet temporanji, u t-tentattiv finali jerġa’ jqajjem l-eċċezzjoni sabiex l-inċident jiġi rrapportat minflok ma jinbela’ b’mod silenzjuż.
import time
from openai import RateLimitError
class RobustEmbeddingClient:
def __init__(self, max_retries: int = 5):
self.client = OpenAI()
self.max_retries = max_retries
def create(
self, input: str | list[str], model: str = "text-embedding-3-large",
**kwargs
):
"""Sejħa b'retry esponenzjali."""
for attempt in range(self.max_retries):
try:
return self.client.embeddings.create(
input=input, model=model, **kwargs
)
except RateLimitError as e:
if attempt == self.max_retries - 1:
raise
wait = 2 ** attempt
print(f"Limitu tar-rata milħuq, nieqaf għal {wait}s...")
time.sleep(wait)
Ipproċessar Asinkronu
Għal pipelines ta’ ingestjoni, il-colloq ta’ bottlenecks mhux il-kompjuter iżda l-wait tan-netwerk: il-programm tiegħek iqatta’ l-biċċa l-kbira tal-ħin ma jagħmel xejn. L-ipproċessar asinkronu jħallik iżżomm talbiet multipli fl-arja. Is-semaphore tillimita intenzjonalment dan il-paralleliżmu, għax it-tnedija ta’ mitt sejħa simultanja biss ttriggerja l-limiti tar-rata li għaddek kemm tgħallimt timmaniġġja—tlieta sa ħames talbiet konkorrenti huma setting tajjeb. It-testi l-ewwel jinqasmu f’batches ta’ mitt, u l-indiċi tal-bidu ta’ kull batch jivvjaġġa mat-task sabiex as_completed, li jirritorna r-riżultati barra mill-ordni, xorta waħda jkun jista’ jpoġġihom korrettament.
import asyncio
from openai import AsyncOpenAI
async_client = AsyncOpenAI()
async def generate_embeddings_async(
texts: list[str],
model: str = "text-embedding-3-large",
max_concurrent: int = 5
) -> list[list[float]]:
"""Iġġenera embeddings parallelament b'semaphore."""
semaphore = asyncio.Semaphore(max_concurrent)
results = [None] * len(texts)
async def process_batch(batch_idx, batch):
async with semaphore:
response = await async_client.embeddings.create(
input=batch, model=model
)
return batch_idx, [
d.embedding
for d in sorted(response.data, key=lambda x: x.index)
]
# Aqsam f'batches ta' 100
tasks = []
batch_size = 100
for i in range(0, len(texts), batch_size):
batch = texts[i:i + batch_size]
tasks.append(process_batch(i, batch))
for coro in asyncio.as_completed(tasks):
batch_idx, embeddings = await coro
for j, emb in enumerate(embeddings):
results[batch_idx + j] = emb
return results
# Użu
embeddings = asyncio.run(
generate_embeddings_async(my_texts, max_concurrent=3)
)
Ottimizzazzjoni tal-Ħażna
Imbagħad hemm il-kont tal-infrastruttura. Għaxart elef vettur ta’ 3,072 dimensjoni f’float32 jokkupaw madwar 122 MB; miljun jokkupaw tnax-il gigabyte, li jridu jinżammu fil-memorja sabiex it-tfittxija tibqa’ mgħaġġla. Il-kwantizzazzjoni għal int8 timmappja kull koordinata għal 256 valur sħiħ, u taqsam l-impronta b’erba’ darbiet għal madwar 30 MB fl-eżempju hawn taħt. It-telf fil-preċiżjoni jeżisti iżda jibqa’ marġinali meta mqabbel mal-lakuni tas-similarità li qed taħdem bihom.
import numpy as np
def quantize_int8(embeddings: np.ndarray) -> tuple:
"""Kwantizza l-embeddings għal int8 (4 inqas memorja)."""
min_val = embeddings.min(axis=1, keepdims=True)
max_val = embeddings.max(axis=1, keepdims=True)
scale = (max_val - min_val) / 255.0
quantized = ((embeddings - min_val) / scale).astype(np.int8)
return quantized, min_val, scale
def dequantize_int8(quantized, min_val, scale):
"""Irripristina l-embeddings minn int8."""
return quantized.astype(np.float32) * scale + min_val
# Tqabbil tad-daqs
embeddings = np.random.randn(10000, 3072).astype(np.float32)
print(f"float32 : {embeddings.nbytes / 1e6:.1f} MB") # ~122 MB
quantized, min_val, scale = quantize_int8(embeddings)
print(f"int8 : {quantized.nbytes / 1e6:.1f} MB") # ~30 MB
Madankollu, il-lever l-aktar sempliċi jibqa’ l-parametru dimensions tal-API, li jipproduċi vetturi iqsar direttament mingħajr ebda post-ipproċessar min-naħa tiegħek: 3,072 dimensjoni jiżnu madwar 24 KB għal kull vettur, 1,024 dimensjoni jinżlu għal 8 KB, u 256 dimensjoni għal 2 KB.
# 3072 dim -> ~24 KB għal kull vettur
# 1024 dim -> ~8 KB għal kull vettur (Tnaqqis tal-API)
# 256 dim -> ~2 KB għal kull vettur (Tnaqqis tal-API)
response = client.embeddings.create(
input="text",
model="text-embedding-3-large",
dimensions=1024 # 3 inqas ħażna
)
Arkitettura tal-Produzzjoni
Meta jingħaqdu, dawn il-biċċiet jagħtu pipeline snella: cache Redis quddiem, client robust għas-sejħat li jgħaddu xorta waħda. L-ingestjoni tieħu r-rotta tal-batch, it-tfittxija t-cache saħansitra l-embedding tal-mistoqsija—u dak l-aħħar punt mhuwiex banali, għax il-mistoqsijiet tal-utenti jirrepetu ruħhom ferm aktar milli taħseb.
class ProductionPipeline:
"""Pipeline RAG ottimizzata għall-produzzjoni."""
def __init__(self):
self.cache = EmbeddingCacheRedis()
self.robust_client = RobustEmbeddingClient()
def ingest(self, documents: list[dict]):
"""Ingestjoni b'cache u retry."""
texts = [d["text"] for d in documents]
embeddings = self.cache.get_embeddings_batch(texts)
# Aħżen fil-bażi tad-data tal-vetturi...
def search(self, query: str, k: int = 5):
"""Tfittxija b'caching tal-mistoqsija."""
query_emb = self.cache.get_embedding(query)
# Fittex fil-bażi tad-data tal-vetturi...
return query_emb
Lista ta’ Verifika tal-Produzzjoni
| Element | Deskrizzjoni |
|---|---|
| Redis Cache | Naqqas is-sejħat tal-API u l-latency |
| Exponential Retry | Immaniġġja l-limiti tar-rata b’mod grazzjuż |
| Monitoring | Traċċa r-rata ta’ suċċess tal-cache, il-latency, l-iżbalji |
| Batch Processing | Ipproċessa volumi kbar f’batches asinkroni |
| Quantization | Naqqas il-ħażna b’4 darbiet b’int8 |
| Tnaqqis tad-Dimensjoni | Uża 1024 jew 512 dim jekk il-kwalità tippermetti |
| Backup | Agħmel backup regolari tal-embeddings u l-metadejta |
| Alerting | Avża dwar żbalji tal-API u deterjorament tal-prestazzjoni |
Żewġ linji f’din it-tabella ma jipproduċu l-ebda gwadan fil-prestazzjoni iżda huma l-aktar importanti. Il-monitoraġġ tar-rata ta’ suċċess tal-cache (cache hit rate) huwa l-indikatur tas-saħħa ekonomika tiegħek: jekk tiġġarraf, il-kont tiegħek jittrejjeb qabel ma xi ħadd jinnota. U l-backup tal-embeddings isalvalek, fil-jum ta’ inċident, milli jkollok tħallas mill-ġdid u terġa’ tistenna għall-kodifika sħiħa tal-corpus.
Punti Ewlenin
- Il-cache Redis inaqqas l-ispejjeż u l-latency b’aktar minn 90%
- Ir-retry esponenzjali jimmaniġġja l-limiti tar-rata ta’ OpenAI
- L-ipproċessar asinkronu jħaffef l-ingestjoni ta’ corpora kbar
- Il-kwantizzazzjoni int8 tnaqqas il-ħażna b’4 darbiet
- It-tnaqqis tad-dimensjoni fl-API huwa l-aktar lever sempliċi
Ittestja l-Għarfien Tiegħek
Għoxrin u żewġ lezzjonijiet dwar embeddings u RAG: l-essenzjali joqogħdu f’ħames mistoqsijiet.
1. X'jaqbad embedding, u kif inqabblu żewġ testi?
Tweġiba: Vettur li jikkodifika t-tifsira: żewġ testi qrib fit-tifsira għandhom vetturi qrib—cosine similarity tkejjel din il-prossimità, irrispettivament mill-kliem eżatt użat.
2. Għaliex tgħaqqad it-tfittxija semantika u lessikali?
Tweġiba: Is-semantika tifhem ir-riformulazzjonijiet iżda titlef termini eżatti (referenzi, identifikaturi); il-lessikali jagħmel l-oppost—l-ibridu jkopri ż-żewġ punti għomja u jgħaqqad bir-rank.
3. X'inhu r-rwol tal-chunking fil-kwalità tar-RAG?
Tweġiba: Deċiżiv: segmenti li jirrispettaw il-fruntieri tal-ideat jipproduċu tfittxija preċiża; qtugħ arbitrarju jiġġenera frammenti mhux kompluti—u l-pipeline kollha tirrita dan.
4. Tfittxija tal-Fajls Integrata jew RAG custom: kif tagħżel?
Tweġiba: Tfittxija tal-Fajls biex timxi malajr b’pipeline ġestita (chunking u ranking integrati); RAG custom meta jkollok bżonn tikkontrolla s-splitting, l-indiċijiet, ir-reranking, jew sorsi multipli.
5. Lil hinn mit-tfittxija, semmi żewġ użi għall-embeddings.
Tweġiba: Klassifikazzjoni u clustering (raggruppament awtomatiku ta’ testi simili), rakkomandazzjonijiet personalizzati, jew detezzjoni ta’ anomaliji u duplikati—l-istess vettur, distanzi differenti.
Il-fil tal-kors: it-tifsira ssir kejl—tfittxija, ranking, rakkomandazzjoni huma biss applikazzjonijiet. Il-produzzjoni (skalar, caching) tagħmel il-bqija.