Produkce: Škálování a mezipaměť
Na této stránce
Cíle
- Optimalizovat výkon systému pro vnoření (embedding) v produkci
- Implementovat mezipaměť pro snížení nákladů a latence
- Zvládat škálování a vysokou dostupnost
Výzvy produkčního prostředí
Během vývoje není volání OpenAI API pro každý požadavev problém: možná provedeš deset volání denně. V produkci však tentýž kód narazí současně na tři zdi. Zaprvé, náklady: každé volání je zpoplatněno a úplné přeindexování korpusu se pokaždé zaplatí v plné výši. Zadruhé, latence: síťová cesta tam a zpět trvající 100 až 300 ms na požadavek se přičítá k času vyhledávání i generování a uživatel pocítí součet všech tří složek. Nakonec, omezení rychlosti (rate limits): OpenAI omezuje počet volání za minutu – limit, který ve vývoji nikdy neuvidíš, ale na který narazíš v den spuštění.
Všechny tři problémy mají z velké části stejné řešení: nevolej API, když to není nutné.
Ukládání vnoření do mezipaměti
Vnoření je deterministické: stejný text se stejným modelem vždy vrátí stejný vektor. To činí mezipaměť vysoce efektivní, mnohem více než u generativního LLM. Pro aplikaci se středním provozem stačí dekorátor lru_cache ze standardní knihovny a zabere jen dva řádky. Návratová hodnota se převede na n-tici (tuple), protože lru_cache vyžaduje hashovatelné hodnoty; to je jediná věc, na kterou si musíš dát pozor.
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 mezipaměť pro vnoření (n-tice, protože je hashovatelná)."""
response = client.embeddings.create(input=text, model=model)
return tuple(response.data[0].embedding)
# Použití - 2. volání je okamžité
emb1 = embedding_cache("Hello world") # Volání API
emb2 = embedding_cache("Hello world") # Z mezipaměti
Tato mezipaměť zmizí při jakémkoli restartu a není sdílena mezi procesy: jakmile spustíš dvě instance za zátěžovou vyvažovačkou (load balancer), každá si znovu vytvoří svou vlastní. Redis řeší oba problémy. Klíčem je hash dvojice model-text, což zabraňuje tomu, aby změna modelu obsluhovala staré vektory, a TTL třiceti dnů omezuje růst úložiště.
Metoda get_embeddings_batch si zaslouží velkou pozornost, protože právě ona dělá rozdíl během ingestace. Nejenže kontroluje mezipaměť text po textu: odděluje chybějící položky (misses), odešle je v jediném volání API a poté pomocí indices_a_calculer znovu vloží každý výsledek na jeho původní pozici. U dávky tisíce dokumentů, kde je devět set již známých, se dostaneš z jednoho volání na dokument k jedinému volání pro zbývajících 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 mezipaměti
cached = self.redis.get(key)
if cached:
return json.loads(cached)
# Generování a uložení do mezipaměti
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 částečným ukládáním do mezipaměti."""
results = [None] * len(texts)
to_calculate = []
indices_to_calculate = []
# Kontrola mezipaměti pro 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 chybějících v jediném volání
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"Mezipaměť: {len(texts) - len(to_calculate)}/{len(texts)} zásahů")
return results
# Použití
cache = EmbeddingCacheRedis()
emb = cache.get_embedding("cache test")
Zvládání omezení rychlosti (Rate Limits)
Mezipaměť snižuje provoz, ale neodstraňuje jej úplně a špička v provozu nakonec spustí chybu RateLimitError. Správnou reakcí není okamžitý opakovaný pokus – což by congestion jen zhoršilo – ale čekání s dvojnásobným prodlužováním prodlevy pokaždé: jedna sekunda, dvě, čtyři, osm, šestnáct. Pět pokusů tak pokryje asi třicet sekund, což pohltí drtivou většinu dočasných špiček, a poslední pokus znovu vyvolá výjimku, aby byl incident nahlášen, místo aby byl tiše polykán.
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
):
"""Volání s exponenciálním opakovaným pokusem."""
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"Naraženo na omezení rychlosti, pauza na {wait}s...")
time.sleep(wait)
Asynchronní zpracování
U ingestčních pipeline není úzkým hrdlem výpočet, ale čekání na síť: tvůj program tráví většinu času tím, že nic nedělá. Asynchronní zpracování ti umožňuje udržet více požadavků ve vzduchu současně. Semafor záměrně omezuje tento paralelismus, protože spuštění sta současných volání pouze spustí omezení rychlosti, která ses právě naučil řešit – tři až pět souběžných požadavků je zdravé nastavení. Texty se nejprve rozdělí do dávek po stu a počáteční index každé dávky cestuje spolu s úkolem, aby as_completed, který vrací výsledky mimo pořadí, mohl stále umístit výsledky správně.
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]]:
"""Generování vnoření paralelně se semaforem."""
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)
]
# Rozdělení do dávek 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žití
embeddings = asyncio.run(
generate_embeddings_async(my_texts, max_concurrent=3)
)
Optimalizace úložiště
Pak je tu faktura za infrastrukturu. Deset tisíc vektorů o 3 072 dimenzích ve formátu float32 zabere asi 122 MB; milion jich zabere dvanáct gigabajtů, které musí být drženy v paměti, aby vyhledávání zůstalo rychlé. Kvantování na int8 mapuje každou souřadnici na 256 celočíselných hodnot, čímž se footprint zmenší čtyřikrát, v níže uvedeném příkladu na zhruba 30 MB. Ztráta přesnosti existuje, ale zůstává marginální ve srovnání s rozdíly v podobnosti, se kterými pracuješ.
import numpy as np
def quantize_int8(embeddings: np.ndarray) -> tuple:
"""Kvantování vnoření na int8 (4x méně paměti)."""
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):
"""Obnovení vnoření z int8."""
return quantized.astype(np.float32) * scale + min_val
# Porovnání 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
Nejjednodušší pákou však zůstává parametr dimensions API, který produkuje kratší vektory přímo bez jakéhokoli následného zpracování z tvé strany: 3 072 dimenzí váží asi 24 KB na vektor, 1 024 dimenzí klesne na 8 KB a 256 dimenzí na 2 KB.
# 3072 dim -> ~24 KB na vektor
# 1024 dim -> ~8 KB na vektor (redukce API)
# 256 dim -> ~2 KB na vektor (redukce API)
response = client.embeddings.create(
input="text",
model="text-embedding-3-large",
dimensions=1024 # 3x méně úložiště
)
Produkční architektura
Tyto díly dohromady dávají štíhlou pipeline: mezipaměť Redis vpředu, robustní klient pro volání, která se přesto dostanou skrz. Ingestace využívá cestu dávek, vyhledávání ukládá do mezipaměti i vnoření dotazu – a tento poslední bod není triviální, protože uživatelské dotazy se opakují mnohem častěji, než bys čekal.
class ProductionPipeline:
"""RAG pipeline optimalizovaná pro produkci."""
def __init__(self):
self.cache = EmbeddingCacheRedis()
self.robust_client = RobustEmbeddingClient()
def ingest(self, documents: list[dict]):
"""Ingestace s mezipamětí a opakovanými pokusy."""
texts = [d["text"] for d in documents]
embeddings = self.cache.get_embeddings_batch(texts)
# Uložení do vektorové databáze...
def search(self, query: str, k: int = 5):
"""Vyhledávání s ukládáním dotazů do mezipaměti."""
query_emb = self.cache.get_embedding(query)
# Vyhledávání ve vektorové databázi...
return query_emb
Kontrolní seznam pro produkci
| Prvek | Popis |
|---|---|
| Mezipaměť Redis | Snížení volání API a latence |
| Exponenciální opakování | Graceful handling omezení rychlosti |
| Monitorování | Sledování míry zásahu mezipaměti, latence, chyb |
| Dávkové zpracování | Zpracování velkých objemů v asynchronních dávkách |
| Kvantování | Snížení úložiště 4x pomocí int8 |
| Redukce dimenzí | Použití 1024 nebo 512 dimenzí, pokud to kvalita dovolí |
| Zálohování | Pravidelné zálohování vnoření a metadat |
| Alerting | Upozornění na chyby API a zhoršení výkonu |
Dva řádky v této tabulce nepřinášejí žádný výkonový zisk, přesto jsou nejdůležitější. Monitorování míry zásahu mezipaměti (cache hit rate) je tvým ukazatelem ekonomického zdraví: pokud se zhroutí, tvůj účet se ztrojnásobí, než si toho někdo všimne. A zálohování vnoření tě zachrání v den incidentu před tím, abys musel znovu platit a čekat na úplné zakódování celého korpusu.
Klíčové poznatky
- Mezipaměť Redis snižuje náklady a latenci o více než 90 %
- Exponenciální opakování zvládá omezení rychlosti OpenAI
- Asynchronní zpracování zrychluje ingestaci velkých korpusů
- Kvantování int8 snižuje úložiště 4x
- Redukce dimenzí přímo v API je nejjednodušší pákou
Ověř si své znalosti
Dvacet dvě lekcí o vnoření a RAG: to podstatné se vejde do pěti otázek.
1. Co zachycuje vnoření a jak porovnáváme dva texty?
Odpověď: Vektor, který kóduje význam: dva texty blízké významem mají blízké vektory – kosinová podobnost měří tuto blízkost bez ohledu na přesně použitá slova.
2. Proč kombinovat sémantické a lexikální vyhledávání?
Odpověď: Sémantické rozumí přeformulováním, ale míjí přesné termíny (reference, identifikátory); lexikální dělá pravý opak – hybrid pokrývá obě slepá místa a slučuje podle pořadí.
3. Jaká je role chunkingu (rozdělování) pro kvalitu RAG?
Odpověď: Rozhodující: segmenty, které respektují hranice myšlenek, produkují přesné vyhledávání; libovolné řezy generují neúplné fragmenty – a celá pipeline toto dědí.
4. Integrované File Search nebo vlastní RAG: jak si vybrat?
Odpověď: File Search pro rychlý start se spravovanou pipeline (integrované chunking a ranking); vlastní RAG, když potřebuješ kontrolovat rozdělování, indexy, přerazování (reranking) nebo více zdrojů.
5. Jmenuj dvě využití vnoření kromě vyhledávání.
Odpověď: Klasifikace a shlukování (automatické seskupování podobných textů), personalizovaná doporučení nebo detekce anomálií a duplicit – stejný vektor, různé vzdálenosti.
Vlákno kurzu: význam se stává měřitelným – vyhledávání, ranking, doporučení jsou jen aplikace. Produkce (škálování, mezipaměť) dělá zbytek.