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

flwr/cli/new/templates/app/code/flwr_tune/strategy.py.tpl

@@ -1,53 +1,48 @@
 """$project_name: A Flower / FlowerTune app."""
 
-from io import BytesIO
+from collections.abc import Iterable
 from logging import INFO, WARN
-from typing import List, Tuple, Union
+from typing import Optional
 
-from flwr.common import FitIns, FitRes, Parameters, log, parameters_to_ndarrays
-from flwr.server.client_manager import ClientManager
-from flwr.server.client_proxy import ClientProxy
-from flwr.server.strategy import FedAvg
+from flwr.app import ArrayRecord, ConfigRecord, Message, MetricRecord
+from flwr.common import log
+from flwr.serverapp import Grid
+from flwr.serverapp.strategy import FedAvg
 
 
 class FlowerTuneLlm(FedAvg):
     """Customised FedAvg strategy implementation.
-    
+
     This class behaves just like FedAvg but also tracks the communication
-    costs associated with `fit` over FL rounds.
+    costs associated with `train` over FL rounds.
     """
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
         self.comm_tracker = CommunicationTracker()
 
-    def configure_fit(
-        self, server_round: int, parameters: Parameters, client_manager: ClientManager
-    ):
+    def configure_train(
+            self, server_round: int, arrays: ArrayRecord, config: ConfigRecord, grid: Grid
+    ) -> Iterable[Message]:
         """Configure the next round of training."""
-        return_clients = super().configure_fit(server_round, parameters, client_manager)
-
-        # Test communication costs
-        fit_ins_list = [fit_ins for _, fit_ins in return_clients]
-        self.comm_tracker.track(fit_ins_list)
-
-        return return_clients
-
-    def aggregate_fit(
-        self,
-        server_round: int,
-        results: List[Tuple[ClientProxy, FitRes]],
-        failures: List[Union[Tuple[ClientProxy, FitRes], BaseException]],
-    ):
-        """Aggregate fit results using weighted average."""
-        # Test communication costs
-        fit_res_list = [fit_res for _, fit_res in results]
-        self.comm_tracker.track(fit_res_list)
-
-        parameters_aggregated, metrics_aggregated = super().aggregate_fit(
-            server_round, results, failures
-        )
+        messages = super().configure_train(server_round, arrays, config, grid)
+
+        # Track communication costs
+        self.comm_tracker.track(messages)
+
+        return messages
+
+    def aggregate_train(
+            self,
+            server_round: int,
+            replies: Iterable[Message],
+    ) -> tuple[Optional[ArrayRecord], Optional[MetricRecord]]:
+        """Aggregate ArrayRecords and MetricRecords in the received Messages."""
+        # Track communication costs
+        self.comm_tracker.track(replies)
 
-        return parameters_aggregated, metrics_aggregated
+        arrays, metrics = super().aggregate_train(server_round, replies)
+
+        return arrays, metrics
 
 
 class CommunicationTracker:
@@ -55,16 +50,16 @@ class CommunicationTracker:
     def __init__(self):
         self.curr_comm_cost = 0.0
 
-    @staticmethod
-    def _compute_bytes(parameters):
-        return sum([BytesIO(t).getbuffer().nbytes for t in parameters.tensors])
-
-    def track(self, fit_list: List[Union[FitIns, FitRes]]):
-        size_bytes_list = [
-            self._compute_bytes(fit_ele.parameters)
-            for fit_ele in fit_list
-        ]
-        comm_cost = sum(size_bytes_list) / 1024**2
+    def track(self, messages: Iterable[Message]):
+        comm_cost = (
+            sum(
+                record.count_bytes()
+                for msg in messages
+                if msg.has_content()
+                for record in msg.content.array_records.values()
+            )
+            / 1024**2
+        )
 
         self.curr_comm_cost += comm_cost
         log(

flwr/cli/new/templates/app/code/model.baseline.py.tpl

@@ -1,7 +1,5 @@
 """$project_name: A Flower Baseline."""
 
-from collections import OrderedDict
-
 import torch
 import torch.nn.functional as F
 from torch import nn
@@ -66,15 +64,3 @@ def test(net, testloader, device):
     accuracy = correct / len(testloader.dataset)
     loss = loss / len(testloader)
     return loss, accuracy
-
-
-def get_weights(net):
-    """Extract model parameters as numpy arrays from state_dict."""
-    return [val.cpu().numpy() for _, val in net.state_dict().items()]
-
-
-def set_weights(net, parameters):
-    """Apply parameters to an existing model."""
-    params_dict = zip(net.state_dict().keys(), parameters)
-    state_dict = OrderedDict({k: torch.from_numpy(v) for k, v in params_dict})
-    net.load_state_dict(state_dict, strict=True)

flwr/cli/new/templates/app/code/server.baseline.py.tpl

@@ -1,45 +1,43 @@
 """$project_name: A Flower Baseline."""
 
-from flwr.common import Context, Metrics, ndarrays_to_parameters
-from flwr.server import ServerApp, ServerAppComponents, ServerConfig
-from flwr.server.strategy import FedAvg
+import torch
+from flwr.app import ArrayRecord, Context
+from flwr.serverapp import Grid, ServerApp
+from flwr.serverapp.strategy import FedAvg
 
-from $import_name.model import Net, get_weights
+from $import_name.model import Net
 
+# Create ServerApp
+app = ServerApp()
 
-# Define metric aggregation function
-def weighted_average(metrics: list[tuple[int, Metrics]]) -> Metrics:
-    """Do weighted average of accuracy metric."""
-    # Multiply accuracy of each client by number of examples used
-    accuracies = [num_examples * float(m["accuracy"]) for num_examples, m in metrics]
-    examples = [num_examples for num_examples, _ in metrics]
-
-    # Aggregate and return custom metric (weighted average)
-    return {"accuracy": sum(accuracies) / sum(examples)}
 
+@app.main()
+def main(grid: Grid, context: Context) -> None:
+    """Main entry point for the ServerApp."""
 
-def server_fn(context: Context):
-    """Construct components that set the ServerApp behaviour."""
     # Read from config
     num_rounds = context.run_config["num-server-rounds"]
-    fraction_fit = context.run_config["fraction-fit"]
+    fraction_train = context.run_config["fraction-train"]
 
-    # Initialize model parameters
-    ndarrays = get_weights(Net())
-    parameters = ndarrays_to_parameters(ndarrays)
+    # Load global model
+    global_model = Net()
+    arrays = ArrayRecord(global_model.state_dict())
 
-    # Define strategy
+    # Initialize FedAvg strategy
     strategy = FedAvg(
-        fraction_fit=float(fraction_fit),
+        fraction_train=fraction_train,
         fraction_evaluate=1.0,
-        min_available_clients=2,
-        initial_parameters=parameters,
-        evaluate_metrics_aggregation_fn=weighted_average,
+        min_available_nodes=2,
     )
-    config = ServerConfig(num_rounds=int(num_rounds))
-
-    return ServerAppComponents(strategy=strategy, config=config)
 
+    # Start strategy, run FedAvg for `num_rounds`
+    result = strategy.start(
+        grid=grid,
+        initial_arrays=arrays,
+        num_rounds=num_rounds,
+    )
 
-# Create ServerApp
-app = ServerApp(server_fn=server_fn)
+    # Save final model to disk
+    print("\nSaving final model to disk...")
+    state_dict = result.arrays.to_torch_state_dict()
+    torch.save(state_dict, "final_model.pt")

flwr/cli/new/templates/app/code/server.huggingface.py.tpl

@@ -1,17 +1,22 @@
 """$project_name: A Flower / $framework_str app."""
 
-from flwr.common import Context, ndarrays_to_parameters
-from flwr.server import ServerApp, ServerAppComponents, ServerConfig
-from flwr.server.strategy import FedAvg
+import torch
+from flwr.app import ArrayRecord, Context
+from flwr.serverapp import Grid, ServerApp
+from flwr.serverapp.strategy import FedAvg
 from transformers import AutoModelForSequenceClassification
 
-from $import_name.task import get_weights
+# Create ServerApp
+app = ServerApp()
+
 
+@app.main()
+def main(grid: Grid, context: Context) -> None:
+    """Main entry point for the ServerApp."""
 
-def server_fn(context: Context):
     # Read from config
     num_rounds = context.run_config["num-server-rounds"]
-    fraction_fit = context.run_config["fraction-fit"]
+    fraction_train = context.run_config["fraction-train"]
 
     # Initialize global model
     model_name = context.run_config["model-name"]
@@ -19,20 +24,19 @@ def server_fn(context: Context):
     net = AutoModelForSequenceClassification.from_pretrained(
         model_name, num_labels=num_labels
     )
+    arrays = ArrayRecord(net.state_dict())
 
-    weights = get_weights(net)
-    initial_parameters = ndarrays_to_parameters(weights)
+    # Initialize FedAvg strategy
+    strategy = FedAvg(fraction_train=fraction_train)
 
-    # Define strategy
-    strategy = FedAvg(
-        fraction_fit=fraction_fit,
-        fraction_evaluate=1.0,
-        initial_parameters=initial_parameters,
+    # Start strategy, run FedAvg for `num_rounds`
+    result = strategy.start(
+        grid=grid,
+        initial_arrays=arrays,
+        num_rounds=num_rounds,
     )
-    config = ServerConfig(num_rounds=num_rounds)
-
-    return ServerAppComponents(strategy=strategy, config=config)
 
-
-# Create ServerApp
-app = ServerApp(server_fn=server_fn)
+    # Save final model to disk
+    print("\nSaving final model to disk...")
+    state_dict = result.arrays.to_torch_state_dict()
+    torch.save(state_dict, "final_model.pt")

flwr/cli/new/templates/app/code/server.jax.py.tpl

@@ -1,26 +1,39 @@
 """$project_name: A Flower / $framework_str app."""
 
-from flwr.common import Context, ndarrays_to_parameters
-from flwr.server import ServerApp, ServerAppComponents, ServerConfig
-from flwr.server.strategy import FedAvg
+import numpy as np
+from flwr.app import ArrayRecord, Context
+from flwr.serverapp import Grid, ServerApp
+from flwr.serverapp.strategy import FedAvg
+
 from $import_name.task import get_params, load_model
 
+# Create ServerApp
+app = ServerApp()
+
+
+@app.main()
+def main(grid: Grid, context: Context) -> None:
+    """Main entry point for the ServerApp."""
 
-def server_fn(context: Context):
     # Read from config
     num_rounds = context.run_config["num-server-rounds"]
     input_dim = context.run_config["input-dim"]
 
-    # Initialize global model
-    params = get_params(load_model((input_dim,)))
-    initial_parameters = ndarrays_to_parameters(params)
-
-    # Define strategy
-    strategy = FedAvg(initial_parameters=initial_parameters)
-    config = ServerConfig(num_rounds=num_rounds)
+    # Load global model
+    model = load_model((input_dim,))
+    arrays = ArrayRecord(get_params(model))
 
-    return ServerAppComponents(strategy=strategy, config=config)
+    # Initialize FedAvg strategy
+    strategy = FedAvg()
 
+    # Start strategy, run FedAvg for `num_rounds`
+    result = strategy.start(
+        grid=grid,
+        initial_arrays=arrays,
+        num_rounds=num_rounds,
+    )
 
-# Create ServerApp
-app = ServerApp(server_fn=server_fn)
+    # Save final model to disk
+    print("\nSaving final model to disk...")
+    ndarrays = result.arrays.to_numpy_ndarrays()
+    np.savez("final_model.npz", *ndarrays)

flwr/cli/new/templates/app/code/server.mlx.py.tpl

@@ -1,31 +1,41 @@
 """$project_name: A Flower / $framework_str app."""
 
-from flwr.common import Context, ndarrays_to_parameters
-from flwr.server import ServerApp, ServerAppComponents, ServerConfig
-from flwr.server.strategy import FedAvg
-from $import_name.task import MLP, get_params
+from flwr.app import ArrayRecord, Context
+from flwr.serverapp import Grid, ServerApp
+from flwr.serverapp.strategy import FedAvg
 
+from $import_name.task import MLP, get_params, set_params
 
-def server_fn(context: Context):
+# Create ServerApp
+app = ServerApp()
+
+
+@app.main()
+def main(grid: Grid, context: Context) -> None:
+    """Main entry point for the ServerApp."""
     # Read from config
     num_rounds = context.run_config["num-server-rounds"]
-
-    num_classes = 10
     num_layers = context.run_config["num-layers"]
     input_dim = context.run_config["input-dim"]
     hidden_dim = context.run_config["hidden-dim"]
 
     # Initialize global model
-    model = MLP(num_layers, input_dim, hidden_dim, num_classes)
+    model = MLP(num_layers, input_dim, hidden_dim, output_dim=10)
     params = get_params(model)
-    initial_parameters = ndarrays_to_parameters(params)
-
-    # Define strategy
-    strategy = FedAvg(initial_parameters=initial_parameters)
-    config = ServerConfig(num_rounds=num_rounds)
-
-    return ServerAppComponents(strategy=strategy, config=config)
-
-
-# Create ServerApp
-app = ServerApp(server_fn=server_fn)
+    arrays = ArrayRecord(params)
+
+    # Initialize FedAvg strategy
+    strategy = FedAvg()
+
+    # Start strategy, run FedAvg for `num_rounds`
+    result = strategy.start(
+        grid=grid,
+        initial_arrays=arrays,
+        num_rounds=num_rounds,
+    )
+
+    # Save final model to disk
+    print("\nSaving final model to disk...")
+    ndarrays = result.arrays.to_numpy_ndarrays()
+    set_params(model, ndarrays)
+    model.save_weights("final_model.npz")

flwr/cli/new/templates/app/code/server.numpy.py.tpl

@@ -1,25 +1,38 @@
 """$project_name: A Flower / $framework_str app."""
 
-from flwr.common import Context, ndarrays_to_parameters
-from flwr.server import ServerApp, ServerAppComponents, ServerConfig
-from flwr.server.strategy import FedAvg
-from $import_name.task import get_dummy_model
-
+import numpy as np
+from flwr.app import ArrayRecord, Context
+from flwr.serverapp import Grid, ServerApp
+from flwr.serverapp.strategy import FedAvg
 
-def server_fn(context: Context):
-    # Read from config
-    num_rounds = context.run_config["num-server-rounds"]
+from $import_name.task import get_dummy_model
 
-    # Initial model
-    model = get_dummy_model()
-    dummy_parameters = ndarrays_to_parameters([model])
+# Create ServerApp
+app = ServerApp()
 
-    # Define strategy
-    strategy = FedAvg(initial_parameters=dummy_parameters)
-    config = ServerConfig(num_rounds=num_rounds)
 
-    return ServerAppComponents(strategy=strategy, config=config)
+@app.main()
+def main(grid: Grid, context: Context) -> None:
+    """Main entry point for the ServerApp."""
 
+    # Read run config
+    num_rounds: int = context.run_config["num-server-rounds"]
 
-# Create ServerApp
-app = ServerApp(server_fn=server_fn)
+    # Load global model
+    model = get_dummy_model()
+    arrays = ArrayRecord(model)
+
+    # Initialize FedAvg strategy
+    strategy = FedAvg()
+
+    # Start strategy, run FedAvg for `num_rounds`
+    result = strategy.start(
+        grid=grid,
+        initial_arrays=arrays,
+        num_rounds=num_rounds,
+    )
+
+    # Save final model to disk
+    print("\nSaving final model to disk...")
+    ndarrays = result.arrays.to_numpy_ndarrays()
+    np.savez("final_model", *ndarrays)

flwr/cli/new/templates/app/code/server.pytorch.py.tpl

@@ -1,31 +1,41 @@
 """$project_name: A Flower / $framework_str app."""
 
-from flwr.common import Context, ndarrays_to_parameters
-from flwr.server import ServerApp, ServerAppComponents, ServerConfig
-from flwr.server.strategy import FedAvg
-from $import_name.task import Net, get_weights
-
-
-def server_fn(context: Context):
-    # Read from config
-    num_rounds = context.run_config["num-server-rounds"]
-    fraction_fit = context.run_config["fraction-fit"]
-
-    # Initialize model parameters
-    ndarrays = get_weights(Net())
-    parameters = ndarrays_to_parameters(ndarrays)
-
-    # Define strategy
-    strategy = FedAvg(
-        fraction_fit=fraction_fit,
-        fraction_evaluate=1.0,
-        min_available_clients=2,
-        initial_parameters=parameters,
-    )
-    config = ServerConfig(num_rounds=num_rounds)
-
-    return ServerAppComponents(strategy=strategy, config=config)
+import torch
+from flwr.app import ArrayRecord, ConfigRecord, Context
+from flwr.serverapp import Grid, ServerApp
+from flwr.serverapp.strategy import FedAvg
 
+from $import_name.task import Net
 
 # Create ServerApp
-app = ServerApp(server_fn=server_fn)
+app = ServerApp()
+
+
+@app.main()
+def main(grid: Grid, context: Context) -> None:
+    """Main entry point for the ServerApp."""
+
+    # Read run config
+    fraction_train: float = context.run_config["fraction-train"]
+    num_rounds: int = context.run_config["num-server-rounds"]
+    lr: float = context.run_config["lr"]
+
+    # Load global model
+    global_model = Net()
+    arrays = ArrayRecord(global_model.state_dict())
+
+    # Initialize FedAvg strategy
+    strategy = FedAvg(fraction_train=fraction_train)
+
+    # Start strategy, run FedAvg for `num_rounds`
+    result = strategy.start(
+        grid=grid,
+        initial_arrays=arrays,
+        train_config=ConfigRecord({"lr": lr}),
+        num_rounds=num_rounds,
+    )
+
+    # Save final model to disk
+    print("\nSaving final model to disk...")
+    state_dict = result.arrays.to_torch_state_dict()
+    torch.save(state_dict, "final_model.pt")

flwr/cli/new/templates/app/code/server.pytorch_legacy_api.py.tpl

@@ -0,0 +1,31 @@
+"""$project_name: A Flower / $framework_str app."""
+
+from flwr.common import Context, ndarrays_to_parameters
+from flwr.server import ServerApp, ServerAppComponents, ServerConfig
+from flwr.server.strategy import FedAvg
+from $import_name.task import Net, get_weights
+
+
+def server_fn(context: Context):
+    # Read from config
+    num_rounds = context.run_config["num-server-rounds"]
+    fraction_fit = context.run_config["fraction-fit"]
+
+    # Initialize model parameters
+    ndarrays = get_weights(Net())
+    parameters = ndarrays_to_parameters(ndarrays)
+
+    # Define strategy
+    strategy = FedAvg(
+        fraction_fit=fraction_fit,
+        fraction_evaluate=1.0,
+        min_available_clients=2,
+        initial_parameters=parameters,
+    )
+    config = ServerConfig(num_rounds=num_rounds)
+
+    return ServerAppComponents(strategy=strategy, config=config)
+
+
+# Create ServerApp
+app = ServerApp(server_fn=server_fn)

flwr/cli/new/templates/app/code/server.sklearn.py.tpl

@@ -1,36 +1,44 @@
 """$project_name: A Flower / $framework_str app."""
 
-from flwr.common import Context, ndarrays_to_parameters
-from flwr.server import ServerApp, ServerAppComponents, ServerConfig
-from flwr.server.strategy import FedAvg
-from $import_name.task import get_model, get_model_params, set_initial_params
+import joblib
+from flwr.app import ArrayRecord, Context
+from flwr.serverapp import Grid, ServerApp
+from flwr.serverapp.strategy import FedAvg
 
+from $import_name.task import get_model, get_model_params, set_initial_params, set_model_params
 
-def server_fn(context: Context):
-    # Read from config
-    num_rounds = context.run_config["num-server-rounds"]
+# Create ServerApp
+app = ServerApp()
+
+
+@app.main()
+def main(grid: Grid, context: Context) -> None:
+    """Main entry point for the ServerApp."""
+
+    # Read run config
+    num_rounds: int = context.run_config["num-server-rounds"]
 
     # Create LogisticRegression Model
     penalty = context.run_config["penalty"]
     local_epochs = context.run_config["local-epochs"]
     model = get_model(penalty, local_epochs)
-
     # Setting initial parameters, akin to model.compile for keras models
     set_initial_params(model)
+    # Construct ArrayRecord representation
+    arrays = ArrayRecord(get_model_params(model))
 
-    initial_parameters = ndarrays_to_parameters(get_model_params(model))
+    # Initialize FedAvg strategy
+    strategy = FedAvg(fraction_train=1.0, fraction_evaluate=1.0)
 
-    # Define strategy
-    strategy = FedAvg(
-        fraction_fit=1.0,
-        fraction_evaluate=1.0,
-        min_available_clients=2,
-        initial_parameters=initial_parameters,
+    # Start strategy, run FedAvg for `num_rounds`
+    result = strategy.start(
+        grid=grid,
+        initial_arrays=arrays,
+        num_rounds=num_rounds,
     )
-    config = ServerConfig(num_rounds=num_rounds)
-
-    return ServerAppComponents(strategy=strategy, config=config)
 
-
-# Create ServerApp
-app = ServerApp(server_fn=server_fn)
+    # Save final model parameters
+    print("\nSaving final model to disk...")
+    ndarrays = result.arrays.to_numpy_ndarrays()
+    set_model_params(model, ndarrays)
+    joblib.dump(model, "logreg_model.pkl")

flwr/cli/new/templates/app/code/server.tensorflow.py.tpl

@@ -1,29 +1,38 @@
 """$project_name: A Flower / $framework_str app."""
 
-from flwr.common import Context, ndarrays_to_parameters
-from flwr.server import ServerApp, ServerAppComponents, ServerConfig
-from flwr.server.strategy import FedAvg
+from flwr.app import ArrayRecord, Context
+from flwr.serverapp import Grid, ServerApp
+from flwr.serverapp.strategy import FedAvg
 
 from $import_name.task import load_model
 
+# Create ServerApp
+app = ServerApp()
 
-def server_fn(context: Context):
-    # Read from config
-    num_rounds = context.run_config["num-server-rounds"]
 
-    # Get parameters to initialize global model
-    parameters = ndarrays_to_parameters(load_model().get_weights())
+@app.main()
+def main(grid: Grid, context: Context) -> None:
+    """Main entry point for the ServerApp."""
 
-    # Define strategy
-    strategy = strategy = FedAvg(
-        fraction_fit=1.0,
-        fraction_evaluate=1.0,
-        min_available_clients=2,
-        initial_parameters=parameters,
-    )
-    config = ServerConfig(num_rounds=num_rounds)
+    # Read run config
+    num_rounds: int = context.run_config["num-server-rounds"]
 
-    return ServerAppComponents(strategy=strategy, config=config)
+    # Load global model
+    model = load_model()
+    arrays = ArrayRecord(model.get_weights())
 
-# Create ServerApp
-app = ServerApp(server_fn=server_fn)
+    # Initialize FedAvg strategy
+    strategy = FedAvg(fraction_train=1.0, fraction_evaluate=1.0)
+
+    # Start strategy, run FedAvg for `num_rounds`
+    result = strategy.start(
+        grid=grid,
+        initial_arrays=arrays,
+        num_rounds=num_rounds,
+    )
+
+    # Save final model to disk
+    print("\nSaving final model to disk...")
+    ndarrays = result.arrays.to_numpy_ndarrays()
+    model.set_weights(ndarrays)
+    model.save("final_model.keras")