O que é aprendizagem federada?

O aprendizado federado (FL) é uma técnica de aprendizado de máquina que treina algo chamado modelo global usando dados de vários dispositivos descentralizados. Ok, muito para desempacotar lá. Vamos começar dividindo isso passo a passo. No FL, existem dispositivos locais (normalmente telefones, computadores, etc.) que armazenam e mantêm todos os seus dados em seus dispositivos. Há também um modelo global que recebe parâmetros atualizados, agrega as atualizações e as utiliza para fazer um novo modelo mais eficiente para os usuários. A parte legal é que o modelo é treinado usando dados de vários dispositivos, sem que esses dados sejam compartilhados! Louco né?

Os dispositivos locais usam seus dados locais para executar o modelo em seu dispositivo e, ao fazer isso, atualizam os parâmetros (pesos e bias). Esses parâmetros atualizados são enviados para o modelo global que os agrega, que é uma palavra chique para consumi-los e organizá-los.

Na verdade, tudo isso é muito novo, o Google lançou esse modelo em 2016. Portanto, há muito potencial para essa tecnologia. Neste artigo estarei examinando, em profundidade, o código para classificação de imagens usando o TensorFlow Federated.

O que é o TensorFlow Federado (TFF)?

Tff é uma estrutura de código aberto que permite que dados descentralizados espalhados por muitos dispositivos sejam treinados. Ele essencialmente fornece muitas ferramentas úteis para trabalhar com dados federados e treinar modelos federados. Os dados federados são diferentes dos dados normais usados ​​para modelos de IA, porque vêm de diferentes fontes e há muitas informações.

Quais ferramentas o TFF oferece?

Antes de mergulharmos no código, gostaria de fazer uma breve visão geral das “ferramentas” que tff fornece que o tornam perfeito para treinar modelos federados.

• tff.learning.build_federated_averaging_process: Esta função permite que os usuários trabalhem com média federada (FedAvg). FedAvg é o modelo de aprendizado federado mais comumente usado. É aqui que o modelo global envia os parâmetros atuais para os dispositivos, os dispositivos executam o modelo e atualizam os parâmetros e os enviam de volta ao modelo global. O modelo global recebe todas essas atualizações e calcula a média delas, atualiza o modelo e as envia de volta aos dispositivos locais. Isso é feito até que o modelo atenda a um determinado critério e isso é chamado de convergência.
• tff.learning.build_federated_evaluation_process : Esta função permite que os programadores avaliem a eficiência do modelo federado. O processo de avaliação pode ser feito usando o sistema de tempo de execução do tff para calcular métricas específicas como exatidão, precisão e recall
• tff.learning.build_federated_sgd_process : Esta função é crucial para tornar a rede eficiente. Ele constrói um processo para treinar um modelo usando gradiente descendente estocástico federado, semelhante ao seu uso em retropropagação em Redes Neurais.

O processo

Vamos quebrar o processo

1. Carregando as bibliotecas TFF
2. Pré-processa os dados
3. Criar o modelo para treinar dados
4. Configurar um processo de média federado
5. Analisar métricas
6. Configure os cálculos de avaliação
7. Analise as métricas de avaliação

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]