Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Gamyba: mastelio keitimas ir talpinimas į podėlį

Paskaita 22 iš 22 Atnaujinta 2026 m. liepos 29 d. Kūrėjas
Šiame puslapyje
  1. Tikslai
  2. Gamybos iššūkiai
  3. Įterpčių talpinimas į podėlį (Caching)
  4. Užklausų ribojimų valdymas
  5. Asinchroninis apdorojimas
  6. Saugyklos optimizavimas
  7. Gamybos architektūra
  8. Gamybos kontrolinis sąrašas
  9. Svarbiausi punktai
  10. Patikrink savo žinias

Tikslai

  • Optimizuoti įterpčių (embedding) sistemos našumą gamybinėje aplinkoje
  • Įgyvendinti talpinimą į podėlį (caching), kad sumažintum išlaidas ir delsą
  • Valdyti mastelio keitimą ir didelį prieinamumą

Gamybos iššūkiai

Kūrimo metu kvietimai į „OpenAI“ API kiekvienam užklausui nėra problema: galbūt atlieki dešimt kvietimų per dieną. Gamyboje tas pats kodas tuo pačiu metu atsitrenkia į tris sienas. Pirma, kaina: už kiekvieną kvietimą mokama, o visos korpuso perkainavimo išlaidos padengiamos kiekvieną kartą, kai jis paleidžiamas. Antra, delsa: tinklo kelionė pirmyn ir atgal trunka nuo 100 iki 300 ms vienam užklausui, tai pridėtinė vertė paieškos ir generavimo laikui, o vartotojas jaučia visų trijų komponentų sumą. Galiausiai, užklausų ribojimai: „OpenAI“ riboja kvietimų skaičių per minutę – ribą, kurios niekada nepamatysi kūrimo metu, bet pasieksi paleidimo dieną.

Visos trys problemos iš esmės turi tą patį sprendimą: nekviesti API, kai tai nėra būtina.

Įterpčių talpinimas į podėlį (Caching)

Įterptis yra deterministinė: tas pats tekstas su tuo pačiu modeliu visada grąžina tą patį vektorių. Dėl to talpinimas į podėlį čia yra itin efektyvus, daug labiau nei generuojančiam didžiajam kalbos modeliui (LLM). Programai, turinčiai vidutinį srautą, standartinės bibliotekos dekoratorius lru_cache yra pakankamas ir užima tik dvi eilutes. Grąžinama reikšmė konvertuojama į kortažą (tuple), nes lru_cache reikalauja maišomų (hashable) reikšmių; tai vienintelis niuansas, kurį reikia žinoti.

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 podėlis įterptims (kortažas, nes jis yra maišomas)."""
    response = client.embeddings.create(input=text, model=model)
    return tuple(response.data[0].embedding)

# Naudojimas - antrasis kvietimas yra momentalus
emb1 = embedding_cache("Hello world")  # API kvietimas
emb2 = embedding_cache("Hello world")  # Iš podėlio

Šis podėlis išnyksta bet kurio paleidimo iš naujo metu ir nėra bendrinamas tarp procesų: kai tik paleidi du egzempliorius už apkrovos balansuoklio, kiekvienas iš jų atkuria savo podėlį iš naujo. „Redis“ išsprendžia abi šias problemas. Raktas yra modelio ir teksto poros maiša (hash), tai neleidžia pakeitus modelį tarnauti senais vektoriais, o trisdešimties dienų galiojimo laikas (TTL) riboja saugyklos augimą.

Metodas get_embeddings_batch nusipelno ypatingo dėmesio, nes būtent jis lemia skirtumą ingestijos metu. Jis ne tik tikrina podėlį tekstas po teksto: jis atskiria nepataikymus (misses), išsiunčia juos vienu API kvietimu, tada įterpia kiekvieną rezultatą atgal į originalią poziciją naudodamas indices_a_calculer. Tūkstančio dokumentų partijoje, kurioje devyni šimtai jau yra žinomi, pereini nuo vieno kvietimo vienam dokumentui prie vieno kvietimo likusiems šimtui.

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 dienų

    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)

        # Tikrinti podėlį
        cached = self.redis.get(key)
        if cached:
            return json.loads(cached)

        # Generuoti ir talpinti į podėlį
        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]]:
        """Partija su daliniu talpinimu į podėlį."""
        results = [None] * len(texts)
        to_calculate = []
        indices_to_calculate = []

        # Tikrinti podėlį kiekvienam tekstui
        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)

        # Apskaičiuoti nepataikymus vienu kvietimu
        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"Podėlis: {len(texts) - len(to_calculate)}/{len(texts)} pataikymų")
        return results

# Naudojimas
cache = EmbeddingCacheRedis()
emb = cache.get_embedding("cache test")

Užklausų ribojimų valdymas

Talpinimas į podėlį sumažina srautą, bet jo nepanaikina, o srauto šuolis galiausiai sukels RateLimitError. Teisingas atsakas – ne bandyti iškart iš naujo, nes tai tik padidina spūstis, o palaukti, kiekvieną kartą dvigubinant delsą: viena sekundė, dvi, keturios, aštuonios, šešiolika. Penki bandymai taip apima apie trisdešimt sekundžių, kas sugeria didžiąją dalį laikinų šuolių, o paskutinis bandymas vėl išmeta išimtį, kad incidentas būtų užfiksuotas, o ne tyliai prarytas.

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
    ):
        """Kvietimas su eksponentiniu bandymų kartojimu."""
        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"Pasiektas užklausų limitas, laukiama {wait}s...")
                time.sleep(wait)

Asinchroninis apdorojimas

Ingestijos vamzdynams „butelio kaklelis“ yra ne skaičiavimai, o laukimas tinklo atsakymo: tavo programa didžiąją laiko dalį nieko neveikia. Asinchroninis apdorojimas leidžia vienu metu vykdyti kelias užklausas. Semaforas tyčia riboja šį lygiagretumą, nes šimto simultaniškų kvietimų paleidimas tik suaktyvina ribojimus, kuriuos ką tik išmokai valdyti – trys iki penkių vienu metu vykdomų užklausų yra sveikas nustatymas. Tekstai pirmiausia suskirstomi į šimto elementų partijas, o kiekvienos partijos pradžios indeksas keliauja kartu su užduotimi, kad as_completed, grąžinantis rezultatus netvarkinga tvarka, vis tiek galėtų juos teisingai išdėstyti.

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]]:
    """Generuoti įterptis lygiagrečiai naudojant semaforą."""
    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)
            ]

    # Skirstyti į 100 elementų partijas
    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

# Naudojimas
embeddings = asyncio.run(
    generate_embeddings_async(my_texts, max_concurrent=3)
)

Saugyklos optimizavimas

Tuomet yra infrastruktūros sąskaita. Dešimt tūkstančių 3072 matmenų vektorių formatu float32 užima apie 122 MB; milijonas užima dvylika gigabaitų, kurie turi būti laikomi operatyviojoje atmintyje, kad paieška išliktų greita. Kvantavimas į int8 susieja kiekvieną koordinatę su 256 sveikaisiais skaičiais, keturis kartus sumažindamas pėdsaką iki maždaug 30 MB žemiau pateiktame pavyzdyje. Tikslumo nuostolis egzistuoja, tačiau lieka nereikšmingas, palyginti su panašumo skirtumais, su kuriais dirbi.

import numpy as np

def quantize_int8(embeddings: np.ndarray) -> tuple:
    """Kvantuoti įterptis į int8 (4 kartus mažiau atminties)."""
    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):
    """Atkurti įterptis iš int8."""
    return quantized.astype(np.float32) * scale + min_val

# Dydzio palyginimas
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

Tačiau paprasčiausias svertas lieka API parametras dimensions, kuris sukuria trumpesnius vektorius tiesiogiai be jokio tavo atliekamo papildomo apdorojimo: 3072 matmenys sveria apie 24 KB vienam vektoriui, 1024 matmenys sumažėja iki 8 KB, o 256 matmenys – iki 2 KB.

# 3072 matmenų -> ~24 KB vienam vektoriui
# 1024 matmenų -> ~8 KB vienam vektoriui  (API sumažinimas)
# 256 matmenų  -> ~2 KB vienam vektoriui  (API sumažinimas)

response = client.embeddings.create(
    input="text",
    model="text-embedding-3-large",
    dimensions=1024  # 3 kartus mažiau saugyklos
)

Gamybos architektūra

Sujungus šias dalis, gaunamas efektyvus vamzdynas: „Redis“ podėlis priekyje, patikimas klientas tiems kvietimams, kurie visgi prasiskverbia. Ingestija vyksta partijų maršrutu, paieška talpina į podėlį net ir užklausos įterptį – ir šis paskutinis punktas nėra trivialus, nes vartotojų užklausos kartojasi daug dažniau, nei gali manyti.

class ProductionPipeline:
    """RAG vamzdynas, optimizuotas gamybai."""

    def __init__(self):
        self.cache = EmbeddingCacheRedis()
        self.robust_client = RobustEmbeddingClient()

    def ingest(self, documents: list[dict]):
        """Ingestija su podėliu ir bandymų kartojimu."""
        texts = [d["text"] for d in documents]
        embeddings = self.cache.get_embeddings_batch(texts)
        # Saugoti vektorių duomenų bazėje...

    def search(self, query: str, k: int = 5):
        """Paieška su užklausos talpinimu į podėlį."""
        query_emb = self.cache.get_embedding(query)
        # Ieškoti vektorių duomenų bazėje...
        return query_emb

Gamybos kontrolinis sąrašas

ElementasAprašymas
Redis podėlisSumažina API kvietimus ir delsą
Eksponentinis bandymų kartojimasSklandžiai valdo užklausų ribojimus
StebėsenaSek podėlio pataikymų rodiklį, delsą, klaidas
Partijų apdorojimasApdorok didelius kiekius asinchroninėse partijose
KvantavimasSumažink saugyklą 4 kartus naudojant int8
Matmenų mažinimasNaudok 1024 arba 512 matmenų, jei kokybė leidžia
Atsarginė kopijaReguliariai kurk įterpčių ir metaduomenų atsargines kopijas
ĮspėjimaiĮspėk apie API klaidas ir našumo blogėjimą

Dvi eilutės šioje lentelėje neduoda našumo padidėjimo, tačiau yra svarbiausios. Podėlio pataikymų rodiklio stebėsena yra tavo ekonominės sveikatos indikatorius: jei jis žlunga, tavo sąskaita išauga trigubai, prieš tai kam nors pastebint. O įterpčių atsarginių kopijų kūrimas išgelbsti tave incidento dieną nuo būtinybės iš naujo mokėti ir laukti viso korpuso kodavimo.

Svarbiausi punktai

  • „Redis“ podėlis sumažina išlaidas ir delsą daugiau nei 90 %
  • Eksponentinis bandymų kartojimas valdo „OpenAI“ užklausų ribojimus
  • Asinchroninis apdorojimas pagreitina didelių korpusų ingestiją
  • int8 kvantavimas sumažina saugyklą 4 kartus
  • Matmenų mažinimas tiesiai API yra paprasčiausias svertas

Patikrink savo žinias

Dvidešimt dvi pamokos apie įterptis ir RAG: esmė telpa į penkis klausimus.

1. Ką fiksuoja įterptis ir kaip lyginame du tekstus?

Atsakymas: Vektorių, kuris koduoja prasmę: du tekstai, artimi prasme, turi artimus vektorius – kosinusinis panašumas matuoja šį artumą, nepaisant naudojamų tikslių žodžių.

2. Kodėl derinti semantinę ir leksinę paiešką?

Atsakymas: Semantinė supranta performulavimus, bet praleidžia tikslius terminus (nuorodos, identifikatoriai); leksinė daro priešingai – hibridas apima abi akląsias zonas ir sujungia pagal rangą.

3. Koks yra skaidymo (chunking) vaidmuo RAG kokybei?

Atsakymas: Lemiamas: segmentai, gerbiantys idėjų ribas, suteikia tikslią paiešką; savavališki pjūviai generuoja neišsamias dalis – ir visas vamzdynas paveldi tai.

4. Integruota failų paieška arba pasirinktinis RAG: kaip rinktis?

Atsakymas: Failų paieška, norint greitai judėti su valdomu vamzdynu (integruotas skaidymas ir rangavimas); pasirinktinis RAG, kai reikia kontroliuoti skaidymą, indeksus, per rangavimą ar kelis šaltinius.

5. Be paieškos, įvardyk du įterpčių naudojimo būdus.

Atsakymas: Klasifikavimas ir klasterizavimas (automatinis panašių tekstų grupavimas), asmeninės rekomendacijos arba anomalijų ir dublikatų aptikimas – tas pats vektorius, skirtingi atstumai.

Kurso gija: prasmė tampa išmatuojama – paieška, rangavimas, rekomendacijos yra tik taikymai. Gamyba (mastelio keitimas, talpinimas į podėlį) atlieka likusį darbą.