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

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

@@ -2,10 +2,16 @@
 
 import warnings
 
-from sklearn.metrics import log_loss
+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 flwr.client import ClientApp, NumPyClient
-from flwr.common import Context
 from $import_name.task import (
     get_model,
     get_model_params,
@@ -14,39 +20,52 @@ from $import_name.task import (
     set_model_params,
 )
 
+# Flower ClientApp
+app = ClientApp()
 
-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 fit(self, parameters, config):
-        set_model_params(self.model, parameters)
+@app.train()
+def train(msg: Message, context: Context):
+    """Train the model on local data."""
 
-        # Ignore convergence failure due to low local epochs
-        with warnings.catch_warnings():
-            warnings.simplefilter("ignore")
-            self.model.fit(self.X_train, self.y_train)
+    # 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)
 
-        return get_model_params(self.model), len(self.X_train), {}
+    # Apply received pararameters
+    ndarrays = msg.content["arrays"].to_numpy_ndarrays()
+    set_model_params(model, ndarrays)
 
-    def evaluate(self, parameters, config):
-        set_model_params(self.model, parameters)
+    # 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)
 
-        loss = log_loss(self.y_test, self.model.predict_proba(self.X_test))
-        accuracy = self.model.score(self.X_test, self.y_test)
+    # 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)
 
-        return loss, len(self.X_test), {"accuracy": accuracy}
+    # 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)
 
-def client_fn(context: Context):
-    partition_id = context.node_config["partition-id"]
-    num_partitions = context.node_config["num-partitions"]
 
-    X_train, X_test, y_train, y_test = load_data(partition_id, num_partitions)
+@app.evaluate()
+def evaluate(msg: Message, context: Context):
+    """Evaluate the model on test data."""
 
     # Create LogisticRegression Model
     penalty = context.run_config["penalty"]
@@ -56,8 +75,34 @@ def client_fn(context: Context):
     # 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()
+    # Apply received pararameters
+    ndarrays = msg.content["arrays"].to_numpy_ndarrays()
+    set_model_params(model, ndarrays)
 
-
-# Flower ClientApp
-app = ClientApp(client_fn=client_fn)
+    # 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,57 +1,82 @@
 """$project_name: A Flower / $framework_str app."""
 
-from flwr.client import NumPyClient, ClientApp
-from flwr.common import Context
+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()
 
-# Define Flower Client and client_fn
-class FlowerClient(NumPyClient):
-    def __init__(
-        self, model, data, epochs, batch_size, verbose
-    ):
-        self.model = model
-        self.x_train, self.y_train, self.x_test, self.y_test = data
-        self.epochs = epochs
-        self.batch_size = batch_size
-        self.verbose = verbose
-
-    def fit(self, parameters, config):
-        self.model.set_weights(parameters)
-        self.model.fit(
-            self.x_train,
-            self.y_train,
-            epochs=self.epochs,
-            batch_size=self.batch_size,
-            verbose=self.verbose,
-        )
-        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(context: Context):
-    # Load model and data
-    net = load_model()
 
-    partition_id = context.node_config["partition-id"]
-    num_partitions = context.node_config["num-partitions"]
-    data = load_data(partition_id, num_partitions)
+@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")
 
-    # Return Client instance
-    return FlowerClient(
-        net, data, epochs, batch_size, verbose
-    ).to_client()
+    # 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,
+    )
 
-# Flower ClientApp
-app = ClientApp(
-    client_fn=client_fn,
-)
+    # 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

@@ -0,0 +1,110 @@
+"""$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/flwr_tune/client_app.py.tpl

@@ -2,15 +2,12 @@
 
 import os
 import warnings
-from typing import Dict, Tuple
 
-import torch
-from flwr.client import ClientApp, NumPyClient
-from flwr.common import Context
+from flwr.app import ArrayRecord, Context, Message, MetricRecord, RecordDict
+from flwr.clientapp import ClientApp
 from flwr.common.config import unflatten_dict
-from flwr.common.typing import NDArrays, Scalar
 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
 
@@ -19,12 +16,7 @@ from $import_name.dataset import (
     load_data,
     replace_keys,
 )
-from $import_name.models import (
-    cosine_annealing,
-    get_model,
-    set_parameters,
-    get_parameters,
-)
+from $import_name.models import cosine_annealing, get_model
 
 # Avoid warnings
 os.environ["TOKENIZERS_PARALLELISM"] = "true"
@@ -32,95 +24,69 @@ os.environ["RAY_DISABLE_DOCKER_CPU_WARNING"] = "1"
 warnings.filterwarnings("ignore", category=UserWarning)
 
 
-# pylint: disable=too-many-arguments
-# pylint: disable=too-many-instance-attributes
-class FlowerClient(NumPyClient):
-    """Flower client for LLM fine-tuning."""
+# Avoid warnings
+os.environ["TOKENIZERS_PARALLELISM"] = "true"
+os.environ["RAY_DISABLE_DOCKER_CPU_WARNING"] = "1"
+warnings.filterwarnings("ignore", category=UserWarning)
 
-    def __init__(
-        self,
-        model_cfg: DictConfig,
-        train_cfg: DictConfig,
-        trainset,
-        tokenizer,
-        formatting_prompts_func,
-        data_collator,
-        num_rounds,
-    ):  # pylint: disable=too-many-arguments
-        self.device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
-        self.train_cfg = train_cfg
-        self.training_arguments = TrainingArguments(**train_cfg.training_arguments)
-        self.tokenizer = tokenizer
-        self.formatting_prompts_func = formatting_prompts_func
-        self.data_collator = data_collator
-        self.num_rounds = num_rounds
-        self.trainset = trainset
-
-        # instantiate model
-        self.model = get_model(model_cfg)
-
-    def fit(
-        self, parameters: NDArrays, config: Dict[str, Scalar]
-    ) -> Tuple[NDArrays, int, Dict]:
-        """Implement distributed fit function for a given client."""
-        set_parameters(self.model, parameters)
-
-        new_lr = cosine_annealing(
-            int(config["current_round"]),
-            self.num_rounds,
-            self.train_cfg.learning_rate_max,
-            self.train_cfg.learning_rate_min,
-        )
-
-        self.training_arguments.learning_rate = new_lr
-        self.training_arguments.output_dir = config["save_path"]
-
-        # Construct trainer
-        trainer = SFTTrainer(
-            model=self.model,
-            tokenizer=self.tokenizer,
-            args=self.training_arguments,
-            max_seq_length=self.train_cfg.seq_length,
-            train_dataset=self.trainset,
-            formatting_func=self.formatting_prompts_func,
-            data_collator=self.data_collator,
-        )
-
-        # Do local training
-        results = trainer.train()
-
-        return (
-            get_parameters(self.model),
-            len(self.trainset),
-            {"train_loss": results.training_loss},
-        )
-
-
-def client_fn(context: Context) -> FlowerClient:
-    """Create a Flower client representing a single organization."""
+
+# 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
-    client_trainset = load_data(partition_id, num_partitions, cfg.static.dataset.name)
+    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)
 
-    return FlowerClient(
-        cfg.model,
-        cfg.train,
-        client_trainset,
-        tokenizer,
-        formatting_prompts_func,
-        data_collator,
-        num_rounds,
-    ).to_client()
-
+    # 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())
 
-# Flower ClientApp
-app = ClientApp(client_fn)
+    # 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/models.py.tpl

@@ -4,18 +4,10 @@ import math
 
 import torch
 from omegaconf import DictConfig
-from collections import OrderedDict
-from peft import (
-    LoraConfig,
-    get_peft_model,
-    get_peft_model_state_dict,
-    set_peft_model_state_dict,
-)
+from peft import LoraConfig, get_peft_model
 from peft.utils import prepare_model_for_kbit_training
 from transformers import AutoModelForCausalLM, BitsAndBytesConfig
 
-from flwr.common.typing import NDArrays
-
 
 def cosine_annealing(
     current_round: int,
@@ -62,17 +54,3 @@ def get_model(model_cfg: DictConfig):
         model.config.use_cache = False
 
     return get_peft_model(model, peft_config)
-
-
-def set_parameters(model, parameters: NDArrays) -> None:
-    """Change the parameters of the model using the given ones."""
-    peft_state_dict_keys = get_peft_model_state_dict(model).keys()
-    params_dict = zip(peft_state_dict_keys, parameters)
-    state_dict = OrderedDict({k: torch.Tensor(v) for k, v in params_dict})
-    set_peft_model_state_dict(model, state_dict)
-
-
-def get_parameters(model) -> NDArrays:
-    """Return the parameters of the current net."""
-    state_dict = get_peft_model_state_dict(model)
-    return [val.cpu().numpy() for _, val in state_dict.items()]