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.

``

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.

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.

Transfer öğrenme nedir?

Derin sinir ağlarının ilk katmanları kenar, renk ve doku gibi genel örüntüleri; ilerleyen katmanları ise nesne parçaları ve sınıfa özgü yapıları öğrenir. Bir kediyi tanımak için öğrenilen kenar dedektörleri, otomobil veya yaprak sınıflandırırken de işe yarar. Böylece modelin bütün bilgisini çöpe atmak yerine yalnızca probleminize özgü bölümünü değiştirirsiniz.

Kaynak görevde öğrenilen parametreleri $w_s$, hedef görev için aradığımız parametreleri $w_t$ ile gösterelim. Transfer öğrenmenin temel fikri şudur:

Yani hedef model rastgele başlamaz; eğitim maratonuna başlangıç çizgisinden değil, parkurun büyük bölümünü tamamlamış halde girer. Ardından hedef veri üzerindeki kayıp fonksiyonu küçültülür:

$N$ küçük olduğunda iyi bir başlangıç noktası, aşırı öğrenme riskini ciddi biçimde azaltabilir.

İki temel strateji

Özellik çıkarımında önceden eğitilmiş ağ sabit bir dönüştürücü gibi davranır. Sadece son sınıflandırma katmanı eğitilir. İnce ayarda ise üst katmanlardan bazıları düşük öğrenme oranıyla güncellenir. Bu, modele “Bildiklerini unutma ama bizim lehçemizi de öğren” demektir.

PyTorch ile uygulama

Aşağıdaki örnek, ImageNet üzerinde eğitilmiş ResNet18 modelini üç sınıflı bir problem için hazırlar:

import torch.nn as nn
from torchvision.models import resnet18, ResNet18_Weights

model = resnet18(weights=ResNet18_Weights.DEFAULT)

# Önceden öğrenilmiş özellikleri koru.
for parameter in model.parameters():
    parameter.requires_grad = False

# Eski 1000 sınıflı çıkışı kendi problemimize uyarla.
input_features = model.fc.in_features
model.fc = nn.Linear(input_features, 3)

Burada omurganın parametreleri dondurulur, ancak yeni model.fc katmanı varsayılan olarak eğitilebilir durumdadır. Optimize ediciye yalnızca güncellenecek parametreleri vermek gereksiz hesaplamayı önler:

import torch.optim as optim

optimizer = optim.Adam(
    filter(lambda p: p.requires_grad, model.parameters()),
    lr=1e-3
)
criterion = nn.CrossEntropyLoss()

İlk eğitimden sonra doğrulama başarımı tıkanırsa son katman grubunu açarak ince ayar yapabiliriz:

for parameter in model.layer4.parameters():
    parameter.requires_grad = True

optimizer = optim.Adam(
    filter(lambda p: p.requires_grad, model.parameters()),
    lr=1e-5
)

Düşük öğrenme oranı önemlidir; büyük adımlar, önceden öğrenilmiş yararlı temsilleri bozarak felaket unutmaya yol açabilir.

Küçük veriyi daha da verimli kullanmak

Veri artırma sırasında döndürme, kırpma, renk değişimi ve yatay çevirme gibi işlemler uygulanabilir. Ancak tıbbi görüntüler veya yönün anlam taşıdığı veriler için her dönüşüm mantıklı değildir. Dikey çevrilmiş bir trafik levhası modele yaratıcılık değil, kafa karışıklığı kazandırabilir.

Eğitim ve doğrulama kümelerini dikkatle ayırmak, sınıf dengesini izlemek ve erken durdurma kullanmak da önemlidir. Başarıyı yalnızca doğrulukla ölçmeyin; dengesiz veri setlerinde precision, recall ve F1 skoru daha açıklayıcıdır.

Transfer öğrenme sihirli değnek değildir: Kaynak ve hedef alanlar çok farklıysa negatif transfer oluşabilir. Yine de doğru model, kontrollü ince ayar ve gerçekçi doğrulama ile birkaç yüz örnekten şaşırtıcı derecede güçlü sistemler üretmek mümkündür. Kısacası devlerin omzuna çıkın; fakat direksiyonu kendi probleminize göre çevirmeyi unutmayın.

``

Dikkat mekanizmasının temel fikri

Bir evrişimli sinir ağı, görüntüyü doğrudan “kedi” veya “otomobil” olarak görmez. Ara katmanlarda $H \times W \times C$ boyutlu özellik haritaları üretir. Burada $H$ ve $W$ uzamsal boyutları, $C$ ise kanal sayısını temsil eder. Dikkat modülü bu özellikler için genellikle $0$ ile $1$ arasında ağırlıklar hesaplar.

Bir konumdaki özellik vektörü $x_i$, dikkat puanı ise $a_i$ olsun. Dikkatli temsil şu şekilde yazılabilir:

Softmax sayesinde $\sum_i \alpha_i=1$ olur. Yani model, elindeki sınırlı “ilgi bütçesini” görüntünün farklı bölgelerine dağıtır. Yüksek $\alpha_i$ alan pikseller veya yamalar kararda daha etkili olur.

Hangi dikkat türü neye odaklanır?

“Yönlendirilmiş” ifadesi, dikkatin yalnızca görüntü içinden kendiliğinden doğması gerekmediğini de anlatır. Bir sınıf etiketi, metin sorgusu, nesne koordinatı veya önceki video karesi hedef sinyali olabilir. Örneğin “kırmızı çantayı bul” sorgusu verildiğinde model hem kırmızılığa hem de çantaya benzeyen şekillere odaklanır.

Basit bir uzamsal dikkat modülü

Aşağıdaki PyTorch modülü, kanal boyunca ortalama ve maksimum özet çıkarır. Ardından bir evrişim ve sigmoid kullanarak tek kanallı dikkat haritası üretir. Son çarpma işlemi önemli bölgeleri güçlendirir:

import torch
import torch.nn as nn

class SpatialAttention(nn.Module):
    def __init__(self, kernel_size=7):
        super().__init__()
        padding = kernel_size // 2
        self.score = nn.Conv2d(
            2, 1, kernel_size, padding=padding, bias=False
        )

    def forward(self, features):
        average = features.mean(dim=1, keepdim=True)
        maximum, _ = features.max(dim=1, keepdim=True)
        summary = torch.cat([average, maximum], dim=1)
        attention = torch.sigmoid(self.score(summary))
        focused = features * attention
        return focused, attention

Buradaki attention, görselleştirilebilen bir ısı haritasıdır. Ancak parlak bir bölge görmek, modelin karar nedenini kesin olarak kanıtlamaz. Dikkat haritası açıklanabilirlik için yararlı bir ipucu olsa da nedensellik testi değildir.

Model gerçekten doğru yere mi bakıyor?

Sadece doğruluk ölçmek yeterli değildir. Dikkat haritası insan tarafından işaretlenmiş nesne maskesiyle karşılaştırılabilir. Eşiklenmiş dikkat alanı $A$, gerçek bölge $G$ ise kesişim-birleşim oranı şöyledir:

Ayrıca görüntünün en dikkatli kısmını kapatıp tahmin güveninin düşüp düşmediği incelenebilir. Güven belirgin biçimde azalıyorsa model gerçekten o bölgeden yararlanıyor olabilir. Tersine, nesne yerine filigrana odaklanan bir ağ veri kümesindeki kestirme yolları öğrenmiş demektir.

Yönlendirilmiş dikkat; tıbbi görüntüleme, otonom sürüş, nesne takibi ve görsel soru cevaplama gibi alanlarda modelin enerjisini doğru yere toplar. Kısacası mesele daha fazla piksel görmek değil, hangi pikselin neden önemli olduğunu öğrenmektir.

``

2-SAT nedir?

2-SAT formülleri, her parantezinde en fazla iki literal bulunan ve bağlaçlarla birleştirilen ifadelerdir:

Literal, bir değişkenin kendisi ($x$) veya değili ($\neg x$) olabilir. Genel bir madde $(a \lor b)$ biçimindedir. Bu ifade yalnızca $a$ ve $b$ birlikte yanlış olduğunda bozulur. Dolayısıyla şu iki zorunluluğu türetebiliriz:

Her zorunluluğu yönlü bir kenara dönüştürürsek implikasyon grafiği ortaya çıkar.

SCC neden çözümü belirliyor?

Bir güçlü bağlı bileşende, her düğümden diğer bütün düğümlere ulaşılabilir. Eğer $x$ ile $\neg x$ aynı SCC içindeyse hem $x \Rightarrow \neg x$ hem de $\neg x \Rightarrow x$ geçerlidir. Hangi doğruluk değerini seçersek seçelim sistem tersini de zorlar; formül çözülemez.

Böylece temel ölçüt şudur:

Bu, yönlü döngülerin mantıksal çelişkiyi görünür hâle getirmesidir. SCC’ler Tarjan veya Kosaraju algoritmasıyla $O(V+E)$ zamanda bulunur. $n$ değişken ve $m$ madde için grafikte $2n$ düğüm, $2m$ kenar bulunduğundan toplam karmaşıklık $O(n+m)$ olur.

Kosaraju ile uygulama

Aşağıdaki C++ kodu, pozitif literali 2*x, negatifini 2*x+1 ile temsil eder. p^1 işlemi bir literalden karşıtına geçer. İlk DFS bitiş sırasını, ikinci DFS ise ters grafikte bileşenleri üretir.

#include <bits/stdc++.h>
using namespace std;

struct TwoSAT {
    int n;
    vector<vector<int>> g, rg;
    vector<int> order, comp, used;

    TwoSAT(int n) : n(n), g(2*n), rg(2*n),
                    comp(2*n, -1), used(2*n) {}

    // (a OR b) maddesini implikasyon grafiğine ekler.
    void addClause(int a, int b) {
        g[a ^ 1].push_back(b);
        rg[b].push_back(a ^ 1);
        g[b ^ 1].push_back(a);
        rg[a].push_back(b ^ 1);
    }

    void dfs1(int v) {
        used[v] = 1;
        for (int u : g[v]) if (!used[u]) dfs1(u);
        order.push_back(v);
    }

    void dfs2(int v, int id) {
        comp[v] = id;
        for (int u : rg[v]) if (comp[u] == -1) dfs2(u, id);
    }

    bool solve(vector<bool>& value) {
        for (int v = 0; v < 2*n; ++v)
            if (!used[v]) dfs1(v);

        reverse(order.begin(), order.end());
        int id = 0;
        for (int v : order)
            if (comp[v] == -1) dfs2(v, id++);

        value.resize(n);
        for (int x = 0; x < n; ++x) {
            if (comp[2*x] == comp[2*x+1]) return false;
            value[x] = comp[2*x] > comp[2*x+1];
        }
        return true;
    }
};

solve, çelişki yoksa örnek bir doğruluk ataması da üretir. Bileşen numaralarına göre yapılan karşılaştırma, SCC’lerin yoğunlaştırılmış grafiğindeki ters topolojik sıradan yararlanır.

Sonuç olarak 2-SAT’ın gücü, mantığı kaba kuvvetle çözmek yerine onu erişilebilirlik problemine dönüştürmesinden gelir. Bir değişken kendi değiliyle aynı yönlü döngünün içine hapsolmuşsa çelişki kaçınılmazdır; aksi durumda bileşen sırası tutarlı bir atamayı doğrudan verir.

Derin bir sinir ağını eğitmek, onlarca kişilik bir kulaktan kulağa oyunu yönetmeye benzer: İlk katmandaki anlamlı sinyal, son katmana ulaşana kadar küçülebilir, büyüyebilir veya tamamen bozulabilir. Batch Normalization, yani Toplu Normalleştirme, katmanlar arasında dolaşan aktivasyonları daha düzenli ölçeklerde tutarak optimizasyonu kolaylaştırır. Böylece ağlar daha yüksek öğrenme oranlarıyla, daha kararlı ve çoğu zaman daha hızlı eğitilebilir. ``

Derin ağlarda sinyal neden bozulur?

Geri yayılım sırasında zincir kuralı uygulanır. Çok katmanlı bir ağdaki erken katmanın gradyanı kabaca şöyle düşünülebilir:

Buradaki her $g_i$, ilgili katmanın yerel türevidir. Değerlerin çoğu 1’den küçükse çarpım hızla sıfıra yaklaşır ve gradyan yok olması ortaya çıkar. Değerler büyükse bu kez gradyan patlayabilir. Ağırlık dağılımlarındaki değişimler ayrıca sonraki katmanların sürekli farklı ölçeklerde girdiler görmesine neden olur.

Batch Normalization bu sorunların tamamını sihirli biçimde çözmez; ancak aktivasyon ölçeklerini denetleyerek gradyanların daha sağlıklı akabileceği bir ortam oluşturur. ReLU, uygun ağırlık başlatma ve artık bağlantılar gibi tekniklerle birlikte kullanıldığında etkisi daha belirgindir.

Batch Normalization nasıl çalışır?

Bir mini-batch içindeki $m$ adet aktivasyon için önce ortalama ve varyans hesaplanır:

Ardından değerler normalize edilir ve öğrenilebilir iki parametreyle yeniden ölçeklenir:

Buradaki $epsilon$, sıfıra bölünmeyi önleyen küçük bir sabittir. $gamma$ ölçeği, $beta$ ise kaydırmayı öğrenir. Dolayısıyla Batch Normalization ağı her şeyi zorla standart normal dağılıma hapsetmez; model, ihtiyaç duyduğu dönüşümü yeniden kurabilir.

Eğitim ve tahmin arasındaki kritik fark

Eğitim sırasında o anki mini-batch’in istatistikleri kullanılır. Tahmin aşamasında ise tek örnek gelebileceğinden eğitim boyunca biriktirilen hareketli ortalama ve varyans devreye girer.

Bu nedenle PyTorch’ta değerlendirme öncesinde model.eval() çağrılmalıdır. Aksi hâlde model, tahmin sırasında da batch istatistikleri hesaplayarak tutarsız sonuçlar üretebilir.

PyTorch ile kullanım

Aşağıdaki ağda Batch Normalization, doğrusal katmandan sonra ve ReLU’dan önce uygulanır:

import torch.nn as nn

model = nn.Sequential(
    nn.Linear(128, 256),
    nn.BatchNorm1d(256),
    nn.ReLU(),
    nn.Linear(256, 10)
)

# Eğitim modu: mini-batch istatistikleri kullanılır.
model.train()

# Tahmin modu: hareketli istatistikler kullanılır.
model.eval()

Evrişimli ağlarda özellik kanallarını normalleştirmek için BatchNorm2d, zaman veya özellik tabanlı doğrusal verilerde ise çoğunlukla BatchNorm1d tercih edilir.

Her durumda iyi bir fikir mi?

Çok küçük batch boyutlarında ortalama ve varyans gürültülü olabilir. Bu durumda Layer Normalization veya Group Normalization daha kararlı seçeneklerdir. Transformer mimarilerinde de batch’ten bağımsız çalışabilen Layer Normalization yaygındır.

Özetle Batch Normalization, gradyan yok olmasını tek başına ortadan kaldıran bir kalkan değil, katmanlar arası sinyal trafiğini düzenleyen etkili bir trafik polisidir. Doğru konumlandırıldığında derin ağların eğitimini hızlandırır, optimizasyonu kararlı hâle getirir ve hiperparametre seçimindeki hassasiyeti azaltır.

``

Fenwick Ağacının temel fikri

Tek boyutlu BIT, her indeksin belirli uzunluktaki bir aralığın toplamını saklamasına dayanır. Bir indeksin sorumlu olduğu aralık, ikili gösterimindeki en düşük anlamlı bit ile belirlenir:

Örneğin $12=(1100)_2$ için $lowbit(12)=4$ olur. Güncelleme sırasında indeksleri $lowbit(i)$ kadar artırır, önek toplamında ise aynı miktarı çıkarırız. Böylece her işlem en fazla $O(\log n)$ düğüme dokunur.

İki boyutta aynı düşünceyi satır ve sütun eksenlerine ayrı ayrı uygularız. $(x,y)$ noktasına eklenen değer, iki iç içe Fenwick yürüyüşüyle ilgili hücrelere taşınır. Bir dikdörtgen toplamı ise dahil etme–hariç tutma ilkesiyle bulunur:

Burada $P(x,y)$, $(1,1)$ ile $(x,y)$ arasındaki önek toplamıdır.

Segment ağacı mı, Fenwick mi?

BIT’in önemli sınırlaması, işlemin tersinin bulunabilmesidir. Toplamada çıkarma sayesinde iki önekten aralık üretilebilir. Ancak genel minimum sorgusunda “önek minimumlarını çıkarma” diye bir işlem yoktur. Bu durumda segment ağacı daha doğru seçimdir.

Bellek dostu 2B uygulama

Aşağıdaki C++ sınıfı matrisi satır satır tek bir vector içinde tutar. Ayrı ayrı vektörler oluşturmadığı için tahsis maliyetini azaltır ve önbellek yerelliğini iyileştirir.

#include <bits/stdc++.h>
using namespace std;

class Fenwick2D {
    int n, m;
    vector<long long> bit;

    long long& at(int x, int y) {
        return bit[x * (m + 1) + y];
    }

public:
    Fenwick2D(int rows, int cols)
        : n(rows), m(cols), bit((rows + 1) * (cols + 1), 0) {}

    // (x, y) noktasına delta ekler.
    void add(int x, int y, long long delta) {
        for (int i = x; i <= n; i += i & -i)
            for (int j = y; j <= m; j += j & -j)
                at(i, j) += delta;
    }

    // (1,1) ile (x,y) arasındaki toplamı döndürür.
    long long prefix(int x, int y) {
        long long result = 0;
        for (int i = x; i > 0; i -= i & -i)
            for (int j = y; j > 0; j -= j & -j)
                result += at(i, j);
        return result;
    }

    long long rectangle(int x1, int y1, int x2, int y2) {
        return prefix(x2, y2) - prefix(x1 - 1, y2)
             - prefix(x2, y1 - 1) + prefix(x1 - 1, y1 - 1);
    }
};

İndekslerin 1’den başlaması önemlidir; sıfır için lowbit(0) sıfırdır ve güncelleme döngüsü ilerlemez.

Boyutlar devasa olduğunda

Koordinatlar milyarlara ulaşıyor fakat yalnızca birkaç bin nokta kullanılıyorsa tam matris ayırmak anlamsızdır. Güncelleme ve sorgulardaki koordinatları sıralayıp benzersizleştirerek koordinat sıkıştırma uygulanabilir. Her gerçek koordinat, sıralamadaki 1 tabanlı sırasına dönüştürülür.

$d$ boyutta güncelleme ve sorgu maliyeti yaklaşık $O(\log^d n)$ olur. Buna karşılık yoğun depolama $O(n^d)$ büyüdüğünden, pratikte üç ve üzeri boyutlarda yalnızca erişilen Fenwick hücrelerini karma tablo veya sıkıştırılmış iç vektörlerle saklamak gerekir. Kısacası toplam ve frekans sorgularında BIT, küçük kodu ve düşük sabit maliyetiyle güçlüdür; karmaşık birleştirme işlemlerinde ise segment ağacı hâlâ sahnededir.

``

Few-shot prompting nedir?

Few-shot prompting, bir görevin nasıl yapılacağını modelin girdisine yerleştirilen az sayıdaki örnek üzerinden tarif etme tekniğidir. Modelin parametreleri değişmez; öğrenme, yalnızca mevcut bağlam penceresi içinde gerçekleşir. Bu nedenle süreç gerçek bir eğitimden ziyade bağlam içi öğrenme olarak adlandırılır.

Bir dil modeli, sıradaki parçanın olasılığını yaklaşık olarak şöyle hesaplar:

Burada $x$ yeni girdi, $y$ beklenen çıktı ve $E$ ise prompt içine koyduğumuz örnekler kümesidir. Örnekler modele yalnızca cevabı değil; biçimi, tonu, sınıfları ve karar sınırlarını da sezdirir.

Neden üç örnek işe yarayabilir?

İyi seçilmiş üç örnek, görevin farklı köşelerini temsil edebilir. Örneğin müşteri yorumlarını sınıflandırırken bir olumlu, bir olumsuz ve bir kararsız yorum göstermek, modelin olası çıktı uzayını anlamasını kolaylaştırır:

Yorum: Ürün harika, teslimat da hızlıydı.
Etiket: olumlu

Yorum: Paket yırtılmış ve ürün çalışmıyor.
Etiket: olumsuz

Yorum: Fiyat iyi ama malzeme kalitesi ortalama.
Etiket: kararsız

Yorum: Kurulumu kolaydı fakat pil ömrü çok kısa.
Etiket:

Model burada yalnızca kelime eşleştirme yapmaz. Önceki örneklerden beklenen etiket biçimini ve karışık duyguların nasıl değerlendirildiğini çıkarır. Yine de örneklerin sırası veya ifadeleri değiştiğinde sonuç farklılaşabilir.

Python ile dinamik prompt oluşturma

Aşağıdaki kod, örnekleri tek bir şablonda birleştirerek yeni yorum için sınıflandırma promptu üretir:

examples = [
    ('Arayüz çok kullanışlı.', 'olumlu'),
    ('Uygulama sürekli çöküyor.', 'olumsuz'),
    ('Hızlı ama tasarımı eski.', 'kararsız')
]

def build_prompt(new_review):
    parts = ['Yorumları olumlu, olumsuz veya kararsız olarak etiketle.']

    for review, label in examples:
        parts.append(f'Yorum: {review}\nEtiket: {label}')

    parts.append(f'Yorum: {new_review}\nEtiket:')
    return '\n\n'.join(parts)

prompt = build_prompt('Özellikleri güzel fakat abonelik pahalı.')
print(prompt)

Bu yaklaşımda örnekleri koddan bağımsız bir veri kaynağında tutabilir, göreve göre en uygun olanları seçebiliriz. Büyük sistemlerde benzer örnekler gömme vektörleriyle aranarak prompta otomatik biçimde eklenir.

İyi örnek seçmenin kuralları

• Örnekler gerçek kullanıcı girdilerine benzemelidir.
• Her olası sınıf en az bir kez temsil edilmelidir.
• Çıktı biçimi bütün örneklerde tutarlı kalmalıdır.
• Birbirini çürüten veya hatalı etiketlenmiş örneklerden kaçınılmalıdır.
• En alakalı örnekleri yeni girdiye yakın yerleştirmek denenmelidir.

Few-shot prompting sihirli bir değnek değildir. Uzun örnekler token maliyetini artırır; taraflı örnekler ise taraflı cevaplar üretir. Ayrıca prompt içindeki kullanıcı metni talimat gibi algılanabileceğinden güvenilmeyen girdiler açık ayraçlarla sınırlandırılmalıdır.

Sonuç olarak birkaç kaliteli örnek, dev bir modeli görev odaklı bir asistana dönüştürebilir. Başarının sırrı örnek sayısını artırmak değil, karar uzayını açıklayan temsil gücü yüksek örnekleri seçmektir. Modeli uysallaştıran şey kırbaç değil; iyi hazırlanmış üç küçük ipucudur.

``

Uzun çarpma neden yavaş?

İki sayının da $N$ basamaklı olduğunu düşünelim. Geleneksel yöntemde birinci sayının her basamağı, ikinci sayının her basamağıyla çarpılır. Dolayısıyla yaklaşık $N^2$ işlem gerekir:

Basamak sayısı iki katına çıktığında çalışma miktarı yaklaşık dört katına çıkar. FFT tabanlı yaklaşımda ise büyüme çok daha sakindir:

Sayıları polinoma dönüştürmek

Örneğin $1234$ sayısını şu polinomla temsil edebiliriz:

Burada $x=10$ seçildiğinde yeniden 1234 elde edilir. İki sayıyı çarpmak, bunlara karşılık gelen polinomları çarpmaya eşdeğerdir. Polinom çarpımındaki katsayılar ise ayrık konvolüsyonla bulunur:

Bu formül doğrudan uygulanırsa yine $O(N^2)$ zaman harcar. FFT’nin sihri, konvolüsyonu noktasal çarpıma dönüştürmesidir:

Yani önce katsayıları frekans uzayına taşır, karşılık gelen değerleri tek tek çarpar ve ters FFT ile geri döneriz.

Birim kökler ve böl-parçala-yönet

Ayrık Fourier Dönüşümü şu şekilde tanımlanır:

Üstel ifadeler, karmaşık düzlemde eşit aralıklarla yerleşmiş $N$’inci birim köklerdir. FFT, çift ve tek indeksli katsayıları ayırarak aynı hesaplamaları tekrar yapmaktan kurtulur. Her seviyede toplam $O(N)$ iş yapılır ve yaklaşık $\log_2N$ seviye bulunur.

Python ile sade bir uygulama

Aşağıdaki örnek, sayıları onluk basamaklarına ayırır. NumPy FFT hesaplamasını yapar; son döngü ise yuvarlama ve elde taşıma işlemlerini düzeltir.

import numpy as np

def fft_multiply(x: str, y: str) -> str:
    a = np.array([int(d) for d in x[::-1]], dtype=float)
    b = np.array([int(d) for d in y[::-1]], dtype=float)

    size = 1
    while size < len(a) + len(b):
        size *= 2

    fa = np.fft.fft(a, size)
    fb = np.fft.fft(b, size)
    coefficients = np.rint(np.fft.ifft(fa * fb).real).astype(np.int64)

    carry = 0
    digits = []
    for value in coefficients:
        total = int(value) + carry
        digits.append(total % 10)
        carry = total // 10

    while carry:
        digits.append(carry % 10)
        carry //= 10

    while len(digits) > 1 and digits[-1] == 0:
        digits.pop()

    return ''.join(map(str, digits[::-1]))

print(fft_multiply("123456789012345", "987654321098765"))

Bu uygulama öğreticidir; kayan nokta hataları nedeniyle gerçekten milyonlarca basamakta güvenilir olmayabilir. Pratik sistemler basamakları daha büyük bloklara ayırır veya modüler aritmetik kullanan Sayı Teorik Dönüşümü’nü (NTT) tercih eder. Birden fazla asal modülle yapılan sonuçlar Çin Kalan Teoremi aracılığıyla birleştirilebilir.

Sonuçta FFT yalnızca ses ve görüntü analizi yapan bir araç değildir. Büyük sayı çarpımını polinom çarpımına, polinom çarpımını konvolüsyona ve konvolüsyonu ucuz noktasal çarpımlara dönüştüren güçlü bir algoritmik köprüdür.