flwr-nightly 1.8.0.dev20240314__py3-none-any.whl → 1.15.0.dev20250114__py3-none-any.whl

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

@@ -0,0 +1,58 @@
+"""$project_name: A Flower Baseline."""
+
+import torch
+
+from flwr.client import ClientApp, NumPyClient
+from flwr.common import Context
+from $import_name.dataset import load_data
+from $import_name.model import Net, get_weights, set_weights, test, train
+
+
+class FlowerClient(NumPyClient):
+    """A class defining the client."""
+
+    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):
+        """Traim model using this client's data."""
+        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):
+        """Evaluate model using this client's data."""
+        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):
+    """Construct a Client that will be run in a ClientApp."""
+    # Load model and data
+    net = Net()
+    partition_id = int(context.node_config["partition-id"])
+    num_partitions = int(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.huggingface.py.tpl

@@ -0,0 +1,55 @@
+"""$project_name: A Flower / $framework_str app."""
+
+import torch
+from flwr.client import ClientApp, NumPyClient
+from flwr.common import Context
+from transformers import AutoModelForSequenceClassification
+
+from $import_name.task import get_weights, load_data, set_weights, test, train
+
+
+# Flower client
+class FlowerClient(NumPyClient):
+    def __init__(self, net, trainloader, testloader, local_epochs):
+        self.net = net
+        self.trainloader = trainloader
+        self.testloader = testloader
+        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(self.net, self.trainloader, epochs=self.local_epochs, device=self.device)
+        return get_weights(self.net), len(self.trainloader), {}
+
+    def evaluate(self, parameters, config):
+        set_weights(self.net, parameters)
+        loss, accuracy = test(self.net, self.testloader, self.device)
+        return float(loss), len(self.testloader), {"accuracy": accuracy}
+
+
+def client_fn(context: Context):
+
+    # 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, 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
+    )
+
+    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.jax.py.tpl

@@ -0,0 +1,50 @@
+"""$project_name: A Flower / $framework_str app."""
+
+import jax
+
+from flwr.client import ClientApp, NumPyClient
+from flwr.common import Context
+from $import_name.task import (
+    evaluation,
+    get_params,
+    load_data,
+    load_model,
+    loss_fn,
+    set_params,
+    train,
+)
+
+
+# Define Flower Client and client_fn
+class FlowerClient(NumPyClient):
+    def __init__(self, input_dim):
+        self.train_x, self.train_y, self.test_x, self.test_y = load_data()
+        self.grad_fn = jax.grad(loss_fn)
+        self.params = load_model((input_dim,))
+
+    def fit(self, parameters, config):
+        set_params(self.params, parameters)
+        self.params, loss, num_examples = train(
+            self.params, self.grad_fn, self.train_x, self.train_y
+        )
+        return get_params(self.params), num_examples, {"loss": float(loss)}
+
+    def evaluate(self, parameters, config):
+        set_params(self.params, parameters)
+        loss, num_examples = evaluation(
+            self.params, self.grad_fn, self.test_x, self.test_y
+        )
+        return float(loss), num_examples, {"loss": float(loss)}
+
+
+def client_fn(context: Context):
+    input_dim = context.run_config["input-dim"]
+
+    # Return Client instance
+    return FlowerClient(input_dim).to_client()
+
+
+# Flower ClientApp
+app = ClientApp(
+    client_fn,
+)

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

@@ -0,0 +1,73 @@
+"""$project_name: A Flower / $framework_str app."""
+
+import mlx.core as mx
+import mlx.nn as nn
+import mlx.optimizers as optim
+
+from flwr.client import ClientApp, NumPyClient
+from flwr.common import Context
+from flwr.common.config import UserConfig
+from $import_name.task import (
+    MLP,
+    batch_iterate,
+    eval_fn,
+    get_params,
+    load_data,
+    loss_fn,
+    set_params,
+)
+
+
+# Define Flower Client and client_fn
+class FlowerClient(NumPyClient):
+    def __init__(
+        self,
+        data,
+        run_config: UserConfig,
+        num_classes,
+    ):
+        num_layers = run_config["num-layers"]
+        hidden_dim = run_config["hidden-dim"]
+        input_dim = run_config["input-dim"]
+        batch_size = run_config["batch-size"]
+        learning_rate = run_config["lr"]
+        self.num_epochs = run_config["local-epochs"]
+
+        self.train_images, self.train_labels, self.test_images, self.test_labels = data
+        self.model = MLP(num_layers, input_dim, hidden_dim, num_classes)
+        self.optimizer = optim.SGD(learning_rate=learning_rate)
+        self.loss_and_grad_fn = nn.value_and_grad(self.model, loss_fn)
+        self.batch_size = batch_size
+
+    def fit(self, parameters, config):
+        set_params(self.model, parameters)
+        for _ in range(self.num_epochs):
+            for X, y in batch_iterate(
+                self.batch_size, self.train_images, self.train_labels
+            ):
+                _, grads = self.loss_and_grad_fn(self.model, X, y)
+                self.optimizer.update(self.model, grads)
+                mx.eval(self.model.parameters(), self.optimizer.state)
+        return get_params(self.model), len(self.train_images), {}
+
+    def evaluate(self, parameters, config):
+        set_params(self.model, parameters)
+        accuracy = eval_fn(self.model, self.test_images, self.test_labels)
+        loss = loss_fn(self.model, self.test_images, self.test_labels)
+        return loss.item(), len(self.test_images), {"accuracy": accuracy.item()}
+
+
+def client_fn(context: Context):
+    partition_id = context.node_config["partition-id"]
+    num_partitions = context.node_config["num-partitions"]
+    data = load_data(partition_id, num_partitions)
+    num_classes = 10
+
+    # Return Client instance
+    return FlowerClient(data, context.run_config, num_classes).to_client()
+
+
+# Flower ClientApp
+app = ClientApp(
+    client_fn,
+)

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

@@ -1,21 +1,21 @@
-"""$project_name: A Flower / NumPy app."""
+"""$project_name: A Flower / $framework_str app."""
 
-from flwr.client import NumPyClient, ClientApp
-import numpy as np
+from flwr.client import ClientApp, NumPyClient
+from flwr.common import Context
+from $import_name.task import get_dummy_model
 
 
 class FlowerClient(NumPyClient):
-    def get_parameters(self, config):
-        return [np.ones((1, 1))]
 
     def fit(self, parameters, config):
-        return ([np.ones((1, 1))], 1, {})
+        model = get_dummy_model()
+        return [model], 1, {}
 
     def evaluate(self, parameters, config):
         return float(0.0), 1, {"accuracy": float(1.0)}
 
 
-def client_fn(cid: str):
+def client_fn(context: Context):
     return FlowerClient().to_client()
 
 

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

@@ -1,43 +1,52 @@
-"""$project_name: A Flower / PyTorch app."""
-
-from flwr.client import NumPyClient, ClientApp
-
-from $project_name.task import (
-    Net,
-    DEVICE,
-    load_data,
-    get_weights,
-    set_weights,
-    train,
-    test,
-)
+"""$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):
+    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)
-        results = train(self.net, self.trainloader, self.valloader, 1, DEVICE)
-        return get_weights(self.net), len(self.trainloader.dataset), results
+        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)
+        loss, accuracy = test(self.net, self.valloader, self.device)
         return loss, len(self.valloader.dataset), {"accuracy": accuracy}
 
 
-def client_fn(cid):
+def client_fn(context: Context):
     # Load model and data
-    net = Net().to(DEVICE)
-    trainloader, valloader = load_data(int(cid), 2)
+    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).to_client()
+    return FlowerClient(net, trainloader, valloader, local_epochs).to_client()
 
 
 # Flower ClientApp

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

@@ -0,0 +1,63 @@
+"""$project_name: A Flower / $framework_str app."""
+
+import warnings
+
+from sklearn.metrics import log_loss
+
+from flwr.client import ClientApp, NumPyClient
+from flwr.common import Context
+from $import_name.task import (
+    get_model,
+    get_model_params,
+    load_data,
+    set_initial_params,
+    set_model_params,
+)
+
+
+class FlowerClient(NumPyClient):
+    def __init__(self, model, X_train, X_test, y_train, y_test):
+        self.model = model
+        self.X_train = X_train
+        self.X_test = X_test
+        self.y_train = y_train
+        self.y_test = y_test
+
+    def fit(self, parameters, config):
+        set_model_params(self.model, parameters)
+
+        # Ignore convergence failure due to low local epochs
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            self.model.fit(self.X_train, self.y_train)
+
+        return get_model_params(self.model), len(self.X_train), {}
+
+    def evaluate(self, parameters, config):
+        set_model_params(self.model, parameters)
+
+        loss = log_loss(self.y_test, self.model.predict_proba(self.X_test))
+        accuracy = self.model.score(self.X_test, self.y_test)
+
+        return loss, len(self.X_test), {"accuracy": accuracy}
+
+
+def client_fn(context: Context):
+    partition_id = context.node_config["partition-id"]
+    num_partitions = context.node_config["num-partitions"]
+
+    X_train, X_test, y_train, y_test = load_data(partition_id, num_partitions)
+
+    # 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)
+
+    return FlowerClient(model, X_train, X_test, y_train, y_test).to_client()
+
+
+# Flower ClientApp
+app = ClientApp(client_fn=client_fn)

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

@@ -1 +1,57 @@
-"""$project_name: A Flower / TensorFlow app."""
+"""$project_name: A Flower / $framework_str app."""
+
+from flwr.client import NumPyClient, ClientApp
+from flwr.common import Context
+
+from $import_name.task import load_data, load_model
+
+
+# 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)
+    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()
+
+
+# Flower ClientApp
+app = ClientApp(
+    client_fn=client_fn,
+)

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

@@ -0,0 +1,36 @@
+"""$project_name: A Flower Baseline."""
+
+from flwr_datasets import FederatedDataset
+from flwr_datasets.partitioner import IidPartitioner
+from torch.utils.data import DataLoader
+from torchvision.transforms import Compose, Normalize, ToTensor
+
+FDS = None  # Cache FederatedDataset
+
+
+def load_data(partition_id: int, num_partitions: int):
+    """Load partition CIFAR10 data."""
+    # Only initialize `FederatedDataset` once
+    global FDS  # pylint: disable=global-statement
+    if FDS is None:
+        partitioner = IidPartitioner(num_partitions=num_partitions)
+        FDS = FederatedDataset(
+            dataset="uoft-cs/cifar10",
+            partitioners={"train": partitioner},
+        )
+    partition = FDS.load_partition(partition_id)
+    # Divide data on each node: 80% train, 20% test
+    partition_train_test = partition.train_test_split(test_size=0.2, seed=42)
+    pytorch_transforms = Compose(
+        [ToTensor(), Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]
+    )
+
+    def apply_transforms(batch):
+        """Apply transforms to the partition from FederatedDataset."""
+        batch["img"] = [pytorch_transforms(img) for img in batch["img"]]
+        return batch
+
+    partition_train_test = partition_train_test.with_transform(apply_transforms)
+    trainloader = DataLoader(partition_train_test["train"], batch_size=32, shuffle=True)
+    testloader = DataLoader(partition_train_test["test"], batch_size=32)
+    return trainloader, testloader

flwr/cli/new/templates/app/code/flwr_tune/__init__.py

@@ -0,0 +1,15 @@
+# Copyright 2024 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 CLI `new` command app / code / flwr_tune templates."""

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

@@ -0,0 +1,126 @@
+"""$project_name: A Flower / FlowerTune app."""
+
+import os
+import warnings
+from typing import Dict, Tuple
+
+import torch
+from flwr.client import ClientApp, NumPyClient
+from flwr.common import Context
+from flwr.common.config import unflatten_dict
+from flwr.common.typing import NDArrays, Scalar
+from omegaconf import DictConfig
+
+from transformers import TrainingArguments
+from trl import SFTTrainer
+
+from $import_name.dataset import (
+    get_tokenizer_and_data_collator_and_propt_formatting,
+    load_data,
+    replace_keys,
+)
+from $import_name.models import (
+    cosine_annealing,
+    get_model,
+    set_parameters,
+    get_parameters,
+)
+
+# Avoid warnings
+os.environ["TOKENIZERS_PARALLELISM"] = "true"
+os.environ["RAY_DISABLE_DOCKER_CPU_WARNING"] = "1"
+warnings.filterwarnings("ignore", category=UserWarning)
+
+
+# pylint: disable=too-many-arguments
+# pylint: disable=too-many-instance-attributes
+class FlowerClient(NumPyClient):
+    """Standard Flower client for CNN training."""
+
+    def __init__(
+        self,
+        model_cfg: DictConfig,
+        train_cfg: DictConfig,
+        trainset,
+        tokenizer,
+        formatting_prompts_func,
+        data_collator,
+        num_rounds,
+    ):  # pylint: disable=too-many-arguments
+        self.device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+        self.train_cfg = train_cfg
+        self.training_argumnets = TrainingArguments(**train_cfg.training_arguments)
+        self.tokenizer = tokenizer
+        self.formatting_prompts_func = formatting_prompts_func
+        self.data_collator = data_collator
+        self.num_rounds = num_rounds
+        self.trainset = trainset
+
+        # instantiate model
+        self.model = get_model(model_cfg)
+
+    def fit(
+        self, parameters: NDArrays, config: Dict[str, Scalar]
+    ) -> Tuple[NDArrays, int, Dict]:
+        """Implement distributed fit function for a given client."""
+        set_parameters(self.model, parameters)
+
+        new_lr = cosine_annealing(
+            int(config["current_round"]),
+            self.num_rounds,
+            self.train_cfg.learning_rate_max,
+            self.train_cfg.learning_rate_min,
+        )
+
+        self.training_argumnets.learning_rate = new_lr
+        self.training_argumnets.output_dir = config["save_path"]
+
+        # Construct trainer
+        trainer = SFTTrainer(
+            model=self.model,
+            tokenizer=self.tokenizer,
+            args=self.training_argumnets,
+            max_seq_length=self.train_cfg.seq_length,
+            train_dataset=self.trainset,
+            formatting_func=self.formatting_prompts_func,
+            data_collator=self.data_collator,
+        )
+
+        # Do local training
+        results = trainer.train()
+
+        return (
+            get_parameters(self.model),
+            len(self.trainset),
+            {"train_loss": results.training_loss},
+        )
+
+
+def client_fn(context: Context) -> FlowerClient:
+    """Create a Flower client representing a single organization."""
+    partition_id = context.node_config["partition-id"]
+    num_partitions = context.node_config["num-partitions"]
+    num_rounds = context.run_config["num-server-rounds"]
+    cfg = DictConfig(replace_keys(unflatten_dict(context.run_config)))
+
+    # Let's get the client partition
+    client_trainset = load_data(partition_id, num_partitions, cfg.static.dataset.name)
+    (
+        tokenizer,
+        data_collator,
+        formatting_prompts_func,
+    ) = get_tokenizer_and_data_collator_and_propt_formatting(cfg.model.name)
+
+    return FlowerClient(
+        cfg.model,
+        cfg.train,
+        client_trainset,
+        tokenizer,
+        formatting_prompts_func,
+        data_collator,
+        num_rounds,
+    ).to_client()
+
+
+# Flower ClientApp
+app = ClientApp(client_fn)