tff.learning.algorithms.build_weighted_fed_prox  |  TensorFlow Federated (original) (raw)

Builds a learning process that performs the FedProx algorithm.

tff.learning.algorithms.build_weighted_fed_prox(
    model_fn: Union[Callable[[], tff.learning.models.VariableModel], tff.learning.models.FunctionalModel],
    proximal_strength: float,
    client_optimizer_fn: tff.learning.optimizers.Optimizer,
    server_optimizer_fn: tff.learning.optimizers.Optimizer = DEFAULT_SERVER_OPTIMIZER_FN,
    client_weighting: Optional[tff.learning.ClientWeighting] = tff.learning.ClientWeighting.NUM_EXAMPLES,
    model_distributor: Optional[tff.learning.templates.DistributionProcess] = None,
    model_aggregator: Optional[tff.aggregators.WeightedAggregationFactory] = None,
    metrics_aggregator: Optional[tff.learning.metrics.MetricsAggregatorType] = None,
    loop_implementation: tff.learning.LoopImplementation = tff.learning.LoopImplementation.DATASET_REDUCE
) -> tff.learning.templates.LearningProcess

This function creates a tff.learning.templates.LearningProcess that performs example-weighted FedProx on client models. This algorithm behaves the same as federated averaging, except that it uses a proximal regularization term that encourages clients to not drift too far from the server model.

The iterative process has the following methods inherited fromtff.learning.templates.LearningProcess:

• initialize: A tff.Computation with the functional type signature( -> S@SERVER), where S is atff.learning.templates.LearningAlgorithmState representing the initial state of the server.
• next: A tff.Computation with the functional type signature(<S@SERVER, {B*}@CLIENTS> -> <L@SERVER>) where S is atff.learning.templates.LearningAlgorithmState whose type matches the output of initializeand {B*}@CLIENTS represents the client datasets. The output L contains the updated server state, as well as aggregated metrics at the server, including client training metrics and any other metrics from distribution and aggregation processes.
• get_model_weights: A tff.Computation with type signature (S -> M), where S is a tff.learning.templates.LearningAlgorithmState whose type matches the output of initialize and next, and M represents the type of the model weights used during training.
• set_model_weights: A tff.Computation with type signature(<S, M> -> S), where S is atff.learning.templates.LearningAlgorithmState whose type matches the output of initialize and M represents the type of the model weights used during training.

Each time the next method is called, the server model is communicated to each client using the provided model_distributor. For each client, local training is performed using client_optimizer_fn. Each client computes the difference between the client model after training and the initial model. These model deltas are then aggregated at the server using a weighted aggregation function, according to client_weighting. The aggregate model delta is applied at the server using a server optimizer, as in the FedOpt framework proposed in Reddi et al., 2021.