Siirry pääsisältöön
Suomi— Valitse kieli
Valikko

Tuotanto: skaalaus ja välimuisti

Oppitunti 22 / 22 Päivitetty 29. heinäkuuta 2026 Kehittäjä
Tällä sivulla
  1. Tavoitteet
  2. Tuotannon haasteet
  3. Upotusten välimuistitus
  4. Nopeusrajoitusten hallinta
  5. Asynkroninen käsittely
  6. Tallennustilan optimointi
  7. Tuotantoarkkitehtuuri
  8. Tuotantotarkistuslista
  9. Keskeiset asiat
  10. Testaa tietämyksesi

Tavoitteet

  • Optimoi upotusjärjestelmän suorituskyky tuotantoympäristössä
  • Toteuta välimuisti kustannusten ja viiveen pienentämiseksi
  • Hallitse skaalautuvuutta ja korkeaa saatavuutta

Tuotannon haasteet

Kehitysvaiheessa OpenAI-rajapinnan kutsuminen jokaisen pyynnön yhteydessä ei ole ongelma: saatat tehdä kymmenen puhelua päivässä. Tuotannossa sama koodi törmää kuitenkin samanaikaisesti kolmeen seinään. Ensinnäkin kustannukset: jokaisesta puhelusta veloitetaan, ja koko tietokannan uudelleenindeksointi maksetaan täysimääräisesti joka kerta, kun se suoritetaan. Toiseksi viive: verkon edestakainen matka, joka kestää 100–300 ms pyyntöä kohden, lisää sekä hakuaikaa että generointiaikaa, ja käyttäjä tuntee kaikkien kolmen summan. Lopuksi nopeusrajoitukset: OpenAI rajoittaa puheluiden määrää minuuttia kohden – rajaa, jota et koskaan näe kehitysvaiheessa, mutta johon törmäät julkaisupäivänä.

Kaikilla kolmella ongelmalla on pitkälti sama ratkaisu: älä kutsu rajapintaa, kun se ei ole välttämätöntä.

Upotusten välimuistitus

Upotus on deterministinen: sama teksti samalla mallilla tuottaa aina saman vektorin. Tämä tekee välimuistista erittäin tehokkaan tässä yhteydessä, paljon tehokkaamman kuin generatiivisessa LLM:ssä. Kohtuullisen liikenteen sovelluksessa standardikirjaston lru_cache-dekoraattori riittää ja vie vain kaksi riviä. Palautusarvo muutetaan tupleksi, koska lru_cache vaatii hashattavia arvoja; tämä on ainoa yksityiskohta, joka on hyvä tietää.

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-välimuisti upotuksille (tuple, koska se on hashattava)."""
    response = client.embeddings.create(input=text, model=model)
    return tuple(response.data[0].embedding)

# Käyttö – toinen puhelu on välitön
emb1 = embedding_cache("Hello world")  # API-puhelu
emb2 = embedding_cache("Hello world")  # Välimuistista

Tämä välimuisti katoaa kaikissa uudelleenkäynnistyksissä eikä sitä jaeta prosessien välillä: heti kun ajat kaksi instanssia kuormantasauksen takana, kumpikin rakentaa oman uudelleen. Redis ratkaisee molemmat ongelmat. Avain on malli-teksti-parin tiiviste (hash), mikä estää vanhojen vektorien tarjoamisen mallin vaihtuessa, ja kolmenkymmenen päivän TTL (Time To Live) rajoittaa tallennustilan kasvua.

Metodi get_embeddings_batch ansaitsee tarkkaa huomiota, sillä se tekee erottelun ingestoinnin aikana. Se ei tarkista välimuistia teksti kerrallaan: se erottaa puuttuvat kohteet, lähettää ne yhdessä API-puhelussa ja sijoittaa sitten jokaisen tuloksen takaisin alkuperäiseen paikkaansa käyttäen muuttujaa indices_a_calculer. Tuhannen dokumentin erässä, jossa yhdeksänsataa on jo tiedossa, siirrytään yhdestä puhelusta dokumenttia kohden yhteen ainoaan puheluun jäljellä oleville sadalle.

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äivää

    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)

        # Tarkista välimuisti
        cached = self.redis.get(key)
        if cached:
            return json.loads(cached)

        # Generoi ja tallenna välimuistiin
        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]]:
        """Eräajossa osittainen välimuistitus."""
        results = [None] * len(texts)
        to_calculate = []
        indices_to_calculate = []

        # Tarkista välimuisti jokaiselle tekstille
        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)

        # Laske puuttuvat yhdellä puhelulla
        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"Välimuisti: {len(texts) - len(to_calculate)}/{len(texts)} osumaa")
        return results

# Käyttö
cache = EmbeddingCacheRedis()
emb = cache.get_embedding("cache test")

Nopeusrajoitusten hallinta

Välimuisti vähentää liikennettä, mutta ei poista sitä kokonaan, ja liikenteen piikki laukaisee ennemmin tai myöhemmin RateLimitError-virheen. Oikea reagointitapa ei ole yrittää heti uudelleen – mikä pahentaa ruuhkaa – vaan odottaa ja kaksinkertaistaa viive joka kerta: yksi sekunti, kaksi, neljä, kahdeksan, kuusitoista. Viisi yritystä kattaa näin noin kolmekymmentä sekuntia, mikä absorboi valtaosan tilapäisistä piikeistä, ja viimeinen yritys heittää poikkeuksen uudelleen, jotta tapahtuma raportoidaan sen sijaan, että se nieltäisiin hiljaa.

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 eksponentiaalisella uudelleenyrityksellä."""
        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"Nopeusrajoitus saavutettu, odotetaan {wait}s...")
                time.sleep(wait)

Asynkroninen käsittely

Ingestointiputkistoissa pullonkaula ei ole laskenta vaan verkon odotus: ohjelmasi käyttää suurimman osan ajastaan tekemättä mitään. Asynkroninen käsittely mahdollistaa useiden pyyntöjen pitämisen ilmassa samanaikaisesti. Semafori rajoittaa tarkoituksellisesti tätä rinnakkaisuutta, koska sadan samanaikaisen puhelun käynnistäminen laukaisee vain ne nopeusrajoitukset, jotka juuri opit hallitsemaan – kolmesta viiteen samanaikaista pyyntöä on terveellinen asetus. Tekstit jaetaan ensin sadan kappaleen eriin, ja jokaisen erän aloitusindeksi kulkee tehtävän mukana, jotta as_completed, joka palauttaa tulokset epäjärjestyksessä, pystyy silti sijoittamaan ne oikein.

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]]:
    """Generoi upotukset rinnakkain semaforilla."""
    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)
            ]

    # Jaa 100 kappaleen eriin
    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

# Käyttö
embeddings = asyncio.run(
    generate_embeddings_async(my_texts, max_concurrent=3)
)

Tallennustilan optimointi

Sitten on infrastruktuurilasku. Kymmenentuhatta 3 072-ulotteista vektoria float32-muodossa vie noin 122 Mt; miljoona vektoria vie kaksitoista gigatavua, jotka on pidettävä muistissa, jotta haku pysyy nopeana. Kvantitus int8-muotoon kuvaa jokaisen koordinaatin 256 kokonaislukuarvoon, mikä jakaa jalanjäljen neljällä noin 30 Mt:iin alla olevassa esimerkissä. Tarkkuuden menetys on olemassa, mutta se jää marginaaliseksi verrattuna siihen samankaltaisuuseroon, jonka kanssa työskentelet.

import numpy as np

def quantize_int8(embeddings: np.ndarray) -> tuple:
    """Kvantitoi upotukset int8-muotoon (4x vähemmän muistia)."""
    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):
    """Palauta upotukset int8-muodosta."""
    return quantized.astype(np.float32) * scale + min_val

# Kokovaihtelu
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

Yksinkertaisin vipu on kuitenkin rajapinnan dimensions-parametri, joka tuottaa lyhyempiä vektoreita suoraan ilman minkäänlaista jälkikäsittelyä puoleltasi: 3 072 ulottuvuutta painaa noin 24 kt vektoria kohden, 1 024 ulottuvuutta putoaa 8 kt:iin ja 256 ulottuvuutta 2 kt:iin.

# 3072 dim -> ~24 kt per vektori
# 1024 dim -> ~8 kt per vektori  (API:n vähennys)
# 256 dim  -> ~2 kt per vektori  (API:n vähennys)

response = client.embeddings.create(
    input="text",
    model="text-embedding-3-large",
    dimensions=1024  # 3x vähemmän tallennustilaa
)

Tuotantoarkkitehtuuri

Nämä osat yhdistettynä muodostavat hoikan putkiston: Redis-välimuisti edessä, robusti asiakas niille puheluille, jotka kuitenkin pääsevät läpi. Ingestointi käyttää eräajoreittiä, haku välimuistaa jopa kyselyupotuksen – ja tämä viimeinen kohta ei ole merkityksetön, sillä käyttäjien kyselyt toistuvat paljon useammin kuin luulisi.

class ProductionPipeline:
    """Tuotantoa varten optimoitu RAG-putkisto."""

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

    def ingest(self, documents: list[dict]):
        """Ingestointi välimuistilla ja uudelleenyrityksellä."""
        texts = [d["text"] for d in documents]
        embeddings = self.cache.get_embeddings_batch(texts)
        # Tallenna vektoritietokantaan...

    def search(self, query: str, k: int = 5):
        """Haku kyselyn välimuistituksella."""
        query_emb = self.cache.get_embedding(query)
        # Hae vektoritietokannasta...
        return query_emb

Tuotantotarkistuslista

ElementtiKuvaus
Redis-välimuistiVähentää API-puheluita ja viivettä
Eksponentiaalinen uudelleenyritysHallitsee nopeusrajoitukset hallitusti
MonitorointiSeuraa välimuistin osumaprosenttia, viivettä ja virheitä
EräajokäsittelyKäsittele suuria määriä asynkronisissa erissä
KvantitusVähennä tallennustilaa 4x int8-muunnoksella
Ulottuvuuksien vähentäminenKäytä 1024 tai 512 ulottuvuutta, jos laatu sallii
VarmuuskopiointiVarmuuskopioi upotukset ja metadata säännöllisesti
HälytyksetHälytä API-virheistä ja suorituskyvyn heikkenemisestä

Taulukon kaksi riviä eivät tuota suorituskykyetua, mutta ne ovat tärkeimpiä. Välimuistin osumaprosentin seuranta on taloudellinen terveysmittarisi: jos romahtaa, laskusi kolminkertaistuu ennen kuin kukaan huomaa. Ja upotusten varmuuskopiointi pelastaa sinut siltä, että joudut incidentin sattuessa maksamaan uudelleen ja odottamaan koko tietokannan uudelleenkoodausta.

Keskeiset asiat

  • Redis-välimuisti vähentää kustannuksia ja viivettä yli 90 %
  • Eksponentiaalinen uudelleenyritys hallitsee OpenAI:n nopeusrajoitukset
  • Asynkroninen käsittely nopeuttaa suurten tietokantojen ingestointia
  • int8-kvantitus vähentää tallennustilaa 4-kertaisesti
  • Ulottuvuuksien vähentäminen API-tasolla on yksinkertaisin vipu

Testaa tietämyksesi

Kaksikymmentäkaksi oppituntia upotuksista ja RAG:sta: oleelliset asiat mahtuvat viiteen kysymykseen.

1. Mitä upotus kuvaa ja miten vertaamme kahta tekstiä?

Vastaus: Merkitystä koodaava vektori: kaksi merkitykseltään lähellä olevaa tekstiä ovat lähellä toisiaan vektorimuodossa – kosinussamankaltaisuus mittaa tätä läheisyyttä riippumatta käytetyistä tarkoista sanoista.

2. Miksi yhdistää semanttinen ja leksikaalinen haku?

Vastaus: Semanttinen ymmärtää uudelleenmuotoilut, mutta missaa tarkat termit (viitteet, tunnisteet); leksikaalinen tekee päinvastoin – hybridi kattaa molemmat sokeat pisteet ja yhdistää tulokset sijoituksen perusteella.

3. Mikä on chunking-rooli RAG:n laadussa?

Vastaus: Ratkaiseva: idearajoja kunnioittavat segmentit tuottavat tarkan haun; mielivaltaiset katkokset synnyttävät epätäydellisiä fragmentteja – ja koko putkisto perii tämän.

4. Integroitu tiedostohaku vai mukautettu RAG: miten valita?

Vastaus: Tiedostohaku, kun haluat edetä nopeasti hallitulla putkistolla (integroitu paloitus ja sijoitus); mukautettu RAG, kun tarvitset hallintaa pilkkomiseen, indekseihin, uudelleensijoitukseen tai useisiin lähteisiin.

5. Nimeä kaksi upotusten käyttötarkoitusta haun lisäksi.

Vastaus: Luokittelu ja klusterointi (samankaltaisten tekstien automaattinen ryhmittely), personoidut suositukset tai poikkeavuuksien ja kaksoiskappaleiden havaitseminen – sama vektori, erilaiset etäisyydet.

Kurssin punainen lanka: merkityksestä tulee mitattavissa olevaa – haku, sijoitus ja suositus ovat vain sovelluksia. Tuotanto (skaalaus, välimuisti) hoitaa loput.