Zen

Source string Source string

331/10000 · 331

The string is read only.

English Actions
We now have the class ``FlowerClient`` which defines client-side training/evaluation and ``client_fn`` which allows Flower to create ``FlowerClient`` instances whenever it needs to call ``fit`` or ``evaluate`` on one particular client. The last step is to start the actual simulation using ``flwr.simulation.start_simulation``.
The function ``start_simulation`` accepts a number of arguments, amongst them the ``client_fn`` used to create ``FlowerClient`` instances, the number of clients to simulate (``num_clients``), the number of federated learning rounds (``num_rounds``), and the strategy. The strategy encapsulates the federated learning approach/algorithm, for example, *Federated Averaging* (FedAvg).
Flower has a number of built-in strategies, but we can also use our own strategy implementations to customize nearly all aspects of the federated learning approach. For this example, we use the built-in ``FedAvg`` implementation and customize it using a few basic parameters. The last step is the actual call to ``start_simulation`` which - you guessed it - starts the simulation:
Behind the scenes
So how does this work? How does Flower execute this simulation?
When we call ``start_simulation``, we tell Flower that there are 10 clients (``num_clients=10``). Flower then goes ahead an asks the ``FedAvg`` strategy to select clients. ``FedAvg`` knows that it should select 100% of the available clients (``fraction_fit=1.0``), so it goes ahead and selects 10 random clients (i.e., 100% of 10).
Flower then asks the selected 10 clients to train the model. When the server receives the model parameter updates from the clients, it hands those updates over to the strategy (*FedAvg*) for aggregation. The strategy aggregates those updates and returns the new global model, which then gets used in the next round of federated learning.
Where's the accuracy?
You may have noticed that all metrics except for ``losses_distributed`` are empty. Where did the ``{"accuracy": float(accuracy)}`` go?
Flower can automatically aggregate losses returned by individual clients, but it cannot do the same for metrics in the generic metrics dictionary (the one with the ``accuracy`` key). Metrics dictionaries can contain very different kinds of metrics and even key/value pairs that are not metrics at all, so the framework does not (and can not) know how to handle these automatically.
As users, we need to tell the framework how to handle/aggregate these custom metrics, and we do so by passing metric aggregation functions to the strategy. The strategy will then call these functions whenever it receives fit or evaluate metrics from clients. The two possible functions are ``fit_metrics_aggregation_fn`` and ``evaluate_metrics_aggregation_fn``.

Loading…

User avatar None

Source string added

  1. Flower Docs
  2. Framework
  3. English
When we call ``start_simulation``, we tell Flower that there are 10 clients (``num_clients=10``). Flower then goes ahead an asks the ``FedAvg`` strategy to select clients. ``FedAvg`` knows that it should select 100% of the available clients (``fraction_fit=1.0``), so it goes ahead and selects 10 random clients (i.e., 100% of 10).
10 months ago
Browse all string changes

Things to check

Multiple failing checks

Following checks are failing:
Python format: French, Chinese (Simplified)

Reset

Multiple unnamed variables

There are multiple unnamed variables in the string, making it impossible for translators to reorder them

Reset

Glossary

English English
No related strings found in the glossary.

String information

Flags
python-format, read-only
Source string location
../../source/tutorial-series-get-started-with-flower-pytorch.ipynb:612
String age
10 months ago
Last updated
13 days ago
Source string age
10 months ago
Translation file
string 3203