flwr-nightly 1.22.0.dev20250910__tar.gz → 1.22.0.dev20250912__tar.gz

{flwr_nightly-1.22.0.dev20250910 → flwr_nightly-1.22.0.dev20250912}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: flwr-nightly
-Version: 1.22.0.dev20250910
+Version: 1.22.0.dev20250912
 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.22.0.dev20250912/py/flwr/cli/new/templates/app/code/client.huggingface.py.tpl

@@ -0,0 +1,93 @@
+"""$project_name: A Flower / $framework_str app."""
+
+import torch
+from flwr.app import ArrayRecord, Context, Message, MetricRecord, RecordDict
+from flwr.clientapp import ClientApp
+from transformers import AutoModelForSequenceClassification
+
+from $import_name.task import load_data
+from $import_name.task import test as test_fn
+from $import_name.task import train as train_fn
+
+# Flower ClientApp
+app = ClientApp()
+
+
+@app.train()
+def train(msg: Message, context: Context):
+    """Train the model on local data."""
+
+    # Get this client's dataset partition
+    partition_id = context.node_config["partition-id"]
+    num_partitions = context.node_config["num-partitions"]
+    model_name = context.run_config["model-name"]
+    trainloader, _ = load_data(partition_id, num_partitions, model_name)
+
+    # Load model
+    num_labels = context.run_config["num-labels"]
+    net = AutoModelForSequenceClassification.from_pretrained(
+        model_name, num_labels=num_labels
+    )
+
+    # Initialize it with the received weights
+    net.load_state_dict(msg.content["arrays"].to_torch_state_dict())
+    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+    net.to(device)
+
+    # Train the model on local data
+    train_loss = train_fn(
+        net,
+        trainloader,
+        context.run_config["local-steps"],
+        device,
+    )
+
+    # Construct and return reply Message
+    model_record = ArrayRecord(net.state_dict())
+    metrics = {
+        "train_loss": train_loss,
+        "num-examples": len(trainloader.dataset),
+    }
+    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."""
+
+    # Get this client's dataset partition
+    partition_id = context.node_config["partition-id"]
+    num_partitions = context.node_config["num-partitions"]
+    model_name = context.run_config["model-name"]
+    _, valloader = load_data(partition_id, num_partitions, model_name)
+
+    # Load model
+    num_labels = context.run_config["num-labels"]
+    net = AutoModelForSequenceClassification.from_pretrained(
+        model_name, num_labels=num_labels
+    )
+
+    # Initialize it with the received weights
+    net.load_state_dict(msg.content["arrays"].to_torch_state_dict())
+    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+    net.to(device)
+
+    # Evaluate the model on local data
+    val_loss, val_accuracy = test_fn(
+        net,
+        valloader,
+        device,
+    )
+
+    # Construct and return reply Message
+    model_record = ArrayRecord(net.state_dict())
+    metrics = {
+        "val_loss": val_loss,
+        "val_accuracy": val_accuracy,
+        "num-examples": len(valloader.dataset),
+    }
+    metric_record = MetricRecord(metrics)
+    content = RecordDict({"arrays": model_record, "metrics": metric_record})
+    return Message(content=content, reply_to=msg)

flwr_nightly-1.22.0.dev20250912/py/flwr/cli/new/templates/app/code/client.jax.py.tpl

@@ -0,0 +1,71 @@
+"""$project_name: A Flower / $framework_str app."""
+
+import jax
+from flwr.app import ArrayRecord, Context, Message, MetricRecord, RecordDict
+from flwr.clientapp import ClientApp
+
+from $import_name.task import evaluation as evaluation_fn
+from $import_name.task import get_params, load_data, load_model, loss_fn, set_params
+from $import_name.task import train as train_fn
+
+# Flower ClientApp
+app = ClientApp()
+
+
+@app.train()
+def train(msg: Message, context: Context):
+    """Train the model on local data."""
+
+    # Read from config
+    input_dim = context.run_config["input-dim"]
+
+    # Load data and model
+    train_x, train_y, _, _ = load_data()
+    model = load_model((input_dim,))
+    grad_fn = jax.grad(loss_fn)
+
+    # Set model parameters
+    ndarrays = msg.content["arrays"].to_numpy_ndarrays()
+    set_params(model, ndarrays)
+
+    # Train the model on local data
+    model, loss, num_examples = train_fn(model, grad_fn, train_x, train_y)
+
+    # Construct and return reply Message
+    model_record = ArrayRecord(get_params(model))
+    metrics = {
+        "train_loss": float(loss),
+        "num-examples": num_examples,
+    }
+    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."""
+
+    # Read from config
+    input_dim = context.run_config["input-dim"]
+
+    # Load data and model
+    _, _, test_x, test_y = load_data()
+    model = load_model((input_dim,))
+    grad_fn = jax.grad(loss_fn)
+
+    # Set model parameters
+    ndarrays = msg.content["arrays"].to_numpy_ndarrays()
+    set_params(model, ndarrays)
+
+    # Evaluate the model on local data
+    loss, num_examples = evaluation_fn(model, grad_fn, test_x, test_y)
+
+    # Construct and return reply Message
+    metrics = {
+        "test_loss": float(loss),
+        "num-examples": num_examples,
+    }
+    metric_record = MetricRecord(metrics)
+    content = RecordDict({"metrics": metric_record})
+    return Message(content=content, reply_to=msg)

flwr_nightly-1.22.0.dev20250912/py/flwr/cli/new/templates/app/code/client.mlx.py.tpl

@@ -0,0 +1,102 @@
+"""$project_name: A Flower / $framework_str app."""
+
+import mlx.core as mx
+import mlx.nn as nn
+import mlx.optimizers as optim
+from flwr.app import ArrayRecord, Context, Message, MetricRecord, RecordDict
+from flwr.clientapp import ClientApp
+
+from $import_name.task import (
+    MLP,
+    batch_iterate,
+    eval_fn,
+    get_params,
+    load_data,
+    loss_fn,
+    set_params,
+)
+
+# Flower ClientApp
+app = ClientApp()
+
+
+@app.train()
+def train(msg: Message, context: Context):
+    """Train the model on local data."""
+
+    # Read config
+    num_layers = context.run_config["num-layers"]
+    input_dim = context.run_config["input-dim"]
+    hidden_dim = context.run_config["hidden-dim"]
+    batch_size = context.run_config["batch-size"]
+    learning_rate = context.run_config["lr"]
+    num_epochs = context.run_config["local-epochs"]
+
+    # Instantiate model and apply global parameters
+    model = MLP(num_layers, input_dim, hidden_dim, output_dim=10)
+    ndarrays = msg.content["arrays"].to_numpy_ndarrays()
+    set_params(model, ndarrays)
+
+    # Define optimizer and loss function
+    optimizer = optim.SGD(learning_rate=learning_rate)
+    loss_and_grad_fn = nn.value_and_grad(model, loss_fn)
+
+    # Load data
+    partition_id = context.node_config["partition-id"]
+    num_partitions = context.node_config["num-partitions"]
+    train_images, train_labels, _, _ = load_data(partition_id, num_partitions)
+
+    # Train the model on local data
+    for _ in range(num_epochs):
+        for X, y in batch_iterate(batch_size, train_images, train_labels):
+            _, grads = loss_and_grad_fn(model, X, y)
+            optimizer.update(model, grads)
+            mx.eval(model.parameters(), optimizer.state)
+
+    # Compute train accuracy and loss
+    accuracy = eval_fn(model, train_images, train_labels)
+    loss = loss_fn(model, train_images, train_labels)
+    # Construct and return reply Message
+    model_record = ArrayRecord(get_params(model))
+    metrics = {
+        "num-examples": len(train_images),
+        "accuracy": float(accuracy.item()),
+        "loss": float(loss.item()),
+    }
+    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."""
+
+    # Read config
+    num_layers = context.run_config["num-layers"]
+    input_dim = context.run_config["input-dim"]
+    hidden_dim = context.run_config["hidden-dim"]
+
+    # Instantiate model and apply global parameters
+    model = MLP(num_layers, input_dim, hidden_dim, output_dim=10)
+    ndarrays = msg.content["arrays"].to_numpy_ndarrays()
+    set_params(model, ndarrays)
+
+    # Load data
+    partition_id = context.node_config["partition-id"]
+    num_partitions = context.node_config["num-partitions"]
+    _, _, test_images, test_labels = load_data(partition_id, num_partitions)
+
+    # Evaluate the model on local data
+    accuracy = eval_fn(model, test_images, test_labels)
+    loss = loss_fn(model, test_images, test_labels)
+
+    # Construct and return reply Message
+    metrics = {
+        "num-examples": len(test_images),
+        "accuracy": float(accuracy.item()),
+        "loss": float(loss.item()),
+    }
+    metric_record = MetricRecord(metrics)
+    content = RecordDict({"metrics": metric_record})
+    return Message(content=content, reply_to=msg)

flwr_nightly-1.22.0.dev20250912/py/flwr/cli/new/templates/app/code/client.numpy.py.tpl

@@ -0,0 +1,46 @@
+"""$project_name: A Flower / $framework_str app."""
+
+import numpy as np
+from flwr.app import ArrayRecord, Context, Message, MetricRecord, RecordDict
+from flwr.clientapp import ClientApp
+
+# Flower ClientApp
+app = ClientApp()
+
+
+@app.train()
+def train(msg: Message, context: Context):
+    """Train the model on local data."""
+
+    # The model is the global arrays
+    ndarrays = msg.content["arrays"].to_numpy_ndarrays()
+
+    # Simulate local training (here we just add random noise to model parameters)
+    model = [m + np.random.rand(*m.shape) for m in ndarrays]
+
+    # Construct and return reply Message
+    model_record = ArrayRecord(model)
+    metrics = {
+        "random_metric": np.random.rand(),
+        "num-examples": 1,
+    }
+    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."""
+
+    # The model is the global arrays
+    ndarrays = msg.content["arrays"].to_numpy_ndarrays()
+
+    # Return reply Message
+    metrics = {
+        "random_metric": np.random.rand(3).tolist(),
+        "num-examples": 1,
+    }
+    metric_record = MetricRecord(metrics)
+    content = RecordDict({"metrics": metric_record})
+    return Message(content=content, reply_to=msg)

flwr_nightly-1.22.0.dev20250912/py/flwr/cli/new/templates/app/code/client.sklearn.py.tpl

@@ -0,0 +1,108 @@
+"""$project_name: A Flower / $framework_str app."""
+
+import warnings
+
+from flwr.app import ArrayRecord, Context, Message, MetricRecord, RecordDict
+from flwr.clientapp import ClientApp
+from sklearn.metrics import (
+    accuracy_score,
+    f1_score,
+    log_loss,
+    precision_score,
+    recall_score,
+)
+
+from $import_name.task import (
+    get_model,
+    get_model_params,
+    load_data,
+    set_initial_params,
+    set_model_params,
+)
+
+# Flower ClientApp
+app = ClientApp()
+
+
+@app.train()
+def train(msg: Message, context: Context):
+    """Train the model on local data."""
+
+    # 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)
+
+    # Apply received pararameters
+    ndarrays = msg.content["arrays"].to_numpy_ndarrays()
+    set_model_params(model, ndarrays)
+
+    # 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)
+
+    # Ignore convergence failure due to low local epochs
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore")
+        # Train the model on local data
+        model.fit(X_train, y_train)
+
+    # Let's compute train loss
+    y_train_pred_proba = model.predict_proba(X_train)
+    train_logloss = log_loss(y_train, y_train_pred_proba)
+
+    # Construct and return reply Message
+    ndarrays = get_model_params(model)
+    model_record = ArrayRecord(ndarrays)
+    metrics = {"num-examples": len(X_train), "train_logloss": train_logloss}
+    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 test data."""
+
+    # 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)
+
+    # Apply received pararameters
+    ndarrays = msg.content["arrays"].to_numpy_ndarrays()
+    set_model_params(model, 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
+    y_train_pred = model.predict(X_test)
+    y_train_pred_proba = model.predict_proba(X_test)
+
+    accuracy = accuracy_score(y_test, y_train_pred)
+    loss = log_loss(y_test, y_train_pred_proba)
+    precision = precision_score(y_test, y_train_pred, average="macro", zero_division=0)
+    recall = recall_score(y_test, y_train_pred, average="macro", zero_division=0)
+    f1 = f1_score(y_test, y_train_pred, average="macro", zero_division=0)
+
+    # Construct and return reply Message
+    metrics = {
+        "num-examples": len(X_test),
+        "test_logloss": loss,
+        "accuracy": accuracy,
+        "precision": precision,
+        "recall": recall,
+        "f1": f1,
+    }
+    metric_record = MetricRecord(metrics)
+    content = RecordDict({"metrics": metric_record})
+    return Message(content=content, reply_to=msg)

flwr_nightly-1.22.0.dev20250912/py/flwr/cli/new/templates/app/code/client.tensorflow.py.tpl

@@ -0,0 +1,82 @@
+"""$project_name: A Flower / $framework_str app."""
+
+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()
+
+
+@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")
+
+    # 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,
+    )
+
+    # 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_nightly-1.22.0.dev20250912/py/flwr/cli/new/templates/app/code/server.huggingface.py.tpl

@@ -0,0 +1,42 @@
+"""$project_name: A Flower / $framework_str app."""
+
+import torch
+from flwr.app import ArrayRecord, Context
+from flwr.serverapp import Grid, ServerApp
+from flwr.serverapp.strategy import FedAvg
+from transformers import AutoModelForSequenceClassification
+
+# 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"]
+    fraction_train = context.run_config["fraction-train"]
+
+    # Initialize global model
+    model_name = context.run_config["model-name"]
+    num_labels = context.run_config["num-labels"]
+    net = AutoModelForSequenceClassification.from_pretrained(
+        model_name, num_labels=num_labels
+    )
+    arrays = ArrayRecord(net.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,
+        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_nightly-1.22.0.dev20250912/py/flwr/cli/new/templates/app/code/server.jax.py.tpl

@@ -0,0 +1,39 @@
+"""$project_name: A Flower / $framework_str app."""
+
+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."""
+
+    # Read from config
+    num_rounds = context.run_config["num-server-rounds"]
+    input_dim = context.run_config["input-dim"]
+
+    # Load global model
+    model = load_model((input_dim,))
+    arrays = ArrayRecord(get_params(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.npz", *ndarrays)

flwr_nightly-1.22.0.dev20250912/py/flwr/cli/new/templates/app/code/server.mlx.py.tpl

@@ -0,0 +1,41 @@
+"""$project_name: A Flower / $framework_str app."""
+
+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
+
+# 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_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, output_dim=10)
+    params = get_params(model)
+    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_nightly-1.22.0.dev20250912/py/flwr/cli/new/templates/app/code/server.numpy.py.tpl

@@ -0,0 +1,38 @@
+"""$project_name: A Flower / $framework_str app."""
+
+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_dummy_model
+
+# 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"]
+
+    # 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)