Programa Federado

Esta documentação é para qualquer pessoa interessada em uma visão geral de alto nível dos conceitos de programas federados. Ele pressupõe conhecimento do TensorFlow Federated, especialmente de seu sistema de tipos.

Para obter mais informações sobre o programa federado, consulte:

O que é um programa federado?

Um programa federado é um programa que executa cálculos e outras lógicas de processamento em um ambiente federado.

Mais, especificamente um programa federado :

A definição desses conceitos e abstrações possibilita descrever os relacionamentos entre os componentes de um programa federado e permite que esses componentes sejam de propriedade e criados por diferentes funções . Essa dissociação permite que os desenvolvedores componham programas federados usando componentes que são compartilhados com outros programas federados, normalmente isso significa executar a mesma lógica de programa em muitas plataformas diferentes.

A biblioteca de programas federados da TFF ( tff.program ) define as abstrações necessárias para criar um programa federado e fornece componentes independentes de plataforma .

Componentes

<!--#include file="components.dot"-->

Os componentes da biblioteca de programas federados da TFF são projetados para que possam pertencer e ser criados por diferentes funções .

Programa

O programa é um binário Python que:

  1. define parâmetros (por exemplo, sinalizadores)
  2. constrói componentes específicos de plataforma e componentes independentes de plataforma
  3. executa cálculos usando lógica de programa em um contexto federado

Por exemplo:

# Parameters set by the customer.
flags.DEFINE_string('output_dir', None, 'The output path.')

def main() -> None:

  # Parameters set by the program.
  total_rounds = 10
  num_clients = 3

  # Construct the platform-specific components.
  context = tff.program.NativeFederatedContext(...)
  data_source = tff.program.DatasetDataSource(...)

  # Construct the platform-agnostic components.
  summary_dir = os.path.join(FLAGS.output_dir, 'summary')
  metrics_manager = tff.program.GroupingReleaseManager([
      tff.program.LoggingReleaseManager(),
      tff.program.TensorBoardReleaseManager(summary_dir),
  ])
  program_state_dir = os.path.join(..., 'program_state')
  program_state_manager = tff.program.FileProgramStateManager(program_state_dir)

  # Define the computations.
  initialize = ...
  train = ...

  # Execute the computations using program logic.
  tff.framework.set_default_context(context)
  asyncio.run(
      train_federated_model(
          initialize=initialize,
          train=train,
          data_source=data_source,
          total_rounds=total_rounds,
          num_clients=num_clients,
          metrics_manager=metrics_manager,
          program_state_manager=program_state_manager,
      )
  )

Parâmetros

Os parâmetros são as entradas do programa , essas entradas podem ser definidas pelo cliente , se forem expostas como flags, ou podem ser definidas pelo programa. No exemplo acima, output_dir é um parâmetro definido pelo cliente e total_rounds e num_clients são parâmetros definidos pelo programa.

Componentes específicos da plataforma

Os componentes específicos da plataforma são os componentes fornecidos por uma plataforma que implementa as interfaces abstratas definidas pela biblioteca de programas federados da TFF.

Componentes independentes de plataforma

Os componentes independentes de plataforma são os componentes fornecidos por uma biblioteca (por exemplo, TFF) que implementa as interfaces abstratas definidas pela biblioteca de programas federados da TFF.

Computações

Os cálculos são implementações da interface abstrata tff.Computation .

Por exemplo, na plataforma TFF você pode usar os decoradores tff.tf_computation ou tff.federated_computation para criar um tff.framework.ConcreteComputation :

Consulte a vida de um cálculo para obter mais informações.

Lógica do Programa

A lógica do programa é uma função Python que recebe como entrada:

e executa algumas operações, que normalmente incluem:

e pode produzir alguma saída, que normalmente inclui:

Por exemplo:

async def program_logic(
    initialize: tff.Computation,
    train: tff.Computation,
    data_source: tff.program.FederatedDataSource,
    total_rounds: int,
    num_clients: int,
    metrics_manager: tff.program.ReleaseManager[
        tff.program.ReleasableStructure, int
    ],
) -> None:
  state = initialize()
  start_round = 1

  data_iterator = data_source.iterator()
  for round_number in range(1, total_rounds + 1):
    train_data = data_iterator.select(num_clients)
    state, metrics = train(state, train_data)

    _, metrics_type = train.type_signature.result
    metrics_manager.release(metrics, metrics_type, round_number)

Funções

Há três funções que são úteis para definir ao discutir programas federados: o cliente , a plataforma e a biblioteca . Cada uma dessas funções possui e é autora de alguns dos componentes usados ​​para criar um programa federado. No entanto, é possível que uma única entidade ou grupo desempenhe múltiplas funções.

Cliente

O cliente normalmente:

mas pode:

Plataforma

A plataforma normalmente:

mas pode:

Biblioteca

Uma biblioteca normalmente:

Conceitos

<!--#include file="concepts.dot"-->

Existem alguns conceitos que são úteis para definir ao discutir programas federados.

Armazenamento do cliente

O armazenamento do cliente é o armazenamento ao qual o cliente tem acesso de leitura e gravação e ao qual a plataforma tem acesso de gravação.

Armazenamento de plataforma

O armazenamento da plataforma é o armazenamento ao qual apenas a plataforma tem acesso de leitura e gravação.

Liberar

A liberação de um valor disponibiliza o valor para armazenamento do cliente (por exemplo, publicação do valor em um painel, registro do valor ou gravação do valor em disco).

Materializar

A materialização de uma referência de valor disponibiliza o valor referenciado para o programa . Muitas vezes é necessário materializar uma referência de valor para liberar o valor ou tornar a lógica do programa tolerante a falhas .

Tolerância ao erro

Tolerância a falhas é a capacidade da lógica do programa de se recuperar de uma falha ao executar cálculos. Por exemplo, se você treinar com sucesso as primeiras 90 rodadas de 100 e depois sofrer uma falha, a lógica do programa é capaz de retomar o treinamento a partir da rodada 91 ou o treinamento precisa ser reiniciado na rodada 1?