"AI mühendisi" ilanlarının sayısı son iki yılda katlanarak arttı. Ancak mülakat masasında karşılaşılan gerçek şu: Şirketler openai.chat.completions.create() çağırabilen birini değil, o çağrının etrafındaki sistemi kurabilen birini arıyor. Vektör araması neden yavaşladı? Model neden aynı cümleyi tekrar ediyor? Türkçe metin neden İngilizceden daha pahalıya geliyor? RAG neden alakasız doküman getiriyor?

Bu soruların hepsinin cevabı, kütüphanelerin arkasında sessizce çalışan birkaç temel algoritmada saklı. Bu rehberde LLM, RAG ve vektör arama sistemlerinin omurgasını oluşturan 10 algoritmayı harici kütüphane kullanmadan, saf Python ile yazıyoruz. Her bölümde algoritmanın AI sistemindeki yerini, çalışan kodunu, karmaşıklığını ve mülakatta karşınıza çıkabilecek takip sorusunu bulacaksınız.

Neden saf Python? Üretimde elbette NumPy, FAISS veya Hugging Face kullanacaksınız. Ama mülakatta "bunu kütüphanesiz yaz" dendiğinde mekanizmayı bilen aday ile API ezberleyen aday anında ayrışır.


Hızlı Bakış: 10 Algoritma ve AI Sistemindeki Yeri

# Algoritma AI Sistemindeki Rolü Karmaşıklık
1 Kosinüs Benzerliği Embedding karşılaştırma O(d)
2 Heap ile Top-K Vektör aramada en yakın K sonuç O(n log k)
3 Kararlı Softmax + Top-p LLM token örnekleme O(V log V)
4 BPE Tokenizasyon Metni token'a çevirme O(m · n)
5 Örtüşmeli Pencere Chunking RAG doküman parçalama O(n)
6 BM25 Anahtar kelime tabanlı arama O(N · q)
7 Reciprocal Rank Fusion Hibrit arama birleştirme O(Σ L)
8 Beam Search Dizi üretimi / decoding O(T · B · V)
9 Gradyan İnişi Model eğitimi O(E · n · d)
10 K-Means (IVF) Vektör indeksleme O(I · n · k · d)

1. Kosinüs Benzerliği (Cosine Similarity)

Her RAG sisteminin kalbi şudur: Kullanıcının sorusu bir vektöre (embedding) dönüştürülür ve doküman vektörleriyle karşılaştırılır. Bu karşılaştırmanın standart ölçüsü kosinüs benzerliğidir: İki vektörün büyüklüğünden bağımsız olarak, aralarındaki açıyı ölçer.

import math

def dot(a: list[float], b: list[float]) -> float:
    return sum(x * y for x, y in zip(a, b))

def norm(a: list[float]) -> float:
    return math.sqrt(dot(a, a))

def cosine_similarity(a: list[float], b: list[float]) -> float:
    na, nb = norm(a), norm(b)
    if na == 0 or nb == 0:
        return 0.0  # sıfır vektör: benzerlik tanımsız, güvenli varsayılan
    return dot(a, b) / (na * nb)

print(cosine_similarity([1, 2, 3], [2, 4, 6]))   # 1.0  (aynı yön)
print(cosine_similarity([1, 0], [0, 1]))         # 0.0  (dik)

Karmaşıklık: Boyut d için O(d).

Üretim İpucu: Vektörleri indekslerken bir kez normalize ederseniz (uzunluklarını 1 yaparsanız), sorgu anında kosinüs benzerliği basit bir iç çarpıma (dot product) dönüşür. FAISS'in IndexFlatIP ile kosinüs araması yapmasının sırrı budur.

Mülakat Sorusu: "Öklid mesafesi yerine neden kosinüs kullanıyoruz?" → Metin embedding'lerinde anlam vektörün yönünde kodlanır; uzun bir doküman daha büyük normlu bir vektör üretebilir ama anlamı değişmez. Normalize edilmiş vektörlerde ikisi aynı sıralamayı verir: ‖a − b‖² = 2 − 2·cos(a, b).


2. Heap ile Top-K Seçimi

Bir milyon doküman vektörünüz var ve en benzer 5 tanesini istiyorsunuz. Hepsini sıralamak O(n log n) maliyet demektir. Oysa boyutu K ile sınırlı bir min-heap ile bunu O(n log k)'ya indirebilirsiniz, üstelik bellekte sadece K eleman tutarak.

import heapq

def top_k(query: list[float], docs: list[tuple[str, list[float]]], k: int = 3):
    """docs: (doc_id, vektör) çiftleri. En benzer k dokümanı döndürür."""
    heap: list[tuple[float, str]] = []  # min-heap: kökte en ZAYIF aday
    for doc_id, vec in docs:
        score = cosine_similarity(query, vec)
        if len(heap) < k:
            heapq.heappush(heap, (score, doc_id))
        elif score > heap[0][0]:
            heapq.heapreplace(heap, (score, doc_id))  # en zayıfı at, yeniyi ekle
    return sorted(heap, reverse=True)

docs = [("python", [0.9, 0.1]), ("java", [0.5, 0.5]), ("yemek", [0.0, 1.0])]
print(top_k([1.0, 0.0], docs, k=2))
# [(0.99..., 'python'), (0.70..., 'java')]

Neden min-heap? Kökte her zaman "şu an elimdeki en kötü aday" durur. Yeni skor ondan iyiyse tek bir O(log k) işlemiyle değiştiririz. Bu kalıp, akan veri (streaming) üzerinde de çalışır, çünkü tüm veriyi belleğe almanız gerekmez.

Mülakat Sorusu: "10 milyar vektörde bu yine de yavaş, ne yaparsın?" → Tam (exact) aramadan yaklaşık en yakın komşu (ANN) aramasına geçilir: IVF (bkz. Algoritma 10), HNSW grafları veya Product Quantization.


3. Kararlı Softmax, Temperature ve Top-p Örnekleme

Bir LLM her adımda kelime dağarcığındaki (vocabulary) her token için ham bir skor (logit) üretir. Bu skorlar softmax ile olasılığa çevrilir ve bir sonraki token örneklenir. temperature ve top_p parametreleri tam olarak bu adımı kontrol eder.

import math
import random

def softmax(logits: list[float], temperature: float = 1.0) -> list[float]:
    if temperature <= 0:
        raise ValueError("temperature pozitif olmalı (greedy için argmax kullanın)")
    scaled = [x / temperature for x in logits]
    m = max(scaled)                          # sayısal kararlılık hilesi
    exps = [math.exp(x - m) for x in scaled]
    total = sum(exps)
    return [e / total for e in exps]

def top_p_sample(logits, p=0.9, temperature=1.0, rng=random):
    probs = softmax(logits, temperature)
    ranked = sorted(enumerate(probs), key=lambda t: t[1], reverse=True)

    nucleus, cumulative = [], 0.0
    for idx, prob in ranked:                 # olasılık kütlesi p'ye ulaşana kadar al
        nucleus.append((idx, prob))
        cumulative += prob
        if cumulative >= p:
            break

    total = sum(prob for _, prob in nucleus)  # çekirdeği yeniden normalize et
    r = rng.random() * total
    acc = 0.0
    for idx, prob in nucleus:
        acc += prob
        if r < acc:
            return idx
    return nucleus[-1][0]

logits = [2.0, 1.0, 0.1, -3.0]
print(softmax(logits, temperature=0.5))  # daha "keskin" dağılım
print(softmax(logits, temperature=2.0))  # daha "düz" dağılım

Kritik Detay: x - max. math.exp(1000) bir OverflowError fırlatır. Tüm logitlerden maksimumu çıkarmak sonucu matematiksel olarak değiştirmez (pay ve payda aynı e^-m ile çarpılır), ama en büyük üssü 0'a sabitleyerek taşmayı önler. Mülakatçılar bu satırı özellikle arar.

Mülakat Sorusu: "Temperature 0'a yaklaşınca ne olur?" → Dağılım en yüksek logite yoğunlaşır ve örnekleme greedy decoding'e (argmax) dönüşür. Bu yüzden deterministik çıktı isteyen sistemlerde temperature=0 kullanılır.


4. BPE (Byte Pair Encoding) Tokenizasyonu

GPT, Llama ve benzeri modeller metni kelimelerle değil alt kelime (subword) token'larıyla işler. Bu token'ların çoğu BPE ile öğrenilir: En sık yan yana gelen iki sembolü tekrar tekrar birleştirerek yeni bir sembol oluşturursunuz.

from collections import Counter

def get_pair_counts(ids: list[int]) -> Counter:
    return Counter(zip(ids, ids[1:]))

def merge(ids: list[int], pair: tuple[int, int], new_id: int) -> list[int]:
    out, i = [], 0
    while i < len(ids):
        if i < len(ids) - 1 and (ids[i], ids[i + 1]) == pair:
            out.append(new_id)
            i += 2
        else:
            out.append(ids[i])
            i += 1
    return out

def train_bpe(text: str, num_merges: int):
    ids = list(text.encode("utf-8"))   # başlangıç: 256 olası byte
    merges: dict[tuple[int, int], int] = {}
    for step in range(num_merges):
        counts = get_pair_counts(ids)
        if not counts:
            break
        pair = max(counts, key=counts.get)   # en sık çift
        new_id = 256 + step
        ids = merge(ids, pair, new_id)
        merges[pair] = new_id
    return merges, ids

text = "düşünüyorum düşündüm düşünce"
merges, ids = train_bpe(text, num_merges=10)
print(len(text.encode("utf-8")), "->", len(ids))  # byte sayısı -> token sayısı

Türkçe İçin Neden Önemli? ş, ü, ğ gibi karakterler UTF-8'de 2 byte yer kaplar. Ağırlıklı olarak İngilizce veriyle eğitilmiş bir tokenizer, Türkçe ekleri iyi birleştiremez; aynı anlamdaki Türkçe metin İngilizcesinden daha fazla token tutar. Bu da daha yüksek API maliyeti ve daha dar context penceresi demektir.

Mülakat Sorusu: "Kelime bazlı tokenizasyon yerine neden BPE?" → Kelime bazlı yaklaşımda sözlükte olmayan kelimeler (OOV) <UNK> olur. Byte seviyesinde başlayan BPE her metni temsil edebilir; nadir kelimeler parçalara bölünür, sık kelimeler tek token olur.


5. Örtüşmeli Kayan Pencere ile Chunking

RAG sistemlerinde bir PDF'i olduğu gibi embedding'e veremezsiniz; hem modelin token limiti vardır hem de devasa bir vektör anlamı "sulandırır". Doküman parçalara (chunk) bölünür. Ama keskin sınırlarla bölerseniz, bir cümle iki parça arasında ikiye ayrılır ve anlam kaybolur. Çözüm: örtüşme (overlap).

def chunk_tokens(tokens: list, size: int = 512, overlap: int = 64) -> list[list]:
    if not 0 <= overlap < size:
        raise ValueError("overlap, 0 ile size arasında olmalı")
    step = size - overlap
    chunks = []
    for start in range(0, len(tokens), step):
        chunks.append(tokens[start:start + size])
        if start + size >= len(tokens):   # son parça metnin sonuna ulaştı
            break
    return chunks

tokens = list(range(10))
print(chunk_tokens(tokens, size=4, overlap=1))
# [[0, 1, 2, 3], [3, 4, 5, 6], [6, 7, 8, 9]]

Karmaşıklık: O(n). Bu, PyMülakat'taki İki Gösterici ve Kayan Pencere modülündeki kalıbın birebir üretim versiyonudur.

Mülakat Sorusu: "overlap >= size olursa ne olur?" → step sıfır veya negatif olur ve döngü ya hiç ilerlemez ya da range boş döner. Bu yüzden ilk satırdaki doğrulama, sonsuz döngü/sessiz hata riskini engeller. Sınır durumlarını sorgulamak mülakatta artı puandır.


6. BM25: Anahtar Kelime Aramasının Altın Standardı

Embedding araması anlamı yakalar ama tam eşleşmede zayıftır: HTTP 429, ERR_CERT_COMMON_NAME_INVALID veya bir ürün kodu gibi terimleri kaçırabilir. Elasticsearch ve OpenSearch'ün varsayılan sıralama fonksiyonu olan BM25 burada devreye girer.

import heapq
import math
from collections import Counter

class BM25:
    def __init__(self, corpus: list[str], k1: float = 1.5, b: float = 0.75):
        self.k1, self.b = k1, b
        self.docs = [doc.lower().split() for doc in corpus]
        self.N = len(self.docs)
        self.avgdl = sum(len(d) for d in self.docs) / self.N
        self.tfs = [Counter(d) for d in self.docs]
        df = Counter(term for d in self.docs for term in set(d))
        self.idf = {
            t: math.log(1 + (self.N - n + 0.5) / (n + 0.5)) for t, n in df.items()
        }

    def score(self, query: str, i: int) -> float:
        tf, dl = self.tfs[i], len(self.docs[i])
        s = 0.0
        for term in query.lower().split():
            if term not in tf:
                continue
            f = tf[term]
            denom = f + self.k1 * (1 - self.b + self.b * dl / self.avgdl)
            s += self.idf[term] * f * (self.k1 + 1) / denom
        return s

    def search(self, query: str, k: int = 5):
        scores = [(self.score(query, i), i) for i in range(self.N)]
        return heapq.nlargest(k, scores)

bm25 = BM25([
    "python ile hız sınırlayıcı yazmak",
    "fastapi 429 too many requests hatası",
    "python generator ve yield kullanımı",
])
print(bm25.search("429 hatası", k=1))  # 2. doküman (indeks 1)

İki Parametrenin Sezgisi:

  • k1 (terim doygunluğu): Bir kelimenin 10. tekrarı, 1. tekrarı kadar değerli değildir. k1 bu azalan getiriyi kontrol eder.
  • b (uzunluk normalizasyonu): Uzun dokümanlar doğal olarak daha çok kelime içerir; b onları cezalandırarak kısa ve odaklı dokümanlara şans tanır.

Mülakat Sorusu: "TF-IDF'ten farkı ne?" → TF-IDF'te terim frekansı doğrusal büyür; BM25'te doyuma ulaşır ve doküman uzunluğuna göre normalize edilir.


7. Reciprocal Rank Fusion (RRF): Hibrit Aramanın Yapıştırıcısı

Elinizde iki sıralı liste var: biri vektör aramasından, diğeri BM25'ten. Skorları doğrudan toplayamazsınız, çünkü kosinüs skoru [-1, 1], BM25 skoru ise [0, ∞) aralığındadır. RRF skorları tamamen yok sayar ve sadece sıralamaya (rank) bakar.

from collections import defaultdict

def reciprocal_rank_fusion(rankings: list[list[str]], k: int = 60):
    scores: dict[str, float] = defaultdict(float)
    for ranking in rankings:
        for rank, doc_id in enumerate(ranking, start=1):
            scores[doc_id] += 1.0 / (k + rank)
    return sorted(scores.items(), key=lambda t: t[1], reverse=True)

vector_results = ["doc_a", "doc_b", "doc_c"]
bm25_results   = ["doc_c", "doc_a", "doc_d"]
print(reciprocal_rank_fusion([vector_results, bm25_results]))
# doc_a ve doc_c her iki listede de üst sıralarda -> en üste çıkar

k = 60 neden? Orijinal makalede (Cormack vd., 2009) deneysel olarak bulunan bu sabit, 1. sıra ile 2. sıra arasındaki farkın aşırı baskın olmasını önler. Böylece her iki listede de iyi olan dokümanlar, sadece birinde birinci olanları geçer.

Mülakat Sorusu: "Skorları min-max normalize edip toplasak olmaz mı?" → Olur, ama aykırı değerlere (outlier) karşı kırılgandır ve her sorguda dağılım değişir. RRF parametresizdir ve kalibrasyon gerektirmez.


8. Beam Search: Greedy'den Daha Akıllı Decoding

Greedy decoding her adımda en olası token'ı seçer, ama yerel olarak en iyi seçim, global olarak en iyi cümleyi garantilemez. Beam search her adımda en iyi B adayı canlı tutar.

import heapq
import math

def beam_search(step_fn, start: str, beam_width: int = 3,
                max_len: int = 10, eos: str = "<eos>"):
    """step_fn(seq) -> {token: olasılık} döndüren bir 'model'."""
    beams = [(0.0, [start])]          # (log-olasılık, dizi)
    finished = []
    for _ in range(max_len):
        candidates = []
        for logp, seq in beams:
            for token, p in step_fn(seq).items():
                if p > 0:
                    candidates.append((logp + math.log(p), seq + [token]))
        if not candidates:
            break
        beams = []
        for logp, seq in heapq.nlargest(beam_width, candidates, key=lambda c: c[0]):
            (finished if seq[-1] == eos else beams).append((logp, seq))
        if not beams:
            break
    finished.extend(beams)
    # uzunluk normalizasyonu: kısa dizilerin haksız avantajını kaldır
    return max(finished, key=lambda c: c[0] / len(c[1]))

Neden log-olasılık? 0.1 olasılığı 50 kez çarparsanız 1e-50 elde edersiniz ve float hassasiyeti çöker (underflow). Logaritma, çarpımı toplamaya çevirerek sayısal kararlılık sağlar.

Mülakat Sorusu: "ChatGPT neden beam search kullanmıyor?" → Açık uçlu sohbette beam search tekrarlı ve "sıkıcı" metin üretme eğilimindedir. Çeviri ve özetleme gibi tek doğru cevaba yakın görevlerde beam search, yaratıcı üretimde ise top-p/temperature örneklemesi (Algoritma 3) tercih edilir.


9. Gradyan İnişi (Gradient Descent)

Milyar parametreli bir transformer da, iki parametreli bir lojistik regresyon da aynı temel fikirle eğitilir: Kaybın (loss) gradyanını hesapla, ters yönde küçük bir adım at. Bunu bir kez sıfırdan yazmak, loss.backward() satırının ne yaptığını gerçekten anlamanızı sağlar.

import math

def sigmoid(z: float) -> float:
    if z >= 0:
        return 1 / (1 + math.exp(-z))
    e = math.exp(z)          # negatif z'de taşmayı önleyen form
    return e / (1 + e)

def train_logreg(X: list[list[float]], y: list[int], lr: float = 0.1, epochs: int = 200):
    w = [0.0] * len(X[0])
    b = 0.0
    n = len(X)
    for _ in range(epochs):
        gw = [0.0] * len(w)
        gb = 0.0
        for xi, yi in zip(X, y):
            pred = sigmoid(sum(wj * xj for wj, xj in zip(w, xi)) + b)
            err = pred - yi              # BCE kaybının z'ye göre türevi
            for j, xj in enumerate(xi):
                gw[j] += err * xj
            gb += err
        w = [wj - lr * g / n for wj, g in zip(w, gw)]
        b -= lr * gb / n
    return w, b

X = [[0.5], [1.5], [3.0], [4.0]]
y = [0, 0, 1, 1]
w, b = train_logreg(X, y, lr=0.5, epochs=500)
print(sigmoid(w[0] * 3.5 + b) > 0.5)  # True

Zarif Detay: Sigmoid + ikili çapraz entropi (BCE) birlikte kullanıldığında gradyan sadeleşerek tahmin − gerçek olur. Bu yüzden err = pred - yi satırı bu kadar basittir.

Mülakat Sorusu: "Learning rate çok büyükse ne olur?" → Kayıp minimumun etrafında salınır veya ıraksar (NaN). Çok küçükse eğitim aşırı yavaşlar. Üretimde Adam gibi adaptif optimizer'lar ve learning rate scheduler'lar kullanılır.


10. K-Means ve IVF İndeksleme

Algoritma 2'deki Top-K araması tüm vektörleri tarar. Milyonlarca vektörde bu kabul edilemez. IVF (Inverted File Index), vektörleri önce K-Means ile kümelere ayırır; sorgu anında sadece sorguya en yakın birkaç kümeye bakar.

import random

def squared_dist(a: list[float], b: list[float]) -> float:
    return sum((x - y) ** 2 for x, y in zip(a, b))

def kmeans(points: list[list[float]], k: int, iters: int = 20, seed: int = 42):
    rng = random.Random(seed)
    centroids = rng.sample(points, k)
    for _ in range(iters):
        clusters = [[] for _ in range(k)]
        for p in points:                              # 1) atama adımı
            idx = min(range(k), key=lambda c: squared_dist(p, centroids[c]))
            clusters[idx].append(p)
        new_centroids = []
        for c, members in enumerate(clusters):        # 2) güncelleme adımı
            if members:
                new_centroids.append([sum(dim) / len(members) for dim in zip(*members)])
            else:
                new_centroids.append(centroids[c])    # boş küme: eski merkezi koru
        if new_centroids == centroids:
            break                                     # yakınsadı
        centroids = new_centroids
    return centroids

def ivf_search(query, centroids, buckets, nprobe=2, k=3):
    """buckets[i]: i. kümeye atanmış (doc_id, vektör) listesi."""
    nearest = sorted(range(len(centroids)),
                     key=lambda c: squared_dist(query, centroids[c]))[:nprobe]
    candidates = [doc for c in nearest for doc in buckets[c]]
    return top_k(query, candidates, k)               # Algoritma 2'yi yeniden kullan

Ödünleşim (Trade-off): nprobe arttıkça doğruluk (recall) artar ama hız düşer. nprobe = küme sayısı olursa tam aramaya geri dönersiniz. Bu, mülakatta "doğruluk mu, gecikme mi?" tartışmasının klasik örneğidir.

Mülakat Sorusu: "K-Means'in zayıf noktaları neler?" → K'nın önceden bilinmesi gerekir, başlangıç merkezlerine duyarlıdır (çözüm: k-means++) ve küresel olmayan kümelerde başarısız olur.


Bu 10 Algoritma Bir RAG Sisteminde Nasıl Birleşir?

Tek tek öğrendiğiniz parçalar, gerçek bir üretim sisteminde şu sırayla birbirine bağlanır:

  1. Hazırlık (Offline): Dokümanlar BPE ile token'a çevrilir (4) → örtüşmeli chunk'lara bölünür (5) → embedding'leri çıkarılır → K-Means/IVF ile indekslenir (10). Paralel olarak bir BM25 indeksi kurulur (6).
  2. Sorgu (Online): Soru embedding'e çevrilir → IVF ile aday kümeler bulunur → kosinüs benzerliği (1) ve heap ile Top-K (2) uygulanır → BM25 sonuçlarıyla RRF ile birleştirilir (7).
  3. Üretim: Bulunan parçalar prompt'a eklenir → LLM softmax + top-p (3) veya beam search (8) ile cevabı üretir.
  4. İyileştirme: Embedding modeli veya reranker, gradyan inişi (9) ile alana özel veriyle ince ayar yapılır.

Bu akışı bir mülakatta beyaz tahtada çizebiliyorsanız, "AI mühendisi" unvanını hak eden adayların arasındasınız demektir.


Sonuç: Kütüphane Değil, Mekanizma

AI araçları her altı ayda bir değişiyor. LangChain'in API'si değişir, yeni bir vektör veritabanı popüler olur, yeni bir model çıkar. Ama kosinüs benzerliği, heap, softmax, BPE ve gradyan inişi on yıllardır aynı ve önümüzdeki on yıl da aynı kalacak.

Bu algoritmaların temelini oluşturan veri yapılarını pekiştirmek için:

Teoriyi okumak yetmez: PyMülakat'ın canlı kodlama ortamında bu kalıpları çözün ve AI mülakatçınızla zaman/bellek karmaşıklığınızı tartışın.

İnteraktif Pratik İstasyonu

Teoriyi Gerçek Sınav Ortamında Test Etmeye Hazır mısın?

PyMülakat platformunda 10 uzmanlık modülü ve 200 özgün Python mülakat sorusu seni bekliyor. Tarayıcıda kodunu hemen yaz, çalıştır ve gizli sınır testleriyle kendini sına.

İlk Soruyu Çöz (K01) →Modülleri İncele