Produkcja: Skalowanie i buforowanie
Na tej stronie
Cele
- Zoptymalizuj wydajność systemu osadzeń (embeddings) w środowisku produkcyjnym
- Wdróż buforowanie, aby zmniejszyć koszty i opóźnienia
- Zarządzaj skalowalnością i wysoką dostępnością
Wyzwania produkcyjne
Podczas rozwoju wywoływanie API OpenAI dla każdego żądania nie stanowi problemu: możesz wykonywać dziesięć wywołań dziennie. W produkcji ten sam kod zderza się jednocześnie z trzema murami. Po pierwsze, koszt: każde wywołanie jest płatne, a pełne ponowne indeksowanie korpusu jest opłacane w całości za każdym razem, gdy jest uruchamiane. Po drugie, opóźnienie: podróż w obie strony przez sieć wynosząca od 100 do 300 ms na żądanie dodaje się do czasu wyszukiwania i czasu generowania, a użytkownik odczuwa sumę wszystkich trzech czynników. Wreszcie, limity przepustowości (rate limits): OpenAI ogranicza liczbę wywołań na minutę – limitu, którego nigdy nie zobaczysz podczas rozwoju, ale który uderzy w dniu premiery.
Wszystkie trzy problemy mają w dużej mierze to samo rozwiązanie: nie wywołuj API, gdy nie jest to konieczne.
Buforowanie osadzeń (Embeddings)
Osadzenie jest deterministyczne: ten sam tekst z tym samym modelem zawsze zwraca ten sam wektor. Sprawia to, że buforowanie jest tutaj wysoce skuteczne, znacznie bardziej niż w przypadku generatywnego LLM. Dla aplikacji o umiarkowanym ruchu wystarczy dekorator lru_cache ze standardowej biblioteki i zajmuje to zaledwie dwie linie kodu. Wartość zwracana jest konwertowana na krotkę, ponieważ lru_cache wymaga wartości hashowalnych; to jedyny haczyk, o którym musisz wiedzieć.
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:
"""Bufor LRU dla osadzeń (krotka, ponieważ jest hashowalna)."""
response = client.embeddings.create(input=text, model=model)
return tuple(response.data[0].embedding)
# Użycie - drugie wywołanie jest natychmiastowe
emb1 = embedding_cache("Hello world") # Wywołanie API
emb2 = embedding_cache("Hello world") # Z bufora
Ten bufor znika przy każdym restartie i nie jest współdzielony między procesami: gdy tylko uruchomisz dwie instancje za balanserem obciążenia, każda z nich odbudowuje swój własny. Redis rozwiązuje oba te problemy. Kluczem jest hash pary model-tekst, co zapobiega obsłudze starych wektorów w przypadku zmiany modelu, a trzydziestodniowy TTL (Time To Live) ogranicza wzrost zużycia pamięci.
Metoda get_embeddings_batch zasługuje na szczególną uwagę, ponieważ to ona robi różnicę podczas ingestii. Nie sprawdza ona bufora tekst po tekście: oddziela chybienia (misses), wysyła je w jednym wywołaniu API, a następnie ponownie wstawia każdy wynik na jego oryginalną pozycję, używając indices_a_calculer. Przy partii tysiąca dokumentów, z których dziewięćset jest już znanych, przechodzisz z jednego wywołania na dokument do jednego wywołania dla pozostałych stu.
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)
# Sprawdź bufor
cached = self.redis.get(key)
if cached:
return json.loads(cached)
# Wygeneruj i zapisz w buforze
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]]:
"""Partia z częściowym buforowaniem."""
results = [None] * len(texts)
to_calculate = []
indices_to_calculate = []
# Sprawdź bufor dla każdego tekstu
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)
# Oblicz chybienia w jednym wywołaniu
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"Bufor: {len(texts) - len(to_calculate)}/{len(texts)} trafień")
return results
# Użycie
cache = EmbeddingCacheRedis()
emb = cache.get_embedding("cache test")
Obsługa limitów przepustowości (Rate Limits)
Buforowanie zmniejsza ruch, ale go nie eliminuje, a skok ruchu w końcu wywoła błąd RateLimitError. Prawidłową reakcją nie jest natychmiastowa ponowna próba – co pogarsza zator – lecz oczekiwanie, podwajając za każdym razem czas opóźnienia: jedna sekunda, dwie, cztery, osiem, szesnaście. Pięć prób pokrywa zatem około trzydziestu sekund, co pochłania przytłaczającą większość tymczasowych skoków, a ostatnia próba ponownie zgłasza wyjątek, aby incydent został zgłoszony, zamiast być cicho połkniętym.
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
):
"""Wywołanie z wykładniczą ponowną próbą."""
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"Osiągnięto limit przepustowości, pauza na {wait}s...")
time.sleep(wait)
Przetwarzanie asynchroniczne
W potokach ingestii wąskim gardłem nie są obliczenia, lecz oczekiwanie na sieć: Twój program spędza większość czasu, nic nie robiąc. Przetwarzanie asynchroniczne pozwala utrzymać wiele żądań w toku. Semafory celowo ograniczają ten paralelizm, ponieważ uruchomienie stu jednoczesnych wywołań jedynie wyzwala limity przepustowości, których właśnie nauczyłeś się unikać – od trzech do pięciu współbieżnych żądań to zdrowe ustawienie. Teksty są najpierw dzielone na partie po sto elementów, a indeks początkowy każdej partii podróżuje wraz z zadaniem, aby as_completed, które zwraca wyniki w dowolnej kolejności, mogło nadal umieszczać je poprawnie.
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]]:
"""Generuj osadzenia równolegle z użyciem semafora."""
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)
]
# Podziel na partie 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
# Użycie
embeddings = asyncio.run(
generate_embeddings_async(my_texts, max_concurrent=3)
)
Optymalizacja przechowywania
Jest jeszcze rachunek za infrastrukturę. Dziesięć tysięcy wektorów o 3072 wymiarach w formacie float32 zajmuje około 122 MB; milion zajmuje dwanaście gigabajtów, które muszą być przechowywane w pamięci, aby wyszukiwanie pozostało szybkie. Kwantyzacja do int8 mapuje każdą współrzędną na 256 wartości całkowitych, dzieląc footprint czterokrotnie do około 30 MB w poniższym przykładzie. Utrata precyzji istnieje, ale pozostaje marginalna w porównaniu z lukami w podobieństwie, z którymi pracujesz.
import numpy as np
def quantize_int8(embeddings: np.ndarray) -> tuple:
"""Kwantyzuj osadzenia do int8 (4x mniej pamięci)."""
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):
"""Przywróć osadzenia z int8."""
return quantized.astype(np.float32) * scale + min_val
# Porównanie rozmiaru
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
Jednak najprostszym dźwigiem pozostaje parametr dimensions API, który produkuje krótsze wektory bezpośrednio, bez żadnego post-processingu z Twojej strony: 3072 wymiarów waży około 24 KB na wektor, 1024 wymiary spadają do 8 KB, a 256 wymiarów do 2 KB.
# 3072 wymiarów -> ~24 KB na wektor
# 1024 wymiary -> ~8 KB na wektor (redukcja po stronie API)
# 256 wymiarów -> ~2 KB na wektor (redukcja po stronie API)
response = client.embeddings.create(
input="text",
model="text-embedding-3-large",
dimensions=1024 # 3x mniej miejsca
)
Architektura produkcyjna
Złożone razem, te elementy tworzą szczupły potok: bufor Redis z przodu, solidny klient dla wywołań, które i tak się przedostaną. Ingestia korzysta ze ścieżki partii, wyszukiwanie buforuje nawet osadzenie zapytania – a ten ostatni punkt nie jest trywialny, ponieważ zapytania użytkowników powtarzają się znacznie częściej, niż byś przypuszczał.
class ProductionPipeline:
"""Potok RAG zoptymalizowany pod produkcję."""
def __init__(self):
self.cache = EmbeddingCacheRedis()
self.robust_client = RobustEmbeddingClient()
def ingest(self, documents: list[dict]):
"""Ingestia z buforem i ponownymi próbami."""
texts = [d["text"] for d in documents]
embeddings = self.cache.get_embeddings_batch(texts)
# Zapisz w bazie wektorowej...
def search(self, query: str, k: int = 5):
"""Wyszukiwanie z buforowaniem zapytań."""
query_emb = self.cache.get_embedding(query)
# Wyszukaj w bazie wektorowej...
return query_emb
Lista kontrolna produkcyjna
| Element | Opis |
|---|---|
| Bufor Redis | Zmniejsz liczbę wywołań API i opóźnienia |
| Wykładnicze ponawianie | Obsługa limitów przepustowości w sposób łagodny |
| Monitorowanie | Śledź wskaźnik trafień bufora, opóźnienia, błędy |
| Przetwarzanie wsadowe | Przetwarzaj duże wolumeny w asynchronicznych partiach |
| Kwantyzacja | Zmniejsz pamięć masową 4-krotnie dzięki int8 |
| Redukcja wymiarów | Użyj 1024 lub 512 wymiarów, jeśli jakość na to pozwala |
| Kopia zapasowa | Regularnie twórz kopie zapasowe osadzeń i metadanych |
| Alerty | Alertuj o błędach API i degradacji wydajności |
Dwie linie w tej tabeli nie przynoszą wzrostu wydajności, a jednak są najważniejsze. Monitorowanie wskaźnika trafień bufora to Twój wskaźnik zdrowia ekonomicznego: jeśli się załamie, Twój rachunek potroi się, zanim ktokolwiek to zauważy. A tworzenie kopii zapasowych osadzeń ratuje Cię w dniu incydentu przed koniecznością ponownej zapłaty i ponownego oczekiwania na pełne zakodowanie korpusu.
Kluczowe wnioski
- Bufor Redis zmniejsza koszty i opóźnienia o ponad 90%
- Wykładnicze ponawianie obsługuje limity przepustowości OpenAI
- Przetwarzanie asynchroniczne przyspiesza ingestię dużych korpusów
- Kwantyzacja int8 zmniejsza pamięć masową 4-krotnie
- Redukcja wymiarów w API jest najprostszą dźwignią
Sprawdź swoją wiedzę
Dwadzieścia dwie lekcje o osadzeniach i RAG: essentials mieszczą się w pięciu pytaniach.
1. Co przechwytuje osadzenie i jak porównujemy dwa teksty?
Odpowiedź: Wektor kodujący znaczenie: dwa teksty bliskie znaczeniowo mają bliskie wektory – podobieństwo cosinusowe mierzy tę bliskość, niezależnie od użytych dokładnych słów.
2. Dlaczego łączyć wyszukiwanie semantyczne i leksykalne?
Odpowiedź: Semantyczne rozumie przeformułowania, ale pomija dokładne terminy (odniesienia, identyfikatory); leksykalne robi odwrotnie – hybryda pokrywa obie ślepe plamki i scala według rangi.
3. Jaka jest rola chunkingu (dzielenia) w jakości RAG?
Odpowiedź: Decydująca: segmenty respektujące granice idei produkują precyzyjne wyszukiwanie; arbitralne cięcia generują niekompletne fragmenty – a cały potok dziedziczy ten problem.
4. Zintegrowane wyszukiwanie plików czy własny RAG: jak wybrać?
Odpowiedź: Wyszukiwanie plików, aby działać szybko z zarządzanym potokiem (zintegrowany chunking i ranking); własny RAG, gdy potrzebujesz kontrolować dzielenie, indeksy, reranking lub wiele źródeł.
5. Poza wyszukiwaniem, wymień dwa zastosowania osadzeń.
Odpowiedź: Klasyfikacja i klasteryzacja (automatyczne grupowanie podobnych tekstów), spersonalizowane rekomendacje lub wykrywanie anomalii i duplikatów – ten sam wektor, różne odległości.
Nić przewodnia kursu: znaczenie staje się mierzalne – wyszukiwanie, ranking, rekomendacje to tylko aplikacje. Produkcja (skalowanie, buforowanie) robi resztę.