LLM Embeddings Anlama: Vector Representations Rehberi

Embedding = text → vector. Semantic similarity ölçen sayısal temsil. RAG, search, recommendation, classification — hepsinin altı.

Embedding Nedir?

"Vector representation:

Text: 'Kedi sevimli bir hayvandır'
Embedding: [0.012, -0.34, 0.78, ..., 0.45]  # 1536 numbers

Properties:
- Aynı anlamlı text → benzer vector
- 'Köpek sevimli bir hayvandır' → çok yakın
- 'Pizza lezzetli' → çok uzak

Similarity ölçme:
- Cosine: -1 to 1 (1 = aynı yön)
- Dot product
- Euclidean distance (L2)

Default: Cosine
"

Embedding Modelleri

Model	Provider	Dim	Fiyat	TR
text-embedding-3-small	OpenAI	1536	$0.02/M	✅
text-embedding-3-large	OpenAI	3072	$0.13/M	✅
BGE-large-en-v1.5	BAAI (open)	1024	Free	❌
BGE-multilingual	BAAI	1024	Free	✅
voyage-3	Voyage	1024	$0.06/M	✅
Cohere embed-english-v3	Cohere	1024	$0.10/M	❌
Cohere embed-multilingual-v3	Cohere	1024	$0.10/M	✅
multilingual-e5-large	Microsoft (open)	1024	Free	✅
Mistral-embed	Mistral	1024	$0.10/M	✅

OpenAI

from openai import OpenAI

client = OpenAI()

response = client.embeddings.create(
    input="Hello world",
    model="text-embedding-3-small"
)

embedding = response.data[0].embedding
# [0.012, -0.34, ...] 1536 floats

# Batch
response = client.embeddings.create(
    input=["text 1", "text 2", "text 3"],
    model="text-embedding-3-large"
)

Cosine Similarity

import numpy as np

def cosine_similarity(a, b):
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))

# Or
from sklearn.metrics.pairwise import cosine_similarity

similarity = cosine_similarity([emb1], [emb2])[0][0]

Use Case 1: Semantic Search

"""
RAG'in temel pattern:

1. Embed all docs (one-time)
2. Embed query (per search)
3. Cosine similarity all docs
4. Return top K
"""

docs = ["text 1", "text 2", ...]
doc_embs = [embed(d) for d in docs]

query = "search query"
query_emb = embed(query)

# Sıralama
similarities = [cosine(query_emb, e) for e in doc_embs]
top_k = sorted(zip(docs, similarities), key=lambda x: x[1], reverse=True)[:5]

Production: vector DB kullan.

Detay: Vector Database

Use Case 2: Clustering

from sklearn.cluster import KMeans

texts = [...]  # 1000 texts
embeddings = [embed(t) for t in texts]

kmeans = KMeans(n_clusters=10)
clusters = kmeans.fit_predict(embeddings)

# Cluster 0: tech topics
# Cluster 1: sports
# ...

Müşteri yorumları kategorize et, otomatik.

Use Case 3: Classification

# K-NN classifier
from sklearn.neighbors import KNeighborsClassifier

X_train = [embed(t) for t in train_texts]
y_train = train_labels

knn = KNeighborsClassifier(n_neighbors=5)
knn.fit(X_train, y_train)

# Predict
test_emb = embed(new_text)
prediction = knn.predict([test_emb])

Embedding + KNN = simple but effective classifier (few-shot).

Use Case 4: Recommendation

"""
Item-item recommendation:

1. Embed all items
2. User likes item X
3. Recommend nearest neighbors
"""

items = [...]
item_embs = [embed(i) for i in items]

# User liked item 5
liked_emb = item_embs[5]
similarities = [cosine(liked_emb, e) for e in item_embs]
recommendations = sorted(...)[:10]

Use Case 5: Deduplication

"""
Find duplicate/similar content:
"""

threshold = 0.95  # very similar

for i, emb1 in enumerate(embeddings):
    for j, emb2 in enumerate(embeddings[i+1:], i+1):
        sim = cosine(emb1, emb2)
        if sim > threshold:
            print(f"Duplicate: {docs[i]} ~= {docs[j]}")

Use Case 6: Anomaly Detection

"""
Outlier text detection:
"""

mean_emb = np.mean(embeddings, axis=0)

distances = [cosine(mean_emb, e) for e in embeddings]
outliers = [i for i, d in enumerate(distances) if d < 0.5]

Open Source Models

from sentence_transformers import SentenceTransformer

# BGE
model = SentenceTransformer("BAAI/bge-large-en-v1.5")

# Multilingual
model = SentenceTransformer("intfloat/multilingual-e5-large")

# Türkçe specifically
# model = SentenceTransformer("dbmdz/bert-base-turkish-cased")

embeddings = model.encode(["text 1", "text 2"])

Detay: Hugging Face

Matryoshka Embeddings

"OpenAI text-3-large + others:

Single model multiple dimensions:
- 3072 (full)
- 1024 (truncated)
- 512 (more truncated)
- 256

Same model, just slice
Smaller = faster + cheaper
Larger = better accuracy

Use case:
- Storage budget tight: 512
- Accuracy critical: 3072
- Hybrid (binary search + rerank)
"

Specialty Embeddings

Code

# Voyage code embedding
voyage_client.embed(
    texts=["def hello():\n    print('hi')"],
    model="voyage-code-2"
)

# Specific for code search, similarity

Image

# CLIP (OpenAI)
from transformers import CLIPProcessor, CLIPModel

model = CLIPModel.from_pretrained("openai/clip-vit-base-patch32")
processor = CLIPProcessor.from_pretrained("openai/clip-vit-base-patch32")

# Image embed
image = Image.open("cat.jpg")
inputs = processor(images=image, return_tensors="pt")
image_emb = model.get_image_features(**inputs)

# Text embed (same space)
text_inputs = processor(text="a cat", return_tensors="pt")
text_emb = model.get_text_features(**text_inputs)

# Compare image ↔ text!

Multi-modal: text and image in same vector space.

Performance Tips

"Production optimization:

1. Batch embedding:
   - 1 request, 100 texts
   - vs 100 requests
   - 10x cheaper, 5x faster

2. Cache:
   - Same text twice = no re-embed
   - Hash → DB store
   - Save cost

3. Async:
   - Background embed
   - Pre-compute when create

4. Quantize:
   - int8 instead of float32
   - 4x storage save
   - Minimal accuracy loss

5. Smaller model:
   - 768 dim vs 3072
   - Use case dependent
"

Cost Comparison

"1M document embed:

Average doc: 200 token

OpenAI text-3-small:
- 200M token × $0.02/M = $4

OpenAI text-3-large:
- 200M × $0.13/M = $26

Cohere:
- 200M × $0.10/M = $20

Voyage:
- 200M × $0.06/M = $12

Open source (self-host):
- GPU rent: $5-50
- Time: depends scale
- Or: free local
"

Embedding Update Strategy

"Model improves over time:

When new model released:
- Test on benchmark
- If improvement significant: migrate

Migration:
1. Embed dataset with new model
2. Index update gradual
3. Switch query model
4. Drop old

Cost:
- 10M doc, $20-100 (depends model)
- Worth it if quality matters
"

Türkçe Performance

"TR embedding benchmark:

Best general (TR text):
- multilingual-e5-large (free, GitHub) ⭐
- Cohere multilingual-v3
- text-embedding-3-large (OpenAI)
- Mistral-embed

TR-specific fine-tunes:
- Cosmos / T3-AI
- Trendyol/Trendyol-LLM-base
- ytu-ce-cosmos models

Test on:
- TR semantic similarity benchmark
- Real use case (your data)
- Compare retrievals manually
"

Evaluation

"How to choose embedding:

MTEB leaderboard (huggingface.co/spaces/mteb/leaderboard):
- 50+ tasks
- Retrieval, classification, clustering
- Multilingual scores

For RAG:
- Retrieval task focus
- Recall@10 metric
- Domain-specific test set

Test:
- Sample 100 queries
- Manual annotate relevant docs
- Embed both
- Measure recall + precision
"

Yaygın Hatalar

1. Different model query vs doc: Incompatible
2. No normalization: Magnitude bias
3. Wrong distance: L2 when cosine appropriate
4. No filtering: Bypass metadata
5. Stale embeddings: Model updated, didn’t re-embed
6. Too small dimension: Quality loss
7. No caching: Cost explode

Sonraki Adımlar

• Vector Database
• RAG Rehberi
• Hugging Face
• Fine-Tuning
• LangChain Agent

Özet

Embedding = text → vector → similarity. RAG, search, classification, clustering. OpenAI text-3-large (general), BGE / e5 (open), Cohere (multilingual). Anahtar: model seçim domain’e göre, MTEB check, cost optimization, query+doc same model.