TensorFlow Federated : machine learning sur les données décentralisées

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) est un framework Open Source qui permet d'appliquer le machine learning et d'effectuer différents calculs sur des données décentralisées. TFF a été développé en vue de promouvoir la science ouverte et l'expérimentation avec l'apprentissage fédéré, une méthode de machine learning par laquelle un modèle global partagé est entraîné par un grand nombre de clients participants qui conservent leurs données d'entraînement en local. L'apprentissage fédéré a ainsi été utilisé pour entraîner des modèles de prédiction pour les claviers d'appareils mobiles, sans importer de données de saisie sensibles sur les serveurs.

    TFF permet non seulement aux développeurs de simuler les algorithmes d'apprentissage fédérés inclus sur leurs modèles et leurs données, mais aussi de tester de nouveaux algorithmes. Les composants fournis par TFF peuvent également être utilisés pour implémenter des calculs non destinés à l'apprentissage, tels que des analyses agrégées sur des données décentralisées. Les interfaces de TFF sont organisées en deux couches :

  • Cette couche propose un ensemble d'interfaces de haut niveau permettant aux développeurs d'appliquer les implémentations d'évaluation et d'apprentissage fédéré incluses à leurs modèles TensorFlow.
  • Au cœur du système, on trouve un ensemble d'interfaces de niveau inférieur permettant d'exprimer de manière concise de nouveaux algorithmes fédérés en combinant TensorFlow avec des opérateurs de communication distribués dans un environnement de programmation fonctionnel fortement typé. Cette couche sert également de base pour le développement de l'apprentissage fédéré.
  • TFF permet aux développeurs d'exprimer des calculs fédérés de manière déclarative afin de pouvoir les déployer dans divers environnements d'exécution. TFF comprend un environnement d'exécution de simulation sur une seule machine destiné aux tests. Accédez aux tutoriels et exercez-vous.