Was ist föderiertes Lernen?

Federated Learning (FL) ist eine maschinelle Lerntechnik, die ein sogenanntes globales Modell mit Daten von einer Reihe dezentraler Geräte trainiert. Okay, da gibt es viel auszupacken. Beginnen wir einfach damit, dies Schritt für Schritt aufzuschlüsseln. In FL gibt es lokale Geräte (normalerweise Telefone, Computer usw.), die alle ihre Daten auf ihrem Gerät speichern und aufbewahren. Es gibt auch ein globales Modell, das aktualisierte Parameter empfängt, die Aktualisierungen aggregiert und sie verwendet, um ein neues Modell zu erstellen, das für Benutzer effizienter ist. Der coole Teil ist, dass das Modell mit Daten von einer Reihe von Geräten trainiert wird, ohne dass diese Daten jemals geteilt werden! Verrückt oder?

Die lokalen Geräte verwenden ihre lokalen Daten, um das Modell auf ihrem Gerät auszuführen, und aktualisieren dadurch die Parameter (Gewichte und Verzerrungen). Diese aktualisierten Parameter werden an das globale Modell gesendet, das sie aggregiert, was ein schickes Wort dafür ist, sie zu konsumieren und zu organisieren.

All das ist eigentlich ziemlich neu, Google hat dieses Modell bereits 2016 herausgebracht. Es gibt also viel Potenzial für diese Technologie. In diesem Artikel werde ich den Code für die Bildklassifizierung mit TensorFlow Federated eingehend untersuchen.

Was ist TensorFlow Federated (TFF)?

Tff ist ein Open-Source-Framework, mit dem dezentrale Daten, die auf viele Geräte verteilt sind, trainiert werden können. Es bietet im Wesentlichen viele nützliche Werkzeuge, um mit föderierten Daten zu arbeiten und föderierte Modelle zu trainieren. Föderierte Daten unterscheiden sich von normalen Daten, die für KI-Modelle verwendet werden, da sie aus unterschiedlichen Quellen stammen und viele Informationen enthalten.

Welche Tools bietet TFF?

Bevor wir in den Code eintauchen, wollte ich einen kurzen Überblick über die „Tools“ geben, die tff bereitstellt, die es perfekt machen, föderierte Modelle zu trainieren.

• tff.learning.build_federated_averaging_process: Diese Funktion ermöglicht es Benutzern, mit Federated Averaging (FedAvg) zu arbeiten. FedAvg ist das am häufigsten verwendete föderierte Lernmodell. Hier sendet das globale Modell die aktuellen Parameter an die Geräte, die Geräte führen das Modell aus, aktualisieren die Parameter und senden sie dann an das globale Modell zurück. Das globale Modell empfängt alle diese Aktualisierungen und mittelt sie, aktualisiert das Modell und sendet sie dann an die lokalen Geräte zurück. Dies geschieht so lange, bis das Modell ein bestimmtes Kriterium erfüllt, und dies wird als Konvergenz bezeichnet.
• tff.learning.build_federated_evaluation_process : Mit dieser Funktion können Programmierer die Effizienz des föderierten Modells bewerten. Der Bewertungsprozess kann mit dem Laufzeitsystem von tff durchgeführt werden, um bestimmte Metriken wie Genauigkeit, Präzision und Abruf zu berechnen
• tff.learning.build_federated_sgd_process : Diese Funktion ist entscheidend, um das Netzwerk effizient zu machen. Es baut einen Prozess zum Trainieren eines Modells unter Verwendung von föderiertem stochastischem Gradientenabstieg auf, ähnlich seiner Verwendung bei der Backpropagation in neuronalen Netzen.

Der Prozess

Lassen Sie uns den Prozess aufschlüsseln

1. Laden der TFF-Bibliotheken
2. Verarbeitet die Daten vor
3. Erstellen Sie das Modell zum Trainieren von Daten
4. Richten Sie einen föderierten Mittelungsprozess ein
5. Metriken analysieren
6. Richten Sie die Bewertungsberechnungen ein
7. Analysieren Sie die Bewertungsmetriken

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]