flwr-nightly 1.8.0.dev20240227__tar.gz → 1.8.0.dev20240229__tar.gz

{flwr_nightly-1.8.0.dev20240227 → flwr_nightly-1.8.0.dev20240229}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: flwr-nightly
-Version: 1.8.0.dev20240227
+Version: 1.8.0.dev20240229
 Summary: Flower: A Friendly Federated Learning Framework
 Home-page: https://flower.ai
 License: Apache-2.0
@@ -32,7 +32,7 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Typing :: Typed
 Provides-Extra: rest
 Provides-Extra: simulation
-Requires-Dist: cryptography (>=41.0.2,<42.0.0)
+Requires-Dist: cryptography (>=42.0.4,<43.0.0)
 Requires-Dist: grpcio (>=1.60.0,<2.0.0)
 Requires-Dist: iterators (>=0.0.2,<0.0.3)
 Requires-Dist: numpy (>=1.21.0,<2.0.0)
@@ -83,7 +83,7 @@ design of Flower is based on a few guiding principles:
 
 - **Framework-agnostic**: Different machine learning frameworks have different
   strengths. Flower can be used with any machine learning framework, for
-  example, [PyTorch](https://pytorch.org), [TensorFlow](https://tensorflow.org), [Hugging Face Transformers](https://huggingface.co/), [PyTorch Lightning](https://pytorchlightning.ai/), [scikit-learn](https://scikit-learn.org/), [JAX](https://jax.readthedocs.io/), [TFLite](https://tensorflow.org/lite/), [fastai](https://www.fast.ai/), [MLX](https://ml-explore.github.io/mlx/build/html/index.html), [XGBoost](https://xgboost.readthedocs.io/en/stable/), [Pandas](https://pandas.pydata.org/) for federated analytics, or even raw [NumPy](https://numpy.org/)
+  example, [PyTorch](https://pytorch.org), [TensorFlow](https://tensorflow.org), [Hugging Face Transformers](https://huggingface.co/), [PyTorch Lightning](https://pytorchlightning.ai/), [scikit-learn](https://scikit-learn.org/), [JAX](https://jax.readthedocs.io/), [TFLite](https://tensorflow.org/lite/), [MONAI](https://docs.monai.io/en/latest/index.html), [fastai](https://www.fast.ai/), [MLX](https://ml-explore.github.io/mlx/build/html/index.html), [XGBoost](https://xgboost.readthedocs.io/en/stable/), [Pandas](https://pandas.pydata.org/) for federated analytics, or even raw [NumPy](https://numpy.org/)
   for users who enjoy computing gradients by hand.
 
 - **Understandable**: Flower is written with maintainability in mind. The
@@ -180,6 +180,7 @@ Quickstart examples:
 - [Quickstart (fastai)](https://github.com/adap/flower/tree/main/examples/quickstart-fastai)
 - [Quickstart (Pandas)](https://github.com/adap/flower/tree/main/examples/quickstart-pandas)
 - [Quickstart (JAX)](https://github.com/adap/flower/tree/main/examples/quickstart-jax)
+- [Quickstart (MONAI)](https://github.com/adap/flower/tree/main/examples/quickstart-monai)
 - [Quickstart (scikit-learn)](https://github.com/adap/flower/tree/main/examples/sklearn-logreg-mnist)
 - [Quickstart (XGBoost)](https://github.com/adap/flower/tree/main/examples/xgboost-quickstart)
 - [Quickstart (Android [TFLite])](https://github.com/adap/flower/tree/main/examples/android)

{flwr_nightly-1.8.0.dev20240227 → flwr_nightly-1.8.0.dev20240229}/README.md

@@ -33,7 +33,7 @@ design of Flower is based on a few guiding principles:
 
 - **Framework-agnostic**: Different machine learning frameworks have different
   strengths. Flower can be used with any machine learning framework, for
-  example, [PyTorch](https://pytorch.org), [TensorFlow](https://tensorflow.org), [Hugging Face Transformers](https://huggingface.co/), [PyTorch Lightning](https://pytorchlightning.ai/), [scikit-learn](https://scikit-learn.org/), [JAX](https://jax.readthedocs.io/), [TFLite](https://tensorflow.org/lite/), [fastai](https://www.fast.ai/), [MLX](https://ml-explore.github.io/mlx/build/html/index.html), [XGBoost](https://xgboost.readthedocs.io/en/stable/), [Pandas](https://pandas.pydata.org/) for federated analytics, or even raw [NumPy](https://numpy.org/)
+  example, [PyTorch](https://pytorch.org), [TensorFlow](https://tensorflow.org), [Hugging Face Transformers](https://huggingface.co/), [PyTorch Lightning](https://pytorchlightning.ai/), [scikit-learn](https://scikit-learn.org/), [JAX](https://jax.readthedocs.io/), [TFLite](https://tensorflow.org/lite/), [MONAI](https://docs.monai.io/en/latest/index.html), [fastai](https://www.fast.ai/), [MLX](https://ml-explore.github.io/mlx/build/html/index.html), [XGBoost](https://xgboost.readthedocs.io/en/stable/), [Pandas](https://pandas.pydata.org/) for federated analytics, or even raw [NumPy](https://numpy.org/)
   for users who enjoy computing gradients by hand.
 
 - **Understandable**: Flower is written with maintainability in mind. The
@@ -130,6 +130,7 @@ Quickstart examples:
 - [Quickstart (fastai)](https://github.com/adap/flower/tree/main/examples/quickstart-fastai)
 - [Quickstart (Pandas)](https://github.com/adap/flower/tree/main/examples/quickstart-pandas)
 - [Quickstart (JAX)](https://github.com/adap/flower/tree/main/examples/quickstart-jax)
+- [Quickstart (MONAI)](https://github.com/adap/flower/tree/main/examples/quickstart-monai)
 - [Quickstart (scikit-learn)](https://github.com/adap/flower/tree/main/examples/sklearn-logreg-mnist)
 - [Quickstart (XGBoost)](https://github.com/adap/flower/tree/main/examples/xgboost-quickstart)
 - [Quickstart (Android [TFLite])](https://github.com/adap/flower/tree/main/examples/android)

{flwr_nightly-1.8.0.dev20240227 → flwr_nightly-1.8.0.dev20240229}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "flwr-nightly"
-version = "1.8.0-dev20240227"
+version = "1.8.0-dev20240229"
 description = "Flower: A Friendly Federated Learning Framework"
 license = "Apache-2.0"
 authors = ["The Flower Authors <hello@flower.ai>"]
@@ -58,6 +58,7 @@ flower-fleet-api = "flwr.server:run_fleet_api"
 flower-superlink = "flwr.server:run_superlink"
 flower-client-app = "flwr.client:run_client_app"
 flower-server-app = "flwr.server:run_server_app"
+flower-simulation = "flwr.simulation:run_simulation"
 
 [tool.poetry.dependencies]
 python = "^3.8"
@@ -65,7 +66,7 @@ python = "^3.8"
 numpy = "^1.21.0"
 grpcio = "^1.60.0"
 protobuf = "^4.25.2"
-cryptography = "^41.0.2"
+cryptography = "^42.0.4"
 pycryptodome = "^3.18.0"
 iterators = "^0.0.2"
 typer = { version = "^0.9.0", extras=["all"] }

{flwr_nightly-1.8.0.dev20240227 → flwr_nightly-1.8.0.dev20240229}/src/py/flwr/client/mod/__init__.py

@@ -15,12 +15,13 @@
 """Mods."""
 
 
-from .centraldp_mods import fixedclipping_mod
+from .centraldp_mods import adaptiveclipping_mod, fixedclipping_mod
 from .secure_aggregation.secaggplus_mod import secaggplus_mod
 from .utils import make_ffn
 
 __all__ = [
+    "adaptiveclipping_mod",
+    "fixedclipping_mod",
     "make_ffn",
     "secaggplus_mod",
-    "fixedclipping_mod",
 ]

{flwr_nightly-1.8.0.dev20240227 → flwr_nightly-1.8.0.dev20240229}/src/py/flwr/client/mod/centraldp_mods.py

@@ -20,8 +20,11 @@ from flwr.common import ndarrays_to_parameters, parameters_to_ndarrays
 from flwr.common import recordset_compat as compat
 from flwr.common.constant import MESSAGE_TYPE_FIT
 from flwr.common.context import Context
-from flwr.common.differential_privacy import compute_clip_model_update
-from flwr.common.differential_privacy_constants import KEY_CLIPPING_NORM
+from flwr.common.differential_privacy import (
+    compute_adaptive_clip_model_update,
+    compute_clip_model_update,
+)
+from flwr.common.differential_privacy_constants import KEY_CLIPPING_NORM, KEY_NORM_BIT
 from flwr.common.message import Message
 
 
@@ -74,3 +77,61 @@ def fixedclipping_mod(
     fit_res.parameters = ndarrays_to_parameters(client_to_server_params)
     out_msg.content = compat.fitres_to_recordset(fit_res, keep_input=True)
     return out_msg
+
+
+def adaptiveclipping_mod(
+    msg: Message, ctxt: Context, call_next: ClientAppCallable
+) -> Message:
+    """Client-side adaptive clipping modifier.
+
+    This mod needs to be used with the DifferentialPrivacyClientSideAdaptiveClipping
+    server-side strategy wrapper.
+
+    The wrapper sends the clipping_norm value to the client.
+
+    This mod clips the client model updates before sending them to the server.
+
+    It also sends KEY_NORM_BIT to the server for computing the new clipping value.
+
+    It operates on messages with type MESSAGE_TYPE_FIT.
+
+    Notes
+    -----
+    Consider the order of mods when using multiple.
+
+    Typically, adaptiveclipping_mod should be the last to operate on params.
+    """
+    if msg.metadata.message_type != MESSAGE_TYPE_FIT:
+        return call_next(msg, ctxt)
+
+    fit_ins = compat.recordset_to_fitins(msg.content, keep_input=True)
+
+    if KEY_CLIPPING_NORM not in fit_ins.config:
+        raise KeyError(
+            f"The {KEY_CLIPPING_NORM} value is not supplied by the "
+            f"DifferentialPrivacyClientSideFixedClipping wrapper at"
+            f" the server side."
+        )
+    if not isinstance(fit_ins.config[KEY_CLIPPING_NORM], float):
+        raise ValueError(f"{KEY_CLIPPING_NORM} should be a float value.")
+    clipping_norm = float(fit_ins.config[KEY_CLIPPING_NORM])
+    server_to_client_params = parameters_to_ndarrays(fit_ins.parameters)
+
+    # Call inner app
+    out_msg = call_next(msg, ctxt)
+    fit_res = compat.recordset_to_fitres(out_msg.content, keep_input=True)
+
+    client_to_server_params = parameters_to_ndarrays(fit_res.parameters)
+
+    # Clip the client update
+    norm_bit = compute_adaptive_clip_model_update(
+        client_to_server_params,
+        server_to_client_params,
+        clipping_norm,
+    )
+
+    fit_res.parameters = ndarrays_to_parameters(client_to_server_params)
+
+    fit_res.metrics[KEY_NORM_BIT] = norm_bit
+    out_msg.content = compat.fitres_to_recordset(fit_res, keep_input=True)
+    return out_msg

{flwr_nightly-1.8.0.dev20240227 → flwr_nightly-1.8.0.dev20240229}/src/py/flwr/client/mod/secure_aggregation/secaggplus_mod.py

@@ -52,31 +52,10 @@ from flwr.common.secure_aggregation.ndarrays_arithmetic import (
 )
 from flwr.common.secure_aggregation.quantization import quantize
 from flwr.common.secure_aggregation.secaggplus_constants import (
-    KEY_ACTIVE_SECURE_ID_LIST,
-    KEY_CIPHERTEXT_LIST,
-    KEY_CLIPPING_RANGE,
-    KEY_DEAD_SECURE_ID_LIST,
-    KEY_DESTINATION_LIST,
-    KEY_MASKED_PARAMETERS,
-    KEY_MOD_RANGE,
-    KEY_PUBLIC_KEY_1,
-    KEY_PUBLIC_KEY_2,
-    KEY_SAMPLE_NUMBER,
-    KEY_SECURE_ID,
-    KEY_SECURE_ID_LIST,
-    KEY_SHARE_LIST,
-    KEY_SHARE_NUMBER,
-    KEY_SOURCE_LIST,
-    KEY_STAGE,
-    KEY_TARGET_RANGE,
-    KEY_THRESHOLD,
     RECORD_KEY_CONFIGS,
     RECORD_KEY_STATE,
-    STAGE_COLLECT_MASKED_INPUT,
-    STAGE_SETUP,
-    STAGE_SHARE_KEYS,
-    STAGE_UNMASK,
-    STAGES,
+    Key,
+    Stage,
 )
 from flwr.common.secure_aggregation.secaggplus_utils import (
     pseudo_rand_gen,
@@ -91,7 +70,7 @@ from flwr.common.typing import ConfigsRecordValues, FitRes
 class SecAggPlusState:
     """State of the SecAgg+ protocol."""
 
-    current_stage: str = STAGE_UNMASK
+    current_stage: str = Stage.UNMASK
 
     sid: int = 0
     sample_num: int = 0
@@ -187,20 +166,20 @@ def secaggplus_mod(
     check_stage(state.current_stage, configs)
 
     # Update the current stage
-    state.current_stage = cast(str, configs.pop(KEY_STAGE))
+    state.current_stage = cast(str, configs.pop(Key.STAGE))
 
     # Check the validity of the configs based on the current stage
     check_configs(state.current_stage, configs)
 
     # Execute
-    if state.current_stage == STAGE_SETUP:
+    if state.current_stage == Stage.SETUP:
         res = _setup(state, configs)
-    elif state.current_stage == STAGE_SHARE_KEYS:
+    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_INPUT:
         fit = _get_fit_fn(msg, ctxt, call_next)
         res = _collect_masked_input(state, configs, fit)
-    elif state.current_stage == STAGE_UNMASK:
+    elif state.current_stage == Stage.UNMASK:
         res = _unmask(state, configs)
     else:
         raise ValueError(f"Unknown secagg stage: {state.current_stage}")
@@ -215,28 +194,29 @@ def secaggplus_mod(
 
 def check_stage(current_stage: str, configs: ConfigsRecord) -> None:
     """Check the validity of the next stage."""
-    # Check the existence of KEY_STAGE
-    if KEY_STAGE not in configs:
+    # 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 input `named_values`."
         )
 
-    # Check the value type of the KEY_STAGE
-    next_stage = configs[KEY_STAGE]
+    # Check the value type of the Config.STAGE
+    next_stage = configs[Key.STAGE]
     if not isinstance(next_stage, str):
         raise TypeError(
-            f"The value for the key '{KEY_STAGE}' must be of type {str}, "
+            f"The value for the key '{Key.STAGE}' must be of type {str}, "
             f"but got {type(next_stage)} instead."
         )
 
     # Check the validity of the next stage
-    if next_stage == STAGE_SETUP:
-        if current_stage != STAGE_UNMASK:
+    if next_stage == Stage.SETUP:
+        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
     else:
-        expected_next_stage = STAGES[(STAGES.index(current_stage) + 1) % len(STAGES)]
+        stages = Stage.all()
+        expected_next_stage = stages[(stages.index(current_stage) + 1) % len(stages)]
         if next_stage != expected_next_stage:
             raise ValueError(
                 "Abort secure aggregation: "
@@ -248,20 +228,20 @@ def check_stage(current_stage: str, configs: ConfigsRecord) -> None:
 def check_configs(stage: str, configs: ConfigsRecord) -> None:
     """Check the validity of the configs."""
     # Check `named_values` for the setup stage
-    if stage == STAGE_SETUP:
+    if stage == Stage.SETUP:
         key_type_pairs = [
-            (KEY_SAMPLE_NUMBER, int),
-            (KEY_SECURE_ID, int),
-            (KEY_SHARE_NUMBER, int),
-            (KEY_THRESHOLD, int),
-            (KEY_CLIPPING_RANGE, float),
-            (KEY_TARGET_RANGE, int),
-            (KEY_MOD_RANGE, int),
+            (Key.SAMPLE_NUMBER, int),
+            (Key.SECURE_ID, int),
+            (Key.SHARE_NUMBER, int),
+            (Key.THRESHOLD, int),
+            (Key.CLIPPING_RANGE, float),
+            (Key.TARGET_RANGE, int),
+            (Key.MOD_RANGE, int),
         ]
         for key, expected_type in key_type_pairs:
             if key not in configs:
                 raise KeyError(
-                    f"Stage {STAGE_SETUP}: the required key '{key}' is "
+                    f"Stage {Stage.SETUP}: the required key '{key}' is "
                     "missing from the input `named_values`."
                 )
             # Bool is a subclass of int in Python,
@@ -269,11 +249,11 @@ def check_configs(stage: str, configs: ConfigsRecord) -> None:
             # pylint: disable-next=unidiomatic-typecheck
             if type(configs[key]) is not expected_type:
                 raise TypeError(
-                    f"Stage {STAGE_SETUP}: The value for the key '{key}' "
+                    f"Stage {Stage.SETUP}: The value for the key '{key}' "
                     f"must be of type {expected_type}, "
                     f"but got {type(configs[key])} instead."
                 )
-    elif stage == STAGE_SHARE_KEYS:
+    elif stage == Stage.SHARE_KEYS:
         for key, value in configs.items():
             if (
                 not isinstance(value, list)
@@ -282,18 +262,18 @@ def check_configs(stage: str, configs: ConfigsRecord) -> None:
                 or not isinstance(value[1], bytes)
             ):
                 raise TypeError(
-                    f"Stage {STAGE_SHARE_KEYS}: "
+                    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_INPUT:
         key_type_pairs = [
-            (KEY_CIPHERTEXT_LIST, bytes),
-            (KEY_SOURCE_LIST, int),
+            (Key.CIPHERTEXT_LIST, bytes),
+            (Key.SOURCE_LIST, int),
         ]
         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_INPUT}: "
                     f"the required key '{key}' is "
                     "missing from the input `named_values`."
                 )
@@ -304,19 +284,19 @@ 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_INPUT}: "
                     f"the value for the key '{key}' "
                     f"must be of type List[{expected_type.__name__}]"
                 )
-    elif stage == STAGE_UNMASK:
+    elif stage == Stage.UNMASK:
         key_type_pairs = [
-            (KEY_ACTIVE_SECURE_ID_LIST, int),
-            (KEY_DEAD_SECURE_ID_LIST, int),
+            (Key.ACTIVE_SECURE_ID_LIST, int),
+            (Key.DEAD_SECURE_ID_LIST, int),
         ]
         for key, expected_type in key_type_pairs:
             if key not in configs:
                 raise KeyError(
-                    f"Stage {STAGE_UNMASK}: "
+                    f"Stage {Stage.UNMASK}: "
                     f"the required key '{key}' is "
                     "missing from the input `named_values`."
                 )
@@ -327,7 +307,7 @@ def check_configs(stage: str, configs: ConfigsRecord) -> None:
                 if type(elm) is not expected_type
             ):
                 raise TypeError(
-                    f"Stage {STAGE_UNMASK}: "
+                    f"Stage {Stage.UNMASK}: "
                     f"the value for the key '{key}' "
                     f"must be of type List[{expected_type.__name__}]"
                 )
@@ -340,15 +320,15 @@ def _setup(
 ) -> Dict[str, ConfigsRecordValues]:
     # Assigning parameter values to object fields
     sec_agg_param_dict = configs
-    state.sample_num = cast(int, sec_agg_param_dict[KEY_SAMPLE_NUMBER])
-    state.sid = cast(int, sec_agg_param_dict[KEY_SECURE_ID])
+    state.sample_num = cast(int, sec_agg_param_dict[Key.SAMPLE_NUMBER])
+    state.sid = cast(int, sec_agg_param_dict[Key.SECURE_ID])
     log(INFO, "Client %d: starting stage 0...", state.sid)
 
-    state.share_num = cast(int, sec_agg_param_dict[KEY_SHARE_NUMBER])
-    state.threshold = cast(int, sec_agg_param_dict[KEY_THRESHOLD])
-    state.clipping_range = cast(float, sec_agg_param_dict[KEY_CLIPPING_RANGE])
-    state.target_range = cast(int, sec_agg_param_dict[KEY_TARGET_RANGE])
-    state.mod_range = cast(int, sec_agg_param_dict[KEY_MOD_RANGE])
+    state.share_num = cast(int, sec_agg_param_dict[Key.SHARE_NUMBER])
+    state.threshold = cast(int, sec_agg_param_dict[Key.THRESHOLD])
+    state.clipping_range = cast(float, sec_agg_param_dict[Key.CLIPPING_RANGE])
+    state.target_range = cast(int, sec_agg_param_dict[Key.TARGET_RANGE])
+    state.mod_range = cast(int, sec_agg_param_dict[Key.MOD_RANGE])
 
     # Dictionaries containing client secure IDs as keys
     # and their respective secret shares as values.
@@ -367,7 +347,7 @@ def _setup(
     state.sk1, state.pk1 = private_key_to_bytes(sk1), public_key_to_bytes(pk1)
     state.sk2, state.pk2 = private_key_to_bytes(sk2), public_key_to_bytes(pk2)
     log(INFO, "Client %d: stage 0 completes. uploading public keys...", state.sid)
-    return {KEY_PUBLIC_KEY_1: state.pk1, KEY_PUBLIC_KEY_2: state.pk2}
+    return {Key.PUBLIC_KEY_1: state.pk1, Key.PUBLIC_KEY_2: state.pk2}
 
 
 # pylint: disable-next=too-many-locals
@@ -429,7 +409,7 @@ def _share_keys(
             ciphertexts.append(ciphertext)
 
     log(INFO, "Client %d: stage 1 completes. uploading key shares...", state.sid)
-    return {KEY_DESTINATION_LIST: dsts, KEY_CIPHERTEXT_LIST: ciphertexts}
+    return {Key.DESTINATION_LIST: dsts, Key.CIPHERTEXT_LIST: ciphertexts}
 
 
 # pylint: disable-next=too-many-locals
@@ -440,8 +420,8 @@ def _collect_masked_input(
 ) -> Dict[str, ConfigsRecordValues]:
     log(INFO, "Client %d: starting stage 2...", state.sid)
     available_clients: List[int] = []
-    ciphertexts = cast(List[bytes], configs[KEY_CIPHERTEXT_LIST])
-    srcs = cast(List[int], configs[KEY_SOURCE_LIST])
+    ciphertexts = cast(List[bytes], configs[Key.CIPHERTEXT_LIST])
+    srcs = cast(List[int], configs[Key.SOURCE_LIST])
     if len(ciphertexts) + 1 < state.threshold:
         raise ValueError("Not enough available neighbour clients.")
 
@@ -505,7 +485,7 @@ def _collect_masked_input(
     quantized_parameters = parameters_mod(quantized_parameters, state.mod_range)
     log(INFO, "Client %d: stage 2 completes. uploading masked parameters...", state.sid)
     return {
-        KEY_MASKED_PARAMETERS: [ndarray_to_bytes(arr) for arr in quantized_parameters]
+        Key.MASKED_PARAMETERS: [ndarray_to_bytes(arr) for arr in quantized_parameters]
     }
 
 
@@ -514,8 +494,8 @@ def _unmask(
 ) -> Dict[str, ConfigsRecordValues]:
     log(INFO, "Client %d: starting stage 3...", state.sid)
 
-    active_sids = cast(List[int], configs[KEY_ACTIVE_SECURE_ID_LIST])
-    dead_sids = cast(List[int], configs[KEY_DEAD_SECURE_ID_LIST])
+    active_sids = cast(List[int], configs[Key.ACTIVE_SECURE_ID_LIST])
+    dead_sids = cast(List[int], configs[Key.DEAD_SECURE_ID_LIST])
     # Send private mask seed share for every avaliable client (including itclient)
     # Send first private key share for building pairwise mask for every dropped client
     if len(active_sids) < state.threshold:
@@ -528,4 +508,4 @@ def _unmask(
     shares += [state.sk1_share_dict[sid] for sid in dead_sids]
 
     log(INFO, "Client %d: stage 3 completes. uploading key shares...", state.sid)
-    return {KEY_SECURE_ID_LIST: sids, KEY_SHARE_LIST: shares}
+    return {Key.SECURE_ID_LIST: sids, Key.SHARE_LIST: shares}

{flwr_nightly-1.8.0.dev20240227 → flwr_nightly-1.8.0.dev20240229}/src/py/flwr/common/differential_privacy.py

@@ -15,6 +15,9 @@
 """Utility functions for differential privacy."""
 
 
+from logging import WARNING
+from typing import Optional, Tuple
+
 import numpy as np
 
 from flwr.common import (
@@ -23,6 +26,7 @@ from flwr.common import (
     ndarrays_to_parameters,
     parameters_to_ndarrays,
 )
+from flwr.common.logger import log
 
 
 def get_norm(input_arrays: NDArrays) -> float:
@@ -72,6 +76,36 @@ def compute_clip_model_update(
         param1[i] = param2[i] + model_update[i]
 
 
+def adaptive_clip_inputs_inplace(input_arrays: NDArrays, clipping_norm: float) -> bool:
+    """Clip model update based on the clipping norm in-place.
+
+    It returns true if scaling_factor < 1 which is used for norm_bit
+    FlatClip method of the paper: https://arxiv.org/abs/1710.06963
+    """
+    input_norm = get_norm(input_arrays)
+    scaling_factor = min(1, clipping_norm / input_norm)
+    for array in input_arrays:
+        array *= scaling_factor
+    return scaling_factor < 1
+
+
+def compute_adaptive_clip_model_update(
+    param1: NDArrays, param2: NDArrays, clipping_norm: float
+) -> bool:
+    """Compute model update, clip it, then add the clipped value to param1.
+
+    model update = param1 - param2
+    Return the norm_bit
+    """
+    model_update = [np.subtract(x, y) for (x, y) in zip(param1, param2)]
+    norm_bit = adaptive_clip_inputs_inplace(model_update, clipping_norm)
+
+    for i, _ in enumerate(param2):
+        param1[i] = param2[i] + model_update[i]
+
+    return norm_bit
+
+
 def add_gaussian_noise_to_params(
     model_params: Parameters,
     noise_multiplier: float,
@@ -85,3 +119,46 @@ def add_gaussian_noise_to_params(
         compute_stdv(noise_multiplier, clipping_norm, num_sampled_clients),
     )
     return ndarrays_to_parameters(model_params_ndarrays)
+
+
+def compute_adaptive_noise_params(
+    noise_multiplier: float,
+    num_sampled_clients: float,
+    clipped_count_stddev: Optional[float],
+) -> Tuple[float, float]:
+    """Compute noising parameters for the adaptive clipping.
+
+    Paper: https://arxiv.org/abs/1905.03871
+    """
+    if noise_multiplier > 0:
+        if clipped_count_stddev is None:
+            clipped_count_stddev = num_sampled_clients / 20
+        if noise_multiplier >= 2 * clipped_count_stddev:
+            raise ValueError(
+                f"If not specified, `clipped_count_stddev` is set to "
+                f"`num_sampled_clients`/20 by default. This value "
+                f"({num_sampled_clients / 20}) is too low to achieve the "
+                f"desired effective `noise_multiplier` ({noise_multiplier}). "
+                f"Consider increasing `clipped_count_stddev` or decreasing "
+                f"`noise_multiplier`."
+            )
+        noise_multiplier_value = (
+            noise_multiplier ** (-2) - (2 * clipped_count_stddev) ** (-2)
+        ) ** -0.5
+
+        adding_noise = noise_multiplier_value / noise_multiplier
+        if adding_noise >= 2:
+            log(
+                WARNING,
+                "A significant amount of noise (%s) has to be "
+                "added. Consider increasing `clipped_count_stddev` or "
+                "`num_sampled_clients`.",
+                adding_noise,
+            )
+
+    else:
+        if clipped_count_stddev is None:
+            clipped_count_stddev = 0.0
+        noise_multiplier_value = 0.0
+
+    return clipped_count_stddev, noise_multiplier_value

{flwr_nightly-1.8.0.dev20240227 → flwr_nightly-1.8.0.dev20240229}/src/py/flwr/common/differential_privacy_constants.py

@@ -16,6 +16,7 @@
 
 
 KEY_CLIPPING_NORM = "clipping_norm"
+KEY_NORM_BIT = "norm_bit"
 CLIENTS_DISCREPANCY_WARNING = (
     "The number of clients returning parameters (%s)"
     " differs from the number of sampled clients (%s)."

flwr_nightly-1.8.0.dev20240229/src/py/flwr/common/secure_aggregation/secaggplus_constants.py

@@ -0,0 +1,68 @@
+# Copyright 2020 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 the SecAgg/SecAgg+ protocol."""
+
+
+from __future__ import annotations
+
+RECORD_KEY_STATE = "secaggplus_state"
+RECORD_KEY_CONFIGS = "secaggplus_configs"
+
+
+class Stage:
+    """Stages for the SecAgg+ protocol."""
+
+    SETUP = "setup"
+    SHARE_KEYS = "share_keys"
+    COLLECT_MASKED_INPUT = "collect_masked_input"
+    UNMASK = "unmask"
+    _stages = (SETUP, SHARE_KEYS, COLLECT_MASKED_INPUT, UNMASK)
+
+    @classmethod
+    def all(cls) -> tuple[str, str, str, str]:
+        """Return all stages."""
+        return cls._stages
+
+    def __new__(cls) -> Stage:
+        """Prevent instantiation."""
+        raise TypeError(f"{cls.__name__} cannot be instantiated.")
+
+
+class Key:
+    """Keys for the configs in the ConfigsRecord."""
+
+    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"
+    PUBLIC_KEY_1 = "pk1"
+    PUBLIC_KEY_2 = "pk2"
+    DESTINATION_LIST = "dsts"
+    CIPHERTEXT_LIST = "ctxts"
+    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"
+    SHARE_LIST = "shares"
+
+    def __new__(cls) -> Key:
+        """Prevent instantiation."""
+        raise TypeError(f"{cls.__name__} cannot be instantiated.")

flwr_nightly-1.8.0.dev20240229/src/py/flwr/proto/error_pb2.py

@@ -0,0 +1,26 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: flwr/proto/error.proto
+# Protobuf Python Version: 4.25.0
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x16\x66lwr/proto/error.proto\x12\nflwr.proto\"%\n\x05\x45rror\x12\x0c\n\x04\x63ode\x18\x01 \x01(\x12\x12\x0e\n\x06reason\x18\x02 \x01(\tb\x06proto3')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'flwr.proto.error_pb2', _globals)
+if _descriptor._USE_C_DESCRIPTORS == False:
+  DESCRIPTOR._options = None
+  _globals['_ERROR']._serialized_start=38
+  _globals['_ERROR']._serialized_end=75
+# @@protoc_insertion_point(module_scope)