flwr-nightly 1.11.0.dev20240822__py3-none-any.whl → 1.11.1.dev20240912__py3-none-any.whl

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

@@ -0,0 +1,46 @@
+"""$project_name: A Flower Baseline."""
+
+from typing import List, Tuple
+
+from flwr.common import Context, Metrics, ndarrays_to_parameters
+from flwr.server import ServerApp, ServerAppComponents, ServerConfig
+from flwr.server.strategy import FedAvg
+from $import_name.model import Net, get_weights
+
+
+# Define metric aggregation function
+def weighted_average(metrics: List[Tuple[int, Metrics]]) -> Metrics:
+    """Do weighted average of accuracy metric."""
+    # Multiply accuracy of each client by number of examples used
+    accuracies = [num_examples * float(m["accuracy"]) for num_examples, m in metrics]
+    examples = [num_examples for num_examples, _ in metrics]
+
+    # Aggregate and return custom metric (weighted average)
+    return {"accuracy": sum(accuracies) / sum(examples)}
+
+
+def server_fn(context: Context):
+    """Construct components that set the ServerApp behaviour."""
+    # Read from config
+    num_rounds = context.run_config["num-server-rounds"]
+    fraction_fit = context.run_config["fraction-fit"]
+
+    # Initialize model parameters
+    ndarrays = get_weights(Net())
+    parameters = ndarrays_to_parameters(ndarrays)
+
+    # Define strategy
+    strategy = FedAvg(
+        fraction_fit=float(fraction_fit),
+        fraction_evaluate=1.0,
+        min_available_clients=2,
+        initial_parameters=parameters,
+        evaluate_metrics_aggregation_fn=weighted_average,
+    )
+    config = ServerConfig(num_rounds=int(num_rounds))
+
+    return ServerAppComponents(strategy=strategy, config=config)
+
+
+# Create ServerApp
+app = ServerApp(server_fn=server_fn)

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

@@ -1,18 +1,33 @@
 """$project_name: A Flower / $framework_str app."""
 
-from flwr.common import Context
-from flwr.server.strategy import FedAvg
+from flwr.common import Context, ndarrays_to_parameters
 from flwr.server import ServerApp, ServerAppComponents, ServerConfig
+from flwr.server.strategy import FedAvg
+from transformers import AutoModelForSequenceClassification
+
+from $import_name.task import get_weights
 
 
 def server_fn(context: Context):
     # Read from config
     num_rounds = context.run_config["num-server-rounds"]
+    fraction_fit = context.run_config["fraction-fit"]
+
+    # Initialize global model
+    model_name = context.run_config["model-name"]
+    num_labels = context.run_config["num-labels"]
+    net = AutoModelForSequenceClassification.from_pretrained(
+        model_name, num_labels=num_labels
+    )
+
+    weights = get_weights(net)
+    initial_parameters = ndarrays_to_parameters(weights)
 
     # Define strategy
     strategy = FedAvg(
-        fraction_fit=1.0,
+        fraction_fit=fraction_fit,
         fraction_evaluate=1.0,
+        initial_parameters=initial_parameters,
     )
     config = ServerConfig(num_rounds=num_rounds)
 

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

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

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

@@ -4,24 +4,25 @@ import warnings
 from collections import OrderedDict
 
 import torch
+import transformers
+from datasets.utils.logging import disable_progress_bar
 from evaluate import load as load_metric
+from flwr_datasets import FederatedDataset
+from flwr_datasets.partitioner import IidPartitioner
 from torch.optim import AdamW
 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
+warnings.filterwarnings("ignore", category=FutureWarning)
+disable_progress_bar()
+transformers.logging.set_verbosity_error()
 
 
 fds = None  # Cache FederatedDataset
 
 
-def load_data(partition_id: int, num_partitions: int):
+def load_data(partition_id: int, num_partitions: int, model_name: str):
     """Load IMDB data (training and eval)"""
     # Only initialize `FederatedDataset` once
     global fds
@@ -35,10 +36,12 @@ def load_data(partition_id: int, num_partitions: int):
     # Divide data: 80% train, 20% test
     partition_train_test = partition.train_test_split(test_size=0.2, seed=42)
 
-    tokenizer = AutoTokenizer.from_pretrained(CHECKPOINT)
+    tokenizer = AutoTokenizer.from_pretrained(model_name)
 
     def tokenize_function(examples):
-        return tokenizer(examples["text"], truncation=True)
+        return tokenizer(
+            examples["text"], truncation=True, add_special_tokens=True, max_length=512
+        )
 
     partition_train_test = partition_train_test.map(tokenize_function, batched=True)
     partition_train_test = partition_train_test.remove_columns("text")
@@ -59,12 +62,12 @@ def load_data(partition_id: int, num_partitions: int):
     return trainloader, testloader
 
 
-def train(net, trainloader, epochs):
+def train(net, trainloader, epochs, device):
     optimizer = AdamW(net.parameters(), lr=5e-5)
     net.train()
     for _ in range(epochs):
         for batch in trainloader:
-            batch = {k: v.to(DEVICE) for k, v in batch.items()}
+            batch = {k: v.to(device) for k, v in batch.items()}
             outputs = net(**batch)
             loss = outputs.loss
             loss.backward()
@@ -72,12 +75,12 @@ def train(net, trainloader, epochs):
             optimizer.zero_grad()
 
 
-def test(net, testloader):
+def test(net, testloader, device):
     metric = load_metric("accuracy")
     loss = 0
     net.eval()
     for batch in testloader:
-        batch = {k: v.to(DEVICE) for k, v in batch.items()}
+        batch = {k: v.to(device) for k, v in batch.items()}
         with torch.no_grad():
             outputs = net(**batch)
         logits = outputs.logits

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

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

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

@@ -0,0 +1,138 @@
+[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.11.0",
+    "flwr-datasets[vision]>=0.3.0",
+    "torch==2.2.1",
+    "torchvision==0.17.1",
+]
+
+[tool.hatch.metadata]
+allow-direct-references = true
+
+[project.optional-dependencies]
+dev = [
+    "isort==5.13.2",
+    "black==24.2.0",
+    "docformatter==1.7.5",
+    "mypy==1.8.0",
+    "pylint==3.2.6",
+    "flake8==5.0.4",
+    "pytest==6.2.4",
+    "pytest-watch==4.2.0",
+    "ruff==0.1.9",
+    "types-requests==2.31.0.20240125",
+]
+
+[tool.isort]
+profile = "black"
+known_first_party = ["flwr"]
+
+[tool.black]
+line-length = 88
+target-version = ["py38", "py39", "py310", "py311"]
+
+[tool.pytest.ini_options]
+minversion = "6.2"
+addopts = "-qq"
+testpaths = [
+    "flwr_baselines",
+]
+
+[tool.mypy]
+ignore_missing_imports = true
+strict = false
+plugins = "numpy.typing.mypy_plugin"
+
+[tool.pylint."MESSAGES CONTROL"]
+disable = "duplicate-code,too-few-public-methods,useless-import-alias"
+good-names = "i,j,k,_,x,y,X,Y,K,N"
+max-args = 10
+max-attributes = 15
+max-locals = 36
+max-branches = 20
+max-statements = 55
+
+[tool.pylint.typecheck]
+generated-members = "numpy.*, torch.*, tensorflow.*"
+
+[[tool.mypy.overrides]]
+module = [
+    "importlib.metadata.*",
+    "importlib_metadata.*",
+]
+follow_imports = "skip"
+follow_imports_for_stubs = true
+disallow_untyped_calls = false
+
+[[tool.mypy.overrides]]
+module = "torch.*"
+follow_imports = "skip"
+follow_imports_for_stubs = true
+
+[tool.docformatter]
+wrap-summaries = 88
+wrap-descriptions = 88
+
+[tool.ruff]
+target-version = "py38"
+line-length = 88
+select = ["D", "E", "F", "W", "B", "ISC", "C4"]
+fixable = ["D", "E", "F", "W", "B", "ISC", "C4"]
+ignore = ["B024", "B027"]
+exclude = [
+    ".bzr",
+    ".direnv",
+    ".eggs",
+    ".git",
+    ".hg",
+    ".mypy_cache",
+    ".nox",
+    ".pants.d",
+    ".pytype",
+    ".ruff_cache",
+    ".svn",
+    ".tox",
+    ".venv",
+    "__pypackages__",
+    "_build",
+    "buck-out",
+    "build",
+    "dist",
+    "node_modules",
+    "venv",
+    "proto",
+]
+
+[tool.ruff.pydocstyle]
+convention = "numpy"
+
+[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
+fraction-fit = 0.5
+local-epochs = 1
+
+[tool.flwr.federations]
+default = "local-simulation"
+
+[tool.flwr.federations.local-simulation]
+options.num-supernodes = 10
+options.backend.client-resources.num-cpus = 2
+options.backend.client-resources.num-gpus = 0.0

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

@@ -8,15 +8,15 @@ version = "1.0.0"
 description = ""
 license = "Apache-2.0"
 dependencies = [
-    "flwr[simulation]>=1.9.0,<2.0",
-    "flwr-datasets>=0.1.0,<1.0.0",
-    "hydra-core==1.3.2",
+    "flwr[simulation]>=1.10.0",
+    "flwr-datasets>=0.3.0",
     "trl==0.8.1",
     "bitsandbytes==0.43.0",
     "scipy==1.13.0",
     "peft==0.6.2",
     "transformers==4.39.3",
     "sentencepiece==0.2.0",
+    "omegaconf==2.3.0",
 ]
 
 [tool.hatch.build.targets.wheel]
@@ -26,14 +26,41 @@ packages = ["."]
 publisher = "$username"
 
 [tool.flwr.app.components]
-serverapp = "$import_name.app:server"
-clientapp = "$import_name.app:client"
+serverapp = "$import_name.server_app:app"
+clientapp = "$import_name.client_app:app"
 
 [tool.flwr.app.config]
-num-server-rounds = 3
+model.name = "mistralai/Mistral-7B-v0.3"
+model.quantization = 4
+model.gradient-checkpointing = true
+model.lora.peft-lora-r = 32
+model.lora.peft-lora-alpha = 64
+train.save-every-round = 5
+train.learning-rate-max = 5e-5
+train.learning-rate-min = 1e-6
+train.seq-length = 512
+train.training-arguments.output-dir = ""
+train.training-arguments.learning-rate = ""
+train.training-arguments.per-device-train-batch-size = 16
+train.training-arguments.gradient-accumulation-steps = 1
+train.training-arguments.logging-steps = 10
+train.training-arguments.num-train-epochs = 3
+train.training-arguments.max-steps = 10
+train.training-arguments.save-steps = 1000
+train.training-arguments.save-total-limit = 10
+train.training-arguments.gradient-checkpointing = true
+train.training-arguments.lr-scheduler-type = "constant"
+strategy.fraction-fit = $fraction_fit
+strategy.fraction-evaluate = 0.0
+num-server-rounds = 200
+
+[tool.flwr.app.config.static]
+dataset.name = "$dataset_name"
 
 [tool.flwr.federations]
 default = "local-simulation"
 
 [tool.flwr.federations.local-simulation]
-options.num-supernodes = 10
+options.num-supernodes = $num_clients
+options.backend.client-resources.num-cpus = 6
+options.backend.client-resources.num-gpus = 1.0

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

@@ -8,7 +8,7 @@ version = "1.0.0"
 description = ""
 license = "Apache-2.0"
 dependencies = [
-    "flwr[simulation]>=1.10.0",
+    "flwr[simulation]>=1.11.0",
     "flwr-datasets>=0.3.0",
     "torch==2.2.1",
     "transformers>=4.30.0,<5.0",
@@ -29,10 +29,18 @@ clientapp = "$import_name.client_app:app"
 
 [tool.flwr.app.config]
 num-server-rounds = 3
+fraction-fit = 0.5
 local-epochs = 1
+model-name = "prajjwal1/bert-tiny" # Set a larger model if you have access to more GPU resources
+num-labels = 2
 
 [tool.flwr.federations]
 default = "localhost"
 
 [tool.flwr.federations.localhost]
 options.num-supernodes = 10
+
+[tool.flwr.federations.localhost-gpu]
+options.num-supernodes = 10
+options.backend.client-resources.num-cpus = 4 # each ClientApp assumes to use 4CPUs
+options.backend.client-resources.num-gpus = 0.25 # at most 4 ClientApps will run in a given GPU

flwr/cli/run/run.py

@@ -15,6 +15,7 @@
 """Flower command line interface `run` command."""
 
 import hashlib
+import json
 import subprocess
 import sys
 from logging import DEBUG
@@ -123,14 +124,14 @@ def run(
 
 
 def _run_with_superexec(
-    app: Optional[Path],
+    app: Path,
     federation_config: Dict[str, Any],
     config_overrides: Optional[List[str]],
 ) -> None:
 
     insecure_str = federation_config.get("insecure")
     if root_certificates := federation_config.get("root-certificates"):
-        root_certificates_bytes = Path(root_certificates).read_bytes()
+        root_certificates_bytes = (app / root_certificates).read_bytes()
         if insecure := bool(insecure_str):
             typer.secho(
                 "❌ `root_certificates` were provided but the `insecure` parameter"
@@ -192,6 +193,8 @@ def _run_without_superexec(
 ) -> None:
     try:
         num_supernodes = federation_config["options"]["num-supernodes"]
+        verbose: Optional[bool] = federation_config["options"].get("verbose")
+        backend_cfg = federation_config["options"].get("backend", {})
     except KeyError as err:
         typer.secho(
             "❌ The project's `pyproject.toml` needs to declare the number of"
@@ -212,6 +215,13 @@ def _run_without_superexec(
         f"{num_supernodes}",
     ]
 
+    if backend_cfg:
+        # Stringify as JSON
+        command.extend(["--backend-config", json.dumps(backend_cfg)])
+
+    if verbose:
+        command.extend(["--verbose"])
+
     if config_overrides:
         command.extend(["--run-config", f"{' '.join(config_overrides)}"])
 

flwr/client/__init__.py

@@ -20,8 +20,6 @@ from .app import start_numpy_client as start_numpy_client
 from .client import Client as Client
 from .client_app import ClientApp as ClientApp
 from .numpy_client import NumPyClient as NumPyClient
-from .supernode import run_client_app as run_client_app
-from .supernode import run_supernode as run_supernode
 from .typing import ClientFn as ClientFn
 from .typing import ClientFnExt as ClientFnExt
 
@@ -32,8 +30,6 @@ __all__ = [
     "ClientFnExt",
     "NumPyClient",
     "mod",
-    "run_client_app",
-    "run_supernode",
     "start_client",
     "start_numpy_client",
 ]

flwr/client/app.py

@@ -35,6 +35,7 @@ from flwr.client.typing import ClientFnExt
 from flwr.common import GRPC_MAX_MESSAGE_LENGTH, Context, EventType, Message, event
 from flwr.common.address import parse_address
 from flwr.common.constant import (
+    CLIENTAPPIO_API_DEFAULT_ADDRESS,
     MISSING_EXTRA_REST,
     RUN_ID_NUM_BYTES,
     TRANSPORT_TYPE_GRPC_ADAPTER,
@@ -60,8 +61,6 @@ from .message_handler.message_handler import handle_control_message
 from .node_state import NodeState
 from .numpy_client import NumPyClient
 
-ADDRESS_CLIENTAPPIO_API_GRPC_RERE = "0.0.0.0:9094"
-
 ISOLATION_MODE_SUBPROCESS = "subprocess"
 ISOLATION_MODE_PROCESS = "process"
 
@@ -211,7 +210,7 @@ def start_client_internal(
     max_wait_time: Optional[float] = None,
     flwr_path: Optional[Path] = None,
     isolation: Optional[str] = None,
-    supernode_address: Optional[str] = ADDRESS_CLIENTAPPIO_API_GRPC_RERE,
+    supernode_address: Optional[str] = CLIENTAPPIO_API_DEFAULT_ADDRESS,
 ) -> None:
     """Start a Flower client node which connects to a Flower server.
 
@@ -266,7 +265,7 @@ def start_client_internal(
         by the SueprNode and communicates using gRPC at the address
         `supernode_address`. If `process`, the `ClientApp` runs in a separate isolated
         process and communicates using gRPC at the address `supernode_address`.
-    supernode_address : Optional[str] (default: `ADDRESS_CLIENTAPPIO_API_GRPC_RERE`)
+    supernode_address : Optional[str] (default: `CLIENTAPPIO_API_DEFAULT_ADDRESS`)
         The SuperNode gRPC server address.
     """
     if insecure is None:

flwr/client/client.py

@@ -33,12 +33,13 @@ from flwr.common import (
     Parameters,
     Status,
 )
+from flwr.common.logger import warn_deprecated_feature_with_example
 
 
 class Client(ABC):
     """Abstract base class for Flower clients."""
 
-    context: Context
+    _context: Context
 
     def get_properties(self, ins: GetPropertiesIns) -> GetPropertiesRes:
         """Return set of client's properties.
@@ -141,6 +142,26 @@ class Client(ABC):
             metrics={},
         )
 
+    @property
+    def context(self) -> Context:
+        """Getter for `Context` client attribute."""
+        warn_deprecated_feature_with_example(
+            "Accessing the context via the client's attribute is deprecated.",
+            example_message="Instead, pass it to the client's "
+            "constructor in your `client_fn()` which already "
+            "receives a context object.",
+            code_example="def client_fn(context: Context) -> Client:\n\n"
+            "\t\t# Your existing client_fn\n\n"
+            "\t\t# Pass `context` to the constructor\n"
+            "\t\treturn FlowerClient(context).to_client()",
+        )
+        return self._context
+
+    @context.setter
+    def context(self, context: Context) -> None:
+        """Setter for `Context` client attribute."""
+        self._context = context
+
     def get_context(self) -> Context:
         """Get the run context from this client."""
         return self.context

flwr/client/client_app.py

@@ -41,11 +41,11 @@ def _alert_erroneous_client_fn() -> None:
 
 def _inspect_maybe_adapt_client_fn_signature(client_fn: ClientFnExt) -> ClientFnExt:
     client_fn_args = inspect.signature(client_fn).parameters
-    first_arg = list(client_fn_args.keys())[0]
 
     if len(client_fn_args) != 1:
         _alert_erroneous_client_fn()
 
+    first_arg = list(client_fn_args.keys())[0]
     first_arg_type = client_fn_args[first_arg].annotation
 
     if first_arg_type is str or first_arg == "cid":
@@ -263,7 +263,7 @@ def _registration_error(fn_name: str) -> ValueError:
         >>> class FlowerClient(NumPyClient):
         >>>     # ...
         >>>
-        >>> def client_fn(cid) -> Client:
+        >>> def client_fn(context: Context):
         >>>     return FlowerClient().to_client()
         >>>
         >>> app = ClientApp(

flwr/client/grpc_rere_client/client_interceptor.py

@@ -17,11 +17,13 @@
 
 import base64
 import collections
+from logging import WARNING
 from typing import Any, Callable, Optional, Sequence, Tuple, Union
 
 import grpc
 from cryptography.hazmat.primitives.asymmetric import ec
 
+from flwr.common.logger import log
 from flwr.common.secure_aggregation.crypto.symmetric_encryption import (
     bytes_to_public_key,
     compute_hmac,
@@ -128,13 +130,12 @@ class AuthenticateClientInterceptor(grpc.UnaryUnaryClientInterceptor):  # type:
             if self.shared_secret is None:
                 raise RuntimeError("Failure to compute hmac")
 
+            message_bytes = request.SerializeToString(deterministic=True)
             metadata.append(
                 (
                     _AUTH_TOKEN_HEADER,
                     base64.urlsafe_b64encode(
-                        compute_hmac(
-                            self.shared_secret, request.SerializeToString(True)
-                        )
+                        compute_hmac(self.shared_secret, message_bytes)
                     ),
                 )
             )
@@ -151,8 +152,15 @@ class AuthenticateClientInterceptor(grpc.UnaryUnaryClientInterceptor):  # type:
             server_public_key_bytes = base64.urlsafe_b64decode(
                 _get_value_from_tuples(_PUBLIC_KEY_HEADER, response.initial_metadata())
             )
-            self.server_public_key = bytes_to_public_key(server_public_key_bytes)
-            self.shared_secret = generate_shared_key(
-                self.private_key, self.server_public_key
-            )
+
+            if server_public_key_bytes != b"":
+                self.server_public_key = bytes_to_public_key(server_public_key_bytes)
+            else:
+                log(WARNING, "Can't get server public key, SuperLink may be offline")
+
+            if self.server_public_key is not None:
+                self.shared_secret = generate_shared_key(
+                    self.private_key, self.server_public_key
+                )
+
         return response

flwr/client/numpy_client.py

@@ -27,6 +27,7 @@ from flwr.common import (
     ndarrays_to_parameters,
     parameters_to_ndarrays,
 )
+from flwr.common.logger import warn_deprecated_feature_with_example
 from flwr.common.typing import (
     Code,
     EvaluateIns,
@@ -70,7 +71,7 @@ Example
 class NumPyClient(ABC):
     """Abstract base class for Flower clients using NumPy."""
 
-    context: Context
+    _context: Context
 
     def get_properties(self, config: Config) -> Dict[str, Scalar]:
         """Return a client's set of properties.
@@ -174,6 +175,26 @@ class NumPyClient(ABC):
         _ = (self, parameters, config)
         return 0.0, 0, {}
 
+    @property
+    def context(self) -> Context:
+        """Getter for `Context` client attribute."""
+        warn_deprecated_feature_with_example(
+            "Accessing the context via the client's attribute is deprecated.",
+            example_message="Instead, pass it to the client's "
+            "constructor in your `client_fn()` which already "
+            "receives a context object.",
+            code_example="def client_fn(context: Context) -> Client:\n\n"
+            "\t\t# Your existing client_fn\n\n"
+            "\t\t# Pass `context` to the constructor\n"
+            "\t\treturn FlowerClient(context).to_client()",
+        )
+        return self._context
+
+    @context.setter
+    def context(self, context: Context) -> None:
+        """Setter for `Context` client attribute."""
+        self._context = context
+
     def get_context(self) -> Context:
         """Get the run context from this client."""
         return self.context

flwr/client/rest_client/connection.py

@@ -275,7 +275,7 @@ def http_request_response(  # pylint: disable=,R0913, R0914, R0915
         req = DeleteNodeRequest(node=node)
 
         # Send the request
-        res = _request(req, DeleteNodeResponse, PATH_CREATE_NODE)
+        res = _request(req, DeleteNodeResponse, PATH_DELETE_NODE)
         if res is None:
             return