Diese Seite wurde von der Cloud Translation API übersetzt.
Switch to English

TensorFlow Federated: Maschinelles Lernen mit dezentralen Daten

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) ist ein Open-Source-Framework für maschinelles Lernen und andere Berechnungen für dezentrale Daten. TFF wurde entwickelt, um offene Forschung und Experimente mit Federated Learning (FL) zu ermöglichen , einem Ansatz für maschinelles Lernen, bei dem ein gemeinsames globales Modell für viele teilnehmende Kunden trainiert wird, die ihre Trainingsdaten lokal aufbewahren. Beispielsweise wurde FL verwendet, um Vorhersagemodelle für mobile Tastaturen zu trainieren , ohne vertrauliche Tippdaten auf Server hochzuladen.

    Mit TFF können Entwickler die enthaltenen föderierten Lernalgorithmen für ihre Modelle und Daten simulieren und mit neuartigen Algorithmen experimentieren. Die von TFF bereitgestellten Bausteine ​​können auch zur Implementierung nicht lernender Berechnungen verwendet werden, z. B. aggregierte Analysen über dezentrale Daten. Die Schnittstellen von TFF sind in zwei Ebenen organisiert:

  • Diese Ebene bietet eine Reihe von Schnittstellen auf hoher Ebene, mit denen Entwickler die enthaltenen Implementierungen von Verbundschulungen und -evaluierungen auf ihre vorhandenen TensorFlow-Modelle anwenden können.
  • Das Kernstück des Systems besteht aus einer Reihe von Schnittstellen auf niedrigerer Ebene, mit denen neuartige Verbundalgorithmen präzise ausgedrückt werden können, indem TensorFlow mit verteilten Kommunikationsoperatoren in einer stark typisierten funktionalen Programmierumgebung kombiniert wird. Diese Ebene dient auch als Grundlage, auf der wir Federated Learning aufgebaut haben.
  • Mit TFF können Entwickler Verbundberechnungen deklarativ ausdrücken, sodass sie in verschiedenen Laufzeitumgebungen bereitgestellt werden können. In TFF ist eine Einzelmaschinen-Simulationslaufzeit für Experimente enthalten. Bitte besuchen Sie die Tutorials und probieren Sie es selbst aus!