flwr-nightly 1.9.0.dev20240507__tar.gz → 1.9.0.dev20240520__tar.gz

{flwr_nightly-1.9.0.dev20240507 → flwr_nightly-1.9.0.dev20240520}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: flwr-nightly
-Version: 1.9.0.dev20240507
+Version: 1.9.0.dev20240520
 Summary: Flower: A Friendly Federated Learning Framework
 Home-page: https://flower.ai
 License: Apache-2.0
@@ -202,6 +202,7 @@ Other [examples](https://github.com/adap/flower/tree/main/examples):
 - [Comprehensive Flower+XGBoost](https://github.com/adap/flower/tree/main/examples/xgboost-comprehensive)
 - [Flower through Docker Compose and with Grafana dashboard](https://github.com/adap/flower/tree/main/examples/flower-via-docker-compose)
 - [Flower with KaplanMeierFitter from the lifelines library](https://github.com/adap/flower/tree/main/examples/federated-kaplna-meier-fitter)
+- [Sample Level Privacy with Opacus](https://github.com/adap/flower/tree/main/examples/opacus)
 
 ## Community
 

{flwr_nightly-1.9.0.dev20240507 → flwr_nightly-1.9.0.dev20240520}/README.md

@@ -151,6 +151,7 @@ Other [examples](https://github.com/adap/flower/tree/main/examples):
 - [Comprehensive Flower+XGBoost](https://github.com/adap/flower/tree/main/examples/xgboost-comprehensive)
 - [Flower through Docker Compose and with Grafana dashboard](https://github.com/adap/flower/tree/main/examples/flower-via-docker-compose)
 - [Flower with KaplanMeierFitter from the lifelines library](https://github.com/adap/flower/tree/main/examples/federated-kaplna-meier-fitter)
+- [Sample Level Privacy with Opacus](https://github.com/adap/flower/tree/main/examples/opacus)
 
 ## Community
 

{flwr_nightly-1.9.0.dev20240507 → flwr_nightly-1.9.0.dev20240520}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "flwr-nightly"
-version = "1.9.0.dev20240507"
+version = "1.9.0.dev20240520"
 description = "Flower: A Friendly Federated Learning Framework"
 license = "Apache-2.0"
 authors = ["The Flower Authors <hello@flower.ai>"]

{flwr_nightly-1.9.0.dev20240507 → flwr_nightly-1.9.0.dev20240520}/src/py/flwr/cli/new/new.py

@@ -37,6 +37,8 @@ class MlFramework(str, Enum):
     NUMPY = "NumPy"
     PYTORCH = "PyTorch"
     TENSORFLOW = "TensorFlow"
+    JAX = "JAX"
+    HUGGINGFACE = "HF"
     MLX = "MLX"
     SKLEARN = "sklearn"
 
@@ -154,6 +156,8 @@ def new(
     # Depending on the framework, generate task.py file
     frameworks_with_tasks = [
         MlFramework.PYTORCH.value.lower(),
+        MlFramework.JAX.value.lower(),
+        MlFramework.HUGGINGFACE.value.lower(),
         MlFramework.MLX.value.lower(),
         MlFramework.TENSORFLOW.value.lower(),
     ]

flwr_nightly-1.9.0.dev20240520/src/py/flwr/cli/new/templates/app/code/client.hf.py.tpl

@@ -0,0 +1,55 @@
+"""$project_name: A Flower / HuggingFace Transformers app."""
+
+from flwr.client import ClientApp, NumPyClient
+from transformers import AutoModelForSequenceClassification
+
+from $import_name.task import (
+    get_weights,
+    load_data,
+    set_weights,
+    train,
+    test,
+    CHECKPOINT,
+    DEVICE,
+)
+
+
+# Flower client
+class FlowerClient(NumPyClient):
+    def __init__(self, net, trainloader, testloader):
+        self.net = net
+        self.trainloader = trainloader
+        self.testloader = testloader
+
+    def get_parameters(self, config):
+        return get_weights(self.net)
+
+    def set_parameters(self, parameters):
+        set_weights(self.net, parameters)
+
+    def fit(self, parameters, config):
+        self.set_parameters(parameters)
+        train(self.net, self.trainloader, epochs=1)
+        return self.get_parameters(config={}), len(self.trainloader), {}
+
+    def evaluate(self, parameters, config):
+        self.set_parameters(parameters)
+        loss, accuracy = test(self.net, self.testloader)
+        return float(loss), len(self.testloader), {"accuracy": accuracy}
+
+
+def client_fn(cid):
+    # Load model and data
+    net = AutoModelForSequenceClassification.from_pretrained(
+        CHECKPOINT, num_labels=2
+    ).to(DEVICE)
+    trainloader, valloader = load_data(int(cid), 2)
+
+    # Return Client instance
+    return FlowerClient(net, trainloader, valloader).to_client()
+
+
+# Flower ClientApp
+app = ClientApp(
+    client_fn,
+)

flwr_nightly-1.9.0.dev20240520/src/py/flwr/cli/new/templates/app/code/client.jax.py.tpl

@@ -0,0 +1,55 @@
+"""$project_name: A Flower / JAX app."""
+
+import jax
+from flwr.client import NumPyClient, ClientApp
+
+from $import_name.task import (
+    evaluation,
+    get_params,
+    load_data,
+    load_model,
+    loss_fn,
+    set_params,
+    train,
+)
+
+
+# Define Flower Client and client_fn
+class FlowerClient(NumPyClient):
+    def __init__(self):
+        self.train_x, self.train_y, self.test_x, self.test_y = load_data()
+        self.grad_fn = jax.grad(loss_fn)
+        model_shape = self.train_x.shape[1:]
+
+        self.params = load_model(model_shape)
+
+    def get_parameters(self, config):
+        return get_params(self.params)
+
+    def set_parameters(self, parameters):
+        set_params(self.params, parameters)
+
+    def fit(self, parameters, config):
+        self.set_parameters(parameters)
+        self.params, loss, num_examples = train(
+            self.params, self.grad_fn, self.train_x, self.train_y
+        )
+        parameters = self.get_parameters(config={})
+        return parameters, num_examples, {"loss": float(loss)}
+
+    def evaluate(self, parameters, config):
+        self.set_parameters(parameters)
+        loss, num_examples = evaluation(
+            self.params, self.grad_fn, self.test_x, self.test_y
+        )
+        return float(loss), num_examples, {"loss": float(loss)}
+
+def client_fn(cid):
+    # Return Client instance
+    return FlowerClient().to_client()
+
+
+# Flower ClientApp
+app = ClientApp(
+    client_fn,
+)

flwr_nightly-1.9.0.dev20240520/src/py/flwr/cli/new/templates/app/code/server.hf.py.tpl

@@ -0,0 +1,17 @@
+"""$project_name: A Flower / HuggingFace Transformers app."""
+
+from flwr.server.strategy import FedAvg
+from flwr.server import ServerApp, ServerConfig
+
+
+# Define strategy
+strategy = FedAvg(
+    fraction_fit=1.0,
+    fraction_evaluate=1.0,
+)
+
+# Start server
+app = ServerApp(
+    config=ServerConfig(num_rounds=3),
+    strategy=strategy,
+)

flwr_nightly-1.9.0.dev20240520/src/py/flwr/cli/new/templates/app/code/server.jax.py.tpl

@@ -0,0 +1,12 @@
+"""$project_name: A Flower / JAX app."""
+
+import flwr as fl
+
+# Configure the strategy
+strategy = fl.server.strategy.FedAvg()
+
+# Flower ServerApp
+app = fl.server.ServerApp(
+    config=fl.server.ServerConfig(num_rounds=3),
+    strategy=strategy,
+)

flwr_nightly-1.9.0.dev20240520/src/py/flwr/cli/new/templates/app/code/task.hf.py.tpl

@@ -0,0 +1,87 @@
+"""$project_name: A Flower / HuggingFace Transformers app."""
+
+import warnings
+from collections import OrderedDict
+
+import torch
+from evaluate import load as load_metric
+from torch.optim import AdamW
+from torch.utils.data import DataLoader
+from transformers import AutoTokenizer, DataCollatorWithPadding
+
+from flwr_datasets import FederatedDataset
+
+warnings.filterwarnings("ignore", category=UserWarning)
+DEVICE = torch.device("cpu")
+CHECKPOINT = "distilbert-base-uncased"  # transformer model checkpoint
+
+
+def load_data(partition_id, num_clients):
+    """Load IMDB data (training and eval)"""
+    fds = FederatedDataset(dataset="imdb", partitioners={"train": num_clients})
+    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)
+
+    tokenizer = AutoTokenizer.from_pretrained(CHECKPOINT)
+
+    def tokenize_function(examples):
+        return tokenizer(examples["text"], truncation=True)
+
+    partition_train_test = partition_train_test.map(tokenize_function, batched=True)
+    partition_train_test = partition_train_test.remove_columns("text")
+    partition_train_test = partition_train_test.rename_column("label", "labels")
+
+    data_collator = DataCollatorWithPadding(tokenizer=tokenizer)
+    trainloader = DataLoader(
+        partition_train_test["train"],
+        shuffle=True,
+        batch_size=32,
+        collate_fn=data_collator,
+    )
+
+    testloader = DataLoader(
+        partition_train_test["test"], batch_size=32, collate_fn=data_collator
+    )
+
+    return trainloader, testloader
+
+
+def train(net, trainloader, epochs):
+    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()}
+            outputs = net(**batch)
+            loss = outputs.loss
+            loss.backward()
+            optimizer.step()
+            optimizer.zero_grad()
+
+
+def test(net, testloader):
+    metric = load_metric("accuracy")
+    loss = 0
+    net.eval()
+    for batch in testloader:
+        batch = {k: v.to(DEVICE) for k, v in batch.items()}
+        with torch.no_grad():
+            outputs = net(**batch)
+        logits = outputs.logits
+        loss += outputs.loss.item()
+        predictions = torch.argmax(logits, dim=-1)
+        metric.add_batch(predictions=predictions, references=batch["labels"])
+    loss /= len(testloader.dataset)
+    accuracy = metric.compute()["accuracy"]
+    return loss, accuracy
+
+
+def get_weights(net):
+    return [val.cpu().numpy() for _, val in net.state_dict().items()]
+
+
+def set_weights(net, parameters):
+    params_dict = zip(net.state_dict().keys(), parameters)
+    state_dict = OrderedDict({k: torch.tensor(v) for k, v in params_dict})
+    net.load_state_dict(state_dict, strict=True)

flwr_nightly-1.9.0.dev20240520/src/py/flwr/cli/new/templates/app/code/task.jax.py.tpl

@@ -0,0 +1,57 @@
+"""$project_name: A Flower / JAX app."""
+
+import jax
+import jax.numpy as jnp
+from sklearn.datasets import make_regression
+from sklearn.model_selection import train_test_split
+import numpy as np
+
+key = jax.random.PRNGKey(0)
+
+
+def load_data():
+    # Load dataset
+    X, y = make_regression(n_features=3, random_state=0)
+    X, X_test, y, y_test = train_test_split(X, y)
+    return X, y, X_test, y_test
+
+
+def load_model(model_shape):
+    # Extract model parameters
+    params = {"b": jax.random.uniform(key), "w": jax.random.uniform(key, model_shape)}
+    return params
+
+
+def loss_fn(params, X, y):
+    # Return MSE as loss
+    err = jnp.dot(X, params["w"]) + params["b"] - y
+    return jnp.mean(jnp.square(err))
+
+
+def train(params, grad_fn, X, y):
+    loss = 1_000_000
+    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)
+        loss = loss_fn(params, X, y)
+    return params, loss, num_examples
+
+
+def evaluation(params, grad_fn, X_test, y_test):
+    num_examples = X_test.shape[0]
+    err_test = loss_fn(params, X_test, y_test)
+    loss_test = jnp.mean(jnp.square(err_test))
+    return loss_test, num_examples
+
+
+def get_params(params):
+    parameters = []
+    for _, val in params.items():
+        parameters.append(np.array(val))
+    return parameters
+
+
+def set_params(local_params, global_params):
+    for key, value in list(zip(local_params.keys(), global_params)):
+        local_params[key] = value

flwr_nightly-1.9.0.dev20240520/src/py/flwr/cli/new/templates/app/pyproject.hf.toml.tpl

@@ -0,0 +1,31 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "$package_name"
+version = "1.0.0"
+description = ""
+authors = [
+    { name = "The Flower Authors", email = "hello@flower.ai" },
+]
+license = { text = "Apache License (2.0)" }
+dependencies = [
+    "flwr[simulation]>=1.8.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 = ["."]
+
+[flower]
+publisher = "$username"
+
+[flower.components]
+serverapp = "$import_name.server:app"
+clientapp = "$import_name.client:app"

flwr_nightly-1.9.0.dev20240520/src/py/flwr/cli/new/templates/app/pyproject.jax.toml.tpl

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "$package_name"
+version = "1.0.0"
+description = ""
+authors = [
+    { name = "The Flower Authors", email = "hello@flower.ai" },
+]
+license = {text = "Apache License (2.0)"}
+dependencies = [
+    "flwr[simulation]>=1.8.0,<2.0",
+    "jax==0.4.26",
+    "jaxlib==0.4.26",
+    "scikit-learn==1.4.2",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["."]
+
+[flower]
+publisher = "$username"
+
+[flower.components]
+serverapp = "$import_name.server:app"
+clientapp = "$import_name.client:app"

{flwr_nightly-1.9.0.dev20240507 → flwr_nightly-1.9.0.dev20240520}/src/py/flwr/client/mod/comms_mods.py

@@ -29,7 +29,7 @@ def message_size_mod(
 ) -> Message:
     """Message size mod.
 
-    This mod logs the size in Bytes of the message being transmited.
+    This mod logs the size in bytes of the message being transmited.
     """
     message_size_in_bytes = 0
 
@@ -42,7 +42,7 @@ def message_size_mod(
     for m_record in msg.content.metrics_records.values():
         message_size_in_bytes += m_record.count_bytes()
 
-    log(INFO, "Message size: %i Bytes", message_size_in_bytes)
+    log(INFO, "Message size: %i bytes", message_size_in_bytes)
 
     return call_next(msg, ctxt)
 
@@ -53,7 +53,7 @@ def parameters_size_mod(
     """Parameters size mod.
 
     This mod logs the number of parameters transmitted in the message as well as their
-    size in Bytes.
+    size in bytes.
     """
     model_size_stats = {}
     parameters_size_in_bytes = 0
@@ -74,6 +74,6 @@ def parameters_size_mod(
     if model_size_stats:
         log(INFO, model_size_stats)
 
-    log(INFO, "Total parameters transmited: %i Bytes", parameters_size_in_bytes)
+    log(INFO, "Total parameters transmitted: %i bytes", parameters_size_in_bytes)
 
     return call_next(msg, ctxt)

{flwr_nightly-1.9.0.dev20240507 → flwr_nightly-1.9.0.dev20240520}/src/py/flwr/client/mod/localdp_mod.py

@@ -145,8 +145,7 @@ class LocalDpMod:
         )
         log(
             INFO,
-            "LocalDpMod: local DP noise with "
-            "standard deviation: %.4f added to parameters.",
+            "LocalDpMod: local DP noise with %.4f stedv added to parameters",
             noise_value_sd,
         )
 

{flwr_nightly-1.9.0.dev20240507 → flwr_nightly-1.9.0.dev20240520}/src/py/flwr/server/__init__.py

@@ -24,7 +24,6 @@ from .app import start_server as start_server
 from .client_manager import ClientManager as ClientManager
 from .client_manager import SimpleClientManager as SimpleClientManager
 from .compat import LegacyContext as LegacyContext
-from .compat import start_driver as start_driver
 from .driver import Driver as Driver
 from .history import History as History
 from .run_serverapp import run_server_app as run_server_app
@@ -45,7 +44,6 @@ __all__ = [
     "ServerApp",
     "ServerConfig",
     "SimpleClientManager",
-    "start_driver",
     "start_server",
     "strategy",
     "workflow",

{flwr_nightly-1.9.0.dev20240507 → flwr_nightly-1.9.0.dev20240520}/src/py/flwr/server/app.py

@@ -41,7 +41,7 @@ from flwr.common.constant import (
     TRANSPORT_TYPE_VCE,
 )
 from flwr.common.exit_handlers import register_exit_handlers
-from flwr.common.logger import log
+from flwr.common.logger import log, warn_deprecated_feature
 from flwr.common.secure_aggregation.crypto.symmetric_encryption import (
     private_key_to_bytes,
     public_key_to_bytes,
@@ -196,6 +196,9 @@ def start_server(  # pylint: disable=too-many-arguments,too-many-locals
 def run_driver_api() -> None:
     """Run Flower server (Driver API)."""
     log(INFO, "Starting Flower server (Driver API)")
+    # Running `flower-driver-api` is deprecated
+    warn_deprecated_feature("flower-driver-api")
+    log(WARN, "Use `flower-superlink` instead")
     event(EventType.RUN_DRIVER_API_ENTER)
     args = _parse_args_run_driver_api().parse_args()
 
@@ -233,6 +236,9 @@ def run_driver_api() -> None:
 def run_fleet_api() -> None:
     """Run Flower server (Fleet API)."""
     log(INFO, "Starting Flower server (Fleet API)")
+    # Running `flower-fleet-api` is deprecated
+    warn_deprecated_feature("flower-fleet-api")
+    log(WARN, "Use `flower-superlink` instead")
     event(EventType.RUN_FLEET_API_ENTER)
     args = _parse_args_run_fleet_api().parse_args()
 

{flwr_nightly-1.9.0.dev20240507 → flwr_nightly-1.9.0.dev20240520}/src/py/flwr/server/compat/app.py

@@ -15,50 +15,35 @@
 """Flower driver app."""
 
 
-import sys
 from logging import INFO
-from pathlib import Path
-from typing import Optional, Union
+from typing import Optional
 
 from flwr.common import EventType, event
-from flwr.common.address import parse_address
-from flwr.common.logger import log, warn_deprecated_feature
+from flwr.common.logger import log
 from flwr.server.client_manager import ClientManager
 from flwr.server.history import History
 from flwr.server.server import Server, init_defaults, run_fl
 from flwr.server.server_config import ServerConfig
 from flwr.server.strategy import Strategy
 
-from ..driver import Driver, GrpcDriver
+from ..driver import Driver
 from .app_utils import start_update_client_manager_thread
 
-DEFAULT_SERVER_ADDRESS_DRIVER = "[::]:9091"
-
-ERROR_MESSAGE_DRIVER_NOT_CONNECTED = """
-[Driver] Error: Not connected.
-
-Call `connect()` on the `Driver` instance before calling any of the other `Driver`
-methods.
-"""
-
 
 def start_driver(  # pylint: disable=too-many-arguments, too-many-locals
     *,
-    server_address: str = DEFAULT_SERVER_ADDRESS_DRIVER,
+    driver: Driver,
     server: Optional[Server] = None,
     config: Optional[ServerConfig] = None,
     strategy: Optional[Strategy] = None,
     client_manager: Optional[ClientManager] = None,
-    root_certificates: Optional[Union[bytes, str]] = None,
-    driver: Optional[Driver] = None,
 ) -> History:
     """Start a Flower Driver API server.
 
     Parameters
     ----------
-    server_address : Optional[str]
-        The IPv4 or IPv6 address of the Driver API server.
-        Defaults to `"[::]:8080"`.
+    driver : Driver
+        The Driver object to use.
     server : Optional[flwr.server.Server] (default: None)
         A server implementation, either `flwr.server.Server` or a subclass
         thereof. If no instance is provided, then `start_driver` will create
@@ -74,50 +59,14 @@ def start_driver(  # pylint: disable=too-many-arguments, too-many-locals
         An implementation of the class `flwr.server.ClientManager`. If no
         implementation is provided, then `start_driver` will use
         `flwr.server.SimpleClientManager`.
-    root_certificates : Optional[Union[bytes, str]] (default: None)
-        The PEM-encoded root certificates as a byte string or a path string.
-        If provided, a secure connection using the certificates will be
-        established to an SSL-enabled Flower server.
-    driver : Optional[Driver] (default: None)
-        The Driver object to use.
 
     Returns
     -------
     hist : flwr.server.history.History
         Object containing training and evaluation metrics.
-
-    Examples
-    --------
-    Starting a driver that connects to an insecure server:
-
-    >>> start_driver()
-
-    Starting a driver that connects to an SSL-enabled server:
-
-    >>> start_driver(
-    >>>     root_certificates=Path("/crts/root.pem").read_bytes()
-    >>> )
     """
     event(EventType.START_DRIVER_ENTER)
 
-    if driver is None:
-        # Not passing a `Driver` object is deprecated
-        warn_deprecated_feature("start_driver")
-
-        # Parse IP address
-        parsed_address = parse_address(server_address)
-        if not parsed_address:
-            sys.exit(f"Server IP address ({server_address}) cannot be parsed.")
-        host, port, is_v6 = parsed_address
-        address = f"[{host}]:{port}" if is_v6 else f"{host}:{port}"
-
-        # Create the Driver
-        if isinstance(root_certificates, str):
-            root_certificates = Path(root_certificates).read_bytes()
-        driver = GrpcDriver(
-            driver_service_address=address, root_certificates=root_certificates
-        )
-
     # Initialize the Driver API server and config
     initialized_server, initialized_config = init_defaults(
         server=server,

{flwr_nightly-1.9.0.dev20240507 → flwr_nightly-1.9.0.dev20240520}/src/py/flwr/server/driver/__init__.py

@@ -16,10 +16,11 @@
 
 
 from .driver import Driver
-from .grpc_driver import GrpcDriver, GrpcDriverHelper
+from .grpc_driver import GrpcDriver
+from .inmemory_driver import InMemoryDriver
 
 __all__ = [
     "Driver",
     "GrpcDriver",
-    "GrpcDriverHelper",
+    "InMemoryDriver",
 ]