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.

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.

``

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.

``

Önce temel mantık: Ajan ne öğreniyor?

Klasik pekiştirmeli öğrenmede bir ajan, bulunduğu durum $s_t$ için bir eylem $a_t$ seçer. Ortam bunun karşılığında $r_t$ ödülünü ve yeni durum $s_{t+1}$ değerini üretir. Ajanın amacı, gelecekteki ödüllerin indirgenmiş toplamını büyütmektir:

Buradaki $\gamma$, ajanın ne kadar ileri görüşlü olduğunu belirleyen indirim katsayısıdır. Değer 0’a yaklaştığında ajan “ödül şimdi gelsin” der; 1’e yaklaştığında ise uzun vadeli stratejilere önem verir.

MARL ortamında tek bir ajan yerine $N$ ajan bulunur. Ortamın sonraki durumu, tüm ajanların ortak eylemine bağlıdır:

Dolayısıyla bir ajanın karşılaştığı dünya sürekli değişir; çünkü diğer ajanlar da öğrenmektedir. Bu durum durağan olmama problemi olarak bilinir.

İşbirliği mi, rekabet mi?

İşbirlikçi senaryoda depo robotları, çarpışmadan paket taşımayı öğrenebilir. Rekabetçi senaryoda bir ajan kazanırken diğeri kaybeder. Karma ortamlarda ise ajanlar bazen yardımlaşır, bazen “o şarj istasyonu benimdi!” diyerek mücadele eder.

Ajanlar gerçekten konuşabilir mi?

Evet, fakat konuşma her zaman doğal dil anlamına gelmez. Bir ajan diğerine konum, hedef veya niyet belirten sayısal mesajlar gönderebilir. Daha ilginci, mesajların anlamı önceden tanımlanmayabilir. Eğitim sırasında ajanlar, görevi kolaylaştıran kendi iletişim protokollerini keşfedebilir.

Örneğin 0.73 mesajı zamanla “sağ koridor boş” anlamına gelebilir. İnsan açısından anlamsız görünen bu sinyal, ajanlar için oldukça net olabilir. Buna ortaya çıkan iletişim denir.

Basit bir ortak ödül örneği

Aşağıdaki Python fonksiyonu, iki ajanın aynı hedefe yaklaşmasını ödüllendirirken çarpışmalarını cezalandırır:

def ortak_odul(ajanlar, hedef):
    odul = 0.0

    for ajan in ajanlar:
        mesafe = abs(ajan.x - hedef.x) + abs(ajan.y - hedef.y)
        odul -= 0.1 * mesafe  # Hedeften uzak kalmayı cezalandırır.

    ayni_konum = ajanlar[0].konum == ajanlar[1].konum
    if ayni_konum:
        odul -= 10  # Çarpışmayı pahalı hâle getirir.

    if all(ajan.hedefte for ajan in ajanlar):
        odul += 50  # Takım başarısını ödüllendirir.

    return odul

Bu tasarım basit görünse de kritik bir soruyu doğurur: Takım başarılı olduğunda hangi ajan ne kadar katkı sağladı? Kredi atama problemi, ortak ödülün bireysel davranışlarla ilişkilendirilmesini zorlaştırır.

Merkezi eğitim, dağıtık uygulama

Yaygın çözümlerden biri Centralized Training, Decentralized Execution (CTDE) yaklaşımıdır. Eğitim sırasında merkezi sistem tüm ajanların durumlarını görebilir. Gerçek kullanımda ise her ajan yalnızca kendi gözlemiyle karar verir.

MARL; trafik ışıklarının koordinasyonundan drone sürülerine, enerji şebekelerinden strateji oyunlarına kadar geniş bir alanda kullanılır. En büyük zorluk yalnızca iyi karar veren ajanlar üretmek değil, başkalarının değişen davranışlarına uyum sağlayan ekip arkadaşları ve rakipler geliştirmektir. Kısacası geleceğin yapay zekâları sadece düşünecek değil; pazarlık edecek, takım kuracak ve muhtemelen dijital toplantılardan bizim kadar yorulacak.

Hyperparameter optimizasyonu neyi çözer?

Model eğitimi, seçilen hyperparameter vektörü $x$ için bir doğrulama kaybı üretir. Optimizasyonun amacı kabaca şudur:

Burada $X$ arama uzayı, $f(x)$ ise eğitim ve doğrulama sürecinin sonunda ölçülen kayıptır. Sorun şu ki $f$ genellikle türevlenebilir değildir, her değerlendirme pahalıdır ve eğitimdeki rastlantısallık nedeniyle gürültülü sonuçlar verebilir. Dolayısıyla klasik gradyan inişi yerine, olabildiğince az deneyle iyi bölgeleri keşfeden yöntemlere ihtiyaç duyarız.

Grid, rastgele ve Bayesçi arama

Grid Search’te her parametre için $k$ değer ve toplam $d$ parametre varsa yaklaşık $k^d$ kombinasyon oluşur. Beş parametrenin her biri için on seçenek belirlemek, $10^5$ eğitim anlamına gelir. Kahve makinesi bile bu planı görünce istifa edebilir.

Random Search bu maliyeti azaltır; ancak iyi ve kötü denemeler arasında hafıza kurmaz. Bayesçi yaklaşım ise gözlenen $(x, f(x))$ çiftlerinden yararlanarak sıradaki adayın nereden seçileceğine karar verir. Amaç yalnızca mevcut en iyi bölgeyi sömürmek değil, belirsiz alanları keşfetmektir. Bu dengeye exploration–exploitation dengesi denir.

Optuna’nın mimarisi

Optuna’da optimizasyon sürecinin merkezi Study nesnesidir. Her model eğitimi bir Trial, parametreleri öneren bileşen Sampler, başarısız olması muhtemel eğitimleri durduran bileşen ise Pruner olarak adlandırılır. Sonuçlar bellek, SQLite veya ilişkisel bir veritabanında saklanabilir.

Optuna’nın varsayılan yöntemlerinden TPE, yani Tree-structured Parzen Estimator, başarılı ve başarısız denemeler için iki olasılık yoğunluğu kurar:

Yeni adaylar, kabaca $l(x) / g(x)$ oranının yüksek olduğu bölgelerden seçilir. Başka bir deyişle Optuna, iyi sonuçlarda sık görülen fakat kötü sonuçlarda seyrek kalan parametrelere öncelik verir. Koşullu arama uzaylarını desteklediği için seçilen modele göre farklı parametreler de tanımlanabilir.

Uygulamalı bir örnek

Aşağıdaki kod, Random Forest modelinin temel ayarlarını optimize eder:

import optuna
from sklearn.datasets import load_breast_cancer
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import cross_val_score

X, y = load_breast_cancer(return_X_y=True)

def objective(trial):
    params = {
        "n_estimators": trial.suggest_int("n_estimators", 50, 400),
        "max_depth": trial.suggest_int("max_depth", 2, 20),
        "min_samples_split": trial.suggest_int("min_samples_split", 2, 16),
        "max_features": trial.suggest_float("max_features", 0.2, 1.0)
    }

    model = RandomForestClassifier(**params, random_state=42)
    score = cross_val_score(model, X, y, cv=5, scoring="accuracy").mean()
    return score

study = optuna.create_study(direction="maximize")
study.optimize(objective, n_trials=50)

print(study.best_value)
print(study.best_params)

objective fonksiyonu bir denemenin nasıl değerlendirileceğini tanımlar. suggest_int ve suggest_float çağrıları arama uzayını oluştururken study.optimize, sampler tarafından seçilen adayları sırayla çalıştırır. Sinir ağları gibi aşamalı eğitimlerde ara skorlar trial.report() ile bildirilip trial.should_prune() ile kötü denemeler erkenden kesilebilir.

Sonuç olarak Optuna sihirli biçimde mükemmel modeli garanti etmez; fakat deneme geçmişini, olasılıksal örneklemeyi, budamayı ve kalıcı depolamayı aynı mimaride birleştirir. Böylece hyperparameter araması, elle sayı çevirdiğimiz bir kumar makinesinden ölçülebilir ve tekrarlanabilir bir optimizasyon sürecine dönüşür.