Cette documentation s'adresse à toute personne intéressée par la création d'une logique de programme fédéré ou d'un programme fédéré . Cela suppose une connaissance de TensorFlow Federated, notamment de son système de types, et des programmes fédérés .
Logique du programme
Cette section définit les lignes directrices sur la façon dont la logique du programme doit être créée.
Voir l'exemple program_logic.py pour plus d'informations.
Signatures de types de documents
Documentez la signature de type TFF pour chaque paramètre fourni à la logique du programme qui a une signature de type.
async def program_logic(
train: tff.Computation,
data_source: tff.program.FederatedDataSource,
...
) -> None:
"""Trains a federated model for some number of rounds.
The following types signatures are required:
1. `train`: `(<S@SERVER, D@CLIENTS> -> <S@SERVER, M@SERVER>)`
2. `data_source`: `D@CLIENTS`
Where:
* `S`: The server state.
* `M`: The train metrics.
* `D`: The train client data.
"""
Vérifier les signatures de type
Vérifiez la signature de type TFF (au moment de l'exécution) pour chaque paramètre fourni à la logique du programme qui a une signature de type.
def _check_program_logic_type_signatures(
train: tff.Computation,
data_source: tff.program.FederatedDataSource,
...
) -> None:
...
async def program_logic(
train: tff.Computation,
data_source: tff.program.FederatedDataSource,
...
) -> None:
_check_program_logic_type_signatures(
train=train,
data_source=data_source,
)
...
Annotations de types
Fournissez un type Python bien défini pour chaque paramètre tff.program.ReleaseManager fourni à la logique du programme.
async def program_logic(
metrics_manager: Optional[
tff.program.ReleaseManager[tff.program.ReleasableStructure, int]
] = None,
...
) -> None:
...
Pas
async def program_logic(
metrics_manager,
...
) -> None:
...
async def program_logic(
metrics_manager: Optional[tff.program.ReleaseManager] = None,
...
) -> None:
...
État du programme
Fournissez une structure bien définie décrivant l’état du programme de la logique du programme.
class _ProgramState(NamedTuple):
state: object
round_num: int
async def program_loic(...) -> None:
initial_state = ...
# Load the program state
if program_state_manager is not None:
structure = _ProgramState(initial_state, round_num=0)
program_state, version = await program_state_manager.load_latest(structure)
else:
program_state = None
version = 0
# Assign state and round_num
if program_state is not None:
state = program_state.state
start_round = program_state.round_num + 1
else:
state = initial_state
start_round = 1
for round_num in range(start_round, ...):
state, _ = train(state, ...)
# Save the program state
program_state = _ProgramState(state, round_num)
version = version + 1
program_state_manager.save(program_state, version)
Valeurs validées du document
Documentez les valeurs libérées par la logique du programme.
async def program_logic(
metrics_manager: Optional[tff.program.ReleaseManager] = None,
...
) -> None:
"""Trains a federated model for some number of rounds.
Each round, `loss` is released to the `metrics_manager`.
"""
Valeurs spécifiques à la version
Ne libérez pas plus de valeurs de la logique du programme que nécessaire.
async def program_logic(...) -> None:
for round_number in range(...):
state, metrics = train(state, ...)
_, metrics_type = train.type_signature.result
loss = metrics['loss']
loss_type = metrics_type['loss']
metrics_manager.release(loss, loss_type, round_number)
Pas
async def program_loic(...) -> None:
for round_number in range(...):
state, metrics = train(state, ...)
_, metrics_type = train.type_signature.result
metrics_manager.release(metrics, metrics_type, round_number)
Fonctions asynchrones
Définissez la logique du programme comme une fonction asynchrone . Les composants de la bibliothèque de programmes fédérés de TFF utilisent asyncio pour exécuter Python simultanément et définir la logique du programme comme une fonction asynchrone facilite l'interaction avec ces composants.
async def program_logic(...) -> None:
...
Pas
def program_logic(...) -> None:
...
Essais
Fournissez des tests unitaires pour la logique du programme (par exemple program_logic_test.py ).
Programme
Cette section définit les lignes directrices sur la façon dont un programme doit être créé.
Voir l'exemple program.py pour plus d'informations.
Documenter le programme
Documentez les détails du programme au client dans la docstring du module (par exemple program.py ):
- Comment exécuter manuellement le programme.
- Quelle plate-forme, quels calculs et quelles sources de données sont utilisés dans le programme.
- Comment un client doit accéder aux informations publiées par le programme vers le stockage client.
Trop de paramètres
Ne paramétrez pas le programme de telle sorte qu'il existe des collections de paramètres mutuellement exclusives. Par exemple, si foo est défini sur X , vous devez également définir les paramètres bar , baz , sinon ces paramètres doivent être None . Cela indique que vous auriez pu créer deux programmes différents pour différentes valeurs de foo .
Paramètres du groupe
Utilisez proto pour définir des paramètres liés mais complexes ou détaillés au lieu de définir de nombreux FLAGS (go/absl.flags).
with tf.io.gfile.GFile(config_path) as f: proto = text_format.Parse(f.read(), vizier_pb2.StudyConfig()) return pyvizier.StudyConfig.from_proto(proto)
Logique Python
N'écrivez pas de logique (par exemple, flux de contrôle, appels de calculs, tout ce qui doit être testé) dans le programme. Au lieu de cela, déplacez la logique dans une bibliothèque privée qui peut être testée ou dans la logique du programme invoquée par le programme.
Fonctions asynchrones
N'écrivez pas de fonctions asynchrones dans le programme. Au lieu de cela, déplacez la fonction dans une bibliothèque privée qui peut être testée ou dans la logique du programme invoquée par le programme.
Essais
N'écrivez pas de tests unitaires pour le programme, si tester le programme est utile, écrivez ces tests en termes de tests d'intégration.