flwr-nightly 1.11.0.dev20240822__py3-none-any.whl → 1.11.1.dev20240912__py3-none-any.whl

flwr/server/superlink/state/in_memory_state.py

@@ -45,7 +45,7 @@ class InMemoryState(State):  # pylint: disable=R0902,R0904
         self.task_ins_store: Dict[UUID, TaskIns] = {}
         self.task_res_store: Dict[UUID, TaskRes] = {}
 
-        self.client_public_keys: Set[bytes] = set()
+        self.node_public_keys: Set[bytes] = set()
         self.server_public_key: Optional[bytes] = None
         self.server_private_key: Optional[bytes] = None
 
@@ -237,7 +237,7 @@ class InMemoryState(State):  # pylint: disable=R0902,R0904
             return node_id
 
     def delete_node(self, node_id: int, public_key: Optional[bytes] = None) -> None:
-        """Delete a client node."""
+        """Delete a node."""
         with self.lock:
             if node_id not in self.node_ids:
                 raise ValueError(f"Node {node_id} not found")
@@ -254,7 +254,7 @@ class InMemoryState(State):  # pylint: disable=R0902,R0904
             del self.node_ids[node_id]
 
     def get_nodes(self, run_id: int) -> Set[int]:
-        """Return all available client nodes.
+        """Return all available nodes.
 
         Constraints
         -----------
@@ -271,9 +271,9 @@ class InMemoryState(State):  # pylint: disable=R0902,R0904
                 if online_until > current_time
             }
 
-    def get_node_id(self, client_public_key: bytes) -> Optional[int]:
-        """Retrieve stored `node_id` filtered by `client_public_keys`."""
-        return self.public_key_to_node_id.get(client_public_key)
+    def get_node_id(self, node_public_key: bytes) -> Optional[int]:
+        """Retrieve stored `node_id` filtered by `node_public_keys`."""
+        return self.public_key_to_node_id.get(node_public_key)
 
     def create_run(
         self,
@@ -318,19 +318,19 @@ class InMemoryState(State):  # pylint: disable=R0902,R0904
         """Retrieve `server_public_key` in urlsafe bytes."""
         return self.server_public_key
 
-    def store_client_public_keys(self, public_keys: Set[bytes]) -> None:
-        """Store a set of `client_public_keys` in state."""
+    def store_node_public_keys(self, public_keys: Set[bytes]) -> None:
+        """Store a set of `node_public_keys` in state."""
         with self.lock:
-            self.client_public_keys = public_keys
+            self.node_public_keys = public_keys
 
-    def store_client_public_key(self, public_key: bytes) -> None:
-        """Store a `client_public_key` in state."""
+    def store_node_public_key(self, public_key: bytes) -> None:
+        """Store a `node_public_key` in state."""
         with self.lock:
-            self.client_public_keys.add(public_key)
+            self.node_public_keys.add(public_key)
 
-    def get_client_public_keys(self) -> Set[bytes]:
-        """Retrieve all currently stored `client_public_keys` as a set."""
-        return self.client_public_keys
+    def get_node_public_keys(self) -> Set[bytes]:
+        """Retrieve all currently stored `node_public_keys` as a set."""
+        return self.node_public_keys
 
     def get_run(self, run_id: int) -> Optional[Run]:
         """Retrieve information about the run with the specified `run_id`."""

flwr/server/superlink/state/sqlite_state.py

@@ -569,7 +569,7 @@ class SqliteState(State):  # pylint: disable=R0904
         return node_id
 
     def delete_node(self, node_id: int, public_key: Optional[bytes] = None) -> None:
-        """Delete a client node."""
+        """Delete a node."""
         query = "DELETE FROM node WHERE node_id = ?"
         params = (node_id,)
 
@@ -607,10 +607,10 @@ class SqliteState(State):  # pylint: disable=R0904
         result: Set[int] = {row["node_id"] for row in rows}
         return result
 
-    def get_node_id(self, client_public_key: bytes) -> Optional[int]:
-        """Retrieve stored `node_id` filtered by `client_public_keys`."""
+    def get_node_id(self, node_public_key: bytes) -> Optional[int]:
+        """Retrieve stored `node_id` filtered by `node_public_keys`."""
         query = "SELECT node_id FROM node WHERE public_key = :public_key;"
-        row = self.query(query, {"public_key": client_public_key})
+        row = self.query(query, {"public_key": node_public_key})
         if len(row) > 0:
             node_id: int = row[0]["node_id"]
             return node_id
@@ -684,19 +684,19 @@ class SqliteState(State):  # pylint: disable=R0904
             public_key = None
         return public_key
 
-    def store_client_public_keys(self, public_keys: Set[bytes]) -> None:
-        """Store a set of `client_public_keys` in state."""
+    def store_node_public_keys(self, public_keys: Set[bytes]) -> None:
+        """Store a set of `node_public_keys` in state."""
         query = "INSERT INTO public_key (public_key) VALUES (?)"
         data = [(key,) for key in public_keys]
         self.query(query, data)
 
-    def store_client_public_key(self, public_key: bytes) -> None:
-        """Store a `client_public_key` in state."""
+    def store_node_public_key(self, public_key: bytes) -> None:
+        """Store a `node_public_key` in state."""
         query = "INSERT INTO public_key (public_key) VALUES (:public_key)"
         self.query(query, {"public_key": public_key})
 
-    def get_client_public_keys(self) -> Set[bytes]:
-        """Retrieve all currently stored `client_public_keys` as a set."""
+    def get_node_public_keys(self) -> Set[bytes]:
+        """Retrieve all currently stored `node_public_keys` as a set."""
         query = "SELECT public_key FROM public_key"
         rows = self.query(query)
         result: Set[bytes] = {row["public_key"] for row in rows}

flwr/server/superlink/state/state.py

@@ -153,8 +153,8 @@ class State(abc.ABC):  # pylint: disable=R0904
         """
 
     @abc.abstractmethod
-    def get_node_id(self, client_public_key: bytes) -> Optional[int]:
-        """Retrieve stored `node_id` filtered by `client_public_keys`."""
+    def get_node_id(self, node_public_key: bytes) -> Optional[int]:
+        """Retrieve stored `node_id` filtered by `node_public_keys`."""
 
     @abc.abstractmethod
     def create_run(
@@ -199,16 +199,16 @@ class State(abc.ABC):  # pylint: disable=R0904
         """Retrieve `server_public_key` in urlsafe bytes."""
 
     @abc.abstractmethod
-    def store_client_public_keys(self, public_keys: Set[bytes]) -> None:
-        """Store a set of `client_public_keys` in state."""
+    def store_node_public_keys(self, public_keys: Set[bytes]) -> None:
+        """Store a set of `node_public_keys` in state."""
 
     @abc.abstractmethod
-    def store_client_public_key(self, public_key: bytes) -> None:
-        """Store a `client_public_key` in state."""
+    def store_node_public_key(self, public_key: bytes) -> None:
+        """Store a `node_public_key` in state."""
 
     @abc.abstractmethod
-    def get_client_public_keys(self) -> Set[bytes]:
-        """Retrieve all currently stored `client_public_keys` as a set."""
+    def get_node_public_keys(self) -> Set[bytes]:
+        """Retrieve all currently stored `node_public_keys` as a set."""
 
     @abc.abstractmethod
     def acknowledge_ping(self, node_id: int, ping_interval: float) -> bool:

flwr/server/workflow/secure_aggregation/secagg_workflow.py

@@ -35,6 +35,7 @@ class SecAggWorkflow(SecAggPlusWorkflow):
     contributions to compute the weighted average of model parameters.
 
     The protocol involves four main stages:
+
     - 'setup': Send SecAgg configuration to clients and collect their public keys.
     - 'share keys': Broadcast public keys among clients and collect encrypted secret
       key shares.

flwr/server/workflow/secure_aggregation/secaggplus_workflow.py

@@ -99,6 +99,7 @@ class SecAggPlusWorkflow:
     contributions to compute the weighted average of model parameters.
 
     The protocol involves four main stages:
+
     - 'setup': Send SecAgg+ configuration to clients and collect their public keys.
     - 'share keys': Broadcast public keys among clients and collect encrypted secret
       key shares.

flwr/simulation/ray_transport/ray_actor.py

@@ -124,14 +124,14 @@ def pool_size_from_resources(client_resources: Dict[str, Union[int, float]]) ->
             WARNING,
             "The ActorPool is empty. The system (CPUs=%s, GPUs=%s) "
             "does not meet the criteria to host at least one client with resources:"
-            " %s. Lowering the `client_resources` could help.",
+            " %s. Lowering these resources could help.",
             num_cpus,
             num_gpus,
             client_resources,
         )
         raise ValueError(
             "ActorPool is empty. Stopping Simulation. "
-            "Check 'client_resources' passed to `start_simulation`"
+            "Check `num_cpus` and/or `num_gpus` passed to the simulation engine"
         )
 
     return total_num_actors

flwr/simulation/run_simulation.py

@@ -25,7 +25,7 @@ from argparse import Namespace
 from logging import DEBUG, ERROR, INFO, WARNING
 from pathlib import Path
 from time import sleep
-from typing import List, Optional
+from typing import Any, List, Optional
 
 from flwr.cli.config_utils import load_and_validate
 from flwr.client import ClientApp
@@ -35,6 +35,7 @@ from flwr.common.constant import RUN_ID_NUM_BYTES
 from flwr.common.logger import (
     set_logger_propagation,
     update_console_handler,
+    warn_deprecated_feature,
     warn_deprecated_feature_with_example,
 )
 from flwr.common.typing import Run, UserConfig
@@ -91,12 +92,41 @@ def _check_args_do_not_interfere(args: Namespace) -> bool:
     return True
 
 
+def _replace_keys(d: Any, match: str, target: str) -> Any:
+    if isinstance(d, dict):
+        return {
+            k.replace(match, target): _replace_keys(v, match, target)
+            for k, v in d.items()
+        }
+    if isinstance(d, list):
+        return [_replace_keys(i, match, target) for i in d]
+    return d
+
+
 # Entry point from CLI
 # pylint: disable=too-many-locals
 def run_simulation_from_cli() -> None:
     """Run Simulation Engine from the CLI."""
     args = _parse_args_run_simulation().parse_args()
 
+    event(
+        EventType.CLI_FLOWER_SIMULATION_ENTER,
+        event_details={"backend": args.backend, "num-supernodes": args.num_supernodes},
+    )
+
+    # Add warnings for deprecated server_app and client_app arguments
+    if args.server_app:
+        warn_deprecated_feature(
+            "The `--server-app` argument is deprecated. "
+            "Please use the `--app` argument instead."
+        )
+
+    if args.client_app:
+        warn_deprecated_feature(
+            "The `--client-app` argument is deprecated. "
+            "Use the `--app` argument instead."
+        )
+
     if args.enable_tf_gpu_growth:
         warn_deprecated_feature_with_example(
             "Passing `--enable-tf-gpu-growth` is deprecated.",
@@ -105,6 +135,14 @@ def run_simulation_from_cli() -> None:
             code_example='TF_FORCE_GPU_ALLOW_GROWTH="true" flower-simulation <...>',
         )
 
+    # Load JSON config
+    backend_config_dict = json.loads(args.backend_config)
+
+    if backend_config_dict:
+        # Backend config internally operates with `_` not with `-`
+        backend_config_dict = _replace_keys(backend_config_dict, match="-", target="_")
+        log(DEBUG, "backend_config_dict: %s", backend_config_dict)
+
     # We are supporting two modes for the CLI entrypoint:
     # 1) Running an app dir containing a `pyproject.toml`
     # 2) Running any ClientApp and SeverApp w/o pyproject.toml being present
@@ -144,7 +182,9 @@ def run_simulation_from_cli() -> None:
         client_app_attr = app_components["clientapp"]
         server_app_attr = app_components["serverapp"]
 
-        override_config = parse_config_args([args.run_config])
+        override_config = parse_config_args(
+            [args.run_config] if args.run_config else args.run_config
+        )
         fused_config = get_fused_config_from_dir(app_path, override_config)
         app_dir = args.app
         is_app = True
@@ -167,9 +207,6 @@ def run_simulation_from_cli() -> None:
         override_config=override_config,
     )
 
-    # Load JSON config
-    backend_config_dict = json.loads(args.backend_config)
-
     _run_simulation(
         server_app_attr=server_app_attr,
         client_app_attr=client_app_attr,
@@ -179,9 +216,11 @@ def run_simulation_from_cli() -> None:
         app_dir=app_dir,
         run=run,
         enable_tf_gpu_growth=args.enable_tf_gpu_growth,
+        delay_start=args.delay_start,
         verbose_logging=args.verbose,
         server_app_run_config=fused_config,
         is_app=is_app,
+        exit_event=EventType.CLI_FLOWER_SIMULATION_LEAVE,
     )
 
 
@@ -209,9 +248,8 @@ def run_simulation(
         messages sent by the `ServerApp`.
 
     num_supernodes : int
-        Number of nodes that run a ClientApp. They can be sampled by a
-        Driver in the ServerApp and receive a Message describing what the ClientApp
-        should perform.
+        Number of nodes that run a ClientApp. They can be sampled by a Driver in the
+        ServerApp and receive a Message describing what the ClientApp should perform.
 
     backend_name : str (default: ray)
         A simulation backend that runs `ClientApp`s.
@@ -236,10 +274,15 @@ def run_simulation(
         When disabled, only INFO, WARNING and ERROR log messages will be shown. If
         enabled, DEBUG-level logs will be displayed.
     """
+    event(
+        EventType.PYTHON_API_RUN_SIMULATION_ENTER,
+        event_details={"backend": backend_name, "num-supernodes": num_supernodes},
+    )
+
     if enable_tf_gpu_growth:
         warn_deprecated_feature_with_example(
             "Passing `enable_tf_gpu_growth=True` is deprecated.",
-            example_message="Instead, set the `TF_FORCE_GPU_ALLOW_GROWTH` environmnet "
+            example_message="Instead, set the `TF_FORCE_GPU_ALLOW_GROWTH` environment "
             "variable to true.",
             code_example='import os;os.environ["TF_FORCE_GPU_ALLOW_GROWTH"]="true"'
             "\n\tflwr.simulation.run_simulationt(...)",
@@ -253,6 +296,7 @@ def run_simulation(
         backend_config=backend_config,
         enable_tf_gpu_growth=enable_tf_gpu_growth,
         verbose_logging=verbose_logging,
+        exit_event=EventType.PYTHON_API_RUN_SIMULATION_LEAVE,
     )
 
 
@@ -266,7 +310,6 @@ def run_serverapp_th(
     f_stop: threading.Event,
     has_exception: threading.Event,
     enable_tf_gpu_growth: bool,
-    delay_launch: int = 3,
 ) -> threading.Thread:
     """Run SeverApp in a thread."""
 
@@ -322,7 +365,6 @@ def run_serverapp_th(
             server_app,
         ),
     )
-    sleep(delay_launch)
     serverapp_th.start()
     return serverapp_th
 
@@ -336,6 +378,8 @@ def _main_loop(
     is_app: bool,
     enable_tf_gpu_growth: bool,
     run: Run,
+    exit_event: EventType,
+    delay_start: int,
     flwr_dir: Optional[str] = None,
     client_app: Optional[ClientApp] = None,
     client_app_attr: Optional[str] = None,
@@ -343,7 +387,7 @@ def _main_loop(
     server_app_attr: Optional[str] = None,
     server_app_run_config: Optional[UserConfig] = None,
 ) -> None:
-    """Launch SuperLink with Simulation Engine, then ServerApp on a separate thread."""
+    """Start ServerApp on a separate thread, then launch Simulation Engine."""
     # Initialize StateFactory
     state_factory = StateFactory(":flwr-in-memory-state:")
 
@@ -351,6 +395,7 @@ def _main_loop(
     # A Threading event to indicate if an exception was raised in the ServerApp thread
     server_app_thread_has_exception = threading.Event()
     serverapp_th = None
+    success = True
     try:
         # Register run
         log(DEBUG, "Pre-registering run with id %s", run.run_id)
@@ -374,8 +419,10 @@ def _main_loop(
             enable_tf_gpu_growth=enable_tf_gpu_growth,
         )
 
-        # SuperLink with Simulation Engine
-        event(EventType.RUN_SUPERLINK_ENTER)
+        # Buffer time so the `ServerApp` in separate thread is ready
+        log(DEBUG, "Buffer time delay: %ds", delay_start)
+        sleep(delay_start)
+        # Start Simulation Engine
         vce.start_vce(
             num_supernodes=num_supernodes,
             client_app_attr=client_app_attr,
@@ -393,13 +440,13 @@ def _main_loop(
     except Exception as ex:
         log(ERROR, "An exception occurred !! %s", ex)
         log(ERROR, traceback.format_exc())
+        success = False
         raise RuntimeError("An error was encountered. Ending simulation.") from ex
 
     finally:
         # Trigger stop event
         f_stop.set()
-
-        event(EventType.RUN_SUPERLINK_LEAVE)
+        event(exit_event, event_details={"success": success})
         if serverapp_th:
             serverapp_th.join()
             if server_app_thread_has_exception.is_set():
@@ -411,6 +458,7 @@ def _main_loop(
 # pylint: disable=too-many-arguments,too-many-locals
 def _run_simulation(
     num_supernodes: int,
+    exit_event: EventType,
     client_app: Optional[ClientApp] = None,
     server_app: Optional[ServerApp] = None,
     backend_name: str = "ray",
@@ -422,6 +470,7 @@ def _run_simulation(
     flwr_dir: Optional[str] = None,
     run: Optional[Run] = None,
     enable_tf_gpu_growth: bool = False,
+    delay_start: int = 5,
     verbose_logging: bool = False,
     is_app: bool = False,
 ) -> None:
@@ -477,6 +526,8 @@ def _run_simulation(
         is_app,
         enable_tf_gpu_growth,
         run,
+        exit_event,
+        delay_start,
         flwr_dir,
         client_app,
         client_app_attr,
@@ -512,13 +563,22 @@ def _parse_args_run_simulation() -> argparse.ArgumentParser:
     parser = argparse.ArgumentParser(
         description="Start a Flower simulation",
     )
+    parser.add_argument(
+        "--app",
+        type=str,
+        default=None,
+        help="Path to a directory containing a FAB-like structure with a "
+        "pyproject.toml.",
+    )
     parser.add_argument(
         "--server-app",
-        help="For example: `server:app` or `project.package.module:wrapper.app`",
+        help="(DEPRECATED: use --app instead) For example: `server:app` or "
+        "`project.package.module:wrapper.app`",
     )
     parser.add_argument(
         "--client-app",
-        help="For example: `client:app` or `project.package.module:wrapper.app`",
+        help="(DEPRECATED: use --app instead) For example: `client:app` or "
+        "`project.package.module:wrapper.app`",
     )
     parser.add_argument(
         "--num-supernodes",
@@ -526,13 +586,6 @@ def _parse_args_run_simulation() -> argparse.ArgumentParser:
         required=True,
         help="Number of simulated SuperNodes.",
     )
-    parser.add_argument(
-        "--app",
-        type=str,
-        default=None,
-        help="Path to a directory containing a FAB-like structure with a "
-        "pyproject.toml.",
-    )
     parser.add_argument(
         "--run-config",
         default=None,
@@ -562,6 +615,13 @@ def _parse_args_run_simulation() -> argparse.ArgumentParser:
         "Read more about how `tf.config.experimental.set_memory_growth()` works in "
         "the TensorFlow documentation: https://www.tensorflow.org/api/stable.",
     )
+    parser.add_argument(
+        "--delay-start",
+        type=int,
+        default=3,
+        help="Buffer time (in seconds) to delay the start the simulation engine after "
+        "the `ServerApp`, which runs in a separate thread, has been launched.",
+    )
     parser.add_argument(
         "--verbose",
         action="store_true",

flwr/superexec/__init__.py

@@ -13,9 +13,3 @@
 # limitations under the License.
 # ==============================================================================
 """Flower SuperExec service."""
-
-from .app import run_superexec as run_superexec
-
-__all__ = [
-    "run_superexec",
-]

flwr/superexec/app.py

@@ -25,7 +25,7 @@ import grpc
 from flwr.common import EventType, event, log
 from flwr.common.address import parse_address
 from flwr.common.config import parse_config_args
-from flwr.common.constant import SUPEREXEC_DEFAULT_ADDRESS
+from flwr.common.constant import EXEC_API_DEFAULT_ADDRESS
 from flwr.common.exit_handlers import register_exit_handlers
 from flwr.common.object_ref import load_app, validate
 
@@ -56,7 +56,9 @@ def run_superexec() -> None:
         address=address,
         executor=_load_executor(args),
         certificates=certificates,
-        config=parse_config_args([args.executor_config]),
+        config=parse_config_args(
+            [args.executor_config] if args.executor_config else args.executor_config
+        ),
     )
 
     grpc_servers = [superexec_server]
@@ -79,7 +81,7 @@ def _parse_args_run_superexec() -> argparse.ArgumentParser:
     parser.add_argument(
         "--address",
         help="SuperExec (gRPC) server address (IPv4, IPv6, or a domain name)",
-        default=SUPEREXEC_DEFAULT_ADDRESS,
+        default=EXEC_API_DEFAULT_ADDRESS,
     )
     parser.add_argument(
         "--executor",

flwr/superexec/deployment.py

@@ -23,13 +23,13 @@ from typing import Optional
 from typing_extensions import override
 
 from flwr.cli.install import install_from_fab
+from flwr.common.constant import DRIVER_API_DEFAULT_ADDRESS
 from flwr.common.grpc import create_channel
 from flwr.common.logger import log
 from flwr.common.serde import fab_to_proto, user_config_to_proto
 from flwr.common.typing import Fab, UserConfig
 from flwr.proto.driver_pb2 import CreateRunRequest  # pylint: disable=E0611
 from flwr.proto.driver_pb2_grpc import DriverStub
-from flwr.server.driver.grpc_driver import DEFAULT_SERVER_ADDRESS_DRIVER
 
 from .executor import Executor, RunTracker
 
@@ -50,7 +50,7 @@ class DeploymentEngine(Executor):
 
     def __init__(
         self,
-        superlink: str = DEFAULT_SERVER_ADDRESS_DRIVER,
+        superlink: str = DRIVER_API_DEFAULT_ADDRESS,
         root_certificates: Optional[str] = None,
         flwr_dir: Optional[str] = None,
     ) -> None:

flwr/superexec/simulation.py

@@ -15,6 +15,7 @@
 """Simulation engine executor."""
 
 
+import json
 import subprocess
 import sys
 from logging import ERROR, INFO, WARN
@@ -24,6 +25,7 @@ from typing_extensions import override
 
 from flwr.cli.config_utils import load_and_validate
 from flwr.cli.install import install_from_fab
+from flwr.common.config import unflatten_dict
 from flwr.common.constant import RUN_ID_NUM_BYTES
 from flwr.common.logger import log
 from flwr.common.typing import UserConfig
@@ -108,6 +110,7 @@ class SimulationEngine(Executor):
                 )
             self.verbose = verbose
 
+    # pylint: disable=too-many-locals
     @override
     def start_run(
         self,
@@ -152,6 +155,15 @@ class SimulationEngine(Executor):
                     "Config extracted from FAB's pyproject.toml is not valid"
                 )
 
+            # Flatten federated config
+            federation_config_flat = unflatten_dict(federation_config)
+
+            num_supernodes = federation_config_flat.get(
+                "num-supernodes", self.num_supernodes
+            )
+            backend_cfg = federation_config_flat.get("backend", {})
+            verbose: Optional[bool] = federation_config_flat.get("verbose")
+
             # In Simulation there is no SuperLink, still we create a run_id
             run_id = generate_rand_int_from_bytes(RUN_ID_NUM_BYTES)
             log(INFO, "Created run %s", str(run_id))
@@ -162,11 +174,18 @@ class SimulationEngine(Executor):
                 "--app",
                 f"{str(fab_path)}",
                 "--num-supernodes",
-                f"{federation_config.get('num-supernodes', self.num_supernodes)}",
+                f"{num_supernodes}",
                 "--run-id",
                 str(run_id),
             ]
 
+            if backend_cfg:
+                # Stringify as JSON
+                command.extend(["--backend-config", json.dumps(backend_cfg)])
+
+            if verbose:
+                command.extend(["--verbose"])
+
             if override_config:
                 override_config_str = _user_config_to_str(override_config)
                 command.extend(["--run-config", f"{override_config_str}"])

{flwr_nightly-1.11.0.dev20240822.dist-info → flwr_nightly-1.11.1.dev20240912.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: flwr-nightly
-Version: 1.11.0.dev20240822
+Version: 1.11.1.dev20240912
 Summary: Flower: A Friendly Federated Learning Framework
 Home-page: https://flower.ai
 License: Apache-2.0
@@ -195,8 +195,8 @@ 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/llm-flowertune)
-- [Federated Finetuning of a Vision Transformer](https://github.com/adap/flower/tree/main/examples/vit-finetune)
+- [Federated Finetuning of Large Language Model](https://github.com/adap/flower/tree/main/examples/flowertune-llm)
+- [Federated Finetuning of a Vision Transformer](https://github.com/adap/flower/tree/main/examples/flowertune-vit)
 - [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)
 - Single-Machine Simulation of Federated Learning Systems ([PyTorch](https://github.com/adap/flower/tree/main/examples/simulation-pytorch)) ([Tensorflow](https://github.com/adap/flower/tree/main/examples/simulation-tensorflow))