Co to jest nauka federacyjna?

Uczenie federacyjne (FL) to technika uczenia maszynowego, która trenuje coś, co nazywa się modelem globalnym, przy użyciu danych z wielu zdecentralizowanych urządzeń. Dobra, jest tam dużo do rozpakowania. Zacznijmy od rozbicia tego krok po kroku. W FL istnieją urządzenia lokalne (zwykle telefony, komputery itp.), które przechowują i przechowują wszystkie dane na swoim urządzeniu. Istnieje również model globalny, który otrzymuje zaktualizowane parametry, agreguje aktualizacje i wykorzystuje je do stworzenia nowego modelu, który jest bardziej wydajny dla użytkowników. Fajną częścią jest to, że model jest szkolony przy użyciu danych z wielu urządzeń, bez udostępniania tych danych! Szalone prawda?

Lokalne urządzenia wykorzystują swoje lokalne dane do uruchomienia modelu na swoim urządzeniu iw ten sposób aktualizują parametry (wagi i odchylenia). Te zaktualizowane parametry są wysyłane do modelu globalnego, który je agreguje, co jest wymyślnym określeniem na ich konsumowanie i organizowanie.

Wszystko to jest właściwie całkiem nowe, Google wypuściło ten model w 2016 roku. Ta technologia ma więc duży potencjał. W tym artykule przeanalizuję dogłębnie kod klasyfikacji obrazów przy użyciu TensorFlow Federated.

Co to jest Federacja TensorFlow (TFF)?

Tff to platforma typu open source, która umożliwia trenowanie zdecentralizowanych danych rozproszonych na wielu urządzeniach. Zasadniczo zapewnia wiele przydatnych narzędzi do pracy z danymi federacyjnymi i uczenia modeli federacyjnych. Dane federacyjne różnią się od zwykłych danych używanych w modelach AI, ponieważ pochodzą z różnych źródeł i zawierają dużo informacji.

Jakie narzędzia zapewnia TFF?

Zanim zagłębimy się w kod, chciałem zrobić krótki przegląd „narzędzi”, które zapewnia tff, dzięki czemu idealnie nadaje się do trenowania modeli federacyjnych.

• tff.learning.build_federated_averaging_process: Ta funkcja umożliwia użytkownikom pracę z uśrednianiem federacyjnym (FedAvg). FedAvg to najczęściej używany model uczenia federacyjnego. W tym miejscu model globalny wysyła bieżące parametry do urządzeń, urządzenia uruchamiają model i aktualizują parametry, a następnie odsyłają je z powrotem do modelu globalnego. Model globalny odbiera wszystkie te aktualizacje i uśrednia je, aktualizuje model, a następnie odsyła je z powrotem do urządzeń lokalnych. Dzieje się tak, dopóki model nie spełni określonego kryterium i nazywa się to konwergencją.
• tff.learning.build_federated_evaluation_process : Ta funkcja umożliwia programistom ocenę wydajności modelu stowarzyszonego. Proces oceny można przeprowadzić za pomocą systemu wykonawczego tff w celu obliczenia określonych wskaźników, takich jak dokładność, precyzja i pamięć
• tff.learning.build_federated_sgd_process : Ta funkcja ma kluczowe znaczenie dla wydajności sieci. Buduje proces uczenia modelu przy użyciu sfederowanego stochastycznego spadku gradientu, podobnie jak w przypadku propagacji wstecznej w sieciach neuronowych.

Proces

Rozbijmy ten proces

1. Ładowanie bibliotek TFF
2. Wstępnie przetwarza dane
3. Utwórz model do uczenia danych
4. Skonfiguruj federacyjny proces uśredniania
5. Analizuj wskaźniki
6. Skonfiguruj obliczenia ewaluacyjne
7. Przeanalizuj wskaźniki oceny

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]