Attend the Women in ML Symposium on December 7 Register now
Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

TensorFlow Federated: aprendizado de máquina em dados descentralizados

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)]

# 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,
      input_spec=train_data[0].element_spec,
      loss=tf.keras.losses.SparseCategoricalCrossentropy(),
      metrics=[tf.keras.metrics.SparseCategoricalAccuracy()])

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

    O TFF permite que os desenvolvedores simulem os algoritmos de aprendizado federado incluídos em seus modelos e dados, bem como experimentem novos algoritmos. Os pesquisadores encontrarão pontos de partida e exemplos completos para muitos tipos de pesquisa. Os blocos de construção fornecidos pelo TFF também podem ser usados ​​para implementar cálculos sem aprendizado, como análise federada . As interfaces do TFF são organizadas em duas camadas principais:

  • Essa camada oferece um conjunto de interfaces de alto nível que permitem que os desenvolvedores apliquem as implementações incluídas de treinamento e avaliação federados aos modelos existentes do TensorFlow.
  • No centro do sistema está um conjunto de interfaces de nível inferior para expressar de forma concisa novos algoritmos federados, combinando o TensorFlow com operadores de comunicação distribuídos em um ambiente de programação funcional fortemente tipado. Essa camada também serve como a base sobre a qual construímos o Federated Learning.
  • O TFF permite que os desenvolvedores expressem computações federadas de forma declarativa, para que possam ser implantados em diversos ambientes de tempo de execução. Incluído no TFF está um tempo de execução de simulação de várias máquinas de alto desempenho para experimentos. Por favor, visite os tutoriais e experimente você mesmo!

    Para perguntas e suporte, encontre-nos na tag federada tensorflow no StackOverflow.