flwr-nightly 1.12.0.dev20241007__tar.gz → 1.12.0.dev20241010__tar.gz

{flwr_nightly-1.12.0.dev20241007 → flwr_nightly-1.12.0.dev20241010}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: flwr-nightly
-Version: 1.12.0.dev20241007
+Version: 1.12.0.dev20241010
 Summary: Flower: A Friendly Federated Learning Framework
 Home-page: https://flower.ai
 License: Apache-2.0

{flwr_nightly-1.12.0.dev20241007 → flwr_nightly-1.12.0.dev20241010}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "flwr-nightly"
-version = "1.12.0.dev20241007"
+version = "1.12.0.dev20241010"
 description = "Flower: A Friendly Federated Learning Framework"
 license = "Apache-2.0"
 authors = ["The Flower Authors <hello@flower.ai>"]
@@ -134,6 +134,7 @@ pre-commit = "==3.5.0"
 sphinx-substitution-extensions = "2022.02.16"
 sphinxext-opengraph = "==0.9.1"
 docstrfmt = { git = "https://github.com/charlesbvll/docstrfmt.git", branch = "patch-1" }
+docsig = "==0.64.0"
 
 [tool.docstrfmt]
 extend_exclude = [
@@ -224,3 +225,7 @@ convention = "numpy"
 
 [tool.ruff.per-file-ignores]
 "src/py/flwr/server/strategy/*.py" = ["E501"]
+
+[tool.docsig]
+ignore-no-params = true
+exclude = 'src/py/flwr/proto/.*|src/py/flwr/.*_test\.py|src/py/flwr/cli/new/templates/.*\.tpl'

{flwr_nightly-1.12.0.dev20241007 → flwr_nightly-1.12.0.dev20241010}/src/py/flwr/cli/build.py

@@ -14,26 +14,50 @@
 # ==============================================================================
 """Flower command line interface `build` command."""
 
+import hashlib
 import os
+import shutil
+import tempfile
 import zipfile
 from pathlib import Path
-from typing import Annotated, Optional
+from typing import Annotated, Any, Optional, Union
 
 import pathspec
 import tomli_w
 import typer
 
+from flwr.common.constant import FAB_ALLOWED_EXTENSIONS, FAB_DATE, FAB_HASH_TRUNCATION
+
 from .config_utils import load_and_validate
-from .utils import get_sha256_hash, is_valid_project_name
+from .utils import is_valid_project_name
+
+
+def write_to_zip(
+    zipfile_obj: zipfile.ZipFile, filename: str, contents: Union[bytes, str]
+) -> zipfile.ZipFile:
+    """Set a fixed date and write contents to a zip file."""
+    zip_info = zipfile.ZipInfo(filename)
+    zip_info.date_time = FAB_DATE
+    zipfile_obj.writestr(zip_info, contents)
+    return zipfile_obj
+
 
+def get_fab_filename(conf: dict[str, Any], fab_hash: str) -> str:
+    """Get the FAB filename based on the given config and FAB hash."""
+    publisher = conf["tool"]["flwr"]["app"]["publisher"]
+    name = conf["project"]["name"]
+    version = conf["project"]["version"].replace(".", "-")
+    fab_hash_truncated = fab_hash[:FAB_HASH_TRUNCATION]
+    return f"{publisher}.{name}.{version}.{fab_hash_truncated}.fab"
 
-# pylint: disable=too-many-locals
+
+# pylint: disable=too-many-locals, too-many-statements
 def build(
     app: Annotated[
         Optional[Path],
         typer.Option(help="Path of the Flower App to bundle into a FAB"),
     ] = None,
-) -> str:
+) -> tuple[str, str]:
     """Build a Flower App into a Flower App Bundle (FAB).
 
     You can run ``flwr build`` without any arguments to bundle the app located in the
@@ -85,16 +109,8 @@ def build(
     # Load .gitignore rules if present
     ignore_spec = _load_gitignore(app)
 
-    # Set the name of the zip file
-    fab_filename = (
-        f"{conf['tool']['flwr']['app']['publisher']}"
-        f".{conf['project']['name']}"
-        f".{conf['project']['version'].replace('.', '-')}.fab"
-    )
     list_file_content = ""
 
-    allowed_extensions = {".py", ".toml", ".md"}
-
     # Remove the 'federations' field from 'tool.flwr' if it exists
     if (
         "tool" in conf
@@ -105,38 +121,53 @@ def build(
 
     toml_contents = tomli_w.dumps(conf)
 
-    with zipfile.ZipFile(fab_filename, "w", zipfile.ZIP_DEFLATED) as fab_file:
-        fab_file.writestr("pyproject.toml", toml_contents)
+    with tempfile.NamedTemporaryFile(suffix=".zip", delete=False) as temp_file:
+        temp_filename = temp_file.name
+
+        with zipfile.ZipFile(temp_filename, "w", zipfile.ZIP_DEFLATED) as fab_file:
+            write_to_zip(fab_file, "pyproject.toml", toml_contents)
 
-        # Continue with adding other files
-        for root, _, files in os.walk(app, topdown=True):
-            files = [
+            # Continue with adding other files
+            all_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
-                and f != "pyproject.toml"  # Exclude the original pyproject.toml
+                for f in app.rglob("*")
+                if not ignore_spec.match_file(f)
+                and f.name != temp_filename
+                and f.suffix in FAB_ALLOWED_EXTENSIONS
+                and f.name != "pyproject.toml"  # Exclude the original pyproject.toml
             ]
 
-            for file in files:
-                file_path = Path(root) / file
+            for file_path in all_files:
+                # Read the file content manually
+                with open(file_path, "rb") as f:
+                    file_contents = f.read()
+
                 archive_path = file_path.relative_to(app)
-                fab_file.write(file_path, archive_path)
+                write_to_zip(fab_file, str(archive_path), file_contents)
 
                 # Calculate file info
-                sha256_hash = get_sha256_hash(file_path)
+                sha256_hash = hashlib.sha256(file_contents).hexdigest()
                 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)
+            # Add CONTENT and CONTENT.jwt to the zip file
+            write_to_zip(fab_file, ".info/CONTENT", list_file_content)
+
+    # Get hash of FAB file
+    content = Path(temp_filename).read_bytes()
+    fab_hash = hashlib.sha256(content).hexdigest()
+
+    # Set the name of the zip file
+    fab_filename = get_fab_filename(conf, fab_hash)
+
+    # Once the temporary zip file is created, rename it to the final filename
+    shutil.move(temp_filename, fab_filename)
 
     typer.secho(
         f"🎊 Successfully built {fab_filename}", fg=typer.colors.GREEN, bold=True
     )
 
-    return fab_filename
+    return fab_filename, fab_hash
 
 
 def _load_gitignore(app: Path) -> pathspec.PathSpec:

{flwr_nightly-1.12.0.dev20241007 → flwr_nightly-1.12.0.dev20241010}/src/py/flwr/cli/config_utils.py

@@ -90,6 +90,16 @@ def load_and_validate(
 ) -> tuple[Optional[dict[str, Any]], list[str], list[str]]:
     """Load and validate pyproject.toml as dict.
 
+    Parameters
+    ----------
+    path : Optional[Path] (default: None)
+        The path of the Flower App config file to load. By default it
+        will try to use `pyproject.toml` inside the current directory.
+    check_module: bool (default: True)
+        Whether the validity of the Python module should be checked.
+        This requires the project to be installed in the currently
+        running environment. True by default.
+
     Returns
     -------
     Tuple[Optional[config], List[str], List[str]]

{flwr_nightly-1.12.0.dev20241007 → flwr_nightly-1.12.0.dev20241010}/src/py/flwr/cli/install.py

@@ -14,7 +14,7 @@
 # ==============================================================================
 """Flower command line interface `install` command."""
 
-
+import hashlib
 import shutil
 import subprocess
 import tempfile
@@ -25,7 +25,8 @@ from typing import IO, Annotated, Optional, Union
 
 import typer
 
-from flwr.common.config import get_flwr_dir
+from flwr.common.config import get_flwr_dir, get_metadata_from_config
+from flwr.common.constant import FAB_HASH_TRUNCATION
 
 from .config_utils import load_and_validate
 from .utils import get_sha256_hash
@@ -91,9 +92,11 @@ def install_from_fab(
     fab_name: Optional[str]
     if isinstance(fab_file, bytes):
         fab_file_archive = BytesIO(fab_file)
+        fab_hash = hashlib.sha256(fab_file).hexdigest()
         fab_name = None
     elif isinstance(fab_file, Path):
         fab_file_archive = fab_file
+        fab_hash = hashlib.sha256(fab_file.read_bytes()).hexdigest()
         fab_name = fab_file.stem
     else:
         raise ValueError("fab_file must be either a Path or bytes")
@@ -126,14 +129,16 @@ def install_from_fab(
             shutil.rmtree(info_dir)
 
             installed_path = validate_and_install(
-                tmpdir_path, fab_name, flwr_dir, skip_prompt
+                tmpdir_path, fab_hash, fab_name, flwr_dir, skip_prompt
             )
 
     return installed_path
 
 
+# pylint: disable=too-many-locals
 def validate_and_install(
     project_dir: Path,
+    fab_hash: str,
     fab_name: Optional[str],
     flwr_dir: Optional[Path],
     skip_prompt: bool = False,
@@ -149,28 +154,17 @@ def validate_and_install(
         )
         raise typer.Exit(code=1)
 
-    publisher = config["tool"]["flwr"]["app"]["publisher"]
-    project_name = config["project"]["name"]
-    version = config["project"]["version"]
+    version, fab_id = get_metadata_from_config(config)
+    publisher, project_name = fab_id.split("/")
+    config_metadata = (publisher, project_name, version, fab_hash)
 
-    if (
-        fab_name
-        and fab_name != f"{publisher}.{project_name}.{version.replace('.', '-')}"
-    ):
-        typer.secho(
-            "❌ FAB file has incorrect name. The file name must follow the format "
-            "`<publisher>.<project_name>.<version>.fab`.",
-            fg=typer.colors.RED,
-            bold=True,
-        )
-        raise typer.Exit(code=1)
+    if fab_name:
+        _validate_fab_and_config_metadata(fab_name, config_metadata)
 
     install_dir: Path = (
         (get_flwr_dir() if not flwr_dir else flwr_dir)
         / "apps"
-        / publisher
-        / project_name
-        / version
+        / f"{publisher}.{project_name}.{version}.{fab_hash[:FAB_HASH_TRUNCATION]}"
     )
     if install_dir.exists():
         if skip_prompt:
@@ -226,3 +220,49 @@ def _verify_hashes(list_content: str, tmpdir: Path) -> bool:
         if not file_path.exists() or get_sha256_hash(file_path) != hash_expected:
             return False
     return True
+
+
+def _validate_fab_and_config_metadata(
+    fab_name: str, config_metadata: tuple[str, str, str, str]
+) -> None:
+    """Validate metadata from the FAB filename and config."""
+    publisher, project_name, version, fab_hash = config_metadata
+
+    fab_name = fab_name.removesuffix(".fab")
+
+    fab_publisher, fab_project_name, fab_version, fab_shorthash = fab_name.split(".")
+    fab_version = fab_version.replace("-", ".")
+
+    # Check FAB filename format
+    if (
+        f"{fab_publisher}.{fab_project_name}.{fab_version}"
+        != f"{publisher}.{project_name}.{version}"
+        or len(fab_shorthash) != FAB_HASH_TRUNCATION  # Verify hash length
+    ):
+        typer.secho(
+            "❌ FAB file has incorrect name. The file name must follow the format "
+            "`<publisher>.<project_name>.<version>.<8hexchars>.fab`.",
+            fg=typer.colors.RED,
+            bold=True,
+        )
+        raise typer.Exit(code=1)
+
+    # Verify hash is a valid hexadecimal
+    try:
+        _ = int(fab_shorthash, 16)
+    except Exception as e:
+        typer.secho(
+            f"❌ FAB file has an invalid hexadecimal string `{fab_shorthash}`.",
+            fg=typer.colors.RED,
+            bold=True,
+        )
+        raise typer.Exit(code=1) from e
+
+    # Verify shorthash matches
+    if fab_shorthash != fab_hash[:FAB_HASH_TRUNCATION]:
+        typer.secho(
+            "❌ The hash in the FAB file name does not match the hash of the FAB.",
+            fg=typer.colors.RED,
+            bold=True,
+        )
+        raise typer.Exit(code=1)

{flwr_nightly-1.12.0.dev20241007 → flwr_nightly-1.12.0.dev20241010}/src/py/flwr/cli/new/new.py

@@ -240,6 +240,8 @@ def new(
             MlFramework.HUGGINGFACE.value,
             MlFramework.MLX.value,
             MlFramework.TENSORFLOW.value,
+            MlFramework.SKLEARN.value,
+            MlFramework.NUMPY.value,
         ]
         if framework_str in frameworks_with_tasks:
             files[f"{import_name}/task.py"] = {

{flwr_nightly-1.12.0.dev20241007 → flwr_nightly-1.12.0.dev20241010}/src/py/flwr/cli/new/templates/app/code/client.jax.py.tpl

@@ -1,9 +1,9 @@
 """$project_name: A Flower / $framework_str app."""
 
 import jax
-from flwr.client import NumPyClient, ClientApp
-from flwr.common import Context
 
+from flwr.client import ClientApp, NumPyClient
+from flwr.common import Context
 from $import_name.task import (
     evaluation,
     get_params,
@@ -17,37 +17,31 @@ from $import_name.task import (
 
 # Define Flower Client and client_fn
 class FlowerClient(NumPyClient):
-    def __init__(self):
+    def __init__(self, input_dim):
         self.train_x, self.train_y, self.test_x, self.test_y = load_data()
         self.grad_fn = jax.grad(loss_fn)
-        model_shape = self.train_x.shape[1:]
-
-        self.params = load_model(model_shape)
-
-    def get_parameters(self, config):
-        return get_params(self.params)
-
-    def set_parameters(self, parameters):
-        set_params(self.params, parameters)
+        self.params = load_model((input_dim,))
 
     def fit(self, parameters, config):
-        self.set_parameters(parameters)
+        set_params(self.params, parameters)
         self.params, loss, num_examples = train(
             self.params, self.grad_fn, self.train_x, self.train_y
         )
-        parameters = self.get_parameters(config={})
-        return parameters, num_examples, {"loss": float(loss)}
+        return get_params(self.params), num_examples, {"loss": float(loss)}
 
     def evaluate(self, parameters, config):
-        self.set_parameters(parameters)
+        set_params(self.params, parameters)
         loss, num_examples = evaluation(
             self.params, self.grad_fn, self.test_x, self.test_y
         )
         return float(loss), num_examples, {"loss": float(loss)}
 
+
 def client_fn(context: Context):
+    input_dim = context.run_config["input-dim"]
+
     # Return Client instance
-    return FlowerClient().to_client()
+    return FlowerClient(input_dim).to_client()
 
 
 # Flower ClientApp

{flwr_nightly-1.12.0.dev20241007 → flwr_nightly-1.12.0.dev20241010}/src/py/flwr/cli/new/templates/app/code/client.mlx.py.tpl

@@ -3,17 +3,18 @@
 import mlx.core as mx
 import mlx.nn as nn
 import mlx.optimizers as optim
-from flwr.client import NumPyClient, ClientApp
-from flwr.common import Context
 
+from flwr.client import ClientApp, NumPyClient
+from flwr.common import Context
+from flwr.common.config import UserConfig
 from $import_name.task import (
+    MLP,
     batch_iterate,
     eval_fn,
     get_params,
     load_data,
     loss_fn,
     set_params,
-    MLP,
 )
 
 
@@ -22,37 +23,24 @@ class FlowerClient(NumPyClient):
     def __init__(
         self,
         data,
-        num_layers,
-        hidden_dim,
+        run_config: UserConfig,
         num_classes,
-        batch_size,
-        learning_rate,
-        num_epochs,
     ):
-        self.num_layers = num_layers
-        self.hidden_dim = hidden_dim
-        self.num_classes = num_classes
-        self.batch_size = batch_size
-        self.learning_rate = learning_rate
-        self.num_epochs = num_epochs
+        num_layers = run_config["num-layers"]
+        hidden_dim = run_config["hidden-dim"]
+        input_dim = run_config["input-dim"]
+        batch_size = run_config["batch-size"]
+        learning_rate = run_config["lr"]
+        self.num_epochs = run_config["local-epochs"]
 
         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.model = MLP(num_layers, input_dim, 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)
+        set_params(self.model, parameters)
         for _ in range(self.num_epochs):
             for X, y in batch_iterate(
                 self.batch_size, self.train_images, self.train_labels
@@ -60,10 +48,10 @@ class FlowerClient(NumPyClient):
                 _, 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), {}
+        return get_params(self.model), len(self.train_images), {}
 
     def evaluate(self, parameters, config):
-        self.set_parameters(parameters)
+        set_params(self.model, 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()}
@@ -73,18 +61,10 @@ def client_fn(context: Context):
     partition_id = context.node_config["partition-id"]
     num_partitions = context.node_config["num-partitions"]
     data = load_data(partition_id, num_partitions)
-
-    num_layers = context.run_config["num-layers"]
-    hidden_dim = context.run_config["hidden-dim"]
     num_classes = 10
-    batch_size = context.run_config["batch-size"]
-    learning_rate = context.run_config["lr"]
-    num_epochs = context.run_config["local-epochs"]
 
     # Return Client instance
-    return FlowerClient(
-        data, num_layers, hidden_dim, num_classes, batch_size, learning_rate, num_epochs
-    ).to_client()
+    return FlowerClient(data, context.run_config, num_classes).to_client()
 
 
 # Flower ClientApp

{flwr_nightly-1.12.0.dev20241007 → flwr_nightly-1.12.0.dev20241010}/src/py/flwr/cli/new/templates/app/code/client.numpy.py.tpl

@@ -1,16 +1,15 @@
 """$project_name: A Flower / $framework_str app."""
 
-from flwr.client import NumPyClient, ClientApp
+from flwr.client import ClientApp, NumPyClient
 from flwr.common import Context
-import numpy as np
+from $import_name.task import get_dummy_model
 
 
 class FlowerClient(NumPyClient):
-    def get_parameters(self, config):
-        return [np.ones((1, 1))]
 
     def fit(self, parameters, config):
-        return ([np.ones((1, 1))], 1, {})
+        model = get_dummy_model()
+        return [model], 1, {}
 
     def evaluate(self, parameters, config):
         return float(0.0), 1, {"accuracy": float(1.0)}

{flwr_nightly-1.12.0.dev20241007 → flwr_nightly-1.12.0.dev20241010}/src/py/flwr/cli/new/templates/app/code/client.pytorch.py.tpl

@@ -1,17 +1,10 @@
 """$project_name: A Flower / $framework_str app."""
 
 import torch
-from flwr.client import NumPyClient, ClientApp
-from flwr.common import Context
 
-from $import_name.task import (
-    Net,
-    load_data,
-    get_weights,
-    set_weights,
-    train,
-    test,
-)
+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
@@ -32,7 +25,11 @@ class FlowerClient(NumPyClient):
             self.local_epochs,
             self.device,
         )
-        return get_weights(self.net), len(self.trainloader.dataset), {"train_loss": train_loss}
+        return (
+            get_weights(self.net),
+            len(self.trainloader.dataset),
+            {"train_loss": train_loss},
+        )
 
     def evaluate(self, parameters, config):
         set_weights(self.net, parameters)

flwr_nightly-1.12.0.dev20241010/src/py/flwr/cli/new/templates/app/code/client.sklearn.py.tpl

@@ -0,0 +1,63 @@
+"""$project_name: A Flower / $framework_str app."""
+
+import warnings
+
+from sklearn.metrics import log_loss
+
+from flwr.client import ClientApp, NumPyClient
+from flwr.common import Context
+from $import_name.task import (
+    get_model,
+    get_model_params,
+    load_data,
+    set_initial_params,
+    set_model_params,
+)
+
+
+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)
+
+        # 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_params(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}
+
+
+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)
+
+    # 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 FlowerClient(model, X_train, X_test, y_train, y_test).to_client()
+
+
+# Flower ClientApp
+app = ClientApp(client_fn=client_fn)

{flwr_nightly-1.12.0.dev20241007 → flwr_nightly-1.12.0.dev20241010}/src/py/flwr/cli/new/templates/app/code/server.jax.py.tpl

@@ -1,16 +1,22 @@
 """$project_name: A Flower / $framework_str app."""
 
-from flwr.common import Context
-from flwr.server.strategy import FedAvg
+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 get_params, load_model
 
 
 def server_fn(context: Context):
     # Read from config
     num_rounds = context.run_config["num-server-rounds"]
+    input_dim = context.run_config["input-dim"]
+
+    # Initialize global model
+    params = get_params(load_model((input_dim,)))
+    initial_parameters = ndarrays_to_parameters(params)
 
     # Define strategy
-    strategy = FedAvg()
+    strategy = FedAvg(initial_parameters=initial_parameters)
     config = ServerConfig(num_rounds=num_rounds)
 
     return ServerAppComponents(strategy=strategy, config=config)

flwr_nightly-1.12.0.dev20241010/src/py/flwr/cli/new/templates/app/code/server.mlx.py.tpl

@@ -0,0 +1,31 @@
+"""$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 MLP, get_params
+
+
+def server_fn(context: Context):
+    # Read from config
+    num_rounds = context.run_config["num-server-rounds"]
+
+    num_classes = 10
+    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, num_classes)
+    params = get_params(model)
+    initial_parameters = ndarrays_to_parameters(params)
+
+    # Define strategy
+    strategy = FedAvg(initial_parameters=initial_parameters)
+    config = ServerConfig(num_rounds=num_rounds)
+
+    return ServerAppComponents(strategy=strategy, config=config)
+
+
+# Create ServerApp
+app = ServerApp(server_fn=server_fn)