flwr-nightly 1.8.0.dev20240309__py3-none-any.whl → 1.8.0.dev20240311__py3-none-any.whl

flwr/common/secure_aggregation/secaggplus_constants.py

@@ -19,6 +19,7 @@ from __future__ import annotations
 
 RECORD_KEY_STATE = "secaggplus_state"
 RECORD_KEY_CONFIGS = "secaggplus_configs"
+RATIO_QUANTIZATION_RANGE = 1073741824  # 1 << 30
 
 
 class Stage:
@@ -26,9 +27,9 @@ class Stage:
 
     SETUP = "setup"
     SHARE_KEYS = "share_keys"
-    COLLECT_MASKED_INPUT = "collect_masked_input"
+    COLLECT_MASKED_VECTORS = "collect_masked_vectors"
     UNMASK = "unmask"
-    _stages = (SETUP, SHARE_KEYS, COLLECT_MASKED_INPUT, UNMASK)
+    _stages = (SETUP, SHARE_KEYS, COLLECT_MASKED_VECTORS, UNMASK)
 
     @classmethod
     def all(cls) -> tuple[str, str, str, str]:
@@ -45,12 +46,12 @@ class Key:
 
     STAGE = "stage"
     SAMPLE_NUMBER = "sample_num"
-    SECURE_ID = "secure_id"
     SHARE_NUMBER = "share_num"
     THRESHOLD = "threshold"
     CLIPPING_RANGE = "clipping_range"
     TARGET_RANGE = "target_range"
     MOD_RANGE = "mod_range"
+    MAX_WEIGHT = "max_weight"
     PUBLIC_KEY_1 = "pk1"
     PUBLIC_KEY_2 = "pk2"
     DESTINATION_LIST = "dsts"
@@ -58,9 +59,9 @@ class Key:
     SOURCE_LIST = "srcs"
     PARAMETERS = "params"
     MASKED_PARAMETERS = "masked_params"
-    ACTIVE_SECURE_ID_LIST = "active_sids"
-    DEAD_SECURE_ID_LIST = "dead_sids"
-    SECURE_ID_LIST = "sids"
+    ACTIVE_NODE_ID_LIST = "active_nids"
+    DEAD_NODE_ID_LIST = "dead_nids"
+    NODE_ID_LIST = "nids"
     SHARE_LIST = "shares"
 
     def __new__(cls) -> Key:

flwr/common/secure_aggregation/secaggplus_utils.py

@@ -23,16 +23,16 @@ from flwr.common.typing import NDArrayInt
 
 
 def share_keys_plaintext_concat(
-    source: int, destination: int, b_share: bytes, sk_share: bytes
+    src_node_id: int, dst_node_id: int, b_share: bytes, sk_share: bytes
 ) -> bytes:
     """Combine arguments to bytes.
 
     Parameters
     ----------
-    source : int
-        the secure ID of the source.
-    destination : int
-        the secure ID of the destination.
+    src_node_id : int
+        the node ID of the source.
+    dst_node_id : int
+        the node ID of the destination.
     b_share : bytes
         the private key share of the source sent to the destination.
     sk_share : bytes
@@ -45,8 +45,8 @@ def share_keys_plaintext_concat(
     """
     return b"".join(
         [
-            int.to_bytes(source, 4, "little"),
-            int.to_bytes(destination, 4, "little"),
+            int.to_bytes(src_node_id, 8, "little", signed=True),
+            int.to_bytes(dst_node_id, 8, "little", signed=True),
             int.to_bytes(len(b_share), 4, "little"),
             b_share,
             sk_share,
@@ -64,21 +64,21 @@ def share_keys_plaintext_separate(plaintext: bytes) -> Tuple[int, int, bytes, by
 
     Returns
     -------
-    source : int
-        the secure ID of the source.
-    destination : int
-        the secure ID of the destination.
+    src_node_id : int
+        the node ID of the source.
+    dst_node_id : int
+        the node ID of the destination.
     b_share : bytes
         the private key share of the source sent to the destination.
     sk_share : bytes
         the secret key share of the source sent to the destination.
     """
     src, dst, mark = (
-        int.from_bytes(plaintext[:4], "little"),
-        int.from_bytes(plaintext[4:8], "little"),
-        int.from_bytes(plaintext[8:12], "little"),
+        int.from_bytes(plaintext[:8], "little", signed=True),
+        int.from_bytes(plaintext[8:16], "little", signed=True),
+        int.from_bytes(plaintext[16:20], "little"),
     )
-    ret = (src, dst, plaintext[12 : 12 + mark], plaintext[12 + mark :])
+    ret = (src, dst, plaintext[20 : 20 + mark], plaintext[20 + mark :])
     return ret
 
 

flwr/server/compat/app.py

@@ -127,9 +127,10 @@ def start_driver(  # pylint: disable=too-many-arguments, too-many-locals
     )
     log(
         INFO,
-        "Starting Flower server, config: %s",
+        "Starting Flower ServerApp, config: %s",
         initialized_config,
     )
+    log(INFO, "")
 
     # Start the thread updating nodes
     thread, f_stop = start_update_client_manager_thread(

flwr/server/driver/grpc_driver.py

@@ -15,7 +15,7 @@
 """Flower driver service client."""
 
 
-from logging import ERROR, INFO, WARNING
+from logging import DEBUG, ERROR, WARNING
 from typing import Optional
 
 import grpc
@@ -70,19 +70,19 @@ class GrpcDriver:
             root_certificates=self.root_certificates,
         )
         self.stub = DriverStub(self.channel)
-        log(INFO, "[Driver] Connected to %s", self.driver_service_address)
+        log(DEBUG, "[Driver] Connected to %s", self.driver_service_address)
 
     def disconnect(self) -> None:
         """Disconnect from the Driver API."""
         event(EventType.DRIVER_DISCONNECT)
         if self.channel is None or self.stub is None:
-            log(WARNING, "Already disconnected")
+            log(DEBUG, "Already disconnected")
             return
         channel = self.channel
         self.channel = None
         self.stub = None
         channel.close()
-        log(INFO, "[Driver] Disconnected")
+        log(DEBUG, "[Driver] Disconnected")
 
     def create_run(self, req: CreateRunRequest) -> CreateRunResponse:
         """Request for run ID."""

flwr/server/history.py

@@ -15,6 +15,7 @@
 """Training history."""
 
 
+import pprint
 from functools import reduce
 from typing import Dict, List, Tuple
 
@@ -90,29 +91,35 @@ class History:
         """
         rep = ""
         if self.losses_distributed:
-            rep += "History (loss, distributed):\n" + reduce(
-                lambda a, b: a + b,
-                [
-                    f"\tround {server_round}: {loss}\n"
-                    for server_round, loss in self.losses_distributed
-                ],
+            rep += "History (loss, distributed):\n" + pprint.pformat(
+                reduce(
+                    lambda a, b: a + b,
+                    [
+                        f"\tround {server_round}: {loss}\n"
+                        for server_round, loss in self.losses_distributed
+                    ],
+                )
             )
         if self.losses_centralized:
-            rep += "History (loss, centralized):\n" + reduce(
-                lambda a, b: a + b,
-                [
-                    f"\tround {server_round}: {loss}\n"
-                    for server_round, loss in self.losses_centralized
-                ],
+            rep += "History (loss, centralized):\n" + pprint.pformat(
+                reduce(
+                    lambda a, b: a + b,
+                    [
+                        f"\tround {server_round}: {loss}\n"
+                        for server_round, loss in self.losses_centralized
+                    ],
+                )
             )
         if self.metrics_distributed_fit:
-            rep += "History (metrics, distributed, fit):\n" + str(
+            rep += "History (metrics, distributed, fit):\n" + pprint.pformat(
                 self.metrics_distributed_fit
             )
         if self.metrics_distributed:
-            rep += "History (metrics, distributed, evaluate):\n" + str(
+            rep += "History (metrics, distributed, evaluate):\n" + pprint.pformat(
                 self.metrics_distributed
             )
         if self.metrics_centralized:
-            rep += "History (metrics, centralized):\n" + str(self.metrics_centralized)
+            rep += "History (metrics, centralized):\n" + pprint.pformat(
+                self.metrics_centralized
+            )
         return rep

flwr/server/run_serverapp.py

@@ -17,15 +17,16 @@
 
 import argparse
 import sys
-from logging import DEBUG, WARN
+from logging import DEBUG, INFO, WARN
 from pathlib import Path
 from typing import Optional
 
 from flwr.common import Context, EventType, RecordSet, event
-from flwr.common.logger import log
+from flwr.common.logger import log, update_console_handler
+from flwr.common.object_ref import load_app
 
 from .driver.driver import Driver
-from .server_app import ServerApp, load_server_app
+from .server_app import LoadServerAppError, ServerApp
 
 
 def run(
@@ -47,7 +48,13 @@ def run(
     # Load ServerApp if needed
     def _load() -> ServerApp:
         if server_app_attr:
-            server_app: ServerApp = load_server_app(server_app_attr)
+            server_app: ServerApp = load_app(server_app_attr, LoadServerAppError)
+
+            if not isinstance(server_app, ServerApp):
+                raise LoadServerAppError(
+                    f"Attribute {server_app_attr} is not of type {ServerApp}",
+                ) from None
+
         if loaded_server_app:
             server_app = loaded_server_app
         return server_app
@@ -69,6 +76,12 @@ def run_server_app() -> None:
 
     args = _parse_args_run_server_app().parse_args()
 
+    update_console_handler(
+        level=DEBUG if args.verbose else INFO,
+        timestamps=args.verbose,
+        colored=True,
+    )
+
     # Obtain certificates
     if args.insecure:
         if args.root_certificates is not None:
@@ -146,6 +159,11 @@ def _parse_args_run_server_app() -> argparse.ArgumentParser:
         help="Run the server app without HTTPS. By default, the app runs with "
         "HTTPS enabled. Use this flag only if you understand the risks.",
     )
+    parser.add_argument(
+        "--verbose",
+        action="store_true",
+        help="Set the logging to `DEBUG`.",
+    )
     parser.add_argument(
         "--root-certificates",
         metavar="ROOT_CERT",

flwr/server/server.py

@@ -16,6 +16,7 @@
 
 
 import concurrent.futures
+import io
 import timeit
 from logging import INFO, WARN
 from typing import Dict, List, Optional, Tuple, Union
@@ -83,14 +84,14 @@ class Server:
         return self._client_manager
 
     # pylint: disable=too-many-locals
-    def fit(self, num_rounds: int, timeout: Optional[float]) -> History:
+    def fit(self, num_rounds: int, timeout: Optional[float]) -> Tuple[History, float]:
         """Run federated averaging for a number of rounds."""
         history = History()
 
         # Initialize parameters
-        log(INFO, "Initializing global parameters")
+        log(INFO, "[INIT]")
         self.parameters = self._get_initial_parameters(server_round=0, timeout=timeout)
-        log(INFO, "Evaluating initial parameters")
+        log(INFO, "Evaluating initial global parameters")
         res = self.strategy.evaluate(0, parameters=self.parameters)
         if res is not None:
             log(
@@ -103,10 +104,11 @@ class Server:
             history.add_metrics_centralized(server_round=0, metrics=res[1])
 
         # Run federated learning for num_rounds
-        log(INFO, "FL starting")
         start_time = timeit.default_timer()
 
         for current_round in range(1, num_rounds + 1):
+            log(INFO, "")
+            log(INFO, "[ROUND %s]", current_round)
             # Train model and replace previous global model
             res_fit = self.fit_round(
                 server_round=current_round,
@@ -152,8 +154,7 @@ class Server:
         # Bookkeeping
         end_time = timeit.default_timer()
         elapsed = end_time - start_time
-        log(INFO, "FL finished in %s", elapsed)
-        return history
+        return history, elapsed
 
     def evaluate_round(
         self,
@@ -170,12 +171,11 @@ class Server:
             client_manager=self._client_manager,
         )
         if not client_instructions:
-            log(INFO, "evaluate_round %s: no clients selected, cancel", server_round)
+            log(INFO, "configure_evaluate: no clients selected, skipping evaluation")
             return None
         log(
             INFO,
-            "evaluate_round %s: strategy sampled %s clients (out of %s)",
-            server_round,
+            "configure_evaluate: strategy sampled %s clients (out of %s)",
             len(client_instructions),
             self._client_manager.num_available(),
         )
@@ -189,8 +189,7 @@ class Server:
         )
         log(
             INFO,
-            "evaluate_round %s received %s results and %s failures",
-            server_round,
+            "aggregate_evaluate: received %s results and %s failures",
             len(results),
             len(failures),
         )
@@ -220,12 +219,11 @@ class Server:
         )
 
         if not client_instructions:
-            log(INFO, "fit_round %s: no clients selected, cancel", server_round)
+            log(INFO, "configure_fit: no clients selected, cancel")
             return None
         log(
             INFO,
-            "fit_round %s: strategy sampled %s clients (out of %s)",
-            server_round,
+            "configure_fit: strategy sampled %s clients (out of %s)",
             len(client_instructions),
             self._client_manager.num_available(),
         )
@@ -239,8 +237,7 @@ class Server:
         )
         log(
             INFO,
-            "fit_round %s received %s results and %s failures",
-            server_round,
+            "aggregate_fit: received %s results and %s failures",
             len(results),
             len(failures),
         )
@@ -275,7 +272,7 @@ class Server:
             client_manager=self._client_manager
         )
         if parameters is not None:
-            log(INFO, "Using initial parameters provided by strategy")
+            log(INFO, "Using initial global parameters provided by strategy")
             return parameters
 
         # Get initial parameters from one of the clients
@@ -483,12 +480,19 @@ def run_fl(
     config: ServerConfig,
 ) -> History:
     """Train a model on the given server and return the History object."""
-    hist = server.fit(num_rounds=config.num_rounds, timeout=config.round_timeout)
-    log(INFO, "app_fit: losses_distributed %s", str(hist.losses_distributed))
-    log(INFO, "app_fit: metrics_distributed_fit %s", str(hist.metrics_distributed_fit))
-    log(INFO, "app_fit: metrics_distributed %s", str(hist.metrics_distributed))
-    log(INFO, "app_fit: losses_centralized %s", str(hist.losses_centralized))
-    log(INFO, "app_fit: metrics_centralized %s", str(hist.metrics_centralized))
+    hist, elapsed_time = server.fit(
+        num_rounds=config.num_rounds, timeout=config.round_timeout
+    )
+
+    log(INFO, "")
+    log(INFO, "[SUMMARY]")
+    log(INFO, "Run finished %s rounds in %.2fs", config.num_rounds, elapsed_time)
+    for idx, line in enumerate(io.StringIO(str(hist))):
+        if idx == 0:
+            log(INFO, "%s", line.strip("\n"))
+        else:
+            log(INFO, "\t%s", line.strip("\n"))
+    log(INFO, "")
 
     # Graceful shutdown
     server.disconnect_all_clients(timeout=config.round_timeout)

flwr/server/server_app.py

@@ -15,8 +15,7 @@
 """Flower ServerApp."""
 
 
-import importlib
-from typing import Callable, Optional, cast
+from typing import Callable, Optional
 
 from flwr.common import Context, RecordSet
 from flwr.server.strategy import Strategy
@@ -132,48 +131,3 @@ class ServerApp:
 
 class LoadServerAppError(Exception):
     """Error when trying to load `ServerApp`."""
-
-
-def load_server_app(module_attribute_str: str) -> ServerApp:
-    """Load the `ServerApp` object specified in a module attribute string.
-
-    The module/attribute string should have the form <module>:<attribute>. Valid
-    examples include `server:app` and `project.package.module:wrapper.app`. It
-    must refer to a module on the PYTHONPATH, the module needs to have the specified
-    attribute, and the attribute must be of type `ServerApp`.
-    """
-    module_str, _, attributes_str = module_attribute_str.partition(":")
-    if not module_str:
-        raise LoadServerAppError(
-            f"Missing module in {module_attribute_str}",
-        ) from None
-    if not attributes_str:
-        raise LoadServerAppError(
-            f"Missing attribute in {module_attribute_str}",
-        ) from None
-
-    # Load module
-    try:
-        module = importlib.import_module(module_str)
-    except ModuleNotFoundError:
-        raise LoadServerAppError(
-            f"Unable to load module {module_str}",
-        ) from None
-
-    # Recursively load attribute
-    attribute = module
-    try:
-        for attribute_str in attributes_str.split("."):
-            attribute = getattr(attribute, attribute_str)
-    except AttributeError:
-        raise LoadServerAppError(
-            f"Unable to load attribute {attributes_str} from module {module_str}",
-        ) from None
-
-    # Check type
-    if not isinstance(attribute, ServerApp):
-        raise LoadServerAppError(
-            f"Attribute {attributes_str} is not of type {ServerApp}",
-        ) from None
-
-    return cast(ServerApp, attribute)

flwr/server/server_config.py

@@ -29,3 +29,12 @@ class ServerConfig:
 
     num_rounds: int = 1
     round_timeout: Optional[float] = None
+
+    def __repr__(self) -> str:
+        """Return the string representation of the ServerConfig."""
+        timeout_string = (
+            "no round_timeout"
+            if self.round_timeout is None
+            else f"round_timeout={self.round_timeout}s"
+        )
+        return f"num_rounds={self.num_rounds}, {timeout_string}"

flwr/server/strategy/fedavg.py

@@ -84,6 +84,8 @@ class FedAvg(Strategy):
         Metrics aggregation function, optional.
     evaluate_metrics_aggregation_fn : Optional[MetricsAggregationFn]
         Metrics aggregation function, optional.
+    inplace : bool (default: True)
+        Enable (True) or disable (False) in-place aggregation of model updates.
     """
 
     # pylint: disable=too-many-arguments,too-many-instance-attributes, line-too-long

flwr/server/superlink/fleet/vce/vce_api.py

@@ -21,9 +21,10 @@ import traceback
 from logging import DEBUG, ERROR, INFO, WARN
 from typing import Callable, Dict, List, Optional
 
-from flwr.client.client_app import ClientApp, LoadClientAppError, load_client_app
+from flwr.client.client_app import ClientApp, LoadClientAppError
 from flwr.client.node_state import NodeState
 from flwr.common.logger import log
+from flwr.common.object_ref import load_app
 from flwr.common.serde import message_from_taskins, message_to_taskres
 from flwr.proto.task_pb2 import TaskIns  # pylint: disable=E0611
 from flwr.server.superlink.state import StateFactory
@@ -305,7 +306,13 @@ def start_vce(
     def _load() -> ClientApp:
 
         if client_app_attr:
-            app: ClientApp = load_client_app(client_app_attr)
+            app: ClientApp = load_app(client_app_attr, LoadClientAppError)
+
+            if not isinstance(app, ClientApp):
+                raise LoadClientAppError(
+                    f"Attribute {client_app_attr} is not of type {ClientApp}",
+                ) from None
+
         if client_app:
             app = client_app
         return app

flwr/server/superlink/state/in_memory_state.py

@@ -122,7 +122,8 @@ class InMemoryState(State):
         task_res.task_id = str(task_id)
         task_res.task.created_at = created_at.isoformat()
         task_res.task.ttl = ttl.isoformat()
-        self.task_res_store[task_id] = task_res
+        with self.lock:
+            self.task_res_store[task_id] = task_res
 
         # Return the new task_id
         return task_id
@@ -132,46 +133,47 @@ class InMemoryState(State):
         if limit is not None and limit < 1:
             raise AssertionError("`limit` must be >= 1")
 
-        # Find TaskRes that were not delivered yet
-        task_res_list: List[TaskRes] = []
-        for _, task_res in self.task_res_store.items():
-            if (
-                UUID(task_res.task.ancestry[0]) in task_ids
-                and task_res.task.delivered_at == ""
-            ):
-                task_res_list.append(task_res)
-            if limit and len(task_res_list) == limit:
-                break
+        with self.lock:
+            # Find TaskRes that were not delivered yet
+            task_res_list: List[TaskRes] = []
+            for _, task_res in self.task_res_store.items():
+                if (
+                    UUID(task_res.task.ancestry[0]) in task_ids
+                    and task_res.task.delivered_at == ""
+                ):
+                    task_res_list.append(task_res)
+                if limit and len(task_res_list) == limit:
+                    break
 
-        # Mark all of them as delivered
-        delivered_at = now().isoformat()
-        for task_res in task_res_list:
-            task_res.task.delivered_at = delivered_at
+            # Mark all of them as delivered
+            delivered_at = now().isoformat()
+            for task_res in task_res_list:
+                task_res.task.delivered_at = delivered_at
 
-        # Return TaskRes
-        return task_res_list
+            # Return TaskRes
+            return task_res_list
 
     def delete_tasks(self, task_ids: Set[UUID]) -> None:
         """Delete all delivered TaskIns/TaskRes pairs."""
         task_ins_to_be_deleted: Set[UUID] = set()
         task_res_to_be_deleted: Set[UUID] = set()
 
-        for task_ins_id in task_ids:
-            # Find the task_id of the matching task_res
-            for task_res_id, task_res in self.task_res_store.items():
-                if UUID(task_res.task.ancestry[0]) != task_ins_id:
-                    continue
-                if task_res.task.delivered_at == "":
-                    continue
-
-                task_ins_to_be_deleted.add(task_ins_id)
-                task_res_to_be_deleted.add(task_res_id)
-
-        for task_id in task_ins_to_be_deleted:
-            with self.lock:
+        with self.lock:
+            for task_ins_id in task_ids:
+                # Find the task_id of the matching task_res
+                for task_res_id, task_res in self.task_res_store.items():
+                    if UUID(task_res.task.ancestry[0]) != task_ins_id:
+                        continue
+                    if task_res.task.delivered_at == "":
+                        continue
+
+                    task_ins_to_be_deleted.add(task_ins_id)
+                    task_res_to_be_deleted.add(task_res_id)
+
+            for task_id in task_ins_to_be_deleted:
                 del self.task_ins_store[task_id]
-        for task_id in task_res_to_be_deleted:
-            del self.task_res_store[task_id]
+            for task_id in task_res_to_be_deleted:
+                del self.task_res_store[task_id]
 
     def num_task_ins(self) -> int:
         """Calculate the number of task_ins in store.

flwr/server/workflow/__init__.py

@@ -16,7 +16,10 @@
 
 
 from .default_workflows import DefaultWorkflow
+from .secure_aggregation import SecAggPlusWorkflow, SecAggWorkflow
 
 __all__ = [
     "DefaultWorkflow",
+    "SecAggPlusWorkflow",
+    "SecAggWorkflow",
 ]

flwr/server/workflow/constant.py

@@ -0,0 +1,32 @@
+# 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.
+# ==============================================================================
+"""Constants for default workflows."""
+
+
+from __future__ import annotations
+
+MAIN_CONFIGS_RECORD = "config"
+MAIN_PARAMS_RECORD = "parameters"
+
+
+class Key:
+    """Constants for default workflows."""
+
+    CURRENT_ROUND = "current_round"
+    START_TIME = "start_time"
+
+    def __new__(cls) -> Key:
+        """Prevent instantiation."""
+        raise TypeError(f"{cls.__name__} cannot be instantiated.")