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

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

@@ -1,80 +0,0 @@
-"""$project_name: A Flower / $framework_str app."""
-
-import torch
-from flwr.app import ArrayRecord, Context, Message, MetricRecord, RecordDict
-from flwr.clientapp import ClientApp
-
-from $import_name.task import Net, load_data
-from $import_name.task import test as test_fn
-from $import_name.task import train as train_fn
-
-# Flower ClientApp
-app = ClientApp()
-
-
-@app.train()
-def train(msg: Message, context: Context):
-    """Train the model on local data."""
-
-    # Load the model and initialize it with the received weights
-    model = Net()
-    model.load_state_dict(msg.content["arrays"].to_torch_state_dict())
-    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
-    model.to(device)
-
-    # Load the data
-    partition_id = context.node_config["partition-id"]
-    num_partitions = context.node_config["num-partitions"]
-    trainloader, _ = load_data(partition_id, num_partitions)
-
-    # Call the training function
-    train_loss = train_fn(
-        model,
-        trainloader,
-        context.run_config["local-epochs"],
-        msg.content["config"]["lr"],
-        device,
-    )
-
-    # Construct and return reply Message
-    model_record = ArrayRecord(model.state_dict())
-    metrics = {
-        "train_loss": train_loss,
-        "num-examples": len(trainloader.dataset),
-    }
-    metric_record = MetricRecord(metrics)
-    content = RecordDict({"arrays": model_record, "metrics": metric_record})
-    return Message(content=content, reply_to=msg)
-
-
-@app.evaluate()
-def evaluate(msg: Message, context: Context):
-    """Evaluate the model on local data."""
-
-    # Load the model and initialize it with the received weights
-    model = Net()
-    model.load_state_dict(msg.content["arrays"].to_torch_state_dict())
-    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
-    model.to(device)
-
-    # Load the data
-    partition_id = context.node_config["partition-id"]
-    num_partitions = context.node_config["num-partitions"]
-    _, valloader = load_data(partition_id, num_partitions)
-
-    # Call the evaluation function
-    eval_loss, eval_acc = test_fn(
-        model,
-        valloader,
-        device,
-    )
-
-    # Construct and return reply Message
-    metrics = {
-        "eval_loss": eval_loss,
-        "eval_acc": eval_acc,
-        "num-examples": len(valloader.dataset),
-    }
-    metric_record = MetricRecord(metrics)
-    content = RecordDict({"metrics": metric_record})
-    return Message(content=content, reply_to=msg)

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

@@ -1,55 +0,0 @@
-"""$project_name: A Flower / $framework_str app."""
-
-import torch
-
-from flwr.client import ClientApp, NumPyClient
-from flwr.common import Context
-from $import_name.task import Net, get_weights, load_data, set_weights, test, train
-
-
-# Define Flower Client and client_fn
-class FlowerClient(NumPyClient):
-    def __init__(self, net, trainloader, valloader, local_epochs):
-        self.net = net
-        self.trainloader = trainloader
-        self.valloader = valloader
-        self.local_epochs = local_epochs
-        self.device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
-        self.net.to(self.device)
-
-    def fit(self, parameters, config):
-        set_weights(self.net, parameters)
-        train_loss = train(
-            self.net,
-            self.trainloader,
-            self.local_epochs,
-            self.device,
-        )
-        return (
-            get_weights(self.net),
-            len(self.trainloader.dataset),
-            {"train_loss": train_loss},
-        )
-
-    def evaluate(self, parameters, config):
-        set_weights(self.net, parameters)
-        loss, accuracy = test(self.net, self.valloader, self.device)
-        return loss, len(self.valloader.dataset), {"accuracy": accuracy}
-
-
-def client_fn(context: Context):
-    # Load model and data
-    net = Net()
-    partition_id = context.node_config["partition-id"]
-    num_partitions = context.node_config["num-partitions"]
-    trainloader, valloader = load_data(partition_id, num_partitions)
-    local_epochs = context.run_config["local-epochs"]
-
-    # Return Client instance
-    return FlowerClient(net, trainloader, valloader, local_epochs).to_client()
-
-
-# Flower ClientApp
-app = ClientApp(
-    client_fn,
-)

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

@@ -1,108 +0,0 @@
-"""$project_name: A Flower / $framework_str app."""
-
-import warnings
-
-from flwr.app import ArrayRecord, Context, Message, MetricRecord, RecordDict
-from flwr.clientapp import ClientApp
-from sklearn.metrics import (
-    accuracy_score,
-    f1_score,
-    log_loss,
-    precision_score,
-    recall_score,
-)
-
-from $import_name.task import (
-    get_model,
-    get_model_params,
-    load_data,
-    set_initial_params,
-    set_model_params,
-)
-
-# Flower ClientApp
-app = ClientApp()
-
-
-@app.train()
-def train(msg: Message, context: Context):
-    """Train the model on local data."""
-
-    # 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)
-
-    # Apply received pararameters
-    ndarrays = msg.content["arrays"].to_numpy_ndarrays()
-    set_model_params(model, ndarrays)
-
-    # Load the data
-    partition_id = context.node_config["partition-id"]
-    num_partitions = context.node_config["num-partitions"]
-    X_train, _, y_train, _ = load_data(partition_id, num_partitions)
-
-    # Ignore convergence failure due to low local epochs
-    with warnings.catch_warnings():
-        warnings.simplefilter("ignore")
-        # Train the model on local data
-        model.fit(X_train, y_train)
-
-    # Let's compute train loss
-    y_train_pred_proba = model.predict_proba(X_train)
-    train_logloss = log_loss(y_train, y_train_pred_proba)
-
-    # Construct and return reply Message
-    ndarrays = get_model_params(model)
-    model_record = ArrayRecord(ndarrays)
-    metrics = {"num-examples": len(X_train), "train_logloss": train_logloss}
-    metric_record = MetricRecord(metrics)
-    content = RecordDict({"arrays": model_record, "metrics": metric_record})
-    return Message(content=content, reply_to=msg)
-
-
-@app.evaluate()
-def evaluate(msg: Message, context: Context):
-    """Evaluate the model on test data."""
-
-    # 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)
-
-    # Apply received pararameters
-    ndarrays = msg.content["arrays"].to_numpy_ndarrays()
-    set_model_params(model, ndarrays)
-
-    # Load the data
-    partition_id = context.node_config["partition-id"]
-    num_partitions = context.node_config["num-partitions"]
-    _, X_test, _, y_test = load_data(partition_id, num_partitions)
-
-    # Evaluate the model on local data
-    y_train_pred = model.predict(X_test)
-    y_train_pred_proba = model.predict_proba(X_test)
-
-    accuracy = accuracy_score(y_test, y_train_pred)
-    loss = log_loss(y_test, y_train_pred_proba)
-    precision = precision_score(y_test, y_train_pred, average="macro", zero_division=0)
-    recall = recall_score(y_test, y_train_pred, average="macro", zero_division=0)
-    f1 = f1_score(y_test, y_train_pred, average="macro", zero_division=0)
-
-    # Construct and return reply Message
-    metrics = {
-        "num-examples": len(X_test),
-        "test_logloss": loss,
-        "accuracy": accuracy,
-        "precision": precision,
-        "recall": recall,
-        "f1": f1,
-    }
-    metric_record = MetricRecord(metrics)
-    content = RecordDict({"metrics": metric_record})
-    return Message(content=content, reply_to=msg)

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

@@ -1,82 +0,0 @@
-"""$project_name: A Flower / $framework_str app."""
-
-from flwr.app import ArrayRecord, Context, Message, MetricRecord, RecordDict
-from flwr.clientapp import ClientApp
-
-from $import_name.task import load_data, load_model
-
-# Flower ClientApp
-app = ClientApp()
-
-
-@app.train()
-def train(msg: Message, context: Context):
-    """Train the model on local data."""
-
-    # Load the model and initialize it with the received weights
-    model = load_model()
-    ndarrays = msg.content["arrays"].to_numpy_ndarrays()
-    model.set_weights(ndarrays)
-
-    # Read from config
-    epochs = context.run_config["local-epochs"]
-    batch_size = context.run_config["batch-size"]
-    verbose = context.run_config.get("verbose")
-
-    # Load the data
-    partition_id = context.node_config["partition-id"]
-    num_partitions = context.node_config["num-partitions"]
-    x_train, y_train, _, _ = load_data(partition_id, num_partitions)
-
-    # Train the model on local data
-    history = model.fit(
-        x_train,
-        y_train,
-        epochs=epochs,
-        batch_size=batch_size,
-        verbose=verbose,
-    )
-
-    # Get final training loss and accuracy
-    train_loss = history.history["loss"][-1] if "loss" in history.history else None
-    train_acc = history.history.get("accuracy")
-    train_acc = train_acc[-1] if train_acc is not None else None
-
-    # Construct and return reply Message
-    model_record = ArrayRecord(model.get_weights())
-    metrics = {"num-examples": len(x_train)}
-    if train_loss is not None:
-        metrics["train_loss"] = train_loss
-    if train_acc is not None:
-        metrics["train_acc"] = train_acc
-    metric_record = MetricRecord(metrics)
-    content = RecordDict({"arrays": model_record, "metrics": metric_record})
-    return Message(content=content, reply_to=msg)
-
-
-@app.evaluate()
-def evaluate(msg: Message, context: Context):
-    """Evaluate the model on local data."""
-
-    # Load the model and initialize it with the received weights
-    model = load_model()
-    ndarrays = msg.content["arrays"].to_numpy_ndarrays()
-    model.set_weights(ndarrays)
-
-    # Load the data
-    partition_id = context.node_config["partition-id"]
-    num_partitions = context.node_config["num-partitions"]
-    _, _, x_test, y_test = load_data(partition_id, num_partitions)
-
-    # Evaluate the model on local data
-    loss, accuracy = model.evaluate(x_test, y_test, verbose=0)
-
-    # Construct and return reply Message
-    metrics = {
-        "eval_loss": loss,
-        "eval_acc": accuracy,
-        "num-examples": len(x_test),
-    }
-    metric_record = MetricRecord(metrics)
-    content = RecordDict({"metrics": metric_record})
-    return Message(content=content, reply_to=msg)

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

@@ -1,110 +0,0 @@
-"""$project_name: A Flower / $framework_str app."""
-
-import warnings
-
-import numpy as np
-import xgboost as xgb
-from flwr.app import ArrayRecord, Context, Message, MetricRecord, RecordDict
-from flwr.clientapp import ClientApp
-from flwr.common.config import unflatten_dict
-
-from $import_name.task import load_data, replace_keys
-
-warnings.filterwarnings("ignore", category=UserWarning)
-
-
-# Flower ClientApp
-app = ClientApp()
-
-
-def _local_boost(bst_input, num_local_round, train_dmatrix):
-    # Update trees based on local training data.
-    for i in range(num_local_round):
-        bst_input.update(train_dmatrix, bst_input.num_boosted_rounds())
-
-    # Bagging: extract the last N=num_local_round trees for sever aggregation
-    bst = bst_input[
-        bst_input.num_boosted_rounds()
-        - num_local_round : bst_input.num_boosted_rounds()
-    ]
-    return bst
-
-
-@app.train()
-def train(msg: Message, context: Context) -> Message:
-    # Load model and data
-    partition_id = context.node_config["partition-id"]
-    num_partitions = context.node_config["num-partitions"]
-    train_dmatrix, _, num_train, _ = load_data(partition_id, num_partitions)
-
-    # Read from run config
-    num_local_round = context.run_config["local-epochs"]
-    # Flatted config dict and replace "-" with "_"
-    cfg = replace_keys(unflatten_dict(context.run_config))
-    params = cfg["params"]
-
-    global_round = msg.content["config"]["server-round"]
-    if global_round == 1:
-        # First round local training
-        bst = xgb.train(
-            params,
-            train_dmatrix,
-            num_boost_round=num_local_round,
-        )
-    else:
-        bst = xgb.Booster(params=params)
-        global_model = bytearray(msg.content["arrays"]["0"].numpy().tobytes())
-
-        # Load global model into booster
-        bst.load_model(global_model)
-
-        # Local training
-        bst = _local_boost(bst, num_local_round, train_dmatrix)
-
-    # Save model
-    local_model = bst.save_raw("json")
-    model_np = np.frombuffer(local_model, dtype=np.uint8)
-
-    # Construct reply message
-    # Note: we store the model as the first item in a list into ArrayRecord,
-    # which can be accessed using index ["0"].
-    model_record = ArrayRecord([model_np])
-    metrics = {
-        "num-examples": num_train,
-    }
-    metric_record = MetricRecord(metrics)
-    content = RecordDict({"arrays": model_record, "metrics": metric_record})
-    return Message(content=content, reply_to=msg)
-
-
-@app.evaluate()
-def evaluate(msg: Message, context: Context) -> Message:
-    # Load model and data
-    partition_id = context.node_config["partition-id"]
-    num_partitions = context.node_config["num-partitions"]
-    _, valid_dmatrix, _, num_val = load_data(partition_id, num_partitions)
-
-    # Load config
-    cfg = replace_keys(unflatten_dict(context.run_config))
-    params = cfg["params"]
-
-    # Load global model
-    bst = xgb.Booster(params=params)
-    global_model = bytearray(msg.content["arrays"]["0"].numpy().tobytes())
-    bst.load_model(global_model)
-
-    # Run evaluation
-    eval_results = bst.eval_set(
-        evals=[(valid_dmatrix, "valid")],
-        iteration=bst.num_boosted_rounds() - 1,
-    )
-    auc = float(eval_results.split("\t")[1].split(":")[1])
-
-    # Construct and return reply Message
-    metrics = {
-        "auc": auc,
-        "num-examples": num_val,
-    }
-    metric_record = MetricRecord(metrics)
-    content = RecordDict({"metrics": metric_record})
-    return Message(content=content, reply_to=msg)

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

@@ -1,36 +0,0 @@
-"""$project_name: A Flower Baseline."""
-
-from flwr_datasets import FederatedDataset
-from flwr_datasets.partitioner import IidPartitioner
-from torch.utils.data import DataLoader
-from torchvision.transforms import Compose, Normalize, ToTensor
-
-FDS = None  # Cache FederatedDataset
-
-
-def load_data(partition_id: int, num_partitions: int):
-    """Load partition CIFAR10 data."""
-    # Only initialize `FederatedDataset` once
-    global FDS  # pylint: disable=global-statement
-    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

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

@@ -1,92 +0,0 @@
-"""$project_name: A Flower / FlowerTune app."""
-
-import os
-import warnings
-
-from flwr.app import ArrayRecord, Context, Message, MetricRecord, RecordDict
-from flwr.clientapp import ClientApp
-from flwr.common.config import unflatten_dict
-from omegaconf import DictConfig
-from peft import get_peft_model_state_dict, set_peft_model_state_dict
-from transformers import TrainingArguments
-from trl import SFTTrainer
-
-from $import_name.dataset import (
-    get_tokenizer_and_data_collator_and_propt_formatting,
-    load_data,
-    replace_keys,
-)
-from $import_name.models import cosine_annealing, get_model
-
-# Avoid warnings
-os.environ["TOKENIZERS_PARALLELISM"] = "true"
-os.environ["RAY_DISABLE_DOCKER_CPU_WARNING"] = "1"
-warnings.filterwarnings("ignore", category=UserWarning)
-
-
-# Avoid warnings
-os.environ["TOKENIZERS_PARALLELISM"] = "true"
-os.environ["RAY_DISABLE_DOCKER_CPU_WARNING"] = "1"
-warnings.filterwarnings("ignore", category=UserWarning)
-
-
-# Flower ClientApp
-app = ClientApp()
-
-
-@app.train()
-def train(msg: Message, context: Context):
-    """Train the model on local data."""
-    # Parse config
-    partition_id = context.node_config["partition-id"]
-    num_partitions = context.node_config["num-partitions"]
-    num_rounds = context.run_config["num-server-rounds"]
-    cfg = DictConfig(replace_keys(unflatten_dict(context.run_config)))
-    training_arguments = TrainingArguments(**cfg.train.training_arguments)
-
-    # Let's get the client partition
-    trainset = load_data(partition_id, num_partitions, cfg.static.dataset.name)
-    (
-        tokenizer,
-        data_collator,
-        formatting_prompts_func,
-    ) = get_tokenizer_and_data_collator_and_propt_formatting(cfg.model.name)
-
-    # Load the model and initialize it with the received weights
-    model = get_model(cfg.model)
-    set_peft_model_state_dict(model, msg.content["arrays"].to_torch_state_dict())
-
-    # Set learning rate for current round
-    new_lr = cosine_annealing(
-        msg.content["config"]["server-round"],
-        num_rounds,
-        cfg.train.learning_rate_max,
-        cfg.train.learning_rate_min,
-    )
-
-    training_arguments.learning_rate = new_lr
-    training_arguments.output_dir = msg.content["config"]["save_path"]
-
-    # Construct trainer
-    trainer = SFTTrainer(
-        model=model,
-        tokenizer=tokenizer,
-        args=training_arguments,
-        max_seq_length=cfg.train.seq_length,
-        train_dataset=trainset,
-        formatting_func=formatting_prompts_func,
-        data_collator=data_collator,
-    )
-
-    # Do local training
-    results = trainer.train()
-
-    # Construct and return reply Message
-    model_record = ArrayRecord(get_peft_model_state_dict(model))
-    metrics = {
-        "train_loss": results.training_loss,
-        "num-examples": len(trainset),
-    }
-    metric_record = MetricRecord(metrics)
-    content = RecordDict({"arrays": model_record, "metrics": metric_record})
-    return Message(content=content, reply_to=msg)

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

@@ -1,87 +0,0 @@
-"""$project_name: A Flower / FlowerTune app."""
-
-from flwr_datasets import FederatedDataset
-from flwr_datasets.partitioner import IidPartitioner
-from transformers import AutoTokenizer
-from trl import DataCollatorForCompletionOnlyLM
-
-FDS = None  # Cache FederatedDataset
-
-
-def formatting_prompts_func(example):
-    """Construct prompts."""
-    output_texts = []
-    # Constructing a standard Alpaca
-    # (https://github.com/tatsu-lab/stanford_alpaca#data-release) prompt
-    mssg = (
-        "Below is an instruction that describes a task. "
-        "Write a response that appropriately completes the request."
-    )
-    for i in range(len(example["instruction"])):
-        text = (
-            f"{mssg}\n### Instruction:\n{example['instruction'][i]}\n"
-            f"### Response: {example['response'][i]}"
-        )
-        output_texts.append(text)
-    return output_texts
-
-
-def get_tokenizer_and_data_collator_and_propt_formatting(model_name: str):
-    """Get tokenizer, data_collator and prompt formatting."""
-    tokenizer = AutoTokenizer.from_pretrained(
-        model_name, use_fast=True, padding_side="right"
-    )
-    tokenizer.pad_token = tokenizer.eos_token
-    response_template_with_context = "\n### Response:"  # alpaca response tag
-    response_template_ids = tokenizer.encode(
-        response_template_with_context, add_special_tokens=False
-    )[2:]
-    data_collator = DataCollatorForCompletionOnlyLM(
-        response_template_ids, tokenizer=tokenizer
-    )
-
-    return tokenizer, data_collator, formatting_prompts_func
-
-
-def formatting(dataset):
-    """Format dataset."""
-    dataset["instruction"] = dataset["instruction"] + " " + dataset["input"]
-    return dataset
-
-
-def reformat(dataset, llm_task):
-    """Reformat datasets."""
-    dataset = dataset.rename_column("output", "response")
-    if llm_task in ["finance", "code"]:
-        dataset = dataset.map(formatting, remove_columns=["input"])
-    if llm_task == "medical":
-        dataset = dataset.remove_columns(["instruction"])
-        dataset = dataset.rename_column("input", "instruction")
-    return dataset
-
-
-def load_data(partition_id: int, num_partitions: int, dataset_name: str):
-    """Load partition data."""
-    # Only initialize `FederatedDataset` once
-    global FDS
-    if FDS is None:
-        partitioner = IidPartitioner(num_partitions=num_partitions)
-        FDS = FederatedDataset(
-            dataset=dataset_name,
-            partitioners={"train": partitioner},
-        )
-    client_trainset = FDS.load_partition(partition_id, "train")
-    client_trainset = reformat(client_trainset, llm_task="$llm_challenge_str")
-    return client_trainset
-
-
-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