Federated Learning: Addestrare l'IA senza condividere i tuoi dati

Nel flusso di lavoro tradizionale del machine learning, la raccolta dei dati è il primo passo e spesso il più costoso. Per addestrare un modello, è necessario raccogliere i dati grezzi degli utenti (foto, messaggi di testo, cartelle cliniche o transazioni finanziarie) e caricarli su un server cloud centralizzato.

Sebbene questo approccio centralizzato abbia guidato la rivoluzione dell’IA, deve affrontare sfide importanti:

1. Problemi di privacy: Gli utenti sono sempre più riluttanti a caricare dati privati su server di terze parti.
2. Regolamentazione dei dati: Normative come il GDPR e l’HIPAA limitano rigorosamente il trasferimento e l’archiviazione dei dati personali.
3. Costi di banda: Caricare gigabyte di dati grezzi da milioni di dispositivi periferici (come gli smartphone) è altamente inefficiente.

Il Federated Learning (FL) risolve questi problemi capovolgendo il paradigma tradizionale. Invece di portare i dati al modello, porta il modello ai dati.

Il concetto cardine: Addestramento decentralizzato

Nel Federated Learning, il server centrale mantiene un modello globale. Invece di raccogliere dati grezzi per addestrare questo modello, il server coordina un processo di addestramento collaborativo attraverso una rete di dispositivi periferici (client), come smartphone, dispositivi smart home o database ospedalieri regionali.

Ecco la regola fondamentale del Federated Learning:

I dati grezzi non lasciano mai il dispositivo locale. Vengono condivisi solo gli aggiornamenti matematici del modello.

Guida dettagliata: Come funziona

Un tipico ciclo di addestramento nel Federated Learning (noto come round di comunicazione) consiste in cinque passaggi principali:

sequenceDiagram
    participant Server as Server Centrale (Modello Globale)
    participant ClientA as Client A (Dati Privati A)
    participant ClientB as Client B (Dati Privati B)
    
    rect rgb(240, 248, 255)
        Note over Server: Passaggio 1: Inizializzazione Modello Globale
    end
    Server->{ClientA}: Passaggio 2: Invia Pesi Globali (W_t)
    Server->{ClientB}: Passaggio 2: Invia Pesi Globali (W_t)
    rect rgb(245, 245, 245)
        Note over ClientA: Passaggio 3: Addestramento Locale su Dati Privati
        Note over ClientB: Passaggio 3: Addestramento Locale su Dati Privati
    end
    ClientA->>Server: Passaggio 4: Invia Aggiornamenti Locali (W_t^A)
    ClientB->>Server: Passaggio 4: Invia Aggiornamenti Locali (W_t^B)
    rect rgb(240, 255, 240)
        Note over Server: Passaggio 5: Media Aggiornamenti (FedAvg)<br/>Aggiorna Modello Globale (W_t+1)
    end

1. Inizializzazione

Il server centrale inizializza il modello globale con pesi di partenza ($W_0$). Questi pesi possono essere casuali o pre-addestrati su un dataset pubblico.

2. Distribuzione (Modello Broadcast)

Il server seleziona un sottoinsieme di dispositivi client disponibili (ad esempio, telefoni in carica, connessi al Wi-Fi e inattivi) e trasmette loro i pesi del modello globale corrente ($W_t$).

3. Addestramento locale

Ogni client selezionato addestra il modello globale ricevuto sul proprio dataset locale privato. Questo viene fatto utilizzando algoritmi di ottimizzazione standard come la Discesa Stocastica del Gradiente (SGD). Dopo alcune epoche, ogni client $i$ produce un nuovo insieme di pesi del modello locale ($W_t^i$).

4. Invio degli aggiornamenti locali

Invece di inviare i dati di addestramento privati, i client inviano al server centrale solo i loro nuovi pesi del modello locale (o la differenza $\Delta W_t^i = W_t^i - W_t$). Questi aggiornamenti sono solitamente crittografati utilizzando protocolli di sicurezza.

5. Aggregazione globale

Il server centrale raccoglie gli aggiornamenti di tutti i client partecipanti. Esegue la media (solitamente ponderata in base alla quantità di dati locali di ciascun client) per produrre un nuovo modello globale ($W_{t+1}$). L’algoritmo più comune per questo processo è il Federated Averaging (FedAvg):

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

Dove:

• $K$ è il numero di client partecipanti.
• $n_i$ è il numero di campioni di dati sul client $i$.
• $N$ è il numero totale di campioni di dati su tutti i client partecipanti ($N = \sum n_i$).

Questo ciclo si ripete per molti round fino a quando il modello globale non raggiunge l’accuratezza desiderata.

Esempio di codice: Una semplice simulazione in Python

Per vedere il Federated Learning in azione, scriviamo una semplice simulazione in Python usando NumPy.

In questo scenario, vogliamo addestrare un modello per prevedere i prezzi delle case ($y = w \cdot x$) utilizzando la regressione lineare. Abbiamo un server centrale e 3 client, ciascuno con le proprie dimensioni delle case ($x$) e i relativi prezzi ($y$) privati.

import numpy as np

# 1. Configurazione dei dati privati dei client (non condivisibili con il server)
# Ciascun client ha un numero diverso di campioni locali (n_i)
clients_data = {
    "Client_1": {"x": np.array([1.0, 1.5, 2.0]), "y": np.array([110.0, 160.0, 210.0])}, # Relazione reale: y = 100x + 10
    "Client_2": {"x": np.array([0.8, 1.2]),       "y": np.array([90.0, 130.0])},       # Relazione reale: y = 100x + 10
    "Client_3": {"x": np.array([2.5, 3.0, 3.5]), "y": np.array([260.0, 310.0, 360.0])}  # Relazione reale: y = 100x + 10
}

# Punti dati totali (N) su tutti i client
total_samples = sum(len(data["x"]) for data in clients_data.values())

# 2. Peso iniziale del server (Modello globale: W_t)
global_weight = 10.0  # Stima iniziale (molto lontana dal valore reale 100.0)
learning_rate = 0.05
epochs = 5  # Epoche di addestramento locale per round
communication_rounds = 3

print(f"Peso globale iniziale: {global_weight:.2f}\n")

# Loop del Federated Learning
for round_idx in range(communication_rounds):
    print(f"--- Round di comunicazione {round_idx + 1} ---")
    local_weights = []
    client_sample_sizes = []
    
    # Passaggio 2 e 3: Distribuzione del modello e addestramento locale sui client
    for client_name, data in clients_data.items():
        x = data["x"]
        y = data["y"]
        n_i = len(x)
        
        # Il client riceve il peso globale
        w_local = global_weight
        
        # Il client si addestra localmente per alcune epoche
        for epoch in range(epochs):
            # Calcolo della previsione: y_pred = w * x
            y_pred = w_local * x
            # Calcolo del gradiente per la regressione lineare semplice
            gradient = -2 * np.mean(x * (y - y_pred))
            # Aggiornamento del peso locale
            w_local -= learning_rate * gradient
            
        print(f"  {client_name} ha addestrato il peso locale a: {w_local:.2f} (campioni: {n_i})")
        
        # Salvataggio dei pesi locali e delle dimensioni del campione per l'aggregazione
        local_weights.append(w_local)
        client_sample_sizes.append(n_i)
        
    # Passaggio 4 e 5: Aggregazione lato server tramite 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"=> Peso globale aggregato dal server: {global_weight:.2f}\n")

print(f"Peso finale del modello globale dopo il FL: {global_weight:.2f}")

Perché questo codice rappresenta il Federated Learning:

• Il dizionario clients_data rappresenta database isolati. Il server non vi accede mai.
• Nel loop di addestramento, l’unica variabile passata dal client al server è w_local.
• Il server esegue una media ponderata in base alle dimensioni del campione (client_sample_sizes), implementando la formula matematica del FedAvg.

Apprendimento Centralizzato vs. Federated Learning

Integrazioni di sicurezza: Privacy e Crittografia

Sebbene il Federated Learning sia intrinsecamente più sicuro del machine learning centralizzato, l’invio di pesi grezzi a un server comporta comunque piccoli rischi per la privacy (poiché a volte i pesi possono essere decodificati per ricostruire i dati di addestramento). Per contrastare questo rischio, il Federated Learning viene combinato con due tecniche di sicurezza principali:

1. Secure Aggregation (SecAgg): Un protocollo crittografico che consente al server di calcolare la somma di tutti gli aggiornamenti locali senza mai vedere l’aggiornamento di un singolo client. Il server vede solo il risultato aggregato.
2. Differential Privacy (DP): Aggiunta di “rumore” matematico ai pesi locali prima del caricamento. Ciò garantisce che nessun dato del singolo utente possa essere isolato o memorizzato dal modello globale.

Esempi nel mondo reale

Il Federated Learning è già attivo e funzionante sui tuoi dispositivi:

• Google Gboard: Google utilizza il Federated Learning per addestrare la previsione della parola successiva e i suggerimenti di ricerca. La tastiera impara le tue abitudini di digitazione senza inviare i tuoi inserimenti ai server di Google.
• Apple QuickType: Apple utilizza l’addestramento decentralizzato per migliorare la correzione automatica e i suggerimenti vocali di Siri direttamente sugli iPhone.
• Settore sanitario (Progetto MELLODDY): Le principali aziende farmaceutiche utilizzano il Federated Learning per addestrare in modo collaborativo modelli di scoperta dei farmaci su database chimici privati, senza esporre la ricerca proprietaria ai concorrenti.

Sintesi

Il Federated Learning segna un cambio di paradigma nel modo in cui costruiamo i sistemi di IA. Rispetta la proprietà dei dati, riduce al minimo i costi di comunicazione e consente l’addestramento dell’IA in settori altamente regolamentati. Spostando il processo di addestramento alla periferia della rete (edge), possiamo creare modelli più intelligenti e personalizzati, mantenendo i nostri dati personali esattamente dove devono stare: nelle nostre mani.

Esplora altre prospettive sulla tecnologia decentralizzata sul Blog di Ghaznix →