Questa documentazione è rivolta a chiunque sia interessato a creare la logica di un programma federato o un programma federato . Si presuppone la conoscenza di TensorFlow Federated, in particolare del suo sistema di tipi e dei programmi federati .
Logica del programma
Questa sezione definisce le linee guida su come deve essere creata la logica del programma .
Vedi l'esempio program_logic.py per maggiori informazioni.
Firme del tipo di documento
Documentare la firma del tipo TFF per ogni parametro fornito alla logica del programma che dispone di una firma del tipo.
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.
"""
Controlla le firme dei tipi
Controllare la firma del tipo TFF (in fase di esecuzione) per ogni parametro fornito alla logica del programma che dispone di una firma del tipo.
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,
)
...
Digitare Annotazioni
Fornire un tipo Python ben definito per ciascun parametro tff.program.ReleaseManager fornito alla logica del programma.
async def program_logic(
metrics_manager: Optional[
tff.program.ReleaseManager[tff.program.ReleasableStructure, int]
] = None,
...
) -> None:
...
Non
async def program_logic(
metrics_manager,
...
) -> None:
...
async def program_logic(
metrics_manager: Optional[tff.program.ReleaseManager] = None,
...
) -> None:
...
Stato del programma
Fornire una struttura ben definita che descriva lo stato della logica del programma.
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)
Valori rilasciati del documento
Documentare i valori rilasciati dalla logica del programma.
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`.
"""
Rilascia valori specifici
Non rilasciare più valori dalla logica del programma di quanto richiesto.
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)
Non
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)
Funzioni asincrone
Definire la logica del programma come una funzione asincrona . I componenti della libreria di programmi federati di TFF utilizzano asyncio per eseguire Python contemporaneamente e definire la logica del programma come funzione asincrona semplifica l'interazione con tali componenti.
async def program_logic(...) -> None:
...
Non
def program_logic(...) -> None:
...
Test
Fornire test unitari per la logica del programma (ad esempio program_logic_test.py ).
Programma
Questa sezione definisce le linee guida su come dovrebbe essere creato un programma .
Vedi l'esempio program.py per maggiori informazioni.
Documentare il programma
Documenta i dettagli del programma al cliente nella docstring del modulo (ad esempio program.py ):
- Come eseguire manualmente il programma.
- Quale piattaforma, calcoli e origini dati vengono utilizzati nel programma.
- Come un cliente dovrebbe accedere alle informazioni rilasciate dal programma nell'archivio del cliente.
Troppi parametri
Non parametrizzare il programma in modo tale che siano presenti raccolte di parametri che si escludono a vicenda. Ad esempio, se foo è impostato su X allora dovrai impostare anche i parametri bar , baz , altrimenti questi parametri devono essere None . Ciò indica che avresti potuto creare due programmi diversi per valori diversi di foo .
Parametri del gruppo
Utilizzare proto per definire parametri correlati ma complessi o dettagliati invece di definire molti FLAG (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)
Logica Python
Non scrivere la logica (ad esempio il flusso di controllo, l'esecuzione di calcoli, tutto ciò che deve essere testato) nel programma. Spostare invece la logica in una libreria privata che può essere testata o nella logica del programma richiamata dal programma.
Funzioni asincrone
Non scrivere funzioni asincrone nel programma. Spostare invece la funzione in una libreria privata che può essere testata o nella logica del programma richiamata dal programma.
Test
Non scrivere unit test per il programma, se testare il programma è utile scrivere quei test in termini di test di integrazione.