ultralytics 8.3.88__py3-none-any.whl → 8.3.90__py3-none-any.whl

ultralytics/utils/callbacks/neptune.py

@@ -1,10 +1,12 @@
 # Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
 
+
 from ultralytics.utils import LOGGER, SETTINGS, TESTS_RUNNING
 
 try:
     assert not TESTS_RUNNING  # do not log pytest
     assert SETTINGS["neptune"] is True  # verify integration is enabled
+
     import neptune
     from neptune.types import File
 
@@ -16,27 +18,27 @@ except (ImportError, AssertionError):
     neptune = None
 
 
-def _log_scalars(scalars, step=0):
+def _log_scalars(scalars: dict, step: int = 0) -> None:
     """Log scalars to the NeptuneAI experiment logger."""
     if run:
         for k, v in scalars.items():
             run[k].append(value=v, step=step)
 
 
-def _log_images(imgs_dict, group=""):
-    """Log scalars to the NeptuneAI experiment logger."""
+def _log_images(imgs_dict: dict, group: str = "") -> None:
+    """Log images to the NeptuneAI experiment logger."""
     if run:
         for k, v in imgs_dict.items():
             run[f"{group}/{k}"].upload(File(v))
 
 
-def _log_plot(title, plot_path):
+def _log_plot(title: str, plot_path: str) -> None:
     """
     Log plots to the NeptuneAI experiment logger.
 
     Args:
         title (str): Title of the plot.
-        plot_path (PosixPath | str): Path to the saved image file.
+        plot_path (str): Path to the saved image file.
     """
     import matplotlib.image as mpimg
     import matplotlib.pyplot as plt
@@ -48,7 +50,7 @@ def _log_plot(title, plot_path):
     run[f"Plots/{title}"].upload(fig)
 
 
-def on_pretrain_routine_start(trainer):
+def on_pretrain_routine_start(trainer) -> None:
     """Callback function called before the training routine starts."""
     try:
         global run
@@ -62,7 +64,7 @@ def on_pretrain_routine_start(trainer):
         LOGGER.warning(f"WARNING ⚠️ NeptuneAI installed but not initialized correctly, not logging this run. {e}")
 
 
-def on_train_epoch_end(trainer):
+def on_train_epoch_end(trainer) -> None:
     """Callback function called at end of each training epoch."""
     _log_scalars(trainer.label_loss_items(trainer.tloss, prefix="train"), trainer.epoch + 1)
     _log_scalars(trainer.lr, trainer.epoch + 1)
@@ -70,7 +72,7 @@ def on_train_epoch_end(trainer):
         _log_images({f.stem: str(f) for f in trainer.save_dir.glob("train_batch*.jpg")}, "Mosaic")
 
 
-def on_fit_epoch_end(trainer):
+def on_fit_epoch_end(trainer) -> None:
     """Callback function called at end of each fit (train+val) epoch."""
     if run and trainer.epoch == 0:
         from ultralytics.utils.torch_utils import model_info_for_loggers
@@ -79,14 +81,14 @@ def on_fit_epoch_end(trainer):
     _log_scalars(trainer.metrics, trainer.epoch + 1)
 
 
-def on_val_end(validator):
+def on_val_end(validator) -> None:
     """Callback function called at end of each validation."""
     if run:
         # Log val_labels and val_pred
         _log_images({f.stem: str(f) for f in validator.save_dir.glob("val*.jpg")}, "Validation")
 
 
-def on_train_end(trainer):
+def on_train_end(trainer) -> None:
     """Callback function called at end of training."""
     if run:
         # Log final results, CM matrix + PR plots

ultralytics/utils/callbacks/raytune.py

@@ -14,7 +14,7 @@ except (ImportError, AssertionError):
 
 def on_fit_epoch_end(trainer):
     """Sends training metrics to Ray Tune at end of each epoch."""
-    if ray.train._internal.session.get_session():  # replacement for deprecated ray.tune.is_session_enabled()
+    if ray.train._internal.session.get_session():  # check if Ray Tune session is active
         metrics = trainer.metrics
         session.report({**metrics, **{"epoch": trainer.epoch + 1}})
 

ultralytics/utils/callbacks/tensorboard.py

@@ -23,14 +23,14 @@ except (ImportError, AssertionError, TypeError, AttributeError):
     SummaryWriter = None
 
 
-def _log_scalars(scalars, step=0):
+def _log_scalars(scalars: dict, step: int = 0) -> None:
     """Logs scalar values to TensorBoard."""
     if WRITER:
         for k, v in scalars.items():
             WRITER.add_scalar(k, v, step)
 
 
-def _log_tensorboard_graph(trainer):
+def _log_tensorboard_graph(trainer) -> None:
     """Log model graph to TensorBoard."""
     # Input image
     imgsz = trainer.args.imgsz
@@ -66,7 +66,7 @@ def _log_tensorboard_graph(trainer):
                 LOGGER.warning(f"{PREFIX}WARNING ⚠️ TensorBoard graph visualization failure {e}")
 
 
-def on_pretrain_routine_start(trainer):
+def on_pretrain_routine_start(trainer) -> None:
     """Initialize TensorBoard logging with SummaryWriter."""
     if SummaryWriter:
         try:
@@ -77,19 +77,19 @@ def on_pretrain_routine_start(trainer):
             LOGGER.warning(f"{PREFIX}WARNING ⚠️ TensorBoard not initialized correctly, not logging this run. {e}")
 
 
-def on_train_start(trainer):
+def on_train_start(trainer) -> None:
     """Log TensorBoard graph."""
     if WRITER:
         _log_tensorboard_graph(trainer)
 
 
-def on_train_epoch_end(trainer):
+def on_train_epoch_end(trainer) -> None:
     """Logs scalar statistics at the end of a training epoch."""
     _log_scalars(trainer.label_loss_items(trainer.tloss, prefix="train"), trainer.epoch + 1)
     _log_scalars(trainer.lr, trainer.epoch + 1)
 
 
-def on_fit_epoch_end(trainer):
+def on_fit_epoch_end(trainer) -> None:
     """Logs epoch metrics at end of training epoch."""
     _log_scalars(trainer.metrics, trainer.epoch + 1)
 

ultralytics/utils/callbacks/wb.py

@@ -27,9 +27,9 @@ def _custom_table(x, y, classes, title="Precision Recall Curve", x_title="Recall
         x (List): Values for the x-axis; expected to have length N.
         y (List): Corresponding values for the y-axis; also expected to have length N.
         classes (List): Labels identifying the class of each point; length N.
-        title (str, optional): Title for the plot; defaults to 'Precision Recall Curve'.
-        x_title (str, optional): Label for the x-axis; defaults to 'Recall'.
-        y_title (str, optional): Label for the y-axis; defaults to 'Precision'.
+        title (str): Title for the plot; defaults to 'Precision Recall Curve'.
+        x_title (str): Label for the x-axis; defaults to 'Recall'.
+        y_title (str): Label for the y-axis; defaults to 'Precision'.
 
     Returns:
         (wandb.Object): A wandb object suitable for logging, showcasing the crafted metric visualization.
@@ -63,16 +63,16 @@ def _plot_curve(
 
     Args:
         x (np.ndarray): Data points for the x-axis with length N.
-        y (np.ndarray): Corresponding data points for the y-axis with shape CxN, where C is the number of classes.
-        names (list, optional): Names of the classes corresponding to the y-axis data; length C. Defaults to [].
-        id (str, optional): Unique identifier for the logged data in wandb. Defaults to 'precision-recall'.
-        title (str, optional): Title for the visualization plot. Defaults to 'Precision Recall Curve'.
-        x_title (str, optional): Label for the x-axis. Defaults to 'Recall'.
-        y_title (str, optional): Label for the y-axis. Defaults to 'Precision'.
-        num_x (int, optional): Number of interpolated data points for visualization. Defaults to 100.
-        only_mean (bool, optional): Flag to indicate if only the mean curve should be plotted. Defaults to True.
-
-    Note:
+        y (np.ndarray): Corresponding data points for the y-axis with shape (C, N), where C is the number of classes.
+        names (List): Names of the classes corresponding to the y-axis data; length C.
+        id (str): Unique identifier for the logged data in wandb.
+        title (str): Title for the visualization plot.
+        x_title (str): Label for the x-axis.
+        y_title (str): Label for the y-axis.
+        num_x (int): Number of interpolated data points for visualization.
+        only_mean (bool): Flag to indicate if only the mean curve should be plotted.
+
+    Notes:
         The function leverages the '_custom_table' function to generate the actual visualization.
     """
     import numpy as np
@@ -108,7 +108,7 @@ def _log_plots(plots, step):
 
 
 def on_pretrain_routine_start(trainer):
-    """Initiate and start project if module is present."""
+    """Initiate and start wandb project if module is present."""
     if not wb.run:
         wb.init(
             project=str(trainer.args.project).replace("/", "-") if trainer.args.project else "Ultralytics",
@@ -118,7 +118,7 @@ def on_pretrain_routine_start(trainer):
 
 
 def on_fit_epoch_end(trainer):
-    """Logs training metrics and model information at the end of an epoch."""
+    """Log training metrics and model information at the end of an epoch."""
     wb.run.log(trainer.metrics, step=trainer.epoch + 1)
     _log_plots(trainer.plots, step=trainer.epoch + 1)
     _log_plots(trainer.validator.plots, step=trainer.epoch + 1)
@@ -135,7 +135,7 @@ def on_train_epoch_end(trainer):
 
 
 def on_train_end(trainer):
-    """Save the best model as an artifact at end of training."""
+    """Save the best model as an artifact and log final plots at the end of training."""
     _log_plots(trainer.validator.plots, step=trainer.epoch + 1)
     _log_plots(trainer.plots, step=trainer.epoch + 1)
     art = wb.Artifact(type="model", name=f"run_{wb.run.id}_model")

ultralytics/utils/checks.py

@@ -55,17 +55,14 @@ def parse_requirements(file_path=ROOT.parent / "requirements.txt", package=""):
 
     Args:
         file_path (Path): Path to the requirements.txt file.
-        package (str, optional): Python package to use instead of requirements.txt file, i.e. package='ultralytics'.
+        package (str, optional): Python package to use instead of requirements.txt file.
 
     Returns:
-        (List[Dict[str, str]]): List of parsed requirements as dictionaries with `name` and `specifier` keys.
+        (List[SimpleNamespace]): List of parsed requirements as SimpleNamespace objects with `name` and `specifier` attributes.
 
-    Example:
-        ```python
-        from ultralytics.utils.checks import parse_requirements
-
-        parse_requirements(package="ultralytics")
-        ```
+    Examples:
+        >>> from ultralytics.utils.checks import parse_requirements
+        >>> parse_requirements(package="ultralytics")
     """
     if package:
         requires = [x for x in metadata.distribution(package).requires if "extra == " not in x]
@@ -85,14 +82,13 @@ def parse_requirements(file_path=ROOT.parent / "requirements.txt", package=""):
 
 def parse_version(version="0.0.0") -> tuple:
     """
-    Convert a version string to a tuple of integers, ignoring any extra non-numeric string attached to the version. This
-    function replaces deprecated 'pkg_resources.parse_version(v)'.
+    Convert a version string to a tuple of integers, ignoring any extra non-numeric string attached to the version.
 
     Args:
         version (str): Version string, i.e. '2.0.1+cpu'
 
     Returns:
-        (tuple): Tuple of integers representing the numeric part of the version and the extra string, i.e. (2, 0, 1)
+        (tuple): Tuple of integers representing the numeric part of the version, i.e. (2, 0, 1)
     """
     try:
         return tuple(map(int, re.findall(r"\d+", version)[:3]))  # '2.0.1+cpu' -> (2, 0, 1)
@@ -124,7 +120,7 @@ def check_imgsz(imgsz, stride=32, min_dim=1, max_dim=2, floor=0):
     stride, update it to the nearest multiple of the stride that is greater than or equal to the given floor value.
 
     Args:
-        imgsz (int | cList[int]): Image size.
+        imgsz (int | List[int]): Image size.
         stride (int): Stride value.
         min_dim (int): Minimum number of dimensions.
         max_dim (int): Maximum number of dimensions.
@@ -186,28 +182,26 @@ def check_version(
     Args:
         current (str): Current version or package name to get version from.
         required (str): Required version or range (in pip-style format).
-        name (str, optional): Name to be used in warning message.
-        hard (bool, optional): If True, raise an AssertionError if the requirement is not met.
-        verbose (bool, optional): If True, print warning message if requirement is not met.
-        msg (str, optional): Extra message to display if verbose.
+        name (str): Name to be used in warning message.
+        hard (bool): If True, raise an AssertionError if the requirement is not met.
+        verbose (bool): If True, print warning message if requirement is not met.
+        msg (str): Extra message to display if verbose.
 
     Returns:
         (bool): True if requirement is met, False otherwise.
 
-    Example:
-        ```python
-        # Check if current version is exactly 22.04
-        check_version(current="22.04", required="==22.04")
+    Examples:
+        Check if current version is exactly 22.04
+        >>> check_version(current="22.04", required="==22.04")
 
-        # Check if current version is greater than or equal to 22.04
-        check_version(current="22.10", required="22.04")  # assumes '>=' inequality if none passed
+        Check if current version is greater than or equal to 22.04
+        >>> check_version(current="22.10", required="22.04")  # assumes '>=' inequality if none passed
 
-        # Check if current version is less than or equal to 22.04
-        check_version(current="22.04", required="<=22.04")
+        Check if current version is less than or equal to 22.04
+        >>> check_version(current="22.04", required="<=22.04")
 
-        # Check if current version is between 20.04 (inclusive) and 22.04 (exclusive)
-        check_version(current="21.10", required=">20.04,<22.04")
-        ```
+        Check if current version is between 20.04 (inclusive) and 22.04 (exclusive)
+        >>> check_version(current="21.10", required=">20.04,<22.04")
     """
     if not current:  # if current is '' or None
         LOGGER.warning(f"WARNING ⚠️ invalid check_version({current}, {required}) requested, please check values.")
@@ -313,7 +307,7 @@ def check_font(font="Arial.ttf"):
         font (str): Path or name of font.
 
     Returns:
-        file (Path): Resolved font file path.
+        (Path): Resolved font file path.
     """
     from matplotlib import font_manager
 
@@ -341,8 +335,8 @@ def check_python(minimum: str = "3.8.0", hard: bool = True, verbose: bool = Fals
 
     Args:
         minimum (str): Required minimum version of python.
-        hard (bool, optional): If True, raise an AssertionError if the requirement is not met.
-        verbose (bool, optional): If True, print warning message if requirement is not met.
+        hard (bool): If True, raise an AssertionError if the requirement is not met.
+        verbose (bool): If True, print warning message if requirement is not met.
 
     Returns:
         (bool): Whether the installed Python version meets the minimum constraints.
@@ -362,19 +356,17 @@ def check_requirements(requirements=ROOT.parent / "requirements.txt", exclude=()
         install (bool): If True, attempt to auto-update packages that don't meet requirements.
         cmds (str): Additional commands to pass to the pip install command when auto-updating.
 
-    Example:
-        ```python
-        from ultralytics.utils.checks import check_requirements
+    Examples:
+        >>> from ultralytics.utils.checks import check_requirements
 
-        # Check a requirements.txt file
-        check_requirements("path/to/requirements.txt")
+        Check a requirements.txt file
+        >>> check_requirements("path/to/requirements.txt")
 
-        # Check a single package
-        check_requirements("ultralytics>=8.0.0")
+        Check a single package
+        >>> check_requirements("ultralytics>=8.0.0")
 
-        # Check multiple packages
-        check_requirements(["numpy", "ultralytics>=8.0.0"])
-        ```
+        Check multiple packages
+        >>> check_requirements(["numpy", "ultralytics>=8.0.0"])
     """
     prefix = colorstr("red", "bold", "requirements:")
     if isinstance(requirements, Path):  # requirements.txt file
@@ -427,11 +419,7 @@ def check_torchvision():
     Checks the installed versions of PyTorch and Torchvision to ensure they're compatible.
 
     This function checks the installed versions of PyTorch and Torchvision, and warns if they're incompatible according
-    to the provided compatibility table based on:
-    https://github.com/pytorch/vision#installation.
-
-    The compatibility table is a dictionary where the keys are PyTorch versions and the values are lists of compatible
-    Torchvision versions.
+    to the compatibility table based on: https://github.com/pytorch/vision#installation.
     """
     compatibility_table = {
         "2.6": ["0.21"],
@@ -460,7 +448,14 @@ def check_torchvision():
 
 
 def check_suffix(file="yolo11n.pt", suffix=".pt", msg=""):
-    """Check file(s) for acceptable suffix."""
+    """
+    Check file(s) for acceptable suffix.
+
+    Args:
+        file (str | List[str]): File or list of files to check.
+        suffix (str | Tuple[str]): Acceptable suffix or tuple of suffixes.
+        msg (str): Additional message to display in case of error.
+    """
     if file and suffix:
         if isinstance(suffix, str):
             suffix = (suffix,)
@@ -471,7 +466,16 @@ def check_suffix(file="yolo11n.pt", suffix=".pt", msg=""):
 
 
 def check_yolov5u_filename(file: str, verbose: bool = True):
-    """Replace legacy YOLOv5 filenames with updated YOLOv5u filenames."""
+    """
+    Replace legacy YOLOv5 filenames with updated YOLOv5u filenames.
+
+    Args:
+        file (str): Filename to check and potentially update.
+        verbose (bool): Whether to print information about the replacement.
+
+    Returns:
+        (str): Updated filename.
+    """
     if "yolov3" in file or "yolov5" in file:
         if "u.yaml" in file:
             file = file.replace("u.yaml", ".yaml")  # i.e. yolov5nu.yaml -> yolov5n.yaml
@@ -490,7 +494,15 @@ def check_yolov5u_filename(file: str, verbose: bool = True):
 
 
 def check_model_file_from_stem(model="yolo11n"):
-    """Return a model filename from a valid model stem."""
+    """
+    Return a model filename from a valid model stem.
+
+    Args:
+        model (str): Model stem to check.
+
+    Returns:
+        (str | Path): Model filename with appropriate suffix.
+    """
     if model and not Path(model).suffix and Path(model).stem in downloads.GITHUB_ASSETS_STEMS:
         return Path(model).with_suffix(".pt")  # add suffix, i.e. yolo11n -> yolo11n.pt
     else:
@@ -498,7 +510,19 @@ def check_model_file_from_stem(model="yolo11n"):
 
 
 def check_file(file, suffix="", download=True, download_dir=".", hard=True):
-    """Search/download file (if necessary) and return path."""
+    """
+    Search/download file (if necessary) and return path.
+
+    Args:
+        file (str): File name or path.
+        suffix (str): File suffix to check.
+        download (bool): Whether to download the file if it doesn't exist locally.
+        download_dir (str): Directory to download the file to.
+        hard (bool): Whether to raise an error if the file is not found.
+
+    Returns:
+        (str): Path to the file.
+    """
     check_suffix(file, suffix)  # optional
     file = str(file).strip()  # convert to string and strip spaces
     file = check_yolov5u_filename(file)  # yolov5n -> yolov5nu
@@ -526,7 +550,17 @@ def check_file(file, suffix="", download=True, download_dir=".", hard=True):
 
 
 def check_yaml(file, suffix=(".yaml", ".yml"), hard=True):
-    """Search/download YAML file (if necessary) and return path, checking suffix."""
+    """
+    Search/download YAML file (if necessary) and return path, checking suffix.
+
+    Args:
+        file (str): File name or path.
+        suffix (tuple): Acceptable file suffixes.
+        hard (bool): Whether to raise an error if the file is not found.
+
+    Returns:
+        (str): Path to the YAML file.
+    """
     return check_file(file, suffix, hard=hard)
 
 
@@ -548,7 +582,15 @@ def check_is_path_safe(basedir, path):
 
 
 def check_imshow(warn=False):
-    """Check if environment supports image displays."""
+    """
+    Check if environment supports image displays.
+
+    Args:
+        warn (bool): Whether to warn if environment doesn't support image displays.
+
+    Returns:
+        (bool): True if environment supports image displays, False otherwise.
+    """
     try:
         if LINUX:
             assert not IS_COLAB and not IS_KAGGLE
@@ -565,7 +607,13 @@ def check_imshow(warn=False):
 
 
 def check_yolo(verbose=True, device=""):
-    """Return a human-readable YOLO software and hardware summary."""
+    """
+    Return a human-readable YOLO software and hardware summary.
+
+    Args:
+        verbose (bool): Whether to print verbose information.
+        device (str): Device to use for YOLO.
+    """
     import psutil
 
     from ultralytics.utils.torch_utils import select_device
@@ -593,7 +641,12 @@ def check_yolo(verbose=True, device=""):
 
 
 def collect_system_info():
-    """Collect and print relevant system information including OS, Python, RAM, CPU, and CUDA."""
+    """
+    Collect and print relevant system information including OS, Python, RAM, CPU, and CUDA.
+
+    Returns:
+        (dict): Dictionary containing system information.
+    """
     import psutil
 
     from ultralytics.utils import ENVIRONMENT  # scope to avoid circular import
@@ -650,24 +703,22 @@ def collect_system_info():
 
 def check_amp(model):
     """
-    Checks the PyTorch Automatic Mixed Precision (AMP) functionality of a YOLO11 model. If the checks fail, it means
-    there are anomalies with AMP on the system that may cause NaN losses or zero-mAP results, so AMP will be disabled
-    during training.
+    Checks the PyTorch Automatic Mixed Precision (AMP) functionality of a YOLO11 model.
+
+    If the checks fail, it means there are anomalies with AMP on the system that may cause NaN losses or zero-mAP
+    results, so AMP will be disabled during training.
 
     Args:
         model (nn.Module): A YOLO11 model instance.
 
-    Example:
-        ```python
-        from ultralytics import YOLO
-        from ultralytics.utils.checks import check_amp
-
-        model = YOLO("yolo11n.pt").model.cuda()
-        check_amp(model)
-        ```
-
     Returns:
         (bool): Returns True if the AMP functionality works correctly with YOLO11 model, else False.
+
+    Examples:
+        >>> from ultralytics import YOLO
+        >>> from ultralytics.utils.checks import check_amp
+        >>> model = YOLO("yolo11n.pt").model.cuda()
+        >>> check_amp(model)
     """
     from ultralytics.utils.torch_utils import autocast
 
@@ -726,7 +777,15 @@ def check_amp(model):
 
 
 def git_describe(path=ROOT):  # path must be a directory
-    """Return human-readable git description, i.e. v5.0-5-g3e25f1e https://git-scm.com/docs/git-describe."""
+    """
+    Return human-readable git description, i.e. v5.0-5-g3e25f1e https://git-scm.com/docs/git-describe.
+
+    Args:
+        path (Path): Path to git repository.
+
+    Returns:
+        (str): Human-readable git description.
+    """
     try:
         return subprocess.check_output(f"git -C {path} describe --tags --long --always", shell=True).decode()[:-1]
     except Exception:
@@ -734,7 +793,14 @@ def git_describe(path=ROOT):  # path must be a directory
 
 
 def print_args(args: Optional[dict] = None, show_file=True, show_func=False):
-    """Print function arguments (optional args dict)."""
+    """
+    Print function arguments (optional args dict).
+
+    Args:
+        args (dict, optional): Arguments to print.
+        show_file (bool): Whether to show the file name.
+        show_func (bool): Whether to show the function name.
+    """
 
     def strip_auth(v):
         """Clean longer Ultralytics HUB URLs by stripping potential authentication information."""
@@ -786,7 +852,12 @@ def cuda_is_available() -> bool:
 
 
 def is_rockchip():
-    """Check if the current environment is running on a Rockchip SoC."""
+    """
+    Check if the current environment is running on a Rockchip SoC.
+
+    Returns:
+        (bool): True if running on a Rockchip SoC, False otherwise.
+    """
     if LINUX and ARM64:
         try:
             with open("/proc/device-tree/compatible") as f:

ultralytics/utils/dist.py

@@ -12,10 +12,13 @@ from .torch_utils import TORCH_1_9
 
 def find_free_network_port() -> int:
     """
-    Finds a free port on localhost.
+    Find a free port on localhost.
 
     It is useful in single-node training when we don't want to connect to a real main node but have to set the
     `MASTER_PORT` environment variable.
+
+    Returns:
+        (int): The available network port number.
     """
     with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
         s.bind(("127.0.0.1", 0))
@@ -54,7 +57,17 @@ if __name__ == "__main__":
 
 
 def generate_ddp_command(world_size, trainer):
-    """Generates and returns command for distributed training."""
+    """
+    Generate command for distributed training.
+
+    Args:
+        world_size (int): Number of processes to spawn for distributed training.
+        trainer (object): The trainer object containing configuration for distributed training.
+
+    Returns:
+        cmd (List[str]): The command to execute for distributed training.
+        file (str): Path to the temporary file created for DDP training.
+    """
     import __main__  # noqa local import to avoid https://github.com/Lightning-AI/lightning/issues/15218
 
     if not trainer.resume: