Föderiertes Lernen: KI-Training ohne Weitergabe Ihrer Daten

In der traditionellen Pipeline des maschinellen Lernens ist die Datenerfassung der erste und oft teuerste Schritt. Um ein Modell zu trainieren, müssen Sie rohe Benutzerdaten wie Fotos, Textnachrichten, Gesundheitsakten oder Finanztransaktionen sammeln und auf einen zentralen Cloud-Server hochladen.

Obwohl dieser zentralisierte Ansatz die KI-Revolution vorangetrieben hat, steht er vor großen Herausforderungen:

1. Datenschutzbedenken: Benutzer zögern zunehmend, private Daten auf Server von Drittanbietern hochzuladen.
2. Datenregulierung: Vorschriften wie die DSGVO schränken die Übertragung und Speicherung personenbezogener Daten streng ein.
3. Bandbreitenkosten: Das Hochladen von Gigabytes an Rohdaten von Millionen von Edge-Geräten (wie Smartphones) ist äußerst ineffizient.

Föderiertes Lernen (Federated Learning - FL) löst diese Probleme, indem es das traditionelle Paradigma auf den Kopf stellt. Anstatt die Daten zum Modell zu bringen, bringt es das Modell zu den Daten.

Das Kernkonzept: Dezentrales Training

Beim föderierten Lernen unterhält der zentrale Server ein globales Modell. Anstatt Rohdaten zu sammeln, um dieses Modell zu trainieren, koordiniert der Server einen kollaborativen Trainingsprozess über ein Netzwerk von Edge-Geräten (Clients) wie Smartphones, Smart-Home-Geräten oder regionalen Krankenhausdatenbanken.

Hier ist die Grundregel des föderierten Lernens:

Rohdaten verlassen niemals das lokale Gerät. Nur mathematische Modellaktualisierungen werden geteilt.

Schritt-für-Schritt-Walkthrough: Wie es funktioniert

Ein typischer Trainingszyklus im föderierten Lernen (bekannt als Kommunikationsrunde) besteht aus fünf Hauptschritten:

sequenceDiagram
    participant Server as Zentraler Server (Globales Modell)
    participant ClientA as Client A (Private Daten A)
    participant ClientB as Client B (Private Daten B)
    
    rect rgb(240, 248, 255)
        Note over Server: Schritt 1: Globales Modell initialisieren
    end
    Server->>ClientA: Schritt 2: Globale Gewichte senden (W_t)
    Server->>ClientB: Schritt 2: Globale Gewichte senden (W_t)
    rect rgb(245, 245, 245)
        Note over ClientA: Schritt 3: Lokal auf privaten Daten trainieren
        Note over ClientB: Schritt 3: Lokal auf privaten Daten trainieren
    end
    ClientA->>Server: Schritt 4: Lokale Updates senden (W_t^A)
    ClientB->>Server: Schritt 4: Lokale Updates senden (W_t^B)
    rect rgb(240, 255, 240)
        Note over Server: Schritt 5: Updates mitteln (FedAvg)<br/>Globales Modell aktualisieren (W_t+1)
    end

1. Initialisierung

Der zentrale Server initialisiert das globale Modell mit Startgewichten ($W_0$). Diese Gewichte können zufällig sein oder auf einem öffentlichen Datensatz vortrainiert werden.

2. Verteilung (Modell-Broadcast)

Der Server wählt eine Teilmenge der verfügbaren Client-Geräte aus (z. B. Smartphones, die an den Strom angeschlossen sind, sich im WLAN befinden und inaktiv sind) und sendet die aktuellen globalen Modellgewichte ($W_t$) an sie.

3. Lokales Training

Jeder ausgewählte Client trainiert das empfangene globale Modell auf seinem eigenen lokalen, privaten Datensatz. Dies geschieht mit Standard-Optimierungsalgorithmen wie dem stochastischen Gradientenabstieg (SGD). Nach einigen Epochen erzeugt jeder Client $i$ einen neuen Satz lokaler Modellgewichte ($W_t^i$).

4. Hochladen lokaler Updates

Anstatt die privaten Trainingsdaten zu senden, senden die Clients nur ihre neuen lokalen Modellgewichte (oder die Differenz $\Delta W_t^i = W_t^i - W_t$) zurück an den zentralen Server. Diese Updates werden in der Regel durch kryptografische Protokolle geschützt.

5. Globale Aggregation

Der zentrale Server sammelt die Updates aller teilnehmenden Clients. Er berechnet den gewichteten Mittelwert (normalerweise gewichtet nach der Menge der lokalen Daten des Clients), um ein neues globales Modell ($W_{t+1}$) zu erstellen. Der am häufigsten verwendete Algorithmus hierfür ist Federated Averaging (FedAvg):

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

Dabei ist:

• $K$ die Anzahl der teilnehmenden Clients.
• $n_i$ die Anzahl der Datenpunkte auf Client $i$.
• $N$ die Gesamtzahl der Datenpunkte über alle teilnehmenden Clients hinweg ($N = \sum n_i$).

Dieser Zyklus wiederholt sich über viele Runden, bis das globale Modell die gewünschte Genauigkeit erreicht.

Code-Beispiel: Eine einfache Python-Simulation

Um föderiertes Lernen in Aktion zu sehen, schreiben wir eine einfache Python-Simulation mit NumPy.

In diesem Szenario möchten wir ein Modell trainieren, um Hauspreise ($y = w \cdot x$) mittels linearer Regression vorherzusagen. Wir haben einen zentralen Server und 3 Clients, von denen jeder seine eigenen privaten Hausgrößen ($x$) und Preise ($y$) hat.

import numpy as np

# 1. Setup der privaten Client-Daten (Dürfen nicht mit dem Server geteilt werden)
# Jeder Client hat eine unterschiedliche Anzahl lokaler Proben (n_i)
clients_data = {
    "Client_1": {"x": np.array([1.0, 1.5, 2.0]), "y": np.array([110.0, 160.0, 210.0])}, # Wahre Beziehung: y = 100x + 10
    "Client_2": {"x": np.array([0.8, 1.2]),       "y": np.array([90.0, 130.0])},       # Wahre Beziehung: y = 100x + 10
    "Client_3": {"x": np.array([2.5, 3.0, 3.5]), "y": np.array([260.0, 310.0, 360.0])}  # Wahre Beziehung: y = 100x + 10
}

# Gesamtzahl der Datenpunkte (N) über alle Clients hinweg
total_samples = sum(len(data["x"]) for data in clients_data.values())

# 2. Server-Initialgewicht (Globales Modell: W_t)
global_weight = 10.0  # Erster Tipp (sehr weit vom wahren Wert 100.0 entfernt)
learning_rate = 0.05
epochs = 5  # Lokale Trainings-Epochen pro Runde
communication_rounds = 3

print(f"Initiales globales Gewicht: {global_weight:.2f}\n")

# Federated Learning Loop
for round_idx in range(communication_rounds):
    print(f"--- Kommunikationsrunde {round_idx + 1} ---")
    local_weights = []
    client_sample_sizes = []
    
    # Schritt 2 & 3: Modellverteilung und lokales Training auf Client-Geräten
    for client_name, data in clients_data.items():
        x = data["x"]
        y = data["y"]
        n_i = len(x)
        
        # Client erhält globales Gewicht
        w_local = global_weight
        
        # Client trainiert lokal für einige Epochen
        for epoch in range(epochs):
            # Vorhersage berechnen: y_pred = w * x
            y_pred = w_local * x
            # Gradient für einfache lineare Regression berechnen
            gradient = -2 * np.mean(x * (y - y_pred))
            # Lokales Gewicht aktualisieren
            w_local -= learning_rate * gradient
            
        print(f"  {client_name} trainierte lokales Gewicht auf: {w_local:.2f} (Proben: {n_i})")
        
        # Lokale Gewichte und Stichprobengrößen für Aggregation speichern
        local_weights.append(w_local)
        client_sample_sizes.append(n_i)
        
    # Schritt 4 & 5: Server-seitige Aggregation mittels Federated Averaging (FedAvg)
    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"=> Server aggregierte globales Gewicht: {global_weight:.2f}\n")

print(f"Finales globales Modellgewicht nach FL: {global_weight:.2f}")

Warum dieser Code föderiertes Lernen darstellt:

• Das Dictionary clients_data stellt isolierte Datenbanken dar. Der Server greift niemals darauf zu.
• In der Trainingsschleife ist die einzige Variable, die vom Client an den Server übergeben wird, w_local.
• Der Server führt eine gewichtete Mittelwertbildung basierend auf der Stichprobengröße durch (client_sample_sizes), was der mathematischen Formel für FedAvg entspricht.

Zentralisiertes vs. Föderiertes Lernen

Sicherheits-Erweiterungen: Datenschutz und Verschlüsselung

Obwohl föderiertes Lernen von Natur aus sicherer ist als das zentralisierte Lernen, birgt das Senden von Rohgewichten an einen Server immer noch geringe Datenschutzrisiken (da Gewichte manchmal rekonstruiert werden können, um Trainingsdaten zurückzugewinnen). Um dem entgegenzuwirken, wird föderiertes Lernen mit zwei primären Sicherheitstechniken kombiniert:

1. Sichere Aggregation (Secure Aggregation - SecAgg): Ein kryptografisches Protokoll, das es dem Server ermöglicht, die Summe aller lokalen Modellaktualisierungen zu berechnen, ohne jemals das Update eines einzelnen Clients zu sehen. Der Server sieht nur das aggregierte Ergebnis.
2. Differenzielle Privatsphäre (Differential Privacy - DP): Hinzufügen von mathematischem “Rauschen” zu den lokalen Gewichten vor dem Hochladen. Dies stellt sicher, dass keine Daten eines einzelnen Benutzers durch das globale Modell identifiziert oder gespeichert werden können.

Praxisbeispiele aus der realen Welt

Föderiertes Lernen läuft heute bereits unbemerkt auf Ihren Geräten:

• Google Gboard: Google verwendet föderiertes Lernen, um die Vorhersage des nächsten Wortes und Suchanfragen-Vorschläge zu trainieren. Ihre Tastatur lernt Ihre Tippgewohnheiten, ohne Ihre Tastenanschläge an Google-Server zu senden.
• Apple QuickType: Apple nutzt dezentrales Training, um Autokorrekturen und Siri-Spracherkennungsvorschläge direkt auf iPhones zu verbessern.
• Gesundheitswesen (MELLODDY-Projekt): Führende Pharmaunternehmen nutzen föderiertes Lernen, um gemeinsam Modelle zur Arzneimittelentwicklung auf privaten chemischen Datenbanken zu trainieren, ohne geschützte Forschungsergebnisse der Konkurrenz preiszugeben.

Zusammenfassung

Föderiertes Lernen markiert einen Paradigmenwechsel in der Entwicklung von KI-Systemen. Es respektiert das Dateneigentum, minimiert Kommunikationskosten und ermöglicht das KI-Training in stark regulierten Branchen. Indem wir den Trainingsprozess an den Rand des Netzwerks (Edge) verlagern, können wir intelligentere, personalisiertere Modelle erstellen und gleichzeitig unsere persönlichen Daten genau dort belassen, wo sie hingehören: in unseren eigenen Händen.

Entdecken Sie weitere Einblicke in dezentrale Technologien im Ghaznix-Blog →