Tutorial Lengkap Flower (flwr): Framework Federated Learning dengan Python
Federated learning adalah paradigma machine learning yang memungkinkan kita melatih model secara kolaboratif tanpa harus mengumpulkan data ke satu tempat terpusat. Bayangkan Anda memiliki sepuluh rumah sakit, masing-masing dengan data pasien sensitif. Dengan federated learning, setiap rumah sakit bisa melatih model di data lokal mereka, lalu hanya mengirim parameter model (bukan data mentah) ke server pusat untuk diagregasi. Hasilnya? Model yang lebih baik tanpa mengorbankan privasi data.
Flower (flwr) adalah framework open-source yang membuat implementasi federated learning menjadi jauh lebih mudah. Framework ini mendukung berbagai ML framework seperti PyTorch, TensorFlow, dan JAX, serta menyediakan arsitektur yang fleksibel untuk eksperimen maupun deployment production. Dalam tutorial ini, saya akan memandu Anda dari instalasi hingga deployment, lengkap dengan contoh kode yang bisa langsung dijalankan.
Instalasi dan Persiapan Environment
Sebelum memulai, pastikan Anda sudah menginstal Python 3.8 atau lebih baru. Saya merekomendasikan penggunaan virtual environment untuk menghindari konflik dependensi.
# Buat virtual environment
python -m venv flower-env
source flower-env/bin/activate # Linux/Mac
flower-env\Scripts\activate # Windows
Instal Flower beserta dependensi simulasi
pip install flwr[simulation]
Instal PyTorch (kita akan menggunakan ini sebagai ML framework)
pip install torch torchvision
Verifikasi instalasi
python -c "import flwr; print(f'Flower version: {flwr.version}')"
Paket flwr[simulation] sudah termasuk komponen untuk menjalankan simulasi federated learning di satu mesin, yang sangat berguna untuk prototyping dan eksperimen. Jika Anda hanya butuh komponen dasar tanpa simulasi, cukup instal pip install flwr.
Struktur direktori project yang akan kita buat kurang lebih seperti ini:
flower-tutorial/
├── server.py # FL server
├── client.py # FL client
├── model.py # Definisi model PyTorch
├── dataset.py # Utilitas dataset
├── simulation.py # Script simulasi
├── strategy.py # Custom strategy
└── requirements.txt
Konsep Dasar Federated Learning
Sebelum masuk ke kode, mari kita pahami konsep fundamental federated learning yang diimplementasikan oleh Flower.
Arsitektur Server-Client
Federated learning bekerja dengan arsitektur server-client. Server bertindak sebagai koordinator yang mengelola proses training secara keseluruhan. Server mengirim model global ke client, mengumpulkan update dari client, dan mengagregasi update tersebut menjadi model global yang baru. Client adalah peserta yang memiliki data lokal. Setiap client menerima model global, melatihnya dengan data lokal, lalu mengirim parameter model yang sudah diupdate kembali ke server.
Federated Averaging (FedAvg)
FedAvg adalah algoritma agregasi paling populer dalam federated learning, diperkenalkan oleh McMahan et al. pada 2017. Cara kerjanya sederhana. Pertama, server mengirim model global ke subset client yang dipilih. Kedua, setiap client melatih model tersebut di data lokal selama beberapa epoch. Ketiga, client mengirim kembali parameter model yang sudah diupdate. Keempat, server menghitung rata-rata tertimbang dari semua parameter client berdasarkan jumlah sampel data masing-masing. Kelima, proses ini diulang selama beberapa round.
Communication Round
Satu siklus lengkap dari pengiriman model ke client, training lokal, dan agregasi di server disebut satu communication round. Biasanya dibutuhkan beberapa puluh hingga ratusan round untuk mencapai konvergensi model.
Flower Architecture
Flower memiliki beberapa komponen utama. Strategy mendefinisikan bagaimana server memilih client, mengagregasi parameter, dan mengevaluasi model. Client mengimplementasikan logika training dan evaluasi lokal. Server mengorkestrasi seluruh proses federated learning. SuperLink adalah komponen inti Flower yang mengelola komunikasi antara server dan client.
Basic Usage: Federated Learning dengan PyTorch dan CIFAR-10
Mari kita mulai dengan contoh konkret, yaitu melatih model klasifikasi gambar pada dataset CIFAR-10 menggunakan federated learning.
Langkah 1: Definisikan Model
Buat file model.py yang berisi arsitektur neural network sederhana:
# model.py
import torch
import torch.nn as nn
import torch.nn.functional as F
class SimpleCNN(nn.Module):
"""CNN sederhana untuk klasifikasi CIFAR-10."""
def init(self):
super(SimpleCNN, self).init()
self.conv1 = nn.Conv2d(3, 32, 3, padding=1)
self.conv2 = nn.Conv2d(32, 64, 3, padding=1)
self.pool = nn.MaxPool2d(2, 2)
self.fc1 = nn.Linear(64 8 8, 256)
self.fc2 = nn.Linear(256, 10)
self.dropout = nn.Dropout(0.25)
def forward(self, x):
x = self.pool(F.relu(self.conv1(x)))
x = self.pool(F.relu(self.conv2(x)))
x = x.view(-1, 64 8 8)
x = self.dropout(F.relu(self.fc1(x)))
x = self.fc2(x)
return x
def getparameters(model):
"""Ambil parameter model sebagai list numpy array."""
return [val.cpu().numpy() for , val in model.statedict().items()]
def setparameters(model, parameters):
"""Set parameter model dari list numpy array."""
paramsdict = zip(model.statedict().keys(), parameters)
statedict = {k: torch.tensor(v) for k, v in paramsdict}
model.loadstatedict(statedict, strict=True)
Langkah 2: Persiapkan Dataset
Buat file dataset.py untuk mengelola pembagian dataset ke beberapa client:
# dataset.py
import torch
from torch.utils.data import DataLoader, randomsplit, Subset
from torchvision import datasets, transforms
def loaddatasets(numclients: int = 5, batchsize: int = 32):
"""
Load CIFAR-10 dan bagi secara merata ke beberapa client.
Mengembalikan list of (trainloader, valloader) untuk setiap client,
beserta testloader untuk evaluasi global.
"""
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.4914, 0.4822, 0.4465),
(0.2470, 0.2435, 0.2616))
])
trainset = datasets.CIFAR10(
root="./data", train=True, download=True, transform=transform
)
testset = datasets.CIFAR10(
root="./data", train=False, download=True, transform=transform
)
# Bagi training set ke setiap client secara merata
partitionsize = len(trainset) // numclients
lengths = [partitionsize] numclients
# Tambahkan sisa ke partisi terakhir
lengths[-1] += len(trainset) - sum(lengths)
partitions = randomsplit(
trainset, lengths, generator=torch.Generator().manualseed(42)
)
trainloaders = []
valloaders = []
for partition in partitions:
# Bagi setiap partisi menjadi 80% train, 20% validation
numval = int(len(partition) 0.2)
numtrain = len(partition) - numval
trainpart, valpart = randomsplit(partition, [numtrain, numval])
trainloaders.append(
DataLoader(trainpart, batchsize=batchsize, shuffle=True)
)
valloaders.append(
DataLoader(valpart, batchsize=batchsize)
)
testloader = DataLoader(testset, batchsize=batchsize)
return trainloaders, valloaders, testloader
Langkah 3: Implementasikan Flower Client
Buat file client.py yang mengimplementasikan logika training dan evaluasi di sisi client:
# client.py
from collections import OrderedDict
from typing import Dict, List, Tuple
import numpy as np
import torch
import torch.nn as nn
import flwr as fl
from model import SimpleCNN, getparameters, setparameters
class CifarClient(fl.client.NumPyClient):
"""Flower client untuk training CIFAR-10."""
def init(self, trainloader, valloader, device):
self.trainloader = trainloader
self.valloader = valloader
self.device = device
self.model = SimpleCNN().to(self.device)
def getparameters(self, config):
"""Kembalikan parameter model saat ini."""
return getparameters(self.model)
def fit(self, parameters, config):
"""
Terima parameter dari server, latih model di data lokal,
kembalikan parameter yang sudah diupdate.
"""
setparameters(self.model, parameters)
# Ambil hyperparameter dari config server (jika ada)
epochs = config.get("localepochs", 1)
lr = config.get("learningrate", 0.01)
# Training loop
self.model.train()
optimizer = torch.optim.SGD(
self.model.parameters(), lr=lr, momentum=0.9
)
criterion = nn.CrossEntropyLoss()
for epoch in range(epochs):
totalloss = 0.0
for images, labels in self.trainloader:
images = images.to(self.device)
labels = labels.to(self.device)
optimizer.zerograd()
outputs = self.model(images)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
totalloss += loss.item()
return (
getparameters(self.model), # Parameter yang sudah diupdate
len(self.trainloader.dataset), # Jumlah sampel training
{"trainloss": totalloss / len(self.trainloader)}, # Metrics
)
def evaluate(self, parameters, config):
"""Evaluasi model pada data validasi lokal."""
setparameters(self.model, parameters)
self.model.eval()
criterion = nn.CrossEntropyLoss()
correct = 0
total = 0
totalloss = 0.0
with torch.nograd():
for images, labels in self.valloader:
images = images.to(self.device)
labels = labels.to(self.device)
outputs = self.model(images)
loss = criterion(outputs, labels)
totalloss += loss.item()
, predicted = torch.max(outputs, 1)
total += labels.size(0)
correct += (predicted == labels).sum().item()
accuracy = correct / total
avgloss = totalloss / len(self.valloader)
return avgloss, total, {"accuracy": accuracy}
Langkah 4: Setup Server
Buat file server.py untuk menjalankan FL server dengan strategi FedAvg:
# server.py
import flwr as fl
from flwr.server.strategy import FedAvg
from model import SimpleCNN, getparameters
def getonfitconfig():
"""Fungsi untuk mengirim config ke client setiap round."""
def onfitconfig(serverround: int):
config = {
"localepochs": 2,
"learningrate": 0.01 if serverround < 5 else 0.001,
}
return config
return onfitconfig
def main():
# Inisialisasi model untuk mendapatkan parameter awal
model = SimpleCNN()
initialparameters = fl.common.ndarraystoparameters(
getparameters(model)
)
# Konfigurasi strategy FedAvg
strategy = FedAvg(
fractionfit=0.5, # Pilih 50% client untuk training
fractionevaluate=0.5, # Pilih 50% client untuk evaluasi
minfitclients=2, # Minimal 2 client untuk training
minevaluateclients=2, # Minimal 2 client untuk evaluasi
minavailableclients=3, # Minimal 3 client harus terhubung
initialparameters=initialparameters,
onfitconfigfn=getonfitconfig(),
)
# Jalankan server
fl.server.startserver(
serveraddress="0.0.0.0:8080",
config=fl.server.ServerConfig(numrounds=10),
strategy=strategy,
)
if name == "main":
main()
Langkah 5: Menjalankan Client
Untuk menjalankan client yang terhubung ke server, buat script launcher:
# runclient.py
import sys
import torch
import flwr as fl
from client import CifarClient
from dataset import loaddatasets
def main():
# Tentukan client ID dari argument
clientid = int(sys.argv[1]) if len(sys.argv) > 1 else 0
numclients = int(sys.argv[2]) if len(sys.argv) > 2 else 5
device = torch.device("cuda" if torch.cuda.isavailable() else "cpu")
print(f"Client {clientid} menggunakan device: {device}")
# Load dataset untuk client ini
trainloaders, valloaders, = loaddatasets(numclients=numclients)
trainloader = trainloaders[clientid]
valloader = valloaders[clientid]
print(f"Client {clientid}: {len(trainloader.dataset)} training samples, "
f"{len(valloader.dataset)} validation samples")
# Buat dan jalankan Flower client
client = CifarClient(trainloader, valloader, device)
fl.client.startclient(
serveraddress="127.0.0.1:8080",
client=client.toclient(),
)
if name == "main":
main()
Untuk menjalankan seluruh sistem, buka beberapa terminal:
# Terminal 1: Jalankan server
python server.py
Terminal 2: Jalankan client 0
python runclient.py 0 5
Terminal 3: Jalankan client 1
python runclient.py 1 5
Terminal 4: Jalankan client 2
python runclient.py 2 5
Server akan mulai training setelah minimal 3 client terhubung (sesuai konfigurasi minavailableclients).
Simulation Mode: Eksperimen Tanpa Multiple Proses
Salah satu fitur terbaik Flower adalah simulation mode. Dengan fitur ini, Anda bisa menjalankan eksperimen federated learning lengkap dalam satu proses Python, tanpa perlu membuka banyak terminal. Ini sangat berguna untuk riset dan prototyping.
# simulation.py
import torch
import flwr as fl
from flwr.common import Metrics
from flwr.server.strategy import FedAvg
from typing import List, Tuple
from client import CifarClient
from model import SimpleCNN, getparameters
from dataset import loaddatasets
NUMCLIENTS = 10
DEVICE = torch.device("cuda" if torch.cuda.isavailable() else "cpu")
Load semua dataset sekaligus
trainloaders, valloaders, testloader = loaddatasets(
numclients=NUMCLIENTS, batchsize=32
)
def clientfn(cid: str):
"""Fungsi factory yang membuat client berdasarkan ID."""
clientid = int(cid)
return CifarClient(
trainloaders[clientid],
valloaders[clientid],
DEVICE,
).toclient()
def weightedaverage(metrics: List[Tuple[int, Metrics]]) -> Metrics:
"""Hitung rata-rata tertimbang dari metrics evaluasi."""
accuracies = [numexamples m["accuracy"] for numexamples, m in metrics]
examples = [numexamples for numexamples, in metrics]
return {"accuracy": sum(accuracies) / sum(examples)}
def serversideevaluation(serverround, parameters, config):
"""Evaluasi model global di test set."""
model = SimpleCNN().to(DEVICE)
paramslist = fl.common.parameterstondarrays(parameters)
paramsdict = zip(model.statedict().keys(), paramslist)
statedict = {k: torch.tensor(v) for k, v in paramsdict}
model.loadstatedict(statedict, strict=True)
model.eval()
correct = 0
total = 0
with torch.nograd():
for images, labels in testloader:
images = images.to(DEVICE)
labels = labels.to(DEVICE)
outputs = model(images)
, predicted = torch.max(outputs, 1)
total += labels.size(0)
correct += (predicted == labels).sum().item()
accuracy = correct / total
print(f"[Round {serverround}] Test accuracy: {accuracy:.4f}")
return accuracy, {"testaccuracy": accuracy}
def main():
# Inisialisasi model dan parameter awal
model = SimpleCNN()
initialparams = fl.common.ndarraystoparameters(getparameters(model))
strategy = FedAvg(
fractionfit=0.3,
fractionevaluate=0.3,
minfitclients=3,
minevaluateclients=3,
minavailableclients=NUMCLIENTS,
initialparameters=initialparams,
evaluatemetricsaggregationfn=weightedaverage,
evaluatefn=serversideevaluation,
onfitconfigfn=lambda rnd: {
"localepochs": 2,
"learningrate": 0.01
},
)
# Jalankan simulasi
history = fl.simulation.startsimulation(
clientfn=clientfn,
numclients=NUMCLIENTS,
config=fl.server.ServerConfig(numrounds=15),
strategy=strategy,
clientresources={"numcpus": 2, "numgpus": 0.0},
)
# Tampilkan hasil
print("\n=== Hasil Simulasi ===")
print(f"Rounds completed: {len(history.metricscentralized)}")
if "testaccuracy" in history.metricscentralized:
for roundnum, accuracy in history.metricscentralized["testaccuracy"]:
print(f"Round {roundnum}: Test Accuracy = {accuracy:.4f}")
if name == "main":
main()
Jalankan simulasi cukup dengan satu command:
python simulation.py
Parameter clientresources menentukan berapa CPU dan GPU yang dialokasikan untuk setiap virtual client. Flower akan secara otomatis menjadwalkan client berdasarkan resource yang tersedia, sehingga jika Anda memiliki 4 CPU dan setiap client butuh 2 CPU, maka 2 client akan berjalan secara paralel.
Advanced Usage
Custom Strategy
Flower menyediakan beberapa built-in strategy seperti FedAvg, FedProx, FedAdam, dan FedMedian. Namun, Anda juga bisa membuat strategy sendiri untuk eksperimen riset atau kebutuhan khusus.
Berikut contoh custom strategy yang menambahkan mekanisme weighted aggregation berdasarkan performa client dan momentum:
# strategy.py
from typing import Dict, List, Optional, Tuple, Union
import numpy as np
import flwr as fl
from flwr.common import (
FitRes,
MetricsAggregationFn,
NDArrays,
Parameters,
Scalar,
ndarraystoparameters,
parameterstondarrays,
)
from flwr.server.clientproxy import ClientProxy
from flwr.server.strategy import Strategy
from flwr.server.strategy.aggregate import aggregate
class FedAvgWithMomentum(fl.server.strategy.FedAvg):
"""
FedAvg dengan server-side momentum.
Menggunakan momentum untuk menstabilkan training
dan mempercepat konvergensi.
"""
def init(
self,
momentum: float = 0.9,
serverlearningrate: float = 1.0,
kwargs,
):
super().init(kwargs)
self.momentum = momentum
self.serverlearningrate = serverlearningrate
self.velocity: Optional[NDArrays] = None
def aggregatefit(
self,
serverround: int,
results: List[Tuple[ClientProxy, FitRes]],
failures: List[Union[Tuple[ClientProxy, FitRes], BaseException]],
) -> Tuple[Optional[Parameters], Dict[str, Scalar]]:
"""Agregasi dengan momentum."""
if not results:
return None, {}
# Log informasi failures
if failures:
print(f"Round {serverround}: {len(failures)} client failures")
# Lakukan agregasi standar (weighted average)
aggregatedparams, metrics = super().aggregatefit(
serverround, results, failures
)
if aggregatedparams is None:
return None, metrics
# Konversi ke numpy arrays
aggregatedndarrays = parameterstondarrays(aggregatedparams)
# Hitung pseudo-gradient (selisih antara model baru dan lama)
if self.velocity is None:
# Inisialisasi velocity dengan zeros
self.velocity = [
np.zeroslike(layer) for layer in aggregatedndarrays
]
# Ambil parameter model saat ini dari round sebelumnya
# (disimpan di initialparameters pada round pertama)
currentparams = parameterstondarrays(self.initialparameters)
# Update velocity dengan momentum
for i in range(len(self.velocity)):
gradient = aggregatedndarrays[i] - currentparams[i]
self.velocity[i] = (
self.momentum self.velocity[i]
- self.serverlearningrate gradient
)
aggregatedndarrays[i] = currentparams[i] + self.velocity[i]
# Simpan parameter baru sebagai initial untuk round berikutnya
self.initialparameters = ndarraystoparameters(aggregatedndarrays)
print(f"Round {serverround}: Aggregated {len(results)} clients "
f"with momentum={self.momentum}")
return ndarraystoparameters(aggregatedndarrays), metrics
Untuk menggunakan custom strategy ini di simulasi:
from strategy import FedAvgWithMomentum
from model import SimpleCNN, getparameters
model = SimpleCNN()
initialparams = fl.common.ndarraystoparameters(getparameters(model))
strategy = FedAvgWithMomentum(
momentum=0.9,
serverlearningrate=1.0,
fractionfit=0.5,
fractionevaluate=0.3,
minfitclients=3,
minevaluateclients=3,
minavailableclients=NUMCLIENTS,
initialparameters=initialparams,
)
FedProx: Menangani Data Non-IID
Dalam skenario dunia nyata, data di setiap client biasanya tidak identically distributed (non-IID). Misalnya, satu rumah sakit mungkin memiliki lebih banyak kasus penyakit tertentu dibanding rumah sakit lain. FedProx mengatasi masalah ini dengan menambahkan proximal term pada loss function.
Flower sudah menyediakan FedProx sebagai built-in strategy. Untuk menggunakannya, Anda perlu memodifikasi client agar mendukung proximal term:
# clientfedprox.py
import torch
import torch.nn as nn
import flwr as fl
from model import SimpleCNN, get
parameters, setparameters
class CifarClientFedProx(fl.client.NumPyClient):
"""Client dengan dukungan FedProx proximal term."""
def init(self, trainloader, valloader, device):
self.trainloader = trainloader
self.valloader = valloader
self.device = device
self.model = SimpleCNN().to(self.device)
def get
parameters(self, config):
return getparameters(self.model)
def fit(self, parameters, config):
setparameters(self.model, parameters)
# Simpan parameter global sebagai referensi untuk proximal term
globalparams = [p.clone().detach() for p in self.model.parameters()]
epochs = config.get("localepochs", 1)
lr = config.get("learningrate", 0.01)
proximalmu = config.get("proximalmu", 0.1)
self.model.train()
optimizer = torch.optim.SGD(
self.model.parameters(), lr=lr, momentum=0.9
)
criterion = nn.CrossEntropyLoss()
for epoch in range(epochs):
for images, labels in self.trainloader:
images = images.to(self.device)
labels = labels.to(self.device)
optimizer.zerograd()
outputs = self.model(images)
loss = criterion(outputs, labels)
# Tambahkan proximal term: (mu/2) ||w - wglobal||^2
proximalterm = 0.0
for localp, globalp in zip(
self.model.parameters(), globalparams
):
proximalterm += (localp - globalp).norm(2) * 2
loss += (proximalmu / 2) proximalterm
loss.backward()
optimizer.step()
return (
getparameters(self.model),
len(self.trainloader.dataset),
{},
)
def evaluate(self, parameters, config):
setparameters(self.model, parameters)
self.model.eval()
criterion = nn.CrossEntropyLoss()
correct, total, totalloss = 0, 0, 0.0
with torch.nograd():
for images, labels in self.valloader:
images = images.to(self.device)
labels = labels.to(self.device)
outputs = self.model(images)
loss = criterion(outputs, labels)
totalloss += loss.item()
, predicted = torch.max(outputs, 1)
total += labels.size(0)
correct += (predicted == labels).sum().item()
return totalloss / len(self.valloader), total, {
"accuracy": correct / total
}
Untuk server, gunakan strategy FedProx:
from flwr.server.strategy import FedProx
strategy = FedProx(
fractionfit=0.5,
fractionevaluate=0.3,
minfitclients=3,
minevaluateclients=3,
minavailableclients=NUMCLIENTS,
initialparameters=initialparams,
proximalmu=0.1, # Kekuatan proximal term
onfitconfigfn=lambda rnd: {
"localepochs": 2,
"learningrate": 0.01,
"proximalmu": 0.1,
},
)
Secure Aggregation
Keamanan adalah aspek krusial dalam federated learning. Meskipun data mentah tidak pernah meninggalkan client, parameter model yang dikirim masih bisa membocorkan informasi tentang data (melalui model inversion attacks, misalnya). Flower mendukung secure aggregation untuk mengatasi masalah ini.
Berikut contoh implementasi secure aggregation sederhana menggunakan teknik masking:
# securestrategy.py
import numpy as np
from typing import Dict, List, Optional, Tuple, Union
from flwr.common import (
FitRes, Parameters, Scalar,
ndarraystoparameters, parameterstondarrays,
)
from flwr.server.clientproxy import ClientProxy
from flwr.server.strategy import FedAvg
class SecureFedAvg(FedAvg):
"""
FedAvg dengan penambahan differential privacy (DP)
pada sisi server. Menambahkan Gaussian noise
ke parameter teragregasi untuk melindungi privasi client.
"""
def init(
self,
noisemultiplier: float = 0.1,
clippingnorm: float = 1.0,
kwargs,
):
super().init(kwargs)
self.noisemultiplier = noisemultiplier
self.clippingnorm = clippingnorm
def aggregatefit(
self,
serverround: int,
results: List[Tuple[ClientProxy, FitRes]],
failures: List[Union[Tuple[ClientProxy, FitRes], BaseException]],
) -> Tuple[Optional[Parameters], Dict[str, Scalar]]:
"""Agregasi dengan differential privacy."""
# Lakukan agregasi standar terlebih dahulu
aggregatedparams, metrics = super().aggregatefit(
serverround, results, failures
)
if aggregatedparams is None:
return None, metrics
# Konversi ke numpy arrays
ndarrays = parameterstondarrays(aggregatedparams)
# Terapkan clipping pada setiap layer
totalnorm = np.sqrt(
sum(np.sum(layer * 2) for layer in ndarrays)
)
clipfactor = min(1.0, self.clippingnorm / (totalnorm + 1e-6))
clipped = [layer clipfactor for layer in ndarrays]
# Tambahkan Gaussian noise
noisyparams = []
for layer in clipped:
noise = np.random.normal(
loc=0.0,
scale=self.noisemultiplier self.clippingnorm,
size=layer.shape,
)
noisyparams.append(layer + noise)
print(f"Round {serverround}: Applied DP noise "
f"(multiplier={self.noisemultiplier}, "
f"clip={self.clippingnorm})")
return ndarraystoparameters(noisyparams), metrics
Untuk menggunakan secure aggregation:
strategy = SecureFedAvg(
noisemultiplier=0.05, # Tingkat noise (trade-off privasi vs akurasi)
clippingnorm=1.0, # Batas norma gradient
fractionfit=0.5,
minfitclients=3,
minavailableclients=NUMCLIENTS,
initialparameters=initialparams,
)
Perlu dicatat bahwa semakin tinggi noisemultiplier, semakin kuat perlindungan privasinya, tetapi akurasi model akan menurun. Ini adalah trade-off fundamental dalam differential privacy yang harus Anda pertimbangkan sesuai kebutuhan aplikasi.
Deployment ke Production
Flower versi terbaru menggunakan arsitektur SuperLink untuk deployment production. Berikut langkah-langkahnya.
Pertama, buat file konfigurasi pyproject.toml untuk project Flower Anda:
[project]
name = "cifar10-federated"
version = "1.0.0"
description = "Federated CIFAR-10 classification"
license = "Apache-2.0"
[tool.flwr.app.components]
serverapp = "server:app"
clientapp = "client:app"
[tool.flwr.app.config]
num-server-rounds = 20
local-epochs = 2
learning-rate = 0.01
[tool.flwr.federations]
default = "local-simulation"
[tool.flwr.federations.local-simulation]
options.num-supernodes = 10
options.backend.client-resources.num-cpus = 2
options.backend.client-resources.num-gpus = 0.0
Kemudian buat server app dan client app sesuai format Flower modern:
# serverapp.py
import flwr as fl
from flwr.server.strategy import FedAvg
from model import SimpleCNN, get
parameters
def serverfn(context):
"""Konfigurasi server."""
model = SimpleCNN()
initialparams = fl.common.ndarraystoparameters(
getparameters(model)
)
numrounds = context.runconfig.get("num-server-rounds", 10)
strategy = FedAvg(
fractionfit=0.5,
fractionevaluate=0.3,
minfitclients=3,
minavailableclients=5,
initialparameters=initialparams,
)
config = fl.server.ServerConfig(numrounds=numrounds)
return fl.server.ServerAppComponents(strategy=strategy, config=config)
app = fl.server.ServerApp(serverfn=serverfn)
# clientapp.py
import torch
import flwr as fl
from client import CifarClient
from dataset import loaddatasets
trainloaders, valloaders, = loaddatasets(numclients=10)
def clientfn(context):
"""Buat client berdasarkan partition ID."""
partitionid = context.nodeconfig["partition-id"]
device = torch.device("cuda" if torch.cuda.isavailable() else "cpu")
return CifarClient(
trainloaders[partitionid],
valloaders[partitionid],
device,
).toclient()
app = fl.client.ClientApp(clientfn=clientfn)
Jalankan dengan Flower CLI:
# Jalankan simulasi lokal
flwr run . local-simulation
Atau jalankan komponen secara terpisah untuk deployment
flwr run . --federation production
Best Practices
Berikut adalah kumpulan best practices yang saya rekomendasikan berdasarkan pengalaman mengimplementasikan federated learning di berbagai project.
1. Mulai dengan Simulasi
Selalu mulai eksperimen dengan simulation mode sebelum deploy ke environment distributed. Simulasi jauh lebih cepat untuk iterasi dan debugging. Anda bisa memvalidasi strategi, hyperparameter, dan arsitektur model tanpa overhead komunikasi jaringan.
2. Tangani Data Non-IID dengan Tepat
Data di dunia nyata hampir selalu non-IID. Beberapa teknik yang bisa Anda gunakan antara lain menggunakan FedProx sebagai pengganti FedAvg standar, menerapkan data augmentation di sisi client, menggunakan batch normalization dengan hati-hati (gunakan group normalization sebagai alternatif), serta mempertimbangkan personalization layer yang tidak diagregasi.
3. Monitor Training dengan Callback
from flwr.server.strategy import FedAvg
class MonitoredFedAvg(FedAvg):
def aggregatefit(self, serverround, results, failures):
params, metrics = super().aggregatefit(
serverround, results, failures
)
# Log jumlah client dan failures
print(f"Round {serverround}: "
f"{len(results)} successful, "
f"{len(failures)} failed")
# Log metrics dari setiap client
for clientproxy, fitres in results:
clientmetrics = fitres.metrics
print(f" Client: loss={clientmetrics.get('trainloss', 'N/A')}")
return params, metrics
4. Atur Resource dengan Bijak
Dalam simulation mode, alokasikan resource yang realistis. Jika client Anda di production akan berjalan di perangkat dengan resource terbatas, simulasikan hal yang sama. Gunakan clientresources parameter:
fl.simulation.startsimulation(
clientfn=clientfn,
numclients=100,