flwr 1.21.0__py3-none-any.whl → 1.22.0__py3-none-any.whl

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

@@ -1,31 +1,41 @@
 """$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 MLP, get_params
+from flwr.app import ArrayRecord, Context
+from flwr.serverapp import Grid, ServerApp
+from flwr.serverapp.strategy import FedAvg
 
+from $import_name.task import MLP, get_params, set_params
 
-def server_fn(context: Context):
+# Create ServerApp
+app = ServerApp()
+
+
+@app.main()
+def main(grid: Grid, context: Context) -> None:
+    """Main entry point for the ServerApp."""
     # Read from config
     num_rounds = context.run_config["num-server-rounds"]
-
-    num_classes = 10
     num_layers = context.run_config["num-layers"]
     input_dim = context.run_config["input-dim"]
     hidden_dim = context.run_config["hidden-dim"]
 
     # Initialize global model
-    model = MLP(num_layers, input_dim, hidden_dim, num_classes)
+    model = MLP(num_layers, input_dim, hidden_dim, output_dim=10)
     params = get_params(model)
-    initial_parameters = ndarrays_to_parameters(params)
-
-    # Define strategy
-    strategy = FedAvg(initial_parameters=initial_parameters)
-    config = ServerConfig(num_rounds=num_rounds)
-
-    return ServerAppComponents(strategy=strategy, config=config)
-
-
-# Create ServerApp
-app = ServerApp(server_fn=server_fn)
+    arrays = ArrayRecord(params)
+
+    # Initialize FedAvg strategy
+    strategy = FedAvg()
+
+    # 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()
+    set_params(model, ndarrays)
+    model.save_weights("final_model.npz")

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

@@ -1,25 +1,38 @@
 """$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 get_dummy_model
-
+import numpy as np
+from flwr.app import ArrayRecord, Context
+from flwr.serverapp import Grid, ServerApp
+from flwr.serverapp.strategy import FedAvg
 
-def server_fn(context: Context):
-    # Read from config
-    num_rounds = context.run_config["num-server-rounds"]
+from $import_name.task import get_dummy_model
 
-    # Initial model
-    model = get_dummy_model()
-    dummy_parameters = ndarrays_to_parameters([model])
+# Create ServerApp
+app = ServerApp()
 
-    # Define strategy
-    strategy = FedAvg(initial_parameters=dummy_parameters)
-    config = ServerConfig(num_rounds=num_rounds)
 
-    return ServerAppComponents(strategy=strategy, config=config)
+@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 ServerApp
-app = ServerApp(server_fn=server_fn)
+    # Load global model
+    model = get_dummy_model()
+    arrays = ArrayRecord(model)
+
+    # Initialize FedAvg strategy
+    strategy = FedAvg()
+
+    # 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()
+    np.savez("final_model", *ndarrays)

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

@@ -1,31 +1,41 @@
 """$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)
+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(server_fn=server_fn)
+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

@@ -0,0 +1,31 @@
+"""$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,36 +1,44 @@
 """$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 get_model, get_model_params, set_initial_params
+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
 
-def server_fn(context: Context):
-    # Read from config
-    num_rounds = context.run_config["num-server-rounds"]
+# 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))
 
-    initial_parameters = ndarrays_to_parameters(get_model_params(model))
+    # Initialize FedAvg strategy
+    strategy = FedAvg(fraction_train=1.0, fraction_evaluate=1.0)
 
-    # Define strategy
-    strategy = FedAvg(
-        fraction_fit=1.0,
-        fraction_evaluate=1.0,
-        min_available_clients=2,
-        initial_parameters=initial_parameters,
+    # Start strategy, run FedAvg for `num_rounds`
+    result = strategy.start(
+        grid=grid,
+        initial_arrays=arrays,
+        num_rounds=num_rounds,
     )
-    config = ServerConfig(num_rounds=num_rounds)
-
-    return ServerAppComponents(strategy=strategy, config=config)
 
-
-# Create ServerApp
-app = ServerApp(server_fn=server_fn)
+    # 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,29 +1,38 @@
 """$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 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()
 
-def server_fn(context: Context):
-    # Read from config
-    num_rounds = context.run_config["num-server-rounds"]
 
-    # Get parameters to initialize global model
-    parameters = ndarrays_to_parameters(load_model().get_weights())
+@app.main()
+def main(grid: Grid, context: Context) -> None:
+    """Main entry point for the ServerApp."""
 
-    # Define strategy
-    strategy = strategy = FedAvg(
-        fraction_fit=1.0,
-        fraction_evaluate=1.0,
-        min_available_clients=2,
-        initial_parameters=parameters,
-    )
-    config = ServerConfig(num_rounds=num_rounds)
+    # Read run config
+    num_rounds: int = context.run_config["num-server-rounds"]
 
-    return ServerAppComponents(strategy=strategy, config=config)
+    # Load global model
+    model = load_model()
+    arrays = ArrayRecord(model.get_weights())
 
-# Create ServerApp
-app = ServerApp(server_fn=server_fn)
+    # 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

@@ -0,0 +1,56 @@
+"""$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/task.huggingface.py.tpl

@@ -1,7 +1,6 @@
 """$project_name: A Flower / $framework_str app."""
 
 import warnings
-from collections import OrderedDict
 
 import torch
 import transformers
@@ -62,17 +61,24 @@ def load_data(partition_id: int, num_partitions: int, model_name: str):
     return trainloader, testloader
 
 
-def train(net, trainloader, epochs, device):
+def train(net, trainloader, num_steps, device):
     optimizer = AdamW(net.parameters(), lr=5e-5)
     net.train()
-    for _ in range(epochs):
-        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 = 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):
@@ -90,13 +96,3 @@ def test(net, testloader, device):
     loss /= len(testloader.dataset)
     accuracy = metric.compute()["accuracy"]
     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.jax.py.tpl

@@ -31,7 +31,7 @@ def loss_fn(params, X, y):
 def train(params, grad_fn, X, y):
     loss = 1_000_000
     num_examples = X.shape[0]
-    for epochs in range(50):
+    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)

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

@@ -4,4 +4,4 @@ import numpy as np
 
 
 def get_dummy_model():
-    return np.ones((1, 1))
+    return [np.ones((1, 1))]

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

@@ -1,7 +1,5 @@
 """$project_name: A Flower / $framework_str app."""
 
-from collections import OrderedDict
-
 import torch
 import torch.nn as nn
 import torch.nn.functional as F
@@ -34,6 +32,14 @@ class Net(nn.Module):
 
 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."""
@@ -48,38 +54,29 @@ def load_data(partition_id: int, num_partitions: int):
     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
-
+    # 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, device):
+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=0.01)
+    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"]
-            labels = batch["label"]
+            images = batch["img"].to(device)
+            labels = batch["label"].to(device)
             optimizer.zero_grad()
-            loss = criterion(net(images.to(device)), labels.to(device))
+            loss = criterion(net(images), labels)
             loss.backward()
             optimizer.step()
             running_loss += loss.item()
-
     avg_trainloss = running_loss / len(trainloader)
     return avg_trainloss
 
@@ -99,13 +96,3 @@ def test(net, testloader, device):
     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.pytorch_msg_api.py.tpl → task.pytorch_legacy_api.py.tpl}

@@ -1,5 +1,7 @@
 """$project_name: A Flower / $framework_str app."""
 
+from collections import OrderedDict
+
 import torch
 import torch.nn as nn
 import torch.nn.functional as F
@@ -32,14 +34,6 @@ class Net(nn.Module):
 
 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."""
@@ -54,29 +48,38 @@ def load_data(partition_id: int, num_partitions: int):
     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
+    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, lr, device):
+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=lr)
+    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"].to(device)
-            labels = batch["label"].to(device)
+            images = batch["img"]
+            labels = batch["label"]
             optimizer.zero_grad()
-            loss = criterion(net(images), labels)
+            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
 
@@ -96,3 +99,13 @@ def test(net, testloader, device):
     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.tensorflow.py.tpl

@@ -3,10 +3,9 @@
 import os
 
 import keras
-from keras import layers
 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"