TensorFlow Federated: Machine Learning on Decentralized Data

import tensorflow as tf
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)
  • TensorFlow Federated (TFF) es un marco de trabajo de código abierto para aprendizaje automático y otros cálculos con datos descentralizados. TFF se desarrolló para facilitar la investigación y experimentación abierta con aprendizaje federado (FL), un enfoque del aprendizaje automático en el que varios clientes participantes que conservan sus datos de entrenamiento de forma local entrenan un modelo general compartido. Por ejemplo, el FL se usó para entrenar modelos de predicción para teclados de dispositivos móviles sin subir a los servidores datos sensibles de la escritura.

    TFF permite a los desarrolladores simular los algoritmos de aprendizaje federado que están incluidos en sus modelos y datos, y experimentar con algoritmos nuevos. Los componentes básicos que proporciona TFF también se pueden usar para implementar cálculos que no sean de aprendizaje, como estadísticas agregadas sobre datos descentralizados. Las interfaces de TFF se organizan en dos capas:

  • Esta capa incluye un conjunto de interfaces de nivel superior que permiten a los desarrolladores aplicar las implementaciones que se incluyen para el entrenamiento y evaluación federados a sus modelos existentes de TensorFlow.
  • El núcleo del sistema consta de un conjunto de interfaces de nivel inferior para expresar de manera concisa nuevos algoritmos federados combinando TensorFlow con operadores de comunicación distribuidos dentro de un entorno de programación funcional fuertemente tipificado. Esta capa también es la base sobre la que creamos el Aprendizaje federado.
  • TFF permite a los desarrolladores expresar cálculos federados de manera declarativa, de modo que se puedan implementar en diferentes entornos de ejecución. TFF incluye un entorno de ejecución que simula una sola máquina para realizar experimentos. Consulta los instructivos y pruébalo tú mismo.