flwr-nightly 1.8.0.dev20240310__tar.gz → 1.8.0.dev20240311__tar.gz

{flwr_nightly-1.8.0.dev20240310 → flwr_nightly-1.8.0.dev20240311}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: flwr-nightly
-Version: 1.8.0.dev20240310
+Version: 1.8.0.dev20240311
 Summary: Flower: A Friendly Federated Learning Framework
 Home-page: https://flower.ai
 License: Apache-2.0

{flwr_nightly-1.8.0.dev20240310 → flwr_nightly-1.8.0.dev20240311}/pyproject.toml

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

{flwr_nightly-1.8.0.dev20240310 → flwr_nightly-1.8.0.dev20240311}/src/py/flwr/cli/new/new.py

@@ -22,7 +22,7 @@ from typing import Dict, Optional
 import typer
 from typing_extensions import Annotated
 
-from ..utils import prompt_options
+from ..utils import prompt_options, prompt_text
 
 
 class MlFramework(str, Enum):
@@ -72,9 +72,9 @@ def render_and_create(file_path: str, template: str, context: Dict[str, str]) ->
 
 def new(
     project_name: Annotated[
-        str,
+        Optional[str],
         typer.Argument(metavar="project_name", help="The name of the project"),
-    ],
+    ] = None,
     framework: Annotated[
         Optional[MlFramework],
         typer.Option(case_sensitive=False, help="The ML framework to use"),
@@ -83,6 +83,9 @@ def new(
     """Create new Flower project."""
     print(f"Creating Flower project {project_name}...")
 
+    if project_name is None:
+        project_name = prompt_text("Please provide project name")
+
     if framework is not None:
         framework_str = str(framework.value)
     else:

{flwr_nightly-1.8.0.dev20240310 → flwr_nightly-1.8.0.dev20240311}/src/py/flwr/cli/utils.py

@@ -14,11 +14,24 @@
 # ==============================================================================
 """Flower command line interface utils."""
 
-from typing import List
+from typing import List, cast
 
 import typer
 
 
+def prompt_text(text: str) -> str:
+    """Ask user to enter text input."""
+    while True:
+        result = typer.prompt(
+            typer.style(f"\n💬 {text}", fg=typer.colors.MAGENTA, bold=True)
+        )
+        if len(result) > 0:
+            break
+        print(typer.style("❌ Invalid entry", fg=typer.colors.RED, bold=True))
+
+    return cast(str, result)
+
+
 def prompt_options(text: str, options: List[str]) -> str:
     """Ask user to select one of the given options and return the selected item."""
     # Turn options into a list with index as in " [ 0] quickstart-pytorch"

{flwr_nightly-1.8.0.dev20240310 → flwr_nightly-1.8.0.dev20240311}/src/py/flwr/client/app.py

@@ -456,7 +456,19 @@ def _start_client_internal(
                     time.sleep(3)  # Wait for 3s before asking again
                     continue
 
-                log(INFO, "Received message")
+                log(INFO, "")
+                log(
+                    INFO,
+                    "[RUN %s, ROUND %s]",
+                    message.metadata.run_id,
+                    message.metadata.group_id,
+                )
+                log(
+                    INFO,
+                    "Received: %s message %s",
+                    message.metadata.message_type,
+                    message.metadata.message_id,
+                )
 
                 # Handle control message
                 out_message, sleep_duration = handle_control_message(message)
@@ -484,7 +496,18 @@ def _start_client_internal(
 
                 # Send
                 send(out_message)
-                log(INFO, "Sent reply")
+                log(
+                    INFO,
+                    "[RUN %s, ROUND %s]",
+                    out_message.metadata.run_id,
+                    out_message.metadata.group_id,
+                )
+                log(
+                    INFO,
+                    "Sent: %s reply to message %s",
+                    out_message.metadata.message_type,
+                    message.metadata.message_id,
+                )
 
             # Unregister node
             if delete_node is not None:

{flwr_nightly-1.8.0.dev20240310 → flwr_nightly-1.8.0.dev20240311}/src/py/flwr/client/mod/__init__.py

@@ -17,7 +17,7 @@
 
 from .centraldp_mods import adaptiveclipping_mod, fixedclipping_mod
 from .localdp_mod import LocalDpMod
-from .secure_aggregation.secaggplus_mod import secaggplus_mod
+from .secure_aggregation import secagg_mod, secaggplus_mod
 from .utils import make_ffn
 
 __all__ = [
@@ -25,5 +25,6 @@ __all__ = [
     "fixedclipping_mod",
     "LocalDpMod",
     "make_ffn",
+    "secagg_mod",
     "secaggplus_mod",
 ]

{flwr_nightly-1.8.0.dev20240310 → flwr_nightly-1.8.0.dev20240311}/src/py/flwr/client/mod/secure_aggregation/__init__.py

@@ -15,8 +15,10 @@
 """Secure Aggregation mods."""
 
 
+from .secagg_mod import secagg_mod
 from .secaggplus_mod import secaggplus_mod
 
 __all__ = [
+    "secagg_mod",
     "secaggplus_mod",
 ]

flwr_nightly-1.8.0.dev20240311/src/py/flwr/client/mod/secure_aggregation/secagg_mod.py

@@ -0,0 +1,30 @@
+# 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.
+# ==============================================================================
+"""Modifier for the SecAgg protocol."""
+
+
+from flwr.client.typing import ClientAppCallable
+from flwr.common import Context, Message
+
+from .secaggplus_mod import secaggplus_mod
+
+
+def secagg_mod(
+    msg: Message,
+    ctxt: Context,
+    call_next: ClientAppCallable,
+) -> Message:
+    """Handle incoming message and return results, following the SecAgg protocol."""
+    return secaggplus_mod(msg, ctxt, call_next)

{flwr_nightly-1.8.0.dev20240310 → flwr_nightly-1.8.0.dev20240311}/src/py/flwr/client/mod/secure_aggregation/secaggplus_mod.py

@@ -178,9 +178,9 @@ def secaggplus_mod(
         res = _setup(state, configs)
     elif state.current_stage == Stage.SHARE_KEYS:
         res = _share_keys(state, configs)
-    elif state.current_stage == Stage.COLLECT_MASKED_INPUT:
+    elif state.current_stage == Stage.COLLECT_MASKED_VECTORS:
         fit = _get_fit_fn(msg, ctxt, call_next)
-        res = _collect_masked_input(state, configs, fit)
+        res = _collect_masked_vectors(state, configs, fit)
     elif state.current_stage == Stage.UNMASK:
         res = _unmask(state, configs)
     else:
@@ -199,7 +199,7 @@ def check_stage(current_stage: str, configs: ConfigsRecord) -> None:
     # Check the existence of Config.STAGE
     if Key.STAGE not in configs:
         raise KeyError(
-            f"The required key '{Key.STAGE}' is missing from the input `named_values`."
+            f"The required key '{Key.STAGE}' is missing from the ConfigsRecord."
         )
 
     # Check the value type of the Config.STAGE
@@ -215,7 +215,7 @@ def check_stage(current_stage: str, configs: ConfigsRecord) -> None:
         if current_stage != Stage.UNMASK:
             log(WARNING, "Restart from the setup stage")
     # If stage is not "setup",
-    # the stage from `named_values` should be the expected next stage
+    # the stage from configs should be the expected next stage
     else:
         stages = Stage.all()
         expected_next_stage = stages[(stages.index(current_stage) + 1) % len(stages)]
@@ -229,7 +229,7 @@ def check_stage(current_stage: str, configs: ConfigsRecord) -> None:
 # pylint: disable-next=too-many-branches
 def check_configs(stage: str, configs: ConfigsRecord) -> None:
     """Check the validity of the configs."""
-    # Check `named_values` for the setup stage
+    # Check configs for the setup stage
     if stage == Stage.SETUP:
         key_type_pairs = [
             (Key.SAMPLE_NUMBER, int),
@@ -243,7 +243,7 @@ def check_configs(stage: str, configs: ConfigsRecord) -> None:
             if key not in configs:
                 raise KeyError(
                     f"Stage {Stage.SETUP}: the required key '{key}' is "
-                    "missing from the input `named_values`."
+                    "missing from the ConfigsRecord."
                 )
             # Bool is a subclass of int in Python,
             # so `isinstance(v, int)` will return True even if v is a boolean.
@@ -266,7 +266,7 @@ def check_configs(stage: str, configs: ConfigsRecord) -> None:
                     f"Stage {Stage.SHARE_KEYS}: "
                     f"the value for the key '{key}' must be a list of two bytes."
                 )
-    elif stage == Stage.COLLECT_MASKED_INPUT:
+    elif stage == Stage.COLLECT_MASKED_VECTORS:
         key_type_pairs = [
             (Key.CIPHERTEXT_LIST, bytes),
             (Key.SOURCE_LIST, int),
@@ -274,9 +274,9 @@ def check_configs(stage: str, configs: ConfigsRecord) -> None:
         for key, expected_type in key_type_pairs:
             if key not in configs:
                 raise KeyError(
-                    f"Stage {Stage.COLLECT_MASKED_INPUT}: "
+                    f"Stage {Stage.COLLECT_MASKED_VECTORS}: "
                     f"the required key '{key}' is "
-                    "missing from the input `named_values`."
+                    "missing from the ConfigsRecord."
                 )
             if not isinstance(configs[key], list) or any(
                 elm
@@ -285,7 +285,7 @@ def check_configs(stage: str, configs: ConfigsRecord) -> None:
                 if type(elm) is not expected_type
             ):
                 raise TypeError(
-                    f"Stage {Stage.COLLECT_MASKED_INPUT}: "
+                    f"Stage {Stage.COLLECT_MASKED_VECTORS}: "
                     f"the value for the key '{key}' "
                     f"must be of type List[{expected_type.__name__}]"
                 )
@@ -299,7 +299,7 @@ def check_configs(stage: str, configs: ConfigsRecord) -> None:
                 raise KeyError(
                     f"Stage {Stage.UNMASK}: "
                     f"the required key '{key}' is "
-                    "missing from the input `named_values`."
+                    "missing from the ConfigsRecord."
                 )
             if not isinstance(configs[key], list) or any(
                 elm
@@ -414,7 +414,7 @@ def _share_keys(
 
 
 # pylint: disable-next=too-many-locals
-def _collect_masked_input(
+def _collect_masked_vectors(
     state: SecAggPlusState,
     configs: ConfigsRecord,
     fit: Callable[[], FitRes],

{flwr_nightly-1.8.0.dev20240310 → flwr_nightly-1.8.0.dev20240311}/src/py/flwr/common/logger.py

@@ -168,11 +168,10 @@ def warn_experimental_feature(name: str) -> None:
     """Warn the user when they use an experimental feature."""
     log(
         WARN,
-        """
-        EXPERIMENTAL FEATURE: %s
+        """EXPERIMENTAL FEATURE: %s
 
-        This is an experimental feature. It could change significantly or be removed
-        entirely in future versions of Flower.
+            This is an experimental feature. It could change significantly or be removed
+            entirely in future versions of Flower.
         """,
         name,
     )
@@ -182,11 +181,10 @@ def warn_deprecated_feature(name: str) -> None:
     """Warn the user when they use a deprecated feature."""
     log(
         WARN,
-        """
-        DEPRECATED FEATURE: %s
+        """DEPRECATED FEATURE: %s
 
-        This is a deprecated feature. It will be removed
-        entirely in future versions of Flower.
+            This is a deprecated feature. It will be removed
+            entirely in future versions of Flower.
         """,
         name,
     )

{flwr_nightly-1.8.0.dev20240310 → flwr_nightly-1.8.0.dev20240311}/src/py/flwr/common/secure_aggregation/secaggplus_constants.py

@@ -27,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]:

{flwr_nightly-1.8.0.dev20240310 → flwr_nightly-1.8.0.dev20240311}/src/py/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_nightly-1.8.0.dev20240310 → flwr_nightly-1.8.0.dev20240311}/src/py/flwr/server/workflow/__init__.py

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

{flwr_nightly-1.8.0.dev20240310 → flwr_nightly-1.8.0.dev20240311}/src/py/flwr/server/workflow/default_workflows.py

@@ -15,8 +15,9 @@
 """Legacy default workflows."""
 
 
+import io
 import timeit
-from logging import DEBUG, INFO
+from logging import INFO
 from typing import Optional, cast
 
 import flwr.common.recordset_compat as compat
@@ -58,16 +59,18 @@ class DefaultWorkflow:
         )
 
         # Initialize parameters
+        log(INFO, "[INIT]")
         default_init_params_workflow(driver, context)
 
         # Run federated learning for num_rounds
-        log(INFO, "FL starting")
         start_time = timeit.default_timer()
         cfg = ConfigsRecord()
         cfg[Key.START_TIME] = start_time
         context.state.configs_records[MAIN_CONFIGS_RECORD] = cfg
 
         for current_round in range(1, context.config.num_rounds + 1):
+            log(INFO, "")
+            log(INFO, "[ROUND %s]", current_round)
             cfg[Key.CURRENT_ROUND] = current_round
 
             # Fit round
@@ -79,22 +82,19 @@ class DefaultWorkflow:
             # Evaluate round
             self.evaluate_workflow(driver, context)
 
-        # Bookkeeping
+        # Bookkeeping and log results
         end_time = timeit.default_timer()
         elapsed = end_time - start_time
-        log(INFO, "FL finished in %s", elapsed)
-
-        # Log results
         hist = context.history
-        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))
+        log(INFO, "")
+        log(INFO, "[SUMMARY]")
+        log(INFO, "Run finished %s rounds in %.2fs", context.config.num_rounds, elapsed)
+        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, "")
 
         # Terminate the thread
         f_stop.set()
@@ -107,12 +107,11 @@ def default_init_params_workflow(driver: Driver, context: Context) -> None:
     if not isinstance(context, LegacyContext):
         raise TypeError(f"Expect a LegacyContext, but get {type(context).__name__}.")
 
-    log(INFO, "Initializing global parameters")
     parameters = context.strategy.initialize_parameters(
         client_manager=context.client_manager
     )
     if parameters is not None:
-        log(INFO, "Using initial parameters provided by strategy")
+        log(INFO, "Using initial global parameters provided by strategy")
         paramsrecord = compat.parameters_to_parametersrecord(
             parameters, keep_input=True
         )
@@ -140,7 +139,7 @@ def default_init_params_workflow(driver: Driver, context: Context) -> None:
     context.state.parameters_records[MAIN_PARAMS_RECORD] = paramsrecord
 
     # Evaluate initial parameters
-    log(INFO, "Evaluating initial parameters")
+    log(INFO, "Evaluating initial global parameters")
     parameters = compat.parametersrecord_to_parameters(paramsrecord, keep_input=True)
     res = context.strategy.evaluate(0, parameters=parameters)
     if res is not None:
@@ -186,7 +185,9 @@ def default_centralized_evaluation_workflow(_: Driver, context: Context) -> None
         )
 
 
-def default_fit_workflow(driver: Driver, context: Context) -> None:
+def default_fit_workflow(  # pylint: disable=R0914
+    driver: Driver, context: Context
+) -> None:
     """Execute the default workflow for a single fit round."""
     if not isinstance(context, LegacyContext):
         raise TypeError(f"Expect a LegacyContext, but get {type(context).__name__}.")
@@ -207,12 +208,11 @@ def default_fit_workflow(driver: Driver, context: Context) -> None:
     )
 
     if not client_instructions:
-        log(INFO, "fit_round %s: no clients selected, cancel", current_round)
+        log(INFO, "configure_fit: no clients selected, cancel")
         return
     log(
-        DEBUG,
-        "fit_round %s: strategy sampled %s clients (out of %s)",
-        current_round,
+        INFO,
+        "configure_fit: strategy sampled %s clients (out of %s)",
         len(client_instructions),
         context.client_manager.num_available(),
     )
@@ -236,14 +236,14 @@ def default_fit_workflow(driver: Driver, context: Context) -> None:
     # collect `fit` results from all clients participating in this round
     messages = list(driver.send_and_receive(out_messages))
     del out_messages
+    num_failures = len([msg for msg in messages if msg.has_error()])
 
     # No exception/failure handling currently
     log(
-        DEBUG,
-        "fit_round %s received %s results and %s failures",
-        current_round,
-        len(messages),
-        0,
+        INFO,
+        "aggregate_fit: received %s results and %s failures",
+        len(messages) - num_failures,
+        num_failures,
     )
 
     # Aggregate training results
@@ -288,12 +288,11 @@ def default_evaluate_workflow(driver: Driver, context: Context) -> None:
         client_manager=context.client_manager,
     )
     if not client_instructions:
-        log(INFO, "evaluate_round %s: no clients selected, cancel", current_round)
+        log(INFO, "configure_evaluate: no clients selected, skipping evaluation")
         return
     log(
-        DEBUG,
-        "evaluate_round %s: strategy sampled %s clients (out of %s)",
-        current_round,
+        INFO,
+        "configure_evaluate: strategy sampled %s clients (out of %s)",
         len(client_instructions),
         context.client_manager.num_available(),
     )
@@ -317,14 +316,14 @@ def default_evaluate_workflow(driver: Driver, context: Context) -> None:
     # collect `evaluate` results from all clients participating in this round
     messages = list(driver.send_and_receive(out_messages))
     del out_messages
+    num_failures = len([msg for msg in messages if msg.has_error()])
 
     # No exception/failure handling currently
     log(
-        DEBUG,
-        "evaluate_round %s received %s results and %s failures",
-        current_round,
-        len(messages),
-        0,
+        INFO,
+        "aggregate_evaluate: received %s results and %s failures",
+        len(messages) - num_failures,
+        num_failures,
     )
 
     # Aggregate the evaluation results

{flwr_nightly-1.8.0.dev20240310 → flwr_nightly-1.8.0.dev20240311}/src/py/flwr/server/workflow/secure_aggregation/__init__.py

@@ -15,8 +15,10 @@
 """Secure Aggregation workflows."""
 
 
+from .secagg_workflow import SecAggWorkflow
 from .secaggplus_workflow import SecAggPlusWorkflow
 
 __all__ = [
     "SecAggPlusWorkflow",
+    "SecAggWorkflow",
 ]