flwr-nightly 1.22.0.dev20250910__py3-none-any.whl → 1.22.0.dev20250912__py3-none-any.whl

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

@@ -1,57 +1,82 @@
 """$project_name: A Flower / $framework_str app."""
 
-from flwr.client import NumPyClient, ClientApp
-from flwr.common import Context
+from flwr.app import ArrayRecord, Context, Message, MetricRecord, RecordDict
+from flwr.clientapp import ClientApp
 
 from $import_name.task import load_data, load_model
 
+# Flower ClientApp
+app = ClientApp()
 
-# Define Flower Client and client_fn
-class FlowerClient(NumPyClient):
-    def __init__(
-        self, model, data, epochs, batch_size, verbose
-    ):
-        self.model = model
-        self.x_train, self.y_train, self.x_test, self.y_test = data
-        self.epochs = epochs
-        self.batch_size = batch_size
-        self.verbose = verbose
-
-    def fit(self, parameters, config):
-        self.model.set_weights(parameters)
-        self.model.fit(
-            self.x_train,
-            self.y_train,
-            epochs=self.epochs,
-            batch_size=self.batch_size,
-            verbose=self.verbose,
-        )
-        return self.model.get_weights(), len(self.x_train), {}
-
-    def evaluate(self, parameters, config):
-        self.model.set_weights(parameters)
-        loss, accuracy = self.model.evaluate(self.x_test, self.y_test, verbose=0)
-        return loss, len(self.x_test), {"accuracy": accuracy}
-
-
-def client_fn(context: Context):
-    # Load model and data
-    net = load_model()
 
-    partition_id = context.node_config["partition-id"]
-    num_partitions = context.node_config["num-partitions"]
-    data = load_data(partition_id, num_partitions)
+@app.train()
+def train(msg: Message, context: Context):
+    """Train the model on local data."""
+
+    # Load the model and initialize it with the received weights
+    model = load_model()
+    ndarrays = msg.content["arrays"].to_numpy_ndarrays()
+    model.set_weights(ndarrays)
+
+    # Read from config
     epochs = context.run_config["local-epochs"]
     batch_size = context.run_config["batch-size"]
     verbose = context.run_config.get("verbose")
 
-    # Return Client instance
-    return FlowerClient(
-        net, data, epochs, batch_size, verbose
-    ).to_client()
+    # Load the data
+    partition_id = context.node_config["partition-id"]
+    num_partitions = context.node_config["num-partitions"]
+    x_train, y_train, _, _ = load_data(partition_id, num_partitions)
 
+    # Train the model on local data
+    history = model.fit(
+        x_train,
+        y_train,
+        epochs=epochs,
+        batch_size=batch_size,
+        verbose=verbose,
+    )
 
-# Flower ClientApp
-app = ClientApp(
-    client_fn=client_fn,
-)
+    # Get final training loss and accuracy
+    train_loss = history.history["loss"][-1] if "loss" in history.history else None
+    train_acc = history.history.get("accuracy")
+    train_acc = train_acc[-1] if train_acc is not None else None
+
+    # Construct and return reply Message
+    model_record = ArrayRecord(model.get_weights())
+    metrics = {"num-examples": len(x_train)}
+    if train_loss is not None:
+        metrics["train_loss"] = train_loss
+    if train_acc is not None:
+        metrics["train_acc"] = train_acc
+    metric_record = MetricRecord(metrics)
+    content = RecordDict({"arrays": model_record, "metrics": metric_record})
+    return Message(content=content, reply_to=msg)
+
+
+@app.evaluate()
+def evaluate(msg: Message, context: Context):
+    """Evaluate the model on local data."""
+
+    # Load the model and initialize it with the received weights
+    model = load_model()
+    ndarrays = msg.content["arrays"].to_numpy_ndarrays()
+    model.set_weights(ndarrays)
+
+    # Load the data
+    partition_id = context.node_config["partition-id"]
+    num_partitions = context.node_config["num-partitions"]
+    _, _, x_test, y_test = load_data(partition_id, num_partitions)
+
+    # Evaluate the model on local data
+    loss, accuracy = model.evaluate(x_test, y_test, verbose=0)
+
+    # Construct and return reply Message
+    metrics = {
+        "eval_loss": loss,
+        "eval_acc": accuracy,
+        "num-examples": len(x_test),
+    }
+    metric_record = MetricRecord(metrics)
+    content = RecordDict({"metrics": metric_record})
+    return Message(content=content, reply_to=msg)

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.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")

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

@@ -1,7 +1,6 @@
 """$project_name: A Flower / $framework_str app."""
 
 import warnings
-from collections import OrderedDict
 
 import torch
 import transformers
@@ -62,17 +61,24 @@ def load_data(partition_id: int, num_partitions: int, model_name: str):
     return trainloader, testloader
 
 
-def train(net, trainloader, epochs, device):
+def train(net, trainloader, num_steps, device):
     optimizer = AdamW(net.parameters(), lr=5e-5)
     net.train()
-    for _ in range(epochs):
-        for batch in trainloader:
-            batch = {k: v.to(device) for k, v in batch.items()}
-            outputs = net(**batch)
-            loss = outputs.loss
-            loss.backward()
-            optimizer.step()
-            optimizer.zero_grad()
+    running_loss = 0.0
+    step_cnt = 0
+    for batch in trainloader:
+        batch = {k: v.to(device) for k, v in batch.items()}
+        outputs = net(**batch)
+        loss = outputs.loss
+        loss.backward()
+        optimizer.step()
+        optimizer.zero_grad()
+        running_loss += loss.item()
+        step_cnt += 1
+        if step_cnt >= num_steps:
+            break
+    avg_trainloss = running_loss / step_cnt
+    return avg_trainloss
 
 
 def test(net, testloader, device):
@@ -90,13 +96,3 @@ def test(net, testloader, device):
     loss /= len(testloader.dataset)
     accuracy = metric.compute()["accuracy"]
     return loss, accuracy
-
-
-def get_weights(net):
-    return [val.cpu().numpy() for _, val in net.state_dict().items()]
-
-
-def set_weights(net, parameters):
-    params_dict = zip(net.state_dict().keys(), parameters)
-    state_dict = OrderedDict({k: torch.tensor(v) for k, v in params_dict})
-    net.load_state_dict(state_dict, strict=True)

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

@@ -31,7 +31,7 @@ def loss_fn(params, X, y):
 def train(params, grad_fn, X, y):
     loss = 1_000_000
     num_examples = X.shape[0]
-    for epochs in range(50):
+    for _ in range(50):
         grads = grad_fn(params, X, y)
         params = jax.tree.map(lambda p, g: p - 0.05 * g, params, grads)
         loss = loss_fn(params, X, y)

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

@@ -4,4 +4,4 @@ import numpy as np
 
 
 def get_dummy_model():
-    return np.ones((1, 1))
+    return [np.ones((1, 1))]

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

@@ -3,10 +3,9 @@
 import os
 
 import keras
-from keras import layers
 from flwr_datasets import FederatedDataset
 from flwr_datasets.partitioner import IidPartitioner
-
+from keras import layers
 
 # Make TensorFlow log less verbose
 os.environ["TF_CPP_MIN_LOG_LEVEL"] = "3"

flwr/cli/new/templates/app/pyproject.huggingface.toml.tpl

@@ -16,7 +16,7 @@ license = "Apache-2.0"
 dependencies = [
     "flwr[simulation]>=1.22.0",
     "flwr-datasets>=0.5.0",
-    "torch==2.7.1",
+    "torch>=2.7.1",
     "transformers>=4.30.0,<5.0",
     "evaluate>=0.4.0,<1.0",
     "datasets>=2.0.0, <3.0",
@@ -38,8 +38,8 @@ clientapp = "$import_name.client_app:app"
 # Custom config values accessible via `context.run_config`
 [tool.flwr.app.config]
 num-server-rounds = 3
-fraction-fit = 0.5
-local-epochs = 1
+fraction-train = 0.5
+local-steps = 5
 model-name = "prajjwal1/bert-tiny" # Set a larger model if you have access to more GPU resources
 num-labels = 2
 

flwr/cli/new/templates/app/pyproject.mlx.toml.tpl

@@ -16,7 +16,7 @@ license = "Apache-2.0"
 dependencies = [
     "flwr[simulation]>=1.22.0",
     "flwr-datasets[vision]>=0.5.0",
-    "mlx==0.26.5",
+    "mlx==0.29.0",
 ]
 
 [tool.hatch.build.targets.wheel]