flwr 1.20.0__py3-none-any.whl → 1.21.0__py3-none-any.whl

flwr/serverapp/strategy/strategy_utils.py

@@ -0,0 +1,251 @@
+# 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 utilities."""
+
+
+import random
+from collections import OrderedDict
+from logging import INFO
+from time import sleep
+from typing import Optional, cast
+
+import numpy as np
+
+from flwr.common import (
+    Array,
+    ArrayRecord,
+    ConfigRecord,
+    MetricRecord,
+    NDArray,
+    RecordDict,
+    log,
+)
+from flwr.server import Grid
+
+from ..exception import InconsistentMessageReplies
+
+
+def config_to_str(config: ConfigRecord) -> str:
+    """Convert a ConfigRecord to a string representation masking bytes."""
+    content = ", ".join(
+        f"'{k}': {'<bytes>' if isinstance(v, bytes) else v}" for k, v in config.items()
+    )
+    return f"{{{content}}}"
+
+
+def log_strategy_start_info(
+    num_rounds: int,
+    arrays: ArrayRecord,
+    train_config: Optional[ConfigRecord],
+    evaluate_config: Optional[ConfigRecord],
+) -> None:
+    """Log information about the strategy start."""
+    log(INFO, "\t├── Number of rounds: %d", num_rounds)
+    log(
+        INFO,
+        "\t├── ArrayRecord (%.2f MB)",
+        sum(len(array.data) for array in arrays.values()) / (1024**2),
+    )
+    log(
+        INFO,
+        "\t├── ConfigRecord (train): %s",
+        config_to_str(train_config) if train_config else "(empty!)",
+    )
+    log(
+        INFO,
+        "\t├── ConfigRecord (evaluate): %s",
+        config_to_str(evaluate_config) if evaluate_config else "(empty!)",
+    )
+
+
+def aggregate_arrayrecords(
+    records: list[RecordDict], weighting_metric_name: str
+) -> ArrayRecord:
+    """Perform weighted aggregation all ArrayRecords using a specific key."""
+    # Retrieve weighting factor from MetricRecord
+    weights: list[float] = []
+    for record in records:
+        # Get the first (and only) MetricRecord in the record
+        metricrecord = next(iter(record.metric_records.values()))
+        # Because replies have been checked for consistency,
+        # we can safely cast the weighting factor to float
+        w = cast(float, metricrecord[weighting_metric_name])
+        weights.append(w)
+
+    # Average
+    total_weight = sum(weights)
+    weight_factors = [w / total_weight for w in weights]
+
+    # Perform weighted aggregation
+    aggregated_np_arrays: dict[str, NDArray] = {}
+
+    for record, weight in zip(records, weight_factors):
+        for record_item in record.array_records.values():
+            # aggregate in-place
+            for key, value in record_item.items():
+                if key not in aggregated_np_arrays:
+                    aggregated_np_arrays[key] = value.numpy() * weight
+                else:
+                    aggregated_np_arrays[key] += value.numpy() * weight
+
+    return ArrayRecord(
+        OrderedDict({k: Array(np.asarray(v)) for k, v in aggregated_np_arrays.items()})
+    )
+
+
+def aggregate_metricrecords(
+    records: list[RecordDict], weighting_metric_name: str
+) -> MetricRecord:
+    """Perform weighted aggregation all MetricRecords using a specific key."""
+    # Retrieve weighting factor from MetricRecord
+    weights: list[float] = []
+    for record in records:
+        # Get the first (and only) MetricRecord in the record
+        metricrecord = next(iter(record.metric_records.values()))
+        # Because replies have been checked for consistency,
+        # we can safely cast the weighting factor to float
+        w = cast(float, metricrecord[weighting_metric_name])
+        weights.append(w)
+
+    # Average
+    total_weight = sum(weights)
+    weight_factors = [w / total_weight for w in weights]
+
+    aggregated_metrics = MetricRecord()
+    for record, weight in zip(records, weight_factors):
+        for record_item in record.metric_records.values():
+            # aggregate in-place
+            for key, value in record_item.items():
+                if key == weighting_metric_name:
+                    # We exclude the weighting key from the aggregated MetricRecord
+                    continue
+                if key not in aggregated_metrics:
+                    if isinstance(value, list):
+                        aggregated_metrics[key] = [v * weight for v in value]
+                    else:
+                        aggregated_metrics[key] = value * weight
+                else:
+                    if isinstance(value, list):
+                        current_list = cast(list[float], aggregated_metrics[key])
+                        aggregated_metrics[key] = [
+                            curr + val * weight
+                            for curr, val in zip(current_list, value)
+                        ]
+                    else:
+                        current_value = cast(float, aggregated_metrics[key])
+                        aggregated_metrics[key] = current_value + value * weight
+
+    return aggregated_metrics
+
+
+def sample_nodes(
+    grid: Grid, min_available_nodes: int, sample_size: int
+) -> tuple[list[int], list[int]]:
+    """Sample the specified number of nodes using the Grid.
+
+    Parameters
+    ----------
+    grid : Grid
+        The grid object.
+    min_available_nodes : int
+        The minimum number of available nodes to sample from.
+    sample_size : int
+        The number of nodes to sample.
+
+    Returns
+    -------
+    tuple[list[int], list[int]]
+        A tuple containing the sampled node IDs and the list
+        of all connected node IDs.
+    """
+    sampled_nodes = []
+
+    # Ensure min_available_nodes is at least as large as sample_size
+    min_available_nodes = max(min_available_nodes, sample_size)
+
+    # wait for min_available_nodes to be online
+    while len(all_nodes := list(grid.get_node_ids())) < min_available_nodes:
+        log(
+            INFO,
+            "Waiting for nodes to connect: %d connected (minimum required: %d).",
+            len(all_nodes),
+            min_available_nodes,
+        )
+        sleep(1)
+
+    # Sample nodes
+    sampled_nodes = random.sample(all_nodes, sample_size)
+
+    return sampled_nodes, all_nodes
+
+
+# pylint: disable=too-many-return-statements
+def validate_message_reply_consistency(
+    replies: list[RecordDict], weighted_by_key: str, check_arrayrecord: bool
+) -> None:
+    """Validate that replies contain exactly one ArrayRecord and one MetricRecord, and
+    that the MetricRecord includes a weight factor key.
+
+    These checks ensure that Message-based strategies behave consistently with
+    *Ins/*Res-based strategies.
+    """
+    # Checking for ArrayRecord consistency
+    if check_arrayrecord:
+        if any(len(msg.array_records) != 1 for msg in replies):
+            raise InconsistentMessageReplies(
+                reason="Expected exactly one ArrayRecord in replies. "
+                "Skipping aggregation."
+            )
+
+        # Ensure all key are present in all ArrayRecords
+        record_key = next(iter(replies[0].array_records.keys()))
+        all_keys = set(replies[0][record_key].keys())
+        if any(set(msg.get(record_key, {}).keys()) != all_keys for msg in replies[1:]):
+            raise InconsistentMessageReplies(
+                reason="All ArrayRecords must have the same keys for aggregation. "
+                "This condition wasn't met. Skipping aggregation."
+            )
+
+    # Checking for MetricRecord consistency
+    if any(len(msg.metric_records) != 1 for msg in replies):
+        raise InconsistentMessageReplies(
+            reason="Expected exactly one MetricRecord in replies, but found more. "
+            "Skipping aggregation."
+        )
+
+    # Ensure all key are present in all MetricRecords
+    record_key = next(iter(replies[0].metric_records.keys()))
+    all_keys = set(replies[0][record_key].keys())
+    if any(set(msg.get(record_key, {}).keys()) != all_keys for msg in replies[1:]):
+        raise InconsistentMessageReplies(
+            reason="All MetricRecords must have the same keys for aggregation. "
+            "This condition wasn't met. Skipping aggregation."
+        )
+
+    # Verify the weight factor key presence in all MetricRecords
+    if weighted_by_key not in all_keys:
+        raise InconsistentMessageReplies(
+            reason=f"Missing required key `{weighted_by_key}` in the MetricRecord of "
+            "reply messages. Cannot average ArrayRecords and MetricRecords. Skipping "
+            "aggregation."
+        )
+
+    # Check that it is not a list
+    if any(isinstance(msg[record_key][weighted_by_key], list) for msg in replies):
+        raise InconsistentMessageReplies(
+            reason=f"Key `{weighted_by_key}` in the MetricRecord of reply messages "
+            "must be a single value (int or float), but a list was found. Skipping "
+            "aggregation."
+        )

flwr/serverapp/strategy/strategy_utils_tests.py

@@ -0,0 +1,304 @@
+# 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.
+# ==============================================================================
+"""Tests for message-based strategy utilities."""
+
+
+from collections import OrderedDict
+
+import numpy as np
+import pytest
+from parameterized import parameterized
+
+from flwr.common import Array, ArrayRecord, ConfigRecord, MetricRecord, RecordDict
+from flwr.serverapp.exception import InconsistentMessageReplies
+
+from .strategy_utils import (
+    aggregate_arrayrecords,
+    aggregate_metricrecords,
+    config_to_str,
+    validate_message_reply_consistency,
+)
+
+
+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"})
+    expected_str = "{'a': 123, 'b': [1, 2, 3], 'c': <bytes>}"
+    assert config_to_str(config) == expected_str
+
+
+def test_arrayrecords_aggregation() -> None:
+    """Test aggregation of ArrayRecords."""
+    num_replies = 3
+    num_arrays = 4
+    weights = [0.25, 0.4, 0.35]
+    np_arrays = [
+        [np.random.randn(7, 3) for _ in range(num_arrays)] for _ in range(num_replies)
+    ]
+
+    avg_list = [
+        np.average([lst[i] for lst in np_arrays], axis=0, weights=weights)
+        for i in range(num_arrays)
+    ]
+
+    # Construct RecordDicts (mimicing replies)
+    records = [
+        RecordDict(
+            {
+                "arrays": ArrayRecord(np_arrays[i]),
+                "metrics": MetricRecord({"weight": weights[i]}),
+            }
+        )
+        for i in range(num_replies)
+    ]
+    # Execute aggregate
+    aggrd = aggregate_arrayrecords(records, weighting_metric_name="weight")
+
+    # Assert consistency
+    assert all(np.allclose(a, b) for a, b in zip(aggrd.to_numpy_ndarrays(), avg_list))
+    assert aggrd.object_id == ArrayRecord(avg_list).object_id
+
+
+def test_arrayrecords_aggregation_with_ndim_zero() -> None:
+    """Test aggregation of ArrayRecords with 0-dim arrays."""
+    num_replies = 3
+    weights = [0.25, 0.4, 0.35]
+    np_arrays = [np.array(np.random.randn()) for _ in range(num_replies)]
+
+    # For 0-dimensional arrays, we just compute the weighted average directly
+    avg_list = [np.average(np_arrays, axis=0, weights=weights)]
+
+    # Construct RecordDicts (mimicing replies)
+    records = [
+        RecordDict(
+            {
+                "arrays": ArrayRecord([np_arrays[i]]),
+                "metrics": MetricRecord({"weight": weights[i]}),
+            }
+        )
+        for i in range(num_replies)
+    ]
+    # Execute aggregate
+    aggrd = aggregate_arrayrecords(records, weighting_metric_name="weight")
+
+    # Assert consistency
+    assert np.isclose(aggrd.to_numpy_ndarrays()[0], avg_list[0])
+    assert aggrd.object_id == ArrayRecord([np.array(avg_list[0])]).object_id
+
+
+def test_metricrecords_aggregation() -> None:
+    """Test aggregation of MetricRecords."""
+    num_replies = 3
+    weights = [0.25, 0.4, 0.35]
+    metric_records = [
+        MetricRecord({"a": 1, "b": 2.0, "c": np.random.randn(3).tolist()})
+        for _ in range(num_replies)
+    ]
+
+    # Compute expected aggregated MetricRecord.
+    # For ease, we convert everything into numpy arrays, then aggregate
+    as_np_entries = [
+        {
+            k: np.array(v) if isinstance(v, (int, float, list)) else v
+            for k, v in record.items()
+        }
+        for record in metric_records
+    ]
+    avg_list = [
+        np.average(
+            [list(entries.values())[i] for entries in as_np_entries],
+            axis=0,
+            weights=weights,
+        ).tolist()
+        for i in range(len(as_np_entries[0]))
+    ]
+    expected_record = MetricRecord(dict(zip(as_np_entries[0].keys(), avg_list)))
+    expected_record["a"] = float(expected_record["a"])  # type: ignore
+    expected_record["b"] = float(expected_record["b"])  # type: ignore
+
+    # Construct RecordDicts (mimicing replies)
+    # Inject weighting factor
+    records = [
+        RecordDict(
+            {
+                "metrics": MetricRecord(
+                    record.__dict__["_data"] | {"weight": weights[i]}
+                ),
+            }
+        )
+        for i, record in enumerate(metric_records)
+    ]
+
+    # Execute aggregate
+    aggrd = aggregate_metricrecords(records, weighting_metric_name="weight")
+    # Assert
+    assert expected_record.object_id == aggrd.object_id
+
+
+@parameterized.expand(  # type: ignore
+    [
+        (
+            True,
+            RecordDict(
+                {
+                    "global-model": ArrayRecord([np.random.randn(7, 3)]),
+                    "metrics": MetricRecord({"weight": 0.123}),
+                }
+            ),
+        ),  # Compliant
+        (
+            False,
+            RecordDict(
+                {
+                    "global-model": ArrayRecord([np.random.randn(7, 3)]),
+                    "metrics": MetricRecord({"weight": [0.123]}),
+                }
+            ),
+        ),  # Weighting key is not a scalar (BAD)
+        (
+            False,
+            RecordDict(
+                {
+                    "global-model": ArrayRecord([np.random.randn(7, 3)]),
+                    "metrics": MetricRecord({"loss": 0.01}),
+                }
+            ),
+        ),  # No weighting key in MetricRecord (BAD)
+        (
+            False,
+            RecordDict({"global-model": ArrayRecord([np.random.randn(7, 3)])}),
+        ),  # No MetricsRecord (BAD)
+        (
+            False,
+            RecordDict(
+                {
+                    "global-model": ArrayRecord([np.random.randn(7, 3)]),
+                    "another-model": ArrayRecord([np.random.randn(7, 3)]),
+                }
+            ),
+        ),  # Two ArrayRecords (BAD)
+        (
+            False,
+            RecordDict(
+                {
+                    "global-model": ArrayRecord([np.random.randn(7, 3)]),
+                    "metrics": MetricRecord({"weight": 0.123}),
+                    "more-metrics": MetricRecord({"loss": 0.321}),
+                }
+            ),
+        ),  # Two MetricRecords (BAD)
+    ]
+)
+def test_consistency_of_replies_with_matching_keys(
+    is_valid: bool, recorddict: RecordDict
+) -> None:
+    """Test consistency in replies."""
+    # Create dummy records
+    records = [recorddict for _ in range(3)]
+
+    if not is_valid:
+        # Should raise InconsistentMessageReplies exception
+        with pytest.raises(InconsistentMessageReplies):
+            validate_message_reply_consistency(
+                records, weighted_by_key="weight", check_arrayrecord=True
+            )
+    else:
+        # Should not raise an exception
+        validate_message_reply_consistency(
+            records, weighted_by_key="weight", check_arrayrecord=True
+        )
+
+
+@parameterized.expand(  # type: ignore
+    [
+        (
+            [
+                RecordDict(
+                    {
+                        "global-model": ArrayRecord([np.random.randn(7, 3)]),
+                        "metrics": MetricRecord({"weight": 0.123}),
+                    }
+                ),
+                RecordDict(
+                    {
+                        "model": ArrayRecord([np.random.randn(7, 3)]),
+                        "metrics": MetricRecord({"weight": 0.123}),
+                    }
+                ),
+            ],
+        ),  # top-level keys don't match for ArrayRecords
+        (
+            [
+                RecordDict(
+                    {
+                        "global-model": ArrayRecord(
+                            OrderedDict({"a": Array(np.random.randn(7, 3))})
+                        ),
+                        "metrics": MetricRecord({"weight": 0.123}),
+                    }
+                ),
+                RecordDict(
+                    {
+                        "global-model": ArrayRecord(
+                            OrderedDict({"b": Array(np.random.randn(7, 3))})
+                        ),
+                        "metrics": MetricRecord({"weight": 0.123}),
+                    }
+                ),
+            ],
+        ),  # top-level keys match for ArrayRecords but not those for Arrays
+        (
+            [
+                RecordDict(
+                    {
+                        "global-model": ArrayRecord([np.random.randn(7, 3)]),
+                        "metrics": MetricRecord({"weight": 0.123}),
+                    }
+                ),
+                RecordDict(
+                    {
+                        "global-model": ArrayRecord([np.random.randn(7, 3)]),
+                        "my-metrics": MetricRecord({"weight": 0.123}),
+                    }
+                ),
+            ],
+        ),  # top-level keys don't match for MetricRecords
+        (
+            [
+                RecordDict(
+                    {
+                        "global-model": ArrayRecord([np.random.randn(7, 3)]),
+                        "metrics": MetricRecord({"weight": 0.123}),
+                    }
+                ),
+                RecordDict(
+                    {
+                        "global-model": ArrayRecord([np.random.randn(7, 3)]),
+                        "my-metrics": MetricRecord({"my-weights": 0.123}),
+                    }
+                ),
+            ],
+        ),  # top-level keys match for MetricRecords but not inner ones
+    ]
+)
+def test_consistency_of_replies_with_different_keys(
+    list_records: list[RecordDict],
+) -> None:
+    """Test consistency in replies when records don't have matching keys."""
+    # All test cases expect InconsistentMessageReplies exception to be raised
+    with pytest.raises(InconsistentMessageReplies):
+        validate_message_reply_consistency(
+            list_records, weighted_by_key="weight", check_arrayrecord=True
+        )