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

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

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

@@ -1,31 +0,0 @@
-"""$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,44 +0,0 @@
-"""$project_name: A Flower / $framework_str app."""
-
-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
-
-# 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))
-
-    # 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 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,38 +0,0 @@
-"""$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 load_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 = load_model()
-    arrays = ArrayRecord(model.get_weights())
-
-    # 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/server.xgboost.py.tpl

@@ -1,56 +0,0 @@
-"""$project_name: A Flower / $framework_str app."""
-
-import numpy as np
-import xgboost as xgb
-from flwr.app import ArrayRecord, Context
-from flwr.common.config import unflatten_dict
-from flwr.serverapp import Grid, ServerApp
-from flwr.serverapp.strategy import FedXgbBagging
-
-from $import_name.task import replace_keys
-
-# Create ServerApp
-app = ServerApp()
-
-
-@app.main()
-def main(grid: Grid, context: Context) -> None:
-    # Read run config
-    num_rounds = context.run_config["num-server-rounds"]
-    fraction_train = context.run_config["fraction-train"]
-    fraction_evaluate = context.run_config["fraction-evaluate"]
-    # Flatted config dict and replace "-" with "_"
-    cfg = replace_keys(unflatten_dict(context.run_config))
-    params = cfg["params"]
-
-    # Init global model
-    # Init with an empty object; the XGBooster will be created
-    # and trained on the client side.
-    global_model = b""
-    # Note: we store the model as the first item in a list into ArrayRecord,
-    # which can be accessed using index ["0"].
-    arrays = ArrayRecord([np.frombuffer(global_model, dtype=np.uint8)])
-
-    # Initialize FedXgbBagging strategy
-    strategy = FedXgbBagging(
-        fraction_train=fraction_train,
-        fraction_evaluate=fraction_evaluate,
-    )
-
-    # Start strategy, run FedXgbBagging for `num_rounds`
-    result = strategy.start(
-        grid=grid,
-        initial_arrays=arrays,
-        num_rounds=num_rounds,
-    )
-
-    # Save final model to disk
-    bst = xgb.Booster(params=params)
-    global_model = bytearray(result.arrays["0"].numpy().tobytes())
-
-    # Load global model into booster
-    bst.load_model(global_model)
-
-    # Save model
-    print("\nSaving final model to disk...")
-    bst.save_model("final_model.json")

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

@@ -1 +0,0 @@
-"""$project_name: A Flower Baseline."""

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

@@ -1,98 +0,0 @@
-"""$project_name: A Flower / $framework_str app."""
-
-import warnings
-
-import torch
-import transformers
-from datasets.utils.logging import disable_progress_bar
-from evaluate import load as load_metric
-from flwr_datasets import FederatedDataset
-from flwr_datasets.partitioner import IidPartitioner
-from torch.optim import AdamW
-from torch.utils.data import DataLoader
-from transformers import AutoTokenizer, DataCollatorWithPadding
-
-warnings.filterwarnings("ignore", category=UserWarning)
-warnings.filterwarnings("ignore", category=FutureWarning)
-disable_progress_bar()
-transformers.logging.set_verbosity_error()
-
-
-fds = None  # Cache FederatedDataset
-
-
-def load_data(partition_id: int, num_partitions: int, model_name: str):
-    """Load IMDB data (training and eval)"""
-    # Only initialize `FederatedDataset` once
-    global fds
-    if fds is None:
-        partitioner = IidPartitioner(num_partitions=num_partitions)
-        fds = FederatedDataset(
-            dataset="stanfordnlp/imdb",
-            partitioners={"train": partitioner},
-        )
-    partition = fds.load_partition(partition_id)
-    # Divide data: 80% train, 20% test
-    partition_train_test = partition.train_test_split(test_size=0.2, seed=42)
-
-    tokenizer = AutoTokenizer.from_pretrained(model_name)
-
-    def tokenize_function(examples):
-        return tokenizer(
-            examples["text"], truncation=True, add_special_tokens=True, max_length=512
-        )
-
-    partition_train_test = partition_train_test.map(tokenize_function, batched=True)
-    partition_train_test = partition_train_test.remove_columns("text")
-    partition_train_test = partition_train_test.rename_column("label", "labels")
-
-    data_collator = DataCollatorWithPadding(tokenizer=tokenizer)
-    trainloader = DataLoader(
-        partition_train_test["train"],
-        shuffle=True,
-        batch_size=32,
-        collate_fn=data_collator,
-    )
-
-    testloader = DataLoader(
-        partition_train_test["test"], batch_size=32, collate_fn=data_collator
-    )
-
-    return trainloader, testloader
-
-
-def train(net, trainloader, num_steps, device):
-    optimizer = AdamW(net.parameters(), lr=5e-5)
-    net.train()
-    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):
-    metric = load_metric("accuracy")
-    loss = 0
-    net.eval()
-    for batch in testloader:
-        batch = {k: v.to(device) for k, v in batch.items()}
-        with torch.no_grad():
-            outputs = net(**batch)
-        logits = outputs.logits
-        loss += outputs.loss.item()
-        predictions = torch.argmax(logits, dim=-1)
-        metric.add_batch(predictions=predictions, references=batch["labels"])
-    loss /= len(testloader.dataset)
-    accuracy = metric.compute()["accuracy"]
-    return loss, accuracy

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

@@ -1,57 +0,0 @@
-"""$project_name: A Flower / $framework_str app."""
-
-import jax
-import jax.numpy as jnp
-import numpy as np
-from sklearn.datasets import make_regression
-from sklearn.model_selection import train_test_split
-
-key = jax.random.PRNGKey(0)
-
-
-def load_data():
-    # Load dataset
-    X, y = make_regression(n_features=3, random_state=0)
-    X, X_test, y, y_test = train_test_split(X, y)
-    return X, y, X_test, y_test
-
-
-def load_model(model_shape):
-    # Extract model parameters
-    params = {"b": jax.random.uniform(key), "w": jax.random.uniform(key, model_shape)}
-    return params
-
-
-def loss_fn(params, X, y):
-    # Return MSE as loss
-    err = jnp.dot(X, params["w"]) + params["b"] - y
-    return jnp.mean(jnp.square(err))
-
-
-def train(params, grad_fn, X, y):
-    loss = 1_000_000
-    num_examples = X.shape[0]
-    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)
-    return params, loss, num_examples
-
-
-def evaluation(params, grad_fn, X_test, y_test):
-    num_examples = X_test.shape[0]
-    err_test = loss_fn(params, X_test, y_test)
-    loss_test = jnp.mean(jnp.square(err_test))
-    return loss_test, num_examples
-
-
-def get_params(params):
-    parameters = []
-    for _, val in params.items():
-        parameters.append(np.array(val))
-    return parameters
-
-
-def set_params(local_params, global_params):
-    for key, value in list(zip(local_params.keys(), global_params)):
-        local_params[key] = value

flwr/cli/new/templates/app/code/task.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 numpy as np
-from flwr_datasets import FederatedDataset
-from flwr_datasets.partitioner import IidPartitioner
-
-from datasets.utils.logging import disable_progress_bar
-
-disable_progress_bar()
-
-
-class MLP(nn.Module):
-    """A simple MLP."""
-
-    def __init__(
-        self, num_layers: int, input_dim: int, hidden_dim: int, output_dim: int
-    ):
-        super().__init__()
-        layer_sizes = [input_dim] + [hidden_dim] * num_layers + [output_dim]
-        self.layers = [
-            nn.Linear(idim, odim)
-            for idim, odim in zip(layer_sizes[:-1], layer_sizes[1:])
-        ]
-
-    def __call__(self, x):
-        for l in self.layers[:-1]:
-            x = mx.maximum(l(x), 0.0)
-        return self.layers[-1](x)
-
-
-def loss_fn(model, X, y):
-    return mx.mean(nn.losses.cross_entropy(model(X), y))
-
-
-def eval_fn(model, X, y):
-    return mx.mean(mx.argmax(model(X), axis=1) == y)
-
-
-def batch_iterate(batch_size, X, y):
-    perm = mx.array(np.random.permutation(y.size))
-    for s in range(0, y.size, batch_size):
-        ids = perm[s : s + batch_size]
-        yield X[ids], y[ids]
-
-
-fds = None  # Cache FederatedDataset
-
-
-def load_data(partition_id: int, num_partitions: int):
-    # Only initialize `FederatedDataset` once
-    global fds
-    if fds is None:
-        partitioner = IidPartitioner(num_partitions=num_partitions)
-        fds = FederatedDataset(
-            dataset="ylecun/mnist",
-            partitioners={"train": partitioner},
-            trust_remote_code=True,
-        )
-    partition = fds.load_partition(partition_id)
-    partition_splits = partition.train_test_split(test_size=0.2, seed=42)
-
-    partition_splits["train"].set_format("numpy")
-    partition_splits["test"].set_format("numpy")
-
-    train_partition = partition_splits["train"].map(
-        lambda img: {
-            "img": img.reshape(-1, 28 * 28).squeeze().astype(np.float32) / 255.0
-        },
-        input_columns="image",
-    )
-    test_partition = partition_splits["test"].map(
-        lambda img: {
-            "img": img.reshape(-1, 28 * 28).squeeze().astype(np.float32) / 255.0
-        },
-        input_columns="image",
-    )
-
-    data = (
-        train_partition["img"],
-        train_partition["label"].astype(np.uint32),
-        test_partition["img"],
-        test_partition["label"].astype(np.uint32),
-    )
-
-    train_images, train_labels, test_images, test_labels = map(mx.array, data)
-    return train_images, train_labels, test_images, test_labels
-
-
-def get_params(model):
-    layers = model.parameters()["layers"]
-    return [np.array(val) for layer in layers for _, val in layer.items()]
-
-
-def set_params(model, parameters):
-    new_params = {}
-    new_params["layers"] = [
-        {"weight": mx.array(parameters[i]), "bias": mx.array(parameters[i + 1])}
-        for i in range(0, len(parameters), 2)
-    ]
-    model.update(new_params)

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

@@ -1,7 +0,0 @@
-"""$project_name: A Flower / $framework_str app."""
-
-import numpy as np
-
-
-def get_dummy_model():
-    return [np.ones((1, 1))]

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

@@ -1,98 +0,0 @@
-"""$project_name: A Flower / $framework_str app."""
-
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-from flwr_datasets import FederatedDataset
-from flwr_datasets.partitioner import IidPartitioner
-from torch.utils.data import DataLoader
-from torchvision.transforms import Compose, Normalize, ToTensor
-
-
-class Net(nn.Module):
-    """Model (simple CNN adapted from 'PyTorch: A 60 Minute Blitz')"""
-
-    def __init__(self):
-        super(Net, self).__init__()
-        self.conv1 = nn.Conv2d(3, 6, 5)
-        self.pool = nn.MaxPool2d(2, 2)
-        self.conv2 = nn.Conv2d(6, 16, 5)
-        self.fc1 = nn.Linear(16 * 5 * 5, 120)
-        self.fc2 = nn.Linear(120, 84)
-        self.fc3 = nn.Linear(84, 10)
-
-    def forward(self, x):
-        x = self.pool(F.relu(self.conv1(x)))
-        x = self.pool(F.relu(self.conv2(x)))
-        x = x.view(-1, 16 * 5 * 5)
-        x = F.relu(self.fc1(x))
-        x = F.relu(self.fc2(x))
-        return self.fc3(x)
-
-
-fds = None  # Cache FederatedDataset
-
-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
-
-
-def load_data(partition_id: int, num_partitions: int):
-    """Load partition CIFAR10 data."""
-    # Only initialize `FederatedDataset` once
-    global fds
-    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)
-    # Construct dataloaders
-    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
-
-
-def train(net, trainloader, epochs, lr, device):
-    """Train the model on the training set."""
-    net.to(device)  # move model to GPU if available
-    criterion = torch.nn.CrossEntropyLoss().to(device)
-    optimizer = torch.optim.Adam(net.parameters(), lr=lr)
-    net.train()
-    running_loss = 0.0
-    for _ in range(epochs):
-        for batch in trainloader:
-            images = batch["img"].to(device)
-            labels = batch["label"].to(device)
-            optimizer.zero_grad()
-            loss = criterion(net(images), labels)
-            loss.backward()
-            optimizer.step()
-            running_loss += loss.item()
-    avg_trainloss = running_loss / len(trainloader)
-    return avg_trainloss
-
-
-def test(net, testloader, device):
-    """Validate the model on the test set."""
-    net.to(device)
-    criterion = torch.nn.CrossEntropyLoss()
-    correct, loss = 0, 0.0
-    with torch.no_grad():
-        for batch in testloader:
-            images = batch["img"].to(device)
-            labels = batch["label"].to(device)
-            outputs = net(images)
-            loss += criterion(outputs, labels).item()
-            correct += (torch.max(outputs.data, 1)[1] == labels).sum().item()
-    accuracy = correct / len(testloader.dataset)
-    loss = loss / len(testloader)
-    return loss, accuracy

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

@@ -1,111 +0,0 @@
-"""$project_name: A Flower / $framework_str app."""
-
-from collections import OrderedDict
-
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-from flwr_datasets import FederatedDataset
-from flwr_datasets.partitioner import IidPartitioner
-from torch.utils.data import DataLoader
-from torchvision.transforms import Compose, Normalize, ToTensor
-
-
-class Net(nn.Module):
-    """Model (simple CNN adapted from 'PyTorch: A 60 Minute Blitz')"""
-
-    def __init__(self):
-        super(Net, self).__init__()
-        self.conv1 = nn.Conv2d(3, 6, 5)
-        self.pool = nn.MaxPool2d(2, 2)
-        self.conv2 = nn.Conv2d(6, 16, 5)
-        self.fc1 = nn.Linear(16 * 5 * 5, 120)
-        self.fc2 = nn.Linear(120, 84)
-        self.fc3 = nn.Linear(84, 10)
-
-    def forward(self, x):
-        x = self.pool(F.relu(self.conv1(x)))
-        x = self.pool(F.relu(self.conv2(x)))
-        x = x.view(-1, 16 * 5 * 5)
-        x = F.relu(self.fc1(x))
-        x = F.relu(self.fc2(x))
-        return self.fc3(x)
-
-
-fds = None  # Cache FederatedDataset
-
-
-def load_data(partition_id: int, num_partitions: int):
-    """Load partition CIFAR10 data."""
-    # Only initialize `FederatedDataset` once
-    global fds
-    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
-
-
-def train(net, trainloader, epochs, device):
-    """Train the model on the training set."""
-    net.to(device)  # move model to GPU if available
-    criterion = torch.nn.CrossEntropyLoss().to(device)
-    optimizer = torch.optim.Adam(net.parameters(), lr=0.01)
-    net.train()
-    running_loss = 0.0
-    for _ in range(epochs):
-        for batch in trainloader:
-            images = batch["img"]
-            labels = batch["label"]
-            optimizer.zero_grad()
-            loss = criterion(net(images.to(device)), labels.to(device))
-            loss.backward()
-            optimizer.step()
-            running_loss += loss.item()
-
-    avg_trainloss = running_loss / len(trainloader)
-    return avg_trainloss
-
-
-def test(net, testloader, device):
-    """Validate the model on the test set."""
-    net.to(device)
-    criterion = torch.nn.CrossEntropyLoss()
-    correct, loss = 0, 0.0
-    with torch.no_grad():
-        for batch in testloader:
-            images = batch["img"].to(device)
-            labels = batch["label"].to(device)
-            outputs = net(images)
-            loss += criterion(outputs, labels).item()
-            correct += (torch.max(outputs.data, 1)[1] == labels).sum().item()
-    accuracy = correct / len(testloader.dataset)
-    loss = loss / len(testloader)
-    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)