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

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

@@ -1,56 +0,0 @@
-"""$project_name: A Flower / FlowerTune app."""
-
-import math
-
-import torch
-from omegaconf import DictConfig
-from peft import LoraConfig, get_peft_model
-from peft.utils import prepare_model_for_kbit_training
-from transformers import AutoModelForCausalLM, BitsAndBytesConfig
-
-
-def cosine_annealing(
-    current_round: int,
-    total_round: int,
-    lrate_max: float = 0.001,
-    lrate_min: float = 0.0,
-) -> float:
-    """Implement cosine annealing learning rate schedule."""
-    cos_inner = math.pi * current_round / total_round
-    return lrate_min + 0.5 * (lrate_max - lrate_min) * (1 + math.cos(cos_inner))
-
-
-def get_model(model_cfg: DictConfig):
-    """Load model with appropriate quantization config and other optimizations.
-    """
-    if model_cfg.quantization == 4:
-        quantization_config = BitsAndBytesConfig(load_in_4bit=True)
-    elif model_cfg.quantization == 8:
-        quantization_config = BitsAndBytesConfig(load_in_8bit=True)
-    else:
-        raise ValueError(
-            f"Use 4-bit or 8-bit quantization. You passed: {model_cfg.quantization}/"
-        )
-
-    model = AutoModelForCausalLM.from_pretrained(
-        model_cfg.name,
-        quantization_config=quantization_config,
-        torch_dtype=torch.bfloat16,
-        low_cpu_mem_usage=True,
-    )
-
-    model = prepare_model_for_kbit_training(
-        model, use_gradient_checkpointing=model_cfg.gradient_checkpointing
-    )
-
-    peft_config = LoraConfig(
-        r=model_cfg.lora.peft_lora_r,
-        lora_alpha=model_cfg.lora.peft_lora_alpha,
-        lora_dropout=0.075,
-        task_type="CAUSAL_LM",
-    )
-
-    if model_cfg.gradient_checkpointing:
-        model.config.use_cache = False
-
-    return get_peft_model(model, peft_config)

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

@@ -1,73 +0,0 @@
-"""$project_name: A Flower / FlowerTune app."""
-
-import os
-from datetime import datetime
-
-from flwr.app import ArrayRecord, ConfigRecord, Context, MetricRecord
-from flwr.common.config import unflatten_dict
-from flwr.serverapp import Grid, ServerApp
-from omegaconf import DictConfig
-from peft import get_peft_model_state_dict, set_peft_model_state_dict
-
-from $import_name.dataset import replace_keys
-from $import_name.models import get_model
-from $import_name.strategy import FlowerTuneLlm
-
-# Create ServerApp
-app = ServerApp()
-
-
-@app.main()
-def main(grid: Grid, context: Context) -> None:
-    """Main entry point for the ServerApp."""
-    # Create output directory given current timestamp
-    current_time = datetime.now()
-    folder_name = current_time.strftime("%Y-%m-%d_%H-%M-%S")
-    save_path = os.path.join(os.getcwd(), f"results/{folder_name}")
-    os.makedirs(save_path, exist_ok=True)
-
-    # Read from config
-    num_rounds = context.run_config["num-server-rounds"]
-    cfg = DictConfig(replace_keys(unflatten_dict(context.run_config)))
-
-    # Get initial model weights
-    init_model = get_model(cfg.model)
-    arrays = ArrayRecord(get_peft_model_state_dict(init_model))
-
-    # Define strategy
-    strategy = FlowerTuneLlm(
-        fraction_train=cfg.strategy.fraction_train,
-        fraction_evaluate=cfg.strategy.fraction_evaluate,
-    )
-
-    # Start strategy, run FedAvg for `num_rounds`
-    strategy.start(
-        grid=grid,
-        initial_arrays=arrays,
-        train_config=ConfigRecord({"save_path": save_path}),
-        num_rounds=num_rounds,
-        evaluate_fn=get_evaluate_fn(
-            cfg.model, cfg.train.save_every_round, num_rounds, save_path
-        ),
-    )
-
-
-# Get function that will be executed by the strategy
-# Here we use it to save global model checkpoints
-def get_evaluate_fn(model_cfg, save_every_round, total_round, save_path):
-    """Return an evaluation function for saving global model."""
-
-    def evaluate(server_round: int, arrays: ArrayRecord) -> MetricRecord:
-        # Save model
-        if server_round != 0 and (
-            server_round == total_round or server_round % save_every_round == 0
-        ):
-            # Init model
-            model = get_model(model_cfg)
-            set_peft_model_state_dict(model, arrays.to_torch_state_dict())
-
-            model.save_pretrained(f"{save_path}/peft_{server_round}")
-
-        return MetricRecord()
-
-    return evaluate

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

@@ -1,78 +0,0 @@
-"""$project_name: A Flower / FlowerTune app."""
-
-from collections.abc import Iterable
-from logging import INFO, WARN
-from typing import Optional
-
-from flwr.app import ArrayRecord, ConfigRecord, Message, MetricRecord
-from flwr.common import log
-from flwr.serverapp import Grid
-from flwr.serverapp.strategy import FedAvg
-
-
-class FlowerTuneLlm(FedAvg):
-    """Customised FedAvg strategy implementation.
-
-    This class behaves just like FedAvg but also tracks the communication
-    costs associated with `train` over FL rounds.
-    """
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
-        self.comm_tracker = CommunicationTracker()
-
-    def configure_train(
-            self, server_round: int, arrays: ArrayRecord, config: ConfigRecord, grid: Grid
-    ) -> Iterable[Message]:
-        """Configure the next round of training."""
-        messages = super().configure_train(server_round, arrays, config, grid)
-
-        # Track communication costs
-        self.comm_tracker.track(messages)
-
-        return messages
-
-    def aggregate_train(
-            self,
-            server_round: int,
-            replies: Iterable[Message],
-    ) -> tuple[Optional[ArrayRecord], Optional[MetricRecord]]:
-        """Aggregate ArrayRecords and MetricRecords in the received Messages."""
-        # Track communication costs
-        self.comm_tracker.track(replies)
-
-        arrays, metrics = super().aggregate_train(server_round, replies)
-
-        return arrays, metrics
-
-
-class CommunicationTracker:
-    """Communication costs tracker over FL rounds."""
-    def __init__(self):
-        self.curr_comm_cost = 0.0
-
-    def track(self, messages: Iterable[Message]):
-        comm_cost = (
-            sum(
-                record.count_bytes()
-                for msg in messages
-                if msg.has_content()
-                for record in msg.content.array_records.values()
-            )
-            / 1024**2
-        )
-
-        self.curr_comm_cost += comm_cost
-        log(
-            INFO,
-            "Communication budget: used %.2f MB (+%.2f MB this round) / 200,000 MB",
-            self.curr_comm_cost,
-            comm_cost,
-        )
-
-        if self.curr_comm_cost > 2e5:
-            log(
-                WARN,
-                "The accumulated communication cost has exceeded 200,000 MB. "
-                "Please consider reducing it if you plan to participate "
-                "FlowerTune LLM Leaderboard.",
-            )

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

@@ -1,66 +0,0 @@
-"""$project_name: A Flower Baseline."""
-
-import torch
-import torch.nn.functional as F
-from torch import nn
-
-
-class Net(nn.Module):
-    """Model (simple CNN adapted from 'PyTorch: A 60 Minute Blitz')."""
-
-    def __init__(self):
-        super().__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):
-        """Do forward."""
-        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)
-
-
-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()
-    criterion.to(device)
-    optimizer = torch.optim.SGD(net.parameters(), lr=0.1, momentum=0.9)
-    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

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

@@ -1,43 +0,0 @@
-"""$project_name: A Flower Baseline."""
-
-import torch
-from flwr.app import ArrayRecord, Context
-from flwr.serverapp import Grid, ServerApp
-from flwr.serverapp.strategy import FedAvg
-
-from $import_name.model import Net
-
-# 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"]
-    fraction_train = context.run_config["fraction-train"]
-
-    # Load global model
-    global_model = Net()
-    arrays = ArrayRecord(global_model.state_dict())
-
-    # Initialize FedAvg strategy
-    strategy = FedAvg(
-        fraction_train=fraction_train,
-        fraction_evaluate=1.0,
-        min_available_nodes=2,
-    )
-
-    # 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...")
-    state_dict = result.arrays.to_torch_state_dict()
-    torch.save(state_dict, "final_model.pt")

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

@@ -1,42 +0,0 @@
-"""$project_name: A Flower / $framework_str app."""
-
-import torch
-from flwr.app import ArrayRecord, Context
-from flwr.serverapp import Grid, ServerApp
-from flwr.serverapp.strategy import FedAvg
-from transformers import AutoModelForSequenceClassification
-
-# 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"]
-    fraction_train = context.run_config["fraction-train"]
-
-    # Initialize global model
-    model_name = context.run_config["model-name"]
-    num_labels = context.run_config["num-labels"]
-    net = AutoModelForSequenceClassification.from_pretrained(
-        model_name, num_labels=num_labels
-    )
-    arrays = ArrayRecord(net.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,
-        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.jax.py.tpl

@@ -1,39 +0,0 @@
-"""$project_name: A Flower / $framework_str app."""
-
-import numpy as np
-from flwr.app import ArrayRecord, Context
-from flwr.serverapp import Grid, ServerApp
-from flwr.serverapp.strategy import FedAvg
-
-from $import_name.task import get_params, load_model
-
-# 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"]
-    input_dim = context.run_config["input-dim"]
-
-    # Load global model
-    model = load_model((input_dim,))
-    arrays = ArrayRecord(get_params(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.npz", *ndarrays)

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

@@ -1,41 +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 MLP, get_params, set_params
-
-# 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_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, output_dim=10)
-    params = get_params(model)
-    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,38 +0,0 @@
-"""$project_name: A Flower / $framework_str app."""
-
-import numpy as np
-from flwr.app import ArrayRecord, Context
-from flwr.serverapp import Grid, ServerApp
-from flwr.serverapp.strategy import FedAvg
-
-from $import_name.task import get_dummy_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 = 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,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")