Tutorial Lengkap Flower (flwr): Framework Federated Learning dengan Python

# Tutorial Lengkap Flower (flwr): Framework Federated Learning dengan Python Federated learning adalah paradigma machine learning yang memungkinkan kita melatih model secara kolaboratif tanpa harus m...

By Ruby Abdullah · · tutorial
FlowerFederated LearningPrivacyPyTorchPython

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, getparameters, 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 getparameters(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, getparameters

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,

Artikel Terkait