Université -Blida 1- Sécurité des systèmes informatiques
Département d’informatique
M2 ISI
TP : TensorFlow Federated
Exercice 1
Soit un scénario d’apprentissage fédéré avec les contraintes suivantes :
Modèle global :
• Apprentissage supervisé pour prédire si une entrée est supérieure ou non à 0.5, en
utilisant un modèle de réseau de neurones simple.
• Le modèle doit être le même pour tous les clients.
• Les poids du modèle global doivent être mis à jour à chaque round à partir des
contributions locales des clients.
Données locales :
• Chaque client dispose d'un sous-ensemble unique des données globales.
• Les données restent privées et ne sont jamais partagées avec d'autres clients ni avec le
serveur central.
Agrégation des modèles locaux :
• Les mises à jour des poids sont envoyées au serveur central.
• Le serveur utilise l’algorithme Federated Averaging (FedAvg) pour agréger ces mises à
jour de manière optimale.
Travail à faire :
• Minimiser la perte globale et maximiser la précision du modèle global sur l'ensemble
des clients. Résultats meilleurs que : Final Global Model - Loss: 0.4260, Accuracy:
0.9140
• Suivre les performances (précision et perte) sur plusieurs rounds.
• Comparer les performances à celles obtenues avec un modèle centralisé.
Le code :
!pip install --quiet --upgrade tensorflow tensorflow-federated
import tensorflow as tf
import tensorflow_federated as tff
import numpy as np
# 1. Définir un modèle Keras simple
def build_model():
model = [Link]([
[Link](shape=(1,)), # Entrée à une dimension
Université -Blida 1- Sécurité des systèmes informatiques
Département d’informatique
M2 ISI
[Link](10, activation='relu'), # Couche cachée avec 10
neurones
[Link](1, activation='sigmoid') # Couche de sortie
])
return model
# 2. Fonction pour transformer le modèle Keras en un modèle TFF compatible
def model_fn():
keras_model = build_model()
input_spec = (
[Link](shape=[None, 1], dtype=tf.float32), # Spécification des
entrées
[Link](shape=[None, 1], dtype=tf.float32) # Spécification des
étiquettes
)
return [Link].from_keras_model(
keras_model,
input_spec=input_spec,
loss=[Link](),
metrics=[[Link]()]
)
# 3. Définir les optimisateurs pour le client et le serveur
client_optimizer_fn = lambda: [Link](learning_rate=0.1)
server_optimizer_fn = lambda: [Link](learning_rate=1.0)
# 4. Créer un processus d'apprentissage fédéré
federated_training_process = [Link].build_weighted_fed_avg(
model_fn=model_fn,
client_optimizer_fn=client_optimizer_fn,
server_optimizer_fn=server_optimizer_fn
)
# 5. Initialiser le processus fédéré
state = federated_training_process.initialize()
# 6. Générer des données fictives pour l'entraînement fédéré
def generate_data():
x = [Link](1000, 1).astype(np.float32) # Données aléatoires
y = (x > 0.5).astype(np.float32) # Classifier comme 0 ou 1
return x, y
def create_federated_data():
client_data = []
x, y = generate_data()
for i in range(10): # 10 clients fictifs
client_data.append((x[i*100:(i+1)*100], y[i*100:(i+1)*100]))
Université -Blida 1- Sécurité des systèmes informatiques
Département d’informatique
M2 ISI
return client_data
# 7. Préparer les données pour TFF
def preprocess(client_data):
def to_dataset(data):
x, y = data
return [Link].from_tensor_slices((x, y)).batch(20)
return [to_dataset(data) for data in client_data]
federated_data = preprocess(create_federated_data())
# 8. Entraîner le modèle fédéré sur plusieurs rounds
accuracies = []
losses = []
num_rounds = 10
for round_num in range(1, num_rounds + 1):
state, metrics = federated_training_process.next(state, federated_data)
# Naviguer dans les métriques pour extraire les valeurs pertinentes
train_metrics = metrics['client_work']['train']
accuracy = train_metrics.get('binary_accuracy', 0.0)
loss = train_metrics.get('loss', 0.0)
[Link](accuracy)
[Link](loss)
print(f"Round {round_num} - Loss: {loss:.4f}, Accuracy: {accuracy:.4f}")
# 9. Fonction pour assigner les poids au modèle Keras
def assign_weights_to_keras_model(keras_model, tff_weights):
# Les poids TFF sont directement une liste
keras_model.set_weights(tff_weights)
# 10. Charger les poids globaux dans un modèle Keras pour évaluation
final_keras_model = build_model()
# Extraire les poids globaux sous forme de liste
global_weights = federated_training_process.get_model_weights(state).trainable
# Appliquer les poids au modèle Keras
assign_weights_to_keras_model(final_keras_model, global_weights)
# Compiler le modèle pour l'évaluation
final_keras_model.compile(optimizer='sgd',
loss='binary_crossentropy',
Université -Blida 1- Sécurité des systèmes informatiques
Département d’informatique
M2 ISI
metrics=['accuracy'])
# 11. Évaluer le modèle global
x_test, y_test = generate_data()
test_data = [Link].from_tensor_slices((x_test, y_test)).batch(32)
loss, accuracy = final_keras_model.evaluate(test_data, verbose=0)
print(f"\nFinal Global Model - Loss: {loss:.4f}, Accuracy: {accuracy:.4f}")
