Federated Learning: Cómo entrenar IA sin compartir tus datos

En el flujo de trabajo tradicional del aprendizaje automático, la recopilación de datos es el primer paso y a menudo el más costoso. Para entrenar un modelo, debe reunir los datos brutos de los usuarios (como fotos, mensajes de texto, registros de salud o transacciones financieras) y cargarlos en un servidor en la nube centralizado.

Si bien este enfoque centralizado ha impulsado la revolución de la IA, se enfrenta a desafíos importantes:

1. Problemas de privacidad: Los usuarios son cada vez más reacios a subir datos privados a servidores de terceros.
2. Regulación de datos: Las regulaciones como GDPR e HIPAA restringen estrictamente cómo se pueden transferir y almacenar los datos personales.
3. Costos de ancho de banda: Cargar gigabytes de datos brutos desde millones de dispositivos periféricos (como teléfonos inteligentes) es altamente ineficiente.

El Aprendizaje Federado (Federated Learning - FL) resuelve estos problemas al dar la vuelta al paradigma tradicional. En lugar de llevar los datos al modelo, lleva el modelo a los datos.

El concepto clave: Entrenamiento descentralizado

En el Aprendizaje Federado, el servidor central mantiene un modelo global. En lugar de recopilar datos brutos para entrenar este modelo, el servidor coordina un proceso de entrenamiento colaborativo a través de una red de dispositivos periféricos (clientes), como teléfonos inteligentes, dispositivos domésticos inteligentes o bases de datos de hospitales regionales.

Esta es la regla fundamental del Aprendizaje Federado:

Los datos brutos nunca salen del dispositivo local. Solo se comparten las actualizaciones matemáticas del modelo.

Guía paso a paso: Cómo funciona

Un ciclo típico de entrenamiento en el Aprendizaje Federado (conocido como ronda de comunicación) consta de cinco pasos principales:

sequenceDiagram
    participant Server as Servidor Central (Modelo Global)
    participant ClientA as Cliente A (Datos Privados A)
    participant ClientB as Cliente B (Datos Privados B)
    
    rect rgb(240, 248, 255)
        Note over Server: Paso 1: Inicializar Modelo Global
    end
    Server->>ClientA: Paso 2: Enviar Pesos Globales (W_t)
    Server->>ClientB: Paso 2: Enviar Pesos Globales (W_t)
    rect rgb(245, 245, 245)
        Note over ClientA: Paso 3: Entrenar Localmente con Datos Privados
        Note over ClientB: Paso 3: Entrenar Localmente con Datos Privados
    end
    ClientA->>Server: Paso 4: Enviar Actualizaciones Locales (W_t^A)
    ClientB->>Server: Paso 4: Enviar Actualizaciones Locales (W_t^B)
    rect rgb(240, 255, 240)
        Note over Server: Paso 5: Promediar Actualizaciones (FedAvg)<br/>Actualizar Modelo Global (W_t+1)
    end

1. Inicialización

El servidor central inicializa el modelo global con pesos iniciales ($W_0$). Estos pesos pueden ser aleatorios o preentrenados en un conjunto de datos público.

2. Distribución (Transmisión del modelo)

El servidor selecciona un subconjunto de dispositivos cliente disponibles (por ejemplo, teléfonos que están cargando, conectados a Wi-Fi e inactivos) y les transmite los pesos actuales del modelo global ($W_t$).

3. Entrenamiento local

Cada cliente seleccionado entrena el modelo global recibido en su propio conjunto de datos local y privado. Esto se hace utilizando algoritmos de optimización estándar como el descenso de gradiente estocástico (SGD). Después de algunas épocas, cada cliente $i$ produce un nuevo conjunto de pesos del modelo local ($W_t^i$).

4. Carga de actualizaciones locales

En lugar de enviar los datos privados de entrenamiento, los clientes envían solo sus nuevos pesos del modelo local (o la diferencia $\Delta W_t^i = W_t^i - W_t$) de vuelta al servidor central. Estas actualizaciones suelen cifrarse utilizando protocolos criptográficos.

5. Agregación global

El servidor central recopila las actualizaciones de todos los clientes participantes. Realiza un promedio (normalmente ponderado por la cantidad de datos locales de cada cliente) para producir un nuevo modelo global ($W_{t+1}$). El algoritmo más común para esto es el Promedio Federado (Federated Averaging - FedAvg):

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

Donde:

• $K$ es el número de clientes participantes.
• $n_i$ es el número de muestras de datos en el cliente $i$.
• $N$ es el número total de muestras de datos en todos los clientes participantes ($N = \sum n_i$).

Este ciclo se repite durante muchas rondas hasta que el modelo global alcanza la precisión deseada.

Ejemplo de código: Una simulación simple en Python

Para ver el Aprendizaje Federado en acción, escribamos una simulación simple en Python utilizando NumPy.

En este escenario, queremos entrenar un modelo para predecir los precios de las viviendas ($y = w \cdot x$) mediante regresión lineal. Tenemos un servidor central y 3 clientes, cada uno con sus propios tamaños de vivienda ($x$) y precios ($y$) privados.

import numpy as np

# 1. Configuración de datos privados del cliente (No se pueden compartir con el servidor)
# Cada cliente tiene un número diferente de muestras locales (n_i)
clients_data = {
    "Client_1": {"x": np.array([1.0, 1.5, 2.0]), "y": np.array([110.0, 160.0, 210.0])}, # Relación real: y = 100x + 10
    "Client_2": {"x": np.array([0.8, 1.2]),       "y": np.array([90.0, 130.0])},       # Relación real: y = 100x + 10
    "Client_3": {"x": np.array([2.5, 3.0, 3.5]), "y": np.array([260.0, 310.0, 360.0])}  # Relación real: y = 100x + 10
}

# Total de puntos de datos (N) en todos los clientes
total_samples = sum(len(data["x"]) for data in clients_data.values())

# 2. Peso inicial del servidor (Modelo global: W_t)
global_weight = 10.0  # Estimación inicial (muy lejos del valor real 100.0)
learning_rate = 0.05
epochs = 5  # Épocas de entrenamiento local por ronda
communication_rounds = 3

print(f"Peso global inicial: {global_weight:.2f}\n")

# Bucle de Aprendizaje Federado
for round_idx in range(communication_rounds):
    print(f"--- Ronda de comunicación {round_idx + 1} ---")
    local_weights = []
    client_sample_sizes = []
    
    # Pasos 2 y 3: Distribución del modelo y entrenamiento local en los dispositivos cliente
    for client_name, data in clients_data.items():
        x = data["x"]
        y = data["y"]
        n_i = len(x)
        
        # El cliente recibe el peso global
        w_local = global_weight
        
        # El cliente entrena localmente durante unas pocas épocas
        for epoch in range(epochs):
            # Calcular la predicción: y_pred = w * x
            y_pred = w_local * x
            # Calcular el gradiente para regresión lineal simple
            gradient = -2 * np.mean(x * (y - y_pred))
            # Actualizar el peso local
            w_local -= learning_rate * gradient
            
        print(f"  {client_name} entrenó el peso local a: {w_local:.2f} (muestras: {n_i})")
        
        # Guardar pesos locales y tamaños de muestra para la agregación
        local_weights.append(w_local)
        client_sample_sizes.append(n_i)
        
    # Pasos 4 y 5: Agregación en el servidor mediante Promedio Federado (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 global agregado por el servidor: {global_weight:.2f}\n")

print(f"Peso final del modelo global después de FL: {global_weight:.2f}")

Por qué este código representa el Aprendizaje Federado:

• El diccionario clients_data representa bases de datos aisladas. El servidor nunca accede a ellas.
• En el bucle de entrenamiento, la única variable que se pasa del cliente al servidor es w_local.
• El servidor realiza un promedio ponderado basado en los tamaños de muestra (client_sample_sizes), que implementa la fórmula matemática para FedAvg.

Aprendizaje Centralizado vs. Aprendizaje Federado

Complementos de seguridad: Privacidad y Cifrado

Aunque el Aprendizaje Federado es inherentemente más seguro que el aprendizaje centralizado, el envío de pesos brutos a un servidor todavía conlleva pequeños riesgos de privacidad (ya que a veces los pesos pueden revertirse para reconstruir los datos de entrenamiento). Para contrarrestar esto, el Aprendizaje Federado se combina con dos técnicas de seguridad primordiales:

1. Agregación segura (Secure Aggregation - SecAgg): Un protocolo criptográfico que permite al servidor calcular la suma de todas las actualizaciones locales de los modelos sin ver la actualización de ningún cliente individual. El servidor solo ve el resultado agregado.
2. Privacidad diferencial (Differential Privacy - DP): Adición de “ruido” matemático a los pesos locales antes de subirlos. Esto garantiza que ningún dato de un usuario individual pueda ser aislado o memorizado por el modelo global.

Ejemplos en el mundo real

El Aprendizaje Federado ya se está ejecutando silenciosamente en sus dispositivos hoy en día:

• Google Gboard: Google utiliza el Aprendizaje Federado para entrenar la predicción de la siguiente palabra y sugerencias de búsqueda. Su teclado aprende sus hábitos de escritura y jerga sin enviar sus pulsaciones de teclas a los servidores de Google.
• Apple QuickType: Apple utiliza el entrenamiento descentralizado para mejorar la autocorrección y las sugerencias de reconocimiento de voz de Siri directamente en los iPhones.
• Atención médica (Proyecto MELLODDY): Las principales compañías farmacéuticas utilizan el Aprendizaje Federado para entrenar en colaboración modelos de descubrimiento de fármacos en bases de datos químicas privadas, sin exponer la investigación patentada a la competencia.

Resumen

El Aprendizaje Federado marca un cambio de paradigma en la forma en que construimos sistemas de IA. Respeta la propiedad de los datos, minimiza los costos de comunicación y permite el entrenamiento de IA en industrias altamente reguladas. Al trasladar el proceso de entrenamiento a la periferia, podemos construir modelos más inteligentes y personalizados mientras mantenemos nuestros datos personales exactamente donde deben estar: en nuestras propias manos.

Explore más perspectivas sobre tecnología descentralizada en el blog de Ghaznix →