``

eBPF tam olarak nedir?

eBPF, kullanıcı alanında hazırlanan programların Linux çekirdeğindeki belirli kancalara yüklenmesini sağlayan bir çalışma ortamıdır. İsmindeki BPF, tarihsel olarak “Berkeley Packet Filter” anlamına gelse de teknoloji bugün ağ paketlerinin çok ötesine uzanır: sistem çağrıları, süreçler, dosya erişimleri ve performans olayları da izlenebilir.

“Çekirdeğe dokunmadan” ifadesi, kodun çekirdek dışında çalıştığı anlamına gelmez. eBPF programı çekirdek bağlamında çalışır; ancak çekirdek kaynak kodunu değiştirmeye veya özel bir modül yüklemeye gerek bırakmaz. Program yüklenmeden önce verifier tarafından incelenir. Geçersiz bellek erişimi, güvensiz işaretçi kullanımı veya sonlanmama riski varsa program reddedilir.

XDP neden bu kadar hızlı?

XDP, yani eXpress Data Path, paketi ağ sürücüsünden gelir gelmez işleyebilir. Paket henüz sk_buff yapısına dönüştürülmeden karar verildiği için ayırma, kopyalama ve ağ yığını maliyetleri azaltılır.

Bir paketin yaklaşık işlem maliyetini şöyle düşünebiliriz:

XDP özellikle $T_{ayrıştırma}$ ve $T_{yönlendirme}$ bileşenlerini küçültür. Program paketi kabul etmek için XDP_PASS, düşürmek için XDP_DROP, başka arayüze göndermek için XDP_REDIRECT döndürebilir.

Aşağıdaki orta düzey örnek, IPv4 UDP paketlerini erken aşamada düşürür:

#include <linux/bpf.h>
#include <linux/if_ether.h>
#include <linux/ip.h>
#include <linux/udp.h>
#include <bpf/bpf_helpers.h>

SEC("xdp")
int drop_udp(struct xdp_md *ctx)
{
    void *data = (void *)(long)ctx->data;
    void *data_end = (void *)(long)ctx->data_end;
    struct ethhdr *eth = data;

    if ((void *)(eth + 1) > data_end)
        return XDP_ABORTED;

    if (eth->h_proto != __constant_htons(ETH_P_IP))
        return XDP_PASS;

    struct iphdr *ip = (void *)(eth + 1);
    if ((void *)(ip + 1) > data_end)
        return XDP_ABORTED;

    return ip->protocol == IPPROTO_UDP ? XDP_DROP : XDP_PASS;
}

char LICENSE[] SEC("license") = "GPL";

Sınır kontrolleri yalnızca iyi programlama alışkanlığı değildir; verifier, data_end kontrolü bulunmayan paket erişimini kabul etmez. Kod Clang ile eBPF bytecode’una çevrilip bir arayüze bağlanabilir:

clang -O2 -g -target bpf -c filter.c -o filter.o
sudo ip link set dev eth0 xdp obj filter.o sec xdp
sudo ip link set dev eth0 xdp off

İlk komut programı derler, ikincisi eth0 arayüzüne yükler, sonuncusu ise bağlantıyı kaldırır. Uzaktan bağlı bir sunucuda bütün UDP trafiğini düşürmeden önce DNS ve VPN kullanımını düşünmek iyi fikirdir; aksi hâlde güvenlik demosu hızla bağlantı kesme demosuna dönüşebilir.

Haritalar ve gözlemlenebilirlik

eBPF haritaları, çekirdek ve kullanıcı alanı arasında paylaşılan anahtar-değer depolarıdır. IP başına paket sayacı tutmak, engelli adresleri dinamik olarak güncellemek veya CPU başına istatistik toplamak için kullanılabilirler. Üretimde C ile doğrudan uğraşmak yerine libbpf, BCC, bpftrace, Cilium ve Rust tabanlı Aya gibi araçlardan yararlanılabilir.

TC kancaları paket değişikliği ve trafik şekillendirme konusunda daha esnekken XDP mümkün olan en erken kararı hedefler. Sonuç olarak eBPF, klasik çekirdek modüllerinin bütün risklerini üstlenmeden çekirdek hızına yaklaşan, programlanabilir bir ağ güvenliği ve izleme katmanı sunar.

Cgroups neyi çözer?

Cgroups, süreçleri gruplandırır ve CPU, bellek, disk G/Ç ya da süreç sayısı gibi kaynakları bu gruplar üzerinden denetler. Namespace’ler bir konteynerin neyi görebildiğini, cgroups ise ne kadar tüketebildiğini belirler. Dolayısıyla ikisi tamamlayıcıdır: namespace izolasyon perdesiyken cgroups kaynak bütçesidir.

Bir grubun CPU kullanım oranı basitçe

ile düşünülebilir. Burada $Q$ izin verilen CPU süresi, $P$ ise periyottur. Örneğin cpu.max dosyasına 50000 100000 yazılması, grubun her 100 milisaniyede en fazla 50 milisaniye CPU kullanabilmesi, yani yaklaşık $R=0.5$ CPU kapasitesi anlamına gelir.

v1 neden yorucuydu?

Cgroups v1’de her denetleyici bağımsız bir hiyerarşiye bağlanabiliyordu. Aynı süreç CPU ağacında bir grupta, bellek ağacında başka bir grupta bulunabiliyordu. Esneklik gibi görünen bu model; Docker, systemd ve Kubernetes gibi araçlar aynı makinede çalıştığında yönetim karmaşasına, belirsiz yetki devrine ve tutarsız kaynak davranışlarına yol açıyordu.

Birleşik hiyerarşi nasıl çalışır?

v2 çoğunlukla /sys/fs/cgroup altında tek bir ağaç sunar. Bir sürecin kimliği cgroup.procs, kullanılabilir denetleyiciler cgroup.controllers, alt gruplara aktarılacak denetleyiciler ise cgroup.subtree_control üzerinden yönetilir.

# Sistemde etkin olan v2 denetleyicilerini gösterir.
cat /sys/fs/cgroup/cgroup.controllers

# Yeni bir uygulama grubu oluşturur.
sudo mkdir /sys/fs/cgroup/demo

# Kabuğun PID'sini gruba taşır.
echo $$ | sudo tee /sys/fs/cgroup/demo/cgroup.procs

v2’nin önemli kurallarından biri no internal process constraint ilkesidir. Kaynak denetleyicileri alt gruplara dağıtan bir cgroup, normalde aynı anda doğrudan süreç barındırmaz. Başka bir deyişle dallar organizasyon, yapraklar iş yükü içindir. Bu kural, ebeveyn ve çocuk gruplar arasında kaynak hesabının bulanıklaşmasını önler.

Bellek, CPU ve süreç sınırları

Bellek tarafında memory.max kesin tavanı, memory.high ise çekirdeğin agresif geri kazanım uygulamaya başlayacağı yumuşak eşiği ifade eder. Böylece uygulamayı anında öldürmeden önce baskı oluşturmak mümkündür. memory.current mevcut tüketimi gösterirken memory.events, OOM gibi olayları sayar.

# Kesin bellek limitini 512 MiB yapar.
echo 536870912 | sudo tee /sys/fs/cgroup/demo/memory.max

# Yaklaşık yarım CPU ve en fazla 100 süreç tanımlar.
echo '50000 100000' | sudo tee /sys/fs/cgroup/demo/cpu.max
echo 100 | sudo tee /sys/fs/cgroup/demo/pids.max

CPU paylaşım önceliği için v1’deki cpu.shares yerine daha anlaşılır bir aralığa sahip cpu.weight kullanılır. G/Ç denetimi de io.max ve io.weight gibi tutarlı adlarla sunulur.

Docker açısından anlamı

Docker’daki --memory, --cpus ve --pids-limit seçenekleri sonuçta bu dosyalara dönüştürülür. Modern systemd sürümleri de servisleri cgroup ağacında doğal olarak düzenler. Tek hiyerarşi sayesinde orkestratör, çalışma zamanı ve init sistemi aynı kaynak ağacını paylaşabilir; “bu süreci aslında kim yönetiyor?” bilmecesi büyük ölçüde ortadan kalkar.

Cgroups v2 yalnızca temizlenmiş bir arayüz değildir. Tutarlı muhasebe, güvenli yetki devri, gelişmiş bellek baskısı ve sade hiyerarşi sayesinde konteyner izolasyonunu daha sağlam bir çekirdek sözleşmesine dönüştürür. Kısacası v1 kaynaklara ayrı ayrı kilit vuruyordu; v2 ise bütün binaya düzenli bir erişim planı çiziyor.

``

Fikir nereden çıktı?

“Öğrenmeyi öğrenme” düşüncesi yapay zekâdan daha eskidir. Psikoloji, insanların önceki deneyimlerinden yararlanarak yeni becerileri daha hızlı kazandığını uzun süredir inceliyordu. Makine öğrenmesinde ise erken dönem çalışmalar, algoritmaların kendi öğrenme kurallarını ayarlayıp ayarlayamayacağı sorusuna odaklandı.

1990’larda sinir ağlarının ağırlık güncellemelerini başka ağlarla yönetme fikri belirginleşti. 2000’lerde çoklu görev öğrenmesi ve aktarım öğrenmesi güçlü temeller sağladı. 2010’ların ortasında derin öğrenme, büyük veri kümeleri ve GPU’larla birleşince meta-learning uygulanabilir hâle geldi. 2016 tarihli Matching Networks ve 2017’de yayımlanan MAML, alanın en etkili dönüm noktaları arasında yer aldı.

Görevler üzerinden öğrenmek

Normal eğitimde veri noktaları örneklenir. Meta-learning eğitiminde ise görevler örneklenir. Her görev genellikle iki parçaya ayrılır:

• Destek kümesi: Modelin göreve uyum sağladığı az sayıdaki örnek.
• Sorgu kümesi: Uyumun gerçekten işe yarayıp yaramadığını ölçen örnekler.

Bir görev $T_i$ için destek kaybı $L_{S_i}$ olsun. Modelin başlangıç parametreleri $θ$ ise tek adımlık uyarlama şöyle yazılabilir:

Burada $α$ iç döngünün öğrenme oranıdır. Meta-model, uyarlanmış parametrelerin sorgu kümelerindeki toplam hatasını azaltmaya çalışır:

İşin sihri burada yatar: Sistem yalnızca doğru cevabı değil, birkaç gradyan adımından sonra iyi sonuç verecek bir başlangıç noktası öğrenir. MAML’ın modelden bağımsız sayılmasının nedeni de bu fikrin sınıflandırma, regresyon veya pekiştirmeli öğrenme gibi farklı alanlara uygulanabilmesidir.

Üç ana meta-learning ailesi

Metrik tabanlı yöntemlerde her sınıfın prototipi hesaplanabilir. $k$ sınıfına ait destek temsillerinin ortalaması:

Yeni örnek, temsili hangi $c_k$ noktasına daha yakınsa o sınıfa atanır. Bir bakıma model, “Bu fotoğraf hangi aile albümüne daha çok benziyor?” diye sorar.

MAML mantığının küçük bir kod karşılığı

Aşağıdaki PyTorch taslağı, tek görev için iç güncelleme yapar ve sorgu kaybını hesaplar. create_graph=True, dış döngünün iç güncelleme üzerinden türev alabilmesini sağlar:

import torch
from torch.func import functional_call

support_logits = model(x_support)
support_loss = loss_fn(support_logits, y_support)

params = dict(model.named_parameters())
grads = torch.autograd.grad(
    support_loss,
    params.values(),
    create_graph=True
)

fast_params = {
    name: param - inner_lr * grad
    for (name, param), grad in zip(params.items(), grads)
}

query_logits = functional_call(model, fast_params, (x_query,))
outer_loss = loss_fn(query_logits, y_query)

optimizer.zero_grad()
outer_loss.backward()
optimizer.step()

Gerçek uygulamada bu işlem birçok görev için tekrarlanır ve sorgu kayıpları ortalanır. Hesaplama maliyeti özellikle ikinci dereceden türevler nedeniyle yükselebilir; First-Order MAML ve Reptile gibi yöntemler bu yükü azaltmayı hedefler.

Neden önemli?

Meta-learning; nadir hastalıkların sınıflandırılması, yeni robot hareketleri, kişiselleştirilmiş öneriler ve az kaynaklı diller gibi verinin pahalı olduğu alanlarda değerlidir. Yine de görev dağılımı kötü seçilirse model yeni koşullara uyum sağlayamaz. Kısacası öğrenmeyi öğrenen bir sistem de öğretmeninin hazırladığı müfredat kadar iyidir. Meta-learning’in büyük vaadi, her şeyi bilen modeller değil; bilmediği bir şeyle karşılaştığında ne yapacağını daha çabuk anlayan modeller üretmesidir.

Halkaların temel mantığı

İşlemci, çalışan kodun hangi ayrıcalık seviyesinde olduğunu takip eder. x86 terminolojisinde mevcut seviye CPL (Current Privilege Level) olarak adlandırılır. Kaynakların ve kod bölümlerinin erişim seviyesi ise DPL (Descriptor Privilege Level) gibi alanlarla belirtilir.

Basitleştirilmiş erişim düşüncesi şu eşitsizlikle anlatılabilir:

Burada küçük sayı daha yüksek yetkiyi temsil eder. Dolayısıyla Ring 0 kodu pek çok ayrıcalıklı kaynağa ulaşabilirken Ring 3 kodu aynı işlemi yapmaya çalıştığında işlemci bir koruma hatası üretir.

Linux, Windows ve çoğu genel amaçlı işletim sistemi pratikte iki seviyeli bir model kullanır: çekirdek Ring 0’da, uygulamalar Ring 3’te çalışır. Ring 1 ve Ring 2 donanımda bulunsa da taşınabilirlik ve tasarım sadeliği nedeniyle çoğunlukla boş bırakılır.

Duvar işlemci seviyesinde nasıl kurulur?

Duvarın ilk tuğlası ayrıcalıklı komutlardır. Kesme sistemini kapatan cli, kontrol yazmaçlarını değiştiren talimatlar veya sayfa tablolarını yöneten işlemler Ring 3’te yürütülemez. Bir uygulama bunları denerse CPU işlemi reddeder ve çekirdeğe bir istisna bildirir.

İkinci tuğla bellek korumasıdır. Sanal bellekteki her sayfa için sayfa tablosu girdileri bulunur. x86 mimarisindeki U/S biti, sayfanın kullanıcı modundan erişilebilir olup olmadığını belirtir:

Buna yazılabilirlik ve çalıştırılabilirlik bitleri de eklenir. Böylece bir süreç başka bir sürecin ya da çekirdeğin belleğine yalnızca adresini tahmin ederek ulaşamaz.

Uygulamalar hizmeti nasıl ister?

Ring 3 tamamen çaresiz değildir; çekirdekten kontrollü biçimde yardım ister. Bunun kapısı sistem çağrısıdır. x86-64 sistemlerinde syscall komutu işlemciyi önceden belirlenmiş çekirdek giriş noktasına taşır, ayrıcalık seviyesini değiştirir ve kullanıcı bağlamının geri yüklenebilmesi için gerekli bilgileri saklar.

#include <unistd.h>

int main(void) {
    const char mesaj[] = "Merhaba, cekirdek!\n";
    write(1, mesaj, sizeof(mesaj) - 1);
    return 0;
}

Buradaki write, ekrana doğrudan erişmez. Standart kütüphane uygun sistem çağrısını başlatır; çekirdek dosya tanımlayıcısını ve kullanıcı belleğindeki adresi doğrular. İstek güvenliyse terminal sürücüsüne kadar uzanan işi çekirdek gerçekleştirir.

Geçişin maliyeti kabaca şöyle düşünülebilir:

Bu nedenle her küçük işlem için sistem çağrısı yapmak yerine tamponlama kullanılır. Örneğin yüzlerce karakter tek tek değil, bir blok hâlinde yazılabilir.

Kesintiler, hatalar ve kontrollü dönüş

Donanım kesintileri ve sayfa hataları da kontrolü çekirdeğe aktarabilir. İşlemci, IDT içindeki hedef kapının yetki kurallarını denetler; rastgele bir adrese sıçramaz. Çekirdek olayı işledikten sonra özel dönüş talimatlarıyla Ring 3 bağlamını geri yükler.

Sonuç olarak kullanıcı modu ile çekirdek modu arasındaki duvar basit bir programlama geleneği değildir. Ayrıcalıklı komutlar, sayfa tabloları, kesme kapıları ve sistem çağrısı mekanizması birlikte çalışır. Uygulama kontrolden çıksa bile işlemci ona nazikçe ama kesin biçimde şunu söyler: Donanıma dokunmak istiyorsan önce çekirdekten izin al.

``

Sürü zekâsı nedir?

Sürü zekâsı, basit kuralları izleyen çok sayıda bireyin etkileşiminden ortaya çıkan kolektif problem çözme yeteneğidir. Buradaki temel fikir, tek bir bireyin kusursuz olmasına gerek olmadığıdır. Bireyler kendi deneyimlerini grubun deneyimiyle birleştirdiğinde etkili bir arama mekanizması oluşur.

PSO, 1995 yılında James Kennedy ve Russell Eberhart tarafından geliştirilmiştir. Algoritmada her olası çözüm bir parçacık, tüm parçacıklar ise bir sürü olarak temsil edilir. Parçacıklar çözüm uzayında dolaşarak amaç fonksiyonunun en iyi değerini arar.

PSO nasıl çalışır?

Her parçacığın bir konumu $x_i$ ve hızı $v_i$ bulunur. Ayrıca parçacık, şimdiye kadar keşfettiği en iyi konumu $p_i$ olarak hatırlar. Sürünün bulduğu en iyi konum ise $g$ ile gösterilir.

Hız güncelleme denklemi şöyledir:

Yeni konum da şu şekilde hesaplanır:

Burada $w$ eylemsizlik katsayısıdır ve parçacığın önceki yönünü ne kadar koruyacağını belirler. $c_1$ bilişsel katsayıdır; parçacığın kendi deneyimine bağlılığını temsil eder. $c_2$ sosyal katsayıdır ve sürünün keşfine verilen önemi kontrol eder. $r_1$ ile $r_2$, $[0,1]$ aralığında rastgele sayılardır. Bu rastlantısallık, bütün parçacıkların erkenden aynı noktaya yığılmasını önlemeye yardımcı olur.

Python ile basit bir uygulama

Aşağıdaki örnek, $f(x)=x^2$ fonksiyonunun minimumunu arar. Teorik minimum $x=0$ noktasındadır.

import random

parcacik_sayisi = 20
konumlar = [random.uniform(-10, 10) for _ in range(parcacik_sayisi)]
hizlar = [random.uniform(-1, 1) for _ in range(parcacik_sayisi)]
kisisel_en_iyi = konumlar.copy()

def uygunluk(x):
    return x ** 2

kuresel_en_iyi = min(kisisel_en_iyi, key=uygunluk)

for _ in range(100):
    for i in range(parcacik_sayisi):
        r1, r2 = random.random(), random.random()
        hizlar[i] = (
            0.7 * hizlar[i]
            + 1.5 * r1 * (kisisel_en_iyi[i] - konumlar[i])
            + 1.5 * r2 * (kuresel_en_iyi - konumlar[i])
        )
        konumlar[i] += hizlar[i]

        if uygunluk(konumlar[i]) < uygunluk(kisisel_en_iyi[i]):
            kisisel_en_iyi[i] = konumlar[i]

    kuresel_en_iyi = min(kisisel_en_iyi, key=uygunluk)

print("Bulunan minimum noktası:", kuresel_en_iyi)

Kod, parçacıkları rastgele başlatır; ardından hız ve konumlarını 100 tur boyunca günceller. Her turda bireysel ve küresel rekorlar yenilenir. Sonuç genellikle sıfıra oldukça yakın çıkar.

Yapay zekâdaki kullanım alanları

PSO; sinir ağlarının ağırlıklarını ayarlamak, özellik seçmek, hiperparametre optimizasyonu yapmak, robot rotaları planlamak ve enerji sistemlerini düzenlemek için kullanılabilir. Türev bilgisi istememesi, karmaşık ve doğrusal olmayan problemlerde önemli bir avantajdır. Buna karşılık doğru katsayılar seçilmezse yerel optimuma erken yakınsayabilir ve yüksek boyutlarda maliyetli hâle gelebilir.

Kısacası PSO, “en iyi çözümü tek başına bul” yaklaşımı yerine “deneyimini paylaş ve birlikte ara” der. Bazen karmaşık bir problemi çözmek için gereken şey daha güçlü bir birey değil, daha iyi iletişim kuran bir sürüdür.

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.