Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Produkcija: Skaliranje in predpomnenje

Lekcija 22 od 22 Posodobljeno 29. julij 2026 Razvijalec
Na tej strani
  1. Cilji
  2. Izzivi v produkcijskem okolju
  3. Predpomnenje vdelav (Embeddings)
  4. Obvladovanje omejitev hitrosti
  5. Asinhrono obdelovanje
  6. Optimizacija shrambe
  7. Produkcijska arhitektura
  8. Kontrolni seznam za produkcijo
  9. Ključne ugotovitve
  10. Preveri svoje znanje

Cilji

  • Optimiziraj zmogljivost sistema za vdelave (embeddings) v produkcijskem okolju
  • Implementiraj predpomnenje za zmanjšanje stroškov in zakasnitve
  • Upravljaj skaliranje in visoko razpoložljivost

Izzivi v produkcijskem okolju

Med razvojem klicanje API-ja OpenAI za vsako zahtevo ni problem: morda narediš deset klicev na dan. V produkciji ista koda hkrati trči v tri zidove. Prvič, stroški: vsak klic se zaračuna in popolno ponovno indeksiranje korpusa se vsakič v celoti plača, ko se zažene. Drugič, zakasnitev: omrežni povratni čas od 100 do 300 ms na zahtevo se doda času iskanja in času generiranja, uporabnik pa čuti vsoto vseh treh. Nazadnje, omejitve hitrosti (rate limits): OpenAI omejuje število klicev na minuto – omejitev, ki je v razvoju nikoli ne boš videl, a jo boš dosegel na dan zagona.

Vse tri težave imajo večinoma isto rešitev: ne kliči API-ja, kadar to ni potrebno.

Predpomnenje vdelav (Embeddings)

Vdelava je deterministična: isto besedilo z istim modelom vedno vrne isti vektor. To omogoča izjemno učinkovito predpomnenje, veliko bolj kot pri generativnem LLM. Za aplikacijo z zmernim prometom je okrasnik lru_cache iz standardne knjižnice zadosten in zahteva le dve vrstici. Vrnjena vrednost se pretvori v nabor (tuple), ker lru_cache zahteva vrednosti, ki jih je mogoče razpršiti (hashable); to je edina posebnost, ki jo moraš poznati.

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 predpomnilnik za vdelave (nabor, ker je hashable)."""
    response = client.embeddings.create(input=text, model=model)
    return tuple(response.data[0].embedding)

# Uporaba - drugi klic je takojšen
emb1 = embedding_cache("Hello world")  # Klic API-ja
emb2 = embedding_cache("Hello world")  # Iz predpomnilnika

Ta predpomnilnik izgine ob vsakem ponovnem zagonu in ni deljen med procesi: takoj ko zaženeš dva primerka za balancerjem obremenitve, vsak znova zgradi svojega. Redis reši oba problema. Ključ je razpršilo (hash) para model-besedilo, kar preprečuje, da bi sprememba modela vračala stare vektorje, in 30-dnevni TTL omejuje rast shrambe.

Metoda get_embeddings_batch si zasluži posebno pozornost, saj je tista, ki naredi razliko med ingestijo. Ne preverja le predpomnilnika besedilo za besedilom: loči zgrešene vnose (misses), jih pošlje v enem samem klicu API-ja, nato pa vsak rezultat znova vstavi na njegov prvotni položaj z uporabo indices_a_calculer. Pri seriji tisoč dokumentov, kjer je devetsto že znanih, greš z enim klicem na dokument na en sam klic za preostalih sto.

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 dni

    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)

        # Preveri predpomnilnik
        cached = self.redis.get(key)
        if cached:
            return json.loads(cached)

        # Generiraj in predpomni
        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]]:
        """Serija z delnim predpomnenjem."""
        results = [None] * len(texts)
        to_calculate = []
        indices_to_calculate = []

        # Preveri predpomnilnik za vsako besedilo
        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)

        # Izračunaj zgrešene vnose v enem klicu
        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"Predpomnilnik: {len(texts) - len(to_calculate)}/{len(texts)} zadetkov")
        return results

# Uporaba
cache = EmbeddingCacheRedis()
emb = cache.get_embedding("cache test")

Obvladovanje omejitev hitrosti

Predpomnenje zmanjša promet, a ga ne odpravi popolnoma, in konica prometa bo sčasoma sprožila RateLimitError. Pravilen odziv ni takojšen ponovni poskus – kar poslabša zastoje – ampak čakanje z vsakič podvojenim zamikom: ena sekunda, dve, štiri, osem, šestnajst. Pet poskusov tako pokrije približno trideset sekund, kar absorbira veliko večino začasnih konic, končni poskus pa ponovno sproži izjemo, da se incident zabeleži namesto tihega požiranja.

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
    ):
        """Klic z eksponentnim ponavljanjem."""
        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"Dosežena omejitev hitrosti, premor za {wait}s...")
                time.sleep(wait)

Asinhrono obdelovanje

Pri cevovodih za ingestijo ozko grlo ni računanje, ampak čakanje na omrežje: tvoj program večino časa ne dela ničesar. Asinhrono obdelovanje ti omogoča, da imaš več zahtev hkrati v teku. Semaforna zapora namerno omejuje to vzporednost, ker zagon sto hkratnih klicev le sproži omejitve hitrosti, ki si se jih pravkar naučil obvladovati – tri do pet sočasnih zahtev je zdrava nastavitev. Besedila se najprej razdelijo na serije po sto, začetni indeks vsake serije pa potuje z nalogo, tako da lahko as_completed, ki vrača rezultate izven vrstnega reda, vseeno pravilno postavi rezultate.

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]]:
    """Generiraj vdelave vzporedno s semaforno zaporo."""
    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)
            ]

    # Razdeli na serije po 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

# Uporaba
embeddings = asyncio.run(
    generate_embeddings_async(my_texts, max_concurrent=3)
)

Optimizacija shrambe

Tu je še račun za infrastrukturo. Deset tisoč vektorjev z 3.072 dimenzijami v formatu float32 zavzame približno 122 MB; milijon jih zavzame dvanajst gigabajtov, ki jih je treba držati v pomnilniku, da ostane iskanje hitro. Kvantizacija na int8 preslika vsako koordinato na 256 celoštevilske vrednosti, kar v spodnjem primeru zmanjša odtis štirikrat na približno 30 MB. Izguba natančnosti obstaja, a ostaja robna v primerjavi z razlikami v podobnosti, s katerimi delaš.

import numpy as np

def quantize_int8(embeddings: np.ndarray) -> tuple:
    """Kvantiziraj vdelave na int8 (4x manj pomnilnika)."""
    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):
    """Obnovi vdelave iz int8."""
    return quantized.astype(np.float32) * scale + min_val

# Primerjava velikosti
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

Vendar pa ostaja najpreprostejša vzvod parameter dimensions v API-ju, ki proizvaja krajše vektorje neposredno brez kakršne koli naknadne obdelave na tvoji strani: 3.072 dimenzij tehta približno 24 KB na vektor, 1.024 dimenzij pade na 8 KB in 256 dimenzij na 2 KB.

# 3072 dim -> ~24 KB na vektor
# 1024 dim -> ~8 KB na vektor  (zmanjšanje preko API-ja)
# 256 dim  -> ~2 KB na vektor  (zmanjšanje preko API-ja)

response = client.embeddings.create(
    input="text",
    model="text-embedding-3-large",
    dimensions=1024  # 3x manj shrambe
)

Produkcijska arhitektura

Sestavljeni ti deli dajejo vitak cevovod: predpomnilnik Redis spredaj, robusten odjemalec za klice, ki vseeno pridejo skozi. Ingestija uporablja pot serij, iskanje pa predpomni celo vdelavo poizvedbe – in ta zadnja točka ni trivialna, ker se uporabniške poizvedbe ponavljajo veliko pogosteje, kot si misliš.

class ProductionPipeline:
    """Cevovod RAG, optimiziran za produkcijo."""

    def __init__(self):
        self.cache = EmbeddingCacheRedis()
        self.robust_client = RobustEmbeddingClient()

    def ingest(self, documents: list[dict]):
        """Ingestija s predpomnilnikom in ponavljanjem."""
        texts = [d["text"] for d in documents]
        embeddings = self.cache.get_embeddings_batch(texts)
        # Shrani v vektorsko bazo podatkov...

    def search(self, query: str, k: int = 5):
        """Iskanje s predpomnenjem poizvedb."""
        query_emb = self.cache.get_embedding(query)
        # Išči v vektorski bazi podatkov...
        return query_emb

Kontrolni seznam za produkcijo

ElementOpis
Predpomnilnik RedisZmanjšaj klice API-ja in zakasnitev
Eksponentno ponavljanjeGladko obvladuj omejitve hitrosti
SpremljanjeSledi stopnji zadetkov predpomnilnika, zakasnitvi, napakam
Serijsko obdelovanjeObdeluj velike količine v asinhronih serijah
KvantizacijaZmanjšaj shrambo za 4x z int8
Zmanjšanje dimenzijUporabi 1024 ali 512 dimenzij, če kakovost dopušča
Varnostna kopijaRedno varnostno kopiraj vdelave in metapodatke
ObveščanjeOpozori na napake API-ja in poslabšanje zmogljivosti

Dve vrstici v tej tabeli ne prinašata neposrednega dobička v zmogljivosti, vendar sta najpomembnejši. Spremljanje stopnje zadetkov predpomnilnika je tvoj kazalnik ekonomskega zdravja: če se zruši, se tvoj račun potroji, preden kdo kaj opazi. In varnostno kopiranje vdelav te reši, da ob incidentu ne bi moral znova plačati in čakati na popolno kodiranje celotnega korpusa.

Ključne ugotovitve

  • Predpomnilnik Redis zmanjša stroške in zakasnitev za več kot 90 %
  • Eksponentno ponavljanje obvlada omejitve hitrosti OpenAI
  • Asinhrono obdelovanje pospeši ingestijo velikih korpusov
  • Kvantizacija int8 zmanjša shrambo za 4x
  • Zmanjšanje dimenzij na ravni API-ja je najpreprostejši vzvod

Preveri svoje znanje

Dvaindvajset lekcij o vdelavah in RAG: bistvo se prilega v pet vprašanj.

1. Kaj zajame vdelava in kako primerjamo dve besedili?

Odgovor: Vektor, ki kodira pomen: dve besedili, ki sta si po pomenu blizu, imata blizu vektorja – kosinusna podobnost meri to bližino, ne glede na točne uporabljene besede.

2. Zakaj združiti semantično in leksikalno iskanje?

Odgovor: Semantično razume preoblikovanja, a zgreši točne izraze (reference, identifikatorje); leksikalno dela obratno – hibridno pokriva obe slepi točki in združuje po rangu.

3. Kakšna je vloga razčlenjevanja (chunking) pri kakovosti RAG?

Odgovor: Odločilna: segmenti, ki spoštujejo meje idej, proizvajajo natančno iskanje; poljubni rezi generirajo nepopolne fragmente – in celoten cevovod podeduje to.

4. Integrirano iskanje datotek ali prilagojen RAG: kako izbrati?

Odgovor: Iskanje datotek za hiter premik z upravljanim cevovodom (integrirano razčlenjevanje in rangiranje); prilagojen RAG, ko potrebuješ nadzor nad razcepom, indeksi, ponovnim rangiranjem ali več viri.

5. Poleg iskanja naštej dve uporabi vdelav.

Odgovor: Klasifikacija in gručenje (samodejno združevanje podobnih besedil), personalizirana priporočila ali zaznavanje anomalij in duplikatov – isti vektor, različne razdalje.

Rdeča nit tečaja: pomen postane merljiv – iskanje, rangiranje, priporočanje so le aplikacije. Produkcija (skaliranje, predpomnenje) naredi ostalo.