Produkcia: Škálovanie a cachovanie
Na tejto strane
Ciele
- Optimalizovať výkon systému vkladania (embedding) v produkčnom prostredí
- Implementovať cachovanie na zníženie nákladov a latencie
- Zvládnuť škálovanie a vysokú dostupnosť
Výzvy v produkčnom prostredí
Počas vývoja nie je volanie OpenAI API pre každú požiadavku problémom: možno urobíš desať volaní denne. V produkcii však ten istý kód narazí naraz na tri steny. Po prvé, náklady: každé volanie sa fakturuje a úplné preindexovanie korpusu sa zaplatí v plnej výške zakaždým, keď sa spustí. Po druhé, latencia: sieťová odozva 100 až 300 ms na požiadavku sa pripočíta k času vyhľadávania aj generovania a používateľ cíti súčet všetkých troch zložiek. Nakoniec, obmedzenia rýchlosti (rate limits): OpenAI obmedzuje počet volaní za minútu – limit, ktorý vo vývoji nikdy neuvidíš, no na deň spustenia do neho narazíš.
Všetky tri problémy majú v podstate rovnaké riešenie: nevolaj API, keď to nie je potrebné.
Cachovanie vektorových reprezentácií (Embeddings)
Vektorová reprezentácia je deterministická: rovnaký text s rovnakým modelom vždy vráti rovnaký vektor. Vďaka tomu je tu cachovanie vysoko efektívne, oveľa viac než pri generatívnych LLM. Pre aplikáciu so strednou premávkou stačí dekorátor lru_cache zo štandardnej knižnice a zaberie len dva riadky. Návratová hodnota sa konvertuje na tuple, pretože lru_cache vyžaduje hashovateľné hodnoty; to je jediná záludnosť, ktorú treba poznať.
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 pre vektorové reprezentácie (tuple, pretože je hashovateľné)."""
response = client.embeddings.create(input=text, model=model)
return tuple(response.data[0].embedding)
# Použitie - 2. volanie je okamžité
emb1 = embedding_cache("Hello world") # Volanie API
emb2 = embedding_cache("Hello world") # Z cache
Táto cache zmizne pri akomkoľvek reštarte a nie je zdieľaná medzi procesmi: akonáhle spustíš dve inštancie za load balancerom, každá si znovu vytvorí svoju vlastnú. Redis rieši oba problémy. Kľúčom je hash dvojice model-text, čo zabraňuje tomu, aby zmena modelu servírovala staré vektory, a TTL tridsať dní obmedzuje rast úložiska.
Metóda get_embeddings_batch si zaslúži osobitnú pozornosť, pretože práve ona robí rozdiel počas ingestie. Nekontroluje cache text po texte: oddelí chýbajúce položky (misses), odošle ich v jednom volaní API a následne vloží každý výsledok späť na jeho pôvodné miesto pomocou indices_a_calculer. Pri dávke tisíca dokumentov, kde je deväťsto už známych, prejdeš z jedného volania na dokument na jediné volanie pre zostávajúcich 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 dní
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)
# Kontrola cache
cached = self.redis.get(key)
if cached:
return json.loads(cached)
# Generovanie a cachovanie
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]]:
"""Dávka s čiastočným cachovaním."""
results = [None] * len(texts)
to_calculate = []
indices_to_calculate = []
# Kontrola cache pre každý text
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)
# Výpočet chýbajúcich v jednom volaní
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)} zásahov")
return results
# Použitie
cache = EmbeddingCacheRedis()
emb = cache.get_embedding("cache test")
Zvládanie obmedzení rýchlosti (Rate Limits)
Cachovanie znižuje premávku, ale neodstraňuje ju úplne a špička v premávke nakoniec vyvolá chybu RateLimitError. Správnou odpoveďou nie je okamžitý opakovaný pokus – čo by prehĺbilo preťaženie – ale čakanie s dvojnásobným oneskorením pri každom pokuse: jedna sekunda, dve, štyri, osem, šestnásť. Päť pokusov tak pokryje približne tridsať sekúnd, čo absorbuje veľkú väčšinu dočasných špičiek, a posledný pokus znova vyhodí výnimku, aby bol incident nahlásený namiesto tichého potlačenia.
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
):
"""Volanie s exponenciálnym opakovaním."""
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"Narazené na limit rýchlosti, pauza na {wait}s...")
time.sleep(wait)
Asynchrónne spracovanie
Pre ingestné pipeline nie je úzkym hrdlom výpočet, ale čakanie na sieť: tvoj program trávi väčšinu času nečinnosťou. Asynchrónne spracovanie ti umožňuje udržiavať viacero požiadaviek súčasne vo vzduchu. Semafór zámerne obmedzuje tento paralelizmus, pretože spustenie sto súčasných volaní len vyvolá obmedzenia rýchlosti, ktoré si sa práve naučil zvládať – tri až päť súbežných požiadaviek je zdravé nastavenie. Texty sa najprv rozdelia na dávky po sto kusoch a počiatočný index každej dávky cestuje spolu s úlohou, aby ich as_completed, ktoré vracia výsledky mimo poradia, mohlo stále správne umiestniť.
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]]:
"""Generovanie vektorových reprezentácií paralelne so semaforom."""
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)
]
# Rozdelenie na dávky 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
# Použitie
embeddings = asyncio.run(
generate_embeddings_async(my_texts, max_concurrent=3)
)
Optimalizácia úložiska
Potom je tu faktúra za infraštruktúru. Desaťtisíc vektorov s 3 072 rozmermi vo formáte float32 zaberá približne 122 MB; milión zaberá dvanásť gigabajtov, ktoré musia byť držané v pamäti, aby zostalo vyhľadávanie rýchle. Kvantovanie na int8 mapuje každú súradnicu na 256 celočíselných hodnôt, čím sa footprint v nižšie uvedenom príklade zmenší štvornásobne na približne 30 MB. Strata presnosti existuje, ale zostáva marginálna v porovnaní s rozdielmi podobnosti, s ktorými pracuješ.
import numpy as np
def quantize_int8(embeddings: np.ndarray) -> tuple:
"""Kvantovanie vektorových reprezentácií na int8 (4x menej pamäte)."""
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):
"""Obnovenie vektorových reprezentácií z int8."""
return quantized.astype(np.float32) * scale + min_val
# Porovnanie veľkosti
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
Najjednoduchšou pákou však zostáva parameter dimensions v API, ktorý produkuje kratšie vektory priamo bez akéhokoľvek post-spracovania z tvojej strany: 3 072 rozmerov váži približne 24 KB na vektor, 1 024 rozmerov klesá na 8 KB a 256 rozmerov na 2 KB.
# 3072 dim -> ~24 KB na vektor
# 1024 dim -> ~8 KB na vektor (redukcia API)
# 256 dim -> ~2 KB na vektor (redukcia API)
response = client.embeddings.create(
input="text",
model="text-embedding-3-large",
dimensions=1024 # 3x menej úložiska
)
Produkčná architektúra
Poskladané dávajú tieto časti štíhlu pipeline: Redis cache vpredu, robustný klient pre volania, ktoré sa aj tak prebijú. Ingestia využíva cestu cez dávky, vyhľadávanie cachuje dokonca aj vektor dotazu – a tento posledný bod nie je triviálny, pretože používateľské dotazy sa opakujú častejšie, než by si čakal.
class ProductionPipeline:
"""RAG pipeline optimalizovaná pre produkciu."""
def __init__(self):
self.cache = EmbeddingCacheRedis()
self.robust_client = RobustEmbeddingClient()
def ingest(self, documents: list[dict]):
"""Ingestia s cachovaním a opakovaním pokusov."""
texts = [d["text"] for d in documents]
embeddings = self.cache.get_embeddings_batch(texts)
# Uloženie do vektorovej databázy...
def search(self, query: str, k: int = 5):
"""Vyhľadávanie s cachovaním dotazov."""
query_emb = self.cache.get_embedding(query)
# Vyhľadávanie vo vektorovej databáze...
return query_emb
Kontrolný zoznam pre produkciu
| Prvok | Popis |
|---|---|
| Redis Cache | Zníženie volaní API a latencie |
| Exponenciálne opakovanie | Graceful zvládanie obmedzení rýchlosti |
| Monitorovanie | Sledovanie miery zásahov cache, latencie, chýb |
| Dávkové spracovanie | Spracovanie veľkých objemov v asynchrónnych dávkach |
| Kvantovanie | Zníženie úložiska 4x pomocou int8 |
| Redukcia rozmerov | Použitie 1024 alebo 512 rozmerov, ak to kvalita dovoľuje |
| Zálohovanie | Pravidelné zálohovanie vektorových reprezentácií a metadát |
| Alerting | Upozornenia na chyby API a zhoršenie výkonu |
Dva riadky v tejto tabuľke neprinášajú žiadny výkonový zisk, no sú najdôležitejšie. Monitorovanie miery zásahov cache je tvojím ukazovateľom ekonomického zdravia: ak sa zrúti, tvoja faktúra sa strojnásobí skôr, než si to niekto všimne. A zálohovanie vektorových reprezentácií ťa zachráni v deň incidentu pred tým, aby si musel znova zaplatiť a čakať na úplné zakódovanie celého korpusu.
Kľúčové poznatky
- Redis cache znižuje náklady a latenciu o viac ako 90 %
- Exponenciálne opakovanie zvláda obmedzenia rýchlosti OpenAI
- Asynchrónne spracovanie urýchľuje ingestiu veľkých korpusov
- Kvantovanie int8 znižuje úložisko 4x
- Redukcia rozmerov priamo v API je najjednoduchšia páka
Otestuj si svoje vedomosti
Dvadsaťdva lekcií o vektorových reprezentáciách a RAG: to podstatné sa zmestí do piatich otázok.
1. Čo zachytáva vektorová reprezentácia (embedding) a ako porovnávame dva texty?
Odpoveď: Vektor, ktorý kóduje význam: dva texty s blízkym významom majú blízke vektory – kosínusová podobnosť meria túto blízkosť bez ohľadu na presne použité slová.
2. Prečo kombinovať sémantické a lexikálne vyhľadávanie?
Odpoveď: Sémantické rozumie preformulovaniam, ale míňa presné termíny (odkazy, identifikátory); lexikálne robí opak – hybrid pokrýva obe slepé miesta a spája ich podľa poradia.
3. Aká je úloha chunkingu (rozdeľovania) v kvalite RAG?
Odpoveď: Rozhodujúca: segmenty, ktoré rešpektujú hranice myšlienok, produkujú presné vyhľadávanie; ľubovoľné rezy generujú neúplné fragmenty – a celá pipeline dedí túto chybu.
4 Integrované vyhľadávanie súborov alebo vlastný RAG: ako si vybrať?
Odpoveď: Vyhľadávanie súborov na rýchly štart so spravovanou pipeline (integrovaný chunking a ranking); vlastný RAG, keď potrebuješ kontrolovať rozdelenie, indexy, preradenie (reranking) alebo viacero zdrojov.
5. Okrem vyhľadávania vymenuj dve využitia vektorových reprezentácií.
Odpoveď: Klasifikácia a zhlukovanie (automatické zoskupovanie podobných textov), personalizované odporúčania alebo detekcia anomálií a duplikátov – rovnaký vektor, rôzne vzdialenosti.
Vlákno kurzu: význam sa stáva merateľným – vyhľadávanie, ranking, odporúčania sú len aplikácie. Produkcia (škálovanie, cachovanie) robí zvyšok.