TensorFlow Federated: machine learning em dados descentralizados

import tensorflow as tf
tf.compat.v1.enable_v2_behavior()
import tensorflow_federated as tff

# Load simulation data.
source, _ = tff.simulation.datasets.emnist.load_data()
def client_data(n):
  return source.create_tf_dataset_for_client(source.client_ids[n]).map(
      lambda e: (tf.reshape(e['pixels'], [-1]), e['label'])
  ).repeat(10).batch(20)

# Pick a subset of client devices to participate in training.
train_data = [client_data(n) for n in range(3)]

# Grab a single batch of data so that TFF knows what data looks like.
sample_batch = tf.nest.map_structure(
    lambda x: x.numpy(), iter(train_data[0]).next())

# Wrap a Keras model for use with TFF.
def model_fn():
  model = tf.keras.models.Sequential([
      tf.keras.layers.Dense(10, tf.nn.softmax, input_shape=(784,),
                            kernel_initializer='zeros')
  ])
  return tff.learning.from_keras_model(
      model,
      dummy_batch=sample_batch,
      loss=tf.keras.losses.SparseCategoricalCrossentropy(),
      metrics=[tf.keras.metrics.SparseCategoricalAccuracy()])

# Simulate a few rounds of training with the selected client devices.
trainer = tff.learning.build_federated_averaging_process(
  model_fn,
  client_optimizer_fn=lambda: tf.keras.optimizers.SGD(0.1))
state = trainer.initialize()
for _ in range(5):
  state, metrics = trainer.next(state, train_data)
  print (metrics.loss)
  • O TensorFlow Federated (TFF) é uma biblioteca de código aberto para machine learning e outros cálculos em dados descentralizados. O TFF foi desenvolvido para facilitar a pesquisa aberta e a experimentação com o Federated Learning (FL), uma abordagem de machine learning em que um modelo global compartilhado é treinado em muitos clientes participantes que mantêm os dados de treinamento localmente. Por exemplo, o FL foi usado para treinar modelos de predição para teclados móveis sem fazer upload para os servidores de dados confidenciais de digitação.

    O TFF permite que os desenvolvedores simulem os algoritmos de federated learning incluídos nos modelos e dados deles, além de experimentar novos algoritmos. Os elementos básicos do TFF também podem ser usados para implementar cálculos que não sejam de aprendizagem, como análises agregadas em dados descentralizados. As interfaces do TFF são organizadas em duas camadas:

  • Essa camada oferece um conjunto de interfaces de alto nível que permitem aos desenvolvedores aplicar as implementações incluídas de avaliação e treinamento federados aos modelos existentes do TensorFlow.
  • O núcleo do sistema é um conjunto de interfaces de nível inferior para expressar de maneira concisa novos algoritmos federados, combinando o TensorFlow com operadores distribuídos de comunicação em um ambiente de programação funcional com tipos consistentes. Essa camada também serviu como base para a criação do federated learning.
  • O TFF permite que os desenvolvedores expressem computações federadas de forma declarativa para que elas possam ser implantadas em diversos ambientes de execução. O TFF inclui um ambiente de execução para a simulação de máquina única em experimentos. Visite os tutoriais e faça um teste.