flwr-nightly 1.8.0.dev20240227__py3-none-any.whl → 1.8.0.dev20240229__py3-none-any.whl

flwr/server/workflow/default_workflows.py

@@ -0,0 +1,357 @@
+# 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.
+# ==============================================================================
+"""Legacy default workflows."""
+
+
+import timeit
+from logging import DEBUG, INFO
+from typing import Optional, cast
+
+import flwr.common.recordset_compat as compat
+from flwr.common import ConfigsRecord, Context, GetParametersIns, log
+from flwr.common.constant import (
+    MESSAGE_TYPE_EVALUATE,
+    MESSAGE_TYPE_FIT,
+    MESSAGE_TYPE_GET_PARAMETERS,
+)
+
+from ..compat.app_utils import start_update_client_manager_thread
+from ..compat.legacy_context import LegacyContext
+from ..driver import Driver
+from ..typing import Workflow
+
+KEY_CURRENT_ROUND = "current_round"
+KEY_START_TIME = "start_time"
+CONFIGS_RECORD_KEY = "config"
+PARAMS_RECORD_KEY = "parameters"
+
+
+class DefaultWorkflow:
+    """Default workflow in Flower."""
+
+    def __init__(
+        self,
+        fit_workflow: Optional[Workflow] = None,
+        evaluate_workflow: Optional[Workflow] = None,
+    ) -> None:
+        if fit_workflow is None:
+            fit_workflow = default_fit_workflow
+        if evaluate_workflow is None:
+            evaluate_workflow = default_evaluate_workflow
+        self.fit_workflow: Workflow = fit_workflow
+        self.evaluate_workflow: Workflow = evaluate_workflow
+
+    def __call__(self, driver: Driver, context: Context) -> None:
+        """Execute the workflow."""
+        if not isinstance(context, LegacyContext):
+            raise TypeError(
+                f"Expect a LegacyContext, but get {type(context).__name__}."
+            )
+
+        # Start the thread updating nodes
+        thread, f_stop = start_update_client_manager_thread(
+            driver, context.client_manager
+        )
+
+        # Initialize parameters
+        default_init_params_workflow(driver, context)
+
+        # Run federated learning for num_rounds
+        log(INFO, "FL starting")
+        start_time = timeit.default_timer()
+        cfg = ConfigsRecord()
+        cfg[KEY_START_TIME] = start_time
+        context.state.configs_records[CONFIGS_RECORD_KEY] = cfg
+
+        for current_round in range(1, context.config.num_rounds + 1):
+            cfg[KEY_CURRENT_ROUND] = current_round
+
+            # Fit round
+            self.fit_workflow(driver, context)
+
+            # Centralized evaluation
+            default_centralized_evaluation_workflow(driver, context)
+
+            # Evaluate round
+            self.evaluate_workflow(driver, context)
+
+        # Bookkeeping
+        end_time = timeit.default_timer()
+        elapsed = end_time - start_time
+        log(INFO, "FL finished in %s", elapsed)
+
+        # Log results
+        hist = context.history
+        log(INFO, "app_fit: losses_distributed %s", str(hist.losses_distributed))
+        log(
+            INFO,
+            "app_fit: metrics_distributed_fit %s",
+            str(hist.metrics_distributed_fit),
+        )
+        log(INFO, "app_fit: metrics_distributed %s", str(hist.metrics_distributed))
+        log(INFO, "app_fit: losses_centralized %s", str(hist.losses_centralized))
+        log(INFO, "app_fit: metrics_centralized %s", str(hist.metrics_centralized))
+
+        # Terminate the thread
+        f_stop.set()
+        del driver
+        thread.join()
+
+
+def default_init_params_workflow(driver: Driver, context: Context) -> None:
+    """Execute the default workflow for parameters initialization."""
+    if not isinstance(context, LegacyContext):
+        raise TypeError(f"Expect a LegacyContext, but get {type(context).__name__}.")
+
+    log(INFO, "Initializing global parameters")
+    parameters = context.strategy.initialize_parameters(
+        client_manager=context.client_manager
+    )
+    if parameters is not None:
+        log(INFO, "Using initial parameters provided by strategy")
+        paramsrecord = compat.parameters_to_parametersrecord(
+            parameters, keep_input=True
+        )
+    else:
+        # Get initial parameters from one of the clients
+        log(INFO, "Requesting initial parameters from one random client")
+        random_client = context.client_manager.sample(1)[0]
+        # Send GetParametersIns and get the response
+        content = compat.getparametersins_to_recordset(GetParametersIns({}))
+        messages = driver.send_and_receive(
+            [
+                driver.create_message(
+                    content=content,
+                    message_type=MESSAGE_TYPE_GET_PARAMETERS,
+                    dst_node_id=random_client.node_id,
+                    group_id="",
+                    ttl="",
+                )
+            ]
+        )
+        log(INFO, "Received initial parameters from one random client")
+        msg = list(messages)[0]
+        paramsrecord = next(iter(msg.content.parameters_records.values()))
+
+    context.state.parameters_records[PARAMS_RECORD_KEY] = paramsrecord
+
+    # Evaluate initial parameters
+    log(INFO, "Evaluating initial parameters")
+    parameters = compat.parametersrecord_to_parameters(paramsrecord, keep_input=True)
+    res = context.strategy.evaluate(0, parameters=parameters)
+    if res is not None:
+        log(
+            INFO,
+            "initial parameters (loss, other metrics): %s, %s",
+            res[0],
+            res[1],
+        )
+        context.history.add_loss_centralized(server_round=0, loss=res[0])
+        context.history.add_metrics_centralized(server_round=0, metrics=res[1])
+
+
+def default_centralized_evaluation_workflow(_: Driver, context: Context) -> None:
+    """Execute the default workflow for centralized evaluation."""
+    if not isinstance(context, LegacyContext):
+        raise TypeError(f"Expect a LegacyContext, but get {type(context).__name__}.")
+
+    # Retrieve current_round and start_time from the context
+    cfg = context.state.configs_records[CONFIGS_RECORD_KEY]
+    current_round = cast(int, cfg[KEY_CURRENT_ROUND])
+    start_time = cast(float, cfg[KEY_START_TIME])
+
+    # Centralized evaluation
+    parameters = compat.parametersrecord_to_parameters(
+        record=context.state.parameters_records[PARAMS_RECORD_KEY],
+        keep_input=True,
+    )
+    res_cen = context.strategy.evaluate(current_round, parameters=parameters)
+    if res_cen is not None:
+        loss_cen, metrics_cen = res_cen
+        log(
+            INFO,
+            "fit progress: (%s, %s, %s, %s)",
+            current_round,
+            loss_cen,
+            metrics_cen,
+            timeit.default_timer() - start_time,
+        )
+        context.history.add_loss_centralized(server_round=current_round, loss=loss_cen)
+        context.history.add_metrics_centralized(
+            server_round=current_round, metrics=metrics_cen
+        )
+
+
+def default_fit_workflow(driver: Driver, context: Context) -> None:
+    """Execute the default workflow for a single fit round."""
+    if not isinstance(context, LegacyContext):
+        raise TypeError(f"Expect a LegacyContext, but get {type(context).__name__}.")
+
+    # Get current_round and parameters
+    cfg = context.state.configs_records[CONFIGS_RECORD_KEY]
+    current_round = cast(int, cfg[KEY_CURRENT_ROUND])
+    parametersrecord = context.state.parameters_records[PARAMS_RECORD_KEY]
+    parameters = compat.parametersrecord_to_parameters(
+        parametersrecord, keep_input=True
+    )
+
+    # Get clients and their respective instructions from strategy
+    client_instructions = context.strategy.configure_fit(
+        server_round=current_round,
+        parameters=parameters,
+        client_manager=context.client_manager,
+    )
+
+    if not client_instructions:
+        log(INFO, "fit_round %s: no clients selected, cancel", current_round)
+        return
+    log(
+        DEBUG,
+        "fit_round %s: strategy sampled %s clients (out of %s)",
+        current_round,
+        len(client_instructions),
+        context.client_manager.num_available(),
+    )
+
+    # Build dictionary mapping node_id to ClientProxy
+    node_id_to_proxy = {proxy.node_id: proxy for proxy, _ in client_instructions}
+
+    # Build out messages
+    out_messages = [
+        driver.create_message(
+            content=compat.fitins_to_recordset(fitins, True),
+            message_type=MESSAGE_TYPE_FIT,
+            dst_node_id=proxy.node_id,
+            group_id="",
+            ttl="",
+        )
+        for proxy, fitins in client_instructions
+    ]
+
+    # Send instructions to clients and
+    # collect `fit` results from all clients participating in this round
+    messages = list(driver.send_and_receive(out_messages))
+    del out_messages
+
+    # No exception/failure handling currently
+    log(
+        DEBUG,
+        "fit_round %s received %s results and %s failures",
+        current_round,
+        len(messages),
+        0,
+    )
+
+    # Aggregate training results
+    results = [
+        (
+            node_id_to_proxy[msg.metadata.src_node_id],
+            compat.recordset_to_fitres(msg.content, False),
+        )
+        for msg in messages
+    ]
+    aggregated_result = context.strategy.aggregate_fit(current_round, results, [])
+    parameters_aggregated, metrics_aggregated = aggregated_result
+
+    # Update the parameters and write history
+    if parameters_aggregated:
+        paramsrecord = compat.parameters_to_parametersrecord(
+            parameters_aggregated, True
+        )
+        context.state.parameters_records[PARAMS_RECORD_KEY] = paramsrecord
+        context.history.add_metrics_distributed_fit(
+            server_round=current_round, metrics=metrics_aggregated
+        )
+
+
+def default_evaluate_workflow(driver: Driver, context: Context) -> None:
+    """Execute the default workflow for a single evaluate round."""
+    if not isinstance(context, LegacyContext):
+        raise TypeError(f"Expect a LegacyContext, but get {type(context).__name__}.")
+
+    # Get current_round and parameters
+    cfg = context.state.configs_records[CONFIGS_RECORD_KEY]
+    current_round = cast(int, cfg[KEY_CURRENT_ROUND])
+    parametersrecord = context.state.parameters_records[PARAMS_RECORD_KEY]
+    parameters = compat.parametersrecord_to_parameters(
+        parametersrecord, keep_input=True
+    )
+
+    # Get clients and their respective instructions from strategy
+    client_instructions = context.strategy.configure_evaluate(
+        server_round=current_round,
+        parameters=parameters,
+        client_manager=context.client_manager,
+    )
+    if not client_instructions:
+        log(INFO, "evaluate_round %s: no clients selected, cancel", current_round)
+        return
+    log(
+        DEBUG,
+        "evaluate_round %s: strategy sampled %s clients (out of %s)",
+        current_round,
+        len(client_instructions),
+        context.client_manager.num_available(),
+    )
+
+    # Build dictionary mapping node_id to ClientProxy
+    node_id_to_proxy = {proxy.node_id: proxy for proxy, _ in client_instructions}
+
+    # Build out messages
+    out_messages = [
+        driver.create_message(
+            content=compat.evaluateins_to_recordset(evalins, True),
+            message_type=MESSAGE_TYPE_EVALUATE,
+            dst_node_id=proxy.node_id,
+            group_id="",
+            ttl="",
+        )
+        for proxy, evalins in client_instructions
+    ]
+
+    # Send instructions to clients and
+    # collect `evaluate` results from all clients participating in this round
+    messages = list(driver.send_and_receive(out_messages))
+    del out_messages
+
+    # No exception/failure handling currently
+    log(
+        DEBUG,
+        "evaluate_round %s received %s results and %s failures",
+        current_round,
+        len(messages),
+        0,
+    )
+
+    # Aggregate the evaluation results
+    results = [
+        (
+            node_id_to_proxy[msg.metadata.src_node_id],
+            compat.recordset_to_evaluateres(msg.content),
+        )
+        for msg in messages
+    ]
+    aggregated_result = context.strategy.aggregate_evaluate(current_round, results, [])
+
+    loss_aggregated, metrics_aggregated = aggregated_result
+
+    # Write history
+    if loss_aggregated is not None:
+        context.history.add_loss_distributed(
+            server_round=current_round, loss=loss_aggregated
+        )
+        context.history.add_metrics_distributed(
+            server_round=current_round, metrics=metrics_aggregated
+        )

flwr/simulation/__init__.py

@@ -17,6 +17,8 @@
 
 import importlib
 
+from flwr.simulation.run_simulation import run_simulation
+
 is_ray_installed = importlib.util.find_spec("ray") is not None
 
 if is_ray_installed:
@@ -36,4 +38,5 @@ To install the necessary dependencies, install `flwr` with the `simulation` extr
 
 __all__ = [
     "start_simulation",
+    "run_simulation",
 ]

flwr/simulation/ray_transport/ray_client_proxy.py

@@ -98,6 +98,7 @@ class RayActorClientProxy(ClientProxy):
         recordset: RecordSet,
         message_type: str,
         timeout: Optional[float],
+        group_id: Optional[int],
     ) -> Message:
         """Wrap a RecordSet inside a Message."""
         return Message(
@@ -105,7 +106,7 @@ class RayActorClientProxy(ClientProxy):
             metadata=Metadata(
                 run_id=0,
                 message_id="",
-                group_id="",
+                group_id=str(group_id) if group_id is not None else "",
                 src_node_id=0,
                 dst_node_id=int(self.cid),
                 reply_to_message="",
@@ -116,7 +117,10 @@ class RayActorClientProxy(ClientProxy):
         )
 
     def get_properties(
-        self, ins: common.GetPropertiesIns, timeout: Optional[float]
+        self,
+        ins: common.GetPropertiesIns,
+        timeout: Optional[float],
+        group_id: Optional[int],
     ) -> common.GetPropertiesRes:
         """Return client's properties."""
         recordset = getpropertiesins_to_recordset(ins)
@@ -124,6 +128,7 @@ class RayActorClientProxy(ClientProxy):
             recordset,
             message_type=MESSAGE_TYPE_GET_PROPERTIES,
             timeout=timeout,
+            group_id=group_id,
         )
 
         message_out = self._submit_job(message, timeout)
@@ -131,7 +136,10 @@ class RayActorClientProxy(ClientProxy):
         return recordset_to_getpropertiesres(message_out.content)
 
     def get_parameters(
-        self, ins: common.GetParametersIns, timeout: Optional[float]
+        self,
+        ins: common.GetParametersIns,
+        timeout: Optional[float],
+        group_id: Optional[int],
     ) -> common.GetParametersRes:
         """Return the current local model parameters."""
         recordset = getparametersins_to_recordset(ins)
@@ -139,19 +147,25 @@ class RayActorClientProxy(ClientProxy):
             recordset,
             message_type=MESSAGE_TYPE_GET_PARAMETERS,
             timeout=timeout,
+            group_id=group_id,
         )
 
         message_out = self._submit_job(message, timeout)
 
         return recordset_to_getparametersres(message_out.content, keep_input=False)
 
-    def fit(self, ins: common.FitIns, timeout: Optional[float]) -> common.FitRes:
+    def fit(
+        self, ins: common.FitIns, timeout: Optional[float], group_id: Optional[int]
+    ) -> common.FitRes:
         """Train model parameters on the locally held dataset."""
         recordset = fitins_to_recordset(
             ins, keep_input=True
         )  # This must stay TRUE since ins are in-memory
         message = self._wrap_recordset_in_message(
-            recordset, message_type=MESSAGE_TYPE_FIT, timeout=timeout
+            recordset,
+            message_type=MESSAGE_TYPE_FIT,
+            timeout=timeout,
+            group_id=group_id,
         )
 
         message_out = self._submit_job(message, timeout)
@@ -159,14 +173,17 @@ class RayActorClientProxy(ClientProxy):
         return recordset_to_fitres(message_out.content, keep_input=False)
 
     def evaluate(
-        self, ins: common.EvaluateIns, timeout: Optional[float]
+        self, ins: common.EvaluateIns, timeout: Optional[float], group_id: Optional[int]
     ) -> common.EvaluateRes:
         """Evaluate model parameters on the locally held dataset."""
         recordset = evaluateins_to_recordset(
             ins, keep_input=True
         )  # This must stay TRUE since ins are in-memory
         message = self._wrap_recordset_in_message(
-            recordset, message_type=MESSAGE_TYPE_EVALUATE, timeout=timeout
+            recordset,
+            message_type=MESSAGE_TYPE_EVALUATE,
+            timeout=timeout,
+            group_id=group_id,
         )
 
         message_out = self._submit_job(message, timeout)
@@ -174,7 +191,10 @@ class RayActorClientProxy(ClientProxy):
         return recordset_to_evaluateres(message_out.content)
 
     def reconnect(
-        self, ins: common.ReconnectIns, timeout: Optional[float]
+        self,
+        ins: common.ReconnectIns,
+        timeout: Optional[float],
+        group_id: Optional[int],
     ) -> common.DisconnectRes:
         """Disconnect and (optionally) reconnect later."""
         return common.DisconnectRes(reason="")  # Nothing to do here (yet)

flwr/simulation/run_simulation.py

@@ -0,0 +1,177 @@
+# 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 Simulation."""
+
+import argparse
+import asyncio
+import json
+import threading
+import traceback
+from logging import ERROR, INFO, WARNING
+
+import grpc
+
+from flwr.common import EventType, event, log
+from flwr.common.exit_handlers import register_exit_handlers
+from flwr.server.driver.driver import Driver
+from flwr.server.run_serverapp import run
+from flwr.server.superlink.driver.driver_grpc import run_driver_api_grpc
+from flwr.server.superlink.fleet import vce
+from flwr.server.superlink.state import StateFactory
+from flwr.simulation.ray_transport.utils import enable_tf_gpu_growth
+
+
+def run_simulation() -> None:
+    """Run Simulation Engine."""
+    args = _parse_args_run_simulation().parse_args()
+
+    # Load JSON config
+    backend_config_dict = json.loads(args.backend_config)
+
+    # Enable GPU memory growth (relevant only for TF)
+    if args.enable_tf_gpu_growth:
+        log(INFO, "Enabling GPU growth for Tensorflow on the main thread.")
+        enable_tf_gpu_growth()
+        # Check that Backend config has also enabled using GPU growth
+        use_tf = backend_config_dict.get("tensorflow", False)
+        if not use_tf:
+            log(WARNING, "Enabling GPU growth for your backend.")
+            backend_config_dict["tensorflow"] = True
+
+    # Convert back to JSON stream
+    backend_config = json.dumps(backend_config_dict)
+
+    # Initialize StateFactory
+    state_factory = StateFactory(":flwr-in-memory-state:")
+
+    # Start Driver API
+    driver_server: grpc.Server = run_driver_api_grpc(
+        address=args.driver_api_address,
+        state_factory=state_factory,
+        certificates=None,
+    )
+
+    # SuperLink with Simulation Engine
+    f_stop = asyncio.Event()
+    superlink_th = threading.Thread(
+        target=vce.start_vce,
+        kwargs={
+            "num_supernodes": args.num_supernodes,
+            "client_app_module_name": args.client_app,
+            "backend_name": args.backend,
+            "backend_config_json_stream": backend_config,
+            "working_dir": args.dir,
+            "state_factory": state_factory,
+            "f_stop": f_stop,
+        },
+        daemon=False,
+    )
+
+    superlink_th.start()
+    event(EventType.RUN_SUPERLINK_ENTER)
+
+    try:
+        # Initialize Driver
+        driver = Driver(
+            driver_service_address=args.driver_api_address,
+            root_certificates=None,
+        )
+
+        # Launch server app
+        run(args.server_app, driver, args.dir)
+
+    except Exception as ex:
+
+        log(ERROR, "An exception occurred: %s", ex)
+        log(ERROR, traceback.format_exc())
+        raise RuntimeError(
+            "An error was encountered by the Simulation Engine. Ending simulation."
+        ) from ex
+
+    finally:
+
+        del driver
+
+        # Trigger stop event
+        f_stop.set()
+
+        register_exit_handlers(
+            grpc_servers=[driver_server],
+            bckg_threads=[superlink_th],
+            event_type=EventType.RUN_SUPERLINK_LEAVE,
+        )
+        superlink_th.join()
+
+
+def _parse_args_run_simulation() -> argparse.ArgumentParser:
+    """Parse flower-simulation command line arguments."""
+    parser = argparse.ArgumentParser(
+        description="Start a Flower simulation",
+    )
+    parser.add_argument(
+        "--client-app",
+        required=True,
+        help="For example: `client:app` or `project.package.module:wrapper.app`",
+    )
+    parser.add_argument(
+        "--server-app",
+        required=True,
+        help="For example: `server:app` or `project.package.module:wrapper.app`",
+    )
+    parser.add_argument(
+        "--driver-api-address",
+        default="0.0.0.0:9091",
+        type=str,
+        help="For example: `server:app` or `project.package.module:wrapper.app`",
+    )
+    parser.add_argument(
+        "--num-supernodes",
+        type=int,
+        required=True,
+        help="Number of simulated SuperNodes.",
+    )
+    parser.add_argument(
+        "--backend",
+        default="ray",
+        type=str,
+        help="Simulation backend that executes the ClientApp.",
+    )
+    parser.add_argument(
+        "--enable-tf-gpu-growth",
+        action="store_true",
+        help="Enables GPU growth on the main thread. This is desirable if you make "
+        "use of a TensorFlow model on your `ServerApp` while having your `ClientApp` "
+        "running on the same GPU. Without enabling this, you might encounter an "
+        "out-of-memory error becasue TensorFlow by default allocates all GPU memory."
+        "Read mor about how `tf.config.experimental.set_memory_growth()` works in "
+        "the TensorFlow documentation: https://www.tensorflow.org/api/stable.",
+    )
+    parser.add_argument(
+        "--backend-config",
+        type=str,
+        default='{"client_resources": {"num_cpus":2, "num_gpus":0.0}, "tensorflow": 0}',
+        help='A JSON formatted stream, e.g \'{"<keyA>":<value>, "<keyB>":<value>}\' to '
+        "configure a backend. Values supported in <value> are those included by "
+        "`flwr.common.typing.ConfigsRecordValues`. ",
+    )
+    parser.add_argument(
+        "--dir",
+        default="",
+        help="Add specified directory to the PYTHONPATH and load"
+        "ClientApp and ServerApp from there."
+        " Default: current working directory.",
+    )
+
+    return parser

{flwr_nightly-1.8.0.dev20240227.dist-info → flwr_nightly-1.8.0.dev20240229.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: flwr-nightly
-Version: 1.8.0.dev20240227
+Version: 1.8.0.dev20240229
 Summary: Flower: A Friendly Federated Learning Framework
 Home-page: https://flower.ai
 License: Apache-2.0
@@ -32,7 +32,7 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Typing :: Typed
 Provides-Extra: rest
 Provides-Extra: simulation
-Requires-Dist: cryptography (>=41.0.2,<42.0.0)
+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)
@@ -83,7 +83,7 @@ design of Flower is based on a few guiding principles:
 
 - **Framework-agnostic**: Different machine learning frameworks have different
   strengths. Flower can be used with any machine learning framework, for
-  example, [PyTorch](https://pytorch.org), [TensorFlow](https://tensorflow.org), [Hugging Face Transformers](https://huggingface.co/), [PyTorch Lightning](https://pytorchlightning.ai/), [scikit-learn](https://scikit-learn.org/), [JAX](https://jax.readthedocs.io/), [TFLite](https://tensorflow.org/lite/), [fastai](https://www.fast.ai/), [MLX](https://ml-explore.github.io/mlx/build/html/index.html), [XGBoost](https://xgboost.readthedocs.io/en/stable/), [Pandas](https://pandas.pydata.org/) for federated analytics, or even raw [NumPy](https://numpy.org/)
+  example, [PyTorch](https://pytorch.org), [TensorFlow](https://tensorflow.org), [Hugging Face Transformers](https://huggingface.co/), [PyTorch Lightning](https://pytorchlightning.ai/), [scikit-learn](https://scikit-learn.org/), [JAX](https://jax.readthedocs.io/), [TFLite](https://tensorflow.org/lite/), [MONAI](https://docs.monai.io/en/latest/index.html), [fastai](https://www.fast.ai/), [MLX](https://ml-explore.github.io/mlx/build/html/index.html), [XGBoost](https://xgboost.readthedocs.io/en/stable/), [Pandas](https://pandas.pydata.org/) for federated analytics, or even raw [NumPy](https://numpy.org/)
   for users who enjoy computing gradients by hand.
 
 - **Understandable**: Flower is written with maintainability in mind. The
@@ -180,6 +180,7 @@ Quickstart examples:
 - [Quickstart (fastai)](https://github.com/adap/flower/tree/main/examples/quickstart-fastai)
 - [Quickstart (Pandas)](https://github.com/adap/flower/tree/main/examples/quickstart-pandas)
 - [Quickstart (JAX)](https://github.com/adap/flower/tree/main/examples/quickstart-jax)
+- [Quickstart (MONAI)](https://github.com/adap/flower/tree/main/examples/quickstart-monai)
 - [Quickstart (scikit-learn)](https://github.com/adap/flower/tree/main/examples/sklearn-logreg-mnist)
 - [Quickstart (XGBoost)](https://github.com/adap/flower/tree/main/examples/xgboost-quickstart)
 - [Quickstart (Android [TFLite])](https://github.com/adap/flower/tree/main/examples/android)