flwr-nightly 1.10.0.dev20240722__py3-none-any.whl → 1.11.0.dev20240805__py3-none-any.whl

flwr/cli/new/templates/app/code/server.tensorflow.py.tpl

@@ -1,4 +1,4 @@
-"""$project_name: A Flower / TensorFlow app."""
+"""$project_name: A Flower / $framework_str app."""
 
 from flwr.common import Context, ndarrays_to_parameters
 from flwr.server import ServerApp, ServerAppComponents, ServerConfig
@@ -6,14 +6,13 @@ from flwr.server.strategy import FedAvg
 
 from $import_name.task import load_model
 
-# Define config
-config = ServerConfig(num_rounds=3)
-
-parameters = ndarrays_to_parameters(load_model().get_weights())
 
 def server_fn(context: Context):
     # Read from config
-    num_rounds = int(context.run_config["num-server-rounds"])
+    num_rounds = context.run_config["num-server-rounds"]
+
+    # Get parameters to initialize global model
+    parameters = ndarrays_to_parameters(load_model().get_weights())
 
     # Define strategy
     strategy = strategy = FedAvg(

flwr/cli/new/templates/app/code/{task.hf.py.tpl → task.huggingface.py.tpl}

@@ -1,4 +1,4 @@
-"""$project_name: A Flower / HuggingFace Transformers app."""
+"""$project_name: A Flower / $framework_str app."""
 
 import warnings
 from collections import OrderedDict
@@ -10,15 +10,27 @@ from torch.utils.data import DataLoader
 from transformers import AutoTokenizer, DataCollatorWithPadding
 
 from flwr_datasets import FederatedDataset
+from flwr_datasets.partitioner import IidPartitioner
+
 
 warnings.filterwarnings("ignore", category=UserWarning)
 DEVICE = torch.device("cpu")
 CHECKPOINT = "distilbert-base-uncased"  # transformer model checkpoint
 
 
+fds = None  # Cache FederatedDataset
+
+
 def load_data(partition_id: int, num_partitions: int):
     """Load IMDB data (training and eval)"""
-    fds = FederatedDataset(dataset="imdb", partitioners={"train": num_partitions})
+    # Only initialize `FederatedDataset` once
+    global fds
+    if fds is None:
+        partitioner = IidPartitioner(num_partitions=num_partitions)
+        fds = FederatedDataset(
+            dataset="stanfordnlp/imdb",
+            partitioners={"train": partitioner},
+        )
     partition = fds.load_partition(partition_id)
     # Divide data: 80% train, 20% test
     partition_train_test = partition.train_test_split(test_size=0.2, seed=42)

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

@@ -1,4 +1,4 @@
-"""$project_name: A Flower / JAX app."""
+"""$project_name: A Flower / $framework_str app."""
 
 import jax
 import jax.numpy as jnp
@@ -33,7 +33,7 @@ def train(params, grad_fn, X, y):
     num_examples = X.shape[0]
     for epochs in range(50):
         grads = grad_fn(params, X, y)
-        params = jax.tree.map(lambda p, g: p - 0.05 * g, params, grads)
+        params = jax.tree_map(lambda p, g: p - 0.05 * g, params, grads)
         loss = loss_fn(params, X, y)
     return params, loss, num_examples
 

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

@@ -1,14 +1,16 @@
-"""$project_name: A Flower / MLX app."""
+"""$project_name: A Flower / $framework_str app."""
 
 import mlx.core as mx
 import mlx.nn as nn
 import numpy as np
 from datasets.utils.logging import disable_progress_bar
 from flwr_datasets import FederatedDataset
+from flwr_datasets.partitioner import IidPartitioner
 
 
 disable_progress_bar()
 
+
 class MLP(nn.Module):
     """A simple MLP."""
 
@@ -43,8 +45,19 @@ def batch_iterate(batch_size, X, y):
         yield X[ids], y[ids]
 
 
+fds = None  # Cache FederatedDataset
+
+
 def load_data(partition_id: int, num_partitions: int):
-    fds = FederatedDataset(dataset="mnist", partitioners={"train": num_partitions})
+    # Only initialize `FederatedDataset` once
+    global fds
+    if fds is None:
+        partitioner = IidPartitioner(num_partitions=num_partitions)
+        fds = FederatedDataset(
+            dataset="ylecun/mnist",
+            partitioners={"train": partitioner},
+            trust_remote_code=True,
+        )
     partition = fds.load_partition(partition_id)
     partition_splits = partition.train_test_split(test_size=0.2, seed=42)
 

flwr/cli/new/templates/app/code/task.pytorch.py.tpl

@@ -1,4 +1,4 @@
-"""$project_name: A Flower / PyTorch app."""
+"""$project_name: A Flower / $framework_str app."""
 
 from collections import OrderedDict
 
@@ -6,11 +6,9 @@ import torch
 import torch.nn as nn
 import torch.nn.functional as F
 from torch.utils.data import DataLoader
-from torchvision.datasets import CIFAR10
 from torchvision.transforms import Compose, Normalize, ToTensor
 from flwr_datasets import FederatedDataset
-
-DEVICE = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+from flwr_datasets.partitioner import IidPartitioner
 
 
 class Net(nn.Module):
@@ -34,9 +32,19 @@ class Net(nn.Module):
         return self.fc3(x)
 
 
+fds = None  # Cache FederatedDataset
+
+
 def load_data(partition_id: int, num_partitions: int):
     """Load partition CIFAR10 data."""
-    fds = FederatedDataset(dataset="cifar10", partitioners={"train": num_partitions})
+    # Only initialize `FederatedDataset` once
+    global fds
+    if fds is None:
+        partitioner = IidPartitioner(num_partitions=num_partitions)
+        fds = FederatedDataset(
+            dataset="uoft-cs/cifar10",
+            partitioners={"train": partitioner},
+        )
     partition = fds.load_partition(partition_id)
     # Divide data on each node: 80% train, 20% test
     partition_train_test = partition.train_test_split(test_size=0.2, seed=42)
@@ -55,44 +63,41 @@ def load_data(partition_id: int, num_partitions: int):
     return trainloader, testloader
 
 
-def train(net, trainloader, valloader, epochs, device):
+def train(net, trainloader, epochs, device):
     """Train the model on the training set."""
     net.to(device)  # move model to GPU if available
     criterion = torch.nn.CrossEntropyLoss().to(device)
-    optimizer = torch.optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
+    optimizer = torch.optim.SGD(net.parameters(), lr=0.1, momentum=0.9)
     net.train()
+    running_loss = 0.0
     for _ in range(epochs):
         for batch in trainloader:
             images = batch["img"]
             labels = batch["label"]
             optimizer.zero_grad()
-            criterion(net(images.to(DEVICE)), labels.to(DEVICE)).backward()
+            loss = criterion(net(images.to(device)), labels.to(device))
+            loss.backward()
             optimizer.step()
+            running_loss += loss.item()
 
-    train_loss, train_acc = test(net, trainloader)
-    val_loss, val_acc = test(net, valloader)
-
-    results = {
-        "train_loss": train_loss,
-        "train_accuracy": train_acc,
-        "val_loss": val_loss,
-        "val_accuracy": val_acc,
-    }
-    return results
+    avg_trainloss = running_loss / len(trainloader)
+    return avg_trainloss
 
 
-def test(net, testloader):
+def test(net, testloader, device):
     """Validate the model on the test set."""
+    net.to(device)
     criterion = torch.nn.CrossEntropyLoss()
     correct, loss = 0, 0.0
     with torch.no_grad():
         for batch in testloader:
-            images = batch["img"].to(DEVICE)
-            labels = batch["label"].to(DEVICE)
+            images = batch["img"].to(device)
+            labels = batch["label"].to(device)
             outputs = net(images)
             loss += criterion(outputs, labels).item()
             correct += (torch.max(outputs.data, 1)[1] == labels).sum().item()
     accuracy = correct / len(testloader.dataset)
+    loss = loss / len(testloader)
     return loss, accuracy
 
 

flwr/cli/new/templates/app/code/task.tensorflow.py.tpl

@@ -1,24 +1,48 @@
-"""$project_name: A Flower / TensorFlow app."""
+"""$project_name: A Flower / $framework_str app."""
 
 import os
 
-import tensorflow as tf
+import keras
+from keras import layers
 from flwr_datasets import FederatedDataset
+from flwr_datasets.partitioner import IidPartitioner
 
 
 # Make TensorFlow log less verbose
 os.environ["TF_CPP_MIN_LOG_LEVEL"] = "3"
 
+
 def load_model():
-    # Load model and data (MobileNetV2, CIFAR-10)
-    model = tf.keras.applications.MobileNetV2((32, 32, 3), classes=10, weights=None)
+    # Define a simple CNN for CIFAR-10 and set Adam optimizer
+    model = keras.Sequential(
+        [
+            keras.Input(shape=(32, 32, 3)),
+            layers.Conv2D(32, kernel_size=(3, 3), activation="relu"),
+            layers.MaxPooling2D(pool_size=(2, 2)),
+            layers.Conv2D(64, kernel_size=(3, 3), activation="relu"),
+            layers.MaxPooling2D(pool_size=(2, 2)),
+            layers.Flatten(),
+            layers.Dropout(0.5),
+            layers.Dense(10, activation="softmax"),
+        ]
+    )
     model.compile("adam", "sparse_categorical_crossentropy", metrics=["accuracy"])
     return model
 
 
+fds = None  # Cache FederatedDataset
+
+
 def load_data(partition_id, num_partitions):
     # Download and partition dataset
-    fds = FederatedDataset(dataset="cifar10", partitioners={"train": num_partitions})
+    # Only initialize `FederatedDataset` once
+    global fds
+    if fds is None:
+        partitioner = IidPartitioner(num_partitions=num_partitions)
+        fds = FederatedDataset(
+            dataset="uoft-cs/cifar10",
+            partitioners={"train": partitioner},
+        )
     partition = fds.load_partition(partition_id, "train")
     partition.set_format("numpy")
 

flwr/cli/new/templates/app/pyproject.flowertune.toml.tpl

@@ -30,10 +30,10 @@ serverapp = "$import_name.app:server"
 clientapp = "$import_name.app:client"
 
 [tool.flwr.app.config]
-num-server-rounds = "3"
+num-server-rounds = 3
 
 [tool.flwr.federations]
-default = "localhost"
+default = "local-simulation"
 
-[tool.flwr.federations.localhost]
+[tool.flwr.federations.local-simulation]
 options.num-supernodes = 10

flwr/cli/new/templates/app/{pyproject.hf.toml.tpl → pyproject.huggingface.toml.tpl}

@@ -8,8 +8,8 @@ version = "1.0.0"
 description = ""
 license = "Apache-2.0"
 dependencies = [
-    "flwr[simulation]>=1.9.0,<2.0",
-    "flwr-datasets>=0.0.2,<1.0.0",
+    "flwr[simulation]>=1.10.0",
+    "flwr-datasets>=0.3.0",
     "torch==2.2.1",
     "transformers>=4.30.0,<5.0",
     "evaluate>=0.4.0,<1.0",
@@ -28,8 +28,8 @@ serverapp = "$import_name.server_app:app"
 clientapp = "$import_name.client_app:app"
 
 [tool.flwr.app.config]
-num-server-rounds = "3"
-local-epochs = "1"
+num-server-rounds = 3
+local-epochs = 1
 
 [tool.flwr.federations]
 default = "localhost"

flwr/cli/new/templates/app/pyproject.jax.toml.tpl

@@ -8,7 +8,7 @@ version = "1.0.0"
 description = ""
 license = "Apache-2.0"
 dependencies = [
-    "flwr[simulation]>=1.9.0,<2.0",
+    "flwr[simulation]>=1.10.0",
     "jax==0.4.13",
     "jaxlib==0.4.13",
     "scikit-learn==1.3.2",
@@ -25,10 +25,10 @@ serverapp = "$import_name.server_app:app"
 clientapp = "$import_name.client_app:app"
 
 [tool.flwr.app.config]
-num-server-rounds = "3"
+num-server-rounds = 3
 
 [tool.flwr.federations]
-default = "localhost"
+default = "local-simulation"
 
-[tool.flwr.federations.localhost]
+[tool.flwr.federations.local-simulation]
 options.num-supernodes = 10

flwr/cli/new/templates/app/pyproject.mlx.toml.tpl

@@ -8,9 +8,9 @@ version = "1.0.0"
 description = ""
 license = "Apache-2.0"
 dependencies = [
-    "flwr[simulation]>=1.9.0,<2.0",
-    "flwr-datasets[vision]>=0.0.2,<1.0.0",
-    "mlx==0.10.0",
+    "flwr[simulation]>=1.10.0",
+    "flwr-datasets[vision]>=0.3.0",
+    "mlx==0.16.1",
     "numpy==1.24.4",
 ]
 
@@ -25,15 +25,15 @@ serverapp = "$import_name.server_app:app"
 clientapp = "$import_name.client_app:app"
 
 [tool.flwr.app.config]
-num-server-rounds = "3"
-local-epochs = "1"
-num-layers = "2"
-hidden-dim = "32"
-batch-size = "256"
-lr = "0.1"
+num-server-rounds = 3
+local-epochs = 1
+num-layers = 2
+hidden-dim = 32
+batch-size = 256
+lr = 0.1
 
 [tool.flwr.federations]
-default = "localhost"
+default = "local-simulation"
 
-[tool.flwr.federations.localhost]
+[tool.flwr.federations.local-simulation]
 options.num-supernodes = 10

flwr/cli/new/templates/app/pyproject.numpy.toml.tpl

@@ -8,7 +8,7 @@ version = "1.0.0"
 description = ""
 license = "Apache-2.0"
 dependencies = [
-    "flwr[simulation]>=1.9.0,<2.0",
+    "flwr[simulation]>=1.10.0",
     "numpy>=1.21.0",
 ]
 
@@ -23,10 +23,10 @@ serverapp = "$import_name.server_app:app"
 clientapp = "$import_name.client_app:app"
 
 [tool.flwr.app.config]
-num-server-rounds = "3"
+num-server-rounds = 3
 
 [tool.flwr.federations]
-default = "localhost"
+default = "local-simulation"
 
-[tool.flwr.federations.localhost]
+[tool.flwr.federations.local-simulation]
 options.num-supernodes = 10

flwr/cli/new/templates/app/pyproject.pytorch.toml.tpl

@@ -8,8 +8,8 @@ version = "1.0.0"
 description = ""
 license = "Apache-2.0"
 dependencies = [
-    "flwr[simulation]>=1.9.0,<2.0",
-    "flwr-datasets[vision]>=0.0.2,<1.0.0",
+    "flwr[simulation]>=1.10.0",
+    "flwr-datasets[vision]>=0.3.0",
     "torch==2.2.1",
     "torchvision==0.17.1",
 ]
@@ -25,11 +25,12 @@ serverapp = "$import_name.server_app:app"
 clientapp = "$import_name.client_app:app"
 
 [tool.flwr.app.config]
-num-server-rounds = "3"
-local-epochs = "1"
+num-server-rounds = 3
+fraction-fit = 0.5
+local-epochs = 1
 
 [tool.flwr.federations]
-default = "localhost"
+default = "local-simulation"
 
-[tool.flwr.federations.localhost]
+[tool.flwr.federations.local-simulation]
 options.num-supernodes = 10

flwr/cli/new/templates/app/pyproject.sklearn.toml.tpl

@@ -8,8 +8,8 @@ version = "1.0.0"
 description = ""
 license = "Apache-2.0"
 dependencies = [
-    "flwr[simulation]>=1.9.0,<2.0",
-    "flwr-datasets[vision]>=0.0.2,<1.0.0",
+    "flwr[simulation]>=1.10.0",
+    "flwr-datasets[vision]>=0.3.0",
     "scikit-learn>=1.1.1",
 ]
 
@@ -24,10 +24,10 @@ serverapp = "$import_name.server_app:app"
 clientapp = "$import_name.client_app:app"
 
 [tool.flwr.app.config]
-num-server-rounds = "3"
+num-server-rounds = 3
 
 [tool.flwr.federations]
-default = "localhost"
+default = "local-simulation"
 
-[tool.flwr.federations.localhost]
+[tool.flwr.federations.local-simulation]
 options.num-supernodes = 10

flwr/cli/new/templates/app/pyproject.tensorflow.toml.tpl

@@ -8,8 +8,8 @@ version = "1.0.0"
 description = ""
 license = "Apache-2.0"
 dependencies = [
-    "flwr[simulation]>=1.9.0,<2.0",
-    "flwr-datasets[vision]>=0.0.2,<1.0.0",
+    "flwr[simulation]>=1.10.0",
+    "flwr-datasets[vision]>=0.3.0",
     "tensorflow>=2.11.1",
 ]
 
@@ -24,13 +24,13 @@ serverapp = "$import_name.server_app:app"
 clientapp = "$import_name.client_app:app"
 
 [tool.flwr.app.config]
-num-server-rounds = "3"
-local-epochs = "1"
-batch-size = "32"
-verbose = ""  # Empty string means False
+num-server-rounds = 3
+local-epochs = 1
+batch-size = 32
+verbose = false
 
 [tool.flwr.federations]
-default = "localhost"
+default = "local-simulation"
 
-[tool.flwr.federations.localhost]
+[tool.flwr.federations.local-simulation]
 options.num-supernodes = 10

flwr/cli/run/run.py

@@ -25,7 +25,7 @@ from typing_extensions import Annotated
 
 from flwr.cli.build import build
 from flwr.cli.config_utils import load_and_validate
-from flwr.common.config import parse_config_args
+from flwr.common.config import flatten_dict, parse_config_args
 from flwr.common.grpc import GRPC_MAX_MESSAGE_LENGTH, create_channel
 from flwr.common.logger import log
 from flwr.common.serde import user_config_to_proto
@@ -35,27 +35,30 @@ from flwr.proto.exec_pb2_grpc import ExecStub
 
 # pylint: disable-next=too-many-locals
 def run(
-    directory: Annotated[
+    app_dir: Annotated[
         Path,
-        typer.Argument(help="Path of the Flower project to run"),
+        typer.Argument(help="Path of the Flower project to run."),
     ] = Path("."),
-    federation_name: Annotated[
+    federation: Annotated[
         Optional[str],
-        typer.Argument(help="Name of the federation to run the app on"),
+        typer.Argument(help="Name of the federation to run the app on."),
     ] = None,
     config_overrides: Annotated[
         Optional[List[str]],
         typer.Option(
             "--run-config",
             "-c",
-            help="Override configuration key-value pairs",
+            help="Override configuration key-value pairs, should be of the format:\n\n"
+            "`--run-config key1=value1,key2=value2 --run-config key3=value3`\n\n"
+            "Note that `key1`, `key2`, and `key3` in this example need to exist "
+            "inside the `pyproject.toml` in order to be properly overriden.",
         ),
     ] = None,
 ) -> None:
     """Run Flower project."""
     typer.secho("Loading project configuration... ", fg=typer.colors.BLUE)
 
-    pyproject_path = directory / "pyproject.toml" if directory else None
+    pyproject_path = app_dir / "pyproject.toml" if app_dir else None
     config, errors, warnings = load_and_validate(path=pyproject_path)
 
     if config is None:
@@ -78,11 +81,9 @@ def run(
 
     typer.secho("Success", fg=typer.colors.GREEN)
 
-    federation_name = federation_name or config["tool"]["flwr"]["federations"].get(
-        "default"
-    )
+    federation = federation or config["tool"]["flwr"]["federations"].get("default")
 
-    if federation_name is None:
+    if federation is None:
         typer.secho(
             "❌ No federation name was provided and the project's `pyproject.toml` "
             "doesn't declare a default federation (with a SuperExec address or an "
@@ -93,13 +94,13 @@ def run(
         raise typer.Exit(code=1)
 
     # Validate the federation exists in the configuration
-    federation = config["tool"]["flwr"]["federations"].get(federation_name)
-    if federation is None:
+    federation_config = config["tool"]["flwr"]["federations"].get(federation)
+    if federation_config is None:
         available_feds = {
             fed for fed in config["tool"]["flwr"]["federations"] if fed != "default"
         }
         typer.secho(
-            f"❌ There is no `{federation_name}` federation declared in the "
+            f"❌ There is no `{federation}` federation declared in "
             "`pyproject.toml`.\n The following federations were found:\n\n"
             + "\n".join(available_feds),
             fg=typer.colors.RED,
@@ -107,15 +108,15 @@ def run(
         )
         raise typer.Exit(code=1)
 
-    if "address" in federation:
-        _run_with_superexec(federation, directory, config_overrides)
+    if "address" in federation_config:
+        _run_with_superexec(federation_config, app_dir, config_overrides)
     else:
-        _run_without_superexec(directory, federation, federation_name, config_overrides)
+        _run_without_superexec(app_dir, federation_config, federation, config_overrides)
 
 
 def _run_with_superexec(
-    federation: Dict[str, str],
-    directory: Optional[Path],
+    federation_config: Dict[str, Any],
+    app_dir: Optional[Path],
     config_overrides: Optional[List[str]],
 ) -> None:
 
@@ -123,8 +124,8 @@ def _run_with_superexec(
         """Log channel connectivity."""
         log(DEBUG, channel_connectivity)
 
-    insecure_str = federation.get("insecure")
-    if root_certificates := federation.get("root-certificates"):
+    insecure_str = federation_config.get("insecure")
+    if root_certificates := federation_config.get("root-certificates"):
         root_certificates_bytes = Path(root_certificates).read_bytes()
         if insecure := bool(insecure_str):
             typer.secho(
@@ -152,7 +153,7 @@ def _run_with_superexec(
             raise typer.Exit(code=1)
 
     channel = create_channel(
-        server_address=federation["address"],
+        server_address=federation_config["address"],
         insecure=insecure,
         root_certificates=root_certificates_bytes,
         max_message_length=GRPC_MAX_MESSAGE_LENGTH,
@@ -161,13 +162,16 @@ def _run_with_superexec(
     channel.subscribe(on_channel_state_change)
     stub = ExecStub(channel)
 
-    fab_path = build(directory)
+    fab_path = build(app_dir)
 
     req = StartRunRequest(
         fab_file=Path(fab_path).read_bytes(),
         override_config=user_config_to_proto(
             parse_config_args(config_overrides, separator=",")
         ),
+        federation_config=user_config_to_proto(
+            flatten_dict(federation_config.get("options"))
+        ),
     )
     res = stub.StartRun(req)
     typer.secho(f"🎊 Successfully started run {res.run_id}", fg=typer.colors.GREEN)
@@ -175,18 +179,18 @@ def _run_with_superexec(
 
 def _run_without_superexec(
     app_path: Optional[Path],
-    federation: Dict[str, Any],
-    federation_name: str,
+    federation_config: Dict[str, Any],
+    federation: str,
     config_overrides: Optional[List[str]],
 ) -> None:
     try:
-        num_supernodes = federation["options"]["num-supernodes"]
+        num_supernodes = federation_config["options"]["num-supernodes"]
     except KeyError as err:
         typer.secho(
             "❌ The project's `pyproject.toml` needs to declare the number of"
             " SuperNodes in the simulation. To simulate 10 SuperNodes,"
             " use the following notation:\n\n"
-            f"[tool.flwr.federations.{federation_name}]\n"
+            f"[tool.flwr.federations.{federation}]\n"
             "options.num-supernodes = 10\n",
             fg=typer.colors.RED,
             bold=True,

flwr/client/grpc_rere_client/grpc_adapter.py

@@ -28,6 +28,7 @@ from flwr.common.constant import (
     GRPC_ADAPTER_METADATA_SHOULD_EXIT_KEY,
 )
 from flwr.common.version import package_version
+from flwr.proto.fab_pb2 import GetFabRequest, GetFabResponse  # pylint: disable=E0611
 from flwr.proto.fleet_pb2 import (  # pylint: disable=E0611
     CreateNodeRequest,
     CreateNodeResponse,
@@ -131,3 +132,9 @@ class GrpcAdapter:
     ) -> GetRunResponse:
         """."""
         return self._send_and_receive(request, GetRunResponse, **kwargs)
+
+    def GetFab(  # pylint: disable=C0103
+        self, request: GetFabRequest, **kwargs: Any
+    ) -> GetFabResponse:
+        """."""
+        return self._send_and_receive(request, GetFabResponse, **kwargs)