Elinizde milyonlarca kedi, köpek ve muhtemelen ne olduğu yalnızca biyologların anlayabileceği canlı fotoğrafı olduğunu düşünün. Bunların hepsini insanlara etiketletmek pahalı ve yavaştır. Active Learning, yani aktif öğrenme, modelin kalabalığın içinden öğrenmeye en çok katkı sağlayacak örnekleri seçip uzmana “Şuna bir bakar mısın?” demesidir. ``

Active Learning nedir?

Klasik denetimli öğrenmede etiketli bir veri kümesi hazırlanır ve model bu kümenin tamamıyla eğitilir. Aktif öğrenmede ise başlangıçta yalnızca küçük bir etiketli küme bulunur. Model eğitildikten sonra etiketsiz veri havuzunu inceler, en faydalı gördüğü örnekleri seçer ve bunları bir insan uzmana gönderir.

Döngü genel olarak şöyledir:

1. Küçük bir başlangıç kümesini etiketle.
2. Modeli bu verilerle eğit.
3. Etiketsiz örnekler üzerinde tahmin yap.
4. En belirsiz veya bilgilendirici örnekleri seç.
5. İnsan uzmanından etiket iste.
6. Yeni etiketleri eğitim kümesine ekleyip modeli yeniden eğit.

Bu süreç, etiket bütçesi bitene veya model hedeflenen başarıya ulaşana kadar devam eder. Amaç daha fazla veri kullanmak değil, doğru veriyi etiketlemektir.

Model hangi örnekleri sorar?

En yaygın yöntem belirsizlik örneklemesidir. İkili sınıflandırmada model bir örnek için $P(y=1\mid x)=0.51$ üretiyorsa oldukça kararsızdır. Buna karşılık $0.99$ olasılıklı bir tahmin model açısından kolaydır. Etiket bütçesini kolay örneğe harcamak yerine kararsız örneği uzmana göndermek daha mantıklıdır.

Çok sınıflı problemlerde entropi kullanılabilir:

Burada $K$ sınıf sayısını, $p_i(x)$ ise örneğin $i$ sınıfına ait olma olasılığını gösterir. Entropi büyüdükçe tahmin dağılımı daha kararsız hâle gelir.

Python ile basit seçim

Aşağıdaki kod, sınıf olasılıklarının entropisini hesaplar ve en belirsiz üç örneği seçer:

import numpy as np

# Her satır bir örneğin sınıf olasılıklarını temsil eder.
probabilities = np.array([
    [0.90, 0.08, 0.02],
    [0.34, 0.33, 0.33],
    [0.55, 0.40, 0.05],
    [0.45, 0.10, 0.45],
    [0.80, 0.10, 0.10]
])

def entropy(probs):
    safe_probs = np.clip(probs, 1e-12, 1.0)
    return -np.sum(safe_probs * np.log(safe_probs), axis=1)

scores = entropy(probabilities)
query_indices = np.argsort(scores)[-3:][::-1]

print("Uzmanlara gönderilecek örnekler:", query_indices)
print("Belirsizlik puanları:", scores[query_indices])

np.clip, sıfır olasılığın logaritmasını alma sorununu önler. En yüksek entropiye sahip indeksler, insan uzmanına gönderilecek adaylardır. Gerçek projede bu indekslere karşılık gelen metinler, görüntüler veya kayıtlar bir etiketleme arayüzünde gösterilir.

Her belirsiz örnek faydalı mı?

Hayır. Model bazen bozuk görüntülere, anlamsız metinlere veya dağılım dışı verilere de aşırı belirsizlik gösterebilir. Bu nedenle çeşitlilik örneklemesi, kümeleme ve kalite filtreleri kullanılmalıdır. Aynı türden yüz kararsız örneği seçmek yerine farklı bölgeleri temsil eden örnekler tercih edilmelidir.

Ayrıca insan uzmanların hata yapabileceği unutulmamalıdır. Birden fazla uzmanın görüşü, uzlaşma ölçümleri ve düzenli kalite kontrolleri sürece eklenebilir. Başarılı bir Active Learning sistemi yalnızca akıllı bir sorgu algoritması değil; model, veri altyapısı ve insan uzman arasında kurulmuş geri bildirim döngüsüdür. Böylece model sessizce veri yutmak yerine, gerçekten merak ettiği soruları sormayı öğrenir.

Bir makineye binlerce kedi fotoğrafı gösterdiğinizi, fakat hiçbirine “kedi” etiketi koymadığınızı düşünün. Makine yine de kulak, tüy ve yüz şekli gibi ortak özellikleri keşfedebilir mi? Contrastive Learning, yani karşılaştırmalı öğrenme, tam olarak bunu hedefler: Benzer örnekleri temsil uzayında birbirine yaklaştırır, farklı örnekleri ise uzaklaştırır. SimCLR da bu fikri şaşırtıcı derecede sade bir eğitim düzenine dönüştüren popüler yöntemlerden biridir. ``

Temel fikir: Etiket yerine karşılaştırma

Geleneksel denetimli öğrenmede model, bir görseli sınıf etiketiyle eşleştirir. Karşılaştırmalı öğrenmede ise “Bu nedir?” sorusundan önce “Bu iki görüntü aynı şeye mi ait?” sorusu sorulur. Böylece veri kendi eğitim sinyalini üretir.

Bir fotoğrafa rastgele kırpma, döndürme, renk değiştirme veya bulanıklaştırma uygulandığında iki farklı görünüm elde edilir. Bunlar pozitif çift kabul edilir. Aynı mini-batch içindeki diğer fotoğraflar ise genellikle negatif örneklerdir.

Model, her görseli bir vektöre dönüştürür. İki temsil arasındaki benzerlik çoğunlukla kosinüs benzerliğiyle ölçülür:

Vektörler aynı yönü gösteriyorsa sonuç 1’e yaklaşır; birbirlerinden farklı yönlerdeyse küçülür. Yani sistem, pikselleri ezberlemek yerine anlamlı bir geometrik harita oluşturmaya çalışır.

SimCLR nasıl çalışır?

SimCLR boru hattı dört temel parçadan oluşur:

1. Batch içindeki her görüntüden iki rastgele görünüm üretilir.
2. Görünümler, ResNet gibi bir encoder üzerinden geçirilerek $h$ temsilleri elde edilir.
3. Küçük bir projection head, bu temsilleri $z$ uzayına taşır.
4. Contrastive loss, pozitif çiftleri yaklaştırırken diğer örnekleri uzaklaştırır.

SimCLR’da sık kullanılan NT-Xent kaybının sadeleştirilmiş biçimi şöyledir:

Buradaki $t$ sıcaklık parametresidir. Küçük sıcaklık, modelin benzerlik farklarına daha sert tepki vermesini sağlar. Pay kısmında pozitif eşleşme, paydada ise aday eşleşmeler bulunur. Kısacası modelden kalabalık içinde doğru “ikizi” bulması istenir.

PyTorch ile sade bir loss örneği

Aşağıdaki kod, iki görünümün temsillerini normalize eder ve doğru çiftleri çapraz entropiyle öne çıkarır:

import torch
import torch.nn.functional as F

def contrastive_loss(z1, z2, temperature=0.5):
    z1 = F.normalize(z1, dim=1)
    z2 = F.normalize(z2, dim=1)

    logits = z1 @ z2.T / temperature
    labels = torch.arange(z1.size(0), device=z1.device)

    loss_1 = F.cross_entropy(logits, labels)
    loss_2 = F.cross_entropy(logits.T, labels)
    return (loss_1 + loss_2) / 2

Matrisin köşegenindeki elemanlar doğru pozitif çiftlerdir. Fonksiyon iki yönü de hesaplayarak birinci görünümden ikinciyi ve ikinci görünümden birinciyi bulmayı öğretir. Gerçek SimCLR uygulamalarında aynı görünümün kendisiyle karşılaştırılması maskelenir ve batch içindeki tüm $2N$ temsil değerlendirilir.

Neden veri artırma bu kadar önemli?

Model yalnızca kırpılmış iki görüntüyü eşleştirirse konuma, yalnızca renk değişimini görürse renge bağımlı olabilir. Güçlü ve çeşitli dönüşümler, modele “Renk değişse de nesne aynı kalabilir” fikrini öğretir.

Eğitim tamamlandığında projection head genellikle atılır; encoder’dan çıkan temsiller sınıflandırma, benzer görsel arama veya kümeleme gibi görevlerde kullanılır. SimCLR’ın sihri aslında sihir değildir: İyi veri artırma, yeterince büyük batch ve doğru kayıp fonksiyonunun uyumlu çalışmasıdır. Etiketsiz bir fotoğraf arşivi böylece sessiz bir veri yığınından, kendi benzerlik dilini öğreten güçlü bir öğretmene dönüşür.

Termodinamikten gelen temel fikir

Difüzyon, fiziksel sistemlerin zamanla daha düzensiz hâle gelmesini anlatır. Bir bardak suya damlatılan mürekkebin kendiliğinden yayılması bunun klasik örneğidir. Başlangıçtaki düzen kaybolurken sistemin entropisi artar. DDPM de gerçek bir görüntüye küçük miktarlarda Gauss gürültüsü ekleyerek benzer bir süreç kurar.

Model iki ayrı süreçten oluşur:

İleri süreç mürekkebin suya yayılması kadar kolaydır. Asıl marifet, yayılmış mürekkebi yeniden tek bir damlada toplamak gibi davranan ters süreçtedir.

İleri difüzyon: Görüntüyü kontrollü bozmak

Temiz görüntüyü $x_0$ ile gösterelim. Her $t$ adımında görüntüye, miktarı bir varyans çizelgesiyle belirlenen gürültü eklenir:

Buradaki $\beta_t$, ilgili adımdaki gürültü miktarıdır. Küçük değerler görüntünün yavaşça bozulmasını sağlar. Güzel tarafı, yüzlerce adımı sırayla çalıştırmadan herhangi bir $t$ anına doğrudan sıçrayabilmemizdir:

Burada $\alpha_t=1-\beta_t$, $\bar{\alpha}t=\prod{s=1}^{t}\alpha_s$ ve $\epsilon\sim\mathcal{N}(0,I)$ olur. İlk terim korunmuş görüntüyü, ikinci terim eklenen rastgeleliği temsil eder.

Ters süreç: Gürültüyü tahmin etmek

Model, $x_t$ görüntüsünü ve zaman adımı $t$ değerini alarak eklenmiş gürültüyü tahmin eder. Genellikle omurgada, farklı çözünürlüklerde ayrıntı yakalayabilen bir U-Net bulunur. Sinir ağı $\epsilon_\theta(x_t,t)$ tahminini üretir; bu tahmin kullanılarak biraz daha temiz olan $x_{t-1}$ hesaplanır.

Eğitim kaybı şaşırtıcı derecede sadedir:

Başka bir deyişle model, gerçek gürültü ile tahmin ettiği gürültü arasındaki karesel farkı küçültür. Görüntünün kendisini ezberlemek yerine her bozulma seviyesinde hangi parçanın rastgele olduğunu öğrenir.

Aşağıdaki PyTorch benzeri kod, tek bir eğitim adımının özünü gösterir:

import torch

# Her örnek için rastgele bir difüzyon zamanı seçilir.
t = torch.randint(0, total_steps, (images.size(0),), device=images.device)
noise = torch.randn_like(images)

# Kapalı formül sayesinde görüntü doğrudan x_t seviyesine taşınır.
noisy = sqrt_alpha_bar[t] * images
noisy += sqrt_one_minus_alpha_bar[t] * noise

# U-Net eklenen gürültüyü tahmin eder.
predicted_noise = model(noisy, t)
loss = torch.mean((noise - predicted_noise) ** 2)

optimizer.zero_grad()
loss.backward()
optimizer.step()

Üretim neden yavaş ama etkileyici?

Üretim sırasında süreç saf $x_T$ gürültüsüyle başlar. Model, yüzlerce veya binlerce küçük temizleme adımı uygular. GAN modelleri çoğunlukla tek geçişte sonuç üretirken DDPM daha sabırlıdır; adeta bir heykeltıraş gibi her adımda rastgeleliği biraz daha yontar.

Bu aşamalı yaklaşım yüksek çeşitlilik, kararlı eğitim ve güçlü görüntü kalitesi sağlar. Dezavantajı hesaplama maliyetidir. DDIM, latent diffusion ve gelişmiş örnekleyiciler adım sayısını azaltarak bu sorunu hafifletir. Sonuçta görünen sihir, aslında olasılık teorisi, termodinamik sezgi ve dikkatle eğitilmiş bir gürültü tahmincisinin zarif iş birliğidir.

Bir otomobil sürücünün zihnini okuyamaz; ancak direksiyon hareketlerini, hız değişimlerini ve frenleme biçimini dikkatle dinleyebilir. Hidden Markov Modeli (HMM), doğrudan göremediğimiz uykulu, agresif veya normal sürüş durumlarını sensörlerden gelen ölçümler yardımıyla tahmin eder. Kısacası HMM, aracın küçük ipuçlarından sürücünün perde arkasındaki durumunu anlamaya çalışan istatistiksel bir dedektiftir.

``

Gizli olan ne, gözlenen ne?

HMM’de sistemin gerçek durumu doğrudan gözlemlenemez. Sürücünün agresif olduğunu kesin biçimde ölçen bir sensör yoktur. Bunun yerine gaz pedalı konumu, direksiyon açısı, şerit sapması ve ivme gibi dolaylı belirtiler izlenir.

Bir HMM, gizli durum dizisini $S_1,S_2,…,S_T$ ve gözlem dizisini $O_1,O_2,…,O_T$ olarak ele alır. Model üç temel olasılık kümesiyle tanımlanır:

• Başlangıç dağılımı: $P(S_1)$
• Geçiş olasılığı: $P(S_t \mid S_{t-1})$
• Gözlem olasılığı: $P(O_t \mid S_t)$

Ortak olasılık genel olarak şöyle yazılır:

Buradaki kritik varsayım, mevcut durumun yalnızca önceki duruma bağlı olmasıdır. Başka bir deyişle model, sürücünün bütün hayat hikâyesini değil yakın geçmişini hatırlar. Bu sadeleştirme hesaplamayı mümkün kılar.

Sensör verisi nasıl hazırlanır?

Ham sensör akışı doğrudan modele verilirse çukurlar, GPS hataları veya ani trafik olayları yanlış alarm üretebilir. Bu nedenle veriler kısa zaman pencerelerine ayrılır. Her pencere için ortalama hız, ivme varyansı, sert fren sayısı ve şerit sapmasının standart sapması gibi özellikler hesaplanır.

Gözlemler sürekli değerliyse her gizli durum için Gauss dağılımı kullanılabilir. Çok sayıda özelliğin birlikte değerlendirilmesi gerekiyorsa çok değişkenli Gauss dağılımı tercih edilir.

Python ile küçük bir model

Aşağıdaki örnek, hız, boylamsal ivme ve şerit sapması özelliklerinden üç davranış durumu öğrenir:

import numpy as np
from hmmlearn.hmm import GaussianHMM

# Her satır: [hız, ivme, şerit_sapması]
X = np.array([
    [82, 0.1, 0.08], [80, 0.0, 0.10],
    [110, 2.4, 0.25], [105, -3.1, 0.30],
    [68, 0.1, 0.65], [66, -0.1, 0.72]
])

model = GaussianHMM(
    n_components=3,
    covariance_type="full",
    n_iter=100,
    random_state=42
)
model.fit(X)

hidden_states = model.predict(X)
print(hidden_states)

fit, geçiş ve gözlem dağılımlarını veriden öğrenir. predict ise Viterbi algoritmasını kullanarak en olası gizli durum dizisini çıkarır. Ancak dönen 0, 1 ve 2 etiketleri otomatik olarak “uykulu” anlamına gelmez; durumların sensör ortalamaları incelenerek uzmanlar tarafından adlandırılması gerekir.

Gerçek hayatta dikkat edilmesi gerekenler

HMM zamansal bağımlılığı hesaba kattığı için tek ölçümlük eşik sistemlerinden daha kararlıdır. Yine de hava koşulları, araç tipi ve sürücünün kişisel alışkanlıkları modeli etkiler. Eğitim verisi farklı sürücülerden ve yol koşullarından toplanmalı; sonuçlar precision, recall ve karışıklık matrisiyle değerlendirilmelidir.

Üstelik “agresif” etiketi güvenlik, sigorta ve mahremiyet sonuçları doğurabilir. Bu yüzden tahminler kesin hüküm değil, sürücü destek sistemine sunulan olasılıksal uyarılar olarak ele alınmalıdır. HMM sihirli bir zihin okuyucu değildir; fakat sensörlerin fısıltısını anlamlı bir davranış hikâyesine dönüştürmekte oldukça yeteneklidir.

Telefonunuzun yazdığınız kelimeleri tahmin etmeyi öğrendiğini, ancak mesajlarınızın hiçbir zaman merkezi bir sunucuya gönderilmediğini düşünün. Federated Learning, yani federe öğrenme, tam olarak bu fikri hayata geçirir: Veriyi modele taşımak yerine modeli veriye götürür. Diferansiyel gizlilik ise paylaşılan model güncellemelerinden kişisel bilgilerin çıkarılmasını matematiksel olarak zorlaştırır.

``

Federe öğrenme nasıl çalışır?

Klasik makine öğrenmesinde kullanıcı verileri merkezi bir veri tabanında toplanır ve model burada eğitilir. Federe öğrenmede sunucu, mevcut global modeli seçilen cihazlara yollar. Her cihaz modeli kendi yerel verisiyle birkaç tur eğitir ve yalnızca hesapladığı ağırlık güncellemesini sunucuya gönderir.

Sunucu, bu güncellemeleri genellikle Federated Averaging (FedAvg) algoritmasıyla birleştirir:

Burada $w_{t+1}^{(k)}$, $k$ numaralı cihazın güncellediği ağırlıkları; $n_k$, cihazdaki örnek sayısını; $N$ ise katılan cihazlardaki toplam örnek sayısını temsil eder. Daha fazla veriye sahip cihazın katkısı doğal olarak daha yüksek olur.

Güncellemeler gerçekten güvenli mi?

Ham verinin gönderilmemesi tek başına kusursuz gizlilik sağlamaz. Saldırganlar gradyanlardan eğitim örneklerini yaklaşık olarak yeniden oluşturabilir veya belirli bir kullanıcının eğitime katılıp katılmadığını tahmin edebilir. İşte diferansiyel gizlilik, kısaca DP, burada devreye girer.

Bir mekanizma $M$, komşu iki veri kümesi $D$ ve $D’$ için şu koşulu sağlıyorsa $(\varepsilon, \delta)$-diferansiyel gizlidir:

Komşu veri kümeleri yalnızca bir kullanıcının eklenmesi veya çıkarılması bakımından farklıdır. Küçük $\varepsilon$ daha güçlü gizlilik, fakat çoğunlukla daha fazla gürültü ve daha düşük model doğruluğu demektir. $\delta$ ise ideal garantinin çok küçük bir olasılıkla aşılmasına izin verir.

Kırpma ve gürültü ekleme

Cihaz güncellemeleri önce norm sınırı $C$ ile kırpılır. Böylece tek bir kullanıcının global modele yapabileceği maksimum etki kontrol edilir:

Ardından toplama Gaussian gürültüsü eklenir. Aşağıdaki basitleştirilmiş Python kodu bu iki adımı gösterir:

import numpy as np

def privatize_update(update, clip_norm=1.0, noise_scale=0.2):
    # Güncellemenin etkisini belirlenen üst sınırda tutar.
    norm = np.linalg.norm(update)
    clipped = update * min(1.0, clip_norm / (norm + 1e-12))

    # Bireysel katkının ayırt edilmesini zorlaştırır.
    noise = np.random.normal(
        loc=0.0,
        scale=noise_scale * clip_norm,
        size=update.shape
    )
    return clipped + noise

Gerçek sistemlerde gürültü her cihazda veya güvenli toplama sonrasında sunucuda uygulanabilir. Secure Aggregation kullanıldığında sunucu tek tek güncellemeleri göremez; yalnızca toplam sonucu elde eder. Bu teknik DP’nin alternatifi değil, güçlü bir tamamlayıcısıdır.

Milyonlarca cihaz neden zorlu?

Cihazların işlem gücü, bağlantı kalitesi ve veri dağılımları farklıdır. Bir telefonda gece çekilmiş fotoğraflar, diğerinde gündüz görüntüleri bulunabilir; yani veriler çoğunlukla bağımsız ve özdeş dağılımlı değildir. Ayrıca her turda cihazların yalnızca küçük bir bölümü çevrim içidir.

Sonuç olarak federe öğrenme veriyi cihazda tutar, diferansiyel gizlilik ise modelin veriyi istemeden ezberlemesini sınırlar. İkisi güvenli toplama, şifreli iletişim ve düzenli gizlilik muhasebesiyle birleştiğinde milyonlarca kullanıcıdan öğrenen; ancak tek bir kullanıcı hakkında mümkün olduğunca az şey söyleyen dev modeller kurulabilir.

Bir dil modeline “Bana bir hikâye yaz” dediğinizde bazen güvenli ve tahmin edilebilir, bazen de uzayda simit satan melankolik bir robot kadar sıra dışı sonuçlar alabilirsiniz. Bu farkın önemli nedenlerinden ikisi temperature ve top-p parametreleridir. Bu ayarlar modelin bilgisini değiştirmez; bir sonraki token seçilirken ne kadar temkinli veya maceracı davranacağını belirler. ``

Model aslında neyi seçiyor?

Dil modelleri metni tek seferde yazmaz. Her adımda mevcut bağlama bakarak olası sonraki token’lara puan verir. Bu puanlar softmax fonksiyonu ile olasılığa dönüştürülür:

Burada $z_i$, ilgili token’ın ham skorudur. Model daha sonra bu dağılımdan seçim yapar. Örneğin “Gökyüzü bugün çok…” ifadesinden sonra dağılım şöyle olabilir:

En yüksek olasılıklı token’ı sürekli seçmek tutarlı sonuçlar üretir; ancak metin kısa sürede tahmin edilebilir hâle gelebilir. İşte temperature ve top-p bu noktada sahneye çıkar.

Temperature: Olasılıkların ses mikseri

Temperature, softmax hesabındaki skorları yeniden ölçeklendirir:

$T$ temperature değeridir. Düşük değerlerde güçlü adaylar daha baskın hâle gelir. Yüksek değerlerde dağılım düzleşir ve düşük olasılıklı seçeneklerin seçilme şansı artar.

Temperature sıfıra yaklaştığında sistem çoğunlukla en güçlü adayı seçer. Fakat API davranışı sağlayıcıya göre değişebilir; “temperature 0” her platformda matematiksel olarak tamamen deterministik sonuç garantisi değildir.

Top-P: Davetli listesini daraltmak

Top-p, diğer adıyla nucleus sampling, token’ları olasılıklarına göre sıralar ve toplam olasılığı $p$ eşiğine ulaşan en küçük aday kümesini tutar. Örneğin $p=0.90$ ise model, toplam olasılığın en az %90’ını kapsayan seçenekler arasından seçim yapar.

Önceki örnekte top-p değeri 0.75 olursa “güzel” ve “mavi” adayları toplamda %75’e ulaştığı için diğerleri elenir. Böylece “turşulu” gökyüzü şimdilik kuliste bekler.

Python ile küçük bir deney

Aşağıdaki kod, OpenAI uyumlu bir istemcide aynı istemi farklı ayarlarla çalıştırarak sonuçları karşılaştırır:

from openai import OpenAI

client = OpenAI()
prompt = "Yağmuru anlatan tek cümlelik yaratıcı bir slogan yaz."

ayarlar = [
    {"temperature": 0.2, "top_p": 0.9},
    {"temperature": 0.8, "top_p": 0.95},
    {"temperature": 1.2, "top_p": 1.0},
]

for ayar in ayarlar:
    yanit = client.responses.create(
        model="gpt-4.1-mini",
        input=prompt,
        temperature=ayar["temperature"],
        top_p=ayar["top_p"]
    )
    print(ayar, yanit.output_text)

Kod aynı görevi üç örnekleme profiliyle çalıştırır. İlk profil güvenli, ikincisi dengeli, üçüncüsü ise daha sürprizli ifadeler üretmeye eğilimlidir. Sonuçların değişkenliğini görmek için her profili birkaç kez çalıştırmak gerekir.

Hangisini ne zaman ayarlamalıyız?

Fatura bilgisi çıkarma, JSON üretme veya kod düzeltme gibi doğruluğun önemli olduğu görevlerde düşük temperature ve nispeten dar top-p tercih edilebilir. Pazarlama metni, karakter diyaloğu ve fikir üretiminde değerler yükseltilebilir. Yine de iki parametreyi aynı anda aşırı değiştirmek, hangi ayarın sonucu etkilediğini anlamayı zorlaştırır.

Pratik başlangıç noktası olarak temperature için 0.6–0.8, top-p için 0.9–1.0 denenebilir. Ardından yalnızca bir parametre değiştirilerek kalite, çeşitlilik ve tutarlılık ölçülmelidir. Kısacası temperature modelin ne kadar cesur konuşacağını, top-p ise konuşmadan önce kaç kelime adayını masada tutacağını belirler. İyi ayarlandıklarında yapay zekâ ne toplantı tutanağı kadar sıkıcı ne de rüya günlüğü kadar kontrolsüz olur.

``

Temel fikir: Anomali neden çabuk izole edilir?

Elimizde işlem tutarı ve işlem saati gibi özelliklerden oluşan bir veri kümesi bulunduğunu düşünelim. Noktaların çoğu birbirine yakınken çok yüksek tutarlı, gece yarısı yapılmış tek bir işlem uzak bir bölgede kalabilir. Isolation Forest, rastgele bir özellik seçer ve bu özelliğin minimum ile maksimum değerleri arasında rastgele bir bölme üretir.

Bu işlem ağaç boyunca tekrarlandığında aykırı nokta birkaç bölmeden sonra tek başına kalabilir. Normal bir noktanın ayrılması içinse kalabalık komşuluğun tekrar tekrar parçalanması gerekir. Bir gözlemin kökten yaprağa kadar geçtiği kenar sayısına yol uzunluğu denir ve $h(x)$ ile gösterilir.

Tek bir rastgele ağaç yanıltıcı olabilir. Bu nedenle algoritma birçok izolasyon ağacı oluşturur ve sonuçların ortalamasını alır. “Forest” kelimesinin hakkını veren kısım da tam olarak budur.

Anomali skoru nasıl hesaplanır?

Bir $x$ gözleminin skorunda, ağaçlar üzerindeki ortalama yol uzunluğu $E[h(x)]$ kullanılır:

Buradaki $n$ örnek sayısını, $c(n)$ ise başarısız bir ikili arama ağacındaki ortalama yol uzunluğunu temsil eden normalleştirme katsayısını belirtir:

$H(i)$ harmonik sayıdır ve yaklaşık olarak $H(i)\approx \ln(i)+\gamma$ biçiminde hesaplanabilir. Skor 1’e yaklaştıkça gözlem daha anormal, 0,5 civarında kaldıkça daha sıradan kabul edilir. Böylece farklı veri büyüklüklerinden elde edilen yol uzunlukları karşılaştırılabilir hâle gelir.

Python ile küçük bir anomali avı

Scikit-learn içindeki IsolationForest sınıfı, yöntemi birkaç satırda uygulamamızı sağlar:

import pandas as pd
from sklearn.ensemble import IsolationForest

veri = pd.DataFrame({
    "tutar": [42, 48, 51, 46, 49, 1200, 44, 53],
    "saat":  [13, 14, 12, 15, 13, 3, 16, 12]
})

model = IsolationForest(
    n_estimators=200,
    contamination=0.125,
    random_state=42
)

model.fit(veri)
veri["tahmin"] = model.predict(veri)
veri["anomali_skoru"] = -model.score_samples(veri)

print(veri.sort_values("anomali_skoru", ascending=False))

n_estimators, ormandaki ağaç sayısını belirler. Daha fazla ağaç genellikle daha kararlı sonuç üretir ancak hesaplama maliyetini artırır. contamination, veride beklenen anomali oranıdır. predict normal gözlemler için 1, anomaliler için -1 döndürür. score_samples sonucunun işaretini ters çevirerek büyük değerin daha şüpheli olduğu, okunması kolay bir skor elde ediyoruz.

Neden tercih edilir?

Isolation Forest’ın eğitim maliyeti örnekleme sayesinde yaklaşık $O(t\,\psi\log\psi)$ düzeyindedir. Burada $t$ ağaç sayısını, $\psi$ ise her ağaç için kullanılan örnek büyüklüğünü gösterir. Bu yapı, milyonlarca satırın bulunduğu dolandırıcılık, sensör arızası ve sistem günlüğü senaryolarında yöntemi cazip kılar.

Yine de algoritma “neden anomali?” sorusunu tek başına açıklamaz. Kategorik değişkenler uygun biçimde kodlanmalı, özellik ölçekleri ve veri sızıntısı kontrol edilmeli, contamination iş bilgisiyle seçilmelidir. Kısacası Isolation Forest hızlı bir bekçidir; alarmı iyi çalar, fakat olay yerindeki son kararı yine alan bilgisi verir.

``

Saflık ve belirsizlik ne anlama gelir?

Bir düğümdeki örneklerin tamamı aynı sınıfa aitse düğüm saftır. Örneğin kutuda yalnızca elmalar bulunuyorsa belirsizlik yoktur. Kutuda eşit sayıda elma ve armut varsa hangi meyveyi çekeceğimizi tahmin etmek daha zordur.

İki sınıflı bir problemde pozitif sınıfın oranı $p$, negatif sınıfın oranı $1-p$ olsun. Hem Gini hem de Entropy, $p=0$ veya $p=1$ olduğunda sıfır değerini alır. En yüksek belirsizlik ise sınıflar dengeliyken, yani $p=0.5$ civarında ortaya çıkar.

Gini Impurity matematiği

Gini Impurity, rastgele seçilen bir örneğin düğümdeki sınıf dağılımına göre rastgele etiketlenmesi durumunda yanlış sınıflandırılma olasılığını temsil eder:

Burada $K$ sınıf sayısını, $p_i$ ise $i$ sınıfının düğümdeki oranını gösterir. Yüzde 50 kedi ve yüzde 50 köpek bulunan bir düğüm için:

Dağılım yüzde 90 kedi ve yüzde 10 köpek olduğunda sonuç $0.18$ olur. Değerin küçülmesi, düğümün daha saf hâle geldiğini gösterir.

Entropy ve bilgi teorisi

Entropy, bilgi teorisinden gelir ve bir dağılımdaki şaşkınlığı ya da belirsizliği ölçer:

Eşit dağılımlı iki sınıfta Entropy değeri $1$’dir. Tek bir sınıftan oluşan düğümde ise $0$ olur. Hesaplama sırasında $0\log_2(0)$ ifadesi limit yaklaşımıyla sıfır kabul edilir.

Entropy ile bölünme değerlendirilirken çoğunlukla Information Gain kullanılır:

Yani çocuk düğümlerin ağırlıklı belirsizliği, ebeveynin belirsizliğinden çıkarılır. En yüksek bilgi kazancını sağlayan bölünme seçilir.

Bölünme nasıl puanlanır?

Bir aday bölünmenin kalitesi, çocuk düğümlerin ağırlıklı impurity değeriyle hesaplanır:

Amaç bu değeri küçültmek veya ebeveyn düğüme göre impurity azalmasını büyütmektir. Çok saf fakat yalnızca iki örnek içeren bir dalın ağacı yanıltmaması için örnek sayılarıyla ağırlıklandırma kritik öneme sahiptir.

from sklearn.tree import DecisionTreeClassifier

# Aynı veri üzerinde iki farklı saflık ölçütü kullanan modeller
models = {
    'gini': DecisionTreeClassifier(criterion='gini', random_state=42),
    'entropy': DecisionTreeClassifier(criterion='entropy', random_state=42)
}

for name, model in models.items():
    model.fit(X_train, y_train)
    print(name, model.score(X_test, y_test))

Bu kod iki ağacı aynı eğitim verisiyle kurar ve test doğruluklarını karşılaştırır. Sağlıklı bir deneyde yalnızca doğruluğa değil; eğitim süresine, ağaç derinliğine, çapraz doğrulama skorlarına ve dengesiz veri varsa F1 ya da ROC-AUC değerlerine de bakılmalıdır.

Hangisini seçmeliyiz?

Pratikte iki kriter çoğu zaman benzer bölünmeler ve tahmin performansı üretir. Gini, logaritma hesaplamadığı için teorik olarak daha hızlıdır; Entropy ise olasılıklardaki değişimleri bilgi miktarı olarak yorumlamayı sağlar. Küçük hız farkları modern uygulamalarda genellikle belirleyici değildir.

En doğru yaklaşım, kriteri bir hiperparametre gibi değerlendirmektir. Çapraz doğrulamayla ikisini de deneyin; genelleme performansı, model karmaşıklığı ve çalışma süresi açısından daha uygun olanı seçin. Kısacası Gini hızlı bir saflık dedektörü, Entropy ise bilgi teorisi gözlüğü takmış meraklı bir matematikçidir.

``

Gradient boosting neden pahalıdır?

Gradient boosting, önceki ağaçların hatalarını azaltacak yeni karar ağaçlarını ardışık biçimde üretir. Modelin genel tahmini kabaca şöyle yazılabilir:

Burada $f_t(x)$ yeni ağacı, $\eta$ ise öğrenme oranını temsil eder. Her düğümde algoritmanın “Bu özelliği hangi değerden bölersem kayıp en fazla azalır?” sorusunu cevaplaması gerekir.

Klasik yaklaşımda sürekli bir özelliğin değerleri sıralanır ve olası eşikler değerlendirilir. $n$ örnek ve $m$ özellik için bu işlem büyük veri kümelerinde ciddi sıralama, tarama ve bellek maliyeti oluşturabilir. Üstelik aynı tür hesaplamalar ağacın birçok düğümünde tekrarlanır.

Histogram numarası

LightGBM, her sürekli özelliği genellikle birkaç yüz bin içine dönüştürür. Örneğin yaş değerleri tek tek tutulmak yerine 18-25, 26-35 ve 36-50 gibi gruplara eşlenebilir. Gerçekte sınırlar veri dağılımına göre daha sistematik belirlenir.

Her bin için gradyan ve Hessian değerleri toplanır:

Bölünme kazancı artık bütün örnekler yerine bu özetler üzerinden hesaplanabilir. Böylece çalışma maliyeti örnek sayısından çok bin sayısına bağlı hâle gelir. Ayrıca ham ondalıklı değerler yerine küçük tamsayı bin kimlikleri saklanabildiği için bellek kullanımı azalır ve işlemci önbelleği daha verimli kullanılır.

Histogramlar yalnızca hız sağlamaz. Bir düğümün histogramı ile çocuklarından birinin histogramı biliniyorsa diğer çocuk çıkarma işlemiyle bulunabilir. Bu histogram subtraction tekniği, aynı verinin tekrar tekrar taranmasını önler.

LightGBM’i farklılaştıran diğer parçalar

LightGBM’in avantajını yalnızca histogramlara bağlamak eksik olur. Algoritma çoğunlukla ağacı seviye seviye değil, kaybı en fazla azaltan yaprağı büyüterek oluşturur. Leaf-wise büyüme daha düşük kayba hızlı ulaşabilir; ancak küçük verilerde aşırı öğrenme riski taşır. Bu nedenle num_leaves, max_depth ve min_data_in_leaf kritik ayarlardır.

Ayrıca GOSS, gradyanı büyük örnekleri koruyup kolay örneklerden örnekleme yapar. EFB ise aynı anda sıfır olmayan seyrek özellikleri tek özellikte paketleyerek boyutu azaltır.

Python ile küçük bir deney

Aşağıdaki kod, histogram çözünürlüğünü belirleyen max_bin seçeneğiyle bir sınıflandırıcı kurar:

from lightgbm import LGBMClassifier
from sklearn.metrics import accuracy_score

model = LGBMClassifier(
    n_estimators=400,
    learning_rate=0.05,
    num_leaves=31,
    max_bin=255,
    min_child_samples=30,
    random_state=42
)

model.fit(X_train, y_train)
predictions = model.predict(X_test)
print(accuracy_score(y_test, predictions))

max_bin artırılırsa daha hassas eşikler elde edilebilir; fakat eğitim ve bellek maliyeti yükselir. Azaltılırsa model hızlanır, ancak önemli ayrımlar aynı sepete düşebilir.

Sonuç olarak LightGBM, özellikle büyük ve yüksek boyutlu verilerde XGBoost’un tarihsel exact yaklaşımını hız ve bellek bakımından geçebildi. Güncel XGBoost sürümlerinin de histogram tabanlı yöntemler sunduğunu unutmamak gerekir; dolayısıyla mutlak bir şampiyon yoktur. Asıl sır, daha fazla hesaplamak değil, veriyi akıllıca özetleyerek doğru hesapları yapmaktır.

Bir çeviri sistemi yüksek BLEU skoru aldığında gerçekten iyi çeviri yapıyor diyebilir miyiz? Kısa cevap: Her zaman değil. BLEU, makine çevirisi dünyasının en meşhur ölçüm araçlarından biri olsa da anlamı, akıcılığı ve bağlamı doğrudan ölçmez. Üstelik bazen kulağa robotik gelen bir çeviriyi ödüllendirirken gayet doğal bir alternatifi cezalandırabilir.

``

BLEU aslında neyi ölçüyor?

BLEU, yani Bilingual Evaluation Understudy, aday çevirideki kelime dizilerini insan tarafından hazırlanmış referans çevirilerle karşılaştırır. Buradaki temel fikir, iki metnin ortak $n$-gram sayısı arttıkça çevirinin daha başarılı kabul edilmesidir.

Bir $n$-gram, art arda gelen $n$ adet parçadan oluşur:

• 1-gram: yapay
• 2-gram: yapay zeka
• 3-gram: yapay zeka sistemi

Basitleştirilmiş $n$-gram kesinliği şöyle gösterilebilir:

BLEU, farklı uzunluklardaki $n$-gram kesinliklerinin geometrik ortalamasını alır ve çok kısa çevirileri engellemek için bir uzunluk cezası ekler:

Buradaki $BP$, brevity penalty olarak bilinen kısalık cezasıdır. Sistem yalnızca birkaç doğru kelime üretip yüksek puanı kapamasın diye kullanılır.

Aynı anlam, farklı kelimeler

Kaynak cümlenin “The meeting was called off” olduğunu düşünelim. Referans çeviri “Toplantı iptal edildi” olsun.

İkinci çeviri bağlama göre son derece doğal olabilir. Ancak BLEU, “görüşme” ile “toplantı” arasındaki yakınlığı veya “iptal oldu” ifadesinin aynı mesajı taşıdığını bilmez. Çünkü kelimelerin anlamlarını değil, yüzeydeki parçaların örtüşmesini sayar.

Bu durum özellikle eş anlamlıların bol olduğu dillerde, serbest sözcük diziliminde ve Türkçe gibi eklemeli dillerde belirginleşir. “Evlerimizden” tek bir kelimeyken başka bir dilde birkaç ayrı sözcüğe karşılık gelebilir. Tokenizasyon tercihi bile sonucu değiştirebilir.

Skoru hızlıca hesaplamak

Python’da sacrebleu paketiyle standartlaştırılmış bir BLEU hesabı yapılabilir:

import sacrebleu

referanslar = [['Toplantı iptal edildi']]
adaylar = ['Görüşme iptal oldu']

sonuc = sacrebleu.corpus_bleu(adaylar, referanslar)
print(f'BLEU: {sonuc.score:.2f}')

Bu kod aday çeviriyi referansla karşılaştırır. Sonuç düşük çıkarsa adayın mutlaka kötü olduğunu söyleyemeyiz; yalnızca referansın kelime dizilimine yeterince benzemediğini söyleyebiliriz. Ayrıca farklı kütüphanelerin tokenizasyon ve düzeltme yöntemleri farklı sonuçlar üretebildiğinden deneylerde kullanılan BLEU sürümü açıkça belirtilmelidir.

BLEU ne zaman işe yarar?

BLEU tamamen kullanışsız değildir. Büyük veri kümelerinde, aynı test seti üzerinde eğitilen sistemlerin genel ilerlemesini hızlı ve ucuz biçimde karşılaştırmak için pratiktir. Ancak tek bir cümlenin kalitesini değerlendirmekte güvenilir değildir. Korpus düzeyinde anlamlı olan istatistikler, cümle düzeyinde oynak hale gelir.

Tek sayı yerine ölçüm sepeti

Sağlıklı değerlendirme için BLEU; chrF, COMET veya BERTScore gibi metriklerle desteklenmelidir. Kritik uygulamalarda insan değerlendiriciler doğruluk, akıcılık, terminoloji ve kültürel uygunluk başlıklarını ayrı ayrı puanlamalıdır.

Sonuç olarak BLEU bizi bilinçli biçimde kandırmaz; yalnızca kendisine sormadığımız soruları cevaplayamaz. O, “Bu çeviri referansa ne kadar benziyor?” sorusunda iyidir. “Bu çeviri anlamı doğru, doğal ve güvenli biçimde aktarıyor mu?” sorusu içinse tek başına oldukça sessizdir.