Federasyonel Öğrenme (Federated Learning): Verilerinizi Paylaşmadan Yapay Zekayı Eğitmek

Geleneksel makine öğrenimi sürecinde, veri toplama ilk ve genellikle en maliyetli adımdır. Bir modeli eğitmek için; fotoğraflar, kısa mesajlar, sağlık kayıtları veya finansal işlemler gibi ham kullanıcı verilerini toplamanız ve bunları merkezi bir bulut sunucusuna yüklemeniz gerekir.

Bu merkezi yaklaşım yapay zeka devrimine güç vermiş olsa da büyük zorluklarla karşı karşıyadır:

1. Gizlilik Endişeleri: Kullanıcılar, özel verilerini üçüncü taraf sunuculara yükleme konusunda giderek daha isteksiz hale gelmektedir.
2. Veri Düzenlemeleri: GDPR ve HIPAA gibi düzenlemeler, kişisel verilerin nasıl aktarılabileceğini ve saklanabileceğini sıkı bir şekilde kısıtlar.
3. Bant Genişliği Maliyetleri: Milyonlarca uç cihazdan (akıllı telefonlar gibi) gigabaytlarca ham veri yüklemek son derece verimsizdir.

Federasyonel Öğrenme (Federated Learning - FL), geleneksel paradigmayı tersine çevirerek bu sorunları çözer. Veriyi modele getirmek yerine, modeli veriye götürür.

Temel Konsept: Merkeziyetsiz Eğitim

Federasyonel Öğrenmede, merkezi sunucu bir küresel model barındırır. Sunucu, bu modeli eğitmek için ham veri toplamak yerine; akıllı telefonlar, akıllı ev cihazları veya bölgesel hastane veritabanları gibi uç cihazlardan (istemciler) oluşan bir ağ genelinde işbirlikçi bir eğitim sürecini koordine eder.

Federasyonel Öğrenmenin temel kuralı şudur:

Ham veri asla yerel cihazı terk etmez. Yalnızca matematiksel model güncellemeleri paylaşılır.

Adım Adım İşleyiş: Nasıl Çalışır?

Tipik bir Federasyonel Öğrenme eğitim döngüsü (bir iletişim turu olarak bilinir) beş ana adımdan oluşur:

sequenceDiagram
    participant Server as Merkezi Sunucu (Küresel Model)
    participant ClientA as İstemci A (Özel Veri A)
    participant ClientB as İstemci B (Özel Veri B)
    
    rect rgb(240, 248, 255)
        Note over Server: Adım 1: Küresel Modeli Başlat
    end
    Server->>ClientA: Adım 2: Küresel Ağırlıkları Gönder (W_t)
    Server->>ClientB: Adım 2: Küresel Ağırlıkları Gönder (W_t)
    rect rgb(245, 245, 245)
        Note over ClientA: Adım 3: Özel Verilerle Yerelde Eğit
        Note over ClientB: Adım 3: Özel Verilerle Yerelde Eğit
    end
    ClientA->>Server: Adım 4: Yerel Güncellemeleri Gönder (W_t^A)
    ClientB->>Server: Adım 4: Yerel Güncellemeleri Gönder (W_t^B)
    rect rgb(240, 255, 240)
        Note over Server: Adım 5: Güncellemeleri Ortalama (FedAvg)<br/>Küresel Modeli Güncelle (W_t+1)
    end

1. Başlatma (Initialization)

Merkezi sunucu, küresel modeli başlangıç ağırlıklarıyla ($W_0$) başlatır. Bu ağırlıklar rastgele olabilir veya halka açık bir veri kümesinde önceden eğitilmiş olabilir.

2. Dağıtım (Model Broadcast)

Sunucu, mevcut istemci cihazların bir alt kümesini seçer (örneğin şarja takılı, Wi-Fi’ye bağlı ve boşta olan telefonlar) ve mevcut küresel model ağırlıklarını ($W_t$) bunlara yayınlar.

3. Yerel Eğitim

Seçilen her istemci, aldığı küresel modeli kendi yerel ve özel veri kümesinde eğitir. Bu, Stokastik Gradyan İnişi (SGD) gibi standart optimizasyon algoritmaları kullanılarak yapılır. Birkaç epoch sonunda, her istemci $i$ yeni bir yerel model ağırlıkları kümesi ($W_t^i$) üretir.

4. Yerel Güncellemeleri Yükleme

İstemciler, özel eğitim verilerini göndermek yerine yalnızca yeni yerel model ağırlıklarını (veya $\Delta W_t^i = W_t^i - W_t$ farkını) merkezi sunucuya geri gönderir. Bu güncellemeler genellikle kriptografik protokoller kullanılarak şifrelenir.

5. Küresel Agregasyon (Birleştirme)

Merkezi sunucu, katılan tüm istemcilerden gelen güncellemeleri toplar. Yeni bir küresel model ($W_{t+1}$) üretmek için bunları ortalamasını alır (genellikle her istemcinin sahip olduğu yerel veri miktarına göre ağırlıklandırılır). Bunun için en yaygın algoritma Federated Averaging (FedAvg)‘dir:

$$W_{t+1} = \sum_{i=1}^{K} \frac{n_i}{N} W_t^i$$

Burada:

• $K$ katılan istemci sayısıdır.
• $n_i$ istemci $i$ üzerindeki veri örneği sayısıdır.
• $N$ katılan tüm istemcilerdeki toplam veri örneği sayısıdır ($N = \sum n_i$).

Bu döngü, küresel model istenen doğruluğa ulaşana kadar birçok tur boyunca tekrarlanır.

Kod Örneği: Basit Bir Python Simülasyonu

Federasyonel Öğrenmeyi iş başında görmek için, NumPy kullanarak basit bir Python simülasyonu yazalım.

Bu senaryoda, doğrusal regresyon kullanarak ev fiyatlarını ($y = w \cdot x$) tahmin edecek bir modeli eğitmek istiyoruz. Bir merkezi sunucumuz ve her birinin kendine ait özel ev büyüklükleri ($x$) ve fiyatları ($y$) olan 3 istemcimiz var.

import numpy as np

# 1. İstemci Özel Verilerini Kurun (Sunucuyla paylaşılamaz)
# Her istemcinin farklı sayıda yerel örneği vardır (n_i)
clients_data = {
    "Client_1": {"x": np.array([1.0, 1.5, 2.0]), "y": np.array([110.0, 160.0, 210.0])}, # Gerçek ilişki: y = 100x + 10
    "Client_2": {"x": np.array([0.8, 1.2]),       "y": np.array([90.0, 130.0])},       # Gerçek ilişki: y = 100x + 10
    "Client_3": {"x": np.array([2.5, 3.0, 3.5]), "y": np.array([260.0, 310.0, 360.0])}  # Gerçek ilişki: y = 100x + 10
}

# Tüm istemcilerdeki toplam veri noktası sayısı (N)
total_samples = sum(len(data["x"]) for data in clients_data.values())

# 2. Sunucu Başlangıç Ağırlığı (Küresel Model: W_t)
global_weight = 10.0  # İlk tahmin (gerçek değer olan 100.0'den çok uzak)
learning_rate = 0.05
epochs = 5  # Tur başına yerel eğitim epoch sayısı
communication_rounds = 3

print(f"Başlangıç Küresel Ağırlığı: {global_weight:.2f}\n")

# Federasyonel Öğrenme Döngüsü
for round_idx in range(communication_rounds):
    print(f"--- İletişim Turu {round_idx + 1} ---")
    local_weights = []
    client_sample_sizes = []
    
    # Adım 2 & 3: Model Dağıtımı ve İstemci Cihazlarda Yerel Eğitim
    for client_name, data in clients_data.items():
        x = data["x"]
        y = data["y"]
        n_i = len(x)
        
        # İstemci küresel ağırlığı alır
        w_local = global_weight
        
        # İstemci birkaç epoch boyunca yerelde eğitim yapar
        for epoch in range(epochs):
            # Tahmini hesapla: y_pred = w * x
            y_pred = w_local * x
            # Basit doğrusal regresyon için gradyanı hesapla
            gradient = -2 * np.mean(x * (y - y_pred))
            # Yerel ağırlığı güncelle
            w_local -= learning_rate * gradient
            
        print(f"  {client_name} yerel ağırlığı şu değere eğitti: {w_local:.2f} (örnek sayısı: {n_i})")
        
        # Agregasyon için yerel ağırlıkları ve örnek boyutlarını kaydet
        local_weights.append(w_local)
        client_sample_sizes.append(n_i)
        
    # Adım 4 & 5: Federasyonel Ortalama (FedAvg) kullanarak sunucu tarafında agregasyon
    weighted_sum = 0.0
    for w, n in zip(local_weights, client_sample_sizes):
        weighted_sum += w * n
        
    global_weight = weighted_sum / total_samples
    print(f"=> Sunucu küresel ağırlığı birleştirdi: {global_weight:.2f}\n")

print(f"FL sonrasında nihai küresel model ağırlığı: {global_weight:.2f}")

Bu kod neden Federasyonel Öğrenmeyi temsil eder?

• clients_data sözlüğü yalıtılmış veritabanlarını temsil eder. Sunucu bunlara asla erişemez.
• Eğitim döngüsünde istemciden sunucuya iletilen tek değişken w_local‘dir.
• Sunucu, FedAvg matematiksel formülünü uygulayan örnek boyutlarına (client_sample_sizes) dayalı ağırlıklı bir ortalama gerçekleştirir.

Merkeziyetçi Öğrenme vs. Federasyonel Öğrenme

Güvenlik Eklentileri: Gizlilik ve Şifreleme

Federasyonel Öğrenme doğası gereği merkezi eğitimden daha güvenli olsa da, sunucuya ham ağırlıkların gönderilmesi hala küçük gizlilik riskleri taşır (çünkü ağırlıklar bazen eğitim verilerini yeniden oluşturmak için tersine mühendisliğe tabi tutulabilir). Buna karşı koymak için Federasyonel Öğrenme iki temel güvenlik tekniği ile birleştirilir:

1. Güvenli Agregasyon (Secure Aggregation - SecAgg): Sunucunun, tek bir istemcinin yerel model güncellemesini görmeden tüm yerel model güncellemelerinin toplamını hesaplamasına olanak tanıyan kriptografik bir protokol. Sunucu yalnızca birleştirilmiş sonucu görür.
2. Diferansiyel Gizlilik (Differential Privacy - DP): Yüklemeden önce yerel ağırlıklara matematiksel “gürültü” eklenmesi. Bu, hiçbir bireysel kullanıcının verisinin küresel model tarafından ayırt edilememesini veya hafızaya alınamamasını sağlar.

Gerçek Hayat Örnekleri

Federasyonel Öğrenme bugün zaten cihazlarınızda sessizce çalışıyor:

• Google Gboard: Google, sonraki kelime tahmini ve arama sorgusu önerilerini eğitmek için Federasyonel Öğrenme kullanır. Klavyeniz, tuş vuruşlarınızı Google sunucularına göndermeden yazma alışkanlıklarınızı öğrenir.
• Apple QuickType: Apple, iPhone’larda otomatik düzeltmeyi ve Siri ses tanıma önerilerini doğrudan geliştirmek için merkeziyetsiz eğitimden yararlanır.
• Sağlık Hizmetleri (MELLODDY Projesi): Lider ilaç şirketleri, tescilli araştırmalarını rakiplerine ifşa etmeden, özel kimyasal veritabanları üzerinde ilaç keşif modellerini işbirlikçi bir şekilde eğitmek için Federasyonel Öğrenme kullanır.

Özet

Federasyonel Öğrenme, yapay zeka sistemlerini kurma şeklimizde bir paradigma değişimine işaret ediyor. Veri sahipliğine saygı duyar, iletişim maliyetlerini en aza indirir ve yüksek düzeyde denetlenen sektörlerde yapay zeka eğitimini mümkün kılar. Eğitim sürecini uç noktalara taşıyarak, kişisel verilerimizi tam olarak ait olduğu yerde, yani kendi ellerimizde tutarken daha akıllı ve daha kişiselleştirilmiş modeller geliştirebiliriz.

Ghaznix Blog’unda merkeziyetsiz teknoloji hakkında daha fazla içgörü keşfedin →