Qu'est-ce que l'apprentissage fédéré ?

L'apprentissage fédéré (FL) est une technique d'apprentissage automatique qui entraîne ce qu'on appelle un modèle global en utilisant les données d'un ensemble d'appareils décentralisés. D'accord, il y a beaucoup à déballer là-bas. Commençons simplement par décomposer cela étape par étape. En Floride, il existe des appareils locaux (généralement des téléphones, des ordinateurs, etc.) qui stockent et conservent toutes leurs données sur leur appareil. Il existe également un modèle global qui reçoit des paramètres mis à jour, agrège les mises à jour et les utilise pour créer un nouveau modèle plus efficace pour les utilisateurs. La partie intéressante, c'est que le modèle est formé à l'aide des données d'un tas d'appareils, sans que ces données ne soient jamais partagées ! Fou non?

Les appareils locaux utilisent leurs données locales pour exécuter le modèle sur leur appareil et, ce faisant, ils mettent à jour les paramètres (pondérations et biais). Ces paramètres mis à jour sont envoyés au modèle global qui les agrège, ce qui est un mot fantaisiste pour les consommer et les organiser.

Tout cela est en fait assez nouveau, Google a sorti ce modèle en 2016. Il y a donc beaucoup de potentiel pour cette technologie. Dans cet article, j'examinerai en profondeur le code de classification des images à l'aide de TensorFlow Federated.

Qu'est-ce que TensorFlow Federated (TFF) ?

Tff est un framework open source qui permet de former des données décentralisées réparties sur de nombreux appareils. Il fournit essentiellement de nombreux outils utiles pour travailler avec des données fédérées et former des modèles fédérés. Les données fédérées sont différentes des données normales utilisées pour les modèles d'IA, car elles proviennent de différentes sources et il y a beaucoup d'informations.

Quels sont les outils fournis par TFF ?

Avant de plonger dans le code, je voulais faire un bref aperçu des "outils" fournis par tff qui le rendent parfait pour former des modèles fédérés.

• tff.learning.build_federated_adging_process : cette fonction permet aux utilisateurs de travailler avec un moyennage fédéré (FedAvg). FedAvg est le modèle d'apprentissage fédéré le plus couramment utilisé. C'est là que le modèle global envoie les paramètres actuels aux appareils, les appareils exécutent le modèle et mettent à jour les paramètres, puis les renvoient au modèle global. Le modèle global reçoit toutes ces mises à jour et en fait la moyenne, met à jour le modèle, puis les renvoie aux appareils locaux. Ceci est fait jusqu'à ce que le modèle réponde à un certain critère et c'est ce qu'on appelle la convergence.
• tff.learning.build_federated_evaluation_process : Cette fonction permet aux programmeurs d'évaluer l'efficacité du modèle fédéré. Le processus d'évaluation peut être effectué à l'aide du système d'exécution de tff pour calculer des mesures spécifiques telles que l'exactitude, la précision et le rappel
• tff.learning.build_federated_sgd_process : Cette fonction est cruciale pour rendre le réseau efficace. Il construit un processus de formation d'un modèle utilisant la descente de gradient stochastique fédérée, similaire à son utilisation dans la rétropropagation dans les réseaux de neurones.

Le processus

Décomposons le processus

1. Chargement des librairies TFF
2. Prétraite les données
3. Créer le modèle pour entraîner les données
4. Mettre en place un processus de moyennage fédéré
5. Analyser les métriques
6. Configurer les calculs d'évaluation
7. Analyser les métriques d'évaluation

import tensorflow as tf 
import tensorflow_federated as tff
from tensorflow_federated import paillier
import numpy as np  

from tensorflow.python.keras.optimizer_v2 import gradient_descent 
from tensorflow_federated import python as tff

NUM_EPOCHES = 5
BATCH_SIZE = 20 
SHUFFLE_BUFFER = 500 
NUM_CLIENTS = 3

tf.compact.v1.enable_v2_behavior()
emnist_train, emnist_test = tff.simulation.datasets.emnist.load_data()

       
                

                    
                    
                
            

def preprocess(dataset):
    def element_fn(element):
        return collections.OrderedDict([
        ('x', tf.reshape(element['pixels'], [-1])),
        ('y', tf.reshape(element['label'], [1])),
        ])
    return dataset.repeat(NUM_EPOCHES).map(element_fn).shuffle(
        SHUFFLE_BUFFER).batch(BATCH_SIZE)

def make_federated_data(client_data, client_ids):
    return[preprocess(client_data.create_tf_dataset_for_client(x))
    for x in client_ids]

sample_clients = emnist_train.client_ids[0: NUM_CLIENTS]

federated_train_data = make_federated_data(emnist_train, sample_clients)
print(f'Number of clinet datasets:{len(federated_train_data)}')
print(f'First dataset:{federated_train_data[0]}')

def create_keras_model():
    return tf.keras.models.Sequntial([
        tf.keras.layers.Input.Layer(input_shapre=(784,)),
        tf.keras.layers.Dense(10, kernel_initializer= 'zeros'),
        tf.keras.layers.Softmax(),
    ])

def model_fn():
    keras_model = create_keras_model()
    return tff.learning.from_keras_model(
        keras_model,
        input_spec = preprocess_example_dataset.element_spec,
        loss=tf.keras.losses.SparseCategoricalCrossentropy
        metric=[tf.keras.metrics.SparseCategoricalAccuracy()])

iterative_process = tff.learning.build_federated_averaging_process(
    client_optimizer_fn = lambda: tf.keras.optimizers.SDG(learning_rate=0.2),
)
server_optimizer_fn=lambda: tf.keras.optimizers.SDG(learning_rate=0.5)

state = iterative_process.initialize()
state,metrics = iterative_process.next(state, federated_train_data)
print('round 1, metrics={}'.format(metrics['train']))

NUM_ROUNDS = 11 
for round_num in range(2,NUM_ROUNDS):
    state, metrics = iterative_process.next(state,federated_train_data)
    print('round{:2d}, metrics{}'.format(round_num,metrics['train']))

evaluation = tff.learning.build_federated_evaluation(model_fn)
shuffled_ids = emnist_test.client_ids.copy()
random.shuffle(shuffled_ids)
sample_clients - shuffled_ids[0:NUM_CLIENTS]

federated_test_data = make_federated_data(emnist_test, sample_clients)

len(federated_test_data), federated_test_data[0]