Flower Framework

https://flower.ai/docs/framework/
Admin
Flower is a friendly federated learning framework designed to help researchers and developers bring...
Tokens:372,261
Snippets:3,861
Trust Score:9.3
Update:1 month ago
Show doc for...
Tokens:
Raw
### Clone a Flower quickstart example

Source: https://flower.ai/docs/framework/_sources/docker/run-quickstart-examples-docker-compose.rst.txt

Downloads the specified quickstart example repository and prepares the directory.

```bash
$ git clone --depth=1 https://github.com/flwrlabs/flower.git \
     && mv flower/examples/quickstart-pytorch . \
     && rm -rf flower && cd quickstart-pytorch
```

--------------------------------

### Install Flower and Initialize Project

Source: https://flower.ai/docs/framework/_sources/tutorial-series-build-a-strategy-from-scratch-pytorch.rst.txt

Commands to install the Flower framework and generate a new project using the PyTorch quickstart template.

```shell
# Install Flower
$ pip install -U flwr
# Create a new Flower App using the PyTorch quickstart template
$ flwr new @flwrlabs/quickstart-pytorch
```

--------------------------------

### Migrate to ServerApp

Source: https://flower.ai/docs/framework/_sources/how-to-upgrade-to-flower-1.13.rst.txt

Example showing the setup for ServerApp to replace legacy start_server calls.

```python
from flwr.app import Context
from flwr.compat.server import ServerAppComponents
from flwr.server import ServerConfig, start_server
from flwr.server.strategy import FedAvg
from flwr.serverapp import ServerApp
```

--------------------------------

### Install dependencies and run the application

Source: https://flower.ai/docs/framework/how-to-run-flower-with-deployment-engine.html

Install the project dependencies and execute the application locally.

```bash
cd quickstart-pytorch && pip install -e .

flwr run .
```

--------------------------------

### Example execution flow registration

Source: https://flower.ai/docs/framework/_sources/how-to-use-built-in-mods.rst.txt

A setup demonstrating both application-wide and function-specific mod registration.

```python
app = fl.clientapp.ClientApp(mods=[example_mod_1, example_mod_2])


@app.train(mods=[example_mod_3, example_mod_4])
def train(msg, ctx):
    return Message(fl.app.RecordDict(), reply_to=msg)


@app.evaluate()
def evaluate(msg, ctx):
    return Message(fl.app.RecordDict(), reply_to=msg)
```

--------------------------------

### Start a NumPy client with various configurations

Source: https://flower.ai/docs/framework/_modules/flwr/compat/client/app.html

Examples demonstrating how to initiate a Flower NumPy client using insecure, system-certificate TLS, or custom-certificate TLS connections.

```python
start_numpy_client(
    server_address=localhost:8080,
    client=FlowerClient(),
)
```

```python
start_numpy_client(
    server_address=localhost:8080,
    client=FlowerClient(),
    insecure=False,
)
```

```python
from pathlib import Path

start_numpy_client(
    server_address=localhost:8080,
    client=FlowerClient(),
    root_certificates=Path("/crts/root.pem").read_bytes(),
)
```

--------------------------------

### start_simulation

Source: https://flower.ai/docs/framework/_modules/flwr/simulation.html

Starts a Ray-based Flower simulation server. This function requires the 'simulation' extra dependencies to be installed.

```APIDOC
## start_simulation(*args, **kwargs)

### Description
Starts a Ray-based Flower simulation server. This function checks for the presence of the 'ray' dependency before delegating to the legacy simulation application.

### Parameters
- **args** (Any) - Optional - Positional arguments passed to the simulation.
- **kwargs** (Any) - Optional - Keyword arguments passed to the simulation.

### Returns
- **Any** - The result of the simulation execution.
```

--------------------------------

### Install Flower and Start SuperNode

Source: https://flower.ai/docs/framework/_sources/how-to-connect-supernodes-to-supergrid.rst.txt

Install the Flower package and launch the SuperNode process pointing to the SuperGrid fleet address and the local private key.

```shell
$ pip install -U flwr
```

```shell
$ flower-supernode \
    --superlink fleet-supergrid.flower.ai:443 \
    --auth-supernode-private-key ~/supernodes_keys/supernode-1
```

--------------------------------

### Install Flower and Initialize Project

Source: https://flower.ai/docs/framework/_sources/how-to-migrate-from-openfl.rst.txt

Commands to install the Flower package and generate a new project structure.

```shell
# In a new Python environment
$ pip install -U "flwr[simulation]"
```

```shell
$ flwr new @flwrlabs/quickstart-pytorch
```

--------------------------------

### Install and Verify kubectl

Source: https://flower.ai/docs/framework/_sources/how-to-run-flower-on-gcp.rst.txt

Install the kubectl component and verify the installed version.

```bash
gcloud components install kubectl
kubectl version --client  # this will show the installed versions of the Client and Kustomize
```

--------------------------------

### Deprecated start_server usage example

Source: https://flower.ai/docs/framework/_modules/flwr/compat/server/app.html

Example of how start_server was previously used with certificates.

```python
start_server(
    certificates=(
        Path("/crts/root.pem").read_bytes(),
        Path("/crts/localhost.crt").read_bytes(),
        Path("/crts/localhost.key").read_bytes()
    )
)
```

--------------------------------

### Install and Create Flower App

Source: https://flower.ai/docs/framework/_sources/how-to-run-flower-on-azure.rst.txt

Commands to install the Flower framework and initialize a new project using the numpy template.

```bash
# Install flower
pip install -U flwr

# This creates a basic Flower App using the numpy framework
flwr new @flwrlabs/quickstart-numpy
```

--------------------------------

### Install and Initialize Google Cloud SDK

Source: https://flower.ai/docs/framework/_sources/how-to-run-flower-on-gcp.rst.txt

Commands to install the gcloud CLI on various operating systems and initialize the environment.

```bash
# macOS
curl https://sdk.cloud.google.com | bash  # and then follow on-screen prompts

# macOS (w/ Homebrew)
brew install --cask google-cloud-sdk

# Windows
# Download the Windows installer from the Google Cloud SDK page
# https://dl.google.com/dl/cloudsdk/channels/rapid/GoogleCloudSDKInstaller.exe
# Run the .exe installer and follow the on-screen instructions

# Once the package is installed (e.g., using brew), we initialize gcloud as follows:
gcloud init  # initialize with gcloud init.
gcloud version  # verify installation
```

--------------------------------

### Initialize and Start a Strategy

Source: https://flower.ai/docs/framework/_sources/how-to-use-strategies.rst.txt

Basic configuration and invocation of the strategy start method with training and evaluation parameters.

```python
# Define configs to send to ClientApp
train_cfg = ConfigRecord({"lr": 0.1, "optim": "adam"})
eval_cfg = ConfigRecord({"max-steps": 500, "local-checkpoint": True})

# Start strategy
result = strategy.start(
    grid=grid,
    initial_arrays=ArrayRecord(...),
    train_config=train_cfg,
    evaluate_config=eval_cfg,
    num_rounds=100,
)
```

--------------------------------

### Install Flower App Bundle

Source: https://flower.ai/docs/framework/ref-api-cli.html

Install a FAB file to the local Flower apps directory.

```bash
flwr install ./target_project.fab
```

```bash
flwr install [OPTIONS] [source]
```

--------------------------------

### Install local Flower source with uv

Source: https://flower.ai/docs/framework/_sources/contributor-how-to-install-development-versions.rst.txt

Install Flower in editable mode from a local directory.

```bash
uv add --editable "../../"
```

```bash
uv add --editable "../../" --extra simulation
```

--------------------------------

### Install Flower pre-releases with uv

Source: https://flower.ai/docs/framework/_sources/contributor-how-to-install-development-versions.rst.txt

Use uv to install specific pre-release versions of Flower from PyPI.

```bash
uv add --prerelease=allow "flwr==1.0.0a0"
```

```bash
uv add --prerelease=allow "flwr[simulation]==1.0.0a0"
```

--------------------------------

### Install local Flower wheel with uv

Source: https://flower.ai/docs/framework/_sources/contributor-how-to-install-development-versions.rst.txt

Install a specific Flower wheel file from a local path.

```bash
uv add "../../dist/flwr-1.8.0-py3-none-any.whl"
```

```bash
uv add "../../dist/flwr-1.8.0-py3-none-any.whl" --extra simulation
```

--------------------------------

### Migrate to ClientApp

Source: https://flower.ai/docs/framework/_sources/how-to-upgrade-to-flower-1.13.rst.txt

Example showing the transition from legacy start_client usage to the ClientApp pattern.

```python
from flwr.app import Context
from flwr.client import start_client
from flwr.clientapp import ClientApp


# Flower 1.10 and later (recommended)
def client_fn(context: Context):
    return FlowerClient().to_client()


app = ClientApp(client_fn=client_fn)


# # Flower 1.8 - 1.9 (deprecated, no longer supported)
# def client_fn(cid: str):
#     return FlowerClient().to_client()
#
#
# app = ClientApp(client_fn=client_fn)


# Flower 1.7 (deprecated, only for backwards-compatibility)
if __name__ == "__main__":
    start_client(
        server_address="127.0.0.1:8080",
        client=FlowerClient().to_client(),
    )
```

--------------------------------

### Example Output of Configuration List

Source: https://flower.ai/docs/framework/_sources/how-to-upgrade-to-flower-1.28.rst.txt

Sample output showing the path to the configuration file and available connections.

```shell
Flower Config file: /path/to/your/.flwr/config.toml
SuperLink connections:
  local (default)
  supergrid
```

--------------------------------

### Start SuperNode in Python

Source: https://flower.ai/docs/framework/how-to-connect-supernodes-to-supergrid.html

Launch the SuperNode process using the installed Flower CLI.

```bash
$ flower-supernode \
    --superlink fleet-supergrid.flower.ai:443 \
    --auth-supernode-private-key ~/supernodes_keys/supernode-1
```

--------------------------------

### Execute Setup Stage

Source: https://flower.ai/docs/framework/_modules/flwr/server/workflow/secure_aggregation/secaggplus_workflow.html

Configures fit instructions for clients and updates the workflow state with node proxies.

```python
    def setup_stage(  # pylint: disable=R0912, R0914, R0915
        self, grid: Grid, context: LegacyContext, state: WorkflowState
    ) -> bool:
        """Execute the 'setup' stage."""
        # Obtain fit instructions
        cfg = context.state.config_records[MAIN_CONFIGS_RECORD]
        current_round = cast(int, cfg[WorkflowKey.CURRENT_ROUND])
        parameters = compat.arrayrecord_to_parameters(
            context.state.array_records[MAIN_PARAMS_RECORD],
            keep_input=True,
        )
        proxy_fitins_lst = context.strategy.configure_fit(
            current_round, parameters, context.client_manager
        )
        if not proxy_fitins_lst:
            log(INFO, "configure_fit: no clients selected, cancel")
            return False
        log(
            INFO,
            "configure_fit: strategy sampled %s clients (out of %s)",
            len(proxy_fitins_lst),
            context.client_manager.num_available(),
        )

        state.nid_to_fitins = {
            proxy.node_id: compat.fitins_to_recorddict(fitins, True)
            for proxy, fitins in proxy_fitins_lst
        }
        state.nid_to_proxies = {proxy.node_id: proxy for proxy, _ in proxy_fitins_lst}
```

--------------------------------

### Flower ServerApp log output

Source: https://flower.ai/docs/framework/_sources/docker/tutorial-quickstart-docker-compose.rst.txt

Example log output showing the successful installation and execution of the Flower project.

```text
INFO :      Starting logstream for run_id `10386255862566726253`
INFO :      Starting Flower ServerApp
WARNING :   Option `--insecure` was set. Starting insecure HTTP channel to superlink:9091.
ðŸŽŠ Successfully installed quickstart-pytorch to /app/.flwr/apps/flower.quickstart-pytorch.1.0.0.35361a47.
Get weights
INFO :      Starting Flower ServerApp, config: num_rounds=3, no round_timeout
```

--------------------------------

### Initialize Flower project

Source: https://flower.ai/docs/framework/_sources/tutorial-quickstart-fastai.rst.txt

Create a new project structure using the fastai quickstart template.

```shell
$ flwr new @flwrlabs/quickstart-fastai
```

--------------------------------

### Run the Flower example

Source: https://flower.ai/docs/framework/_sources/docker/run-quickstart-examples-docker-compose.rst.txt

Executes the Flower application using the specified deployment configuration.

```bash
$ flwr run . local-deployment --stream
```

--------------------------------

### Audit Log Event Structure

Source: https://flower.ai/docs/framework/_sources/how-to-configure-audit-logging.rst.txt

Example of the JSON structure for audit logs, showing the started and completed states of a FleetServicer event.

```json
INFO :      [AUDIT] {"timestamp": "2025-07-14T10:27:02Z", "actor": {"actor_id": "...", "description": "SuperNode", "ip_address": "..."}, "event": {"action": "FleetServicer.PullMessages", "run_id": null, "fab_hash": null}, "status": "started"}
INFO :      [Fleet.PullMessages] node_id=...
INFO :      [AUDIT] {"timestamp": "2025-07-14T10:27:02Z", "actor": {"actor_id": "...", "description": "SuperNode", "ip_address": "..."}, "event": {"action": "FleetServicer.PullMessages", "run_id": null, "fab_hash": null}, "status": "completed"}
```

--------------------------------

### Start Flower Server

Source: https://flower.ai/docs/framework/_sources/tutorial-quickstart-ios.rst.txt

Initializes a basic Flower server with default configurations.

```python
import flwr as fl

fl.server.start_server(config=fl.server.ServerConfig(num_rounds=3))
```

--------------------------------

### Define a PyTorch TaskRunner in OpenFL

Source: https://flower.ai/docs/framework/_sources/how-to-migrate-from-openfl.rst.txt

An example of a PyTorchCNN class inheriting from PyTorchTaskRunner, including model initialization, optimizer setup, and forward pass definition.

```python
class PyTorchCNN(PyTorchTaskRunner):
    """
    Simple CNN for classification.

    PyTorchTaskRunner inherits from nn.Module, so you can define your model
    in the same way that you would for PyTorch
    """

    def __init__(self, device="cpu", **kwargs):
        """Initialize.

        Args:
            device: The hardware device to use for training (Default = "cpu")
            **kwargs: Additional arguments to pass to the function

        """
        super().__init__(device=device, **kwargs)

        # Define the model
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(3, 6, 5)
        self.pool = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(6, 16, 5)
        self.fc1 = nn.Linear(16 * 5 * 5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)
        self.to(device)

        # `self.optimizer` must be set for optimizer weights to be federated
        self.optimizer = optim.Adam(self.parameters(), lr=1e-4)

        # Set the loss function
        self.loss_fn = F.cross_entropy

    def forward(self, x):
        """
        Forward pass of the model.

        Args:
            x: Data input to the model for the forward pass
        """
        x = self.pool(F.relu(self.conv1(x)))
        x = self.pool(F.relu(self.conv2(x)))
        x = x.view(-1, 16 * 5 * 5)
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        return self.fc3(x)

    def train_(
        self, train_dataloader: Iterator[Tuple[np.ndarray, np.ndarray]]
    ) -> Metric:
        """TaskRunner train function"""
        ...

    def validate_(
        self, valid_dataloader: Iterator[Tuple[np.ndarray, np.ndarray]]
    ) -> Metric:
        """TaskRunner validation function"""
        ...
```

--------------------------------

### start_server

Source: https://flower.ai/docs/framework/_sources/ref-api/flwr.server.rst.txt

Starts a Flower server instance.

```APIDOC
## start_server

### Description
Starts the Flower server, allowing it to communicate with clients and coordinate the federated learning process.
```

--------------------------------

### Initialize Flower App Locally

Source: https://flower.ai/docs/framework/how-to-run-flower-apps-on-supergrid.html

Download a Flower application template and navigate into the project directory.

```bash
$ flwr new @flwrlabs/quickstart-numpy
$ cd quickstart-numpy
```

--------------------------------

### flwr install

Source: https://flower.ai/docs/framework/ref-api-cli.html

Install a Flower App Bundle.

```APIDOC
## flwr install

### Description
Install a Flower App Bundle (FAB).

### Usage
`flwr install [OPTIONS] [source]`

### Arguments
- **source** (string) - Optional - The source FAB file to install.
```

--------------------------------

### Initialize server defaults

Source: https://flower.ai/docs/framework/_modules/flwr/server/server.html

Creates a server instance and configuration if they are not provided, applying default strategies and managers.

```python
def init_defaults(
    server: Server | None,
    config: ServerConfig | None,
    strategy: Strategy | None,
    client_manager: ClientManager | None,
) -> tuple[Server, ServerConfig]:
    """Create server instance if none was given."""
    if server is None:
        if client_manager is None:
            client_manager = SimpleClientManager()
        if strategy is None:
            strategy = FedAvg()
        server = Server(client_manager=client_manager, strategy=strategy)
    elif strategy is not None:
        log(WARN, "Both server and strategy were provided, ignoring strategy")

    # Set default config values
    if config is None:
        config = ServerConfig()

    return server, config
```

--------------------------------

### Install Flower

Source: https://flower.ai/docs/framework/_sources/tutorial-quickstart-fastai.rst.txt

Install the Flower framework in a new Python environment.

```shell
# In a new Python environment
$ pip install flwr
```

--------------------------------

### View project structure

Source: https://flower.ai/docs/framework/_sources/tutorial-quickstart-fastai.rst.txt

The directory structure generated by the quickstart command.

```shell
quickstart-fastai
â”œâ”€â”€ fastai_example
â”‚   â”œâ”€â”€ client_app.py   # Defines your ClientApp
â”‚   â”œâ”€â”€ server_app.py   # Defines your ServerApp
â”‚   â””â”€â”€ task.py         # Defines your model, training and data loading
â”œâ”€â”€ pyproject.toml      # Project metadata like dependencies and configs
â””â”€â”€ README.md
```

--------------------------------

### Install updated dependencies

Source: https://flower.ai/docs/framework/_sources/how-to-upgrade-to-message-api.rst.txt

Command to install the application with updated dependencies.

```bash
# Install the app with updated dependencies
$ pip install -e .
```

--------------------------------

### Verify Flower installation

Source: https://flower.ai/docs/framework/_sources/how-to-install-flower.rst.txt

Command to check the installed version of Flower.

```bash
$ flwr --version
Flower version: |stable_flwr_version|
```

--------------------------------

### Install Dependencies

Source: https://flower.ai/docs/framework/_sources/how-to-configure-pyproject-toml.rst.txt

Command to install the dependencies defined in the pyproject.toml file.

```shell
pip install -e .
```

--------------------------------

### Start a NumPyClient

Source: https://flower.ai/docs/framework/_modules/flwr/compat/client/app.html

Initializes and starts a Flower NumPyClient that connects to a gRPC server.

```python
def start_numpy_client(
    *,
    server_address: str,
    client: NumPyClient,
    grpc_max_message_length: int = GRPC_MAX_MESSAGE_LENGTH,
    root_certificates: bytes | None = None,
    insecure: bool | None = None,
    transport: str | None = None,
) -> None:
    """Start a Flower NumPyClient which connects to a gRPC server.

```

--------------------------------

### Start Flower client components

Source: https://flower.ai/docs/framework/docker/tutorial-deploy-on-multiple-machines.html

Launch the client components on the local machine by setting the project directory and running Docker Compose.

```bash
# In the `docker/distributed` directory
$ export PROJECT_DIR=../../../../examples/quickstart-sklearn
$ docker compose -f client/compose.yml up --build -d
```

--------------------------------

### ClientApp.__init__

Source: https://flower.ai/docs/framework/ref-api/flwr.client.ClientApp.html

Initializes a new ClientApp instance.

```APIDOC
## ClientApp(client_fn=None, mods=None)

### Description
Initializes the Flower ClientApp with an optional client function and global modifiers.

### Parameters
- **client_fn** (Callable[[Context], Client]) - Optional - A function that returns a Client instance.
- **mods** (list[Callable]) - Optional - A list of global modifiers to apply to messages.
```

--------------------------------

### Strategy.start

Source: https://flower.ai/docs/framework/ref-api/flwr.server.strategy.Strategy.html

Initializes the strategy.

```APIDOC
## Strategy.start()

### Description
Initializes the strategy, returning results containing final model arrays and training/evaluation metrics.
```

--------------------------------

### Install system dependencies on macOS

Source: https://flower.ai/docs/framework/contributor-tutorial-get-started-as-a-contributor.html

Install required system packages using Homebrew.

```bash
$ brew install xz pandoc

```

--------------------------------

### Start log uploader thread

Source: https://flower.ai/docs/framework/_modules/flwr/supercore/logger.html

Initializes and starts a daemon thread for uploading logs.

```python
def start_log_uploader(
    log_queue: Queue[str | None],
    node_id: int,
    run_id: int,
    client: _RuntimeLogClient,
) -> threading.Thread:
    """Start the log uploader thread and return it."""
    thread = threading.Thread(
        target=_log_uploader, args=(log_queue, node_id, run_id, client), daemon=True
    )
    thread.start()
    return thread
```

--------------------------------

### start_client

Source: https://flower.ai/docs/framework/_sources/ref-api/flwr.client.rst.txt

Starts a Flower client that connects to a server.

```APIDOC
## start_client

### Description
Starts a Flower client that connects to a server and handles the federated learning process.

### Signature
`flwr.client.start_client(server_address: str, client: Client, ...)`
```

--------------------------------

### Bootstrap the development environment

Source: https://flower.ai/docs/framework/_sources/contributor-how-to-set-up-a-virtual-env.rst.txt

Initializes the virtual environment and installs dependencies from the lockfile.

```shell
./dev/bootstrap.sh
```

```shell
./dev/bootstrap.sh 3.11.14
```

--------------------------------

### Simulation Output Example

Source: https://flower.ai/docs/framework/_sources/tutorial-quickstart-pytorch-lightning.rst.txt

Example of the console output generated during a local simulation run.

```shell
Starting local SuperLink on 127.0.0.1:39093...
Successfully started run 1859953118041441032
INFO :      Starting FedAvg strategy:
INFO :          â”œâ”€â”€ Number of rounds: 3
INFO :      [ROUND 1/3]
INFO :      configure_train: Sampled 2 nodes (out of 2)
INFO :      aggregate_train: Received 2 results and 0 failures
INFO :          â””â”€â”€> Aggregated MetricRecord: {'train_loss': 0.0487}
INFO :      configure_evaluate: Sampled 2 nodes (out of 2)
INFO :      aggregate_evaluate: Received 2 results and 0 failures
INFO :          â””â”€â”€> Aggregated MetricRecord: {'eval_loss': 0.0495}
INFO :      [ROUND 2/3]
INFO :      ...
INFO :      [ROUND 3/3]
INFO :      ...
INFO :      Strategy execution finished in 159.24s
INFO :      Final results:
INFO :          ServerApp-side Evaluate Metrics:
INFO :          {}
```

--------------------------------

### Evaluate Return Type Example

Source: https://flower.ai/docs/framework/_modules/flwr/compat/client/numpy_client.html

Example of the expected return format for the evaluate method.

```python
0.5, 10, {"accuracy": 0.95}
```

--------------------------------

### Fit Return Type Example

Source: https://flower.ai/docs/framework/_modules/flwr/compat/client/numpy_client.html

Example of the expected return format for the fit method.

```python
model.get_weights(), 10, {"accuracy": 0.95}
```

--------------------------------

### Initialize ServerApp

Source: https://flower.ai/docs/framework/_sources/tutorial-quickstart-xgboost.rst.txt

Basic setup for the ServerApp instance in a Flower application.

```python
# Create ServerApp
app = ServerApp()
```

--------------------------------

### Create a new Flower App

Source: https://flower.ai/docs/framework/_sources/how-to-run-flower-with-deployment-engine.rst.txt

Initializes a new Flower project using the PyTorch quickstart template.

```bash
$ flwr new @flwrlabs/quickstart-pytorch

ðŸ”— Requesting download link for @flwrlabs/quickstart-pytorch...
ðŸ”½ Downloading ZIP into memory...
ðŸ“¦ Unpacking into /Users/alice/quickstart-pytorch...
ðŸŽŠ Flower App creation successful.

To run your Flower App, first install its dependencies:

        cd quickstart-pytorch && pip install -e .

then, run the app:

        flwr run .
```

--------------------------------

### Install system dependencies on Ubuntu

Source: https://flower.ai/docs/framework/contributor-tutorial-get-started-as-a-contributor.html

Install required build-essential and development libraries on Ubuntu 22.04+.

```bash
$ apt update
$ apt install build-essential zlib1g-dev libssl-dev libsqlite3-dev \
              libreadline-dev libbz2-dev libffi-dev liblzma-dev pandoc

```

--------------------------------

### Install project dependencies

Source: https://flower.ai/docs/framework/_sources/tutorial-series-get-started-with-flower-pytorch.rst.txt

Install the project in editable mode to resolve dependencies defined in pyproject.toml.

```shell
$ cd quickstart-pytorch
$ pip install -e .
```

--------------------------------

### Implement custom start method logic

Source: https://flower.ai/docs/framework/tutorial-build-a-strategy-from-scratch-pytorch.html

This snippet demonstrates the loop structure for managing training and evaluation rounds, including communication with clients and metric logging.

```python
        for current_round in range(1, num_rounds + 1):
            log(INFO, "")
            log(INFO, "[ROUND %s/%s]", current_round, num_rounds)

            # -----------------------------------------------------------------
            # --- TRAINING (CLIENTAPP-SIDE) -----------------------------------
            # -----------------------------------------------------------------

            # Call strategy to configure training round
            # Send messages and wait for replies
            train_replies = grid.send_and_receive(
                messages=self.configure_train(
                    current_round,
                    arrays,
                    train_config,
                    grid,
                ),
                timeout=timeout,
            )

            # Aggregate train
            agg_arrays, agg_train_metrics = self.aggregate_train(
                current_round,
                train_replies,
            )

            # Log training metrics and append to history
            if agg_arrays is not None:
                result.arrays = agg_arrays
                arrays = agg_arrays
            if agg_train_metrics is not None:
                log(INFO, "\t└──> Aggregated MetricRecord: %s", agg_train_metrics)
                result.train_metrics_clientapp[current_round] = agg_train_metrics
                # Log to W&B
                wandb.log(dict(agg_train_metrics), step=current_round)

            # -----------------------------------------------------------------
            # --- EVALUATION (CLIENTAPP-SIDE) ---------------------------------
            # -----------------------------------------------------------------

            # Call strategy to configure evaluation round
            # Send messages and wait for replies
            evaluate_replies = grid.send_and_receive(
                messages=self.configure_evaluate(
                    current_round,
                    arrays,
                    evaluate_config,
                    grid,
                ),
                timeout=timeout,
            )

            # Aggregate evaluate
            agg_evaluate_metrics = self.aggregate_evaluate(
                current_round,
                evaluate_replies,
            )

            # Log training metrics and append to history
            if agg_evaluate_metrics is not None:
                log(INFO, "\t└──> Aggregated MetricRecord: %s", agg_evaluate_metrics)
                result.evaluate_metrics_clientapp[current_round] = agg_evaluate_metrics
                # Log to W&B
                wandb.log(dict(agg_evaluate_metrics), step=current_round)
            # -----------------------------------------------------------------
            # --- EVALUATION (SERVERAPP-SIDE) ---------------------------------
            # -----------------------------------------------------------------

            # Centralized evaluation
            if evaluate_fn:
                log(INFO, "Global evaluation")
                res = evaluate_fn(current_round, arrays)
                log(INFO, "\t└──> MetricRecord: %s", res)
                if res is not None:
                    result.evaluate_metrics_serverapp[current_round] = res
                    # Maybe save to disk if new best is found
                    self._update_best_acc(current_round, res["accuracy"], arrays)
                    # Log to W&B
                    wandb.log(dict(res), step=current_round)

        log(INFO, "")
        log(INFO, "Strategy execution finished in %.2fs", time.time() - t_start)
        log(INFO, "")
        log(INFO, "Final results:")
        log(INFO, "")
        for line in io.StringIO(str(result)):
            log(INFO, "\t%s", line.strip("\n"))
        log(INFO, "")

        return result
```

--------------------------------

### Install Flower dependencies

Source: https://flower.ai/docs/framework/_sources/tutorial-series-get-started-with-flower-pytorch.rst.txt

Install the Flower package with simulation support in a new Python environment.

```shell
# In a new Python environment
$ pip install -U "flwr[simulation]"
```

--------------------------------

### Example Execution Output

Source: https://flower.ai/docs/framework/_sources/tutorial-quickstart-xgboost.rst.txt

Sample output showing the FedXgbBagging strategy execution progress.

```shell
Starting local SuperLink on 127.0.0.1:39093...
Successfully started run 1859953118041441032
INFO :      Starting FedXgbBagging strategy:
INFO :              â”œâ”€â”€ Number of rounds: 3
INFO :      [ROUND 1/3]
INFO :      configure_train: Sampled 2 nodes (out of 2)
INFO :      aggregate_train: Received 2 results and 0 failures
INFO :              â””â”€â”€> Aggregated MetricRecord: {}
INFO :      configure_evaluate: Sampled 2 nodes (out of 2)
INFO :      aggregate_evaluate: Received 2 results and 0 failures
INFO :              â””â”€â”€> Aggregated MetricRecord: {'auc': 0.7677505289821278}
INFO :      [ROUND 2/3]
INFO :      ...
INFO :      [ROUND 3/3]
INFO :      ...
INFO :      Strategy execution finished in 132.88s
INFO :      Final results:
INFO :              ServerApp-side Evaluate Metrics:
INFO :              {}
```

--------------------------------

### Install Flower CLI

Source: https://flower.ai/docs/framework/_sources/how-to-run-flower-apps-on-supergrid.rst.txt

Install the Flower framework using pip to enable CLI commands.

```shell
$ pip install -U flwr
```

--------------------------------

### Example output

Source: https://flower.ai/docs/framework/_sources/tutorial-quickstart-scikitlearn.rst.txt

Sample output observed when running the project with default arguments.

```shell
Starting local SuperLink on 127.0.0.1:39093...
Successfully started run 1859953118041441032
INFO :      Starting FedAvg strategy:
INFO :          â”œâ”€â”€ Number of rounds: 3
INFO :      [ROUND 1/3]
INFO :      configure_train: Sampled 2 nodes (out of 2)
INFO :      aggregate_train: Received 2 results and 0 failures
INFO :          â””â”€â”€> Aggregated MetricRecord: {'train_logloss': 1.3937176081476854}
INFO :      configure_evaluate: Sampled 2 nodes (out of 2)
INFO :      aggregate_evaluate: Received 2 results and 0 failures
INFO :          â””â”€â”€> Aggregated MetricRecord: {'test_logloss': 1.23306, 'accuracy': 0.69154, 'precision': 0.68659, 'recall': 0.68046, 'f1': 0.65752}
INFO :      [ROUND 2/3]
INFO :      ...
INFO :      [ROUND 3/3]
INFO :      ...
INFO :      Strategy execution finished in 17.87s
INFO :      Final results:
INFO :          ServerApp-side Evaluate Metrics:
INFO :          {}
```

--------------------------------

### Create a new Flower project

Source: https://flower.ai/docs/framework/_sources/docker/tutorial-quickstart-docker.rst.txt

Initialize a new project using the Flower CLI and install dependencies.

```console
$ flwr new @flwrlabs/quickstart-pytorch

ðŸ”— Requesting download link for @flwrlabs/quickstart-pytorch...
ðŸ”½ Downloading ZIP into memory...
ðŸ“¦ Unpacking into /Users/alice/quickstart-pytorch...
ðŸŽŠ Flower App creation successful.

To run your Flower App, first install its dependencies:

        cd quickstart-pytorch && pip install -e .

then, run the app:

        flwr run .

ðŸ’¡ Check the README in your app directory to learn how to
customize it and how to run it using the Deployment Runtime.

$ cd quickstart-pytorch
```

--------------------------------

### Install Flower via conda or mamba

Source: https://flower.ai/docs/framework/_sources/how-to-install-flower.rst.txt

Commands to install Flower once the conda-forge channel is configured.

```bash
conda install flwr
```

```bash
mamba install flwr
```
Tokens:
Raw