flwr-nightly 1.9.0.dev20240420__tar.gz → 1.9.0.dev20240507__tar.gz

{flwr_nightly-1.9.0.dev20240420 → flwr_nightly-1.9.0.dev20240507}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: flwr-nightly
-Version: 1.9.0.dev20240420
+Version: 1.9.0.dev20240507
 Summary: Flower: A Friendly Federated Learning Framework
 Home-page: https://flower.ai
 License: Apache-2.0
@@ -36,6 +36,7 @@ Requires-Dist: cryptography (>=42.0.4,<43.0.0)
 Requires-Dist: grpcio (>=1.60.0,<2.0.0)
 Requires-Dist: iterators (>=0.0.2,<0.0.3)
 Requires-Dist: numpy (>=1.21.0,<2.0.0)
+Requires-Dist: pathspec (>=0.12.1,<0.13.0)
 Requires-Dist: protobuf (>=4.25.2,<5.0.0)
 Requires-Dist: pycryptodome (>=3.18.0,<4.0.0)
 Requires-Dist: ray (==2.6.3) ; (python_version >= "3.8" and python_version < "3.12") and (extra == "simulation")
@@ -193,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.dev20240420 → flwr_nightly-1.9.0.dev20240507}/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.dev20240420 → flwr_nightly-1.9.0.dev20240507}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "flwr-nightly"
-version = "1.9.0.dev20240420"
+version = "1.9.0.dev20240507"
 description = "Flower: A Friendly Federated Learning Framework"
 license = "Apache-2.0"
 authors = ["The Flower Authors <hello@flower.ai>"]
@@ -59,7 +59,7 @@ flower-superlink = "flwr.server:run_superlink"
 flower-supernode = "flwr.client:run_supernode"
 flower-client-app = "flwr.client:run_client_app"
 flower-server-app = "flwr.server:run_server_app"
-flower-simulation = "flwr.simulation:run_simulation_from_cli"
+flower-simulation = "flwr.simulation.run_simulation:run_simulation_from_cli"
 
 [tool.poetry.dependencies]
 python = "^3.8"
@@ -72,6 +72,7 @@ pycryptodome = "^3.18.0"
 iterators = "^0.0.2"
 typer = { version = "^0.9.0", extras=["all"] }
 tomli = "^2.0.1"
+pathspec = "^0.12.1"
 # Optional dependencies (Simulation Engine)
 ray = { version = "==2.6.3", optional = true, python = ">=3.8,<3.12" }
 # Optional dependencies (REST transport layer)
@@ -136,7 +137,7 @@ multi_line_output = 3
 include_trailing_comma = true
 force_grid_wrap = 0
 use_parentheses = true
-known_first_party = ["flwr", "flwr_experimental", "flwr_tool"]
+known_first_party = ["flwr", "flwr_tool"]
 
 [tool.black]
 line-length = 88
@@ -170,12 +171,6 @@ plugins = [
 ignore_missing_imports = true
 strict = true
 
-[[tool.mypy.overrides]]
-module = [
-    "flwr_experimental.*",
-]
-ignore_errors = true
-
 [[tool.mypy.overrides]]
 module = [
     "importlib.metadata.*",

{flwr_nightly-1.9.0.dev20240420 → flwr_nightly-1.9.0.dev20240507}/src/py/flwr/cli/app.py

@@ -16,6 +16,7 @@
 
 import typer
 
+from .build import build
 from .example import example
 from .new import new
 from .run import run
@@ -32,6 +33,7 @@ app = typer.Typer(
 app.command()(new)
 app.command()(example)
 app.command()(run)
+app.command()(build)
 
 if __name__ == "__main__":
     app()

flwr_nightly-1.9.0.dev20240507/src/py/flwr/cli/build.py

@@ -0,0 +1,151 @@
+# Copyright 2024 Flower Labs GmbH. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Flower command line interface `build` command."""
+
+import hashlib
+import os
+import zipfile
+from pathlib import Path
+from typing import Optional
+
+import pathspec
+import typer
+from typing_extensions import Annotated
+
+from .config_utils import load_and_validate_with_defaults
+from .utils import is_valid_project_name
+
+
+# pylint: disable=too-many-locals
+def build(
+    directory: Annotated[
+        Optional[Path],
+        typer.Option(help="The Flower project directory to bundle into a FAB"),
+    ] = None,
+) -> None:
+    """Build a Flower project into a Flower App Bundle (FAB).
+
+    You can run `flwr build` without any argument to bundle the current directory:
+
+        `flwr build`
+
+    You can also build a specific directory:
+
+        `flwr build --directory ./projects/flower-hello-world`
+    """
+    if directory is None:
+        directory = Path.cwd()
+
+    directory = directory.resolve()
+    if not directory.is_dir():
+        typer.secho(
+            f"❌ The path {directory} is not a valid directory.",
+            fg=typer.colors.RED,
+            bold=True,
+        )
+        raise typer.Exit(code=1)
+
+    if not is_valid_project_name(directory.name):
+        typer.secho(
+            f"❌ The project name {directory.name} is invalid, "
+            "a valid project name must start with a letter or an underscore, "
+            "and can only contain letters, digits, and underscores.",
+            fg=typer.colors.RED,
+            bold=True,
+        )
+        raise typer.Exit(code=1)
+
+    conf, errors, warnings = load_and_validate_with_defaults(
+        directory / "pyproject.toml"
+    )
+    if conf is None:
+        typer.secho(
+            "Project configuration could not be loaded.\npyproject.toml is invalid:\n"
+            + "\n".join([f"- {line}" for line in errors]),
+            fg=typer.colors.RED,
+            bold=True,
+        )
+        raise typer.Exit(code=1)
+
+    if warnings:
+        typer.secho(
+            "Project configuration is missing the following "
+            "recommended properties:\n" + "\n".join([f"- {line}" for line in warnings]),
+            fg=typer.colors.RED,
+            bold=True,
+        )
+
+    # Load .gitignore rules if present
+    ignore_spec = _load_gitignore(directory)
+
+    # Set the name of the zip file
+    fab_filename = (
+        f"{conf['flower']['publisher']}"
+        f".{directory.name}"
+        f".{conf['project']['version'].replace('.', '-')}.fab"
+    )
+    list_file_content = ""
+
+    allowed_extensions = {".py", ".toml", ".md"}
+
+    with zipfile.ZipFile(fab_filename, "w", zipfile.ZIP_DEFLATED) as fab_file:
+        for root, _, files in os.walk(directory, topdown=True):
+            # Filter directories and files based on .gitignore
+            files = [
+                f
+                for f in files
+                if not ignore_spec.match_file(Path(root) / f)
+                and f != fab_filename
+                and Path(f).suffix in allowed_extensions
+            ]
+
+            for file in files:
+                file_path = Path(root) / file
+                archive_path = file_path.relative_to(directory)
+                fab_file.write(file_path, archive_path)
+
+                # Calculate file info
+                sha256_hash = _get_sha256_hash(file_path)
+                file_size_bits = os.path.getsize(file_path) * 8  # size in bits
+                list_file_content += f"{archive_path},{sha256_hash},{file_size_bits}\n"
+
+        # Add CONTENT and CONTENT.jwt to the zip file
+        fab_file.writestr(".info/CONTENT", list_file_content)
+
+    typer.secho(
+        f"🎊 Successfully built {fab_filename}.", fg=typer.colors.GREEN, bold=True
+    )
+
+
+def _get_sha256_hash(file_path: Path) -> str:
+    """Calculate the SHA-256 hash of a file."""
+    sha256 = hashlib.sha256()
+    with open(file_path, "rb") as f:
+        while True:
+            data = f.read(65536)  # Read in 64kB blocks
+            if not data:
+                break
+            sha256.update(data)
+    return sha256.hexdigest()
+
+
+def _load_gitignore(directory: Path) -> pathspec.PathSpec:
+    """Load and parse .gitignore file, returning a pathspec."""
+    gitignore_path = directory / ".gitignore"
+    patterns = ["__pycache__/"]  # Default pattern
+    if gitignore_path.exists():
+        with open(gitignore_path, encoding="UTF-8") as file:
+            patterns.extend(file.readlines())
+    return pathspec.PathSpec.from_lines("gitwildmatch", patterns)

{flwr_nightly-1.9.0.dev20240420 → flwr_nightly-1.9.0.dev20240507}/src/py/flwr/cli/config_utils.py

@@ -14,49 +14,16 @@
 # ==============================================================================
 """Utility to validate the `pyproject.toml` file."""
 
-import os
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple
 
 import tomli
-import typer
 
 from flwr.common import object_ref
 
 
-def validate_project_dir(project_dir: Path) -> Optional[Dict[str, Any]]:
-    """Check if a Flower App directory is valid."""
-    config = load(str(project_dir / "pyproject.toml"))
-    if config is None:
-        typer.secho(
-            "❌ Project configuration could not be loaded. "
-            "`pyproject.toml` does not exist.",
-            fg=typer.colors.RED,
-            bold=True,
-        )
-        return None
-
-    if not validate(config):
-        typer.secho(
-            "❌ Project configuration is invalid.",
-            fg=typer.colors.RED,
-            bold=True,
-        )
-        return None
-
-    if "publisher" not in config["flower"]:
-        typer.secho(
-            "❌ Project configuration is missing required `publisher` field.",
-            fg=typer.colors.RED,
-            bold=True,
-        )
-        return None
-
-    return config
-
-
 def load_and_validate_with_defaults(
-    path: Optional[str] = None,
+    path: Optional[Path] = None,
 ) -> Tuple[Optional[Dict[str, Any]], List[str], List[str]]:
     """Load and validate pyproject.toml as dict.
 
@@ -70,7 +37,8 @@ def load_and_validate_with_defaults(
 
     if config is None:
         errors = [
-            "Project configuration could not be loaded. pyproject.toml does not exist."
+            "Project configuration could not be loaded. "
+            "`pyproject.toml` does not exist."
         ]
         return (None, errors, [])
 
@@ -90,22 +58,23 @@ def load_and_validate_with_defaults(
     return (config, errors, warnings)
 
 
-def load(path: Optional[str] = None) -> Optional[Dict[str, Any]]:
+def load(path: Optional[Path] = None) -> Optional[Dict[str, Any]]:
     """Load pyproject.toml and return as dict."""
     if path is None:
-        cur_dir = os.getcwd()
-        toml_path = os.path.join(cur_dir, "pyproject.toml")
+        cur_dir = Path.cwd()
+        toml_path = cur_dir / "pyproject.toml"
     else:
         toml_path = path
 
-    if not os.path.isfile(toml_path):
+    if not toml_path.is_file():
         return None
 
-    with open(toml_path, encoding="utf-8") as toml_file:
+    with toml_path.open(encoding="utf-8") as toml_file:
         data = tomli.loads(toml_file.read())
         return data
 
 
+# pylint: disable=too-many-branches
 def validate_fields(config: Dict[str, Any]) -> Tuple[bool, List[str], List[str]]:
     """Validate pyproject.toml fields."""
     errors = []
@@ -127,13 +96,16 @@ def validate_fields(config: Dict[str, Any]) -> Tuple[bool, List[str], List[str]]
 
     if "flower" not in config:
         errors.append("Missing [flower] section")
-    elif "components" not in config["flower"]:
-        errors.append("Missing [flower.components] section")
     else:
-        if "serverapp" not in config["flower"]["components"]:
-            errors.append('Property "serverapp" missing in [flower.components]')
-        if "clientapp" not in config["flower"]["components"]:
-            errors.append('Property "clientapp" missing in [flower.components]')
+        if "publisher" not in config["flower"]:
+            errors.append('Property "publisher" missing in [flower]')
+        if "components" not in config["flower"]:
+            errors.append("Missing [flower.components] section")
+        else:
+            if "serverapp" not in config["flower"]["components"]:
+                errors.append('Property "serverapp" missing in [flower.components]')
+            if "clientapp" not in config["flower"]["components"]:
+                errors.append('Property "clientapp" missing in [flower.components]')
 
     return len(errors) == 0, errors, warnings
 

{flwr_nightly-1.9.0.dev20240420 → flwr_nightly-1.9.0.dev20240507}/src/py/flwr/cli/new/new.py

@@ -15,6 +15,7 @@
 """Flower command line interface `new` command."""
 
 import os
+import re
 from enum import Enum
 from string import Template
 from typing import Dict, Optional
@@ -36,6 +37,8 @@ class MlFramework(str, Enum):
     NUMPY = "NumPy"
     PYTORCH = "PyTorch"
     TENSORFLOW = "TensorFlow"
+    MLX = "MLX"
+    SKLEARN = "sklearn"
 
 
 class TemplateNotFound(Exception):
@@ -85,32 +88,31 @@ def new(
         Optional[MlFramework],
         typer.Option(case_sensitive=False, help="The ML framework to use"),
     ] = None,
+    username: Annotated[
+        Optional[str],
+        typer.Option(case_sensitive=False, help="The Flower username of the author"),
+    ] = None,
 ) -> None:
     """Create new Flower project."""
     if project_name is None:
-        project_name = prompt_text("Please provide project name")
+        project_name = prompt_text("Please provide the project name")
     if not is_valid_project_name(project_name):
         project_name = prompt_text(
             "Please provide a name that only contains "
-            "characters in {'_', 'a-zA-Z', '0-9'}",
+            "characters in {'-', a-zA-Z', '0-9'}",
             predicate=is_valid_project_name,
             default=sanitize_project_name(project_name),
         )
 
-    print(
-        typer.style(
-            f"🔨 Creating Flower project {project_name}...",
-            fg=typer.colors.GREEN,
-            bold=True,
-        )
-    )
+    if username is None:
+        username = prompt_text("Please provide your Flower username")
 
     if framework is not None:
         framework_str = str(framework.value)
     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
@@ -121,29 +123,51 @@ def new(
 
     framework_str = framework_str.lower()
 
+    print(
+        typer.style(
+            f"\n🔨 Creating Flower project {project_name}...",
+            fg=typer.colors.GREEN,
+            bold=True,
+        )
+    )
+
     # Set project directory path
     cwd = os.getcwd()
-    pnl = project_name.lower()
-    project_dir = os.path.join(cwd, pnl)
+    package_name = re.sub(r"[-_.]+", "-", project_name).lower()
+    import_name = package_name.replace("-", "_")
+    project_dir = os.path.join(cwd, package_name)
 
     # List of files to render
     files = {
         ".gitignore": {"template": "app/.gitignore.tpl"},
         "README.md": {"template": "app/README.md.tpl"},
         "pyproject.toml": {"template": f"app/pyproject.{framework_str}.toml.tpl"},
-        f"{pnl}/__init__.py": {"template": "app/code/__init__.py.tpl"},
-        f"{pnl}/server.py": {"template": f"app/code/server.{framework_str}.py.tpl"},
-        f"{pnl}/client.py": {"template": f"app/code/client.{framework_str}.py.tpl"},
+        f"{import_name}/__init__.py": {"template": "app/code/__init__.py.tpl"},
+        f"{import_name}/server.py": {
+            "template": f"app/code/server.{framework_str}.py.tpl"
+        },
+        f"{import_name}/client.py": {
+            "template": f"app/code/client.{framework_str}.py.tpl"
+        },
     }
 
     # Depending on the framework, generate task.py file
     frameworks_with_tasks = [
         MlFramework.PYTORCH.value.lower(),
+        MlFramework.MLX.value.lower(),
+        MlFramework.TENSORFLOW.value.lower(),
     ]
     if framework_str in frameworks_with_tasks:
-        files[f"{pnl}/task.py"] = {"template": f"app/code/task.{framework_str}.py.tpl"}
-
-    context = {"project_name": project_name}
+        files[f"{import_name}/task.py"] = {
+            "template": f"app/code/task.{framework_str}.py.tpl"
+        }
+
+    context = {
+        "project_name": project_name,
+        "package_name": package_name,
+        "import_name": import_name.replace("-", "_"),
+        "username": username,
+    }
 
     for file_path, value in files.items():
         render_and_create(

flwr_nightly-1.9.0.dev20240507/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.dev20240420 → flwr_nightly-1.9.0.dev20240507}/src/py/flwr/cli/new/templates/app/code/client.pytorch.py.tpl

@@ -2,7 +2,7 @@
 
 from flwr.client import NumPyClient, ClientApp
 
-from $project_name.task import (
+from $import_name.task import (
     Net,
     DEVICE,
     load_data,

flwr_nightly-1.9.0.dev20240507/src/py/flwr/cli/new/templates/app/code/client.sklearn.py.tpl

@@ -0,0 +1,94 @@
+"""$project_name: A Flower / Scikit-Learn app."""
+
+import warnings
+
+import numpy as np
+from flwr.client import NumPyClient, ClientApp
+from flwr_datasets import FederatedDataset
+from sklearn.linear_model import LogisticRegression
+from sklearn.metrics import log_loss
+
+
+def get_model_parameters(model):
+    if model.fit_intercept:
+        params = [
+            model.coef_,
+            model.intercept_,
+        ]
+    else:
+        params = [model.coef_]
+    return params
+
+
+def set_model_params(model, params):
+    model.coef_ = params[0]
+    if model.fit_intercept:
+        model.intercept_ = params[1]
+    return model
+
+
+def set_initial_params(model):
+    n_classes = 10  # MNIST has 10 classes
+    n_features = 784  # Number of features in dataset
+    model.classes_ = np.array([i for i in range(10)])
+
+    model.coef_ = np.zeros((n_classes, n_features))
+    if model.fit_intercept:
+        model.intercept_ = np.zeros((n_classes,))
+
+
+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 get_parameters(self, config):
+        return get_model_parameters(self.model)
+
+    def fit(self, parameters, config):
+        set_model_params(self.model, parameters)
+
+        # Ignore convergence failure due to low local epochs
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            self.model.fit(self.X_train, self.y_train)
+
+        return get_model_parameters(self.model), len(self.X_train), {}
+
+    def evaluate(self, parameters, config):
+        set_model_params(self.model, parameters)
+
+        loss = log_loss(self.y_test, self.model.predict_proba(self.X_test))
+        accuracy = self.model.score(self.X_test, self.y_test)
+
+        return loss, len(self.X_test), {"accuracy": accuracy}
+
+fds = FederatedDataset(dataset="mnist", partitioners={"train": 2})
+
+def client_fn(cid: str):
+    dataset = fds.load_partition(int(cid), "train").with_format("numpy")
+
+    X, y = dataset["image"].reshape((len(dataset), -1)), dataset["label"]
+
+    # Split the on edge data: 80% train, 20% test
+    X_train, X_test = X[: int(0.8 * len(X))], X[int(0.8 * len(X)) :]
+    y_train, y_test = y[: int(0.8 * len(y))], y[int(0.8 * len(y)) :]
+
+    # Create LogisticRegression Model
+    model = LogisticRegression(
+        penalty="l2",
+        max_iter=1,  # local epoch
+        warm_start=True,  # prevent refreshing weights when fitting
+    )
+
+    # 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()
+
+
+# Flower ClientApp
+app = ClientApp(client_fn=client_fn)