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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: flwr-nightly
-Version: 1.9.0.dev20240509
+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.dev20240509 → 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.dev20240509 → 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.dev20240509"
+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.dev20240509 → flwr_nightly-1.9.0.dev20240520}/src/py/flwr/cli/new/new.py

@@ -37,6 +37,7 @@ class MlFramework(str, Enum):
     NUMPY = "NumPy"
     PYTORCH = "PyTorch"
     TENSORFLOW = "TensorFlow"
+    JAX = "JAX"
     HUGGINGFACE = "HF"
     MLX = "MLX"
     SKLEARN = "sklearn"
@@ -155,6 +156,7 @@ 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.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.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.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.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.dev20240509 → 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.dev20240509 → 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.dev20240509 → 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",
 ]

flwr_nightly-1.9.0.dev20240520/src/py/flwr/server/driver/inmemory_driver.py

@@ -0,0 +1,181 @@
+# Copyright 2024 Flower Labs GmbH. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Flower in-memory Driver."""
+
+
+import time
+import warnings
+from typing import Iterable, List, Optional
+from uuid import UUID
+
+from flwr.common import DEFAULT_TTL, Message, Metadata, RecordSet
+from flwr.common.serde import message_from_taskres, message_to_taskins
+from flwr.proto.node_pb2 import Node  # pylint: disable=E0611
+from flwr.server.superlink.state import StateFactory
+
+from .driver import Driver
+
+
+class InMemoryDriver(Driver):
+    """`InMemoryDriver` class provides an interface to the Driver API.
+
+    Parameters
+    ----------
+    state_factory : StateFactory
+        A StateFactory embedding a state that this driver can interface with.
+    fab_id : str (default: None)
+        The identifier of the FAB used in the run.
+    fab_version : str (default: None)
+        The version of the FAB used in the run.
+    """
+
+    def __init__(
+        self,
+        state_factory: StateFactory,
+        fab_id: Optional[str] = None,
+        fab_version: Optional[str] = None,
+    ) -> None:
+        self.run_id: Optional[int] = None
+        self.fab_id = fab_id if fab_id is not None else ""
+        self.fab_version = fab_version if fab_version is not None else ""
+        self.node = Node(node_id=0, anonymous=True)
+        self.state = state_factory.state()
+
+    def _check_message(self, message: Message) -> None:
+        # Check if the message is valid
+        if not (
+            message.metadata.run_id == self.run_id
+            and message.metadata.src_node_id == self.node.node_id
+            and message.metadata.message_id == ""
+            and message.metadata.reply_to_message == ""
+            and message.metadata.ttl > 0
+        ):
+            raise ValueError(f"Invalid message: {message}")
+
+    def _get_run_id(self) -> int:
+        """Return run_id.
+
+        If unset, create a new run.
+        """
+        if self.run_id is None:
+            self.run_id = self.state.create_run(
+                fab_id=self.fab_id, fab_version=self.fab_version
+            )
+        return self.run_id
+
+    def create_message(  # pylint: disable=too-many-arguments
+        self,
+        content: RecordSet,
+        message_type: str,
+        dst_node_id: int,
+        group_id: str,
+        ttl: Optional[float] = None,
+    ) -> Message:
+        """Create a new message with specified parameters.
+
+        This method constructs a new `Message` with given content and metadata.
+        The `run_id` and `src_node_id` will be set automatically.
+        """
+        run_id = self._get_run_id()
+        if ttl:
+            warnings.warn(
+                "A custom TTL was set, but note that the SuperLink does not enforce "
+                "the TTL yet. The SuperLink will start enforcing the TTL in a future "
+                "version of Flower.",
+                stacklevel=2,
+            )
+        ttl_ = DEFAULT_TTL if ttl is None else ttl
+
+        metadata = Metadata(
+            run_id=run_id,
+            message_id="",  # Will be set by the server
+            src_node_id=self.node.node_id,
+            dst_node_id=dst_node_id,
+            reply_to_message="",
+            group_id=group_id,
+            ttl=ttl_,
+            message_type=message_type,
+        )
+        return Message(metadata=metadata, content=content)
+
+    def get_node_ids(self) -> List[int]:
+        """Get node IDs."""
+        run_id = self._get_run_id()
+        return list(self.state.get_nodes(run_id))
+
+    def push_messages(self, messages: Iterable[Message]) -> Iterable[str]:
+        """Push messages to specified node IDs.
+
+        This method takes an iterable of messages and sends each message
+        to the node specified in `dst_node_id`.
+        """
+        task_ids: List[str] = []
+        for msg in messages:
+            # Check message
+            self._check_message(msg)
+            # Convert Message to TaskIns
+            taskins = message_to_taskins(msg)
+            # Store in state
+            taskins.task.pushed_at = time.time()
+            task_id = self.state.store_task_ins(taskins)
+            if task_id:
+                task_ids.append(str(task_id))
+
+        return task_ids
+
+    def pull_messages(self, message_ids: Iterable[str]) -> Iterable[Message]:
+        """Pull messages based on message IDs.
+
+        This method is used to collect messages from the SuperLink that correspond to a
+        set of given message IDs.
+        """
+        msg_ids = {UUID(msg_id) for msg_id in message_ids}
+        # Pull TaskRes
+        task_res_list = self.state.get_task_res(task_ids=msg_ids, limit=len(msg_ids))
+        # Delete tasks in state
+        self.state.delete_tasks(msg_ids)
+        # Convert TaskRes to Message
+        msgs = [message_from_taskres(taskres) for taskres in task_res_list]
+        return msgs
+
+    def send_and_receive(
+        self,
+        messages: Iterable[Message],
+        *,
+        timeout: Optional[float] = None,
+    ) -> Iterable[Message]:
+        """Push messages to specified node IDs and pull the reply messages.
+
+        This method sends a list of messages to their destination node IDs and then
+        waits for the replies. It continues to pull replies until either all replies are
+        received or the specified timeout duration is exceeded.
+        """
+        # Push messages
+        msg_ids = set(self.push_messages(messages))
+
+        # Pull messages
+        end_time = time.time() + (timeout if timeout is not None else 0.0)
+        ret: List[Message] = []
+        while timeout is None or time.time() < end_time:
+            res_msgs = self.pull_messages(msg_ids)
+            ret.extend(res_msgs)
+            msg_ids.difference_update(
+                {msg.metadata.reply_to_message for msg in res_msgs}
+            )
+            if len(msg_ids) == 0:
+                break
+            # Sleep
+            time.sleep(3)
+        return ret

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

@@ -282,7 +282,14 @@ class Server:
         get_parameters_res = random_client.get_parameters(
             ins=ins, timeout=timeout, group_id=server_round
         )
-        log(INFO, "Received initial parameters from one random client")
+        if get_parameters_res.status.code == Code.OK:
+            log(INFO, "Received initial parameters from one random client")
+        else:
+            log(
+                WARN,
+                "Failed to receive initial parameters from the client."
+                " Empty initial parameters will be used.",
+            )
         return get_parameters_res.parameters
 
 
@@ -486,7 +493,7 @@ def run_fl(
 
     log(INFO, "")
     log(INFO, "[SUMMARY]")
-    log(INFO, "Run finished %s rounds in %.2fs", config.num_rounds, elapsed_time)
+    log(INFO, "Run finished %s round(s) in %.2fs", config.num_rounds, elapsed_time)
     for line in io.StringIO(str(hist)):
         log(INFO, "\t%s", line.strip("\n"))
     log(INFO, "")

{flwr_nightly-1.9.0.dev20240509 → flwr_nightly-1.9.0.dev20240520}/src/py/flwr/server/strategy/dp_adaptive_clipping.py

@@ -234,8 +234,7 @@ class DifferentialPrivacyServerSideAdaptiveClipping(Strategy):
             )
             log(
                 INFO,
-                "aggregate_fit: central DP noise with "
-                "standard deviation: %.4f added to parameters.",
+                "aggregate_fit: central DP noise with %.4f stdev added",
                 compute_stdv(
                     self.noise_multiplier, self.clipping_norm, self.num_sampled_clients
                 ),
@@ -425,8 +424,7 @@ class DifferentialPrivacyClientSideAdaptiveClipping(Strategy):
             )
             log(
                 INFO,
-                "aggregate_fit: central DP noise with "
-                "standard deviation: %.4f added to parameters.",
+                "aggregate_fit: central DP noise with %.4f stdev added",
                 compute_stdv(
                     self.noise_multiplier, self.clipping_norm, self.num_sampled_clients
                 ),

{flwr_nightly-1.9.0.dev20240509 → flwr_nightly-1.9.0.dev20240520}/src/py/flwr/server/strategy/dp_fixed_clipping.py

@@ -180,8 +180,7 @@ class DifferentialPrivacyServerSideFixedClipping(Strategy):
 
             log(
                 INFO,
-                "aggregate_fit: central DP noise with "
-                "standard deviation: %.4f added to parameters.",
+                "aggregate_fit: central DP noise with %.4f stdev added",
                 compute_stdv(
                     self.noise_multiplier, self.clipping_norm, self.num_sampled_clients
                 ),
@@ -338,8 +337,7 @@ class DifferentialPrivacyClientSideFixedClipping(Strategy):
             )
             log(
                 INFO,
-                "aggregate_fit: central DP noise with "
-                "standard deviation: %.4f added to parameters.",
+                "aggregate_fit: central DP noise with %.4f stdev added",
                 compute_stdv(
                     self.noise_multiplier, self.clipping_norm, self.num_sampled_clients
                 ),

{flwr_nightly-1.9.0.dev20240509 → flwr_nightly-1.9.0.dev20240520}/src/py/flwr/server/superlink/driver/driver_servicer.py

@@ -16,7 +16,7 @@
 
 
 import time
-from logging import DEBUG, INFO
+from logging import DEBUG
 from typing import List, Optional, Set
 from uuid import UUID
 
@@ -62,7 +62,7 @@ class DriverServicer(driver_pb2_grpc.DriverServicer):
         self, request: CreateRunRequest, context: grpc.ServicerContext
     ) -> CreateRunResponse:
         """Create run ID."""
-        log(INFO, "DriverServicer.CreateRun")
+        log(DEBUG, "DriverServicer.CreateRun")
         state: State = self.state_factory.state()
         run_id = state.create_run(request.fab_id, request.fab_version)
         return CreateRunResponse(run_id=run_id)

{flwr_nightly-1.9.0.dev20240509 → flwr_nightly-1.9.0.dev20240520}/src/py/flwr/server/superlink/fleet/vce/backend/raybackend.py

@@ -15,7 +15,7 @@
 """Ray backend for the Fleet API using the Simulation Engine."""
 
 import pathlib
-from logging import DEBUG, ERROR, INFO, WARNING
+from logging import DEBUG, ERROR, WARNING
 from typing import Callable, Dict, List, Tuple, Union
 
 import ray
@@ -45,7 +45,7 @@ class RayBackend(Backend):
         work_dir: str,
     ) -> None:
         """Prepare RayBackend by initialising Ray and creating the ActorPool."""
-        log(INFO, "Initialising: %s", self.__class__.__name__)
+        log(DEBUG, "Initialising: %s", self.__class__.__name__)
         log(DEBUG, "Backend config: %s", backend_config)
 
         if not pathlib.Path(work_dir).exists():
@@ -55,7 +55,12 @@ class RayBackend(Backend):
         runtime_env = (
             self._configure_runtime_env(work_dir=work_dir) if work_dir else None
         )
-        if backend_config.get("silent", False):
+
+        if backend_config.get("mute_logging", False):
+            init_ray(
+                logging_level=WARNING, log_to_driver=False, runtime_env=runtime_env
+            )
+        elif backend_config.get("silent", False):
             init_ray(logging_level=WARNING, log_to_driver=True, runtime_env=runtime_env)
         else:
             init_ray(runtime_env=runtime_env)

{flwr_nightly-1.9.0.dev20240509 → flwr_nightly-1.9.0.dev20240520}/src/py/flwr/server/superlink/fleet/vce/vce_api.py

@@ -46,7 +46,7 @@ def _register_nodes(
     for i in range(num_nodes):
         node_id = state.create_node(ping_interval=PING_MAX_INTERVAL)
         nodes_mapping[node_id] = i
-    log(INFO, "Registered %i nodes", len(nodes_mapping))
+    log(DEBUG, "Registered %i nodes", len(nodes_mapping))
     return nodes_mapping