Produkcija: Skaliranje in predpomnenje
Na tej strani
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
| Element | Opis |
|---|---|
| Predpomnilnik Redis | Zmanjšaj klice API-ja in zakasnitev |
| Eksponentno ponavljanje | Gladko obvladuj omejitve hitrosti |
| Spremljanje | Sledi stopnji zadetkov predpomnilnika, zakasnitvi, napakam |
| Serijsko obdelovanje | Obdeluj velike količine v asinhronih serijah |
| Kvantizacija | Zmanjšaj shrambo za 4x z int8 |
| Zmanjšanje dimenzij | Uporabi 1024 ali 512 dimenzij, če kakovost dopušča |
| Varnostna kopija | Redno varnostno kopiraj vdelave in metapodatke |
| Obveščanje | Opozori 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.