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

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,99 +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)
-    net.eval()
-    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)

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

@@ -1,67 +0,0 @@
-"""$project_name: A Flower / $framework_str app."""
-
-import numpy as np
-from flwr_datasets import FederatedDataset
-from flwr_datasets.partitioner import IidPartitioner
-from sklearn.linear_model import LogisticRegression
-
-fds = None  # Cache FederatedDataset
-
-
-def load_data(partition_id: int, num_partitions: int):
-    """Load partition MNIST data."""
-    # Only initialize `FederatedDataset` once
-    global fds
-    if fds is None:
-        partitioner = IidPartitioner(num_partitions=num_partitions)
-        fds = FederatedDataset(
-            dataset="ylecun/mnist",
-            partitioners={"train": partitioner},
-        )
-
-    dataset = fds.load_partition(partition_id, "train").with_format("numpy")
-
-    X, y = dataset["image"].reshape((len(dataset), -1)), dataset["label"]
-
-    # Split the on edge data: 80% train, 20% test
-    X_train, X_test = X[: int(0.8 * len(X))], X[int(0.8 * len(X)) :]
-    y_train, y_test = y[: int(0.8 * len(y))], y[int(0.8 * len(y)) :]
-
-    return X_train, X_test, y_train, y_test
-
-
-def get_model(penalty: str, local_epochs: int):
-
-    return LogisticRegression(
-        penalty=penalty,
-        max_iter=local_epochs,
-        warm_start=True,
-    )
-
-
-def get_model_params(model):
-    if model.fit_intercept:
-        params = [
-            model.coef_,
-            model.intercept_,
-        ]
-    else:
-        params = [model.coef_]
-    return params
-
-
-def set_model_params(model, params):
-    model.coef_ = params[0]
-    if model.fit_intercept:
-        model.intercept_ = params[1]
-    return model
-
-
-def set_initial_params(model):
-    n_classes = 10  # MNIST has 10 classes
-    n_features = 784  # Number of features in dataset
-    model.classes_ = np.array([i for i in range(10)])
-
-    model.coef_ = np.zeros((n_classes, n_features))
-    if model.fit_intercept:
-        model.intercept_ = np.zeros((n_classes,))

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

@@ -1,52 +0,0 @@
-"""$project_name: A Flower / $framework_str app."""
-
-import os
-
-import keras
-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"
-
-
-def load_model():
-    # Define a simple CNN for CIFAR-10 and set Adam optimizer
-    model = keras.Sequential(
-        [
-            keras.Input(shape=(32, 32, 3)),
-            layers.Conv2D(32, kernel_size=(3, 3), activation="relu"),
-            layers.MaxPooling2D(pool_size=(2, 2)),
-            layers.Conv2D(64, kernel_size=(3, 3), activation="relu"),
-            layers.MaxPooling2D(pool_size=(2, 2)),
-            layers.Flatten(),
-            layers.Dropout(0.5),
-            layers.Dense(10, activation="softmax"),
-        ]
-    )
-    model.compile("adam", "sparse_categorical_crossentropy", metrics=["accuracy"])
-    return model
-
-
-fds = None  # Cache FederatedDataset
-
-
-def load_data(partition_id, num_partitions):
-    # Download and partition dataset
-    # 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, "train")
-    partition.set_format("numpy")
-
-    # Divide data on each node: 80% train, 20% test
-    partition = partition.train_test_split(test_size=0.2)
-    x_train, y_train = partition["train"]["img"] / 255.0, partition["train"]["label"]
-    x_test, y_test = partition["test"]["img"] / 255.0, partition["test"]["label"]
-    return x_train, y_train, x_test, y_test

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

@@ -1,67 +0,0 @@
-"""$project_name: A Flower / $framework_str app."""
-
-import xgboost as xgb
-from flwr_datasets import FederatedDataset
-from flwr_datasets.partitioner import IidPartitioner
-
-
-def train_test_split(partition, test_fraction, seed):
-    """Split the data into train and validation set given split rate."""
-    train_test = partition.train_test_split(test_size=test_fraction, seed=seed)
-    partition_train = train_test["train"]
-    partition_test = train_test["test"]
-
-    num_train = len(partition_train)
-    num_test = len(partition_test)
-
-    return partition_train, partition_test, num_train, num_test
-
-
-def transform_dataset_to_dmatrix(data):
-    """Transform dataset to DMatrix format for xgboost."""
-    x = data["inputs"]
-    y = data["label"]
-    new_data = xgb.DMatrix(x, label=y)
-    return new_data
-
-
-fds = None  # Cache FederatedDataset
-
-
-def load_data(partition_id, num_clients):
-    """Load partition HIGGS data."""
-    # Only initialize `FederatedDataset` once
-    global fds
-    if fds is None:
-        partitioner = IidPartitioner(num_partitions=num_clients)
-        fds = FederatedDataset(
-            dataset="jxie/higgs",
-            partitioners={"train": partitioner},
-        )
-
-    # Load the partition for this `partition_id`
-    partition = fds.load_partition(partition_id, split="train")
-    partition.set_format("numpy")
-
-    # Train/test splitting
-    train_data, valid_data, num_train, num_val = train_test_split(
-        partition, test_fraction=0.2, seed=42
-    )
-
-    # Reformat data to DMatrix for xgboost
-    train_dmatrix = transform_dataset_to_dmatrix(train_data)
-    valid_dmatrix = transform_dataset_to_dmatrix(valid_data)
-
-    return train_dmatrix, valid_dmatrix, num_train, num_val
-
-
-def replace_keys(input_dict, match="-", target="_"):
-    """Recursively replace match string with target string in dictionary keys."""
-    new_dict = {}
-    for key, value in input_dict.items():
-        new_key = key.replace(match, target)
-        if isinstance(value, dict):
-            new_dict[new_key] = replace_keys(value, match, target)
-        else:
-            new_dict[new_key] = value
-    return new_dict

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

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

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

@@ -1,146 +0,0 @@
-# =====================================================================
-# For a full TOML configuration guide, check the Flower docs:
-# https://flower.ai/docs/framework/how-to-configure-pyproject-toml.html
-# =====================================================================
-
-[build-system]
-requires = ["hatchling"]
-build-backend = "hatchling.build"
-
-[project]
-name = "$package_name"
-version = "1.0.0"
-description = ""
-license = "Apache-2.0"
-# Dependencies for your Flower App
-dependencies = [
-    "flwr[simulation]>=1.24.0",
-    "flwr-datasets[vision]>=0.5.0",
-    "torch==2.8.0",
-    "torchvision==0.23.0",
-]
-
-[tool.hatch.metadata]
-allow-direct-references = true
-
-[project.optional-dependencies]
-dev = [
-    "isort==5.13.2",
-    "black==24.2.0",
-    "docformatter==1.7.5",
-    "mypy==1.8.0",
-    "pylint==3.3.1",
-    "pytest==7.4.4",
-    "pytest-watch==4.2.0",
-    "ruff==0.4.5",
-    "types-requests==2.31.0.20240125",
-]
-
-[tool.isort]
-profile = "black"
-
-[tool.black]
-line-length = 88
-target-version = ["py310", "py311", "py312"]
-
-[tool.pytest.ini_options]
-minversion = "6.2"
-addopts = "-qq"
-
-[tool.mypy]
-ignore_missing_imports = true
-strict = false
-plugins = "numpy.typing.mypy_plugin"
-
-[tool.pylint."MESSAGES CONTROL"]
-disable = "duplicate-code,too-few-public-methods,useless-import-alias"
-good-names = "i,j,k,_,x,y,X,Y,K,N"
-max-args = 10
-max-attributes = 15
-max-locals = 36
-max-branches = 20
-max-statements = 55
-
-[tool.pylint.typecheck]
-generated-members = "numpy.*, torch.*, tensorflow.*"
-
-[[tool.mypy.overrides]]
-module = [
-    "importlib.metadata.*",
-    "importlib_metadata.*",
-]
-follow_imports = "skip"
-follow_imports_for_stubs = true
-disallow_untyped_calls = false
-
-[[tool.mypy.overrides]]
-module = "torch.*"
-follow_imports = "skip"
-follow_imports_for_stubs = true
-
-[tool.docformatter]
-wrap-summaries = 88
-wrap-descriptions = 88
-
-[tool.ruff]
-target-version = "py310"
-line-length = 88
-exclude = [
-    ".bzr",
-    ".direnv",
-    ".eggs",
-    ".git",
-    ".hg",
-    ".mypy_cache",
-    ".nox",
-    ".pants.d",
-    ".pytype",
-    ".ruff_cache",
-    ".svn",
-    ".tox",
-    ".venv",
-    "__pypackages__",
-    "_build",
-    "buck-out",
-    "build",
-    "dist",
-    "node_modules",
-    "venv",
-    "proto",
-]
-
-[tool.ruff.lint]
-select = ["D", "E", "F", "W", "B", "ISC", "C4", "UP"]
-fixable = ["D", "E", "F", "W", "B", "ISC", "C4", "UP"]
-ignore = ["B024", "B027", "D205", "D209"]
-
-[tool.ruff.lint.pydocstyle]
-convention = "numpy"
-
-[tool.hatch.build.targets.wheel]
-packages = ["."]
-
-[tool.flwr.app]
-publisher = "$username"
-
-# Point to your ServerApp and ClientApp objects
-# Format: "<module>:<object>"
-[tool.flwr.app.components]
-serverapp = "$import_name.server_app:app"
-clientapp = "$import_name.client_app:app"
-
-# Custom config values accessible via `context.run_config`
-[tool.flwr.app.config]
-num-server-rounds = 3
-fraction-train = 0.5
-local-epochs = 1
-
-# Default federation to use when running the app
-[tool.flwr.federations]
-default = "local-simulation"
-
-# Local simulation federation with 10 virtual SuperNodes
-[tool.flwr.federations.local-simulation]
-options.num-supernodes = 10
-options.backend.client-resources.num-cpus = 2
-options.backend.client-resources.num-gpus = 0.0