Продукция: Мащабиране и кеширане
На тази страница
Цели
- Оптимизиране на производителността на система за вграждания (embeddings) в продукционна среда
- Внедряване на кеширане за намаляване на разходите и латентността
- Управление на мащабирането и висока наличност
Предизвикателства в продукционна среда
По време на разработването извикването на OpenAI API за всяка заявка не представлява проблем: може би правите десет обаждания на ден. В продукционна среда обаче същият код се сблъсква едновременно с три препятствия. Първо, разходи: всяко обаждане се таксува, а пълното повторно индексиране на корпус се заплаща изцяло всеки път, когато се изпълни. Второ, латентност: мрежовото пътуване до сървъра и обратно отнема между 100 и 300 ms на заявка, което се добавя към времето за търсене и генериране, а потребителят усеща сумата от всички тях. Накрая, ограничения на честотата (rate limits): OpenAI ограничава броя на обажданията в минута – ограничение, което никога няма да срещнете по време на разработка, но ще ударите в деня на стартирането.
И трите проблема имат до голяма степен едно и също решение: не правете обаждане към API, когато не е необходимо.
Кеширане на вгражданията
Едно вграждане е детерминирано: един и същ текст с един и същ модел винаги връща един и същ вектор. Това прави кеширането изключително ефективно тук, много повече, отколкото за генеративен LLM. За приложение с умерен трафик декораторът lru_cache от стандартната библиотека е напълно достатъчен и изисква само два реда код. Върнатата стойност се преобразува в кортеж (tuple), защото lru_cache изисква хешируеми стойности; това е единствената особеност, която трябва да знаете.
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
Този кеш изчезва при всяко рестартиране и не се споделя между процесите: щом пуснете две инстанции зад балансировщик на натоварването, всяка от тях изгражда своя собствена отново. Redis решава и двата проблема. Ключът е хеш на двойката модел-текст, което предотвратява обслужването на стари вектори при промяна на модела, а TTL от тридесет дни ограничава растежа на хранилището.
Методът get_embeddings_batch заслужава специално внимание, тъй като той прави разликата по време на поглъщане на данни (ingestion). Той не просто проверява кеша текст по текст: той разделя пропуснатите елементи (misses), изпраща ги в едно единствено API обаждане и след това вмъква всеки резултат обратно в оригиналната му позиция, използвайки indices_a_calculer. При партида от хиляда документа, от които деветстотин вече са известни, преминавате от едно обаждане на документ към едно единствено обаждане за останалите сто.
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")
Управление на ограниченията на честотата
Кеширането намалява трафика, но не го елиминира напълно, и пик в трафика в крайна сметка ще предизвика RateLimitError. Правилният отговор не е незабавно повторение на опита – което само влошава задръстването – а изчакване, като времето за забавяне се удвоява всеки път: една секунда, две, четири, осем, шестнадесет. Петте опита по този начин покриват около тридесет секунди, което поглъща огромната част от временните пикове, а последният опит отново повдига изключението, така че инцидентът да бъде докладван, вместо да бъде погълнат тихо.
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)
Асинхронна обработка
За конвейерите за поглъщане на данни (ingestion pipelines) тясното място не е изчислението, а чакането на мрежата: вашата програма прекарва по-голямата част от времето си, без да прави нищо. Асинхронната обработка ви позволява да поддържате множество заявки едновременно във въздуха. Семафорът умишлено ограничава този паралелизъм, защото стартирането на сто едновременни обаждания само ще задейства ограниченията на честотата, които току-що научихте как да управлявате – три до пет едновременни заявки са здравословна настройка. Текстовете първо се разделят на партиди от сто, а началният индекс на всяка партида пътува със задачата, така че as_completed, който връща резултатите извън реда, все пак да може да ги постави правилно.
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)
)
Оптимизиране на съхранението
След това идва сметката за инфраструктурата. Десет хиляди вектора с 3072 измерения във формат float32 заемат около 122 MB; един милион заемат дванадесет гигабайта, които трябва да се държат в паметта, за да остане търсенето бързо. Квантуването до int8 картографира всяка координата към 256 цели числа, като намалява отпечатъка четири пъти до около 30 MB в примера по-долу. Загубата на прецизност съществува, но остава маргинална в сравнение с разликите в сходството, с които работите.
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
Въпреки това, най-простият лост остава параметърът dimensions на API, който произвежда по-къси вектори директно, без никаква пост-обработка от ваша страна: 3072 измерения тежат около 24 KB на вектор, 1024 измерения падат до 8 KB, а 256 измерения до 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
)
Продукционна архитектура
Сглобени заедно, тези части дават изчистен конвейер: Redis кеш отпред, надежден клиент за обажданията, които все пак пробиват. Поглъщането използва маршрута на партидите, търсенето кешира дори вграждането на заявката – и тази последна точка не е тривиална, защото потребителските заявки се повтарят много повече, отколкото бихте си помислили.
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
Контролен списък за продукция
| Елемент | Описание |
|---|---|
| Redis Cache | Намаляване на API обажданията и латентността |
| Exponential Retry | Грациозно справяне с ограниченията на честотата |
| Monitoring | Проследяване на процента на попадения в кеша, латентност, грешки |
| Batch Processing | Обработка на големи обеми в асинхронни партиди |
| Quantization | Намаляване на съхранението 4 пъти с int8 |
| Dimension Reduction | Използване на 1024 или 512 измерения, ако качеството позволява |
| Backup | Редовно архивиране на вгражданията и метаданните |
| Alerting | Известия при грешки в API и влошаване на производителността |
Два реда в тази таблица не носят печалба в производителността, но са най-важните. Мониторингът на процента на попадения в кеша е вашият индикатор за икономическо здраве: ако той се срине, сметката ви се утроява, преди някой да забележи. А архивирането на вгражданията ви спасява в деня на инцидент от необходимостта да платите отново и да изчакате пълното кодиране на корпуса.
Ключови изводи
- Redis кешът намалява разходите и латентността с над 90%
- Експоненциалното повторение на опита управлява ограниченията на честотата на OpenAI
- Асинхронната обработка ускорява поглъщането на големи корпуси
- int8 квантуването намалява съхранението 4 пъти
- Намаляването на измеренията на ниво API е най-простият лост
Проверете знанията си
Двадесет и два урока за вграждания и RAG: същността се събира в пет въпроса.
1. Какво улавя едно вграждане и как сравняваме два текста?
Отговор: Вектор, който кодира смисъла: два текста, близки по смисъл, имат близки вектори – косинусовото сходство измерва тази близост, независимо от точните използвани думи.
2. Защо комбинираме семантично и лексикално търсене?
Отговор: Семантичното разбира преформулировките, но пропуска точните термини (препратки, идентификатори); лексикалното прави обратното – хибридното покрива и двете слепи петна и обединява чрез ранг.
3. Каква е ролята на разделянето на части (chunking) за качеството на RAG?
Отговор: Решаваща: сегментите, които спазват границите на идеите, произвеждат точно търсене; произволните разрези генерират непълни фрагменти – и целият конвейер наследява това.
4. Интегрирано търсене на файлове или персонализиран RAG: как да изберем?
Отговор: Търсене на файлове за бързо движение с управляван конвейер (интегрирано разделяне и ранжиране); персонализиран RAG, когато трябва да контролирате разделянето, индексите, повторното ранжиране или множество източници.
5. Освен търсенето, назовете две употреби за вграждания.
Отговор: Класификация и клъстериране (автоматично групиране на сходни текстове), персонализирани препоръки или откриване на аномалии и дубликати – същият вектор, различни разстояния.
Нишката на курса: смисълът става измерим – търсенето, ранжирането, препоръките са просто приложения. Продукцията (мащабиране, кеширане) прави останалото.