flwr-nightly 1.22.0.dev20250913__py3-none-any.whl → 1.22.0.dev20250916__py3-none-any.whl

flwr/serverapp/strategy/fedavgm.py

@@ -0,0 +1,198 @@
+# 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.
+# ==============================================================================
+"""Federated Averaging with Momentum (FedAvgM) [Hsu et al., 2019] strategy.
+
+Paper: arxiv.org/pdf/1909.06335.pdf
+"""
+
+
+from collections import OrderedDict
+from collections.abc import Iterable
+from logging import INFO
+from typing import Callable, Optional
+
+from flwr.common import (
+    Array,
+    ArrayRecord,
+    ConfigRecord,
+    Message,
+    MetricRecord,
+    NDArrays,
+    RecordDict,
+    log,
+)
+from flwr.server import Grid
+
+from ..exception import AggregationError
+from .fedavg import FedAvg
+
+
+class FedAvgM(FedAvg):
+    """Federated Averaging with Momentum strategy.
+
+    Implementation based on https://arxiv.org/abs/1909.06335
+
+    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.
+    server_learning_rate: float (default: 1.0)
+        Server-side learning rate used in server-side optimization.
+    server_momentum: float (default: 0.0)
+        Server-side momentum factor used for FedAvgM.
+    """
+
+    def __init__(  # pylint: disable=R0913, R0917
+        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,
+        server_learning_rate: float = 1.0,
+        server_momentum: float = 0.0,
+    ) -> 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.server_learning_rate = server_learning_rate
+        self.server_momentum = server_momentum
+        self.server_opt: bool = (self.server_momentum != 0.0) or (
+            self.server_learning_rate != 1.0
+        )
+        self.current_arrays: Optional[ArrayRecord] = None
+        self.momentum_vector: Optional[NDArrays] = None
+
+    def summary(self) -> None:
+        """Log summary configuration of the strategy."""
+        opt_status = "ON" if self.server_opt else "OFF"
+        log(INFO, "\t├──> FedAvgM settings:")
+        log(INFO, "\t|\t├── Server optimization: %s", opt_status)
+        log(INFO, "\t|\t├── Server learning rate: %s", self.server_learning_rate)
+        log(INFO, "\t|\t└── Server Momentum: %s", self.server_momentum)
+        super().summary()
+
+    def configure_train(
+        self, server_round: int, arrays: ArrayRecord, config: ConfigRecord, grid: Grid
+    ) -> Iterable[Message]:
+        """Configure the next round of federated training."""
+        if self.current_arrays is None:
+            self.current_arrays = arrays
+        return super().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."""
+        # Call FedAvg aggregate_train to perform validation and aggregation
+        aggregated_arrays, aggregated_metrics = super().aggregate_train(
+            server_round, replies
+        )
+
+        # following convention described in
+        # https://pytorch.org/docs/stable/generated/torch.optim.SGD.html
+        if self.server_opt and aggregated_arrays is not None:
+            # The initial parameters should be set in `start()` method already
+            if self.current_arrays is None:
+                raise AggregationError(
+                    "No initial parameters set for FedAvgM. "
+                    "Ensure that `configure_train` has been called before aggregation."
+                )
+            ndarrays = self.current_arrays.to_numpy_ndarrays()
+            aggregated_ndarrays = aggregated_arrays.to_numpy_ndarrays()
+
+            # Preserve keys for arrays in ArrayRecord
+            array_keys = list(aggregated_arrays.keys())
+            aggregated_arrays.clear()
+
+            # Remember that updates are the opposite of gradients
+            pseudo_gradient = [
+                old - new for new, old in zip(aggregated_ndarrays, ndarrays)
+            ]
+            if self.server_momentum > 0.0:
+                if self.momentum_vector is None:
+                    # Initialize momentum vector in the first round
+                    self.momentum_vector = pseudo_gradient
+                else:
+                    self.momentum_vector = [
+                        self.server_momentum * mv + pg
+                        for mv, pg in zip(self.momentum_vector, pseudo_gradient)
+                    ]
+
+                # No nesterov for now
+                pseudo_gradient = self.momentum_vector
+
+            # SGD and convert back to ArrayRecord
+            updated_array_list = [
+                Array(old - self.server_learning_rate * pg)
+                for old, pg in zip(ndarrays, pseudo_gradient)
+            ]
+            aggregated_arrays = ArrayRecord(
+                OrderedDict(zip(array_keys, updated_array_list))
+            )
+
+            # Update current weights
+            self.current_arrays = aggregated_arrays
+
+        return aggregated_arrays, aggregated_metrics

flwr/serverapp/strategy/fedmedian.py

@@ -0,0 +1,71 @@
+# 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.
+# ==============================================================================
+"""Federated Median (FedMedian) [Yin et al., 2018] strategy.
+
+Paper: arxiv.org/pdf/1803.01498v1.pdf
+"""
+
+
+from collections.abc import Iterable
+from typing import Optional, cast
+
+import numpy as np
+
+from flwr.common import Array, ArrayRecord, Message, MetricRecord
+
+from .fedavg import FedAvg
+
+
+class FedMedian(FedAvg):
+    """Federated Median (FedMedian) strategy.
+
+    Implementation based on https://arxiv.org/pdf/1803.01498v1
+    """
+
+    def aggregate_train(
+        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
+
+        # Aggregate ArrayRecords using median
+        # Get the key for the only ArrayRecord from the first Message
+        record_key = list(valid_replies[0].content.array_records.keys())[0]
+        # Preserve keys for arrays in ArrayRecord
+        array_keys = list(valid_replies[0].content[record_key].keys())
+
+        # Compute median for each layer and construct ArrayRecord
+        arrays = ArrayRecord()
+        for array_key in array_keys:
+            # Get the corresponding layer from each client
+            layers = [
+                cast(ArrayRecord, msg.content[record_key]).pop(array_key).numpy()
+                for msg in valid_replies
+            ]
+            # Compute median and save as Array in ArrayRecord
+            arrays[array_key] = Array(np.median(np.stack(layers), axis=0))
+
+        # Aggregate MetricRecords
+        metrics = self.train_metrics_aggr_fn(
+            [msg.content for msg in valid_replies],
+            self.weighted_by_key,
+        )
+        return arrays, metrics

flwr/serverapp/strategy/fedtrimmedavg.py

@@ -0,0 +1,176 @@
+# 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.
+# ==============================================================================
+"""Federated Averaging with Trimmed Mean [Dong Yin, et al., 2021].
+
+Paper: arxiv.org/abs/1803.01498
+"""
+
+
+from collections.abc import Iterable
+from logging import INFO
+from typing import Callable, Optional, cast
+
+import numpy as np
+
+from flwr.common import Array, ArrayRecord, Message, MetricRecord, NDArray, RecordDict
+from flwr.common.logger import log
+
+from ..exception import AggregationError
+from .fedavg import FedAvg
+
+
+class FedTrimmedAvg(FedAvg):
+    """Federated Averaging with Trimmed Mean [Dong Yin, et al., 2021].
+
+    Implemented based on: https://arxiv.org/abs/1803.01498
+
+    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.
+    beta : float (default: 0.2)
+        Fraction to cut off of both tails of the distribution.
+    """
+
+    def __init__(  # pylint: disable=R0913, R0917
+        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,
+        beta: float = 0.2,
+    ) -> 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.beta = beta
+
+    def summary(self) -> None:
+        """Log summary configuration of the strategy."""
+        log(INFO, "\t├──> FedTrimmedAvg settings:")
+        log(INFO, "\t|\t└── beta: %s", self.beta)
+        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."""
+        # 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
+
+        # Aggregate ArrayRecords using trimmed mean
+        # Get the key for the only ArrayRecord from the first Message
+        record_key = list(valid_replies[0].content.array_records.keys())[0]
+        # Preserve keys for arrays in ArrayRecord
+        array_keys = list(valid_replies[0].content[record_key].keys())
+
+        # Compute trimmed mean for each layer and construct ArrayRecord
+        arrays = ArrayRecord()
+        for array_key in array_keys:
+            # Get the corresponding layer from each client
+            layers = [
+                cast(ArrayRecord, msg.content[record_key]).pop(array_key).numpy()
+                for msg in valid_replies
+            ]
+            # Compute trimmed mean and save as Array in ArrayRecord
+            try:
+                arrays[array_key] = Array(trim_mean(np.stack(layers), self.beta))
+            except ValueError as e:
+                raise AggregationError(
+                    f"Trimmed mean could not be computed. "
+                    f"Likely cause: beta={self.beta} is too large."
+                ) from e
+
+        # Aggregate MetricRecords
+        metrics = self.train_metrics_aggr_fn(
+            [msg.content for msg in valid_replies],
+            self.weighted_by_key,
+        )
+        return arrays, metrics
+
+
+def trim_mean(array: NDArray, cut_fraction: float) -> NDArray:
+    """Compute trimmed mean along axis=0.
+
+    It is based on the scipy implementation:
+
+    https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.trim_mean.html
+    """
+    axis = 0
+    nobs = array.shape[0]
+    lowercut = int(cut_fraction * nobs)
+    uppercut = nobs - lowercut
+    if lowercut > uppercut:
+        raise ValueError("Fraction too big.")
+
+    atmp = np.partition(array, (lowercut, uppercut - 1), axis)
+
+    slice_list = [slice(None)] * atmp.ndim
+    slice_list[axis] = slice(lowercut, uppercut)
+    result: NDArray = np.mean(atmp[tuple(slice_list)], axis=axis)
+    return result

flwr/serverapp/strategy/fedxgb_bagging.py

@@ -0,0 +1,82 @@
+# 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 FedXgbBagging strategy."""
+from collections.abc import Iterable
+from typing import Optional, cast
+
+import numpy as np
+
+from flwr.common import ArrayRecord, ConfigRecord, Message, MetricRecord
+from flwr.server import Grid
+
+from ..exception import InconsistentMessageReplies
+from .fedavg import FedAvg
+from .strategy_utils import aggregate_bagging
+
+
+# pylint: disable=line-too-long
+class FedXgbBagging(FedAvg):
+    """Configurable FedXgbBagging strategy implementation."""
+
+    current_bst: Optional[bytes] = None
+
+    def _ensure_single_array(self, arrays: ArrayRecord) -> None:
+        """Check that ensures there's only one Array in the ArrayRecord."""
+        n = len(arrays)
+        if n != 1:
+            raise InconsistentMessageReplies(
+                reason="Expected exactly one Array in ArrayRecord. "
+                "Skipping aggregation."
+            )
+
+    def configure_train(
+        self, server_round: int, arrays: ArrayRecord, config: ConfigRecord, grid: Grid
+    ) -> Iterable[Message]:
+        """Configure the next round of federated training."""
+        self._ensure_single_array(arrays)
+        # Keep track of array record being communicated
+        self.current_bst = arrays["0"].numpy().tobytes()
+        return super().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."""
+        valid_replies, _ = self._check_and_log_replies(replies, is_train=True)
+
+        arrays, metrics = None, None
+        if valid_replies:
+            reply_contents = [msg.content for msg in valid_replies]
+            array_record_key = next(iter(reply_contents[0].array_records.keys()))
+
+            # Aggregate ArrayRecords
+            for content in reply_contents:
+                self._ensure_single_array(cast(ArrayRecord, content[array_record_key]))
+                bst = content[array_record_key]["0"].numpy().tobytes()  # type: ignore[union-attr]
+
+                if self.current_bst is not None:
+                    self.current_bst = aggregate_bagging(self.current_bst, bst)
+
+            if self.current_bst is not None:
+                arrays = ArrayRecord([np.frombuffer(self.current_bst, dtype=np.uint8)])
+
+            # Aggregate MetricRecords
+            metrics = self.train_metrics_aggr_fn(
+                reply_contents,
+                self.weighted_by_key,
+            )
+        return arrays, metrics

flwr/serverapp/strategy/strategy_utils.py

@@ -15,6 +15,7 @@
 """Flower message-based strategy utilities."""
 
 
+import json
 import random
 from collections import OrderedDict
 from logging import INFO
@@ -249,3 +250,50 @@ def validate_message_reply_consistency(
             "must be a single value (int or float), but a list was found. Skipping "
             "aggregation."
         )
+
+
+def aggregate_bagging(
+    bst_prev_org: bytes,
+    bst_curr_org: bytes,
+) -> bytes:
+    """Conduct bagging aggregation for given trees."""
+    if bst_prev_org == b"":
+        return bst_curr_org
+
+    # Get the tree numbers
+    tree_num_prev, _ = _get_tree_nums(bst_prev_org)
+    _, paral_tree_num_curr = _get_tree_nums(bst_curr_org)
+
+    bst_prev = json.loads(bytearray(bst_prev_org))
+    bst_curr = json.loads(bytearray(bst_curr_org))
+
+    previous_model = bst_prev["learner"]["gradient_booster"]["model"]
+    previous_model["gbtree_model_param"]["num_trees"] = str(
+        tree_num_prev + paral_tree_num_curr
+    )
+    iteration_indptr = previous_model["iteration_indptr"]
+    previous_model["iteration_indptr"].append(
+        iteration_indptr[-1] + paral_tree_num_curr
+    )
+
+    # Aggregate new trees
+    trees_curr = bst_curr["learner"]["gradient_booster"]["model"]["trees"]
+    for tree_count in range(paral_tree_num_curr):
+        trees_curr[tree_count]["id"] = tree_num_prev + tree_count
+        previous_model["trees"].append(trees_curr[tree_count])
+        previous_model["tree_info"].append(0)
+
+    bst_prev_bytes = bytes(json.dumps(bst_prev), "utf-8")
+
+    return bst_prev_bytes
+
+
+def _get_tree_nums(xgb_model_org: bytes) -> tuple[int, int]:
+    xgb_model = json.loads(bytearray(xgb_model_org))
+
+    # Access model parameters
+    model_param = xgb_model["learner"]["gradient_booster"]["model"][
+        "gbtree_model_param"
+    ]
+    # Return the number of trees and the number of parallel trees
+    return int(model_param["num_trees"]), int(model_param["num_parallel_tree"])

flwr/serverapp/strategy/strategy_utils_tests.py

@@ -16,12 +16,20 @@
 
 
 from collections import OrderedDict
+from unittest.mock import Mock
 
 import numpy as np
 import pytest
 from parameterized import parameterized
 
-from flwr.common import Array, ArrayRecord, ConfigRecord, MetricRecord, RecordDict
+from flwr.common import (
+    Array,
+    ArrayRecord,
+    ConfigRecord,
+    Message,
+    MetricRecord,
+    RecordDict,
+)
 from flwr.serverapp.exception import InconsistentMessageReplies
 
 from .strategy_utils import (
@@ -32,6 +40,17 @@ from .strategy_utils import (
 )
 
 
+def create_mock_reply(arrays: ArrayRecord, num_examples: float) -> Message:
+    """Create a mock reply Message with default keys."""
+    message = Mock(spec=Message)
+    message.content = RecordDict(
+        {"arrays": arrays, "metrics": MetricRecord({"num-examples": num_examples})}
+    )
+    message.has_error.side_effect = lambda: False
+    message.has_content.side_effect = lambda: True
+    return message
+
+
 def test_config_to_str() -> None:
     """Test that items of types bytes are masked out."""
     config = ConfigRecord({"a": 123, "b": [1, 2, 3], "c": b"bytes"})

{flwr_nightly-1.22.0.dev20250913.dist-info → flwr_nightly-1.22.0.dev20250916.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: flwr-nightly
-Version: 1.22.0.dev20250913
+Version: 1.22.0.dev20250916
 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
@@ -102,25 +102,15 @@ Meet the Flower community on [flower.ai](https://flower.ai)!
 
 Flower's goal is to make federated learning accessible to everyone. This series of tutorials introduces the fundamentals of federated learning and how to implement them in Flower.
 
-0. **What is Federated Learning?**
+0. **[What is Federated Learning?](https://flower.ai/docs/framework/main/en/tutorial-series-what-is-federated-learning.html)**
 
-   [![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/adap/flower/blob/main/framework/docs/source/tutorial-series-what-is-federated-learning.ipynb) (or open the [Jupyter Notebook](https://github.com/adap/flower/blob/main/framework/docs/source/tutorial-series-what-is-federated-learning.ipynb))
+1. **[An Introduction to Federated Learning](https://flower.ai/docs/framework/main/en/tutorial-series-get-started-with-flower-pytorch.html)**
 
-1. **An Introduction to Federated Learning**
+2. **[Using Strategies in Federated Learning](https://flower.ai/docs/framework/main/en/tutorial-series-use-a-federated-learning-strategy-pytorch.html)**
 
-   [![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/adap/flower/blob/main/framework/docs/source/tutorial-series-get-started-with-flower-pytorch.ipynb) (or open the [Jupyter Notebook](https://github.com/adap/flower/blob/main/framework/docs/source/tutorial-series-get-started-with-flower-pytorch.ipynb))
+3. **[Customize a Flower Strategy](https://flower.ai/docs/framework/main/en/tutorial-series-build-a-strategy-from-scratch-pytorch.html)**
 
-2. **Using Strategies in Federated Learning**
-
-   [![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/adap/flower/blob/main/framework/docs/source/tutorial-series-use-a-federated-learning-strategy-pytorch.ipynb) (or open the [Jupyter Notebook](https://github.com/adap/flower/blob/main/framework/docs/source/tutorial-series-use-a-federated-learning-strategy-pytorch.ipynb))
-
-3. **Building Strategies for Federated Learning**
-
-   [![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/adap/flower/blob/main/framework/docs/source/tutorial-series-build-a-strategy-from-scratch-pytorch.ipynb) (or open the [Jupyter Notebook](https://github.com/adap/flower/blob/main/framework/docs/source/tutorial-series-build-a-strategy-from-scratch-pytorch.ipynb))
-
-4. **Custom Clients for Federated Learning**
-
-   [![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/adap/flower/blob/main/framework/docs/source/tutorial-series-customize-the-client-pytorch.ipynb) (or open the [Jupyter Notebook](https://github.com/adap/flower/blob/main/framework/docs/source/tutorial-series-customize-the-client-pytorch.ipynb))
+4. **[Communicate Custom Messages](https://flower.ai/docs/framework/main/en/tutorial-series-customize-the-client-pytorch.html)**
 
 Stay tuned, more tutorials are coming soon. Topics include **Privacy and Security in Federated Learning**, and **Scaling Federated Learning**.