flwr-nightly 1.10.0.dev20240707__py3-none-any.whl → 1.11.0.dev20240724__py3-none-any.whl

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

@@ -9,13 +9,13 @@ from hydra import compose, initialize
 from hydra.utils import instantiate
 
 from flwr.client import ClientApp
-from flwr.common import ndarrays_to_parameters
-from flwr.server import ServerApp, ServerConfig
+from flwr.common import Context, ndarrays_to_parameters
+from flwr.server import ServerApp, ServerAppComponents, ServerConfig
 
-from $import_name.client import gen_client_fn, get_parameters
+from $import_name.client_app import gen_client_fn, get_parameters
 from $import_name.dataset import get_tokenizer_and_data_collator_and_propt_formatting
 from $import_name.models import get_model
-from $import_name.server import fit_weighted_average, get_evaluate_fn, get_on_fit_config
+from $import_name.server_app import fit_weighted_average, get_evaluate_fn, get_on_fit_config
 
 # Avoid warnings
 warnings.filterwarnings("ignore", category=UserWarning)
@@ -67,20 +67,23 @@ init_model = get_model(cfg.model)
 init_model_parameters = get_parameters(init_model)
 init_model_parameters = ndarrays_to_parameters(init_model_parameters)
 
-# Instantiate strategy according to config. Here we pass other arguments
-# that are only defined at runtime.
-strategy = instantiate(
-    cfg.strategy,
-    on_fit_config_fn=get_on_fit_config(),
-    fit_metrics_aggregation_fn=fit_weighted_average,
-    initial_parameters=init_model_parameters,
-    evaluate_fn=get_evaluate_fn(
-        cfg.model, cfg.train.save_every_round, cfg_static.num_rounds, save_path
-    ),
-)
+def server_fn(context: Context):
+    # Instantiate strategy according to config. Here we pass other arguments
+    # that are only defined at runtime.
+    strategy = instantiate(
+        cfg.strategy,
+        on_fit_config_fn=get_on_fit_config(),
+        fit_metrics_aggregation_fn=fit_weighted_average,
+        initial_parameters=init_model_parameters,
+        evaluate_fn=get_evaluate_fn(
+            cfg.model, cfg.train.save_every_round, cfg_static.num_rounds, save_path
+        ),
+    )
+
+    config = ServerConfig(num_rounds=cfg_static.num_rounds)
+
+    return ServerAppComponents(strategy=strategy, config=config)
+
 
 # ServerApp for Flower Next
-server = ServerApp(
-    config=ServerConfig(num_rounds=cfg_static.num_rounds),
-    strategy=strategy,
-)
+server = ServerApp(server_fn=server_fn)

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

@@ -10,6 +10,7 @@ from transformers import TrainingArguments
 from trl import SFTTrainer
 
 from flwr.client import NumPyClient
+from flwr.common import Context
 from flwr.common.typing import NDArrays, Scalar
 from $import_name.dataset import reformat
 from $import_name.models import cosine_annealing, get_model
@@ -102,13 +103,14 @@ def gen_client_fn(
     model_cfg: DictConfig,
     train_cfg: DictConfig,
     save_path: str,
-) -> Callable[[str], FlowerClient]:  # pylint: disable=too-many-arguments
+) -> Callable[[Context], FlowerClient]:  # pylint: disable=too-many-arguments
     """Generate the client function that creates the Flower Clients."""
 
-    def client_fn(cid: str) -> FlowerClient:
+    def client_fn(context: Context) -> FlowerClient:
         """Create a Flower client representing a single organization."""
         # Let's get the partition corresponding to the i-th client
-        client_trainset = fds.load_partition(int(cid), "train")
+        partition_id = context.node_config["partition-id"]
+        client_trainset = fds.load_partition(partition_id, "train")
         client_trainset = reformat(client_trainset, llm_task="$llm_challenge_str")
 
         return FlowerClient(

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

@@ -1,6 +1,6 @@
 """$project_name: A Flower / FlowerTune app."""
 
-from $import_name.client import set_parameters
+from $import_name.client_app import set_parameters
 from $import_name.models import get_model
 
 

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

@@ -0,0 +1,23 @@
+"""$project_name: A Flower / HuggingFace Transformers app."""
+
+from flwr.common import Context
+from flwr.server.strategy import FedAvg
+from flwr.server import ServerApp, ServerAppComponents, ServerConfig
+
+
+def server_fn(context: Context):
+    # Read from config
+    num_rounds = context.run_config["num-server-rounds"]
+
+    # Define strategy
+    strategy = FedAvg(
+        fraction_fit=1.0,
+        fraction_evaluate=1.0,
+    )
+    config = ServerConfig(num_rounds=num_rounds)
+
+    return ServerAppComponents(strategy=strategy, config=config)
+
+
+# Create ServerApp
+app = ServerApp(server_fn=server_fn)

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

@@ -1,12 +1,20 @@
 """$project_name: A Flower / JAX app."""
 
-import flwr as fl
+from flwr.common import Context
+from flwr.server.strategy import FedAvg
+from flwr.server import ServerApp, ServerAppComponents, ServerConfig
 
-# Configure the strategy
-strategy = fl.server.strategy.FedAvg()
 
-# Flower ServerApp
-app = fl.server.ServerApp(
-    config=fl.server.ServerConfig(num_rounds=3),
-    strategy=strategy,
-)
+def server_fn(context: Context):
+    # Read from config
+    num_rounds = context.run_config["num-server-rounds"]
+
+    # Define strategy
+    strategy = FedAvg()
+    config = ServerConfig(num_rounds=num_rounds)
+
+    return ServerAppComponents(strategy=strategy, config=config)
+
+
+# Create ServerApp
+app = ServerApp(server_fn=server_fn)

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

@@ -1,15 +1,20 @@
 """$project_name: A Flower / MLX app."""
 
-from flwr.server import ServerApp, ServerConfig
+from flwr.common import Context
+from flwr.server import ServerApp, ServerAppComponents, ServerConfig
 from flwr.server.strategy import FedAvg
 
 
-# Define strategy
-strategy = FedAvg()
+def server_fn(context: Context):
+    # Read from config
+    num_rounds = context.run_config["num-server-rounds"]
+
+    # Define strategy
+    strategy = FedAvg()
+    config = ServerConfig(num_rounds=num_rounds)
+
+    return ServerAppComponents(strategy=strategy, config=config)
 
 
 # Create ServerApp
-app = ServerApp(
-    config=ServerConfig(num_rounds=3),
-    strategy=strategy,
-)
+app = ServerApp(server_fn=server_fn)

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

@@ -1,12 +1,20 @@
 """$project_name: A Flower / NumPy app."""
 
-import flwr as fl
+from flwr.common import Context
+from flwr.server import ServerApp, ServerAppComponents, ServerConfig
+from flwr.server.strategy import FedAvg
 
-# Configure the strategy
-strategy = fl.server.strategy.FedAvg()
 
-# Flower ServerApp
-app = fl.server.ServerApp(
-    config=fl.server.ServerConfig(num_rounds=1),
-    strategy=strategy,
-)
+def server_fn(context: Context):
+    # Read from config
+    num_rounds = context.run_config["num-server-rounds"]
+
+    # Define strategy
+    strategy = FedAvg()
+    config = ServerConfig(num_rounds=num_rounds)
+
+    return ServerAppComponents(strategy=strategy, config=config)
+
+
+# Create ServerApp
+app = ServerApp(server_fn=server_fn)

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

@@ -1,7 +1,7 @@
 """$project_name: A Flower / PyTorch app."""
 
-from flwr.common import ndarrays_to_parameters
-from flwr.server import ServerApp, ServerConfig
+from flwr.common import Context, ndarrays_to_parameters
+from flwr.server import ServerApp, ServerAppComponents, ServerConfig
 from flwr.server.strategy import FedAvg
 
 from $import_name.task import Net, get_weights
@@ -11,18 +11,20 @@ from $import_name.task import Net, get_weights
 ndarrays = get_weights(Net())
 parameters = ndarrays_to_parameters(ndarrays)
 
+def server_fn(context: Context):
+    # Read from config
+    num_rounds = context.run_config["num-server-rounds"]
 
-# Define strategy
-strategy = FedAvg(
-    fraction_fit=1.0,
-    fraction_evaluate=1.0,
-    min_available_clients=2,
-    initial_parameters=parameters,
-)
+    # Define strategy
+    strategy = FedAvg(
+        fraction_fit=1.0,
+        fraction_evaluate=1.0,
+        min_available_clients=2,
+        initial_parameters=parameters,
+    )
+    config = ServerConfig(num_rounds=num_rounds)
 
+    return ServerAppComponents(strategy=strategy, config=config)
 
 # Create ServerApp
-app = ServerApp(
-    config=ServerConfig(num_rounds=3),
-    strategy=strategy,
-)
+app = ServerApp(server_fn=server_fn)

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

@@ -1,17 +1,24 @@
 """$project_name: A Flower / Scikit-Learn app."""
 
-from flwr.server import ServerApp, ServerConfig
+from flwr.common import Context
+from flwr.server import ServerApp, ServerAppComponents, ServerConfig
 from flwr.server.strategy import FedAvg
 
 
-strategy = FedAvg(
-    fraction_fit=1.0,
-    fraction_evaluate=1.0,
-    min_available_clients=2,
-)
+def server_fn(context: Context):
+    # Read from config
+    num_rounds = context.run_config["num-server-rounds"]
+
+    # Define strategy
+    strategy = FedAvg(
+        fraction_fit=1.0,
+        fraction_evaluate=1.0,
+        min_available_clients=2,
+    )
+    config = ServerConfig(num_rounds=num_rounds)
+
+    return ServerAppComponents(strategy=strategy, config=config)
+
 
 # Create ServerApp
-app = ServerApp(
-    config=ServerConfig(num_rounds=3),
-    strategy=strategy,
-)
+app = ServerApp(server_fn=server_fn)

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

@@ -1,7 +1,7 @@
 """$project_name: A Flower / TensorFlow app."""
 
-from flwr.common import ndarrays_to_parameters
-from flwr.server import ServerApp, ServerConfig
+from flwr.common import Context, ndarrays_to_parameters
+from flwr.server import ServerApp, ServerAppComponents, ServerConfig
 from flwr.server.strategy import FedAvg
 
 from $import_name.task import load_model
@@ -11,17 +11,20 @@ config = ServerConfig(num_rounds=3)
 
 parameters = ndarrays_to_parameters(load_model().get_weights())
 
-# Define strategy
-strategy = FedAvg(
-    fraction_fit=1.0,
-    fraction_evaluate=1.0,
-    min_available_clients=2,
-    initial_parameters=parameters,
-)
+def server_fn(context: Context):
+    # Read from config
+    num_rounds = context.run_config["num-server-rounds"]
 
+    # Define strategy
+    strategy = strategy = FedAvg(
+        fraction_fit=1.0,
+        fraction_evaluate=1.0,
+        min_available_clients=2,
+        initial_parameters=parameters,
+    )
+    config = ServerConfig(num_rounds=num_rounds)
+
+    return ServerAppComponents(strategy=strategy, config=config)
 
 # Create ServerApp
-app = ServerApp(
-    config=config,
-    strategy=strategy,
-)
+app = ServerApp(server_fn=server_fn)

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

@@ -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
 
 
-def load_data(partition_id, num_clients):
+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_clients})
+    # 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.mlx.py.tpl

@@ -5,10 +5,12 @@ 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,18 @@ def batch_iterate(batch_size, X, y):
         yield X[ids], y[ids]
 
 
-def load_data(partition_id, num_clients):
-    fds = FederatedDataset(dataset="mnist", partitioners={"train": num_clients})
+fds = None  # Cache FederatedDataset
+
+
+def load_data(partition_id: int, num_partitions: int):
+    # Only initialize `FederatedDataset` once
+    global fds
+    if fds is None:
+        partitioner = IidPartitioner(num_partitions=num_partitions)
+        fds = FederatedDataset(
+            dataset="ylecun/mnist",
+            partitioners={"train": partitioner},
+        )
     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

@@ -6,9 +6,10 @@ 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
+from flwr_datasets.partitioner import IidPartitioner
+
 
 DEVICE = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
 
@@ -34,9 +35,19 @@ class Net(nn.Module):
         return self.fc3(x)
 
 
-def load_data(partition_id, num_partitions):
+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)

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

@@ -4,11 +4,13 @@ import os
 
 import tensorflow as tf
 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)
@@ -16,9 +18,19 @@ def load_model():
     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

@@ -6,10 +6,7 @@ build-backend = "hatchling.build"
 name = "$package_name"
 version = "1.0.0"
 description = ""
-authors = [
-    { name = "The Flower Authors", email = "hello@flower.ai" },
-]
-license = { text = "Apache License (2.0)" }
+license = "Apache-2.0"
 dependencies = [
     "flwr[simulation]>=1.9.0,<2.0",
     "flwr-datasets>=0.1.0,<1.0.0",
@@ -25,18 +22,18 @@ dependencies = [
 [tool.hatch.build.targets.wheel]
 packages = ["."]
 
-[flower]
+[tool.flwr.app]
 publisher = "$username"
 
-[flower.components]
+[tool.flwr.app.components]
 serverapp = "$import_name.app:server"
 clientapp = "$import_name.app:client"
 
-[flower.engine]
-name = "simulation"
+[tool.flwr.app.config]
+num-server-rounds = 3
 
-[flower.engine.simulation.supernode]
-num = $num_clients
+[tool.flwr.federations]
+default = "local-simulation"
 
-[flower.engine.simulation]
-backend_config = { client_resources = { num_cpus = 8, num_gpus = 1.0 } }
+[tool.flwr.federations.local-simulation]
+options.num-supernodes = 10

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

@@ -0,0 +1,38 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "$package_name"
+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",
+    "torch==2.2.1",
+    "transformers>=4.30.0,<5.0",
+    "evaluate>=0.4.0,<1.0",
+    "datasets>=2.0.0, <3.0",
+    "scikit-learn>=1.3.1, <2.0",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["."]
+
+[tool.flwr.app]
+publisher = "$username"
+
+[tool.flwr.app.components]
+serverapp = "$import_name.server_app:app"
+clientapp = "$import_name.client_app:app"
+
+[tool.flwr.app.config]
+num-server-rounds = 3
+local-epochs = 1
+
+[tool.flwr.federations]
+default = "localhost"
+
+[tool.flwr.federations.localhost]
+options.num-supernodes = 10

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

@@ -6,23 +6,29 @@ build-backend = "hatchling.build"
 name = "$package_name"
 version = "1.0.0"
 description = ""
-authors = [
-    { name = "The Flower Authors", email = "hello@flower.ai" },
-]
-license = {text = "Apache License (2.0)"}
+license = "Apache-2.0"
 dependencies = [
     "flwr[simulation]>=1.9.0,<2.0",
-    "jax==0.4.26",
-    "jaxlib==0.4.26",
-    "scikit-learn==1.4.2",
+    "jax==0.4.13",
+    "jaxlib==0.4.13",
+    "scikit-learn==1.3.2",
 ]
 
 [tool.hatch.build.targets.wheel]
 packages = ["."]
 
-[flower]
+[tool.flwr.app]
 publisher = "$username"
 
-[flower.components]
-serverapp = "$import_name.server:app"
-clientapp = "$import_name.client:app"
+[tool.flwr.app.components]
+serverapp = "$import_name.server_app:app"
+clientapp = "$import_name.client_app:app"
+
+[tool.flwr.app.config]
+num-server-rounds = 3
+
+[tool.flwr.federations]
+default = "local-simulation"
+
+[tool.flwr.federations.local-simulation]
+options.num-supernodes = 10

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

@@ -6,10 +6,7 @@ build-backend = "hatchling.build"
 name = "$package_name"
 version = "1.0.0"
 description = ""
-authors = [
-    { name = "The Flower Authors", email = "hello@flower.ai" },
-]
-license = { text = "Apache License (2.0)" }
+license = "Apache-2.0"
 dependencies = [
     "flwr[simulation]>=1.9.0,<2.0",
     "flwr-datasets[vision]>=0.0.2,<1.0.0",
@@ -20,15 +17,23 @@ dependencies = [
 [tool.hatch.build.targets.wheel]
 packages = ["."]
 
-[flower]
+[tool.flwr.app]
 publisher = "$username"
 
-[flower.components]
-serverapp = "$import_name.server:app"
-clientapp = "$import_name.client:app"
+[tool.flwr.app.components]
+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
 
-[flower.engine]
-name = "simulation"
+[tool.flwr.federations]
+default = "local-simulation"
 
-[flower.engine.simulation.supernode]
-num = 2
+[tool.flwr.federations.local-simulation]
+options.num-supernodes = 10

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

@@ -6,10 +6,7 @@ build-backend = "hatchling.build"
 name = "$package_name"
 version = "1.0.0"
 description = ""
-authors = [
-    { name = "The Flower Authors", email = "hello@flower.ai" },
-]
-license = { text = "Apache License (2.0)" }
+license = "Apache-2.0"
 dependencies = [
     "flwr[simulation]>=1.9.0,<2.0",
     "numpy>=1.21.0",
@@ -18,15 +15,18 @@ dependencies = [
 [tool.hatch.build.targets.wheel]
 packages = ["."]
 
-[flower]
+[tool.flwr.app]
 publisher = "$username"
 
-[flower.components]
-serverapp = "$import_name.server:app"
-clientapp = "$import_name.client:app"
+[tool.flwr.app.components]
+serverapp = "$import_name.server_app:app"
+clientapp = "$import_name.client_app:app"
+
+[tool.flwr.app.config]
+num-server-rounds = 3
 
-[flower.engine]
-name = "simulation"
+[tool.flwr.federations]
+default = "local-simulation"
 
-[flower.engine.simulation.supernode]
-num = 2
+[tool.flwr.federations.local-simulation]
+options.num-supernodes = 10