flwr 1.24.0__py3-none-any.whl → 1.25.0__py3-none-any.whl

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

@@ -1,75 +0,0 @@
-"""$project_name: A Flower Baseline."""
-
-import torch
-from flwr.app import ArrayRecord, Context, Message, MetricRecord, RecordDict
-from flwr.clientapp import ClientApp
-
-from $import_name.dataset import load_data
-from $import_name.model import Net
-from $import_name.model import test as test_fn
-from $import_name.model import train as train_fn
-
-# 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 = Net()
-    model.load_state_dict(msg.content["arrays"].to_torch_state_dict())
-    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
-
-    # Load the data
-    partition_id = int(context.node_config["partition-id"])
-    num_partitions = int(context.node_config["num-partitions"])
-    trainloader, _ = load_data(partition_id, num_partitions)
-    local_epochs = context.run_config["local-epochs"]
-
-    # Call the training function
-    train_loss = train_fn(
-        model,
-        trainloader,
-        local_epochs,
-        device,
-    )
-
-    # Construct and return reply Message
-    model_record = ArrayRecord(model.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."""
-
-    # Load the model and initialize it with the received weights
-    model = Net()
-    model.load_state_dict(msg.content["arrays"].to_torch_state_dict())
-    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
-
-    # Load the data
-    partition_id = int(context.node_config["partition-id"])
-    num_partitions = int(context.node_config["num-partitions"])
-    _, valloader = load_data(partition_id, num_partitions)
-
-    # Call the evaluation function
-    eval_loss, eval_acc = test_fn(model, valloader, device)
-
-    # Construct and return reply Message
-    metrics = {
-        "eval_loss": eval_loss,
-        "eval_acc": eval_acc,
-        "num-examples": len(valloader.dataset),
-    }
-    metric_record = MetricRecord(metrics)
-    content = RecordDict({"metrics": metric_record})
-    return Message(content=content, reply_to=msg)

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

@@ -1,93 +0,0 @@
-"""$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/cli/new/templates/app/code/client.jax.py.tpl

@@ -1,71 +0,0 @@
-"""$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/cli/new/templates/app/code/client.mlx.py.tpl

@@ -1,102 +0,0 @@
-"""$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/cli/new/templates/app/code/client.numpy.py.tpl

@@ -1,46 +0,0 @@
-"""$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/cli/new/templates/app/code/client.pytorch.py.tpl

@@ -1,80 +0,0 @@
-"""$project_name: A Flower / $framework_str app."""
-
-import torch
-from flwr.app import ArrayRecord, Context, Message, MetricRecord, RecordDict
-from flwr.clientapp import ClientApp
-
-from $import_name.task import Net, 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."""
-
-    # Load the model and initialize it with the received weights
-    model = Net()
-    model.load_state_dict(msg.content["arrays"].to_torch_state_dict())
-    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
-    model.to(device)
-
-    # Load the data
-    partition_id = context.node_config["partition-id"]
-    num_partitions = context.node_config["num-partitions"]
-    trainloader, _ = load_data(partition_id, num_partitions)
-
-    # Call the training function
-    train_loss = train_fn(
-        model,
-        trainloader,
-        context.run_config["local-epochs"],
-        msg.content["config"]["lr"],
-        device,
-    )
-
-    # Construct and return reply Message
-    model_record = ArrayRecord(model.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."""
-
-    # Load the model and initialize it with the received weights
-    model = Net()
-    model.load_state_dict(msg.content["arrays"].to_torch_state_dict())
-    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
-    model.to(device)
-
-    # Load the data
-    partition_id = context.node_config["partition-id"]
-    num_partitions = context.node_config["num-partitions"]
-    _, valloader = load_data(partition_id, num_partitions)
-
-    # Call the evaluation function
-    eval_loss, eval_acc = test_fn(
-        model,
-        valloader,
-        device,
-    )
-
-    # Construct and return reply Message
-    metrics = {
-        "eval_loss": eval_loss,
-        "eval_acc": eval_acc,
-        "num-examples": len(valloader.dataset),
-    }
-    metric_record = MetricRecord(metrics)
-    content = RecordDict({"metrics": metric_record})
-    return Message(content=content, reply_to=msg)

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

@@ -1,55 +0,0 @@
-"""$project_name: A Flower / $framework_str app."""
-
-import torch
-
-from flwr.client import ClientApp, NumPyClient
-from flwr.common import Context
-from $import_name.task import Net, get_weights, load_data, set_weights, test, train
-
-
-# Define Flower Client and client_fn
-class FlowerClient(NumPyClient):
-    def __init__(self, net, trainloader, valloader, local_epochs):
-        self.net = net
-        self.trainloader = trainloader
-        self.valloader = valloader
-        self.local_epochs = local_epochs
-        self.device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
-        self.net.to(self.device)
-
-    def fit(self, parameters, config):
-        set_weights(self.net, parameters)
-        train_loss = train(
-            self.net,
-            self.trainloader,
-            self.local_epochs,
-            self.device,
-        )
-        return (
-            get_weights(self.net),
-            len(self.trainloader.dataset),
-            {"train_loss": train_loss},
-        )
-
-    def evaluate(self, parameters, config):
-        set_weights(self.net, parameters)
-        loss, accuracy = test(self.net, self.valloader, self.device)
-        return loss, len(self.valloader.dataset), {"accuracy": accuracy}
-
-
-def client_fn(context: Context):
-    # Load model and data
-    net = Net()
-    partition_id = context.node_config["partition-id"]
-    num_partitions = context.node_config["num-partitions"]
-    trainloader, valloader = load_data(partition_id, num_partitions)
-    local_epochs = context.run_config["local-epochs"]
-
-    # Return Client instance
-    return FlowerClient(net, trainloader, valloader, local_epochs).to_client()
-
-
-# Flower ClientApp
-app = ClientApp(
-    client_fn,
-)

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

@@ -1,108 +0,0 @@
-"""$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)