Embedding modely — srovnání pro produkci

Embedding modely jsou klíčové pro moderní AI aplikace, ale výběr toho správného pro produkci může být složitý. Porovnáváme nejpopulárnější modely z hlediska výkonnosti, rychlosti, nákladů a kvality pro různé použití.

Embedding modely v produkci: praktické srovnání¶

Výběr správného embedding modelu pro produkční nasazení je kritické rozhodnutí, které ovlivňuje kvalitu vašeho RAG systému i celkové náklady. V tomto článku porovnáme nejpoužívanější modely z pohledu výkonu, nákladů a praktického nasazení.

Klíčová kritéria pro výběr¶

Před srovnáním konkrétních modelů je důležité definovat, co hodnotíme:

Kvalita embeddingů: MTEB skóre, schopnost zachytit sémantiku
Rychlost inference: latence a throughput v produkci
Náklady: cena za token nebo časová jednotka
Integrace: API dostupnost, self-hosting možnosti
Multijazyčnost: podpora češtiny a dalších jazyků

Přehled hlavních kandidátů¶

OpenAI text-embedding-3-large¶

Aktuálně nejkvalitnější komerční embedding model s výjimečným výkonem na MTEB benchmarku (skóre 64.6).

import openai

client = openai.OpenAI(api_key="your-key")

response = client.embeddings.create(
    model="text-embedding-3-large",
    input=["Dokumentace API pro platební bránu", "Technická specifikace systému"],
    dimensions=1536  # Lze snížit pro úsporu nákladů
)

embeddings = [data.embedding for data in response.data]
print(f"Rozměr vektoru: {len(embeddings[0])}")

Výhody: Špičková kvalita, stabilní API, podpora dimenzionality. Nevýhody: Vyšší náklady ($0.13/1M tokenů), závislost na externím API.

Sentence-BERT modely¶

Open-source alternativa s možností self-hostingu. Model all-MiniLM-L6-v2 nabízí dobrý poměr výkon/rychlost.

from sentence_transformers import SentenceTransformer
import numpy as np

# Lokální model - jednorázové stažení
model = SentenceTransformer('all-MiniLM-L6-v2')

texts = [
    "Implementace microservices architektury",
    "Návrh distribuované databáze",
    "Optimalizace výkonu aplikace"
]

embeddings = model.encode(texts)
print(f"Shape: {embeddings.shape}")

# Výpočet podobnosti
similarity = np.dot(embeddings[0], embeddings[1])
print(f"Podobnost: {similarity:.3f}")

Výhody: Žádné API náklady, plná kontrola, rychlá inference. Nevýhody: Nižší kvalita než top komerční modely, omezená podpora češtiny.

Cohere Embed v3¶

Specializovaný embedding model s pokročilou kompresí a multijazyčností.

import cohere

co = cohere.Client("your-api-key")

response = co.embed(
    texts=["Databázový design", "Architektura systému"],
    model="embed-multilingual-v3.0",
    input_type="search_document",  # nebo "search_query"
    embedding_types=["float", "int8"]  # Komprese pro úsporu místa
)

# Float embeddings pro maximální přesnost
float_embeddings = response.embeddings.float_

# Int8 embeddings pro úsporu paměti (4x menší)
compressed_embeddings = response.embeddings.int8

Výhody: Dobrá multijazyčnost, kompresní možnosti, rychlé API. Nevýhody: Středně vysoké náklady ($0.1/1M tokenů).

Praktické testování kvality¶

Pro validaci kvality na vašich datech doporučuji tento přístup:

import pandas as pd
from sklearn.metrics.pairwise import cosine_similarity

def evaluate_embeddings(model_func, test_pairs):
    """
    test_pairs: List of tuples (text1, text2, expected_similarity)
    """
    results = []

    for text1, text2, expected in test_pairs:
        emb1 = model_func(text1)
        emb2 = model_func(text2)

        actual = cosine_similarity([emb1], [emb2])[0][0]
        results.append({
            'text1': text1,
            'text2': text2,
            'expected': expected,
            'actual': actual,
            'diff': abs(expected - actual)
        })

    return pd.DataFrame(results)

# Testovací data specifická pro vaši doménu
test_data = [
    ("REST API dokumentace", "API reference guide", 0.8),
    ("Databázová migrace", "Schéma databáze", 0.6),
    ("Frontend komponenty", "Backend služby", 0.3)
]

# Porovnání modelů
results_openai = evaluate_embeddings(openai_embed_func, test_data)
results_sbert = evaluate_embeddings(sbert_embed_func, test_data)

Optimalizace nákladů a výkonu¶

Pro produkční nasazení je klíčová optimalizace:

Caching embeddingů¶

import redis
import hashlib
import json

class EmbeddingCache:
    def __init__(self, redis_client, model_name):
        self.redis = redis_client
        self.model_name = model_name
        self.ttl = 86400 * 7  # 7 dní

    def _get_key(self, text):
        text_hash = hashlib.md5(text.encode()).hexdigest()
        return f"emb:{self.model_name}:{text_hash}"

    def get_embedding(self, text, embed_func):
        key = self._get_key(text)
        cached = self.redis.get(key)

        if cached:
            return json.loads(cached)

        # Cache miss - počítáme embedding
        embedding = embed_func(text)
        self.redis.setex(key, self.ttl, json.dumps(embedding))
        return embedding

# Použití
cache = EmbeddingCache(redis_client, "text-embedding-3-large")
embedding = cache.get_embedding(document_text, openai_embed_func)

Batch processing¶

Pro větší objemy dat využívejte batch zpracování:

def batch_embed_documents(documents, batch_size=100):
    """Efektivní zpracování velkých objemů dokumentů"""
    embeddings = []

    for i in range(0, len(documents), batch_size):
        batch = documents[i:i + batch_size]

        # OpenAI API podporuje batch requesty
        response = client.embeddings.create(
            model="text-embedding-3-large",
            input=batch
        )

        batch_embeddings = [data.embedding for data in response.data]
        embeddings.extend(batch_embeddings)

        # Rate limiting
        time.sleep(0.1)

    return embeddings

Doporučení pro různé use cases¶

Vysoká kvalita, střední objem: OpenAI text-embedding-3-large s cachingem

Velký objem, kontrola nákladů: Self-hosted Sentence-BERT nebo multilingual-e5-large

Multijazyčnost: Cohere Embed v3 nebo mBERT varianta

Real-time aplikace: Lokální model s GPU akcelerací

Implementace A/B testování¶

class EmbeddingABTest:
    def __init__(self, model_a, model_b, split_ratio=0.5):
        self.model_a = model_a
        self.model_b = model_b
        self.split_ratio = split_ratio
        self.metrics = {'a': [], 'b': []}

    def get_embedding(self, text, user_id):
        # Konzistentní rozdělení podle user_id
        use_a = hash(user_id) % 100 < (self.split_ratio * 100)

        if use_a:
            result = self.model_a.embed(text)
            variant = 'a'
        else:
            result = self.model_b.embed(text)
            variant = 'b'

        return result, variant

    def log_retrieval_quality(self, variant, relevance_score):
        """Logování kvality pro vyhodnocení testu"""
        self.metrics[variant].append(relevance_score)

Shrnutí¶

Výběr embedding modelu závisí na specifických požadavcích vašeho projektu. OpenAI text-embedding-3-large nabízí nejlepší kvalitu pro kritické aplikace, zatímco open-source alternativy jako Sentence-BERT poskytují kontrolu nad náklady a daty. Klíčové je testování na vlastních datech a implementace metriky pro kontinuální vyhodnocování kvality. Nezapomeňte na caching a batch processing pro optimalizaci výkonu v produkci.

embeddingssrovnánírag