In diesem Tutorial zeigen wir, wie wir mithilfe von Federated Studying ein datenschutzschonendes Betrugserkennungssystem simulieren, ohne auf schwere Frameworks oder komplexe Infrastruktur angewiesen zu sein. Wir bauen ein sauberes, CPU-freundliches Setup auf, das zehn unabhängige Banken nachahmt, von denen jede ein lokales Betrugserkennungsmodell anhand ihrer eigenen, stark unausgewogenen Transaktionsdaten trainiert. Wir koordinieren diese lokalen Aktualisierungen über eine einfache FedAvg-Aggregationsschleife, wodurch wir ein globales Modell verbessern und gleichzeitig sicherstellen können, dass keine rohen Transaktionsdaten jemals einen Kunden verlassen. Darüber hinaus integrieren wir OpenAI, um die Analyse nach dem Coaching und risikoorientierte Berichterstattung zu unterstützen und zu demonstrieren, wie föderierte Lernergebnisse in entscheidungsreife Erkenntnisse umgesetzt werden können. Schauen Sie sich das an Vollständige Codes hier.
!pip -q set up torch scikit-learn numpy openai
import time, random, json, os, getpass
import numpy as np
import torch
import torch.nn as nn
from torch.utils.information import DataLoader, TensorDataset
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import roc_auc_score, average_precision_score, accuracy_score
from openai import OpenAI
SEED = 7
random.seed(SEED); np.random.seed(SEED); torch.manual_seed(SEED)
DEVICE = torch.gadget("cpu")
print("Gadget:", DEVICE)Wir richten die Ausführungsumgebung ein und importieren alle erforderlichen Bibliotheken für die Datengenerierung, Modellierung, Auswertung und Berichterstattung. Wir korrigieren auch zufällige Seeds und die Gerätekonfiguration, um sicherzustellen, dass unsere Verbundsimulation deterministisch und auf der CPU reproduzierbar bleibt. Schauen Sie sich das an Vollständige Codes hier.
X, y = make_classification(
n_samples=60000,
n_features=30,
n_informative=18,
n_redundant=8,
weights=(0.985, 0.015),
class_sep=1.5,
flip_y=0.01,
random_state=SEED
)
X = X.astype(np.float32)
y = y.astype(np.int64)
X_train_full, X_test, y_train_full, y_test = train_test_split(
X, y, test_size=0.2, stratify=y, random_state=SEED
)
server_scaler = StandardScaler()
X_train_full_s = server_scaler.fit_transform(X_train_full).astype(np.float32)
X_test_s = server_scaler.rework(X_test).astype(np.float32)
test_loader = DataLoader(
TensorDataset(torch.from_numpy(X_test_s), torch.from_numpy(y_test)),
batch_size=1024,
shuffle=False
)
Wir generieren einen äußerst unausgewogenen, kreditkartenähnlichen Betrugsdatensatz und teilen ihn in Trainings- und Testsätze auf. Wir standardisieren die serverseitigen Daten und bereiten einen globalen Testloader vor, der es uns ermöglicht, das aggregierte Modell nach jeder Verbundrunde konsistent auszuwerten. Schauen Sie sich das an Vollständige Codes hier.
def dirichlet_partition(y, n_clients=10, alpha=0.35):
lessons = np.distinctive(y)
idx_by_class = (np.the place(y == c)(0) for c in lessons)
client_idxs = (() for _ in vary(n_clients))
for idxs in idx_by_class:
np.random.shuffle(idxs)
props = np.random.dirichlet(alpha * np.ones(n_clients))
cuts = (np.cumsum(props) * len(idxs)).astype(int)
prev = 0
for cid, minimize in enumerate(cuts):
client_idxs(cid).prolong(idxs(prev:minimize).tolist())
prev = minimize
return (np.array(ci, dtype=np.int64) for ci in client_idxs)
NUM_CLIENTS = 10
client_idxs = dirichlet_partition(y_train_full, NUM_CLIENTS, 0.35)
def make_client_split(X, y, idxs):
Xi, yi = X(idxs), y(idxs)
if len(np.distinctive(yi)) < 2:
different = np.the place(y == (1 - yi(0)))(0)
add = np.random.selection(different, measurement=min(10, len(different)), substitute=False)
Xi = np.concatenate((Xi, X(add)))
yi = np.concatenate((yi, y(add)))
return train_test_split(Xi, yi, test_size=0.15, stratify=yi, random_state=SEED)
client_data = (make_client_split(X_train_full, y_train_full, client_idxs(c)) for c in vary(NUM_CLIENTS))
def make_client_loaders(Xtr, ytr, Xva, yva):
sc = StandardScaler()
Xtr_s = sc.fit_transform(Xtr).astype(np.float32)
Xva_s = sc.rework(Xva).astype(np.float32)
tr = DataLoader(TensorDataset(torch.from_numpy(Xtr_s), torch.from_numpy(ytr)), batch_size=512, shuffle=True)
va = DataLoader(TensorDataset(torch.from_numpy(Xva_s), torch.from_numpy(yva)), batch_size=512)
return tr, va
client_loaders = (make_client_loaders(*cd) for cd in client_data)Wir simulieren realistisches Nicht-IID-Verhalten, indem wir die Trainingsdaten mithilfe einer Dirichlet-Verteilung auf zehn Purchasers verteilen. Anschließend erstellen wir unabhängige Trainings- und Validierungslader auf Kundenebene und stellen so sicher, dass jede simulierte Financial institution mit ihren eigenen lokal skalierten Daten arbeitet. Schauen Sie sich das an Vollständige Codes hier.
class FraudNet(nn.Module):
def __init__(self, in_dim):
tremendous().__init__()
self.internet = nn.Sequential(
nn.Linear(in_dim, 64),
nn.ReLU(),
nn.Dropout(0.1),
nn.Linear(64, 32),
nn.ReLU(),
nn.Dropout(0.1),
nn.Linear(32, 1)
)
def ahead(self, x):
return self.internet(x).squeeze(-1)
def get_weights(mannequin):
return (p.detach().cpu().numpy() for p in mannequin.state_dict().values())
def set_weights(mannequin, weights):
keys = listing(mannequin.state_dict().keys())
mannequin.load_state_dict({ok: torch.tensor(w) for ok, w in zip(keys, weights)}, strict=True)
@torch.no_grad()
def consider(mannequin, loader):
mannequin.eval()
bce = nn.BCEWithLogitsLoss()
ys, ps, losses = (), (), ()
for xb, yb in loader:
logits = mannequin(xb)
losses.append(bce(logits, yb.float()).merchandise())
ys.append(yb.numpy())
ps.append(torch.sigmoid(logits).numpy())
y_true = np.concatenate(ys)
y_prob = np.concatenate(ps)
return {
"loss": float(np.imply(losses)),
"auc": roc_auc_score(y_true, y_prob),
"ap": average_precision_score(y_true, y_prob),
"acc": accuracy_score(y_true, (y_prob >= 0.5).astype(int))
}
def train_local(mannequin, loader, lr):
decide = torch.optim.Adam(mannequin.parameters(), lr=lr)
bce = nn.BCEWithLogitsLoss()
mannequin.prepare()
for xb, yb in loader:
decide.zero_grad()
loss = bce(mannequin(xb), yb.float())
loss.backward()
decide.step()Wir definieren das neuronale Netzwerk, das zur Betrugserkennung verwendet wird, zusammen mit Hilfsfunktionen für Coaching, Bewertung und Gewichtsaustausch. Wir implementieren eine leichte lokale Optimierung und Metrikberechnung, um clientseitige Aktualisierungen effizient und leicht nachvollziehbar zu halten. Schauen Sie sich das an Vollständige Codes hier.
def fedavg(weights, sizes):
whole = sum(sizes)
return (
sum(w(i) * (s / whole) for w, s in zip(weights, sizes))
for i in vary(len(weights(0)))
)
ROUNDS = 10
LR = 5e-4
global_model = FraudNet(X_train_full.form(1))
global_weights = get_weights(global_model)
for r in vary(1, ROUNDS + 1):
client_weights, client_sizes = (), ()
for cid in vary(NUM_CLIENTS):
native = FraudNet(X_train_full.form(1))
set_weights(native, global_weights)
train_local(native, client_loaders(cid)(0), LR)
client_weights.append(get_weights(native))
client_sizes.append(len(client_loaders(cid)(0).dataset))
global_weights = fedavg(client_weights, client_sizes)
set_weights(global_model, global_weights)
metrics = consider(global_model, test_loader)
print(f"Spherical {r}: {metrics}")Wir orchestrieren den föderierten Lernprozess, indem wir lokale Kundenmodelle iterativ trainieren und ihre Parameter mithilfe von FedAvg aggregieren. Wir bewerten das globale Modell nach jeder Runde, um die Konvergenz zu überwachen und zu verstehen, wie kollektives Lernen die Leistung der Betrugserkennung verbessert. Schauen Sie sich das an Vollständige Codes hier.
OPENAI_API_KEY = getpass.getpass("Enter OPENAI_API_KEY (enter hidden): ").strip()
if OPENAI_API_KEY:
os.environ("OPENAI_API_KEY") = OPENAI_API_KEY
shopper = OpenAI()
abstract = {
"rounds": ROUNDS,
"num_clients": NUM_CLIENTS,
"final_metrics": metrics,
"client_sizes": (len(client_loaders(c)(0).dataset) for c in vary(NUM_CLIENTS)),
"client_fraud_rates": (float(client_data(c)(1).imply()) for c in vary(NUM_CLIENTS))
}
immediate = (
"Write a concise inside fraud-risk report.n"
"Embrace government abstract, metric interpretation, dangers, and subsequent steps.nn"
+ json.dumps(abstract, indent=2)
)
resp = shopper.responses.create(mannequin="gpt-5.2", enter=immediate)
print(resp.output_text)Wir überführen die technischen Ergebnisse mithilfe eines externen Sprachmodells in einen prägnanten Analysebericht. Wir akzeptieren den API-Schlüssel sicher per Tastatureingabe und generieren entscheidungsorientierte Erkenntnisse, die Leistung, Risiken und empfohlene nächste Schritte zusammenfassen.
Abschließend haben wir gezeigt, wie man föderiertes Lernen nach den ersten Prinzipien in einem Colab-Notizbuch umsetzen und dabei stabil, interpretierbar und realistisch bleiben kann. Wir haben beobachtet, wie excessive Datenheterogenität zwischen Purchasers die Konvergenz beeinflusst und warum eine sorgfältige Aggregation und Auswertung in Betrugserkennungsumgebungen von entscheidender Bedeutung sind. Wir haben den Arbeitsablauf außerdem durch die Erstellung eines automatisierten Risikoteamberichts erweitert, der zeigt, wie Analyseergebnisse in entscheidungsreife Erkenntnisse umgesetzt werden können. Abschließend haben wir einen praktischen Entwurf für das Experimentieren mit föderierten Betrugsmodellen vorgestellt, bei dem Datenschutzbewusstsein, Einfachheit und Relevanz für die Praxis im Vordergrund stehen.
Schauen Sie sich das an Vollständige Codes hier. Sie können uns auch gerne weiter folgen Twitter und vergessen Sie nicht, bei uns mitzumachen 100.000+ ML SubReddit und Abonnieren Unser E-newsletter. Warten! Bist du im Telegram? Jetzt können Sie uns auch per Telegram kontaktieren.
Asif Razzaq ist CEO von Marktechpost Media Inc.. Als visionärer Unternehmer und Ingenieur setzt sich Asif dafür ein, das Potenzial der künstlichen Intelligenz für das soziale Wohl zu nutzen. Sein jüngstes Unterfangen ist die Einführung einer Medienplattform für künstliche Intelligenz, Marktechpost, die sich durch eine ausführliche Berichterstattung über maschinelles Lernen und Deep-Studying-Nachrichten auszeichnet, die sowohl technisch fundiert als auch für ein breites Publikum leicht verständlich ist. Die Plattform verfügt über mehr als 2 Millionen monatliche Aufrufe, was ihre Beliebtheit beim Publikum verdeutlicht.