flwr-nightly 1.9.0.dev20240506__tar.gz → 1.9.0.dev20240508__tar.gz

{flwr_nightly-1.9.0.dev20240506 → flwr_nightly-1.9.0.dev20240508}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: flwr-nightly
-Version: 1.9.0.dev20240506
+Version: 1.9.0.dev20240508
 Summary: Flower: A Friendly Federated Learning Framework
 Home-page: https://flower.ai
 License: Apache-2.0
@@ -194,7 +194,7 @@ Other [examples](https://github.com/adap/flower/tree/main/examples):
 - [PyTorch: From Centralized to Federated](https://github.com/adap/flower/tree/main/examples/pytorch-from-centralized-to-federated)
 - [Vertical FL](https://github.com/adap/flower/tree/main/examples/vertical-fl)
 - [Federated Finetuning of OpenAI's Whisper](https://github.com/adap/flower/tree/main/examples/whisper-federated-finetuning)
-- [Federated Finetuning of Large Language Model](https://github.com/adap/flower/tree/main/examples/fedllm-finetune)
+- [Federated Finetuning of Large Language Model](https://github.com/adap/flower/tree/main/examples/llm-flowertune)
 - [Federated Finetuning of a Vision Transformer](https://github.com/adap/flower/tree/main/examples/vit-finetune)
 - [Advanced Flower with TensorFlow/Keras](https://github.com/adap/flower/tree/main/examples/advanced-tensorflow)
 - [Advanced Flower with PyTorch](https://github.com/adap/flower/tree/main/examples/advanced-pytorch)

{flwr_nightly-1.9.0.dev20240506 → flwr_nightly-1.9.0.dev20240508}/README.md

@@ -143,7 +143,7 @@ Other [examples](https://github.com/adap/flower/tree/main/examples):
 - [PyTorch: From Centralized to Federated](https://github.com/adap/flower/tree/main/examples/pytorch-from-centralized-to-federated)
 - [Vertical FL](https://github.com/adap/flower/tree/main/examples/vertical-fl)
 - [Federated Finetuning of OpenAI's Whisper](https://github.com/adap/flower/tree/main/examples/whisper-federated-finetuning)
-- [Federated Finetuning of Large Language Model](https://github.com/adap/flower/tree/main/examples/fedllm-finetune)
+- [Federated Finetuning of Large Language Model](https://github.com/adap/flower/tree/main/examples/llm-flowertune)
 - [Federated Finetuning of a Vision Transformer](https://github.com/adap/flower/tree/main/examples/vit-finetune)
 - [Advanced Flower with TensorFlow/Keras](https://github.com/adap/flower/tree/main/examples/advanced-tensorflow)
 - [Advanced Flower with PyTorch](https://github.com/adap/flower/tree/main/examples/advanced-pytorch)

{flwr_nightly-1.9.0.dev20240506 → flwr_nightly-1.9.0.dev20240508}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "flwr-nightly"
-version = "1.9.0.dev20240506"
+version = "1.9.0.dev20240508"
 description = "Flower: A Friendly Federated Learning Framework"
 license = "Apache-2.0"
 authors = ["The Flower Authors <hello@flower.ai>"]

{flwr_nightly-1.9.0.dev20240506 → flwr_nightly-1.9.0.dev20240508}/src/py/flwr/cli/new/new.py

@@ -37,6 +37,8 @@ class MlFramework(str, Enum):
     NUMPY = "NumPy"
     PYTORCH = "PyTorch"
     TENSORFLOW = "TensorFlow"
+    HUGGINGFACE = "HF"
+    MLX = "MLX"
     SKLEARN = "sklearn"
 
 
@@ -111,7 +113,7 @@ def new(
     else:
         framework_value = prompt_options(
             "Please select ML framework by typing in the number",
-            [mlf.value for mlf in MlFramework],
+            sorted([mlf.value for mlf in MlFramework]),
         )
         selected_value = [
             name
@@ -153,6 +155,8 @@ def new(
     # Depending on the framework, generate task.py file
     frameworks_with_tasks = [
         MlFramework.PYTORCH.value.lower(),
+        MlFramework.HUGGINGFACE.value.lower(),
+        MlFramework.MLX.value.lower(),
         MlFramework.TENSORFLOW.value.lower(),
     ]
     if framework_str in frameworks_with_tasks:

flwr_nightly-1.9.0.dev20240508/src/py/flwr/cli/new/templates/app/code/client.hf.py.tpl

@@ -0,0 +1,55 @@
+"""$project_name: A Flower / HuggingFace Transformers app."""
+
+from flwr.client import ClientApp, NumPyClient
+from transformers import AutoModelForSequenceClassification
+
+from $import_name.task import (
+    get_weights,
+    load_data,
+    set_weights,
+    train,
+    test,
+    CHECKPOINT,
+    DEVICE,
+)
+
+
+# Flower client
+class FlowerClient(NumPyClient):
+    def __init__(self, net, trainloader, testloader):
+        self.net = net
+        self.trainloader = trainloader
+        self.testloader = testloader
+
+    def get_parameters(self, config):
+        return get_weights(self.net)
+
+    def set_parameters(self, parameters):
+        set_weights(self.net, parameters)
+
+    def fit(self, parameters, config):
+        self.set_parameters(parameters)
+        train(self.net, self.trainloader, epochs=1)
+        return self.get_parameters(config={}), len(self.trainloader), {}
+
+    def evaluate(self, parameters, config):
+        self.set_parameters(parameters)
+        loss, accuracy = test(self.net, self.testloader)
+        return float(loss), len(self.testloader), {"accuracy": accuracy}
+
+
+def client_fn(cid):
+    # Load model and data
+    net = AutoModelForSequenceClassification.from_pretrained(
+        CHECKPOINT, num_labels=2
+    ).to(DEVICE)
+    trainloader, valloader = load_data(int(cid), 2)
+
+    # Return Client instance
+    return FlowerClient(net, trainloader, valloader).to_client()
+
+
+# Flower ClientApp
+app = ClientApp(
+    client_fn,
+)

flwr_nightly-1.9.0.dev20240508/src/py/flwr/cli/new/templates/app/code/client.mlx.py.tpl

@@ -0,0 +1,70 @@
+"""$project_name: A Flower / MLX app."""
+
+import mlx.core as mx
+import mlx.nn as nn
+import mlx.optimizers as optim
+from flwr.client import NumPyClient, ClientApp
+
+from $import_name.task import (
+    batch_iterate,
+    eval_fn,
+    get_params,
+    load_data,
+    loss_fn,
+    set_params,
+    MLP,
+)
+
+
+# Define Flower Client and client_fn
+class FlowerClient(NumPyClient):
+    def __init__(self, data):
+        num_layers = 2
+        hidden_dim = 32
+        num_classes = 10
+        batch_size = 256
+        num_epochs = 1
+        learning_rate = 1e-1
+
+        self.train_images, self.train_labels, self.test_images, self.test_labels = data
+        self.model = MLP(num_layers, self.train_images.shape[-1], hidden_dim, num_classes) 
+        self.optimizer = optim.SGD(learning_rate=learning_rate) 
+        self.loss_and_grad_fn = nn.value_and_grad(self.model, loss_fn) 
+        self.num_epochs = num_epochs
+        self.batch_size = batch_size
+
+    def get_parameters(self, config):
+        return get_params(self.model)
+
+    def set_parameters(self, parameters):
+        set_params(self.model, parameters)
+
+    def fit(self, parameters, config):
+        self.set_parameters(parameters)
+        for _ in range(self.num_epochs):
+            for X, y in batch_iterate(
+                self.batch_size, self.train_images, self.train_labels
+            ):
+                _, grads = self.loss_and_grad_fn(self.model, X, y)
+                self.optimizer.update(self.model, grads)
+                mx.eval(self.model.parameters(), self.optimizer.state)
+        return self.get_parameters(config={}), len(self.train_images), {}
+
+    def evaluate(self, parameters, config):
+        self.set_parameters(parameters)
+        accuracy = eval_fn(self.model, self.test_images, self.test_labels)
+        loss = loss_fn(self.model, self.test_images, self.test_labels)
+        return loss.item(), len(self.test_images), {"accuracy": accuracy.item()}
+
+
+def client_fn(cid):
+    data = load_data(int(cid), 2)
+
+    # Return Client instance
+    return FlowerClient(data).to_client()
+
+
+# Flower ClientApp
+app = ClientApp(
+    client_fn,
+)

flwr_nightly-1.9.0.dev20240508/src/py/flwr/cli/new/templates/app/code/server.hf.py.tpl

@@ -0,0 +1,17 @@
+"""$project_name: A Flower / HuggingFace Transformers app."""
+
+from flwr.server.strategy import FedAvg
+from flwr.server import ServerApp, ServerConfig
+
+
+# Define strategy
+strategy = FedAvg(
+    fraction_fit=1.0,
+    fraction_evaluate=1.0,
+)
+
+# Start server
+app = ServerApp(
+    config=ServerConfig(num_rounds=3),
+    strategy=strategy,
+)

flwr_nightly-1.9.0.dev20240508/src/py/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_nightly-1.9.0.dev20240508/src/py/flwr/cli/new/templates/app/code/task.hf.py.tpl

@@ -0,0 +1,87 @@
+"""$project_name: A Flower / HuggingFace Transformers app."""
+
+import warnings
+from collections import OrderedDict
+
+import torch
+from evaluate import load as load_metric
+from torch.optim import AdamW
+from torch.utils.data import DataLoader
+from transformers import AutoTokenizer, DataCollatorWithPadding
+
+from flwr_datasets import FederatedDataset
+
+warnings.filterwarnings("ignore", category=UserWarning)
+DEVICE = torch.device("cpu")
+CHECKPOINT = "distilbert-base-uncased"  # transformer model checkpoint
+
+
+def load_data(partition_id, num_clients):
+    """Load IMDB data (training and eval)"""
+    fds = FederatedDataset(dataset="imdb", partitioners={"train": num_clients})
+    partition = fds.load_partition(partition_id)
+    # Divide data: 80% train, 20% test
+    partition_train_test = partition.train_test_split(test_size=0.2, seed=42)
+
+    tokenizer = AutoTokenizer.from_pretrained(CHECKPOINT)
+
+    def tokenize_function(examples):
+        return tokenizer(examples["text"], truncation=True)
+
+    partition_train_test = partition_train_test.map(tokenize_function, batched=True)
+    partition_train_test = partition_train_test.remove_columns("text")
+    partition_train_test = partition_train_test.rename_column("label", "labels")
+
+    data_collator = DataCollatorWithPadding(tokenizer=tokenizer)
+    trainloader = DataLoader(
+        partition_train_test["train"],
+        shuffle=True,
+        batch_size=32,
+        collate_fn=data_collator,
+    )
+
+    testloader = DataLoader(
+        partition_train_test["test"], batch_size=32, collate_fn=data_collator
+    )
+
+    return trainloader, testloader
+
+
+def train(net, trainloader, epochs):
+    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()
+
+
+def test(net, testloader):
+    metric = load_metric("accuracy")
+    loss = 0
+    net.eval()
+    for batch in testloader:
+        batch = {k: v.to(DEVICE) for k, v in batch.items()}
+        with torch.no_grad():
+            outputs = net(**batch)
+        logits = outputs.logits
+        loss += outputs.loss.item()
+        predictions = torch.argmax(logits, dim=-1)
+        metric.add_batch(predictions=predictions, references=batch["labels"])
+    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_nightly-1.9.0.dev20240508/src/py/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_nightly-1.9.0.dev20240508/src/py/flwr/cli/new/templates/app/pyproject.hf.toml.tpl

@@ -0,0 +1,31 @@
+[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>=0.0.2,<1.0.0",
+    "torch==2.2.1",
+    "transformers>=4.30.0,<5.0"
+    "evaluate>=0.4.0,<1.0"
+    "datasets>=2.0.0, <3.0"
+    "scikit-learn>=1.3.1, <2.0"
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["."]
+
+[flower]
+publisher = "$username"
+
+[flower.components]
+serverapp = "$import_name.server:app"
+clientapp = "$import_name.client:app"

flwr_nightly-1.9.0.dev20240508/src/py/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_nightly-1.9.0.dev20240506 → flwr_nightly-1.9.0.dev20240508}/src/py/flwr/server/__init__.py

@@ -24,7 +24,6 @@ from .app import start_server as start_server
 from .client_manager import ClientManager as ClientManager
 from .client_manager import SimpleClientManager as SimpleClientManager
 from .compat import LegacyContext as LegacyContext
-from .compat import start_driver as start_driver
 from .driver import Driver as Driver
 from .history import History as History
 from .run_serverapp import run_server_app as run_server_app
@@ -45,7 +44,6 @@ __all__ = [
     "ServerApp",
     "ServerConfig",
     "SimpleClientManager",
-    "start_driver",
     "start_server",
     "strategy",
     "workflow",

{flwr_nightly-1.9.0.dev20240506 → flwr_nightly-1.9.0.dev20240508}/src/py/flwr/server/app.py

@@ -41,7 +41,7 @@ from flwr.common.constant import (
     TRANSPORT_TYPE_VCE,
 )
 from flwr.common.exit_handlers import register_exit_handlers
-from flwr.common.logger import log
+from flwr.common.logger import log, warn_deprecated_feature
 from flwr.common.secure_aggregation.crypto.symmetric_encryption import (
     private_key_to_bytes,
     public_key_to_bytes,
@@ -196,6 +196,9 @@ def start_server(  # pylint: disable=too-many-arguments,too-many-locals
 def run_driver_api() -> None:
     """Run Flower server (Driver API)."""
     log(INFO, "Starting Flower server (Driver API)")
+    # Running `flower-driver-api` is deprecated
+    warn_deprecated_feature("flower-driver-api")
+    log(WARN, "Use `flower-superlink` instead")
     event(EventType.RUN_DRIVER_API_ENTER)
     args = _parse_args_run_driver_api().parse_args()
 
@@ -233,6 +236,9 @@ def run_driver_api() -> None:
 def run_fleet_api() -> None:
     """Run Flower server (Fleet API)."""
     log(INFO, "Starting Flower server (Fleet API)")
+    # Running `flower-fleet-api` is deprecated
+    warn_deprecated_feature("flower-fleet-api")
+    log(WARN, "Use `flower-superlink` instead")
     event(EventType.RUN_FLEET_API_ENTER)
     args = _parse_args_run_fleet_api().parse_args()
 

{flwr_nightly-1.9.0.dev20240506 → flwr_nightly-1.9.0.dev20240508}/src/py/flwr/server/compat/app.py

@@ -15,50 +15,35 @@
 """Flower driver app."""
 
 
-import sys
 from logging import INFO
-from pathlib import Path
-from typing import Optional, Union
+from typing import Optional
 
 from flwr.common import EventType, event
-from flwr.common.address import parse_address
-from flwr.common.logger import log, warn_deprecated_feature
+from flwr.common.logger import log
 from flwr.server.client_manager import ClientManager
 from flwr.server.history import History
 from flwr.server.server import Server, init_defaults, run_fl
 from flwr.server.server_config import ServerConfig
 from flwr.server.strategy import Strategy
 
-from ..driver import Driver, GrpcDriver
+from ..driver import Driver
 from .app_utils import start_update_client_manager_thread
 
-DEFAULT_SERVER_ADDRESS_DRIVER = "[::]:9091"
-
-ERROR_MESSAGE_DRIVER_NOT_CONNECTED = """
-[Driver] Error: Not connected.
-
-Call `connect()` on the `Driver` instance before calling any of the other `Driver`
-methods.
-"""
-
 
 def start_driver(  # pylint: disable=too-many-arguments, too-many-locals
     *,
-    server_address: str = DEFAULT_SERVER_ADDRESS_DRIVER,
+    driver: Driver,
     server: Optional[Server] = None,
     config: Optional[ServerConfig] = None,
     strategy: Optional[Strategy] = None,
     client_manager: Optional[ClientManager] = None,
-    root_certificates: Optional[Union[bytes, str]] = None,
-    driver: Optional[Driver] = None,
 ) -> History:
     """Start a Flower Driver API server.
 
     Parameters
     ----------
-    server_address : Optional[str]
-        The IPv4 or IPv6 address of the Driver API server.
-        Defaults to `"[::]:8080"`.
+    driver : Driver
+        The Driver object to use.
     server : Optional[flwr.server.Server] (default: None)
         A server implementation, either `flwr.server.Server` or a subclass
         thereof. If no instance is provided, then `start_driver` will create
@@ -74,50 +59,14 @@ def start_driver(  # pylint: disable=too-many-arguments, too-many-locals
         An implementation of the class `flwr.server.ClientManager`. If no
         implementation is provided, then `start_driver` will use
         `flwr.server.SimpleClientManager`.
-    root_certificates : Optional[Union[bytes, str]] (default: None)
-        The PEM-encoded root certificates as a byte string or a path string.
-        If provided, a secure connection using the certificates will be
-        established to an SSL-enabled Flower server.
-    driver : Optional[Driver] (default: None)
-        The Driver object to use.
 
     Returns
     -------
     hist : flwr.server.history.History
         Object containing training and evaluation metrics.
-
-    Examples
-    --------
-    Starting a driver that connects to an insecure server:
-
-    >>> start_driver()
-
-    Starting a driver that connects to an SSL-enabled server:
-
-    >>> start_driver(
-    >>>     root_certificates=Path("/crts/root.pem").read_bytes()
-    >>> )
     """
     event(EventType.START_DRIVER_ENTER)
 
-    if driver is None:
-        # Not passing a `Driver` object is deprecated
-        warn_deprecated_feature("start_driver")
-
-        # Parse IP address
-        parsed_address = parse_address(server_address)
-        if not parsed_address:
-            sys.exit(f"Server IP address ({server_address}) cannot be parsed.")
-        host, port, is_v6 = parsed_address
-        address = f"[{host}]:{port}" if is_v6 else f"{host}:{port}"
-
-        # Create the Driver
-        if isinstance(root_certificates, str):
-            root_certificates = Path(root_certificates).read_bytes()
-        driver = GrpcDriver(
-            driver_service_address=address, root_certificates=root_certificates
-        )
-
     # Initialize the Driver API server and config
     initialized_server, initialized_config = init_defaults(
         server=server,

{flwr_nightly-1.9.0.dev20240506 → flwr_nightly-1.9.0.dev20240508}/src/py/flwr/server/history.py

@@ -91,32 +91,32 @@ class History:
         """
         rep = ""
         if self.losses_distributed:
-            rep += "History (loss, distributed):\n" + pprint.pformat(
-                reduce(
-                    lambda a, b: a + b,
-                    [
-                        f"\tround {server_round}: {loss}\n"
-                        for server_round, loss in self.losses_distributed
-                    ],
-                )
+            rep += "History (loss, distributed):\n" + reduce(
+                lambda a, b: a + b,
+                [
+                    f"\tround {server_round}: {loss}\n"
+                    for server_round, loss in self.losses_distributed
+                ],
             )
         if self.losses_centralized:
-            rep += "History (loss, centralized):\n" + pprint.pformat(
-                reduce(
-                    lambda a, b: a + b,
-                    [
-                        f"\tround {server_round}: {loss}\n"
-                        for server_round, loss in self.losses_centralized
-                    ],
-                )
+            rep += "History (loss, centralized):\n" + reduce(
+                lambda a, b: a + b,
+                [
+                    f"\tround {server_round}: {loss}\n"
+                    for server_round, loss in self.losses_centralized
+                ],
             )
         if self.metrics_distributed_fit:
-            rep += "History (metrics, distributed, fit):\n" + pprint.pformat(
-                self.metrics_distributed_fit
+            rep += (
+                "History (metrics, distributed, fit):\n"
+                + pprint.pformat(self.metrics_distributed_fit)
+                + "\n"
             )
         if self.metrics_distributed:
-            rep += "History (metrics, distributed, evaluate):\n" + pprint.pformat(
-                self.metrics_distributed
+            rep += (
+                "History (metrics, distributed, evaluate):\n"
+                + pprint.pformat(self.metrics_distributed)
+                + "\n"
             )
         if self.metrics_centralized:
             rep += "History (metrics, centralized):\n" + pprint.pformat(