En este tutorial, demostramos cómo simulamos un sistema de detección de fraude que preserva la privacidad utilizando el aprendizaje federado sin depender de marcos pesados o infraestructura compleja. Creamos una configuración limpia y compatible con CPU que imita a diez bancos independientes, cada uno de los cuales entrena un modelo local de detección de fraude con sus propios datos de transacciones altamente desequilibrados. Coordinamos estas actualizaciones locales a través de un simple bucle de agregación FedAvg, lo que nos permite mejorar un modelo global y al mismo tiempo garantizar que ningún dato de transacción sin procesar salga del cliente. Además de esto, integramos OpenAI para respaldar el análisis posterior a la capacitación y los informes orientados a los riesgos, lo que demuestra cómo los resultados del aprendizaje federado se pueden traducir en conocimientos listos para tomar decisiones. Consulte los códigos completos aquí.
Configuramos el entorno de ejecución e importamos todas las bibliotecas necesarias para la generación, modelado, evaluación y generación de informes de datos. También arreglamos semillas aleatorias y la configuración del dispositivo para garantizar que nuestra simulación federada siga siendo determinista y reproducible en la CPU. Consulte los códigos completos aquí.
Generamos un conjunto de datos de fraude similar al de las tarjetas de crédito, altamente desequilibrado, y lo dividimos en conjuntos de capacitación y prueba. Estandarizamos los datos del lado del servidor y preparamos un cargador de pruebas global que nos permite evaluar consistentemente el modelo agregado después de cada ronda federada. Consulte los códigos completos aquí.
NUM_CLIENTES = 10 client_idxs = dirichlet_partition(y_train_full, NUM_CLIENTES, 0.35) def make_client_split(X, y, idxs): Xi, yi = X[idxs]y[idxs]
si len(np.unique(yi)) < 2: otro = np.where(y == (1 - yi[0]))[0]
agregar = np.random.choice(otro, tamaño=min(10, len(otro)), reemplazar=Falso) Xi = np.concatenate([Xi, X[add]]) yi = np.concatenar([yi, y[add]]) devuelve train_test_split(Xi, yi, test_size=0.15, estratify=yi, random_state=SEED) client_data = [make_client_split(X_train_full, y_train_full, client_idxs[c]) para c en el rango(NUM_CLIENTES)]def make_client_loaders(Xtr, ytr, Xva, yva): sc = StandardScaler() Xtr_s = sc.fit_transform(Xtr).astype(np.float32) Xva_s = sc.transform(Xva).astype(np.float32) tr = DataLoader(TensorDataset(torch.from_numpy(Xtr_s), torch.from_numpy(ytr)), lote_size=512, shuffle=True) va = DataLoader(TensorDataset(torch.from_numpy(Xva_s), torch.from_numpy(yva)), lote_size=512) return tr, va client_loaders = [make_client_loaders(*cd) for cd in client_data]
Simulamos un comportamiento realista no IID dividiendo los datos de entrenamiento entre diez clientes utilizando una distribución de Dirichlet. Luego creamos cargadores de validación y trenes independientes a nivel de cliente, asegurando que cada banco simulado opere con sus propios datos escalados localmente. Consulte los códigos completos aquí.
def set_weights(modelo, pesos): claves = lista(model.state_dict().keys()) model.load_state_dict({k: torch.tensor(w) for k, w in zip(keys,weights)}, estricto=True) @torch.no_grad() def evaluar(modelo, cargador): model.eval() bce = nn.BCEWithLogitsLoss() ys, ps, pérdidas = [], [], []
para xb, yb en el cargador: logits = model(xb) pérdidas.append(bce(logits, yb.float()).item()) ys.append(yb.numpy()) ps.append(torch.sigmoid(logits).numpy()) y_true = np.concatenate(ys) y_prob = np.concatenate(ps) return { “pérdida”: float(np.mean(pérdidas)), “auc”: roc_auc_score(y_true, y_prob), “ap”: Average_precision_score(y_true, y_prob), “acc”: precision_score(y_true, (y_prob >= 0.5).astype(int)) } def train_local(modelo, cargador, lr): opt = torch.optim.Adam(model.parameters(), lr=lr) bce = nn.BCEWithLogitsLoss() model.train() para xb, yb en el cargador: opt.zero_grad() pérdida = bce(model(xb), yb.float()) loss.backward() opt.step()
Definimos la red neuronal utilizada para la detección de fraude junto con funciones de utilidad para capacitación, evaluación e intercambio de peso. Implementamos optimización local ligera y cálculo de métricas para mantener las actualizaciones del lado del cliente eficientes y fáciles de entender. Consulte los códigos completos aquí.
sum(w[i] * (s / total) para w, s en zip(pesos, tamaños)) para i en rango(len(pesos[0])) ]RONDAS = 10 LR = 5e-4 global_model = FraudNet(X_train_full.shape[1]) globales_weights = get_weights(global_model) para r en el rango(1, ROUNDS + 1): client_weights, client_sizes = [], []
para cid en el rango (NUM_CLIENTES): local = FraudNet (X_train_full.shape[1]) set_weights(local, global_weights) train_local(local, client_loaders[cid][0]LR) client_weights.append(get_weights(local)) client_sizes.append(len(client_loaders[cid][0].dataset)) global_weights = fedavg(client_weights, client_sizes) set_weights(global_model, global_weights) métricas = evaluar(global_model, test_loader) print(f”Ronda {r}: {métricas}”)
Orquestamos el proceso de aprendizaje federado entrenando de forma iterativa modelos de clientes locales y agregando sus parámetros utilizando FedAvg. Evaluamos el modelo global después de cada ronda para monitorear la convergencia y comprender cómo el aprendizaje colectivo mejora el desempeño de la detección de fraude. Consulte los códigos completos aquí.
Transformamos los resultados técnicos en un informe analítico conciso utilizando un modelo de lenguaje externo. Aceptamos de forma segura la clave API mediante la entrada del teclado y generamos información orientada a la toma de decisiones que resume el rendimiento, los riesgos y los próximos pasos recomendados.
En conclusión, mostramos cómo implementar el aprendizaje federado desde los primeros principios en un cuaderno de Colab sin dejar de ser estable, interpretable y realista. Observamos cómo la heterogeneidad extrema de los datos entre clientes influye en la convergencia y por qué la agregación y evaluación cuidadosas son fundamentales en entornos de detección de fraude. También ampliamos el flujo de trabajo generando un informe automatizado del equipo de riesgo, demostrando cómo los resultados analíticos se pueden traducir en conocimientos listos para tomar decisiones. Por último, presentamos un plan práctico para experimentar con modelos de fraude federados que enfatizan la conciencia de la privacidad, la simplicidad y la relevancia en el mundo real.
Consulte los códigos completos aquí. Además, no dude en seguirnos en Twitter y no olvide unirse a nuestro SubReddit de más de 100.000 ML y suscribirse a nuestro boletín. ¡Esperar! estas en telegrama? Ahora también puedes unirte a nosotros en Telegram.
Asif Razzaq es el director ejecutivo de Marktechpost Media Inc.. Como empresario e ingeniero visionario, Asif está comprometido a aprovechar el potencial de la inteligencia artificial para el bien social. Su esfuerzo más reciente es el lanzamiento de una plataforma de medios de inteligencia artificial, Marktechpost, que se destaca por su cobertura en profundidad del aprendizaje automático y las noticias sobre aprendizaje profundo que es técnicamente sólida y fácilmente comprensible para una amplia audiencia. La plataforma cuenta con más de 2 millones de visitas mensuales, lo que ilustra su popularidad entre el público.