Aqbeż għall-kontenut ewlieni
Malti— Agħżel lingwa
Menu

Produzzjoni: Skalar u Caching

Lezzjoni 22 / 22 Aġġornat 29 ta’ Lulju 2026 Zviluppatur
F'din il-paġna
  1. Għanijiet
  2. Sfidi tal-Produzzjoni
  3. Caching tal-Embeddings
  4. Immaniġġjar tal-Limiti tar-Rata
  5. Ipproċessar Asinkronu
  6. Ottimizzazzjoni tal-Ħażna
  7. Arkitettura tal-Produzzjoni
  8. Lista ta’ Verifika tal-Produzzjoni
  9. Punti Ewlenin
  10. Ittestja l-Għarfien Tiegħek

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

ElementDeskrizzjoni
Redis CacheNaqqas is-sejħat tal-API u l-latency
Exponential RetryImmaniġġja l-limiti tar-rata b’mod grazzjuż
MonitoringTraċċa r-rata ta’ suċċess tal-cache, il-latency, l-iżbalji
Batch ProcessingIpproċessa volumi kbar f’batches asinkroni
QuantizationNaqqas il-ħażna b’4 darbiet b’int8
Tnaqqis tad-DimensjoniUża 1024 jew 512 dim jekk il-kwalità tippermetti
BackupAgħmel backup regolari tal-embeddings u l-metadejta
AlertingAvż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.