flwr-nightly 1.22.0.dev20250920__tar.gz → 1.23.0.dev20250922__tar.gz

{flwr_nightly-1.22.0.dev20250920 → flwr_nightly-1.23.0.dev20250922}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: flwr-nightly
-Version: 1.22.0.dev20250920
+Version: 1.23.0.dev20250922
 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.dev20250920 → flwr_nightly-1.23.0.dev20250922}/py/flwr/cli/new/templates/app/pyproject.baseline.toml.tpl

@@ -14,7 +14,7 @@ description = ""
 license = "Apache-2.0"
 # Dependencies for your Flower App
 dependencies = [
-    "flwr[simulation]>=1.22.0",
+    "flwr[simulation]>=1.23.0",
     "flwr-datasets[vision]>=0.5.0",
     "torch==2.8.0",
     "torchvision==0.23.0",

{flwr_nightly-1.22.0.dev20250920 → flwr_nightly-1.23.0.dev20250922}/py/flwr/cli/new/templates/app/pyproject.flowertune.toml.tpl

@@ -14,7 +14,7 @@ description = ""
 license = "Apache-2.0"
 # Dependencies for your Flower App
 dependencies = [
-    "flwr[simulation]>=1.22.0",
+    "flwr[simulation]>=1.23.0",
     "flwr-datasets>=0.5.0",
     "torch==2.4.0",
     "trl==0.8.1",

{flwr_nightly-1.22.0.dev20250920 → flwr_nightly-1.23.0.dev20250922}/py/flwr/cli/new/templates/app/pyproject.huggingface.toml.tpl

@@ -14,7 +14,7 @@ description = ""
 license = "Apache-2.0"
 # Dependencies for your Flower App
 dependencies = [
-    "flwr[simulation]>=1.22.0",
+    "flwr[simulation]>=1.23.0",
     "flwr-datasets>=0.5.0",
     "torch>=2.7.1",
     "transformers>=4.30.0,<5.0",

{flwr_nightly-1.22.0.dev20250920 → flwr_nightly-1.23.0.dev20250922}/py/flwr/cli/new/templates/app/pyproject.jax.toml.tpl

@@ -14,7 +14,7 @@ description = ""
 license = "Apache-2.0"
 # Dependencies for your Flower App
 dependencies = [
-    "flwr[simulation]>=1.22.0",
+    "flwr[simulation]>=1.23.0",
     "jax==0.4.30",
     "jaxlib==0.4.30",
     "scikit-learn==1.6.1",

{flwr_nightly-1.22.0.dev20250920 → flwr_nightly-1.23.0.dev20250922}/py/flwr/cli/new/templates/app/pyproject.mlx.toml.tpl

@@ -14,7 +14,7 @@ description = ""
 license = "Apache-2.0"
 # Dependencies for your Flower App
 dependencies = [
-    "flwr[simulation]>=1.22.0",
+    "flwr[simulation]>=1.23.0",
     "flwr-datasets[vision]>=0.5.0",
     "mlx==0.29.0",
 ]

{flwr_nightly-1.22.0.dev20250920 → flwr_nightly-1.23.0.dev20250922}/py/flwr/cli/new/templates/app/pyproject.numpy.toml.tpl

@@ -14,7 +14,7 @@ description = ""
 license = "Apache-2.0"
 # Dependencies for your Flower App
 dependencies = [
-    "flwr[simulation]>=1.22.0",
+    "flwr[simulation]>=1.23.0",
     "numpy>=2.0.2",
 ]
 

{flwr_nightly-1.22.0.dev20250920 → flwr_nightly-1.23.0.dev20250922}/py/flwr/cli/new/templates/app/pyproject.pytorch.toml.tpl

@@ -14,7 +14,7 @@ description = ""
 license = "Apache-2.0"
 # Dependencies for your Flower App
 dependencies = [
-    "flwr[simulation]>=1.22.0",
+    "flwr[simulation]>=1.23.0",
     "flwr-datasets[vision]>=0.5.0",
     "torch==2.7.1",
     "torchvision==0.22.1",

{flwr_nightly-1.22.0.dev20250920 → flwr_nightly-1.23.0.dev20250922}/py/flwr/cli/new/templates/app/pyproject.pytorch_legacy_api.toml.tpl

@@ -14,7 +14,7 @@ description = ""
 license = "Apache-2.0"
 # Dependencies for your Flower App
 dependencies = [
-    "flwr[simulation]>=1.22.0",
+    "flwr[simulation]>=1.23.0",
     "flwr-datasets[vision]>=0.5.0",
     "torch==2.7.1",
     "torchvision==0.22.1",

{flwr_nightly-1.22.0.dev20250920 → flwr_nightly-1.23.0.dev20250922}/py/flwr/cli/new/templates/app/pyproject.sklearn.toml.tpl

@@ -14,7 +14,7 @@ description = ""
 license = "Apache-2.0"
 # Dependencies for your Flower App
 dependencies = [
-    "flwr[simulation]>=1.22.0",
+    "flwr[simulation]>=1.23.0",
     "flwr-datasets[vision]>=0.5.0",
     "scikit-learn>=1.6.1",
 ]

{flwr_nightly-1.22.0.dev20250920 → flwr_nightly-1.23.0.dev20250922}/py/flwr/cli/new/templates/app/pyproject.tensorflow.toml.tpl

@@ -14,7 +14,7 @@ description = ""
 license = "Apache-2.0"
 # Dependencies for your Flower App
 dependencies = [
-    "flwr[simulation]>=1.22.0",
+    "flwr[simulation]>=1.23.0",
     "flwr-datasets[vision]>=0.5.0",
     "tensorflow>=2.11.1,<2.18.0",
 ]

{flwr_nightly-1.22.0.dev20250920 → flwr_nightly-1.23.0.dev20250922}/py/flwr/cli/new/templates/app/pyproject.xgboost.toml.tpl

@@ -14,7 +14,7 @@ description = ""
 license = "Apache-2.0"
 # Dependencies for your Flower App
 dependencies = [
-    "flwr[simulation]>=1.22.0",
+    "flwr[simulation]>=1.23.0",
     "flwr-datasets>=0.5.0",
     "xgboost>=2.0.0",
 ]

{flwr_nightly-1.22.0.dev20250920 → flwr_nightly-1.23.0.dev20250922}/py/flwr/clientapp/mod/__init__.py

@@ -18,8 +18,10 @@
 from flwr.client.mod.comms_mods import arrays_size_mod, message_size_mod
 
 from .centraldp_mods import adaptiveclipping_mod, fixedclipping_mod
+from .localdp_mod import LocalDpMod
 
 __all__ = [
+    "LocalDpMod",
     "adaptiveclipping_mod",
     "arrays_size_mod",
     "fixedclipping_mod",

{flwr_nightly-1.22.0.dev20250920 → flwr_nightly-1.23.0.dev20250922}/py/flwr/clientapp/mod/centraldp_mods.py

@@ -89,7 +89,7 @@ def fixedclipping_mod(
         iter(out_msg.content.array_records.items())
     )
     # Ensure keys in returned ArrayRecord match those in the one sent from server
-    if set(original_array_record.keys()) != set(client_to_server_arrecord.keys()):
+    if list(original_array_record.keys()) != list(client_to_server_arrecord.keys()):
         return _handle_array_key_mismatch_err("fixedclipping_mod", out_msg)
 
     client_to_server_ndarrays = client_to_server_arrecord.to_numpy_ndarrays()
@@ -158,6 +158,10 @@ def adaptiveclipping_mod(
     # Call inner app
     out_msg = call_next(msg, ctxt)
 
+    # Check if the msg has error
+    if out_msg.has_error():
+        return out_msg
+
     # Ensure reply has a single ArrayRecord
     if len(out_msg.content.array_records) != 1:
         return _handle_multi_record_err("adaptiveclipping_mod", out_msg, ArrayRecord)
@@ -166,16 +170,12 @@ def adaptiveclipping_mod(
     if len(out_msg.content.metric_records) != 1:
         return _handle_multi_record_err("adaptiveclipping_mod", out_msg, MetricRecord)
 
-    # Check if the msg has error
-    if out_msg.has_error():
-        return out_msg
-
     new_array_record_key, client_to_server_arrecord = next(
         iter(out_msg.content.array_records.items())
     )
 
     # Ensure keys in returned ArrayRecord match those in the one sent from server
-    if set(original_array_record.keys()) != set(client_to_server_arrecord.keys()):
+    if list(original_array_record.keys()) != list(client_to_server_arrecord.keys()):
         return _handle_array_key_mismatch_err("adaptiveclipping_mod", out_msg)
 
     client_to_server_ndarrays = client_to_server_arrecord.to_numpy_ndarrays()

flwr_nightly-1.23.0.dev20250922/py/flwr/clientapp/mod/localdp_mod.py

@@ -0,0 +1,169 @@
+# 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.
+# ==============================================================================
+"""Local DP modifier."""
+
+
+from collections import OrderedDict
+from logging import INFO
+
+import numpy as np
+
+from flwr.clientapp.typing import ClientAppCallable
+from flwr.common import Array, ArrayRecord
+from flwr.common.context import Context
+from flwr.common.differential_privacy import (
+    add_gaussian_noise_inplace,
+    compute_clip_model_update,
+)
+from flwr.common.logger import log
+from flwr.common.message import Message
+
+from .centraldp_mods import _handle_array_key_mismatch_err, _handle_multi_record_err
+
+
+class LocalDpMod:
+    """Modifier for local differential privacy.
+
+    This mod clips the client model updates and
+    adds noise to the params before sending them to the server.
+
+    It operates on messages of type `MessageType.TRAIN`.
+
+    Parameters
+    ----------
+    clipping_norm : float
+        The value of the clipping norm.
+    sensitivity : float
+        The sensitivity of the client model.
+    epsilon : float
+        The privacy budget.
+        Smaller value of epsilon indicates a higher level of privacy protection.
+    delta : float
+        The failure probability.
+        The probability that the privacy mechanism
+        fails to provide the desired level of privacy.
+        A smaller value of delta indicates a stricter privacy guarantee.
+
+    Examples
+    --------
+    Create an instance of the local DP mod and add it to the client-side mods::
+
+        local_dp_mod = LocalDpMod( ... )
+        app = fl.client.ClientApp(mods=[local_dp_mod])
+    """
+
+    def __init__(
+        self, clipping_norm: float, sensitivity: float, epsilon: float, delta: float
+    ) -> None:
+        if clipping_norm <= 0:
+            raise ValueError("The clipping norm should be a positive value.")
+
+        if sensitivity < 0:
+            raise ValueError("The sensitivity should be a non-negative value.")
+
+        if epsilon < 0:
+            raise ValueError("Epsilon should be a non-negative value.")
+
+        if delta < 0:
+            raise ValueError("Delta should be a non-negative value.")
+
+        self.clipping_norm = clipping_norm
+        self.sensitivity = sensitivity
+        self.epsilon = epsilon
+        self.delta = delta
+
+    def __call__(
+        self, msg: Message, ctxt: Context, call_next: ClientAppCallable
+    ) -> Message:
+        """Perform local DP on the client model parameters.
+
+        Parameters
+        ----------
+        msg : Message
+            The message received from the ServerApp.
+        ctxt : Context
+            The context of the ClientApp.
+        call_next : ClientAppCallable
+            The callable to call the next mod (or the ClientApp) in the chain.
+
+        Returns
+        -------
+        Message
+            The modified message to be sent back to the server.
+        """
+        if len(msg.content.array_records) != 1:
+            return _handle_multi_record_err("LocalDpMod", msg, ArrayRecord)
+
+        # Record array record communicated to client and clipping norm
+        original_array_record = next(iter(msg.content.array_records.values()))
+
+        # Call inner app
+        out_msg = call_next(msg, ctxt)
+
+        # Check if the msg has error
+        if out_msg.has_error():
+            return out_msg
+
+        # Ensure reply has a single ArrayRecord
+        if len(out_msg.content.array_records) != 1:
+            return _handle_multi_record_err("LocalDpMod", out_msg, ArrayRecord)
+
+        new_array_record_key, client_to_server_arrecord = next(
+            iter(out_msg.content.array_records.items())
+        )
+
+        # Ensure keys in returned ArrayRecord match those in the one sent from server
+        if list(original_array_record.keys()) != list(client_to_server_arrecord.keys()):
+            return _handle_array_key_mismatch_err("LocalDpMod", out_msg)
+
+        client_to_server_ndarrays = client_to_server_arrecord.to_numpy_ndarrays()
+
+        # Clip the client update
+        compute_clip_model_update(
+            client_to_server_ndarrays,
+            original_array_record.to_numpy_ndarrays(),
+            self.clipping_norm,
+        )
+        log(
+            INFO,
+            "LocalDpMod: parameters are clipped by value: %.4f.",
+            self.clipping_norm,
+        )
+
+        std_dev = (
+            self.sensitivity * np.sqrt(2 * np.log(1.25 / self.delta)) / self.epsilon
+        )
+        add_gaussian_noise_inplace(
+            client_to_server_ndarrays,
+            std_dev,
+        )
+        log(
+            INFO,
+            "LocalDpMod: local DP noise with %.4f stddev added to parameters",
+            std_dev,
+        )
+
+        # Replace outgoing ArrayRecord's Array while preserving their keys
+        out_msg.content[new_array_record_key] = ArrayRecord(
+            OrderedDict(
+                {
+                    k: Array(v)
+                    for k, v in zip(
+                        client_to_server_arrecord.keys(), client_to_server_ndarrays
+                    )
+                }
+            )
+        )
+        return out_msg

{flwr_nightly-1.22.0.dev20250920 → flwr_nightly-1.23.0.dev20250922}/py/flwr/serverapp/strategy/__init__.py

@@ -15,6 +15,7 @@
 """ServerApp strategies."""
 
 
+from .bulyan import Bulyan
 from .dp_adaptive_clipping import (
     DifferentialPrivacyClientSideAdaptiveClipping,
     DifferentialPrivacyServerSideAdaptiveClipping,
@@ -34,11 +35,13 @@ from .fedxgb_bagging import FedXgbBagging
 from .fedxgb_cyclic import FedXgbCyclic
 from .fedyogi import FedYogi
 from .krum import Krum
+from .multikrum import MultiKrum
 from .qfedavg import QFedAvg
 from .result import Result
 from .strategy import Strategy
 
 __all__ = [
+    "Bulyan",
     "DifferentialPrivacyClientSideAdaptiveClipping",
     "DifferentialPrivacyClientSideFixedClipping",
     "DifferentialPrivacyServerSideAdaptiveClipping",
@@ -54,6 +57,7 @@ __all__ = [
     "FedXgbCyclic",
     "FedYogi",
     "Krum",
+    "MultiKrum",
     "QFedAvg",
     "Result",
     "Strategy",

flwr_nightly-1.23.0.dev20250922/py/flwr/serverapp/strategy/bulyan.py

@@ -0,0 +1,238 @@
+# 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.
+# ==============================================================================
+"""Bulyan [El Mhamdi et al., 2018] strategy.
+
+Paper: arxiv.org/abs/1802.07927
+"""
+
+
+from collections import OrderedDict
+from collections.abc import Iterable
+from logging import INFO, WARN
+from typing import Callable, Optional, cast
+
+import numpy as np
+
+from flwr.common import (
+    Array,
+    ArrayRecord,
+    Message,
+    MetricRecord,
+    NDArrays,
+    RecordDict,
+    log,
+)
+
+from .fedavg import FedAvg
+from .multikrum import select_multikrum
+
+
+# pylint: disable=too-many-instance-attributes
+class Bulyan(FedAvg):
+    """Bulyan strategy.
+
+    Implementation based on https://arxiv.org/abs/1802.07927.
+
+    Parameters
+    ----------
+    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.
+    num_malicious_nodes : int (default: 0)
+        Number of malicious 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.
+    selection_rule : Optional[Callable] (default: None)
+        Function with signature (list[RecordDict], int, int) -> list[RecordDict].
+        The inputs are:
+        - a list of contents from reply messages,
+        - the assumed number of malicious nodes (`num_malicious_nodes`),
+        - the number of nodes to select (`num_nodes_to_select`).
+
+        The function should implement a Byzantine-resilient selection rule that
+        serves as the first step of Bulyan. If None, defaults to `select_multikrum`,
+        which selects nodes according to the Multi-Krum algorithm.
+    """
+
+    # pylint: disable=too-many-arguments,too-many-positional-arguments
+    def __init__(
+        self,
+        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,
+        num_malicious_nodes: int = 0,
+        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,
+        selection_rule: Optional[
+            Callable[[list[RecordDict], int, int], list[RecordDict]]
+        ] = 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.num_malicious_nodes = num_malicious_nodes
+        self.selection_rule = selection_rule or select_multikrum
+
+    def summary(self) -> None:
+        """Log summary configuration of the strategy."""
+        log(INFO, "\t├──> Bulyan settings:")
+        log(INFO, "\t│\t├── Number of malicious nodes: %d", self.num_malicious_nodes)
+        log(INFO, "\t│\t└── Selection rule: %s", self.selection_rule.__name__)
+        super().summary()
+
+    def aggregate_train(
+        self,
+        server_round: int,
+        replies: Iterable[Message],
+    ) -> tuple[Optional[ArrayRecord], Optional[MetricRecord]]:
+        """Aggregate ArrayRecords and MetricRecords in the received Messages."""
+        valid_replies, _ = self._check_and_log_replies(replies, is_train=True)
+
+        # Check if sufficient replies have been received
+        if len(valid_replies) < 4 * self.num_malicious_nodes + 3:
+            log(
+                WARN,
+                "Insufficient replies, skipping Bulyan aggregation: "
+                "Required at least %d (4*num_malicious_nodes + 3), but received %d.",
+                4 * self.num_malicious_nodes + 3,
+                len(valid_replies),
+            )
+            return None, None
+
+        reply_contents = [msg.content for msg in valid_replies]
+
+        # Compute theta and beta
+        theta = len(valid_replies) - 2 * self.num_malicious_nodes
+        beta = theta - 2 * self.num_malicious_nodes
+
+        # Byzantine-resilient selection rule
+        selected_contents = self.selection_rule(
+            reply_contents, self.num_malicious_nodes, theta
+        )
+
+        # Convert each ArrayRecord to a list of NDArray for easier computation
+        key = list(selected_contents[0].array_records.keys())[0]
+        array_keys = list(selected_contents[0][key].keys())
+        selected_ndarrays = [
+            cast(ArrayRecord, ctnt[key]).to_numpy_ndarrays(keep_input=False)
+            for ctnt in selected_contents
+        ]
+
+        # Compute median
+        median_ndarrays = [np.median(arr, axis=0) for arr in zip(*selected_ndarrays)]
+
+        # Aggregate the beta closest weights element-wise
+        aggregated_ndarrays = aggregate_n_closest_weights(
+            median_ndarrays, selected_ndarrays, beta
+        )
+
+        # Convert to ArrayRecord
+        arrays = ArrayRecord(
+            OrderedDict(zip(array_keys, map(Array, aggregated_ndarrays)))
+        )
+
+        # Aggregate MetricRecords
+        metrics = self.train_metrics_aggr_fn(
+            selected_contents,
+            self.weighted_by_key,
+        )
+        return arrays, metrics
+
+
+def aggregate_n_closest_weights(
+    ref_weights: NDArrays, weights_list: list[NDArrays], beta: int
+) -> NDArrays:
+    """Compute the element-wise mean of the `beta` closest weight arrays.
+
+    For each element (i-th coordinate), the output is the average of the
+    `beta` weight arrays that are closest to the reference weights.
+
+    Parameters
+    ----------
+    ref_weights : NDArrays
+        Reference weights used to compute distances.
+    weights_list : list[NDArrays]
+        List of weight arrays (e.g., from selected nodes).
+    beta : int
+        Number of closest weight arrays to include in the averaging.
+
+    Returns
+    -------
+    aggregated_weights : NDArrays
+        Element-wise average of the `beta` closest weight arrays to the
+        reference weights.
+    """
+    aggregated_weights = []
+    for layer_id, ref_layer in enumerate(ref_weights):
+        # Shape: (n_models, *layer_shape)
+        layer_stack = np.stack([weights[layer_id] for weights in weights_list])
+
+        # Compute absolute differences: shape (n_models, *layer_shape)
+        diffs = np.abs(layer_stack - ref_layer)
+
+        # Find indices of `beta` smallest per coordinate
+        idx = np.argpartition(diffs, beta - 1, axis=0)[:beta]
+
+        # Gather the closest weights
+        closest = np.take_along_axis(layer_stack, idx, axis=0)
+
+        # Average them
+        aggregated_weights.append(np.mean(closest, axis=0))
+
+    return aggregated_weights

{flwr_nightly-1.22.0.dev20250920 → flwr_nightly-1.23.0.dev20250922}/py/flwr/serverapp/strategy/fedmedian.py

@@ -32,6 +32,40 @@ class FedMedian(FedAvg):
     """Federated Median (FedMedian) strategy.
 
     Implementation based on https://arxiv.org/pdf/1803.01498v1
+
+    Parameters
+    ----------
+    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 aggregate_train(