Produktion: Skalering og Caching
På denne side
Mål
- Optimér ydeevnen for et embedding-system i produktion
- Implementér caching for at reducere omkostninger og ventetid
- Håndtér skalering og høj tilgængelighed
Udfordringer i produktionen
Under udviklingen er det ikke et problem at kalde OpenAI API’en for hver anmodning: du laver måske ti kald om dagen. I produktionen rammer den samme kode tre vægge samtidigt. For det første omkostninger: hvert kald faktureres, og en fuld genindeksering af et korpus betales fuldt ud hver gang det kører. For det andet ventetid: en netværksrundtur på 100 til 300 ms pr. anmodning lægges til søgetid og genereringstid, og brugeren mærker summen af alle tre. Endelig rate limits: OpenAI begrænser antallet af kald pr. minut – en grænse, du aldrig ser under udvikling, men som du rammer på lanceringsdagen.
Alle tre problemer har stort set samme løsning: undgå at kalde API’en, når det ikke er nødvendigt.
Caching af embeddings
En embedding er deterministisk: den samme tekst med den samme model returnerer altid den samme vektor. Det gør caching yderst effektivt her, langt mere end for en generativ LLM. Til en applikation med moderat trafik er standardbibliotekets lru_cache-decorator tilstrækkelig og kræver kun to linjer. Returværdien konverteres til en tuple, fordi lru_cache kræver hashbare værdier; det er den eneste lille detalje, du skal kende.
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 for embeddings (tuple because it's hashable)."""
response = client.embeddings.create(input=text, model=model)
return tuple(response.data[0].embedding)
# Usage - the 2nd call is instant
emb1 = embedding_cache("Hello world") # API call
emb2 = embedding_cache("Hello world") # From cache
Denne cache forsvinder ved enhver genstart og deles ikke på tværs af processer: så snart du kører to instanser bag en load balancer, genopbygger hver sin egen. Redis løser begge problemer. Nøglen er et hash af model-tekst-parret, hvilket forhindrer, at en modelændring serverer gamle vektorer, og en TTL på tredive dage begrænser lagringsvæksten.
Metoden get_embeddings_batch fortjener særlig opmærksomhed, da det er den, der gør forskellen under indlæsning. Den tjekker ikke bare cachen tekst for tekst: den separerer de, der ikke findes i cachen (misses), sender dem i et enkelt API-kald og indsætter derefter hvert resultat på dets oprindelige plads ved hjælp af indices_a_calculer. På en batch på tusind dokumenter, hvor ni hundrede allerede er kendt, går du fra ét kald pr. dokument til et enkelt kald for de resterende hundrede.
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 days
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)
# Check cache
cached = self.redis.get(key)
if cached:
return json.loads(cached)
# Generate and 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 with partial caching."""
results = [None] * len(texts)
to_calculate = []
indices_to_calculate = []
# Check cache for each 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)
# Calculate misses in a single call
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
# Usage
cache = EmbeddingCacheRedis()
emb = cache.get_embedding("cache test")
Håndtering af rate limits
Caching reducerer trafikken, men eliminerer den ikke, og en trafikspids vil før eller siden udløse en RateLimitError. Det korrekte svar er ikke at forsøge med det samme – hvilket kun forværrer overbelastningen – men at vente og fordoble ventetiden hver gang: ét sekund, to, fire, otte, seksten. Fem forsøg dækker dermed cirka tredive sekunder, hvilket absorberer langt de fleste midlertidige spidser, og det sidste forsøg gen-kaster undtagelsen, så hændelsen rapporteres i stedet for at blive slugt i stilhed.
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
):
"""Call with exponential retry."""
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"Rate limit hit, pausing for {wait}s...")
time.sleep(wait)
Asynkron behandling
For indlæsningspipelines er flaskehalsen ikke beregning, men netværksventetid: dit program bruger det meste af sin tid på at gøre ingenting. Asynkron behandling lader dig holde flere anmodninger i luften samtidig. Semaphoren begrænser bevidst denne parallelisme, fordi lancering af hundrede samtidige kald kun udløser de rate limits, du lige har lært at håndtere – tre til fem samtidige anmodninger er en sund indstilling. Tekster opdeles først i batches på hundrede, og startindekset for hver batch rejser med opgaven, så as_completed, der returnerer resultater i vilkårlig rækkefølge, stadig kan placere dem korrekt.
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]]:
"""Generate embeddings in parallel with a 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)
]
# Split into batches of 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
# Usage
embeddings = asyncio.run(
generate_embeddings_async(my_texts, max_concurrent=3)
)
Optimering af lagring
Så er der infrastrukturens regning. Ti tusind vektorer med 3.072 dimensioner i float32 optager cirka 122 MB; en million optager tolv gigabyte, som skal holdes i hukommelsen, for at søgningen forbliver hurtig. Kvantificering til int8 mapper hver koordinat til 256 heltalsværdier, hvilket dividerer footprintet med fire til omkring 30 MB i eksemplet nedenfor. Præcisionstabet eksisterer, men forbliver marginalt sammenlignet med de ligheds-gab, du arbejder med.
import numpy as np
def quantize_int8(embeddings: np.ndarray) -> tuple:
"""Quantize embeddings to int8 (4x less memory)."""
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):
"""Restore embeddings from int8."""
return quantized.astype(np.float32) * scale + min_val
# Size comparison
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
Den enkleste løftestang er dog stadig API’ens parameter dimensions, som producerer kortere vektorer direkte uden nogen efterbehandling fra din side: 3.072 dimensioner vejer cirka 24 KB pr. vektor, 1.024 dimensioner falder til 8 KB, og 256 dimensioner til 2 KB.
# 3072 dim -> ~24 KB per vector
# 1024 dim -> ~8 KB per vector (API reduction)
# 256 dim -> ~2 KB per vector (API reduction)
response = client.embeddings.create(
input="text",
model="text-embedding-3-large",
dimensions=1024 # 3x less storage
)
Produktionsarkitektur
Samlet giver disse dele en slank pipeline: Redis-cache foran, robust klient til de kald, der alligevel slipper igennem. Indlæsning tager batch-ruten, søgning cachér selv query-embeddinget – og det sidste punkt er ikke trivielt, fordi brugerforespørgsler gentages langt oftere, end du tror.
class ProductionPipeline:
"""RAG pipeline optimized for production."""
def __init__(self):
self.cache = EmbeddingCacheRedis()
self.robust_client = RobustEmbeddingClient()
def ingest(self, documents: list[dict]):
"""Ingestion with cache and retry."""
texts = [d["text"] for d in documents]
embeddings = self.cache.get_embeddings_batch(texts)
# Store in vector database...
def search(self, query: str, k: int = 5):
"""Search with query caching."""
query_emb = self.cache.get_embedding(query)
# Search in vector database...
return query_emb
Produktions-checkliste
| Element | Beskrivelse |
|---|---|
| Redis Cache | Reducér API-kald og ventetid |
| Eksponentiel genforsøg | Håndtér rate limits gnidningsfrit |
| Overvågning | Spor cache-hit-rate, ventetid og fejl |
| Batch-behandling | Behandle store mængder i asynkrone batches |
| Kvantificering | Reducér lagring med 4x ved hjælp af int8 |
| Dimensionsreduktion | Brug 1024 eller 512 dims, hvis kvaliteten tillader det |
| Backup | Tag regelmæssigt backup af embeddings og metadata |
| Alarmering | Giv alarm ved API-fejl og ydeevneforringelse |
To linjer i denne tabel giver ingen ydeevnegevinst, men er de vigtigste. Overvågning af cache-hit-raten er din økonomiske sundhedsindikator: hvis den kollapser, tredobles din regning, før nogen lægger mærke til det. Og backup af embeddings redder dig på dagen for en hændelse fra at skulle betale og gen-vente på den fulde kodning af korpussen.
Opsummering
- Redis-cache reducerer omkostninger og ventetid med over 90 %
- Eksponentiel genforsøg håndterer OpenAI rate limits
- Asynkron behandling fremskynder indlæsning af store korpusser
- int8-kvantificering reducerer lagring med 4x
- Dimensionsreduktion direkte i API’en er den enkleste løftestang
Test din viden
Toogtyve lektioner om embeddings og RAG: essensen passer i fem spørgsmål.
1. Hvad fanger en embedding, og hvordan sammenligner vi to tekster?
Svar: En vektor, der kodifierer betydning: to tekster tæt på hinanden i betydning har tætte vektorer – cosinus-lished måler denne nærhed uanset de præcise ord, der bruges.
2. Hvorfor kombinere semantisk og leksikalsk søgning?
Svar: Semantisk forståelse håndterer omformuleringer, men savner eksakte termer (referencer, identifikatorer); leksikalsk gør det modsatte – den hybride dækker begge blinde vinkler og fletter efter rang.
3. Hvad er rollen for chunking i RAG-kvalitet?
Svar: Afgørende: segmenter, der respekterer idégrænser, producerer præcis søgning; vilkårlige snit genererer ufuldstændige fragmenter – og hele pipelinen arver dette.
4. Integreret filsøgning eller brugerdefineret RAG: hvordan vælger du?
Svar: Filsøgning for at komme hurtigt i gang med en administreret pipeline (integreret chunking og rangering); brugerdefineret RAG, når du skal kontrollere opsplitning, indeks, om-rangering eller flere kilder.
5. Udover søgning, nævn to anvendelser for embeddings.
Svar: Klassificering og klyngedannelse (automatisk gruppering af lignende tekster), personlige anbefalinger eller detektering af anomalier og dubletter – samme vektor, forskellige afstande.
Kursusets røde tråd: betydning bliver målelig – søgning, rangering, anbefaling er blot anvendelser. Produktion (skalering, caching) gør resten.