Program federacyjny

Niniejsza dokumentacja jest przeznaczona dla każdego, kto jest zainteresowany ogólnym przeglądem koncepcji programów stowarzyszonych. Zakłada znajomość TensorFlow Federated, zwłaszcza jego systemu typów.

Aby uzyskać więcej informacji na temat programu stowarzyszonego, zobacz:

Co to jest program federacyjny?

Program stowarzyszony to program, który wykonuje obliczenia i inną logikę przetwarzania w środowisku stowarzyszonym.

Więcej, w szczególności program stowarzyszony :

Zdefiniowanie tych pojęć i abstrakcji umożliwia opisanie relacji między komponentami programu stowarzyszonego oraz pozwala, aby te komponenty były własnością różnych ról i były przez nie tworzone. To oddzielenie umożliwia programistom tworzenie programów stowarzyszonych przy użyciu komponentów współdzielonych z innymi programami stowarzyszonymi, co zazwyczaj oznacza wykonywanie tej samej logiki programu na wielu różnych platformach.

Biblioteka programów stowarzyszonych TFF ( tff.program ) definiuje abstrakcje wymagane do utworzenia programu stowarzyszonego i udostępnia komponenty niezależne od platformy .

Komponenty 

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

Komponenty stowarzyszonej biblioteki programów TFF zostały zaprojektowane w taki sposób, aby mogły być własnością różnych osób i być przez nie tworzone.

Program

Program jest plikiem binarnym Pythona, który:

  1. definiuje parametry (np. flagi)
  2. konstruuje komponenty specyficzne dla platformy i komponenty niezależne od platformy
  3. wykonuje obliczenia przy użyciu logiki programu w kontekście stowarzyszonym

Na przykład:

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

Parametry

Parametry są danymi wejściowymi programu , wejścia te mogą być ustawione przez klienta , jeśli są widoczne jako flagi, lub mogą być ustawione przez program. W powyższym przykładzie output_dir jest parametrem ustawianym przez klienta , a parametry total_rounds i num_clients są ustawiane przez program.

Komponenty specyficzne dla platformy

Komponenty specyficzne dla platformy to komponenty dostarczane przez platformę implementującą abstrakcyjne interfejsy zdefiniowane przez stowarzyszoną bibliotekę programów TFF.

Komponenty niezależne od platformy

Komponenty niezależne od platformy to komponenty dostarczane przez bibliotekę (np. TFF) implementującą abstrakcyjne interfejsy zdefiniowane przez bibliotekę programów stowarzyszonych TFF.

Obliczenia

Obliczenia są implementacjami abstrakcyjnego interfejsu tff.Computation .

Na przykład na platformie TFF można użyć dekoratorów tff.tensorflow.computation lub tff.federated_computation do utworzenia tff.framework.ConcreteComputation :

Aby uzyskać więcej informacji, zobacz żywotność obliczeń .

Logika programu

Logika programu jest funkcją Pythona, która jako dane wejściowe przyjmuje:

i wykonuje pewne operacje, które zazwyczaj obejmują:

i może dać pewien wynik, który zazwyczaj obejmuje:

Na przykład:

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)

Role

Podczas omawiania programów stowarzyszonych warto zdefiniować trzy role : klient , platforma i biblioteka . Każda z tych ról jest właścicielem i autorem niektórych komponentów używanych do tworzenia programu stowarzyszonego. Możliwe jest jednak, że pojedynczy podmiot lub grupa będzie pełnić wiele ról.

Klient

Klient zazwyczaj:

ale może:

Platforma

Platforma zazwyczaj:

ale może:

Biblioteka

Biblioteka zazwyczaj:

Koncepcje 

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

Istnieje kilka pojęć , które warto zdefiniować podczas omawiania programów stowarzyszonych.

Przechowywanie klientów

Pamięć klienta to pamięć, do której klient ma dostęp do odczytu i zapisu oraz do której platforma ma dostęp do zapisu.

Przechowywanie platformy

Pamięć platformy to pamięć, do której tylko platforma ma dostęp do odczytu i zapisu.

Uwolnienie

Zwolnienie wartości udostępnia ją w pamięci klienta (np. publikowanie wartości na pulpicie nawigacyjnym, rejestrowanie wartości lub zapisywanie wartości na dysku).

Zmaterializować

Materializacja odniesienia do wartości powoduje, że wartość, do której się odwołujemy, staje się dostępna dla programu . Często wymagana jest materializacja odniesienia do wartości, aby zwolnić wartość lub zapewnić odporność logiki programu na błędy.

Tolerancja błędów

Tolerancja błędów to zdolność logiki programu do regeneracji po awarii podczas wykonywania obliczeń. Na przykład, jeśli pomyślnie przetrenujesz pierwsze 90 rund na 100, a następnie doświadczysz niepowodzenia, czy logika programu jest w stanie wznowić trening od rundy 91, czy też trening należy rozpocząć od rundy 1?