flwr 1.24.0__py3-none-any.whl → 1.26.0__py3-none-any.whl

flwr/cli/new/templates/app/README.baseline.md.tpl

@@ -1,127 +0,0 @@
----
-title: title of the paper # TODO
-url: https://arxiv.org/abs/2007.14390 # TODO: update with the link to your paper
-labels: [label1, label2] # TODO: please add between 4 and 10 single-word (maybe two-words) labels (e.g. system heterogeneity, image classification, asynchronous, weight sharing, cross-silo). Do not use "". Remove this comment once you are done.
-dataset: [dataset1, dataset2] # TODO: list of datasets you include in your baseline. Do not use "". Remove this comment once you are done.
----
-
-> [!IMPORTANT]
-> This is the template for your `README.md`. Please fill-in the information in all areas with a :warning: symbol.
-> Please refer to the [Flower Baselines contribution](https://flower.ai/docs/baselines/how-to-contribute-baselines.html) and [Flower Baselines usage](https://flower.ai/docs/baselines/how-to-use-baselines.html) guides for more details.
-> Please complete the metadata section at the very top of this README. This generates a table at the top of the file that will facilitate indexing baselines.
-> Please remove this [!IMPORTANT] block once you are done with your `README.md` as well as all the `:warning:` symbols and the comments next to them.
-
-> [!IMPORTANT]
-> To help having all baselines similarly formatted and structured, we have included two scripts in `baselines/dev` that when run will format your code and run some tests checking if it's formatted.
-> These checks use standard packages such as `isort`, `black`, `pylint` and others. You as a baseline creator will need to install additional packages. These are already specified in the `pyproject.toml` of
-> your baseline. Follow these steps:
-
-```bash
-# Create a python env
-pyenv virtualenv 3.10.14 $project_name
-
-# Activate it
-pyenv activate $project_name
-
-# Install project including developer packages
-# Note the `-e` this means you install it in editable mode 
-# so even if you change the code you don't need to do `pip install`
-# again. However, if you add a new dependency to `pyproject.toml` you
-# will need to re-run the command below
-pip install -e ".[dev]"
-
-# Even without modifying or adding new code, you can run your baseline
-# with the placeholder code generated when you did `flwr new`. If you
-# want to test this to familiarise yourself with how flower apps are
-# executed, execute this from the directory where you `pyproject.toml` is:
-flwr run .
-
-# At anypoint during the process of creating your baseline you can 
-# run the formatting script. For this do:
-cd .. # so you are in the `flower/baselines` directory
-
-# Run the formatting script (it will auto-correct issues if possible)
-./dev/format-baseline.sh $project_name
-
-# Then, if the above is all good, run the tests.
-./dev/test-baseline.sh $project_name
-```
-
-> [!IMPORTANT]
-> When you open a PR to get the baseline merged into the main Flower repository, the `./dev/test-baseline.sh` script will run. Only if test pass, the baseline can be merged. 
-> Some issues highlighted by the tests script are easier than others to fix. Do not hesitate in reaching out for help to us (e.g. as a comment in your PR) if you are stuck with these.
-> Before opening your PR, please remove the code snippet above as well all the [!IMPORTANT] message blocks. Yes, including this one.
-
-# :warning: *_Title of your baseline_* # Also copy this title to the `description` in the `[project]` section of your `pyproject.toml`.
-
-> [!NOTE] 
-> If you use this baseline in your work, please remember to cite the original authors of the paper as well as the Flower paper.
-
-**Paper:** :warning: *_add the URL of the paper page (not to the .pdf). For instance if you link a paper on ArXiv, add here the URL to the abstract page (e.g. [paper](https://arxiv.org/abs/1512.03385)). If your paper is in from a journal or conference proceedings, please follow the same logic._*
-
-**Authors:** :warning: *_list authors of the paper_*
-
-**Abstract:** :warning: *_add here the abstract of the paper you are implementing_*
-
-
-## About this baseline
-
-**What’s implemented:** :warning: *_Concisely describe what experiment(s) (e.g. Figure 1, Table 2, etc.) in the publication can be replicated by running the code. Please only use a few sentences. ”_*
-
-**Datasets:** :warning: *_List the datasets you used (if you used a medium to large dataset, >10GB please also include the sizes of the dataset). We highly recommend using [FlowerDatasets](https://flower.ai/docs/datasets/index.html) to download and partition your dataset. If you have other ways to download the data, you can also use `FlowerDatasets` to partition it._*
-
-**Hardware Setup:** :warning: *_Give some details about the hardware (e.g. a server with 8x V100 32GB and 256GB of RAM) you used to run the experiments for this baseline. Indicate how long it took to run the experiments. Someone out there might not have access to the same resources you have so, could you list the absolute minimum hardware needed to run the experiment in a reasonable amount of time ? (e.g. minimum is 1x 16GB GPU otherwise a client model can’t be trained with a sufficiently large batch size). Could you test this works too?_*
-
-**Contributors:** :warning: *_let the world know who contributed to this baseline. This could be either your name, your name and affiliation at the time, or your GitHub profile name if you prefer. If multiple contributors signed up for this baseline, please list yourself and your colleagues_*
-
-
-## Experimental Setup
-
-**Task:** :warning: *_what’s the primary task that is being federated? (e.g. image classification, next-word prediction). If you have experiments for several, please list them_*
-
-**Model:** :warning: *_provide details about the model you used in your experiments (if more than use a list). If your model is small, describing it as a table would be :100:. Some FL methods do not use an off-the-shelve model (e.g. ResNet18) instead they create your own. If this is your case, please provide a summary here and give pointers to where in the paper (e.g. Appendix B.4) is detailed._*
-
-**Dataset:** :warning: *_Earlier you listed already the datasets that your baseline uses. Now you should include a breakdown of the details about each of them. Please include information about: how the dataset is partitioned (e.g. LDA with alpha 0.1 as default and all clients have the same number of training examples; or each client gets assigned a different number of samples following a power-law distribution with each client only instances of 2 classes)? if  your dataset is naturally partitioned just state “naturally partitioned”; how many partitions there are (i.e. how many clients)? Please include this an all information relevant about the dataset and its partitioning into a table._*
-
-**Training Hyperparameters:** :warning: *_Include a table with all the main hyperparameters in your baseline. Please show them with their default value._*
-
-
-## Environment Setup
-
-:warning: _Specify the steps to create and activate your environment and install the baseline project. Most baselines are expected to require minimal steps as shown below. These instructions should be comprehensive enough so anyone can run them (if non standard, describe them step-by-step)._
-
-:warning: _The dependencies for your baseline are listed in the `pyproject.toml`, extend it with additional packages needed for your baseline._
-
-:warning: _Baselines should use Python 3.10, [pyenv](https://github.com/pyenv/pyenv), and the [virtualenv](https://github.com/pyenv/pyenv-virtualenv) plugging. 
-
-```bash
-# Create the virtual environment
-pyenv virtualenv 3.10.14 <name-of-your-baseline-env>
-
-# Activate it
-pyenv activate <name-of-your-baseline-env>
-
-# Install the baseline
-pip install -e .
-```
-
-:warning: _If your baseline requires running some script before starting an experiment, please indicate so here_.
-
-## Running the Experiments
-
-:warning: _Make sure you have adjusted the `client-resources` in the federation in `pyproject.toml` so your simulation makes the best use of the system resources available._
-
-:warning: _Your baseline implementation should replicate several of the experiments in the original paper. Please include here the exact command(s) needed to run each of those experiments followed by a figure (e.g. a line plot) or table showing the results you obtained when you ran the code. Below is an example of how you can present this. Please add command followed by results for all your experiments._
-
-:warning: _You might want to add more hyperparameters and settings for your baseline. You can do so by extending `[tool.flwr.app.config]` in `pyproject.toml`. In addition, you can create a new `.toml` file that can be passed with the `--run-config` command (see below an example) to override several config values **already present** in `pyproject.toml`._
-```bash
-# it is likely that for one experiment you need to override some arguments.
-flwr run . --run-config learning-rate=0.1,coefficient=0.123
-
-# or you might want to load different `.toml` configs all together:
-flwr run . --run-config <my-big-experiment-config>.toml
-```
-
-:warning: _It is preferable to show a single command (or multiple commands if they belong to the same experiment) and then a table/plot with the expected results, instead of showing all the commands first and then all the results/plots._
-:warning: _If you present plots or other figures, please include either a Jupyter notebook showing how to create them or include a utility function that can be called after the experiments finish running._
-:warning: If you include plots or figures, save them in `.png` format and place them in a new directory named `_static` at the same level as your `README.md`.

flwr/cli/new/templates/app/README.flowertune.md.tpl

@@ -1,68 +0,0 @@
-# FlowerTune LLM on $challenge_name Dataset
-
-This directory conducts federated instruction tuning with a pretrained [Mistral-7B](https://huggingface.co/mistralai/Mistral-7B-v0.3) model on a [$challenge_name dataset](https://huggingface.co/datasets/$dataset_name).
-We use [Flower Datasets](https://flower.dev/docs/datasets/) to download, partition and preprocess the dataset.
-Flower's Simulation Engine is used to simulate the LLM fine-tuning process in federated way,
-which allows users to perform the training on a single GPU.
-
-
-## Methodology
-
-This baseline performs federated LLM fine-tuning with [LoRA](https://arxiv.org/pdf/2106.09685) using the [🤗PEFT](https://huggingface.co/docs/peft/en/index) library.
-The clients' models are aggregated with FedAvg strategy.
-This provides a baseline performance for the leaderboard of $challenge_name challenge.
-
-
-## Environments setup
-
-Project dependencies are defined in `pyproject.toml`. Install them in an activated Python environment with:
-
-```shell
-pip install -e .
-```
-
-> **Tip:** Learn how to configure your `pyproject.toml` file for Flower apps in [this guide](https://flower.ai/docs/framework/how-to-configure-pyproject-toml.html).
-
-## Experimental setup
-
-The dataset is divided into $num_clients partitions in an IID fashion, a partition is assigned to each ClientApp.
-We randomly sample a fraction ($fraction_train) of the total nodes to participate in each round, for a total of `200` rounds.
-All settings are defined in `pyproject.toml`.
-
-> [!IMPORTANT]
-> Please note that `[tool.flwr.app.config.static]` and `options.num-supernodes` under `[tool.flwr.federations.local-simulation]` are not allowed to be modified for fair competition if you plan to participated in the [LLM leaderboard](https://flower.ai/benchmarks/llm-leaderboard).
-
-
-## Running the challenge
-
-First make sure that you have got the access to [Mistral-7B](https://huggingface.co/mistralai/Mistral-7B-v0.3) model with your Hugging-Face account. You can request access directly from the Hugging-Face website.
-Then, follow the instruction [here](https://huggingface.co/docs/huggingface_hub/en/quick-start#login-command) to log in your account. Note you only need to complete this stage once in your development machine:
-
-```bash
-huggingface-cli login
-```
-
-Run the challenge with default config values.
-The configs are defined in `[tool.flwr.app.config]` entry of `pyproject.toml`, and are loaded automatically.
-
-```bash
-flwr run
-```
-
-## VRAM consumption
-
-We use Mistral-7B model with 4-bit quantization as default. The estimated VRAM consumption per client for each challenge is shown below:
-
-| Challenges | GeneralNLP |   Finance  |   Medical  |    Code    |
-| :--------: | :--------: | :--------: | :--------: | :--------: |
-|    VRAM    | ~25.50 GB  | ~17.30 GB  | ~22.80 GB  | ~17.40 GB  |
-
-You can adjust the CPU/GPU resources you assign to each of the clients based on your device, which are specified with `options.backend.client-resources.num-cpus` and `options.backend.client-resources.num-gpus` under `[tool.flwr.federations.local-simulation]` entry in `pyproject.toml`.
-
-
-## Model saving
-
-The global PEFT model checkpoints are saved every 5 rounds after aggregation on the sever side as default, which can be specified with `train.save-every-round` under [tool.flwr.app.config] entry in `pyproject.toml`.
-
-> [!NOTE]
-> Please provide the last PEFT checkpoint if you plan to participated in the [LLM leaderboard](https://flower.ai/benchmarks/llm-leaderboard).

flwr/cli/new/templates/app/README.md.tpl

@@ -1,37 +0,0 @@
-# $project_name: A Flower / $framework_str app
-
-## Install dependencies and project
-
-The dependencies are listed in the `pyproject.toml` and you can install them as follows:
-
-```bash
-pip install -e .
-```
-
-> **Tip:** Your `pyproject.toml` file can define more than just the dependencies of your Flower app. You can also use it to specify hyperparameters for your runs and control which Flower Runtime is used. By default, it uses the Simulation Runtime, but you can switch to the Deployment Runtime when needed.
-> Learn more in the [TOML configuration guide](https://flower.ai/docs/framework/how-to-configure-pyproject-toml.html).
-
-## Run with the Simulation Engine
-
-In the `$project_name` directory, use `flwr run` to run a local simulation:
-
-```bash
-flwr run .
-```
-
-Refer to the [How to Run Simulations](https://flower.ai/docs/framework/how-to-run-simulations.html) guide in the documentation for advice on how to optimize your simulations.
-
-## Run with the Deployment Engine
-
-Follow this [how-to guide](https://flower.ai/docs/framework/how-to-run-flower-with-deployment-engine.html) to run the same app in this example but with Flower's Deployment Engine. After that, you might be interested in setting up [secure TLS-enabled communications](https://flower.ai/docs/framework/how-to-enable-tls-connections.html) and [SuperNode authentication](https://flower.ai/docs/framework/how-to-authenticate-supernodes.html) in your federation.
-
-You can run Flower on Docker too! Check out the [Flower with Docker](https://flower.ai/docs/framework/docker/index.html) documentation.
-
-## Resources
-
-- Flower website: [flower.ai](https://flower.ai/)
-- Check the documentation: [flower.ai/docs](https://flower.ai/docs/)
-- Give Flower a ⭐️ on GitHub: [GitHub](https://github.com/adap/flower)
-- Join the Flower community!
-  - [Flower Slack](https://flower.ai/join-slack/)
-  - [Flower Discuss](https://discuss.flower.ai/)

flwr/cli/new/templates/app/code/__init__.baseline.py.tpl

@@ -1 +0,0 @@
-"""$project_name: A Flower Baseline."""

flwr/cli/new/templates/app/code/__init__.py.tpl

@@ -1 +0,0 @@
-"""$project_name: A Flower / $framework_str app."""

flwr/cli/new/templates/app/code/__init__.pytorch_legacy_api.py.tpl

@@ -1 +0,0 @@
-"""$project_name: A Flower / PyTorch app."""

flwr/cli/new/templates/app/code/client.baseline.py.tpl

@@ -1,75 +0,0 @@
-"""$project_name: A Flower Baseline."""
-
-import torch
-from flwr.app import ArrayRecord, Context, Message, MetricRecord, RecordDict
-from flwr.clientapp import ClientApp
-
-from $import_name.dataset import load_data
-from $import_name.model import Net
-from $import_name.model import test as test_fn
-from $import_name.model import train as train_fn
-
-# Flower ClientApp
-app = ClientApp()
-
-
-@app.train()
-def train(msg: Message, context: Context):
-    """Train the model on local data."""
-
-    # Load the model and initialize it with the received weights
-    model = Net()
-    model.load_state_dict(msg.content["arrays"].to_torch_state_dict())
-    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
-
-    # Load the data
-    partition_id = int(context.node_config["partition-id"])
-    num_partitions = int(context.node_config["num-partitions"])
-    trainloader, _ = load_data(partition_id, num_partitions)
-    local_epochs = context.run_config["local-epochs"]
-
-    # Call the training function
-    train_loss = train_fn(
-        model,
-        trainloader,
-        local_epochs,
-        device,
-    )
-
-    # Construct and return reply Message
-    model_record = ArrayRecord(model.state_dict())
-    metrics = {
-        "train_loss": train_loss,
-        "num-examples": len(trainloader.dataset),
-    }
-    metric_record = MetricRecord(metrics)
-    content = RecordDict({"arrays": model_record, "metrics": metric_record})
-    return Message(content=content, reply_to=msg)
-
-
-@app.evaluate()
-def evaluate(msg: Message, context: Context):
-    """Evaluate the model on local data."""
-
-    # Load the model and initialize it with the received weights
-    model = Net()
-    model.load_state_dict(msg.content["arrays"].to_torch_state_dict())
-    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
-
-    # Load the data
-    partition_id = int(context.node_config["partition-id"])
-    num_partitions = int(context.node_config["num-partitions"])
-    _, valloader = load_data(partition_id, num_partitions)
-
-    # Call the evaluation function
-    eval_loss, eval_acc = test_fn(model, valloader, device)
-
-    # Construct and return reply Message
-    metrics = {
-        "eval_loss": eval_loss,
-        "eval_acc": eval_acc,
-        "num-examples": len(valloader.dataset),
-    }
-    metric_record = MetricRecord(metrics)
-    content = RecordDict({"metrics": metric_record})
-    return Message(content=content, reply_to=msg)

flwr/cli/new/templates/app/code/client.huggingface.py.tpl

@@ -1,93 +0,0 @@
-"""$project_name: A Flower / $framework_str app."""
-
-import torch
-from flwr.app import ArrayRecord, Context, Message, MetricRecord, RecordDict
-from flwr.clientapp import ClientApp
-from transformers import AutoModelForSequenceClassification
-
-from $import_name.task import load_data
-from $import_name.task import test as test_fn
-from $import_name.task import train as train_fn
-
-# Flower ClientApp
-app = ClientApp()
-
-
-@app.train()
-def train(msg: Message, context: Context):
-    """Train the model on local data."""
-
-    # Get this client's dataset partition
-    partition_id = context.node_config["partition-id"]
-    num_partitions = context.node_config["num-partitions"]
-    model_name = context.run_config["model-name"]
-    trainloader, _ = load_data(partition_id, num_partitions, model_name)
-
-    # Load model
-    num_labels = context.run_config["num-labels"]
-    net = AutoModelForSequenceClassification.from_pretrained(
-        model_name, num_labels=num_labels
-    )
-
-    # Initialize it with the received weights
-    net.load_state_dict(msg.content["arrays"].to_torch_state_dict())
-    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
-    net.to(device)
-
-    # Train the model on local data
-    train_loss = train_fn(
-        net,
-        trainloader,
-        context.run_config["local-steps"],
-        device,
-    )
-
-    # Construct and return reply Message
-    model_record = ArrayRecord(net.state_dict())
-    metrics = {
-        "train_loss": train_loss,
-        "num-examples": len(trainloader.dataset),
-    }
-    metric_record = MetricRecord(metrics)
-    content = RecordDict({"arrays": model_record, "metrics": metric_record})
-    return Message(content=content, reply_to=msg)
-
-
-@app.evaluate()
-def evaluate(msg: Message, context: Context):
-    """Evaluate the model on local data."""
-
-    # Get this client's dataset partition
-    partition_id = context.node_config["partition-id"]
-    num_partitions = context.node_config["num-partitions"]
-    model_name = context.run_config["model-name"]
-    _, valloader = load_data(partition_id, num_partitions, model_name)
-
-    # Load model
-    num_labels = context.run_config["num-labels"]
-    net = AutoModelForSequenceClassification.from_pretrained(
-        model_name, num_labels=num_labels
-    )
-
-    # Initialize it with the received weights
-    net.load_state_dict(msg.content["arrays"].to_torch_state_dict())
-    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
-    net.to(device)
-
-    # Evaluate the model on local data
-    val_loss, val_accuracy = test_fn(
-        net,
-        valloader,
-        device,
-    )
-
-    # Construct and return reply Message
-    model_record = ArrayRecord(net.state_dict())
-    metrics = {
-        "val_loss": val_loss,
-        "val_accuracy": val_accuracy,
-        "num-examples": len(valloader.dataset),
-    }
-    metric_record = MetricRecord(metrics)
-    content = RecordDict({"arrays": model_record, "metrics": metric_record})
-    return Message(content=content, reply_to=msg)

flwr/cli/new/templates/app/code/client.jax.py.tpl

@@ -1,71 +0,0 @@
-"""$project_name: A Flower / $framework_str app."""
-
-import jax
-from flwr.app import ArrayRecord, Context, Message, MetricRecord, RecordDict
-from flwr.clientapp import ClientApp
-
-from $import_name.task import evaluation as evaluation_fn
-from $import_name.task import get_params, load_data, load_model, loss_fn, set_params
-from $import_name.task import train as train_fn
-
-# Flower ClientApp
-app = ClientApp()
-
-
-@app.train()
-def train(msg: Message, context: Context):
-    """Train the model on local data."""
-
-    # Read from config
-    input_dim = context.run_config["input-dim"]
-
-    # Load data and model
-    train_x, train_y, _, _ = load_data()
-    model = load_model((input_dim,))
-    grad_fn = jax.grad(loss_fn)
-
-    # Set model parameters
-    ndarrays = msg.content["arrays"].to_numpy_ndarrays()
-    set_params(model, ndarrays)
-
-    # Train the model on local data
-    model, loss, num_examples = train_fn(model, grad_fn, train_x, train_y)
-
-    # Construct and return reply Message
-    model_record = ArrayRecord(get_params(model))
-    metrics = {
-        "train_loss": float(loss),
-        "num-examples": num_examples,
-    }
-    metric_record = MetricRecord(metrics)
-    content = RecordDict({"arrays": model_record, "metrics": metric_record})
-    return Message(content=content, reply_to=msg)
-
-
-@app.evaluate()
-def evaluate(msg: Message, context: Context):
-    """Evaluate the model on local data."""
-
-    # Read from config
-    input_dim = context.run_config["input-dim"]
-
-    # Load data and model
-    _, _, test_x, test_y = load_data()
-    model = load_model((input_dim,))
-    grad_fn = jax.grad(loss_fn)
-
-    # Set model parameters
-    ndarrays = msg.content["arrays"].to_numpy_ndarrays()
-    set_params(model, ndarrays)
-
-    # Evaluate the model on local data
-    loss, num_examples = evaluation_fn(model, grad_fn, test_x, test_y)
-
-    # Construct and return reply Message
-    metrics = {
-        "test_loss": float(loss),
-        "num-examples": num_examples,
-    }
-    metric_record = MetricRecord(metrics)
-    content = RecordDict({"metrics": metric_record})
-    return Message(content=content, reply_to=msg)

flwr/cli/new/templates/app/code/client.mlx.py.tpl

@@ -1,102 +0,0 @@
-"""$project_name: A Flower / $framework_str app."""
-
-import mlx.core as mx
-import mlx.nn as nn
-import mlx.optimizers as optim
-from flwr.app import ArrayRecord, Context, Message, MetricRecord, RecordDict
-from flwr.clientapp import ClientApp
-
-from $import_name.task import (
-    MLP,
-    batch_iterate,
-    eval_fn,
-    get_params,
-    load_data,
-    loss_fn,
-    set_params,
-)
-
-# Flower ClientApp
-app = ClientApp()
-
-
-@app.train()
-def train(msg: Message, context: Context):
-    """Train the model on local data."""
-
-    # Read config
-    num_layers = context.run_config["num-layers"]
-    input_dim = context.run_config["input-dim"]
-    hidden_dim = context.run_config["hidden-dim"]
-    batch_size = context.run_config["batch-size"]
-    learning_rate = context.run_config["lr"]
-    num_epochs = context.run_config["local-epochs"]
-
-    # Instantiate model and apply global parameters
-    model = MLP(num_layers, input_dim, hidden_dim, output_dim=10)
-    ndarrays = msg.content["arrays"].to_numpy_ndarrays()
-    set_params(model, ndarrays)
-
-    # Define optimizer and loss function
-    optimizer = optim.SGD(learning_rate=learning_rate)
-    loss_and_grad_fn = nn.value_and_grad(model, loss_fn)
-
-    # Load data
-    partition_id = context.node_config["partition-id"]
-    num_partitions = context.node_config["num-partitions"]
-    train_images, train_labels, _, _ = load_data(partition_id, num_partitions)
-
-    # Train the model on local data
-    for _ in range(num_epochs):
-        for X, y in batch_iterate(batch_size, train_images, train_labels):
-            _, grads = loss_and_grad_fn(model, X, y)
-            optimizer.update(model, grads)
-            mx.eval(model.parameters(), optimizer.state)
-
-    # Compute train accuracy and loss
-    accuracy = eval_fn(model, train_images, train_labels)
-    loss = loss_fn(model, train_images, train_labels)
-    # Construct and return reply Message
-    model_record = ArrayRecord(get_params(model))
-    metrics = {
-        "num-examples": len(train_images),
-        "accuracy": float(accuracy.item()),
-        "loss": float(loss.item()),
-    }
-    metric_record = MetricRecord(metrics)
-    content = RecordDict({"arrays": model_record, "metrics": metric_record})
-    return Message(content=content, reply_to=msg)
-
-
-@app.evaluate()
-def evaluate(msg: Message, context: Context):
-    """Evaluate the model on local data."""
-
-    # Read config
-    num_layers = context.run_config["num-layers"]
-    input_dim = context.run_config["input-dim"]
-    hidden_dim = context.run_config["hidden-dim"]
-
-    # Instantiate model and apply global parameters
-    model = MLP(num_layers, input_dim, hidden_dim, output_dim=10)
-    ndarrays = msg.content["arrays"].to_numpy_ndarrays()
-    set_params(model, ndarrays)
-
-    # Load data
-    partition_id = context.node_config["partition-id"]
-    num_partitions = context.node_config["num-partitions"]
-    _, _, test_images, test_labels = load_data(partition_id, num_partitions)
-
-    # Evaluate the model on local data
-    accuracy = eval_fn(model, test_images, test_labels)
-    loss = loss_fn(model, test_images, test_labels)
-
-    # Construct and return reply Message
-    metrics = {
-        "num-examples": len(test_images),
-        "accuracy": float(accuracy.item()),
-        "loss": float(loss.item()),
-    }
-    metric_record = MetricRecord(metrics)
-    content = RecordDict({"metrics": metric_record})
-    return Message(content=content, reply_to=msg)

flwr/cli/new/templates/app/code/client.numpy.py.tpl

@@ -1,46 +0,0 @@
-"""$project_name: A Flower / $framework_str app."""
-
-import numpy as np
-from flwr.app import ArrayRecord, Context, Message, MetricRecord, RecordDict
-from flwr.clientapp import ClientApp
-
-# Flower ClientApp
-app = ClientApp()
-
-
-@app.train()
-def train(msg: Message, context: Context):
-    """Train the model on local data."""
-
-    # The model is the global arrays
-    ndarrays = msg.content["arrays"].to_numpy_ndarrays()
-
-    # Simulate local training (here we just add random noise to model parameters)
-    model = [m + np.random.rand(*m.shape) for m in ndarrays]
-
-    # Construct and return reply Message
-    model_record = ArrayRecord(model)
-    metrics = {
-        "random_metric": np.random.rand(),
-        "num-examples": 1,
-    }
-    metric_record = MetricRecord(metrics)
-    content = RecordDict({"arrays": model_record, "metrics": metric_record})
-    return Message(content=content, reply_to=msg)
-
-
-@app.evaluate()
-def evaluate(msg: Message, context: Context):
-    """Evaluate the model on local data."""
-
-    # The model is the global arrays
-    ndarrays = msg.content["arrays"].to_numpy_ndarrays()
-
-    # Return reply Message
-    metrics = {
-        "random_metric": np.random.rand(3).tolist(),
-        "num-examples": 1,
-    }
-    metric_record = MetricRecord(metrics)
-    content = RecordDict({"metrics": metric_record})
-    return Message(content=content, reply_to=msg)