Programma federato

Questa documentazione è rivolta a chiunque sia interessato a una panoramica di alto livello dei concetti dei programmi federati. Si presuppone la conoscenza di TensorFlow Federated, in particolare del suo sistema di tipi.

Per ulteriori informazioni sul programma federato, vedere:

Cos'è un programma federato?

Un programma federato è un programma che esegue calcoli e altra logica di elaborazione in un ambiente federato.

Più precisamente un programma federato :

La definizione di questi concetti e astrazioni rende possibile descrivere le relazioni tra i componenti di un programma federato e consente a questi componenti di essere posseduti e creati da ruoli diversi. Questo disaccoppiamento consente agli sviluppatori di comporre programmi federati utilizzando componenti condivisi con altri programmi federati, in genere ciò significa eseguire la stessa logica di programma su molte piattaforme diverse.

La libreria di programmi federati di TFF ( tff.program ) definisce le astrazioni richieste per creare un programma federato e fornisce componenti indipendenti dalla piattaforma .

Componenti 

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

I componenti della libreria di programmi federati di TFF sono progettati in modo che possano essere posseduti e creati da ruoli diversi.

Programma

Il programma è un binario Python che:

  1. definisce i parametri (ad esempio i flag)
  2. costruisce componenti specifici della piattaforma e componenti indipendenti dalla piattaforma
  3. esegue calcoli utilizzando la logica del programma in un contesto federato

Per esempio:

# 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,
      )
  )

Parametri

I parametri sono gli input del programma , questi input possono essere impostati dal cliente , se sono esposti come flag, oppure possono essere impostati dal programma. Nell'esempio sopra, output_dir è un parametro impostato dal cliente e total_rounds e num_clients sono parametri impostati dal programma.

Componenti specifici della piattaforma

I componenti specifici della piattaforma sono i componenti forniti da una piattaforma che implementa le interfacce astratte definite dalla libreria di programmi federati di TFF.

Componenti indipendenti dalla piattaforma

I componenti indipendenti dalla piattaforma sono i componenti forniti da una libreria (ad esempio TFF) che implementa le interfacce astratte definite dalla libreria di programmi federati di TFF.

Calcoli

I calcoli sono implementazioni dell'interfaccia astratta tff.Computation .

Ad esempio, nella piattaforma TFF è possibile utilizzare i decoratori tff.tensorflow.computation o tff.federated_computation per creare un tff.framework.ConcreteComputation :

Per ulteriori informazioni, vedere la durata di un calcolo .

Logica del programma

La logica del programma è una funzione Python che accetta come input:

ed esegue alcune operazioni, che in genere includono:

e può produrre alcuni output, che in genere includono:

Per esempio:

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)

Ruoli

Esistono tre ruoli che è utile definire quando si parla di programmi federati: il cliente , la piattaforma e la libreria . Ciascuno di questi ruoli possiede ed è autore di alcuni dei componenti utilizzati per creare un programma federato. Tuttavia, è possibile che una singola entità o gruppo ricopra più ruoli.

Cliente

Il cliente tipicamente:

ma può:

Piattaforma

La piattaforma tipicamente:

ma può:

Biblioteca

Una biblioteca tipicamente:

Concetti 

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

È utile definire alcuni concetti quando si parla di programmi federati.

Archiviazione del cliente

L'archiviazione del cliente è l'archiviazione a cui il cliente ha accesso in lettura e scrittura e a cui la piattaforma ha accesso in scrittura.

Archiviazione della piattaforma

Lo storage della piattaforma è uno spazio di archiviazione a cui solo la piattaforma ha accesso in lettura e scrittura.

Pubblicazione

Il rilascio di un valore rende il valore disponibile per l'archiviazione del cliente (ad esempio pubblicando il valore su un dashboard, registrando il valore o scrivendo il valore su disco).

Materializzarsi

La materializzazione di un riferimento al valore rende disponibile al programma il valore a cui si fa riferimento. Spesso è necessario materializzare un riferimento al valore per rilasciare il valore o per rendere la logica del programma tollerante agli errori .

Tolleranza agli errori

La tolleranza agli errori è la capacità della logica del programma di riprendersi da un errore durante l'esecuzione di calcoli. Ad esempio, se ci si allena con successo nei primi 90 round su 100 e poi si verifica un fallimento, la logica del programma è in grado di riprendere l'allenamento dal round 91 o è necessario riavviare l'allenamento dal round 1?