Léim go dtí an príomhábhar
Gaeilge— Roghnaigh teanga
Roghchlár

Léiriú: Scálú agus Caiséáil

Ceacht 22 as 22 Nuashonraithe 29 Iúil 2026 Forbróir
Ar an leathanach seo
  1. Cuspóirí
  2. Dúshláin Léirithe
  3. Caiséáil Leabaithe
  4. Teorainneacha Ráta a Láimhseáil
  5. Próiseáil Asincronach
  6. Stóráil a Bharrfheabhsú
  7. Ailtireacht Léirithe
  8. Seicliosta Léirithe
  9. Príomhphointí
  10. Tástáil do Chuid Eolais

Cuspóirí

  • Feidhmíocht córas leabaithe a bharrfheabhsú i dtimpeallacht léirithe
  • Caiséáil a chur i bhfeidhm chun costais agus moille a laghdú
  • Scálú agus ard-infhaighteacht a bhainistiú

Dúshláin Léirithe

Le linn forbartha, ní fadhb é glaoch ar an API OpenAI do gach iarratas: b’fhéidir go ndéanfá deich nglaoch sa lá. I léiriú, buaileann an cód céanna trí bhalla ag an am céanna. Ar an gcéad dul síos, costas: tá gach glaoch íoctha, agus íoctar as ath-innéacsú iomlán de chorpas gach uair a ritheann sé. Ar an dara dul síos, moill: cuireann turas timpeall líonra 100 go 300 ms in aghaidh an iarratais le ham cuardaigh agus am giniúna, agus mothaíonn an t-úsáideoir suim an trí cinn. Faoi dheireadh, teorainneacha ráta: cuireann OpenAI teorainn le líon na nglaoch in aghaidh an nóiméid – teorainn nach bhfeicfidh tú riamh le linn forbartha ach a bhuaileann tú ar lá seolta.

Tá an réiteach céanna ag na trí fhadhb seo den chuid is mó: ná déan glaoch ar an API mura gá.

Caiséáil Leabaithe

Tá leabaithe cinntitheach: filleann an téacs céanna leis an múnla céanna an veicteoir céanna i gcónaí. Déanann sé seo caiséáil an-éifeachtach anseo, i bhfad níos mó ná do LLM giniúnach. D’fheidhmchlár le tráchta measartha, tá an maisín lru_cache sa leabharlann caighdeánach leordhóthanach agus ní ghlacann sé ach dhá líne. Tiontaítear an luach fillte go tiúpal toisc go n-éilíonn lru_cache luachanna in-haisithe; sin an t-aon rud a chaithfidh tú a bheith ar an eolas faoi.

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:
    """Caisé LRU do leabaithe (tiúpal toisc go bhfuil sé in-haisithe)."""
    response = client.embeddings.create(input=text, model=model)
    return tuple(response.data[0].embedding)

# Úsáid - tá an 2ú glaoch láithreach
emb1 = embedding_cache("Hello world")  # Glaoch API
emb2 = embedding_cache("Hello world")  # Ón gcaisé

Imíonn an caisé seo ar athsheoladh ar bith agus ní roinntear é thar phróisis: chomh luath agus a ritheann tú dhá shampla taobh thiar de chothromóir ualaigh, athdhéanann gach ceann a cheann féin. Réitíonn Redis an dá fhadhb. Is hais de phéire múnla-téacs an eochair, rud a chuireann cosc ar sheirbhísiú veicteoirí seanmhúnla má athraítear an múnla, agus cuireann TTL tríocha lá srian ar fhás stórála.

Tuilleann an modh get_embeddings_batch aird ghairid, mar is é seo a dhéanann an difríocht le linn ionghabhála. Ní sheiceálann sé an caisé téacs ar théacs amháin: scarann sé na hiarraidh a theipeann, seolann iad i nglaoch API amháin, agus ansin athchuireann sé gach toradh ina shuíomh bunaidh ag baint úsáide as indices_a_calculer. Ar bhaisc de mhíle doiciméad ina bhfuil naoi gcéad ar eolas cheana, téann tú ó ghlaoch amháin in aghaidh an doiciméid go glaoch amháin don chéad chéad eile.

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 lá

    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)

        # Seiceáil an caisé
        cached = self.redis.get(key)
        if cached:
            return json.loads(cached)

        # Giniúint agus caiséáil
        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]]:
        """Baisc le caiséáil pháirteach."""
        results = [None] * len(texts)
        to_calculate = []
        indices_to_calculate = []

        # Seiceáil an caisé do gach téacs
        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)

        # Ríomh na hiarraidh a theipeann i nglaoch amháin
        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"Caisé: {len(texts) - len(to_calculate)}/{len(texts)} buillí")
        return results

# Úsáid
cache = EmbeddingCacheRedis()
emb = cache.get_embedding("tástáil caisé")

Teorainneacha Ráta a Láimhseáil

Laghdaíonn caiséáil tráchta ach ní dhíothaíonn sí í, agus spreagfaidh barr tráchta RateLimitError faoi dheireadh. Ní hé an freagra ceart ná iarracht a dhéanamh arís láithreach – rud a dhéanann an plódú níos measa – ach fanacht, ag dúbailt an mhoill gach uair: soicind amháin, dhá, ceathair, ocht, sé déag. Clúdaíonn cúig iarracht mar sin thart ar thríocha soicind, rud a shúnn an chuid is mó de na buaicphointí sealadacha, agus ardaíonn an iarracht dheireanach an eisceacht arís ionas go dtuairiscítear an teagmhas in ionad é a shlogadh go ciúin.

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
    ):
        """Glaoch le hiarracht easpónantúil."""
        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"Buaileadh teorainn ráta, ag stopadh ar feadh {wait}s...")
                time.sleep(wait)

Próiseáil Asincronach

Do phíblínte ionghabhála, ní ríomhaireacht an bac ach fanacht líonra: caiteann do chlár an chuid is mó dá chuid ama gan aon rud a dhéanamh. Ligeann próiseáil asincronach duit iarratais iolracha a choinneáil ar siúl. Teorannaíonn an seimeafar an comhthreomhaireacht seo d’aon ghnó, toisc nach spreagfadh céad glaoch comhuaineach ach na teorainneacha ráta a d’fhoghlaim tú conas a láimhseáil – is socruithe sláintiúla iad trí go cúig iarratas comhuaineach. Roinntear téacsanna ar dtús i mbaisc de chéad, agus taistealaíonn an t-innéacs tosaigh de gach baisc leis an tasc ionas gur féidir le as_completed, a fhilltorthaí as ord, iad a chur ina n-áit i gceart fós.

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]]:
    """Gin leabaithe go comhthreomhar le seimeafar."""
    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)
            ]

    # Roinn i mbaisc de 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

# Úsáid
embeddings = asyncio.run(
    generate_embeddings_async(my_texts, max_concurrent=3)
)

Stóráil a Bharrfheabhsú

Ansin tá an bille bonneagair. Glacann deich míle veicteoir de 3,072 toise i float32 thart ar 122 MB; glacann milliún dhá ghigibheart déag, ar gá iad a choinneáil sa chuimhne chun go bhfanfadh an cuardach tapa. Mapálann candamú go int8 gach comhordanáid go 256 luach slánuimhriúil, ag roinnt an lorgchoise faoi cheathair go dtí thart ar 30 MB san sampla thíos. Tá an chaillteanas cruinnis ann ach fanann sé imeallach i gcomparáid leis na bearnaí cosúlachta a bhfuil tú ag obair leo.

import numpy as np

def quantize_int8(embeddings: np.ndarray) -> tuple:
    """Candamaigh leabaithe go int8 (4x níos lú cuimhne)."""
    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):
    """Athchóirigh leabaithe ó int8."""
    return quantized.astype(np.float32) * scale + min_val

# Comparáid méide
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

Mar sin féin, is é an luamhán is simplí fós paraiméadar dimensions an API, a tháirgeann veicteoirí níos giorra go díreach gan aon iar-phróiseáil ar do chuidse: meáchan 3,072 toise thart ar 24 KB in aghaidh an veicteora, titann 1,024 toise go 8 KB, agus 256 toise go 2 KB.

# 3072 toise -> ~24 KB in aghaidh an veicteora
# 1024 toise -> ~8 KB in aghaidh an veicteora  (laghdú API)
# 256 toise  -> ~2 KB in aghaidh an veicteora  (laghdú API)

response = client.embeddings.create(
    input="text",
    model="text-embedding-3-large",
    dimensions=1024  # 3x níos lú stórála
)

Ailtireacht Léirithe

Nuair a chuirtear na píosaí seo le chéile, faigheann tú píblíne lean: caisé Redis os a chomhair, cliant láidir do na glaochanna a théann tríd ar aon nós. Glacann an t-ionghabháil an bealach baisce, caiséálann an cuardach fiú an leabaithe ceiste – agus níl an pointe deireanach sin suarach, toisc go n-athraíonn ceisteanna úsáideoirí i bhfad níos minice ná mar a shamhlófá.

class ProductionPipeline:
    """Píblíne RAG barrfheabhsaithe do léiriú."""

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

    def ingest(self, documents: list[dict]):
        """Ionghabháil le caisé agus athiarracht."""
        texts = [d["text"] for d in documents]
        embeddings = self.cache.get_embeddings_batch(texts)
        # Stóráil i mbunachar sonraí veicteora...

    def search(self, query: str, k: int = 5):
        """Cuardach le caiséáil ceiste."""
        query_emb = self.cache.get_embedding(query)
        # Cuardach i mbunachar sonraí veicteora...
        return query_emb

Seicliosta Léirithe

EilimintCur síos
Caisé RedisLaghdaigh glaochanna API agus moill
Athiarracht EaspónantúilLáimhseáil teorainneacha ráta go réidh
MonatóireachtRianaigh ráta buailte caisé, moill, earráidí
Próiseáil BaiscePróiseáil toirteanna móra i mbaisc asincronacha
CandamúLaghdaigh stóráil faoi 4x le int8
Laghdú ToiseÚsáid 1024 nó 512 toise má cheadaíonn cáilíocht
CúltacaDéan cúltaca de leabaithe agus meiteashonraí go rialta
FoláirimhTabhair foláireamh ar earráidí API agus díghrádú feidhmíochta

Ní tháirgeann dhá líne sa tábla seo aon bhuachan feidhmíochta fós ach is iad an dá cheann is tábhachtaí. Is é monatóireacht an ráta buailte caisé do tháscaire sláinte eacnamaíoch: má thiteann sé, triplaíonn do bhille sula dtugann aon duine faoi deara é. Agus sábhálann cúltaca leabaithe thú, ar lá teagmhais, ón ngá atá le híoc arís agus fanacht arís ar ionchódú iomlán an chorpuis.

Príomhphointí

  • Laghdaíonn caisé Redis costais agus moill faoi 90%+
  • Láimhseálann athiarracht easpónantúil teorainneacha ráta OpenAI
  • Luasaíonn próiseáil asincronach ionghabháil corpas mór
  • Laghdaíonn candamú int8 stóráil faoi 4x
  • Is é laghdú toise ag an API an luamhán is simplí

Tástáil do Chuid Eolais

Fiche dhá cheacht ar leabaithe agus RAG: oireann na bunriachtanais i gcúig cheist.

1. Cad a ghabhann leabaithe, agus conas a dhéanaimid comparáid idir dhá théacs?

Freagra: Veicteoir a chódálann brí: tá veicteoirí gar ag dhá théacs atá gar i mbrí – tomhaiseann cosúlacht chomhshíneas an gaireacht seo, beag beann ar na focail bheacha a úsáideadh.

2. Cén fáth cuardach seimeantach agus léicsiceach a chomhcheangal?

Freagra: Tuigeann seimeantach athfhoirmliúcháin ach cailleann sé téarmaí beachta (tagairtí, aitheantóirí); déanann léicsiceach an rud contrártha – clúdaíonn an hibrideach an dá phointe dall agus cumaisc de réir céime.

3. Cad é ról an scoilte (chunking) i gcáilíocht RAG?

Freagra: Cinntitheach: táirgeann deighleoga a urramaíonn teorainneacha smaointe cuardach cruinn; cruthaíonn gearrthacha treallacha blúirí neamhiomlána – agus oidhreachtann an phíblíne iomlán é seo.

4. Cuardach Comhtháite Comhad nó RAG saincheaptha: conas roghnú?

Freagra: Cuardach Comhad chun bogadh go tapa le píblíne bhainistithe (scoilte agus rangú comhtháite); RAG saincheaptha nuair is gá duit smacht a bheith agat ar scoilteadh, innéacsanna, athrangú, nó foinsí iolracha.

5. Thar cuardach, ainmnigh dhá úsáid do leabaithe.

Freagra: Aicmiú agus braislí (téacsanna cosúla a ghrúpáil go huathoibríoch), moltaí pearsantaithe, nó brath ar ainrialtachtaí agus ar dhúblacháin – an veicteoir céanna, fadanna éagsúla.

Is é snáithe an chúrsa: éiríonn brí intomhaiste – ní feidhmchláir ach cuardach, rangú, moladh. Déanann léiriú (scálú, caiséáil) an chuid eile.