dgenerate-ultralytics-headless 8.3.214__py3-none-any.whl → 8.3.248__py3-none-any.whl

ultralytics/utils/autodevice.py

@@ -9,24 +9,23 @@ from ultralytics.utils.checks import check_requirements
 
 
 class GPUInfo:
-    """
-    Manages NVIDIA GPU information via pynvml with robust error handling.
+    """Manages NVIDIA GPU information via pynvml with robust error handling.
 
-    Provides methods to query detailed GPU statistics (utilization, memory, temp, power) and select the most idle
-    GPUs based on configurable criteria. It safely handles the absence or initialization failure of the pynvml
-    library by logging warnings and disabling related features, preventing application crashes.
+    Provides methods to query detailed GPU statistics (utilization, memory, temp, power) and select the most idle GPUs
+    based on configurable criteria. It safely handles the absence or initialization failure of the pynvml library by
+    logging warnings and disabling related features, preventing application crashes.
 
     Includes fallback logic using `torch.cuda` for basic device counting if NVML is unavailable during GPU
     selection. Manages NVML initialization and shutdown internally.
 
     Attributes:
         pynvml (module | None): The `pynvml` module if successfully imported and initialized, otherwise `None`.
-        nvml_available (bool): Indicates if `pynvml` is ready for use. True if import and `nvmlInit()` succeeded,
-            False otherwise.
-        gpu_stats (list[dict[str, Any]]): A list of dictionaries, each holding stats for one GPU. Populated on
-            initialization and by `refresh_stats()`. Keys include: 'index', 'name', 'utilization' (%),
-            'memory_used' (MiB), 'memory_total' (MiB), 'memory_free' (MiB), 'temperature' (C), 'power_draw' (W),
-            'power_limit' (W or 'N/A'). Empty if NVML is unavailable or queries fail.
+        nvml_available (bool): Indicates if `pynvml` is ready for use. True if import and `nvmlInit()` succeeded, False
+            otherwise.
+        gpu_stats (list[dict[str, Any]]): A list of dictionaries, each holding stats for one GPU, populated on
+        initialization and by `refresh_stats()`. Keys include: 'index', 'name', 'utilization' (%), 'memory_used' (MiB),
+            'memory_total' (MiB), 'memory_free' (MiB), 'temperature' (C), 'power_draw' (W), 'power_limit' (W or 'N/A').
+            Empty if NVML is unavailable or queries fail.
 
     Methods:
         refresh_stats: Refresh the internal gpu_stats list by querying NVML.
@@ -137,8 +136,7 @@ class GPUInfo:
     def select_idle_gpu(
         self, count: int = 1, min_memory_fraction: float = 0, min_util_fraction: float = 0
     ) -> list[int]:
-        """
-        Select the most idle GPUs based on utilization and free memory.
+        """Select the most idle GPUs based on utilization and free memory.
 
         Args:
             count (int): The number of idle GPUs to select.
@@ -154,9 +152,10 @@ class GPUInfo:
         """
         assert min_memory_fraction <= 1.0, f"min_memory_fraction must be <= 1.0, got {min_memory_fraction}"
         assert min_util_fraction <= 1.0, f"min_util_fraction must be <= 1.0, got {min_util_fraction}"
-        LOGGER.info(
-            f"Searching for {count} idle GPUs with free memory >= {min_memory_fraction * 100:.1f}% and free utilization >= {min_util_fraction * 100:.1f}%..."
+        criteria = (
+            f"free memory >= {min_memory_fraction * 100:.1f}% and free utilization >= {min_util_fraction * 100:.1f}%"
         )
+        LOGGER.info(f"Searching for {count} idle GPUs with {criteria}...")
 
         if count <= 0:
             return []
@@ -179,11 +178,11 @@ class GPUInfo:
         selected = [gpu["index"] for gpu in eligible_gpus[:count]]
 
         if selected:
+            if len(selected) < count:
+                LOGGER.warning(f"Requested {count} GPUs but only {len(selected)} met the idle criteria.")
             LOGGER.info(f"Selected idle CUDA devices {selected}")
         else:
-            LOGGER.warning(
-                f"No GPUs met criteria (Free Mem >= {min_memory_fraction * 100:.1f}% and Free Util >= {min_util_fraction * 100:.1f}%)."
-            )
+            LOGGER.warning(f"No GPUs met criteria ({criteria}).")
 
         return selected
 

ultralytics/utils/benchmarks.py

@@ -1,6 +1,6 @@
 # Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
 """
-Benchmark a YOLO model formats for speed and accuracy.
+Benchmark YOLO model formats for speed and accuracy.
 
 Usage:
     from ultralytics.utils.benchmarks import ProfileModels, benchmark
@@ -25,6 +25,7 @@ MNN                     | `mnn`                     | yolo11n.mnn
 NCNN                    | `ncnn`                    | yolo11n_ncnn_model/
 IMX                     | `imx`                     | yolo11n_imx_model/
 RKNN                    | `rknn`                    | yolo11n_rknn_model/
+ExecuTorch              | `executorch`              | yolo11n_executorch_model/
 """
 
 from __future__ import annotations
@@ -62,8 +63,7 @@ def benchmark(
     format="",
     **kwargs,
 ):
-    """
-    Benchmark a YOLO model across different formats for speed and accuracy.
+    """Benchmark a YOLO model across different formats for speed and accuracy.
 
     Args:
         model (str | Path): Path to the model file or directory.
@@ -78,8 +78,8 @@ def benchmark(
         **kwargs (Any): Additional keyword arguments for exporter.
 
     Returns:
-        (polars.DataFrame): A polars DataFrame with benchmark results for each format, including file size, metric,
-            and inference time.
+        (polars.DataFrame): A Polars DataFrame with benchmark results for each format, including file size, metric, and
+            inference time.
 
     Examples:
         Benchmark a YOLO model with default settings:
@@ -144,13 +144,18 @@ def benchmark(
             if format == "imx":
                 assert not is_end2end
                 assert not isinstance(model, YOLOWorld), "YOLOWorldv2 IMX exports not supported"
-                assert model.task == "detect", "IMX only supported for detection task"
+                assert model.task in {"detect", "classify", "pose"}, (
+                    "IMX export is only supported for detection, classification and pose estimation tasks"
+                )
                 assert "C2f" in model.__str__(), "IMX only supported for YOLOv8n and YOLO11n"
             if format == "rknn":
                 assert not isinstance(model, YOLOWorld), "YOLOWorldv2 RKNN exports not supported yet"
                 assert not is_end2end, "End-to-end models not supported by RKNN yet"
                 assert LINUX, "RKNN only supported on Linux"
                 assert not is_rockchip(), "RKNN Inference only supported on Rockchip devices"
+            if format == "executorch":
+                assert not isinstance(model, YOLOWorld), "YOLOWorldv2 ExecuTorch exports not supported yet"
+                assert not is_end2end, "End-to-end models not supported by ExecuTorch yet"
             if "cpu" in device.type:
                 assert cpu, "inference not supported on CPU"
             if "cuda" in device.type:
@@ -170,6 +175,7 @@ def benchmark(
 
             # Predict
             assert model.task != "pose" or format != "pb", "GraphDef Pose inference is not supported"
+            assert model.task != "pose" or format != "executorch", "ExecuTorch Pose inference is not supported"
             assert format not in {"edgetpu", "tfjs"}, "inference not supported"
             assert format != "coreml" or platform.system() == "Darwin", "inference only supported on macOS>=10.13"
             if format == "ncnn":
@@ -220,8 +226,7 @@ def benchmark(
 
 
 class RF100Benchmark:
-    """
-    Benchmark YOLO model performance across various formats for speed and accuracy.
+    """Benchmark YOLO model performance across various formats for speed and accuracy.
 
     This class provides functionality to benchmark YOLO models on the RF100 dataset collection.
 
@@ -246,8 +251,7 @@ class RF100Benchmark:
         self.val_metrics = ["class", "images", "targets", "precision", "recall", "map50", "map95"]
 
     def set_key(self, api_key: str):
-        """
-        Set Roboflow API key for processing.
+        """Set Roboflow API key for processing.
 
         Args:
             api_key (str): The API key.
@@ -263,8 +267,7 @@ class RF100Benchmark:
         self.rf = Roboflow(api_key=api_key)
 
     def parse_dataset(self, ds_link_txt: str = "datasets_links.txt"):
-        """
-        Parse dataset links and download datasets.
+        """Parse dataset links and download datasets.
 
         Args:
             ds_link_txt (str): Path to the file containing dataset links.
@@ -286,7 +289,7 @@ class RF100Benchmark:
         with open(ds_link_txt, encoding="utf-8") as file:
             for line in file:
                 try:
-                    _, url, workspace, project, version = re.split("/+", line.strip())
+                    _, _url, workspace, project, version = re.split("/+", line.strip())
                     self.ds_names.append(project)
                     proj_version = f"{project}-{version}"
                     if not Path(proj_version).exists():
@@ -308,8 +311,7 @@ class RF100Benchmark:
         YAML.dump(yaml_data, path)
 
     def evaluate(self, yaml_path: str, val_log_file: str, eval_log_file: str, list_ind: int):
-        """
-        Evaluate model performance on validation results.
+        """Evaluate model performance on validation results.
 
         Args:
             yaml_path (str): Path to the YAML configuration file.
@@ -357,7 +359,7 @@ class RF100Benchmark:
                     map_val = lst["map50"]
         else:
             LOGGER.info("Single dict found")
-            map_val = [res["map50"] for res in eval_lines][0]
+            map_val = next(res["map50"] for res in eval_lines)
 
         with open(eval_log_file, "a", encoding="utf-8") as f:
             f.write(f"{self.ds_names[list_ind]}: {map_val}\n")
@@ -366,8 +368,7 @@ class RF100Benchmark:
 
 
 class ProfileModels:
-    """
-    ProfileModels class for profiling different models on ONNX and TensorRT.
+    """ProfileModels class for profiling different models on ONNX and TensorRT.
 
     This class profiles the performance of different models, returning results such as model speed and FLOPs.
 
@@ -410,8 +411,7 @@ class ProfileModels:
         trt: bool = True,
         device: torch.device | str | None = None,
     ):
-        """
-        Initialize the ProfileModels class for profiling models.
+        """Initialize the ProfileModels class for profiling models.
 
         Args:
             paths (list[str]): List of paths of the models to be profiled.
@@ -425,12 +425,6 @@ class ProfileModels:
 
         Notes:
             FP16 'half' argument option removed for ONNX as slower on CPU than FP32.
-
-        Examples:
-            Initialize and profile models
-            >>> from ultralytics.utils.benchmarks import ProfileModels
-            >>> profiler = ProfileModels(["yolo11n.yaml", "yolov8s.yaml"], imgsz=640)
-            >>> profiler.run()
         """
         self.paths = paths
         self.num_timed_runs = num_timed_runs
@@ -442,8 +436,7 @@ class ProfileModels:
         self.device = device if isinstance(device, torch.device) else select_device(device)
 
     def run(self):
-        """
-        Profile YOLO models for speed and accuracy across various formats including ONNX and TensorRT.
+        """Profile YOLO models for speed and accuracy across various formats including ONNX and TensorRT.
 
         Returns:
             (list[dict]): List of dictionaries containing profiling results for each model.
@@ -497,8 +490,7 @@ class ProfileModels:
         return output
 
     def get_files(self):
-        """
-        Return a list of paths for all relevant model files given by the user.
+        """Return a list of paths for all relevant model files given by the user.
 
         Returns:
             (list[Path]): List of Path objects for the model files.
@@ -524,8 +516,7 @@ class ProfileModels:
 
     @staticmethod
     def iterative_sigma_clipping(data: np.ndarray, sigma: float = 2, max_iters: int = 3):
-        """
-        Apply iterative sigma clipping to data to remove outliers.
+        """Apply iterative sigma clipping to data to remove outliers.
 
         Args:
             data (np.ndarray): Input data array.
@@ -545,8 +536,7 @@ class ProfileModels:
         return data
 
     def profile_tensorrt_model(self, engine_file: str, eps: float = 1e-3):
-        """
-        Profile YOLO model performance with TensorRT, measuring average run time and standard deviation.
+        """Profile YOLO model performance with TensorRT, measuring average run time and standard deviation.
 
         Args:
             engine_file (str): Path to the TensorRT engine file.
@@ -589,8 +579,7 @@ class ProfileModels:
         return not all(isinstance(dim, int) and dim >= 0 for dim in tensor_shape)
 
     def profile_onnx_model(self, onnx_file: str, eps: float = 1e-3):
-        """
-        Profile an ONNX model, measuring average inference time and standard deviation across multiple runs.
+        """Profile an ONNX model, measuring average inference time and standard deviation across multiple runs.
 
         Args:
             onnx_file (str): Path to the ONNX model file.
@@ -609,7 +598,7 @@ class ProfileModels:
         sess_options.intra_op_num_threads = 8  # Limit the number of threads
         sess = ort.InferenceSession(onnx_file, sess_options, providers=["CPUExecutionProvider"])
 
-        input_data_dict = dict()
+        input_data_dict = {}
         for input_tensor in sess.get_inputs():
             input_type = input_tensor.type
             if self.check_dynamic(input_tensor.shape):
@@ -637,7 +626,7 @@ class ProfileModels:
 
             input_data = np.random.rand(*input_shape).astype(input_dtype)
             input_name = input_tensor.name
-            input_data_dict.update({input_name: input_data})
+            input_data_dict[input_name] = input_data
 
         output_name = sess.get_outputs()[0].name
 
@@ -669,8 +658,7 @@ class ProfileModels:
         t_engine: tuple[float, float],
         model_info: tuple[float, float, float, float],
     ):
-        """
-        Generate a table row string with model performance metrics.
+        """Generate a table row string with model performance metrics.
 
         Args:
             model_name (str): Name of the model.
@@ -681,7 +669,7 @@ class ProfileModels:
         Returns:
             (str): Formatted table row string with model metrics.
         """
-        layers, params, gradients, flops = model_info
+        _layers, params, _gradients, flops = model_info
         return (
             f"| {model_name:18s} | {self.imgsz} | - | {t_onnx[0]:.1f}±{t_onnx[1]:.1f} ms | {t_engine[0]:.1f}±"
             f"{t_engine[1]:.1f} ms | {params / 1e6:.1f} | {flops:.1f} |"
@@ -694,8 +682,7 @@ class ProfileModels:
         t_engine: tuple[float, float],
         model_info: tuple[float, float, float, float],
     ):
-        """
-        Generate a dictionary of profiling results.
+        """Generate a dictionary of profiling results.
 
         Args:
             model_name (str): Name of the model.
@@ -706,7 +693,7 @@ class ProfileModels:
         Returns:
             (dict): Dictionary containing profiling results.
         """
-        layers, params, gradients, flops = model_info
+        _layers, params, _gradients, flops = model_info
         return {
             "model/name": model_name,
             "model/parameters": params,
@@ -717,8 +704,7 @@ class ProfileModels:
 
     @staticmethod
     def print_table(table_rows: list[str]):
-        """
-        Print a formatted table of model profiling results.
+        """Print a formatted table of model profiling results.
 
         Args:
             table_rows (list[str]): List of formatted table row strings.

ultralytics/utils/callbacks/base.py

@@ -175,13 +175,12 @@ default_callbacks = {
 
 
 def get_default_callbacks():
-    """
-    Get the default callbacks for Ultralytics training, validation, prediction, and export processes.
+    """Get the default callbacks for Ultralytics training, validation, prediction, and export processes.
 
     Returns:
         (dict): Dictionary of default callbacks for various training events. Each key represents an event during the
-            training process, and the corresponding value is a list of callback functions executed when that event
-            occurs.
+            training process, and the corresponding value is a list of callback functions executed when that
+            event occurs.
 
     Examples:
         >>> callbacks = get_default_callbacks()
@@ -192,17 +191,16 @@ def get_default_callbacks():
 
 
 def add_integration_callbacks(instance):
-    """
-    Add integration callbacks to the instance's callbacks dictionary.
+    """Add integration callbacks to the instance's callbacks dictionary.
 
     This function loads and adds various integration callbacks to the provided instance. The specific callbacks added
     depend on the type of instance provided. All instances receive HUB callbacks, while Trainer instances also receive
-    additional callbacks for various integrations like ClearML, Comet, DVC, MLflow, Neptune, Ray Tune, TensorBoard,
-    and Weights & Biases.
+    additional callbacks for various integrations like ClearML, Comet, DVC, MLflow, Neptune, Ray Tune, TensorBoard, and
+    Weights & Biases.
 
     Args:
-        instance (Trainer | Predictor | Validator | Exporter): The object instance to which callbacks will be added.
-            The type of instance determines which callbacks are loaded.
+        instance (Trainer | Predictor | Validator | Exporter): The object instance to which callbacks will be added. The
+            type of instance determines which callbacks are loaded.
 
     Examples:
         >>> from ultralytics.engine.trainer import BaseTrainer

ultralytics/utils/callbacks/clearml.py

@@ -15,8 +15,7 @@ except (ImportError, AssertionError):
 
 
 def _log_debug_samples(files, title: str = "Debug Samples") -> None:
-    """
-    Log files (images) as debug samples in the ClearML task.
+    """Log files (images) as debug samples in the ClearML task.
 
     Args:
         files (list[Path]): A list of file paths in PosixPath format.
@@ -35,8 +34,7 @@ def _log_debug_samples(files, title: str = "Debug Samples") -> None:
 
 
 def _log_plot(title: str, plot_path: str) -> None:
-    """
-    Log an image as a plot in the plot section of ClearML.
+    """Log an image as a plot in the plot section of ClearML.
 
     Args:
         title (str): The title of the plot.
@@ -125,15 +123,9 @@ def on_train_end(trainer) -> None:
     """Log final model and training results on training completion."""
     if task := Task.current_task():
         # Log final results, confusion matrix and PR plots
-        files = [
-            "results.png",
-            "confusion_matrix.png",
-            "confusion_matrix_normalized.png",
-            *(f"{x}_curve.png" for x in ("F1", "PR", "P", "R")),
-        ]
-        files = [(trainer.save_dir / f) for f in files if (trainer.save_dir / f).exists()]  # filter existing files
-        for f in files:
-            _log_plot(title=f.stem, plot_path=f)
+        for f in [*trainer.plots.keys(), *trainer.validator.plots.keys()]:
+            if "batch" not in f.name:
+                _log_plot(title=f.stem, plot_path=f)
         # Report final metrics
         for k, v in trainer.validator.metrics.results_dict.items():
             task.get_logger().report_single_value(k, v)

ultralytics/utils/callbacks/comet.py

@@ -88,8 +88,7 @@ def _should_log_image_predictions() -> bool:
 
 
 def _resume_or_create_experiment(args: SimpleNamespace) -> None:
-    """
-    Resume CometML experiment or create a new experiment based on args.
+    """Resume CometML experiment or create a new experiment based on args.
 
     Ensures that the experiment object is only created in a single process during distributed training.
 
@@ -124,8 +123,7 @@ def _resume_or_create_experiment(args: SimpleNamespace) -> None:
 
 
 def _fetch_trainer_metadata(trainer) -> dict:
-    """
-    Return metadata for YOLO training including epoch and asset saving status.
+    """Return metadata for YOLO training including epoch and asset saving status.
 
     Args:
         trainer (ultralytics.engine.trainer.BaseTrainer): The YOLO trainer object containing training state and config.
@@ -150,11 +148,10 @@ def _fetch_trainer_metadata(trainer) -> dict:
 def _scale_bounding_box_to_original_image_shape(
     box, resized_image_shape, original_image_shape, ratio_pad
 ) -> list[float]:
-    """
-    Scale bounding box from resized image coordinates to original image coordinates.
+    """Scale bounding box from resized image coordinates to original image coordinates.
 
-    YOLO resizes images during training and the label values are normalized based on this resized shape.
-    This function rescales the bounding box labels to the original image shape.
+    YOLO resizes images during training and the label values are normalized based on this resized shape. This function
+    rescales the bounding box labels to the original image shape.
 
     Args:
         box (torch.Tensor): Bounding box in normalized xywh format.
@@ -181,8 +178,7 @@ def _scale_bounding_box_to_original_image_shape(
 
 
 def _format_ground_truth_annotations_for_detection(img_idx, image_path, batch, class_name_map=None) -> dict | None:
-    """
-    Format ground truth annotations for object detection.
+    """Format ground truth annotations for object detection.
 
     This function processes ground truth annotations from a batch of images for object detection tasks. It extracts
     bounding boxes, class labels, and other metadata for a specific image in the batch, and formats them for
@@ -205,7 +201,7 @@ def _format_ground_truth_annotations_for_detection(img_idx, image_path, batch, c
             - 'boxes': List of box coordinates [x, y, width, height]
             - 'label': Label string with format "gt_{class_name}"
             - 'score': Confidence score (always 1.0, scaled by _scale_confidence_score)
-        Returns None if no bounding boxes are found for the image.
+            Returns None if no bounding boxes are found for the image.
     """
     indices = batch["batch_idx"] == img_idx
     bboxes = batch["bboxes"][indices]
@@ -236,8 +232,7 @@ def _format_ground_truth_annotations_for_detection(img_idx, image_path, batch, c
 
 
 def _format_prediction_annotations(image_path, metadata, class_label_map=None, class_map=None) -> dict | None:
-    """
-    Format YOLO predictions for object detection visualization.
+    """Format YOLO predictions for object detection visualization.
 
     Args:
         image_path (Path): Path to the image file.
@@ -261,7 +256,7 @@ def _format_prediction_annotations(image_path, metadata, class_label_map=None, c
         class_label_map = {class_map[k]: v for k, v in class_label_map.items()}
     try:
         # import pycotools utilities to decompress annotations for various tasks, e.g. segmentation
-        from faster_coco_eval.core.mask import decode  # noqa
+        from faster_coco_eval.core.mask import decode
     except ImportError:
         decode = None
 
@@ -289,8 +284,7 @@ def _format_prediction_annotations(image_path, metadata, class_label_map=None, c
 
 
 def _extract_segmentation_annotation(segmentation_raw: str, decode: Callable) -> list[list[Any]] | None:
-    """
-    Extract segmentation annotation from compressed segmentations as list of polygons.
+    """Extract segmentation annotation from compressed segmentations as list of polygons.
 
     Args:
         segmentation_raw (str): Raw segmentation data in compressed format.
@@ -310,8 +304,7 @@ def _extract_segmentation_annotation(segmentation_raw: str, decode: Callable) ->
 
 
 def _fetch_annotations(img_idx, image_path, batch, prediction_metadata_map, class_label_map, class_map) -> list | None:
-    """
-    Join the ground truth and prediction annotations if they exist.
+    """Join the ground truth and prediction annotations if they exist.
 
     Args:
         img_idx (int): Index of the image in the batch.
@@ -350,25 +343,24 @@ def _create_prediction_metadata_map(model_predictions) -> dict:
 def _log_confusion_matrix(experiment, trainer, curr_step, curr_epoch) -> None:
     """Log the confusion matrix to Comet experiment."""
     conf_mat = trainer.validator.confusion_matrix.matrix
-    names = list(trainer.data["names"].values()) + ["background"]
+    names = [*list(trainer.data["names"].values()), "background"]
     experiment.log_confusion_matrix(
         matrix=conf_mat, labels=names, max_categories=len(names), epoch=curr_epoch, step=curr_step
     )
 
 
 def _log_images(experiment, image_paths, curr_step: int | None, annotations=None) -> None:
-    """
-    Log images to the experiment with optional annotations.
+    """Log images to the experiment with optional annotations.
 
-    This function logs images to a Comet ML experiment, optionally including annotation data for visualization
-    such as bounding boxes or segmentation masks.
+    This function logs images to a Comet ML experiment, optionally including annotation data for visualization such as
+    bounding boxes or segmentation masks.
 
     Args:
         experiment (comet_ml.CometExperiment): The Comet ML experiment to log images to.
         image_paths (list[Path]): List of paths to images that will be logged.
         curr_step (int): Current training step/iteration for tracking in the experiment timeline.
-        annotations (list[list[dict]], optional): Nested list of annotation dictionaries for each image. Each
-            annotation contains visualization data like bounding boxes, labels, and confidence scores.
+        annotations (list[list[dict]], optional): Nested list of annotation dictionaries for each image. Each annotation
+            contains visualization data like bounding boxes, labels, and confidence scores.
     """
     if annotations:
         for image_path, annotation in zip(image_paths, annotations):
@@ -380,11 +372,10 @@ def _log_images(experiment, image_paths, curr_step: int | None, annotations=None
 
 
 def _log_image_predictions(experiment, validator, curr_step) -> None:
-    """
-    Log predicted boxes for a single image during training.
+    """Log predicted boxes for a single image during training.
 
-    This function logs image predictions to a Comet ML experiment during model validation. It processes
-    validation data and formats both ground truth and prediction annotations for visualization in the Comet
+    This function logs image predictions to a Comet ML experiment during model validation. It processes validation data
+    and formats both ground truth and prediction annotations for visualization in the Comet
     dashboard. The function respects configured limits on the number of images to log.
 
     Args:
@@ -443,12 +434,11 @@ def _log_image_predictions(experiment, validator, curr_step) -> None:
 
 
 def _log_plots(experiment, trainer) -> None:
-    """
-    Log evaluation plots and label plots for the experiment.
+    """Log evaluation plots and label plots for the experiment.
 
     This function logs various evaluation plots and confusion matrices to the experiment tracking system. It handles
-    different types of metrics (SegmentMetrics, PoseMetrics, DetMetrics, OBBMetrics) and logs the appropriate plots
-    for each type.
+    different types of metrics (SegmentMetrics, PoseMetrics, DetMetrics, OBBMetrics) and logs the appropriate plots for
+    each type.
 
     Args:
         experiment (comet_ml.CometExperiment): The Comet ML experiment to log plots to.
@@ -503,8 +493,7 @@ def _log_image_batches(experiment, trainer, curr_step: int) -> None:
 
 
 def _log_asset(experiment, asset_path) -> None:
-    """
-    Logs a specific asset file to the given experiment.
+    """Logs a specific asset file to the given experiment.
 
     This function facilitates logging an asset, such as a file, to the provided
     experiment. It enables integration with experiment tracking platforms.
@@ -517,11 +506,9 @@ def _log_asset(experiment, asset_path) -> None:
 
 
 def _log_table(experiment, table_path) -> None:
-    """
-    Logs a table to the provided experiment.
+    """Logs a table to the provided experiment.
 
-    This function is used to log a table file to the given experiment. The table
-    is identified by its file path.
+    This function is used to log a table file to the given experiment. The table is identified by its file path.
 
     Args:
         experiment (comet_ml.CometExperiment): The experiment object where the table file will be logged.
@@ -549,16 +536,15 @@ def on_train_epoch_end(trainer) -> None:
 
 
 def on_fit_epoch_end(trainer) -> None:
-    """
-    Log model assets at the end of each epoch during training.
+    """Log model assets at the end of each epoch during training.
 
-    This function is called at the end of each training epoch to log metrics, learning rates, and model information
-    to a Comet ML experiment. It also logs model assets, confusion matrices, and image predictions based on
-    configuration settings.
+    This function is called at the end of each training epoch to log metrics, learning rates, and model information to a
+    Comet ML experiment. It also logs model assets, confusion matrices, and image predictions based on configuration
+    settings.
 
     The function retrieves the current Comet ML experiment and logs various training metrics. If it's the first epoch,
-    it also logs model information. On specified save intervals, it logs the model, confusion matrix (if enabled),
-    and image predictions (if enabled).
+    it also logs model information. On specified save intervals, it logs the model, confusion matrix (if enabled), and
+    image predictions (if enabled).
 
     Args:
         trainer (BaseTrainer): The YOLO trainer object containing training state, metrics, and configuration.