Μετάβαση στο κύριο περιεχόμενο
Ελληνικά— Επιλέξτε γλώσσα
Μενού

Παραγωγή: Κλιμάκωση και Caching

Μάθημα 22 / 22 Ενημερώθηκε 29 Ιουλίου 2026 Για developers
Σε αυτήν τη σελίδα
  1. Στόχοι
  2. Προκλήσεις στην Παραγωγή
  3. Caching των Embeddings
  4. Διαχείριση των Ορίων Ρυθμού (Rate Limits)
  5. Ασύγχρονη Επεξεργασία
  6. Βελτιστοποίηση Αποθήκευσης
  7. Αρχιτεκτονική Παραγωγής
  8. Λίστα Ελέγχου Παραγωγής
  9. Βασικά σημεία
  10. Δοκιμάστε τις Γνώσεις σας

Στόχοι

  • Βελτιστοποίηση της απόδοσης ενός συστήματος embeddings σε περιβάλλον παραγωγής
  • Υλοποίηση caching για μείωση του κόστους και του λανθάνοντος χρόνου (latency)
  • Διαχείριση της κλιμάκωσης και της υψηλής διαθεσιμότητας

Προκλήσεις στην Παραγωγή

Κατά τη διάρκεια της ανάπτυξης, η κλήση του API της OpenAI για κάθε αίτημα δεν αποτελεί πρόβλημα: μπορεί να κάνετε δέκα κλήσεις την ημέρα. Στην παραγωγή, ο ίδιος κώδικας προσκρούει ταυτόχρονα σε τρεις τοίχους. Πρώτον, το κόστος: κάθε κλήση χρεώνεται και μια πλήρης επανευρετηρίαση ενός σώματος κειμένων πληρώνεται εξ ολοκλήρου κάθε φορά που εκτελείται. Δεύτερον, ο λανθάνων χρόνος (latency): ένας γύρος δικτύου 100 έως 300 ms ανά αίτημα προστίθεται στον χρόνο αναζήτησης και παραγωγής, και ο χρήστης αισθάνεται το άθροισμα και των τριών. Τέλος, τα όρια ρυθμού (rate limits): η OpenAI περιορίζει τον αριθμό των κλήσεων ανά λεπτό—ένα όριο που δεν θα δείτε ποτέ στην ανάπτυξη, αλλά θα το συναντήσετε την ημέρα της κυκλοφορίας.

Και τα τρία προβλήματα έχουν σε μεγάλο βαθμό την ίδια λύση: μην καλείτε το API όταν δεν είναι απαραίτητο.

Caching των Embeddings

Ένα embedding είναι ντετερμινιστικό: το ίδιο κείμενο με το ίδιο μοντέλο επιστρέφει πάντα το ίδιο διάνυσμα. Αυτό καθιστά το caching εξαιρετικά αποτελεσματικό εδώ, πολύ περισσότερο από ό,τι για ένα generative LLM. Για μια εφαρμογή με μέτρια κίνηση, ο διακοσμητής lru_cache της τυπικής βιβλιοθήκης είναι επαρκής και απαιτεί μόνο δύο γραμμές. Η τιμή επιστροφής μετατρέπεται σε tuple επειδή το lru_cache απαιτεί hashable τιμές· αυτή είναι η μόνη ιδιαιτερότητα που πρέπει να γνωρίζετε.

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

Αυτή η μνήμη cache εξαφανίζεται με οποιαδήποτε επανεκκίνηση και δεν κοινοποιείται μεταξύ διεργασιών: μόλις εκτελέσετε δύο instances πίσω από έναν load balancer, το καθένα ξαναχτίζει τη δική του. Το Redis λύνει και τα δύο προβλήματα. Το κλειδί είναι ένα hash του ζεύγους μοντέλου-κειμένου, το οποίο αποτρέπει την εξυπηρέτηση παλιών διανυσμάτων σε περίπτωση αλλαγής του μοντέλου, και ένα TTL τριάντα ημερών περιορίζει την ανάπτυξη του αποθηκευτικού χώρου.

Η μέθοδος get_embeddings_batch αξίζει ιδιαίτερη προσοχή, καθώς είναι αυτή που κάνει τη διαφορά κατά την εισαγωγή δεδομένων (ingestion). Δεν ελέγχει απλώς τη μνήμη cache κείμενο προς κείμενο: διαχωρίζει τις αστοχίες (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")

Διαχείριση των Ορίων Ρυθμού (Rate Limits)

Το caching μειώνει την κίνηση αλλά δεν την εξαλείφει, και μια αιχμή κίνησης θα προκαλέσει τελικά ένα RateLimitError. Η σωστή αντίδραση δεν είναι η άμεση επανάληψη—which worsens congestion—but η αναμονή, διπλασιάζοντας την καθυστέρηση κάθε φορά: ένα δευτερόλεπτο, δύο, τέσσερα, οκτώ, δεκαέξι. Πέντε προσπάθειες καλύπτουν έτσι περίπου τριάντα δευτερόλεπτα, κάτι που απορροφά τη συντριπτική πλειοψηφία των προσωρινών αιχμών, και η τελική προσπάθεια επαναδημιουργεί την εξαίρεση ώστε το συμβάν να αναφέρεται αντί να καταπίνεται σιωπηλά.

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), το σημείο συμφόρησης δεν είναι ο υπολογισμός αλλά η αναμονή δικτύου: το πρόγραμμά σας περνά το μεγαλύτερο μέρος του χρόνου του χωρίς να κάνει τίποτα. Η ασύγχρονη επεξεργασία σάς επιτρέπει να διατηρείτε πολλαπλά αιτήματα σε εξέλιξη. Το semaphore περιορίζει σκόπιμα αυτόν τον παραλληλισμό, επειδή η εκκίνηση εκατό ταυτόχρονων κλήσεων ενεργοποιεί μόνο τα όρια ρυθμού που μόλις μάθατε να διαχειρίζεστε—τρεις έως πέντε ταυτόχρονες αιτήσεις είναι μια υγιής ρύθμιση. Τα κείμενα χωρίζονται πρώτα σε παρτίδες των εκατό, και το αρχικό ευρετήριο κάθε παρτίδας ταξιδεύει με την εργασία ώστε το as_completed, το οποίο επιστρέφει αποτελέσματα εκτός σειράς, να μπορεί nonetheless να τα τοποθετήσει σωστά.

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)
)

Βελτιστοποίηση Αποθήκευσης

Στη συνέχεια υπάρχει ο λογαριασμός των υποδομών. Δέκα χιλιάδες διανύσματα 3.072 διαστάσεων σε float32 καταλαμβάνουν περίπου 122 MB· ένα εκατομμύριο καταλαμβάνει δώδεκα gigabytes, τα οποία πρέπει να διατηρούνται στη μνήμη για να παραμείνει γρήγορη η αναζήτηση. Η κβάντωση σε 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, η οποία παράγει απευθείας μικρότερα διανύσματα χωρίς καμία μετα-επεξεργασία εκ μέρους σας: 3.072 διαστάσεις ζυγίζουν περίπου 24 KB ανά διάνυσμα, 1.024 διαστάσεις πέφτουν στα 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
)

Αρχιτεκτονική Παραγωγής

Συναρμολογημένα, αυτά τα κομμάτια δίνουν μια λιτή ροή: μνήμη cache Redis μπροστά, robust client για τις κλήσεις που περνούν ούτως ή άλλως. Η εισαγωγή ακολουθεί τη διαδρομή των παρτίδων, η αναζήτηση κάνει cache ακόμη και στο embedding του ερωτήματος—και αυτό το τελευταίο σημείο δεν είναι τετριμμένο, επειδή τα ερωτήματα των χρηστών επαναλαμβάνονται πολύ περισσότερο από όσο φαντάζεστε.

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)Καταγραφή ποσοστού επιτυχίας cache, λανθάνοντος χρόνου, σφαλμάτων
Επεξεργασία ΠαρτίδωνΕπεξεργασία μεγάλων όγκων σε ασύγχρονες παρτίδες
ΚβάντωσηΜείωση αποθήκευσης κατά 4x με int8
Μείωση ΔιαστάσεωνΧρήση 1024 ή 512 διαστάσεων εάν η ποιότητα το επιτρέπει
Αντίγραφο ΑσφαλείαςΤακτικά αντίγραφα ασφαλείας των embeddings και των μεταδεδομένων
ΕιδοποιήσειςΕιδοποίηση για σφάλματα API και υποβάθμιση απόδοσης

Δύο γραμμές σε αυτόν τον πίνακα δεν παράγουν κέρδος απόδοσης, αλλά είναι οι πιο σημαντικές. Η παρακολούθηση του ποσοστού επιτυχίας της μνήμης cache είναι ο δείκτης οικονομικής υγείας σας: εάν καταρρεύσει, ο λογαριασμός σας τριπλασιάζεται πριν το αντιληφθεί κανείς. Και η δημιουργία αντιγράφων ασφαλείας των embeddings σάς γλιτώνει, την ημέρα ενός περιστατικού, από το να χρειαστεί να πληρώσετε ξανά και να περιμένετε την πλήρη κωδικοποίηση του σώματος κειμένων.

Βασικά σημεία

  • Η μνήμη cache Redis μειώνει το κόστος και τον λανθάνοντα χρόνο κατά πάνω από 90%
  • Η εκθετική επανάληψη διαχειρίζεται τα όρια ρυθμού της OpenAI
  • Η ασύγχρονη επεξεργασία επιταχύνει την εισαγωγή μεγάλων σωμάτων κειμένων
  • Η κβάντωση int8 μειώνει την αποθήκευση κατά 4 φορές
  • Η μείωση διαστάσεων στο API είναι ο απλούστερος μοχλός

Δοκιμάστε τις Γνώσεις σας

Είκοσι δύο μαθήματα για embeddings και RAG: τα βασικά χωρούν σε πέντε ερωτήσεις.

1. Τι αποτυπώνει ένα embedding και πώς συγκρίνουμε δύο κείμενα;

Απάντηση: Ένα διάνυσμα που κωδικοποιεί το νόημα: δύο κείμενα κοντά στο νόημα έχουν κοντινά διανύσματα—η ομοιότητα συνημιτόνου (cosine similarity) μετρά αυτή την εγγύτητα, ανεξάρτητα από τις ακριβείς λέξεις που χρησιμοποιούνται.

2. Γιατί συνδυάζουμε την σημασιολογική και τη λεκτική αναζήτηση;

Απάντηση: Η σημασιολογική κατανοεί τις διατυπώσεις αλλά χάνει τους ακριβείς όρους (αναφορές, αναγνωριστικά)· η λεκτική κάνει το αντίθετο—η υβριδική καλύπτει και τα δύο τυφλά σημεία και συγχωνεύεται κατά βαθμολογία.

3. Ποιος είναι ο ρόλος του chunking στην ποιότητα του RAG;

Απάντηση: Αποφασιστικός: τα τμήματα που σέβονται τα όρια των ιδεών παράγουν ακριβή αναζήτηση· οι αυθαίρετες τομές δημιουργούν ελλιπή αποσπάσματα—και ολόκληρη η ροή κληρονομεί αυτό το πρόβλημα.

4. Ενσωματωμένη Αναζήτηση Αρχείων ή προσαρμοσμένο RAG: πώς να επιλέξετε;

Απάντηση: Αναζήτηση Αρχείων για γρήγορη κίνηση με μια διαχειριζόμενη ροή (ενσωματωμένο chunking και ranking)· προσαρμοσμένο RAG όταν χρειάζεται να ελέγξετε τη διαίρεση, τα ευρετήρια, την επαναβαθμολόγηση (reranking) ή πολλαπλές πηγές.

5. Πέρα από την αναζήτηση, ονομάστε δύο χρήσεις για τα embeddings.

Απάντηση: Ταξινόμηση και ομαδοποίηση (αυτόματη ομαδοποίηση παρόμοιων κειμένων), προσωποποιημένες προτάσεις, ή ανίχνευση ανωμαλιών και διπλοτύπων—ίδιο διάνυσμα, διαφορετικές αποστάσεις.

Το νήμα του μαθήματος: το νόημα γίνεται μετρήσιμο—η αναζήτηση, η κατάταξη, η σύσταση είναι απλώς εφαρμογές. Η παραγωγή (κλιμάκωση, caching) κάνει τα υπόλοιπα.