Tootmine: skaleerimine ja vahemällu salvestamine
Sellel lehel
Eesmärgid
- Optimeeri manustussüsteemi jõudlust tootmiskeskkonnas
- Rakenda vahemällu salvestamine kulude ja latentsuse vähendamiseks
- Halda skaleeritavust ja kõrget kättesaadavust
Tootmise väljakutsed
Arenduse käigus pole OpenAI API iga päringu jaoks kutsumine probleem: võid teha kümme väljakutset päevas. Tootmises põrkab sama kood korraga kolmele seinale. Esiteks kulud: iga väljakutse on tasuline ja korpuse täielik ümberindekseerimine makstakse iga kord täies ulatuses kinni. Teiseks latentsus: võrgu edasi-tagasi reis 100–300 ms päringu kohta liidetakse otsingu- ja genereerimisajale ning kasutaja tunneb kõigi kolme summat. Lõpuks kiiruse piirangud: OpenAI piirab väljakutsete arvu minutis – piirangut, mida arenduses kunagi ei näe, kuid tabad selle käivitamise päeval.
Kõigil kolmel probleemil on sisuliselt sama lahendus: ära kutsu API-t, kui see pole vajalik.
Manuste vahemällu salvestamine
Manus on deterministlik: sama tekst sama mudeliga annab alati sama vektori. See muudab vahemällu salvestamise siin äärmiselt tõhusaks, palju rohkem kui generatiivse LLM-i puhul. Mõõduka liiklusega rakenduse jaoks piisab standardteegi lru_cache dekoratsioonist, mis võtab vaid kaks rida. Tagastusväärtus teisendatakse tuple’iks, kuna lru_cache nõuab räsitavaid väärtusi; see on ainus nüanss, mida teada tuleb.
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 vahemälu manustele (tuple, kuna see on räsitav)."""
response = client.embeddings.create(input=text, model=model)
return tuple(response.data[0].embedding)
# Kasutus – 2. väljakutse on kohene
emb1 = embedding_cache("Hello world") # API väljakutse
emb2 = embedding_cache("Hello world") # Vahemälust
See vahemälu kaob iga taaskäivituse korral ega ole protsesside vahel jagatud: niipea kui käivitad kaks eksemplari koormusjaoturi taga, ehitab igaüks oma uuesti üles. Redis lahendab mõlemad probleemid. Võtmeks on mudeli ja teksti paari räsi, mis takistab mudeli muutmisel vanade vektorite serveerimist, ja kolmekümne päeva TTL piirab salvestusruumi kasvu.
Meetod get_embeddings_batch väärib tähelepanelikku uurimist, kuna just see teeb sisestamisel vahet. See ei kontrolli vahemälu teksti haaval: see eraldab puudujäägid, saadab need ühe API väljakutsena ja sisestab seejärel iga tulemuse indices_a_calculer abil oma algsele kohale tagasi. Tuhande dokumendi partiis, kus üheksasada on juba teada, lähed ühelt väljakutselt dokumendi kohta ühele väljakutsele ülejäänud saja jaoks.
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 päeva
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)
# Kontrolli vahemälu
cached = self.redis.get(key)
if cached:
return json.loads(cached)
# Genereeri ja salvesta vahemällu
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]]:
"""Partii osalise vahemällu salvestamisega."""
results = [None] * len(texts)
to_calculate = []
indices_to_calculate = []
# Kontrolli iga teksti vahemälu
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)
# Arvuta puudujäägid ühe väljakutsega
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"Vahemälu: {len(texts) - len(to_calculate)}/{len(texts)} tabamust")
return results
# Kasutus
cache = EmbeddingCacheRedis()
emb = cache.get_embedding("cache test")
Kiiruse piirangute haldamine
Vahemällu salvestamine vähendab liiklust, kuid ei kõrvalda seda täielikult ja liikluse tippkoormus käivitab varem või hiljem RateLimitError. Õige reaktsioon pole kohe uuesti proovida – see süvendab ummistust –, vaid oodata, kahekordistades iga kord viivitust: üks sekund, kaks, neli, kaheksa, kuusteist. Viis katet hõlmavad seega umbes kolmkümmend sekundit, mis neelab valdava osa ajutistest tippkoormustest, ja viimane katse viskab erandi uuesti, et intsident teatataks selle vaikiva neelamise asemel.
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
):
"""Kutsu eksponentsiaalse uuestiproovimisega."""
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"Kiiruse piirang tabatud, paus {wait}s...")
time.sleep(wait)
Asünkroonne töötlemine
Sisestamistorustike jaoks pole kitsaskoht arvutus, vaid võrgu ooteaeg: su programm veedab suurema osa ajast tegevusetuna. Asünkroonne töötlemine võimaldab hoida mitu päringut samaaegselt õhus. Semaphor piirab seda paralleelsust tahtlikult, sest saja samaaegse väljakutse käivitamine kutsub esile just need kiiruse piirangud, mida õppisid käsitlema – kolm kuni viis samaaegset päringut on tervislik seadistus. Tekstid jagatakse esmalt sadast koosnevateks partiideks ja iga partii algusindeks reisib ülesandega kaasa, et as_completed, mis tagastab tulemused väljaspool järjekorda, saaks need siiski õigesti paigutada.
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]]:
"""Genereeri manuseid paralleelselt semaphoriga."""
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)
]
# Jagada partiideks suurusega 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
# Kasutus
embeddings = asyncio.run(
generate_embeddings_async(my_texts, max_concurrent=3)
)
Salvestuse optimeerimine
Siis on veel infrastruktuuri arve. Kümme tuhat 3072 mõõtmega vektorit float32-formaadis hõivavad umbes 122 MB; miljon hõivab kaksteist gigabaiti, mis peab otsingu kiireks hoidmiseks olema mälus. Kvantimine int8-formaati kaardistab iga koordinaadi 256 täisarvväärtusele, jagades jalajälje neljaga umbes 30 MB-ni allpool toodud näites. Täpsuse kaotus on olemas, kuid jääb marginaalseks võrreldes sarnasuslünkadega, millega töötad.
import numpy as np
def quantize_int8(embeddings: np.ndarray) -> tuple:
"""Kvandi manused int8-formaati (4x vähem mälu)."""
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):
"""Taasta manused int8-formaadist."""
return quantized.astype(np.float32) * scale + min_val
# Suuruse võrdlus
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
Lihtsaim hoob on aga API parameeter dimensions, mis toodab lühemaid vektoreid otse ilma igasuguse järeltöötluseta: 3072 mõõdet kaaluvad vektori kohta umbes 24 KB, 1024 mõõdet langevad 8 KB-ni ja 256 mõõdet 2 KB-ni.
# 3072 mõõdet -> ~24 KB vektori kohta
# 1024 mõõdet -> ~8 KB vektori kohta (API vähendus)
# 256 mõõdet -> ~2 KB vektori kohta (API vähendus)
response = client.embeddings.create(
input="text",
model="text-embedding-3-large",
dimensions=1024 # 3x vähem salvestusruumi
)
Tootmise arhitektuur
Kokku panduna annavad need osad schlanki torustiku: Redis vahemälu ees, robustne klient väljakutsetele, mis ikka läbi pääsevad. Sisestamine kasutab partii teed, otsing vahemällu salvestab isegi päringu manuse – ja see viimane punkt pole triviaalne, sest kasutajate päringud korduvad palju sagedamini, kui arvata oskad.
class ProductionPipeline:
"""Tootmiseks optimeeritud RAG torustik."""
def __init__(self):
self.cache = EmbeddingCacheRedis()
self.robust_client = RobustEmbeddingClient()
def ingest(self, documents: list[dict]):
"""Sisestamine vahemälu ja uuestiproovimisega."""
texts = [d["text"] for d in documents]
embeddings = self.cache.get_embeddings_batch(texts)
# Salvesta vektorandmebaasi...
def search(self, query: str, k: int = 5):
"""Otsing päringu vahemällu salvestamisega."""
query_emb = self.cache.get_embedding(query)
# Otsi vektorandmebaasist...
return query_emb
Tootmise kontrollnimekiri
| Element | Kirjeldus |
|---|---|
| Redis vahemälu | Vähenda API väljakutseid ja latentsust |
| Eksponentsiaalne uuestiproovimine | Käitle kiiruse piiranguid sujuvalt |
| Monitooring | Jälgi vahemälu tabamuste määra, latentsust, vigu |
| Partii töötlemine | Töötle suuri mahte asünkroonsetes partiides |
| Kvantimine | Vähenda salvestusruumi 4x int8-ga |
| Mõõtmete vähendamine | Kasuta 1024 või 512 mõõdet, kui kvaliteet lubab |
| Varundamine | Varunda regulaarselt manuseid ja metaandmeid |
| Hoiatused | Teavita API vigadest ja jõudluse halvenemisest |
Selles tabelis on kaks rida, mis ei too kaasa jõudluse kasvu, kuid on kõige olulisemad. Vahemälu tabamuste määra monitooring on sinu majandusliku tervise näitaja: kui see kokku variseb, kolmekordistub su arve enne, kui keegi seda märkab. Ja manuste varundamine päästab sind intsidenti päeval kohustusest maksta ja uuesti oodata kogu korpuse täielikku kodeerimist.
Kokkuvõte
- Redis vahemälu vähendab kulusid ja latentsust üle 90%
- Eksponentsiaalne uuestiproovimine käsitleb OpenAI kiiruse piiranguid
- Asünkroonne töötlemine kiirendab suurte korpuste sisestamist
- int8 kvantimine vähendab salvestusruumi 4x
- Mõõtmete vähendamine API tasemel on lihtsaim hoob
Testi oma teadmisi
Kakskümmend kaks õppetundi manuste ja RAG-i teemal: põhiosa mahub viide küsimusse.
1. Mida manus jäädvustab ja kuidas võrdleme kahte teksti?
Vastus: Vektor, mis kodeerib tähendust: kaks tähenduselt lähedast teksti omavad lähedasi vektoreid – koosinussarnasus mõõdab seda lähedust sõltumata kasutatud täpsetest sõnadest.
2. Miks kombineerida semantilist ja leksikaalset otsingut?
Vastus: Semantiline mõistab ümberformuleeringuid, kuid jätab täpsed terminid (viited, identifikaatorid) vahele; leksikaalne teeb vastupidist – hübriid katab mõlemad pimedad kohad ja liidab tulemused järjestuse alusel.
3. Milline on tükeldamise roll RAG-i kvaliteedis?
Vastus: Otsustav: ideepiire austavad segmendid toodavad täpse otsingu; suvalised lõiked genereerivad mittetäielikke fragmente – ja kogu torustik pärib selle.
4. Integreeritud failiotsing või kohandatud RAG: kuidas valida?
Vastus: Failiotsing kiireks liikumiseks hallatud torustikuga (integreeritud tükeldamine ja järjestamine); kohandatud RAG, kui vajad kontrolli lõikamise, indeksite, ümberjärjestamise või mitme allika üle.
5. Nimeta lisaks otsingule kaks manuste kasutusviisi.
Vastus: Klassifitseerimine ja klasterdamine (sarnaste tekstide automaatne rühmitamine), isikupärastatud soovitused või anomaaliate ja duplikaatide tuvastamine – sama vektor, erinevad kaugused.
Kursuse punane niit: tähendus muutub mõõdetavaks – otsing, järjestamine, soovitused on lihtsalt rakendused. Tootmine (skaleerimine, vahemällu salvestamine) teeb ülejäänu.