flwr-nightly 1.22.0.dev20250918__py3-none-any.whl → 1.22.0.dev20250919__py3-none-any.whl

flwr/serverapp/strategy/qfedavg.py

@@ -0,0 +1,252 @@
+# Copyright 2025 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.
+# ==============================================================================
+"""Fair Resource Allocation in Federated Learning [Li et al., 2020] strategy.
+
+Paper: openreview.net/pdf?id=ByexElSYDr
+"""
+
+
+from collections import OrderedDict
+from collections.abc import Iterable
+from logging import INFO
+from typing import Callable, Optional
+
+import numpy as np
+
+from flwr.common import (
+    Array,
+    ArrayRecord,
+    ConfigRecord,
+    Message,
+    MetricRecord,
+    NDArray,
+    RecordDict,
+)
+from flwr.common.logger import log
+from flwr.server import Grid
+
+from ..exception import AggregationError
+from .fedavg import FedAvg
+
+
+class QFedAvg(FedAvg):
+    """Q-FedAvg strategy.
+
+    Implementation based on openreview.net/pdf?id=ByexElSYDr
+
+    Parameters
+    ----------
+    client_learning_rate : float
+        Local learning rate used by clients during training. This value is used by
+        the strategy to approximate the base Lipschitz constant L, via
+        L = 1 / client_learning_rate.
+    q : float (default: 0.1)
+        The parameter q that controls the degree of fairness of the algorithm. Please
+        tune this parameter based on your use case.
+        When set to 0, q-FedAvg is equivalent to FedAvg.
+    train_loss_key : str (default: "train_loss")
+        The key within the MetricRecord whose value is used as the training loss when
+        aggregating ArrayRecords following q-FedAvg.
+    fraction_train : float (default: 1.0)
+        Fraction of nodes used during training. In case `min_train_nodes`
+        is larger than `fraction_train * total_connected_nodes`, `min_train_nodes`
+        will still be sampled.
+    fraction_evaluate : float (default: 1.0)
+        Fraction of nodes used during validation. In case `min_evaluate_nodes`
+        is larger than `fraction_evaluate * total_connected_nodes`,
+        `min_evaluate_nodes` will still be sampled.
+    min_train_nodes : int (default: 2)
+        Minimum number of nodes used during training.
+    min_evaluate_nodes : int (default: 2)
+        Minimum number of nodes used during validation.
+    min_available_nodes : int (default: 2)
+        Minimum number of total nodes in the system.
+    weighted_by_key : str (default: "num-examples")
+        The key within each MetricRecord whose value is used as the weight when
+        computing weighted averages for MetricRecords.
+    arrayrecord_key : str (default: "arrays")
+        Key used to store the ArrayRecord when constructing Messages.
+    configrecord_key : str (default: "config")
+        Key used to store the ConfigRecord when constructing Messages.
+    train_metrics_aggr_fn : Optional[callable] (default: None)
+        Function with signature (list[RecordDict], str) -> MetricRecord,
+        used to aggregate MetricRecords from training round replies.
+        If `None`, defaults to `aggregate_metricrecords`, which performs a weighted
+        average using the provided weight factor key.
+    evaluate_metrics_aggr_fn : Optional[callable] (default: None)
+        Function with signature (list[RecordDict], str) -> MetricRecord,
+        used to aggregate MetricRecords from training round replies.
+        If `None`, defaults to `aggregate_metricrecords`, which performs a weighted
+        average using the provided weight factor key.
+    """
+
+    def __init__(  # pylint: disable=R0913, R0917
+        self,
+        client_learning_rate: float,
+        q: float = 0.1,
+        train_loss_key: str = "train_loss",
+        fraction_train: float = 1.0,
+        fraction_evaluate: float = 1.0,
+        min_train_nodes: int = 2,
+        min_evaluate_nodes: int = 2,
+        min_available_nodes: int = 2,
+        weighted_by_key: str = "num-examples",
+        arrayrecord_key: str = "arrays",
+        configrecord_key: str = "config",
+        train_metrics_aggr_fn: Optional[
+            Callable[[list[RecordDict], str], MetricRecord]
+        ] = None,
+        evaluate_metrics_aggr_fn: Optional[
+            Callable[[list[RecordDict], str], MetricRecord]
+        ] = None,
+    ) -> None:
+        super().__init__(
+            fraction_train=fraction_train,
+            fraction_evaluate=fraction_evaluate,
+            min_train_nodes=min_train_nodes,
+            min_evaluate_nodes=min_evaluate_nodes,
+            min_available_nodes=min_available_nodes,
+            weighted_by_key=weighted_by_key,
+            arrayrecord_key=arrayrecord_key,
+            configrecord_key=configrecord_key,
+            train_metrics_aggr_fn=train_metrics_aggr_fn,
+            evaluate_metrics_aggr_fn=evaluate_metrics_aggr_fn,
+        )
+        self.q = q
+        self.client_learning_rate = client_learning_rate
+        self.train_loss_key = train_loss_key
+        self.current_arrays: Optional[ArrayRecord] = None
+
+    def summary(self) -> None:
+        """Log summary configuration of the strategy."""
+        log(INFO, "\t├──> q-FedAvg settings:")
+        log(INFO, "\t│\t├── client_learning_rate: %s", self.client_learning_rate)
+        log(INFO, "\t│\t├── q: %s", self.q)
+        log(INFO, "\t│\t└── train_loss_key: '%s'", self.train_loss_key)
+        super().summary()
+
+    def configure_train(
+        self, server_round: int, arrays: ArrayRecord, config: ConfigRecord, grid: Grid
+    ) -> Iterable[Message]:
+        """Configure the next round of federated training."""
+        self.current_arrays = arrays.copy()
+        return super().configure_train(server_round, arrays, config, grid)
+
+    def aggregate_train(  # pylint: disable=too-many-locals
+        self,
+        server_round: int,
+        replies: Iterable[Message],
+    ) -> tuple[Optional[ArrayRecord], Optional[MetricRecord]]:
+        """Aggregate ArrayRecords and MetricRecords in the received Messages."""
+        # Call FedAvg aggregate_train to perform validation and aggregation
+        valid_replies, _ = self._check_and_log_replies(replies, is_train=True)
+
+        if not valid_replies:
+            return None, None
+
+        # Compute estimate of Lipschitz constant L
+        L = 1.0 / self.client_learning_rate  # pylint: disable=C0103
+
+        # q-FedAvg aggregation
+        if self.current_arrays is None:
+            raise AggregationError(
+                "Current global model weights are not available. Make sure to call"
+                "`configure_train` before calling `aggregate_train`."
+            )
+        array_keys = list(self.current_arrays.keys())  # Preserve keys
+        global_weights = self.current_arrays.to_numpy_ndarrays(keep_input=False)
+        sum_delta = None
+        sum_h = 0.0
+
+        for msg in valid_replies:
+            # Extract local weights and training loss from Message
+            local_weights = get_local_weights(msg)
+            loss = get_train_loss(msg, self.train_loss_key)
+
+            # Compute delta and h
+            delta, h = compute_delta_and_h(
+                global_weights, local_weights, self.q, L, loss
+            )
+
+            # Compute sum of deltas and sum of h
+            if sum_delta is None:
+                sum_delta = delta
+            else:
+                sum_delta = [sd + d for sd, d in zip(sum_delta, delta)]
+            sum_h += h
+
+        # Compute new global weights and convert to Array type
+        # `np.asarray` can convert numpy scalars to 0-dim arrays
+        assert sum_delta is not None  # Make mypy happy
+        array_list = [
+            Array(np.asarray(gw - (d / sum_h)))
+            for gw, d in zip(global_weights, sum_delta)
+        ]
+
+        # Aggregate MetricRecords
+        metrics = self.train_metrics_aggr_fn(
+            [msg.content for msg in valid_replies],
+            self.weighted_by_key,
+        )
+        return ArrayRecord(OrderedDict(zip(array_keys, array_list))), metrics
+
+
+def get_train_loss(msg: Message, loss_key: str) -> float:
+    """Extract training loss from a Message."""
+    metrics = list(msg.content.metric_records.values())[0]
+    if (loss := metrics.get(loss_key)) is None or not isinstance(loss, (int, float)):
+        raise AggregationError(
+            "Missing or invalid training loss. "
+            f"The strategy expected a float value for the key '{loss_key}' "
+            "as the training loss in each MetricRecord from the clients. "
+            f"Ensure that '{loss_key}' is present and maps to a valid float."
+        )
+    return float(loss)
+
+
+def get_local_weights(msg: Message) -> list[NDArray]:
+    """Extract local weights from a Message."""
+    arrays = list(msg.content.array_records.values())[0]
+    return arrays.to_numpy_ndarrays(keep_input=False)
+
+
+def l2_norm(ndarrays: list[NDArray]) -> float:
+    """Compute the squared L2 norm of a list of numpy.ndarray."""
+    return float(sum(np.sum(np.square(g)) for g in ndarrays))
+
+
+def compute_delta_and_h(
+    global_weights: list[NDArray],
+    local_weights: list[NDArray],
+    q: float,
+    L: float,  # Lipschitz constant  # pylint: disable=C0103
+    loss: float,
+) -> tuple[list[NDArray], float]:
+    """Compute delta and h used in q-FedAvg aggregation."""
+    # Compute gradient_k = L * (w - w_k)
+    for gw, lw in zip(global_weights, local_weights):
+        np.subtract(gw, lw, out=lw)
+        lw *= L
+    grad = local_weights  # After in-place operations, local_weights is now grad
+    # Compute ||w_k - w||^2
+    norm = l2_norm(grad)
+    # Compute delta_k = loss_k^q * gradient_k
+    loss_pow_q: float = np.float_power(loss + 1e-10, q)
+    for g in grad:
+        g *= loss_pow_q
+    delta = grad  # After in-place multiplication, grad is now delta
+    # Compute h_k
+    h = q * np.float_power(loss + 1e-10, q - 1) * norm + L * loss_pow_q
+    return delta, h

{flwr_nightly-1.22.0.dev20250918.dist-info → flwr_nightly-1.22.0.dev20250919.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: flwr-nightly
-Version: 1.22.0.dev20250918
+Version: 1.22.0.dev20250919
 Summary: Flower: A Friendly Federated AI Framework
 License: Apache-2.0
 Keywords: Artificial Intelligence,Federated AI,Federated Analytics,Federated Evaluation,Federated Learning,Flower,Machine Learning

{flwr_nightly-1.22.0.dev20250918.dist-info → flwr_nightly-1.22.0.dev20250919.dist-info}/RECORD

@@ -113,15 +113,16 @@ flwr/client/rest_client/connection.py,sha256=fyiS1aXTv71jWczx7mSco94LYJTBXgTF-p2
 flwr/client/run_info_store.py,sha256=MaJ3UQ-07hWtK67wnWu0zR29jrk0fsfgJX506dvEOfE,4042
 flwr/client/typing.py,sha256=Jw3rawDzI_-ZDcRmEQcs5gZModY7oeQlEeltYsdOhlU,1048
 flwr/clientapp/__init__.py,sha256=uoTjvIynfGvMhsmc7iYK-5qJ0AdKKjCbx7WTKc0KeSk,828
-flwr/clientapp/mod/__init__.py,sha256=o8bbHMYb_aiPbGp6guRA-I_gCJaJQ6mCqSRZdfBYYrs,920
-flwr/clientapp/mod/centraldp_mods.py,sha256=M8vvdrjfLVsFLMd9JXqD_-P08q9jsNOgu_4AAs-X9Zk,4626
+flwr/clientapp/mod/__init__.py,sha256=LZveV-U2YZVEH4FyAZMXMT-aD1Hc0I5miIkDr7p6uQQ,970
+flwr/clientapp/mod/centraldp_mods.py,sha256=a-F-ELs3lt_wtmLl8900ExJiIY792cPCrmwmJKRrerI,8950
+flwr/clientapp/typing.py,sha256=x1GvXWy112RqZh27liJqz-yZ7SSCOwiOSmAQsUxk9MY,853
 flwr/common/__init__.py,sha256=5GCLVk399Az_rTJHNticRlL0Sl_oPw_j5_LuFKfX7-M,4171
 flwr/common/address.py,sha256=9JucdTwlc-jpeJkRKeUboZoacUtErwSVtnDR9kAtLqE,4119
 flwr/common/args.py,sha256=Nq2u4yePbkSY0CWFamn0hZY6Rms8G1xYDeDGIcLIITE,5849
 flwr/common/auth_plugin/__init__.py,sha256=DktrRcGZrRarLf7Jb_UlHtOyLp9_-kEplyq6PS5-vOA,988
 flwr/common/auth_plugin/auth_plugin.py,sha256=mM7SuphO4OsVAVJR1GErYVgYT83ZjxDzS_gha12bT9E,4855
 flwr/common/config.py,sha256=glcZDjco-amw1YfQcYTFJ4S1pt9APoexT-mf1QscuHs,13960
-flwr/common/constant.py,sha256=zopMTlEgz8TxMSh59ueef6VutHSdfb3XRStl1W5yBZ4,9013
+flwr/common/constant.py,sha256=y3yKgr1UxAWveUkw29z8KM2hKsZJqhHUqPPhKQeef80,9045
 flwr/common/context.py,sha256=Be8obQR_OvEDy1OmshuUKxGRQ7Qx89mf5F4xlhkR10s,2407
 flwr/common/date.py,sha256=1ZT2cRSpC2DJqprOVTLXYCR_O2_OZR0zXO_brJ3LqWc,1554
 flwr/common/differential_privacy.py,sha256=FdlpdpPl_H_2HJa8CQM1iCUGBBQ5Dc8CzxmHERM-EoE,6148
@@ -152,7 +153,7 @@ flwr/common/record/configrecord.py,sha256=G7U0q39kB0Kyi0zMxFmPxcVemL9NgwVS1qjvI4
 flwr/common/record/conversion_utils.py,sha256=wbNCzy7oAqaA3-arhls_EqRZYXRC4YrWIoE-Gy82fJ0,1191
 flwr/common/record/metricrecord.py,sha256=KOyJjJbvFV6IwBPbgm92FZ_0_hXpMHuwfCi1rh5Zddk,8954
 flwr/common/record/recorddict.py,sha256=p7hBimFpKM1XKUe6OAkR_7pYGzGL_EwUJUvJ8odZEcY,14986
-flwr/common/record/typeddict.py,sha256=dDKgUThs2BscYUNcgP82KP8-qfAYXYftDrf2LszAC_o,3599
+flwr/common/record/typeddict.py,sha256=NkHvzTEiicrLstryvTb-2O-sMvtsLgsOjAbostSf1z0,4102
 flwr/common/recorddict_compat.py,sha256=D5SqXWkqBddn5b6K_5UoH7aZ11UaN3lDTlzvHx3-rqk,14119
 flwr/common/retry_invoker.py,sha256=uQeDcgoTgmFwhJ0mkDE2eNz2acF9eShaqMOO5boGrPQ,15285
 flwr/common/secure_aggregation/__init__.py,sha256=MgW6uHGhyFLBAYQqa1Vzs5n2Gc0d4yEw1_NmerFir70,731
@@ -335,21 +336,23 @@ flwr/server/workflow/secure_aggregation/__init__.py,sha256=vGkycLb65CxdaMkKsANxQ
 flwr/server/workflow/secure_aggregation/secagg_workflow.py,sha256=b_pKk7gmbahwyj0ftOOLXvu-AMtRHEc82N9PJTEO8dc,5839
 flwr/server/workflow/secure_aggregation/secaggplus_workflow.py,sha256=DkayCsnlAya6Y2PZsueLgoUCMRtV-GbnW08RfWx_SXM,29460
 flwr/serverapp/__init__.py,sha256=ZujKNXULwhWYQhFnxOOT5Wi9MRq2JCWFhAAj7ouiQ78,884
-flwr/serverapp/dp_fixed_clipping.py,sha256=wbP4W7CaUHXdll8ZSVUnTBSEWrnWM00CGk63rOR-Q2s,12133
 flwr/serverapp/exception.py,sha256=5cuH-2AafvihzosWDdDjuMmHdDqZ1XxHvCqZXNBVklw,1334
-flwr/serverapp/strategy/__init__.py,sha256=mt2l31EAQ9oSvBcQhk4Jj4SvTePmWzBHQxZqL1v0uhE,1552
-flwr/serverapp/strategy/dp_fixed_clipping.py,sha256=wbP4W7CaUHXdll8ZSVUnTBSEWrnWM00CGk63rOR-Q2s,12133
-flwr/serverapp/strategy/fedadagrad.py,sha256=fD65P6OEERa_pxq847e1UZpA083AcWR44XavYB0naGM,6343
-flwr/serverapp/strategy/fedadam.py,sha256=s3xPIqhopy6yPTeFxevSPnc7a6BcKnKsvo2AaO6Z_xs,7138
+flwr/serverapp/strategy/__init__.py,sha256=QQFa0uMXWrSCTVbd7Ixk_48U6o3K-g4nLYYJUhEVbfo,1877
+flwr/serverapp/strategy/dp_adaptive_clipping.py,sha256=mssiVGMgfJw8DeP6_pBSZUKWmaXvYeG-B-p7RSt2tAU,13600
+flwr/serverapp/strategy/dp_fixed_clipping.py,sha256=C_faT0ggzeUB2bGv_r1Vss-fv7-UhDrpmfiHATESI0w,12832
+flwr/serverapp/strategy/fedadagrad.py,sha256=faFsuKZziPTCLeNrJOyKbPTNo-1xrIZOz7SWT5rdjJs,6269
+flwr/serverapp/strategy/fedadam.py,sha256=NsY_V6TGFAfCeA9vmqaLpvB_T5siJEtKozKGdxJssAI,7064
 flwr/serverapp/strategy/fedavg.py,sha256=Bq_nlmngzJbjqX1fF1mevXGVN6-pwglHv-6yNrs6lkA,12035
-flwr/serverapp/strategy/fedavgm.py,sha256=VlByltWzUYCoiVIWPFRqsqLKNWjlOlO2INK8SUxEjzk,8327
+flwr/serverapp/strategy/fedavgm.py,sha256=FtFmBGLzuUQ_7JWk85Xh19d8sP0YDwqczGTliGzZyGs,8333
 flwr/serverapp/strategy/fedmedian.py,sha256=b31Dk0LQBbQxi_f-jeSbWHI7iOBugcuBSN2Az-_a75E,2596
 flwr/serverapp/strategy/fedopt.py,sha256=kqT0uV2IUE93O72XEVa1JJo61dcwbZEoT9KmYTjR2tE,8477
-flwr/serverapp/strategy/fedprox.py,sha256=XkkLTk3XpXAj0QoAzHqAvcAlPjrNlX11ISAu5u2x6X8,7026
-flwr/serverapp/strategy/fedtrimmedavg.py,sha256=4-QxgAQGo_7vB_L7qDYy28d95OBt9MeDa92yaTRMHqk,7166
+flwr/serverapp/strategy/fedprox.py,sha256=J1KrcE5DFko6i4608iICv1G0t9MPXspjibPd-SF_HT8,7028
+flwr/serverapp/strategy/fedtrimmedavg.py,sha256=58xDPc_YO41QM8jXn0gZ79PFzO8zo3Mh3UlkF0UBbIA,7168
 flwr/serverapp/strategy/fedxgb_bagging.py,sha256=ktDjzov4y0BRecioq788umCEtcuwElou9olBizQKOnM,3282
 flwr/serverapp/strategy/fedxgb_cyclic.py,sha256=8H8WoLdG4Fy1_dtLLE4AYiidC-Cvaw2GxySfzAb7Xj0,8774
-flwr/serverapp/strategy/fedyogi.py,sha256=1Ripr4Hi2cdeTOLiFOXtMKvOxR3BsUQwc7bbTrXN4LM,6653
+flwr/serverapp/strategy/fedyogi.py,sha256=Y9RFBQaNch3fPgGXF7OfnTH6eOpavZxpMWxWVIC9_SY,6579
+flwr/serverapp/strategy/krum.py,sha256=iUM7MFCKQcSqUO3Eu4JKWnMc8NV0WMQW9dZXm4onQ-s,9490
+flwr/serverapp/strategy/qfedavg.py,sha256=EM1tO_ovkybOBeW-h1PYX0lszCUAVHT6hUpwXykAEps,10204
 flwr/serverapp/strategy/result.py,sha256=E0Hl2VLnZAgQJjE2GDoKsK7JX-kPPU2KXc47Axt6hGw,4295
 flwr/serverapp/strategy/strategy.py,sha256=8uJGGm1ROLZERQ_dkRS7Z_rs-yK6XCE0UxXtIdFiEWk,10789
 flwr/serverapp/strategy/strategy_utils.py,sha256=hiwS7k-Hx6_c4NZXoKpHucS5CBKb7f8GppXRBSMt3Us,10851
@@ -416,7 +419,7 @@ flwr/supernode/servicer/__init__.py,sha256=lucTzre5WPK7G1YLCfaqg3rbFWdNSb7ZTt-ca
 flwr/supernode/servicer/clientappio/__init__.py,sha256=7Oy62Y_oijqF7Dxi6tpcUQyOpLc_QpIRZ83NvwmB0Yg,813
 flwr/supernode/servicer/clientappio/clientappio_servicer.py,sha256=nIHRu38EWK-rpNOkcgBRAAKwYQQWFeCwu0lkO7OPZGQ,10239
 flwr/supernode/start_client_internal.py,sha256=Y9S1-QlO2WP6eo4JvWzIpfaCoh2aoE7bjEYyxNNnlyg,20777
-flwr_nightly-1.22.0.dev20250918.dist-info/METADATA,sha256=XdvpDYzZ_dWvMX49Pwi2gOUo0qLtrt466UABjDeyavg,14559
-flwr_nightly-1.22.0.dev20250918.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-flwr_nightly-1.22.0.dev20250918.dist-info/entry_points.txt,sha256=hxHD2ixb_vJFDOlZV-zB4Ao32_BQlL34ftsDh1GXv14,420
-flwr_nightly-1.22.0.dev20250918.dist-info/RECORD,,
+flwr_nightly-1.22.0.dev20250919.dist-info/METADATA,sha256=RuNCBGYrX4Df-vdIVKJ6Do1uDfeKomIIJ557ZlE8uLI,14559
+flwr_nightly-1.22.0.dev20250919.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+flwr_nightly-1.22.0.dev20250919.dist-info/entry_points.txt,sha256=hxHD2ixb_vJFDOlZV-zB4Ao32_BQlL34ftsDh1GXv14,420
+flwr_nightly-1.22.0.dev20250919.dist-info/RECORD,,

flwr/serverapp/dp_fixed_clipping.py

@@ -1,352 +0,0 @@
-# Copyright 2025 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.
-# ==============================================================================
-"""Message-based Central differential privacy with fixed clipping.
-
-Papers: https://arxiv.org/abs/1712.07557, https://arxiv.org/abs/1710.06963
-"""
-
-from abc import ABC
-from collections import OrderedDict
-from collections.abc import Iterable
-from logging import INFO, WARNING
-from typing import Optional
-
-from flwr.common import Array, ArrayRecord, ConfigRecord, Message, MetricRecord, log
-from flwr.common.differential_privacy import (
-    add_gaussian_noise_inplace,
-    compute_clip_model_update,
-    compute_stdv,
-)
-from flwr.common.differential_privacy_constants import (
-    CLIENTS_DISCREPANCY_WARNING,
-    KEY_CLIPPING_NORM,
-)
-from flwr.server import Grid
-
-from .strategy import Strategy
-
-
-class DifferentialPrivacyFixedClippingBase(Strategy, ABC):
-    """Base class for DP strategies with fixed clipping.
-
-    This class contains common functionality shared between server-side and
-    client-side fixed clipping implementations.
-
-    Parameters
-    ----------
-    strategy : Strategy
-        The strategy to which DP functionalities will be added by this wrapper.
-    noise_multiplier : float
-        The noise multiplier for the Gaussian mechanism for model updates.
-        A value of 1.0 or higher is recommended for strong privacy.
-    clipping_norm : float
-        The value of the clipping norm.
-    num_sampled_clients : int
-        The number of clients that are sampled on each round.
-    """
-
-    # pylint: disable=too-many-arguments,too-many-instance-attributes
-    def __init__(
-        self,
-        strategy: Strategy,
-        noise_multiplier: float,
-        clipping_norm: float,
-        num_sampled_clients: int,
-    ) -> None:
-        super().__init__()
-
-        self.strategy = strategy
-
-        if noise_multiplier < 0:
-            raise ValueError("The noise multiplier should be a non-negative value.")
-
-        if clipping_norm <= 0:
-            raise ValueError("The clipping norm should be a positive value.")
-
-        if num_sampled_clients <= 0:
-            raise ValueError(
-                "The number of sampled clients should be a positive value."
-            )
-
-        self.noise_multiplier = noise_multiplier
-        self.clipping_norm = clipping_norm
-        self.num_sampled_clients = num_sampled_clients
-
-    def _validate_replies(self, replies: Iterable[Message]) -> bool:
-        """Validate replies and log errors/warnings.
-
-        Returns
-        -------
-        bool
-            True if replies are valid for aggregation, False otherwise.
-        """
-        num_errors = 0
-        num_replies_with_content = 0
-        for msg in replies:
-            if msg.has_error():
-                log(
-                    INFO,
-                    "Received error in reply from node %d: %s",
-                    msg.metadata.src_node_id,
-                    msg.error,
-                )
-                num_errors += 1
-            else:
-                num_replies_with_content += 1
-
-        # Errors are not allowed
-        if num_errors:
-            log(
-                INFO,
-                "aggregate_train: Some clients reported errors. Skipping aggregation.",
-            )
-            return False
-
-        log(
-            INFO,
-            "aggregate_train: Received %s results and %s failures",
-            num_replies_with_content,
-            num_errors,
-        )
-
-        if num_replies_with_content != self.num_sampled_clients:
-            log(
-                WARNING,
-                CLIENTS_DISCREPANCY_WARNING,
-                num_replies_with_content,
-                self.num_sampled_clients,
-            )
-
-        return True
-
-    def _add_noise_to_aggregated_arrays(
-        self, aggregated_arrays: ArrayRecord
-    ) -> ArrayRecord:
-        """Add Gaussian noise to aggregated arrays.
-
-        Parameters
-        ----------
-        aggregated_arrays : ArrayRecord
-            The aggregated arrays to add noise to.
-
-        Returns
-        -------
-        ArrayRecord
-            The aggregated arrays with noise added.
-        """
-        aggregated_ndarrays = aggregated_arrays.to_numpy_ndarrays()
-        stdv = compute_stdv(
-            self.noise_multiplier, self.clipping_norm, self.num_sampled_clients
-        )
-        add_gaussian_noise_inplace(aggregated_ndarrays, stdv)
-
-        log(
-            INFO,
-            "aggregate_fit: central DP noise with %.4f stdev added",
-            stdv,
-        )
-
-        return ArrayRecord(
-            OrderedDict(
-                {
-                    k: Array(v)
-                    for k, v in zip(aggregated_arrays.keys(), aggregated_ndarrays)
-                }
-            )
-        )
-
-    def configure_evaluate(
-        self, server_round: int, arrays: ArrayRecord, config: ConfigRecord, grid: Grid
-    ) -> Iterable[Message]:
-        """Configure the next round of federated evaluation."""
-        return self.strategy.configure_evaluate(server_round, arrays, config, grid)
-
-    def aggregate_evaluate(
-        self,
-        server_round: int,
-        replies: Iterable[Message],
-    ) -> Optional[MetricRecord]:
-        """Aggregate MetricRecords in the received Messages."""
-        return self.strategy.aggregate_evaluate(server_round, replies)
-
-    def summary(self) -> None:
-        """Log summary configuration of the strategy."""
-        self.strategy.summary()
-
-
-class DifferentialPrivacyServerSideFixedClipping(DifferentialPrivacyFixedClippingBase):
-    """Strategy wrapper for central DP with server-side fixed clipping.
-
-    Parameters
-    ----------
-    strategy : Strategy
-        The strategy to which DP functionalities will be added by this wrapper.
-    noise_multiplier : float
-        The noise multiplier for the Gaussian mechanism for model updates.
-        A value of 1.0 or higher is recommended for strong privacy.
-    clipping_norm : float
-        The value of the clipping norm.
-    num_sampled_clients : int
-        The number of clients that are sampled on each round.
-
-    Examples
-    --------
-    Create a strategy::
-
-        strategy = fl.serverapp.FedAvg( ... )
-
-    Wrap the strategy with the `DifferentialPrivacyServerSideFixedClipping` wrapper::
-
-        dp_strategy = DifferentialPrivacyServerSideFixedClipping(
-            strategy, cfg.noise_multiplier, cfg.clipping_norm, cfg.num_sampled_clients
-        )
-    """
-
-    def __init__(
-        self,
-        strategy: Strategy,
-        noise_multiplier: float,
-        clipping_norm: float,
-        num_sampled_clients: int,
-    ) -> None:
-        super().__init__(strategy, noise_multiplier, clipping_norm, num_sampled_clients)
-        self.current_arrays: ArrayRecord = ArrayRecord()
-
-    def __repr__(self) -> str:
-        """Compute a string representation of the strategy."""
-        return "Differential Privacy Strategy Wrapper (Server-Side Fixed Clipping)"
-
-    def configure_train(
-        self, server_round: int, arrays: ArrayRecord, config: ConfigRecord, grid: Grid
-    ) -> Iterable[Message]:
-        """Configure the next round of training."""
-        self.current_arrays = arrays
-        return self.strategy.configure_train(server_round, arrays, config, grid)
-
-    def aggregate_train(
-        self,
-        server_round: int,
-        replies: Iterable[Message],
-    ) -> tuple[Optional[ArrayRecord], Optional[MetricRecord]]:
-        """Aggregate ArrayRecords and MetricRecords in the received Messages."""
-        if not self._validate_replies(replies):
-            return None, None
-
-        # Clip arrays in replies
-        current_ndarrays = self.current_arrays.to_numpy_ndarrays()
-        for reply in replies:
-            for arr_name, record in reply.content.array_records.items():
-                # Clip
-                reply_ndarrays = record.to_numpy_ndarrays()
-                compute_clip_model_update(
-                    param1=reply_ndarrays,
-                    param2=current_ndarrays,
-                    clipping_norm=self.clipping_norm,
-                )
-                # Replace content while preserving keys
-                reply.content[arr_name] = ArrayRecord(
-                    OrderedDict(
-                        {k: Array(v) for k, v in zip(record.keys(), reply_ndarrays)}
-                    )
-                )
-            log(
-                INFO,
-                "aggregate_fit: parameters are clipped by value: %.4f.",
-                self.clipping_norm,
-            )
-
-        # Pass the new parameters for aggregation
-        aggregated_arrays, aggregated_metrics = self.strategy.aggregate_train(
-            server_round, replies
-        )
-
-        # Add Gaussian noise to the aggregated arrays
-        if aggregated_arrays:
-            aggregated_arrays = self._add_noise_to_aggregated_arrays(aggregated_arrays)
-
-        return aggregated_arrays, aggregated_metrics
-
-
-class DifferentialPrivacyClientSideFixedClipping(DifferentialPrivacyFixedClippingBase):
-    """Strategy wrapper for central DP with client-side fixed clipping.
-
-    Use `fixedclipping_mod` modifier at the client side.
-
-    In comparison to `DifferentialPrivacyServerSideFixedClipping`,
-    which performs clipping on the server-side,
-    `DifferentialPrivacyClientSideFixedClipping` expects clipping to happen
-    on the client-side, usually by using the built-in `fixedclipping_mod`.
-
-    Parameters
-    ----------
-    strategy : Strategy
-        The strategy to which DP functionalities will be added by this wrapper.
-    noise_multiplier : float
-        The noise multiplier for the Gaussian mechanism for model updates.
-        A value of 1.0 or higher is recommended for strong privacy.
-    clipping_norm : float
-        The value of the clipping norm.
-    num_sampled_clients : int
-        The number of clients that are sampled on each round.
-
-    Examples
-    --------
-    Create a strategy::
-
-        strategy = fl.serverapp.FedAvg(...)
-
-    Wrap the strategy with the `DifferentialPrivacyClientSideFixedClipping` wrapper::
-
-        dp_strategy = DifferentialPrivacyClientSideFixedClipping(
-            strategy, cfg.noise_multiplier, cfg.clipping_norm, cfg.num_sampled_clients
-        )
-
-    On the client, add the `fixedclipping_mod` to the client-side mods::
-
-        app = fl.client.ClientApp(mods=[fixedclipping_mod])
-    """
-
-    def __repr__(self) -> str:
-        """Compute a string representation of the strategy."""
-        return "Differential Privacy Strategy Wrapper (Client-Side Fixed Clipping)"
-
-    def configure_train(
-        self, server_round: int, arrays: ArrayRecord, config: ConfigRecord, grid: Grid
-    ) -> Iterable[Message]:
-        """Configure the next round of training."""
-        # Inject clipping norm in config
-        config[KEY_CLIPPING_NORM] = self.clipping_norm
-        # Call parent method
-        return self.strategy.configure_train(server_round, arrays, config, grid)
-
-    def aggregate_train(
-        self,
-        server_round: int,
-        replies: Iterable[Message],
-    ) -> tuple[Optional[ArrayRecord], Optional[MetricRecord]]:
-        """Aggregate ArrayRecords and MetricRecords in the received Messages."""
-        if not self._validate_replies(replies):
-            return None, None
-
-        # Aggregate
-        aggregated_arrays, aggregated_metrics = self.strategy.aggregate_train(
-            server_round, replies
-        )
-
-        # Add Gaussian noise to the aggregated arrays
-        if aggregated_arrays:
-            aggregated_arrays = self._add_noise_to_aggregated_arrays(aggregated_arrays)
-
-        return aggregated_arrays, aggregated_metrics