Questa pagina è stata tradotta dall'API Cloud Translation.
Switch to English

TensorFlow Federated: machine learning su dati decentralizzati

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) è un framework open source per l'apprendimento automatico e altri calcoli su dati decentralizzati. TFF è stato sviluppato per facilitare la ricerca aperta e la sperimentazione con Federated Learning (FL) , un approccio all'apprendimento automatico in cui un modello globale condiviso viene addestrato tra molti clienti partecipanti che conservano i propri dati di formazione a livello locale. Ad esempio, FL è stato utilizzato per addestrare modelli di previsione per tastiere mobili senza caricare dati di digitazione sensibili sui server.

    TFF consente agli sviluppatori di simulare gli algoritmi di apprendimento federato inclusi sui loro modelli e dati, nonché di sperimentare nuovi algoritmi. Gli elementi costitutivi forniti da TFF possono essere utilizzati anche per implementare calcoli non di apprendimento, come analisi aggregate su dati decentralizzati. Le interfacce di TFF sono organizzate in due livelli:

  • Questo livello offre una serie di interfacce di alto livello che consentono agli sviluppatori di applicare le implementazioni incluse di formazione e valutazione federate ai modelli TensorFlow esistenti.
  • Al centro del sistema c'è un insieme di interfacce di livello inferiore per esprimere in modo conciso nuovi algoritmi federati combinando TensorFlow con operatori di comunicazione distribuita all'interno di un ambiente di programmazione funzionale fortemente tipizzato. Questo livello serve anche come base su cui abbiamo costruito l'apprendimento federato.
  • TFF consente agli sviluppatori di esprimere in modo dichiarativo calcoli federati, in modo che possano essere distribuiti in diversi ambienti di runtime. Incluso con TFF è un runtime di simulazione a macchina singola per esperimenti. Visita i tutorial e provalo tu stesso!