Przejdź do głównej treści
Polski— Wybierz język
Menu

Produkcja: Skalowanie i buforowanie

Lekcja 22 z 22 Zaktualizowano 29 lipca 2026 Programista
Na tej stronie
  1. Cele
  2. Wyzwania produkcyjne
  3. Buforowanie osadzeń (Embeddings)
  4. Obsługa limitów przepustowości (Rate Limits)
  5. Przetwarzanie asynchroniczne
  6. Optymalizacja przechowywania
  7. Architektura produkcyjna
  8. Lista kontrolna produkcyjna
  9. Kluczowe wnioski
  10. Sprawdź swoją wiedzę

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

ElementOpis
Bufor RedisZmniejsz liczbę wywołań API i opóźnienia
Wykładnicze ponawianieObsługa limitów przepustowości w sposób łagodny
MonitorowanieŚledź wskaźnik trafień bufora, opóźnienia, błędy
Przetwarzanie wsadowePrzetwarzaj duże wolumeny w asynchronicznych partiach
KwantyzacjaZmniejsz pamięć masową 4-krotnie dzięki int8
Redukcja wymiarówUżyj 1024 lub 512 wymiarów, jeśli jakość na to pozwala
Kopia zapasowaRegularnie twórz kopie zapasowe osadzeń i metadanych
AlertyAlertuj 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ę.