flwr-nightly 1.21.0.dev20250902__py3-none-any.whl → 1.21.0.dev20250904__py3-none-any.whl

flwr/serverapp/strategy/fedopt.py

@@ -0,0 +1,218 @@
+# 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.
+# ==============================================================================
+"""Adaptive Federated Optimization (FedOpt) [Reddi et al., 2020] abstract strategy.
+
+Paper: arxiv.org/abs/2003.00295
+"""
+
+from collections.abc import Iterable
+from logging import INFO
+from typing import Callable, Optional
+
+import numpy as np
+
+from flwr.common import (
+    ArrayRecord,
+    ConfigRecord,
+    Message,
+    MetricRecord,
+    NDArray,
+    RecordDict,
+    log,
+)
+from flwr.server import Grid
+
+from .fedavg import FedAvg
+from .strategy_utils import AggregationError
+
+
+# pylint: disable=line-too-long
+class FedOpt(FedAvg):
+    """Federated Optim strategy.
+
+    Implementation based on https://arxiv.org/abs/2003.00295v5
+
+    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 both ArrayRecords and 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.
+    eta : float, optional
+        Server-side learning rate. Defaults to 1e-1.
+    eta_l : float, optional
+        Client-side learning rate. Defaults to 1e-1.
+    beta_1 : float, optional
+        Momentum parameter. Defaults to 0.0.
+    beta_2 : float, optional
+        Second moment parameter. Defaults to 0.0.
+    tau : float, optional
+        Controls the algorithm's degree of adaptability. Defaults to 1e-3.
+    """
+
+    # pylint: disable=too-many-arguments,too-many-instance-attributes,too-many-locals, line-too-long
+    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,
+        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,
+        eta: float = 1e-1,
+        eta_l: float = 1e-1,
+        beta_1: float = 0.0,
+        beta_2: float = 0.0,
+        tau: float = 1e-3,
+    ) -> 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.current_arrays: Optional[dict[str, NDArray]] = None
+        self.eta = eta
+        self.eta_l = eta_l
+        self.tau = tau
+        self.beta_1 = beta_1
+        self.beta_2 = beta_2
+        self.m_t: Optional[dict[str, NDArray]] = None
+        self.v_t: Optional[dict[str, NDArray]] = None
+
+    def summary(self) -> None:
+        """Log summary configuration of the strategy."""
+        log(INFO, "\t├──> FedOpt settings:")
+        log(
+            INFO,
+            "\t│\t├── eta (%s) | eta_l (%s)",
+            f"{self.eta:.6g}",
+            f"{self.eta_l:.6g}",
+        )
+        log(
+            INFO,
+            "\t│\t├── beta_1 (%s) | beta_2 (%s)",
+            f"{self.beta_1:.6g}",
+            f"{self.beta_2:.6g}",
+        )
+        log(
+            INFO,
+            "\t│\t└── tau (%s)",
+            f"{self.tau:.6g}",
+        )
+        super().summary()
+
+    def configure_train(
+        self, server_round: int, arrays: ArrayRecord, config: ConfigRecord, grid: Grid
+    ) -> Iterable[Message]:
+        """Configure the next round of federated training."""
+        # Keep track of array record being communicated
+        self.current_arrays = {k: array.numpy() for k, array in arrays.items()}
+        return super().configure_train(server_round, arrays, config, grid)
+
+    def _compute_deltat_and_mt(
+        self, aggregated_arrayrecord: ArrayRecord
+    ) -> tuple[dict[str, NDArray], dict[str, NDArray], dict[str, NDArray]]:
+        """Compute delta_t and m_t.
+
+        This is a shared stage during aggregation for FedAdagrad, FedAdam and FedYogi.
+        """
+        if self.current_arrays is None:
+            reason = (
+                "Current arrays not set. Ensure that `configure_train` has been "
+                "called before aggregation."
+            )
+            raise AggregationError(reason=reason)
+
+        aggregated_ndarrays = {
+            k: array.numpy() for k, array in aggregated_arrayrecord.items()
+        }
+
+        # Check keys in aggregated arrays match those in current arrays
+        if set(aggregated_ndarrays.keys()) != set(self.current_arrays.keys()):
+            reason = (
+                "Keys of the aggregated arrays do not match those of the arrays "
+                "stored at the strategy. `delta_t = aggregated_arrays - "
+                "current_arrays` cannot be computed."
+            )
+            raise AggregationError(reason=reason)
+
+        # Check that the shape of values match
+        # Only shapes that match can compute delta_t (we don't want
+        # broadcasting to happen)
+        for k, x in aggregated_ndarrays.items():
+            if x.shape != self.current_arrays[k].shape:
+                reason = (
+                    f"Shape of aggregated array '{k}' does not match "
+                    f"shape of the array under the same key stored in the strategy. "
+                    f"Cannot compute `delta_t`."
+                )
+                raise AggregationError(reason=reason)
+
+        delta_t = {
+            k: x - self.current_arrays[k] for k, x in aggregated_ndarrays.items()
+        }
+
+        # m_t
+        if not self.m_t:
+            self.m_t = {k: np.zeros_like(v) for k, v in aggregated_ndarrays.items()}
+        self.m_t = {
+            k: self.beta_1 * v + (1 - self.beta_1) * delta_t[k]
+            for k, v in self.m_t.items()
+        }
+
+        return delta_t, self.m_t, aggregated_ndarrays

flwr/serverapp/strategy/fedyogi.py

@@ -0,0 +1,173 @@
+# 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.
+# ==============================================================================
+"""Adaptive Federated Optimization using Yogi (FedYogi) [Reddi et al., 2020] strategy.
+
+Paper: arxiv.org/abs/2003.00295
+"""
+
+
+from collections import OrderedDict
+from collections.abc import Iterable
+from typing import Callable, Optional
+
+import numpy as np
+
+from flwr.common import Array, ArrayRecord, Message, MetricRecord, RecordDict
+
+from .fedopt import FedOpt
+from .strategy_utils import AggregationError
+
+
+# pylint: disable=line-too-long
+class FedYogi(FedOpt):
+    """FedYogi [Reddi et al., 2020] strategy.
+
+    Implementation based on https://arxiv.org/abs/2003.00295v5
+
+
+    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 both ArrayRecords and 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.
+    eta : float, optional
+        Server-side learning rate. Defaults to 1e-2.
+    eta_l : float, optional
+        Client-side learning rate. Defaults to 0.0316.
+    beta_1 : float, optional
+        Momentum parameter. Defaults to 0.9.
+    beta_2 : float, optional
+        Second moment parameter. Defaults to 0.99.
+    tau : float, optional
+        Controls the algorithm's degree of adaptability.
+        Defaults to 1e-3.
+    """
+
+    # pylint: disable=too-many-arguments, too-many-locals
+    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,
+        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,
+        eta: float = 1e-2,
+        eta_l: float = 0.0316,
+        beta_1: float = 0.9,
+        beta_2: float = 0.99,
+        tau: float = 1e-3,
+    ) -> 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,
+            eta=eta,
+            eta_l=eta_l,
+            beta_1=beta_1,
+            beta_2=beta_2,
+            tau=tau,
+        )
+
+    def aggregate_train(
+        self,
+        server_round: int,
+        replies: Iterable[Message],
+    ) -> tuple[Optional[ArrayRecord], Optional[MetricRecord]]:
+        """Aggregate ArrayRecords and MetricRecords in the received Messages."""
+        aggregated_arrayrecord, aggregated_metrics = super().aggregate_train(
+            server_round, replies
+        )
+
+        if aggregated_arrayrecord is None:
+            return aggregated_arrayrecord, aggregated_metrics
+
+        if self.current_arrays is None:
+            reason = (
+                "Current arrays not set. Ensure that `configure_train` has been "
+                "called before aggregation."
+            )
+            raise AggregationError(reason=reason)
+
+        # Compute intermediate variables
+        delta_t, m_t, aggregated_ndarrays = self._compute_deltat_and_mt(
+            aggregated_arrayrecord
+        )
+
+        # v_t
+        if not self.v_t:
+            self.v_t = {k: np.zeros_like(v) for k, v in aggregated_ndarrays.items()}
+        self.v_t = {
+            k: v
+            - (1.0 - self.beta_2) * (delta_t[k] ** 2) * np.sign(v - delta_t[k] ** 2)
+            for k, v in self.v_t.items()
+        }
+
+        new_arrays = {
+            k: x + self.eta * m_t[k] / (np.sqrt(self.v_t[k]) + self.tau)
+            for k, x in self.current_arrays.items()
+        }
+
+        # Update current arrays
+        self.current_arrays = new_arrays
+
+        return (
+            ArrayRecord(OrderedDict({k: Array(v) for k, v in new_arrays.items()})),
+            aggregated_metrics,
+        )

flwr/serverapp/strategy/result.py

@@ -15,16 +15,91 @@
 """Strategy results."""
 
 
+import pprint
 from dataclasses import dataclass, field
 
 from flwr.common import ArrayRecord, MetricRecord
+from flwr.common.typing import MetricRecordValues
 
 
 @dataclass
 class Result:
-    """Data class carrying records generated during the execution of a strategy."""
+    """Data class carrying records generated during the execution of a strategy.
+
+    This class encapsulates the results of a federated learning strategy execution,
+    including the final global model parameters and metrics collected throughout
+    the federated training and evaluation (both federated and centralized) stages.
+
+    Attributes
+    ----------
+    arrays : ArrayRecord
+        The final global model parameters. Contains the
+        aggregated model weights/parameters that resulted from the federated
+        learning process.
+    train_metrics_clientapp : dict[int, MetricRecord]
+        Training metrics collected from ClientApps, indexed by round number.
+        Contains aggregated metrics (e.g., loss, accuracy) from the training
+        phase of each federated learning round.
+    evaluate_metrics_clientapp : dict[int, MetricRecord]
+        Evaluation metrics collected from ClientApps, indexed by round number.
+        Contains aggregated metrics  (e.g. validation loss) from the evaluation
+        phase where ClientApps evaluate the global model on their local
+        validation/test data.
+    evaluate_metrics_serverapp : dict[int, MetricRecord]
+        Evaluation metrics generated at the ServerApp, indexed by round number.
+        Contains metrics from centralized evaluation performed by the ServerApp
+        (e.g., when the server evaluates the global model on a held-out dataset).
+    """
 
     arrays: ArrayRecord = field(default_factory=ArrayRecord)
     train_metrics_clientapp: dict[int, MetricRecord] = field(default_factory=dict)
     evaluate_metrics_clientapp: dict[int, MetricRecord] = field(default_factory=dict)
     evaluate_metrics_serverapp: dict[int, MetricRecord] = field(default_factory=dict)
+
+    def __repr__(self) -> str:
+        """Create a representation of the Result instance."""
+        rep = ""
+        arr_size = sum(len(array.data) for array in self.arrays.values()) / (1024**2)
+        rep += "Global Arrays:\n" + f"\tArrayRecord ({arr_size:.3f} MB)\n" + "\n"
+        rep += (
+            "Aggregated ClientApp-side Train Metrics:\n"
+            + pprint.pformat(stringify_dict(self.train_metrics_clientapp), indent=2)
+            + "\n\n"
+        )
+
+        rep += (
+            "Aggregated ClientApp-side Evaluate Metrics:\n"
+            + pprint.pformat(stringify_dict(self.evaluate_metrics_clientapp), indent=2)
+            + "\n\n"
+        )
+
+        rep += (
+            "ServerApp-side Evaluate Metrics:\n"
+            + pprint.pformat(stringify_dict(self.evaluate_metrics_serverapp), indent=2)
+            + "\n"
+        )
+
+        return rep
+
+
+def format_value(val: MetricRecordValues) -> str:
+    """Format a value as string, applying scientific notation for floats."""
+    if isinstance(val, float):
+        return f"{val:.4e}"
+    if isinstance(val, int):
+        return str(val)
+    if isinstance(val, list):
+        return str([f"{x:.4e}" if isinstance(x, float) else str(x) for x in val])
+    return str(val)
+
+
+def stringify_dict(d: dict[int, MetricRecord]) -> dict[int, dict[str, str]]:
+    """Return a copy results metrics but with values converted to string and formatted
+    accordingtly."""
+    new_metrics_dict = {}
+    for k, inner in d.items():
+        new_inner = {}
+        for ik, iv in inner.items():
+            new_inner[ik] = format_value(iv)
+        new_metrics_dict[k] = new_inner
+    return new_metrics_dict

flwr/serverapp/strategy/strategy.py

@@ -15,6 +15,7 @@
 """Flower message-based strategy."""
 
 
+import io
 import time
 from abc import ABC, abstractmethod
 from collections.abc import Iterable
@@ -22,11 +23,10 @@ from logging import INFO
 from typing import Callable, Optional
 
 from flwr.common import ArrayRecord, ConfigRecord, Message, MetricRecord, log
-from flwr.common.exit import ExitCode, flwr_exit
 from flwr.server import Grid
 
 from .result import Result
-from .strategy_utils import InconsistentMessageReplies, log_strategy_start_info
+from .strategy_utils import log_strategy_start_info
 
 
 class Strategy(ABC):
@@ -202,7 +202,7 @@ class Strategy(ABC):
             log(INFO, "[ROUND %s/%s]", current_round, num_rounds)
 
             # -----------------------------------------------------------------
-            # --- TRAINING ----------------------------------------------------
+            # --- TRAINING (CLIENTAPP-SIDE) -----------------------------------
             # -----------------------------------------------------------------
 
             # Call strategy to configure training round
@@ -218,15 +218,10 @@ class Strategy(ABC):
             )
 
             # Aggregate train
-            try:
-                agg_arrays, agg_train_metrics = self.aggregate_train(
-                    current_round,
-                    train_replies,
-                )
-            except InconsistentMessageReplies as e:
-                flwr_exit(
-                    ExitCode.SERVERAPP_STRATEGY_PRECONDITION_UNMET, message=str(e)
-                )
+            agg_arrays, agg_train_metrics = self.aggregate_train(
+                current_round,
+                train_replies,
+            )
 
             # Log training metrics and append to history
             if agg_arrays is not None:
@@ -237,7 +232,7 @@ class Strategy(ABC):
                 result.train_metrics_clientapp[current_round] = agg_train_metrics
 
             # -----------------------------------------------------------------
-            # --- EVALUATION (LOCAL) ------------------------------------------
+            # --- EVALUATION (CLIENTAPP-SIDE) ---------------------------------
             # -----------------------------------------------------------------
 
             # Call strategy to configure evaluation round
@@ -253,15 +248,10 @@ class Strategy(ABC):
             )
 
             # Aggregate evaluate
-            try:
-                agg_evaluate_metrics = self.aggregate_evaluate(
-                    current_round,
-                    evaluate_replies,
-                )
-            except InconsistentMessageReplies as e:
-                flwr_exit(
-                    ExitCode.SERVERAPP_STRATEGY_PRECONDITION_UNMET, message=str(e)
-                )
+            agg_evaluate_metrics = self.aggregate_evaluate(
+                current_round,
+                evaluate_replies,
+            )
 
             # Log training metrics and append to history
             if agg_evaluate_metrics is not None:
@@ -269,7 +259,7 @@ class Strategy(ABC):
                 result.evaluate_metrics_clientapp[current_round] = agg_evaluate_metrics
 
             # -----------------------------------------------------------------
-            # --- EVALUATION (GLOBAL) -----------------------------------------
+            # --- EVALUATION (SERVERAPP-SIDE) ---------------------------------
             # -----------------------------------------------------------------
 
             # Centralized evaluation
@@ -282,5 +272,10 @@ class Strategy(ABC):
         log(INFO, "")
         log(INFO, "Strategy execution finished in %.2fs", time.time() - t_start)
         log(INFO, "")
+        log(INFO, "Final results:")
+        log(INFO, "")
+        for line in io.StringIO(str(result)):
+            log(INFO, "\t%s", line.strip("\n"))
+        log(INFO, "")
 
         return result

flwr/serverapp/strategy/strategy_utils.py

@@ -30,13 +30,26 @@ from flwr.common import (
     RecordDict,
     log,
 )
+from flwr.common.exception import AppExitException
+from flwr.common.exit import ExitCode
 from flwr.server import Grid
 
 
-class InconsistentMessageReplies(Exception):
+class InconsistentMessageReplies(AppExitException):
     """Exception triggered when replies are inconsistent and therefore aggregation must
     be skipped."""
 
+    exit_code = ExitCode.SERVERAPP_STRATEGY_PRECONDITION_UNMET
+
+    def __init__(self, reason: str):
+        super().__init__(reason)
+
+
+class AggregationError(AppExitException):
+    """Exception triggered when aggregation fails."""
+
+    exit_code = ExitCode.SERVERAPP_STRATEGY_AGGREGATION_ERROR
+
     def __init__(self, reason: str):
         super().__init__(reason)
 

{flwr_nightly-1.21.0.dev20250902.dist-info → flwr_nightly-1.21.0.dev20250904.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: flwr-nightly
-Version: 1.21.0.dev20250902
+Version: 1.21.0.dev20250904
 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