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 :
- executa cálculos
- usando lógica de programa
- com componentes específicos da plataforma
- e componentes independentes de plataforma
- dados parâmetros definidos pelo programa
- e parâmetros definidos pelo cliente
- quando o cliente executa o programa
- e poderá materializar dados no armazenamento da plataforma para:
- usar na lógica Python
- implementar tolerância a falhas
- e pode liberar dados para armazenamento do cliente
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:
- define parâmetros (por exemplo, sinalizadores)
- constrói componentes específicos de plataforma e componentes independentes de plataforma
- 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.tensorflow.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:
- parâmetros definidos pelo cliente e pelo programa
- componentes específicos da plataforma
- componentes independentes de plataforma
- cálculos
e executa algumas operações, que normalmente incluem:
- executando cálculos
- executando a lógica Python
- materializando dados no armazenamento da plataforma para:
- usar na lógica Python
- implementar tolerância a falhas
e pode produzir alguma saída, que normalmente inclui:
- liberando dados para armazenamento do cliente como métricas
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:
- possui armazenamento de clientes
- lança o programa
mas pode:
- autor do programa
- cumprir qualquer um dos recursos da plataforma
Plataforma
A plataforma normalmente:
- possui armazenamento de plataforma
- componentes específicos da plataforma dos autores
mas pode:
- autor do programa
- cumprir qualquer uma das capacidades da biblioteca
Biblioteca
Uma biblioteca normalmente:
- autores componentes independentes de plataforma
- cálculos dos autores
- lógica do programa dos autores
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 a falhas
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?