flwr-nightly 1.9.0.dev20240417__py3-none-any.whl → 1.9.0.dev20240507__py3-none-any.whl

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

@@ -0,0 +1,94 @@
+"""$project_name: A Flower / Scikit-Learn app."""
+
+import warnings
+
+import numpy as np
+from flwr.client import NumPyClient, ClientApp
+from flwr_datasets import FederatedDataset
+from sklearn.linear_model import LogisticRegression
+from sklearn.metrics import log_loss
+
+
+def get_model_parameters(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,))
+
+
+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 get_parameters(self, config):
+        return get_model_parameters(self.model)
+
+    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_parameters(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}
+
+fds = FederatedDataset(dataset="mnist", partitioners={"train": 2})
+
+def client_fn(cid: str):
+    dataset = fds.load_partition(int(cid), "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)) :]
+
+    # Create LogisticRegression Model
+    model = LogisticRegression(
+        penalty="l2",
+        max_iter=1,  # local epoch
+        warm_start=True,  # prevent refreshing weights when fitting
+    )
+
+    # 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,43 @@
 """$project_name: A Flower / TensorFlow app."""
+
+from flwr.client import NumPyClient, ClientApp
+
+from $import_name.task import load_data, load_model
+
+
+# Define Flower Client and client_fn
+class FlowerClient(NumPyClient):
+    def __init__(self, model, x_train, y_train, x_test, y_test):
+        self.model = model
+        self.x_train = x_train
+        self.y_train = y_train
+        self.x_test = x_test
+        self.y_test = y_test
+
+    def get_parameters(self, config):
+        return self.model.get_weights()
+
+    def fit(self, parameters, config):
+        self.model.set_weights(parameters)
+        self.model.fit(self.x_train, self.y_train, epochs=1, batch_size=32, verbose=0)
+        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(cid):
+    # Load model and data
+    net = load_model()
+    x_train, y_train, x_test, y_test = load_data(int(cid), 2)
+
+    # Return Client instance
+    return FlowerClient(net, x_train, y_train, x_test, y_test).to_client()
+
+
+# Flower ClientApp
+app = ClientApp(
+    client_fn=client_fn,
+)

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

@@ -0,0 +1,15 @@
+"""$project_name: A Flower / MLX app."""
+
+from flwr.server import ServerApp, ServerConfig
+from flwr.server.strategy import FedAvg
+
+
+# Define strategy
+strategy = FedAvg()
+
+
+# Create ServerApp
+app = ServerApp(
+    config=ServerConfig(num_rounds=3),
+    strategy=strategy,
+)

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

@@ -4,7 +4,7 @@ from flwr.common import ndarrays_to_parameters
 from flwr.server import ServerApp, ServerConfig
 from flwr.server.strategy import FedAvg
 
-from $project_name.task import Net, get_weights
+from $import_name.task import Net, get_weights
 
 
 # Initialize model parameters

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

@@ -0,0 +1,17 @@
+"""$project_name: A Flower / Scikit-Learn app."""
+
+from flwr.server import ServerApp, ServerConfig
+from flwr.server.strategy import FedAvg
+
+
+strategy = FedAvg(
+    fraction_fit=1.0,
+    fraction_evaluate=1.0,
+    min_available_clients=2,
+)
+
+# Create ServerApp
+app = ServerApp(
+    config=ServerConfig(num_rounds=3),
+    strategy=strategy,
+)

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

@@ -1 +1,27 @@
 """$project_name: A Flower / TensorFlow app."""
+
+from flwr.common import ndarrays_to_parameters
+from flwr.server import ServerApp, ServerConfig
+from flwr.server.strategy import FedAvg
+
+from $import_name.task import load_model
+
+# Define config
+config = ServerConfig(num_rounds=3)
+
+parameters = ndarrays_to_parameters(load_model().get_weights())
+
+# Define strategy
+strategy = FedAvg(
+    fraction_fit=1.0,
+    fraction_evaluate=1.0,
+    min_available_clients=2,
+    initial_parameters=parameters,
+)
+
+
+# Create ServerApp
+app = ServerApp(
+    config=config,
+    strategy=strategy,
+)

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

@@ -0,0 +1,89 @@
+"""$project_name: A Flower / MLX app."""
+
+import mlx.core as mx
+import mlx.nn as nn
+import numpy as np
+from datasets.utils.logging import disable_progress_bar
+from flwr_datasets import FederatedDataset
+
+
+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]
+
+
+def load_data(partition_id, num_clients):
+    fds = FederatedDataset(dataset="mnist", partitioners={"train": num_clients})
+    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.tensorflow.py.tpl

@@ -0,0 +1,29 @@
+"""$project_name: A Flower / TensorFlow app."""
+
+import os
+
+import tensorflow as tf
+from flwr_datasets import FederatedDataset
+
+
+# Make TensorFlow log less verbose
+os.environ["TF_CPP_MIN_LOG_LEVEL"] = "3"
+
+def load_model():
+    # Load model and data (MobileNetV2, CIFAR-10)
+    model = tf.keras.applications.MobileNetV2((32, 32, 3), classes=10, weights=None)
+    model.compile("adam", "sparse_categorical_crossentropy", metrics=["accuracy"])
+    return model
+
+
+def load_data(partition_id, num_partitions):
+    # Download and partition dataset
+    fds = FederatedDataset(dataset="cifar10", partitioners={"train": num_partitions})
+    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/pyproject.mlx.toml.tpl

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "$package_name"
+version = "1.0.0"
+description = ""
+authors = [
+    { name = "The Flower Authors", email = "hello@flower.ai" },
+]
+license = { text = "Apache License (2.0)" }
+dependencies = [
+    "flwr[simulation]>=1.8.0,<2.0",
+    "flwr-datasets[vision]>=0.0.2,<1.0.0",
+    "mlx==0.10.0",
+    "numpy==1.24.4",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["."]
+
+[flower]
+publisher = "$username"
+
+[flower.components]
+serverapp = "$import_name.server:app"
+clientapp = "$import_name.client:app"

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

@@ -3,13 +3,13 @@ requires = ["hatchling"]
 build-backend = "hatchling.build"
 
 [project]
-name = "$project_name"
+name = "$package_name"
 version = "1.0.0"
 description = ""
 authors = [
     { name = "The Flower Authors", email = "hello@flower.ai" },
 ]
-license = {text = "Apache License (2.0)"}
+license = { text = "Apache License (2.0)" }
 dependencies = [
     "flwr[simulation]>=1.8.0,<2.0",
     "numpy>=1.21.0",
@@ -18,6 +18,9 @@ dependencies = [
 [tool.hatch.build.targets.wheel]
 packages = ["."]
 
+[flower]
+publisher = "$username"
+
 [flower.components]
-serverapp = "$project_name.server:app"
-clientapp = "$project_name.client:app"
+serverapp = "$import_name.server:app"
+clientapp = "$import_name.client:app"

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

@@ -3,13 +3,13 @@ requires = ["hatchling"]
 build-backend = "hatchling.build"
 
 [project]
-name = "$project_name"
+name = "$package_name"
 version = "1.0.0"
 description = ""
 authors = [
     { name = "The Flower Authors", email = "hello@flower.ai" },
 ]
-license = {text = "Apache License (2.0)"}
+license = { text = "Apache License (2.0)" }
 dependencies = [
     "flwr[simulation]>=1.8.0,<2.0",
     "flwr-datasets[vision]>=0.0.2,<1.0.0",
@@ -20,6 +20,9 @@ dependencies = [
 [tool.hatch.build.targets.wheel]
 packages = ["."]
 
+[flower]
+publisher = "$username"
+
 [flower.components]
-serverapp = "$project_name.server:app"
-clientapp = "$project_name.client:app"
+serverapp = "$import_name.server:app"
+clientapp = "$import_name.client:app"

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

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "$package_name"
+version = "1.0.0"
+description = ""
+authors = [
+    { name = "The Flower Authors", email = "hello@flower.ai" },
+]
+license = { text = "Apache License (2.0)" }
+dependencies = [
+    "flwr[simulation]>=1.8.0,<2.0",
+    "flwr-datasets[vision]>=0.0.2,<1.0.0",
+    "scikit-learn>=1.1.1",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["."]
+
+[flower]
+publisher = "$username"
+
+[flower.components]
+serverapp = "$import_name.server:app"
+clientapp = "$import_name.client:app"

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

@@ -3,13 +3,13 @@ requires = ["hatchling"]
 build-backend = "hatchling.build"
 
 [project]
-name = "$project_name"
+name = "$package_name"
 version = "1.0.0"
 description = ""
 authors = [
     { name = "The Flower Authors", email = "hello@flower.ai" },
 ]
-license = {text = "Apache License (2.0)"}
+license = { text = "Apache License (2.0)" }
 dependencies = [
     "flwr[simulation]>=1.8.0,<2.0",
     "flwr-datasets[vision]>=0.0.2,<1.0.0",
@@ -19,6 +19,9 @@ dependencies = [
 [tool.hatch.build.targets.wheel]
 packages = ["."]
 
+[flower]
+publisher = "$username"
+
 [flower.components]
-serverapp = "$project_name.server:app"
-clientapp = "$project_name.client:app"
+serverapp = "$import_name.server:app"
+clientapp = "$import_name.client:app"

flwr/cli/run/run.py

@@ -30,7 +30,7 @@ def run() -> None:
 
     if config is None:
         typer.secho(
-            "Project configuration could not be loaded.\nflower.toml is invalid:\n"
+            "Project configuration could not be loaded.\npyproject.toml is invalid:\n"
             + "\n".join([f"- {line}" for line in errors]),
             fg=typer.colors.RED,
             bold=True,

flwr/cli/utils.py

@@ -14,6 +14,7 @@
 # ==============================================================================
 """Flower command line interface utils."""
 
+import re
 from typing import Callable, List, Optional, cast
 
 import typer
@@ -73,51 +74,51 @@ def prompt_options(text: str, options: List[str]) -> str:
 
 
 def is_valid_project_name(name: str) -> bool:
-    """Check if the given string is a valid Python module name.
+    """Check if the given string is a valid Python project name.
 
-    A valid module name must start with a letter or an underscore, and can only contain
-    letters, digits, and underscores.
+    A valid project name must start with a letter and can only contain letters, digits,
+    and hyphens.
     """
     if not name:
         return False
 
-    # Check if the first character is a letter or underscore
-    if not (name[0].isalpha() or name[0] == "_"):
+    # Check if the first character is a letter
+    if not name[0].isalpha():
         return False
 
-    # Check if the rest of the characters are valid (letter, digit, or underscore)
+    # Check if the rest of the characters are valid (letter, digit, or dash)
     for char in name[1:]:
-        if not (char.isalnum() or char == "_"):
+        if not (char.isalnum() or char in "-"):
             return False
 
     return True
 
 
 def sanitize_project_name(name: str) -> str:
-    """Sanitize the given string to make it a valid Python module name.
+    """Sanitize the given string to make it a valid Python project name.
 
-    This version replaces hyphens with underscores, removes any characters not allowed
-    in Python module names, makes the string lowercase, and ensures it starts with a
-    valid character.
+    This version replaces spaces, dots, slashes, and underscores with dashes, removes
+    any characters not allowed in Python project names, makes the string lowercase, and
+    ensures it starts with a valid character.
     """
-    # Replace '-' with '_'
-    name_with_underscores = name.replace("-", "_").replace(" ", "_")
+    # Replace whitespace with '_'
+    name_with_hyphens = re.sub(r"[ ./_]", "-", name)
 
     # Allowed characters in a module name: letters, digits, underscore
     allowed_chars = set(
-        "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_"
+        "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-"
     )
 
     # Make the string lowercase
-    sanitized_name = name_with_underscores.lower()
+    sanitized_name = name_with_hyphens.lower()
 
     # Remove any characters not allowed in Python module names
     sanitized_name = "".join(c for c in sanitized_name if c in allowed_chars)
 
     # Ensure the first character is a letter or underscore
-    if sanitized_name and (
+    while sanitized_name and (
         sanitized_name[0].isdigit() or sanitized_name[0] not in allowed_chars
     ):
-        sanitized_name = "_" + sanitized_name
+        sanitized_name = sanitized_name[1:]
 
     return sanitized_name

flwr/client/__init__.py

@@ -15,12 +15,13 @@
 """Flower client."""
 
 
-from .app import run_client_app as run_client_app
 from .app import start_client as start_client
 from .app import start_numpy_client as start_numpy_client
 from .client import Client as Client
 from .client_app import ClientApp as ClientApp
 from .numpy_client import NumPyClient as NumPyClient
+from .supernode import run_client_app as run_client_app
+from .supernode import run_supernode as run_supernode
 from .typing import ClientFn as ClientFn
 
 __all__ = [
@@ -29,6 +30,7 @@ __all__ = [
     "ClientFn",
     "NumPyClient",
     "run_client_app",
+    "run_supernode",
     "start_client",
     "start_numpy_client",
 ]