flwr-nightly 1.21.0.dev20250826__tar.gz → 1.21.0.dev20250827__tar.gz

{flwr_nightly-1.21.0.dev20250826 → flwr_nightly-1.21.0.dev20250827}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: flwr-nightly
-Version: 1.21.0.dev20250826
+Version: 1.21.0.dev20250827
 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.21.0.dev20250826 → flwr_nightly-1.21.0.dev20250827}/py/flwr/common/exit/exit_code.py

@@ -34,6 +34,9 @@ class ExitCode:
     SUPERLINK_LICENSE_URL_INVALID = 103
     SUPERLINK_INVALID_ARGS = 104
 
+    # ServerApp-specific exit codes (200-299)
+    SERVERAPP_STRATEGY_PRECONDITION_UNMET = 200
+
     # SuperNode-specific exit codes (300-399)
     SUPERNODE_REST_ADDRESS_INVALID = 300
     SUPERNODE_NODE_AUTH_KEYS_REQUIRED = 301
@@ -76,6 +79,16 @@ EXIT_CODE_HELP = {
         "Invalid arguments provided to SuperLink. Use `--help` check for the correct "
         "usage. Alternatively, check the documentation."
     ),
+    # ServerApp-specific exit codes (200-299)
+    ExitCode.SERVERAPP_STRATEGY_PRECONDITION_UNMET: (
+        "The strategy received replies that cannot be aggregated. Please ensure all "
+        "replies returned by ClientApps have one `ArrayRecord` (none when replies are "
+        "from a round of federated evaluation, i.e. when message type is "
+        "`MessageType.EVALUATE`) and one `MetricRecord`. The records in all replies "
+        "must use identical keys. In addition, if the strategy expects a key to "
+        "perform weighted average (e.g. in FedAvg) please ensure the returned "
+        "MetricRecord from ClientApps do include this key."
+    ),
     # SuperNode-specific exit codes (300-399)
     ExitCode.SUPERNODE_REST_ADDRESS_INVALID: (
         "When using the REST API, please provide `https://` or "

{flwr_nightly-1.21.0.dev20250826 → flwr_nightly-1.21.0.dev20250827}/py/flwr/serverapp/__init__.py

@@ -13,3 +13,13 @@
 # limitations under the License.
 # ==============================================================================
 """Public Flower ServerApp APIs."""
+
+from .fedavg import FedAvg
+from .result import Result
+from .strategy import Strategy
+
+__all__ = [
+    "FedAvg",
+    "Result",
+    "Strategy",
+]

flwr_nightly-1.21.0.dev20250827/py/flwr/serverapp/fedavg.py

@@ -0,0 +1,292 @@
+# 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.
+# ==============================================================================
+"""Flower message-based FedAvg strategy."""
+
+
+from collections.abc import Iterable
+from logging import INFO
+from typing import Callable, Optional
+
+from flwr.common import (
+    ArrayRecord,
+    ConfigRecord,
+    Message,
+    MessageType,
+    MetricRecord,
+    RecordDict,
+    log,
+)
+from flwr.server import Grid
+
+from .strategy import Strategy
+from .strategy_utils import (
+    aggregate_arrayrecords,
+    aggregate_metricrecords,
+    sample_nodes,
+    validate_message_reply_consistency,
+)
+
+
+# pylint: disable=too-many-instance-attributes
+class FedAvg(Strategy):
+    """Federated Averaging strategy.
+
+    Implementation based on https://arxiv.org/abs/1602.05629
+
+    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.
+    """
+
+    # 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,
+        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:
+        self.fraction_train = fraction_train
+        self.fraction_evaluate = fraction_evaluate
+        self.min_train_nodes = min_train_nodes
+        self.min_evaluate_nodes = min_evaluate_nodes
+        self.min_available_nodes = min_available_nodes
+        self.weighted_by_key = weighted_by_key
+        self.arrayrecord_key = arrayrecord_key
+        self.configrecord_key = configrecord_key
+        self.train_metrics_aggr_fn = train_metrics_aggr_fn or aggregate_metricrecords
+        self.evaluate_metrics_aggr_fn = (
+            evaluate_metrics_aggr_fn or aggregate_metricrecords
+        )
+
+    def summary(self) -> None:
+        """Log summary configuration of the strategy."""
+        log(INFO, "\t├──> Sampling:")
+        log(
+            INFO,
+            "\t│\t├──Fraction: train (%.2f) | evaluate ( %.2f)",
+            self.fraction_train,
+            self.fraction_evaluate,
+        )  # pylint: disable=line-too-long
+        log(
+            INFO,
+            "\t│\t├──Minimum nodes: train (%d) | evaluate (%d)",
+            self.min_train_nodes,
+            self.min_evaluate_nodes,
+        )  # pylint: disable=line-too-long
+        log(INFO, "\t│\t└──Minimum available nodes: %d", self.min_available_nodes)
+        log(INFO, "\t└──> Keys in records:")
+        log(INFO, "\t\t├── Weighted by: '%s'", self.weighted_by_key)
+        log(INFO, "\t\t├── ArrayRecord key: '%s'", self.arrayrecord_key)
+        log(INFO, "\t\t└── ConfigRecord key: '%s'", self.configrecord_key)
+
+    def _construct_messages(
+        self, record: RecordDict, node_ids: list[int], message_type: str
+    ) -> Iterable[Message]:
+        """Construct N Messages carrying the same RecordDict payload."""
+        messages = []
+        for node_id in node_ids:  # one message for each node
+            message = Message(
+                content=record,
+                message_type=message_type,
+                dst_node_id=node_id,
+            )
+            messages.append(message)
+        return messages
+
+    def configure_train(
+        self, server_round: int, arrays: ArrayRecord, config: ConfigRecord, grid: Grid
+    ) -> Iterable[Message]:
+        """Configure the next round of federated training."""
+        # Sample nodes
+        num_nodes = int(len(list(grid.get_node_ids())) * self.fraction_train)
+        sample_size = max(num_nodes, self.min_train_nodes)
+        node_ids, num_total = sample_nodes(grid, self.min_available_nodes, sample_size)
+        log(
+            INFO,
+            "configure_train: Sampled %s nodes (out of %s)",
+            len(node_ids),
+            len(num_total),
+        )
+        # Always inject current server round
+        config["server-round"] = server_round
+
+        # Construct messages
+        record = RecordDict(
+            {self.arrayrecord_key: arrays, self.configrecord_key: config}
+        )
+        return self._construct_messages(record, node_ids, MessageType.TRAIN)
+
+    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 replies:
+            return None, None
+
+        # Log if any Messages carried errors
+        # Filter messages that carry content
+        num_errors = 0
+        replies_with_content = []
+        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:
+                replies_with_content.append(msg.content)
+
+        log(
+            INFO,
+            "aggregate_train: Received %s results and %s failures",
+            len(replies_with_content) - num_errors,
+            num_errors,
+        )
+
+        # Ensure expected ArrayRecords and MetricRecords are received
+        validate_message_reply_consistency(
+            replies=replies_with_content,
+            weighted_by_key=self.weighted_by_key,
+            check_arrayrecord=True,
+        )
+
+        # Aggregate ArrayRecords
+        arrays = aggregate_arrayrecords(
+            replies_with_content,
+            self.weighted_by_key,
+        )
+
+        # Aggregate MetricRecords
+        metrics = self.train_metrics_aggr_fn(
+            replies_with_content,
+            self.weighted_by_key,
+        )
+        return arrays, metrics
+
+    def configure_evaluate(
+        self, server_round: int, arrays: ArrayRecord, config: ConfigRecord, grid: Grid
+    ) -> Iterable[Message]:
+        """Configure the next round of federated evaluation."""
+        # Sample nodes
+        num_nodes = int(len(list(grid.get_node_ids())) * self.fraction_evaluate)
+        sample_size = max(num_nodes, self.min_evaluate_nodes)
+        node_ids, num_total = sample_nodes(grid, self.min_available_nodes, sample_size)
+        log(
+            INFO,
+            "configure_evaluate: Sampled %s nodes (out of %s)",
+            len(node_ids),
+            len(num_total),
+        )
+
+        # Always inject current server round
+        config["server-round"] = server_round
+
+        # Construct messages
+        record = RecordDict(
+            {self.arrayrecord_key: arrays, self.configrecord_key: config}
+        )
+        return self._construct_messages(record, node_ids, MessageType.EVALUATE)
+
+    def aggregate_evaluate(
+        self,
+        server_round: int,
+        replies: Iterable[Message],
+    ) -> Optional[MetricRecord]:
+        """Aggregate MetricRecords in the received Messages."""
+        if not replies:
+            return None
+
+        # Log if any Messages carried errors
+        # Filter messages that carry content
+        num_errors = 0
+        replies_with_content = []
+        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:
+                replies_with_content.append(msg.content)
+
+        log(
+            INFO,
+            "aggregate_evaluate: Received %s results and %s failures",
+            len(replies_with_content) - num_errors,
+            num_errors,
+        )
+
+        # Ensure expected ArrayRecords and MetricRecords are received
+        validate_message_reply_consistency(
+            replies=replies_with_content,
+            weighted_by_key=self.weighted_by_key,
+            check_arrayrecord=False,
+        )
+
+        # Aggregate MetricRecords
+        metrics = self.evaluate_metrics_aggr_fn(
+            replies_with_content,
+            self.weighted_by_key,
+        )
+        return metrics

flwr_nightly-1.21.0.dev20250827/py/flwr/serverapp/result.py

@@ -0,0 +1,30 @@
+# 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.
+# ==============================================================================
+"""Strategy results."""
+
+
+from dataclasses import dataclass, field
+
+from flwr.common import ArrayRecord, MetricRecord
+
+
+@dataclass
+class Result:
+    """Data class carrying records generated during the execution of a strategy."""
+
+    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)

flwr_nightly-1.21.0.dev20250827/py/flwr/serverapp/strategy.py

@@ -0,0 +1,286 @@
+# 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.
+# ==============================================================================
+"""Flower message-based strategy."""
+
+
+import time
+from abc import ABC, abstractmethod
+from collections.abc import Iterable
+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
+
+
+class Strategy(ABC):
+    """Abstract base class for server strategy implementations."""
+
+    @abstractmethod
+    def configure_train(
+        self, server_round: int, arrays: ArrayRecord, config: ConfigRecord, grid: Grid
+    ) -> Iterable[Message]:
+        """Configure the next round of training.
+
+        Parameters
+        ----------
+        server_round : int
+            The current round of federated learning.
+        arrays : ArrayRecord
+            Current global ArrayRecord (e.g. global model) to be sent to client
+            nodes for training.
+        config : ConfigRecord
+            Configuration to be sent to clients nodes for training.
+        grid : Grid
+            The Grid instance used for node sampling and communication.
+
+        Returns
+        -------
+        Iterable[Message]
+            An iterable of messages to be sent to selected client nodes for training.
+        """
+
+    @abstractmethod
+    def aggregate_train(
+        self,
+        server_round: int,
+        replies: Iterable[Message],
+    ) -> tuple[Optional[ArrayRecord], Optional[MetricRecord]]:
+        """Aggregate training results from client nodes.
+
+        Parameters
+        ----------
+        server_round : int
+            The current round of federated learning, starting from 1.
+        replies : Iterable[Message]
+            Iterable of reply messages received from client nodes after training.
+            Each message contains ArrayRecords and MetricRecords that get aggregated.
+
+        Returns
+        -------
+        tuple[Optional[ArrayRecord], Optional[MetricRecord]]
+            A tuple containing:
+            - ArrayRecord: Aggregated ArrayRecord, or None if aggregation failed
+            - MetricRecord: Aggregated MetricRecord, or None if aggregation failed
+        """
+
+    @abstractmethod
+    def configure_evaluate(
+        self, server_round: int, arrays: ArrayRecord, config: ConfigRecord, grid: Grid
+    ) -> Iterable[Message]:
+        """Configure the next round of evaluation.
+
+        Parameters
+        ----------
+        server_round : int
+            The current round of federated learning.
+        arrays : ArrayRecord
+            Current global ArrayRecord (e.g. global model) to be sent to client
+            nodes for evaluation.
+        config : ConfigRecord
+            Configuration to be sent to clients nodes for evaluation.
+        grid : Grid
+            The Grid instance used for node sampling and communication.
+
+        Returns
+        -------
+        Iterable[Message]
+            An iterable of messages to be sent to selected client nodes for evaluation.
+        """
+
+    @abstractmethod
+    def aggregate_evaluate(
+        self,
+        server_round: int,
+        replies: Iterable[Message],
+    ) -> Optional[MetricRecord]:
+        """Aggregate evaluation metrics from client nodes.
+
+        Parameters
+        ----------
+        server_round : int
+            The current round of federated learning.
+        replies : Iterable[Message]
+            Iterable of reply messages received from client nodes after evaluation.
+            MetricRecords in the messages are aggregated.
+
+        Returns
+        -------
+        Optional[MetricRecord]
+            Aggregated evaluation metrics from all participating clients,
+            or None if aggregation failed.
+        """
+
+    @abstractmethod
+    def summary(self) -> None:
+        """Log summary configuration of the strategy."""
+
+    # pylint: disable=too-many-arguments, too-many-positional-arguments, too-many-locals
+    def start(
+        self,
+        grid: Grid,
+        initial_arrays: ArrayRecord,
+        num_rounds: int = 3,
+        timeout: float = 3600,
+        train_config: Optional[ConfigRecord] = None,
+        evaluate_config: Optional[ConfigRecord] = None,
+        evaluate_fn: Optional[Callable[[int, ArrayRecord], MetricRecord]] = None,
+    ) -> Result:
+        """Execute the federated learning strategy.
+
+        Runs the complete federated learning workflow for the specified number of
+        rounds, including training, evaluation, and optional centralized evaluation.
+
+        Parameters
+        ----------
+        grid : Grid
+            The Grid instance used to send/receive Messages from nodes executing a
+            ClientApp.
+        initial_arrays : ArrayRecord
+            Initial model parameters (arrays) to be used for federated learning.
+        num_rounds : int (default: 3)
+            Number of federated learning rounds to execute.
+        timeout : float (default: 3600)
+            Timeout in seconds for waiting for node responses.
+        train_config : ConfigRecord, optional
+            Configuration to be sent to nodes during training rounds.
+            If unset, an empty ConfigRecord will be used.
+        evaluate_config : ConfigRecord, optional
+            Configuration to be sent to nodes during evaluation rounds.
+            If unset, an empty ConfigRecord will be used.
+        evaluate_fn : Callable[[int, ArrayRecord], MetricRecord], optional
+            Optional function for centralized evaluation of the global model. Takes
+            server round number and array record, returns a MetricRecord. If provided,
+            will be called before the first round and after each round. Defaults to
+            None.
+
+        Returns
+        -------
+        Results
+            Results containing final model arrays and also training metrics, evaluation
+            metrics and global evaluation metrics (if provided) from all rounds.
+        """
+        log(INFO, "Starting %s strategy:", self.__class__.__name__)
+        log_strategy_start_info(
+            num_rounds, initial_arrays, train_config, evaluate_config
+        )
+        self.summary()
+        log(INFO, "")
+
+        # Initialize if None
+        train_config = ConfigRecord() if train_config is None else train_config
+        evaluate_config = ConfigRecord() if evaluate_config is None else evaluate_config
+        result = Result()
+
+        t_start = time.time()
+        # Evaluate starting global parameters
+        if evaluate_fn:
+            res = evaluate_fn(0, initial_arrays)
+            log(INFO, "Initial global evaluation results: %s", res)
+            result.evaluate_metrics_serverapp[0] = res
+
+        arrays = initial_arrays
+
+        for current_round in range(1, num_rounds + 1):
+            log(INFO, "")
+            log(INFO, "[ROUND %s/%s]", current_round, num_rounds)
+
+            # -----------------------------------------------------------------
+            # --- TRAINING ----------------------------------------------------
+            # -----------------------------------------------------------------
+
+            # Call strategy to configure training round
+            # Send messages and wait for replies
+            train_replies = grid.send_and_receive(
+                messages=self.configure_train(
+                    current_round,
+                    arrays,
+                    train_config,
+                    grid,
+                ),
+                timeout=timeout,
+            )
+
+            # 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)
+                )
+
+            # Log training metrics and append to history
+            if agg_arrays is not None:
+                result.arrays = agg_arrays
+                arrays = agg_arrays
+            if agg_train_metrics is not None:
+                log(INFO, "\t└──> Aggregated MetricRecord: %s", agg_train_metrics)
+                result.train_metrics_clientapp[current_round] = agg_train_metrics
+
+            # -----------------------------------------------------------------
+            # --- EVALUATION (LOCAL) ------------------------------------------
+            # -----------------------------------------------------------------
+
+            # Call strategy to configure evaluation round
+            # Send messages and wait for replies
+            evaluate_replies = grid.send_and_receive(
+                messages=self.configure_evaluate(
+                    current_round,
+                    arrays,
+                    evaluate_config,
+                    grid,
+                ),
+                timeout=timeout,
+            )
+
+            # 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)
+                )
+
+            # Log training metrics and append to history
+            if agg_evaluate_metrics is not None:
+                log(INFO, "\t└──> Aggregated MetricRecord: %s", agg_evaluate_metrics)
+                result.evaluate_metrics_clientapp[current_round] = agg_evaluate_metrics
+
+            # -----------------------------------------------------------------
+            # --- EVALUATION (GLOBAL) -----------------------------------------
+            # -----------------------------------------------------------------
+
+            # Centralized evaluation
+            if evaluate_fn:
+                log(INFO, "Global evaluation")
+                res = evaluate_fn(current_round, arrays)
+                log(INFO, "\t└──> MetricRecord: %s", res)
+                result.evaluate_metrics_serverapp[current_round] = res
+
+        log(INFO, "")
+        log(INFO, "Strategy execution finished in %.2fs", time.time() - t_start)
+        log(INFO, "")
+
+        return result