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

ultralytics/utils/export/tensorflow.py

@@ -0,0 +1,231 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import numpy as np
+import torch
+
+from ultralytics.nn.modules import Detect, Pose
+from ultralytics.utils import LOGGER
+from ultralytics.utils.downloads import attempt_download_asset
+from ultralytics.utils.files import spaces_in_path
+from ultralytics.utils.tal import make_anchors
+
+
+def tf_wrapper(model: torch.nn.Module) -> torch.nn.Module:
+    """A wrapper to add TensorFlow compatible inference methods to Detect and Pose layers."""
+    for m in model.modules():
+        if not isinstance(m, Detect):
+            continue
+        import types
+
+        m._inference = types.MethodType(_tf_inference, m)
+        if type(m) is Pose:
+            m.kpts_decode = types.MethodType(tf_kpts_decode, m)
+    return model
+
+
+def _tf_inference(self, x: list[torch.Tensor]) -> tuple[torch.Tensor]:
+    """Decode boxes and cls scores for tf object detection."""
+    shape = x[0].shape  # BCHW
+    x_cat = torch.cat([xi.view(x[0].shape[0], self.no, -1) for xi in x], 2)
+    box, cls = x_cat.split((self.reg_max * 4, self.nc), 1)
+    if self.dynamic or self.shape != shape:
+        self.anchors, self.strides = (x.transpose(0, 1) for x in make_anchors(x, self.stride, 0.5))
+        self.shape = shape
+    grid_h, grid_w = shape[2], shape[3]
+    grid_size = torch.tensor([grid_w, grid_h, grid_w, grid_h], device=box.device).reshape(1, 4, 1)
+    norm = self.strides / (self.stride[0] * grid_size)
+    dbox = self.decode_bboxes(self.dfl(box) * norm, self.anchors.unsqueeze(0) * norm[:, :2])
+    return torch.cat((dbox, cls.sigmoid()), 1)
+
+
+def tf_kpts_decode(self, bs: int, kpts: torch.Tensor) -> torch.Tensor:
+    """Decode keypoints for tf pose estimation."""
+    ndim = self.kpt_shape[1]
+    # required for TFLite export to avoid 'PLACEHOLDER_FOR_GREATER_OP_CODES' bug
+    # Precompute normalization factor to increase numerical stability
+    y = kpts.view(bs, *self.kpt_shape, -1)
+    grid_h, grid_w = self.shape[2], self.shape[3]
+    grid_size = torch.tensor([grid_w, grid_h], device=y.device).reshape(1, 2, 1)
+    norm = self.strides / (self.stride[0] * grid_size)
+    a = (y[:, :, :2] * 2.0 + (self.anchors - 0.5)) * norm
+    if ndim == 3:
+        a = torch.cat((a, y[:, :, 2:3].sigmoid()), 2)
+    return a.view(bs, self.nk, -1)
+
+
+def onnx2saved_model(
+    onnx_file: str,
+    output_dir: Path,
+    int8: bool = False,
+    images: np.ndarray = None,
+    disable_group_convolution: bool = False,
+    prefix="",
+):
+    """Convert a ONNX model to TensorFlow SavedModel format via ONNX.
+
+    Args:
+        onnx_file (str): ONNX file path.
+        output_dir (Path): Output directory path for the SavedModel.
+        int8 (bool, optional): Enable INT8 quantization. Defaults to False.
+        images (np.ndarray, optional): Calibration images for INT8 quantization in BHWC format.
+        disable_group_convolution (bool, optional): Disable group convolution optimization. Defaults to False.
+        prefix (str, optional): Logging prefix. Defaults to "".
+
+    Returns:
+        (keras.Model): Converted Keras model.
+
+    Notes:
+        - Requires onnx2tf package. Downloads calibration data if INT8 quantization is enabled.
+        - Removes temporary files and renames quantized models after conversion.
+    """
+    # Pre-download calibration file to fix https://github.com/PINTO0309/onnx2tf/issues/545
+    onnx2tf_file = Path("calibration_image_sample_data_20x128x128x3_float32.npy")
+    if not onnx2tf_file.exists():
+        attempt_download_asset(f"{onnx2tf_file}.zip", unzip=True, delete=True)
+    np_data = None
+    if int8:
+        tmp_file = output_dir / "tmp_tflite_int8_calibration_images.npy"  # int8 calibration images file
+        if images is not None:
+            output_dir.mkdir(parents=True, exist_ok=True)
+            np.save(str(tmp_file), images)  # BHWC
+            np_data = [["images", tmp_file, [[[[0, 0, 0]]]], [[[[255, 255, 255]]]]]]
+
+    # Patch onnx.helper for onnx_graphsurgeon compatibility with ONNX>=1.17
+    # The float32_to_bfloat16 function was removed in ONNX 1.17, but onnx_graphsurgeon still uses it
+    import onnx.helper
+
+    if not hasattr(onnx.helper, "float32_to_bfloat16"):
+        import struct
+
+        def float32_to_bfloat16(fval):
+            """Convert float32 to bfloat16 (truncates lower 16 bits of mantissa)."""
+            ival = struct.unpack("=I", struct.pack("=f", fval))[0]
+            return ival >> 16
+
+        onnx.helper.float32_to_bfloat16 = float32_to_bfloat16
+
+    import onnx2tf  # scoped for after ONNX export for reduced conflict during import
+
+    LOGGER.info(f"{prefix} starting TFLite export with onnx2tf {onnx2tf.__version__}...")
+    keras_model = onnx2tf.convert(
+        input_onnx_file_path=onnx_file,
+        output_folder_path=str(output_dir),
+        not_use_onnxsim=True,
+        verbosity="error",  # note INT8-FP16 activation bug https://github.com/ultralytics/ultralytics/issues/15873
+        output_integer_quantized_tflite=int8,
+        custom_input_op_name_np_data_path=np_data,
+        enable_batchmatmul_unfold=True and not int8,  # fix lower no. of detected objects on GPU delegate
+        output_signaturedefs=True,  # fix error with Attention block group convolution
+        disable_group_convolution=disable_group_convolution,  # fix error with group convolution
+    )
+
+    # Remove/rename TFLite models
+    if int8:
+        tmp_file.unlink(missing_ok=True)
+        for file in output_dir.rglob("*_dynamic_range_quant.tflite"):
+            file.rename(file.with_name(file.stem.replace("_dynamic_range_quant", "_int8") + file.suffix))
+        for file in output_dir.rglob("*_integer_quant_with_int16_act.tflite"):
+            file.unlink()  # delete extra fp16 activation TFLite files
+    return keras_model
+
+
+def keras2pb(keras_model, file: Path, prefix=""):
+    """Convert a Keras model to TensorFlow GraphDef (.pb) format.
+
+    Args:
+        keras_model (keras.Model): Keras model to convert to frozen graph format.
+        file (Path): Output file path (suffix will be changed to .pb).
+        prefix (str, optional): Logging prefix. Defaults to "".
+
+    Notes:
+        Creates a frozen graph by converting variables to constants for inference optimization.
+    """
+    import tensorflow as tf
+    from tensorflow.python.framework.convert_to_constants import convert_variables_to_constants_v2
+
+    LOGGER.info(f"\n{prefix} starting export with tensorflow {tf.__version__}...")
+    m = tf.function(lambda x: keras_model(x))  # full model
+    m = m.get_concrete_function(tf.TensorSpec(keras_model.inputs[0].shape, keras_model.inputs[0].dtype))
+    frozen_func = convert_variables_to_constants_v2(m)
+    frozen_func.graph.as_graph_def()
+    tf.io.write_graph(graph_or_graph_def=frozen_func.graph, logdir=str(file.parent), name=file.name, as_text=False)
+
+
+def tflite2edgetpu(tflite_file: str | Path, output_dir: str | Path, prefix: str = ""):
+    """Convert a TensorFlow Lite model to Edge TPU format using the Edge TPU compiler.
+
+    Args:
+        tflite_file (str | Path): Path to the input TensorFlow Lite (.tflite) model file.
+        output_dir (str | Path): Output directory path for the compiled Edge TPU model.
+        prefix (str, optional): Logging prefix. Defaults to "".
+
+    Notes:
+        Requires the Edge TPU compiler to be installed. The function compiles the TFLite model
+        for optimal performance on Google's Edge TPU hardware accelerator.
+    """
+    import subprocess
+
+    cmd = (
+        "edgetpu_compiler "
+        f'--out_dir "{output_dir}" '
+        "--show_operations "
+        "--search_delegate "
+        "--delegate_search_step 30 "
+        "--timeout_sec 180 "
+        f'"{tflite_file}"'
+    )
+    LOGGER.info(f"{prefix} running '{cmd}'")
+    subprocess.run(cmd, shell=True)
+
+
+def pb2tfjs(pb_file: str, output_dir: str, half: bool = False, int8: bool = False, prefix: str = ""):
+    """Convert a TensorFlow GraphDef (.pb) model to TensorFlow.js format.
+
+    Args:
+        pb_file (str): Path to the input TensorFlow GraphDef (.pb) model file.
+        output_dir (str): Output directory path for the converted TensorFlow.js model.
+        half (bool, optional): Enable FP16 quantization. Defaults to False.
+        int8 (bool, optional): Enable INT8 quantization. Defaults to False.
+        prefix (str, optional): Logging prefix. Defaults to "".
+
+    Notes:
+        Requires tensorflowjs package. Uses tensorflowjs_converter command-line tool for conversion.
+        Handles spaces in file paths and warns if output directory contains spaces.
+    """
+    import subprocess
+
+    import tensorflow as tf
+    import tensorflowjs as tfjs
+
+    LOGGER.info(f"\n{prefix} starting export with tensorflowjs {tfjs.__version__}...")
+
+    gd = tf.Graph().as_graph_def()  # TF GraphDef
+    with open(pb_file, "rb") as file:
+        gd.ParseFromString(file.read())
+    outputs = ",".join(gd_outputs(gd))
+    LOGGER.info(f"\n{prefix} output node names: {outputs}")
+
+    quantization = "--quantize_float16" if half else "--quantize_uint8" if int8 else ""
+    with spaces_in_path(pb_file) as fpb_, spaces_in_path(output_dir) as f_:  # exporter cannot handle spaces in paths
+        cmd = (
+            "tensorflowjs_converter "
+            f'--input_format=tf_frozen_model {quantization} --output_node_names={outputs} "{fpb_}" "{f_}"'
+        )
+        LOGGER.info(f"{prefix} running '{cmd}'")
+        subprocess.run(cmd, shell=True)
+
+    if " " in output_dir:
+        LOGGER.warning(f"{prefix} your model may not work correctly with spaces in path '{output_dir}'.")
+
+
+def gd_outputs(gd):
+    """Return TensorFlow GraphDef model output node names."""
+    name_list, input_list = [], []
+    for node in gd.node:  # tensorflow.core.framework.node_def_pb2.NodeDef
+        name_list.append(node.name)
+        input_list.extend(node.input)
+    return sorted(f"{x}:0" for x in list(set(name_list) - set(input_list)) if not x.startswith("NoOp"))

ultralytics/utils/files.py

@@ -13,11 +13,10 @@ from pathlib import Path
 
 
 class WorkingDirectory(contextlib.ContextDecorator):
-    """
-    A context manager and decorator for temporarily changing the working directory.
+    """A context manager and decorator for temporarily changing the working directory.
 
-    This class allows for the temporary change of the working directory using a context manager or decorator.
-    It ensures that the original working directory is restored after the context or decorated function completes.
+    This class allows for the temporary change of the working directory using a context manager or decorator. It ensures
+    that the original working directory is restored after the context or decorated function completes.
 
     Attributes:
         dir (Path | str): The new directory to switch to.
@@ -29,15 +28,15 @@ class WorkingDirectory(contextlib.ContextDecorator):
 
     Examples:
         Using as a context manager:
-        >>> with WorkingDirectory('/path/to/new/dir'):
-        >>> # Perform operations in the new directory
-        >>>     pass
+        >>> with WorkingDirectory("/path/to/new/dir"):
+        ...     # Perform operations in the new directory
+        ...     pass
 
         Using as a decorator:
-        >>> @WorkingDirectory('/path/to/new/dir')
-        >>> def some_function():
-        >>> # Perform operations in the new directory
-        >>>     pass
+        >>> @WorkingDirectory("/path/to/new/dir")
+        ... def some_function():
+        ...     # Perform operations in the new directory
+        ...     pass
     """
 
     def __init__(self, new_dir: str | Path):
@@ -49,15 +48,14 @@ class WorkingDirectory(contextlib.ContextDecorator):
         """Change the current working directory to the specified directory upon entering the context."""
         os.chdir(self.dir)
 
-    def __exit__(self, exc_type, exc_val, exc_tb):  # noqa
+    def __exit__(self, exc_type, exc_val, exc_tb):
         """Restore the original working directory when exiting the context."""
         os.chdir(self.cwd)
 
 
 @contextmanager
 def spaces_in_path(path: str | Path):
-    """
-    Context manager to handle paths with spaces in their names.
+    """Context manager to handle paths with spaces in their names.
 
     If a path contains spaces, it replaces them with underscores, copies the file/directory to the new path, executes
     the context code block, then copies the file/directory back to its original location.
@@ -66,13 +64,12 @@ def spaces_in_path(path: str | Path):
         path (str | Path): The original path that may contain spaces.
 
     Yields:
-        (Path | str): Temporary path with spaces replaced by underscores if spaces were present, otherwise the
-            original path.
+        (Path | str): Temporary path with any spaces replaced by underscores.
 
     Examples:
-        >>> with spaces_in_path('/path/with spaces') as new_path:
-        >>> # Your code here
-        >>>     pass
+        >>> with spaces_in_path("/path/with spaces") as new_path:
+        ...     # Your code here
+        ...     pass
     """
     # If path has spaces, replace them with underscores
     if " " in str(path):
@@ -107,12 +104,11 @@ def spaces_in_path(path: str | Path):
 
 
 def increment_path(path: str | Path, exist_ok: bool = False, sep: str = "", mkdir: bool = False) -> Path:
-    """
-    Increment a file or directory path, i.e., runs/exp --> runs/exp{sep}2, runs/exp{sep}3, ... etc.
+    """Increment a file or directory path, i.e., runs/exp --> runs/exp{sep}2, runs/exp{sep}3, ... etc.
 
-    If the path exists and `exist_ok` is not True, the path will be incremented by appending a number and `sep` to
-    the end of the path. If the path is a file, the file extension will be preserved. If the path is a directory, the
-    number will be appended directly to the end of the path.
+    If the path exists and `exist_ok` is not True, the path will be incremented by appending a number and `sep` to the
+    end of the path. If the path is a file, the file extension will be preserved. If the path is a directory, the number
+    will be appended directly to the end of the path.
 
     Args:
         path (str | Path): Path to increment.
@@ -185,8 +181,7 @@ def get_latest_run(search_dir: str = ".") -> str:
 
 
 def update_models(model_names: tuple = ("yolo11n.pt",), source_dir: Path = Path("."), update_names: bool = False):
-    """
-    Update and re-save specified YOLO models in an 'updated_models' subdirectory.
+    """Update and re-save specified YOLO models in an 'updated_models' subdirectory.
 
     Args:
         model_names (tuple, optional): Model filenames to update.
@@ -201,13 +196,14 @@ def update_models(model_names: tuple = ("yolo11n.pt",), source_dir: Path = Path(
     """
     from ultralytics import YOLO
     from ultralytics.nn.autobackend import default_class_names
+    from ultralytics.utils import LOGGER
 
     target_dir = source_dir / "updated_models"
     target_dir.mkdir(parents=True, exist_ok=True)  # Ensure target directory exists
 
     for model_name in model_names:
         model_path = source_dir / model_name
-        print(f"Loading model from {model_path}")
+        LOGGER.info(f"Loading model from {model_path}")
 
         # Load model
         model = YOLO(model_path)
@@ -219,5 +215,5 @@ def update_models(model_names: tuple = ("yolo11n.pt",), source_dir: Path = Path(
         save_path = target_dir / model_name
 
         # Save model using model.save()
-        print(f"Re-saving {model_name} model to {save_path}")
+        LOGGER.info(f"Re-saving {model_name} model to {save_path}")
         model.save(save_path)

ultralytics/utils/git.py

@@ -7,13 +7,12 @@ from pathlib import Path
 
 
 class GitRepo:
-    """
-    Represent a local Git repository and expose branch, commit, and remote metadata.
+    """Represent a local Git repository and expose branch, commit, and remote metadata.
 
     This class discovers the repository root by searching for a .git entry from the given path upward, resolves the
-    actual .git directory (including worktrees), and reads Git metadata directly from on-disk files. It does not
-    invoke the git binary and therefore works in restricted environments. All metadata properties are resolved
-    lazily and cached; construct a new instance to refresh state.
+    actual .git directory (including worktrees), and reads Git metadata directly from on-disk files. It does not invoke
+    the git binary and therefore works in restricted environments. All metadata properties are resolved lazily and
+    cached; construct a new instance to refresh state.
 
     Attributes:
         root (Path | None): Repository root directory containing the .git entry; None if not in a repository.
@@ -39,8 +38,7 @@ class GitRepo:
     """
 
     def __init__(self, path: Path = Path(__file__).resolve()):
-        """
-        Initialize a Git repository context by discovering the repository root from a starting path.
+        """Initialize a Git repository context by discovering the repository root from a starting path.
 
         Args:
             path (Path, optional): File or directory path used as the starting point to locate the repository root.
@@ -51,7 +49,7 @@ class GitRepo:
     @staticmethod
     def _find_root(p: Path) -> Path | None:
         """Return repo root or None."""
-        return next((d for d in [p] + list(p.parents) if (d / ".git").exists()), None)
+        return next((d for d in [p, *list(p.parents)] if (d / ".git").exists()), None)
 
     @staticmethod
     def _gitdir(root: Path) -> Path | None:
@@ -65,7 +63,8 @@ class GitRepo:
                 return (root / t.split(":", 1)[1].strip()).resolve()
         return None
 
-    def _read(self, p: Path | None) -> str | None:
+    @staticmethod
+    def _read(p: Path | None) -> str | None:
         """Read and strip file if exists."""
         return p.read_text(errors="ignore").strip() if p and p.exists() else None
 
@@ -77,8 +76,7 @@ class GitRepo:
     def _ref_commit(self, ref: str) -> str | None:
         """Commit for ref (handles packed-refs)."""
         rf = self.gitdir / ref
-        s = self._read(rf)
-        if s:
+        if s := self._read(rf):
             return s
         pf = self.gitdir / "packed-refs"
         b = pf.read_bytes().splitlines() if pf.exists() else []

ultralytics/utils/instance.py

@@ -33,8 +33,7 @@ __all__ = ("Bboxes", "Instances")  # tuple or list
 
 
 class Bboxes:
-    """
-    A class for handling bounding boxes in multiple formats.
+    """A class for handling bounding boxes in multiple formats.
 
     The class supports various bounding box formats like 'xyxy', 'xywh', and 'ltwh' and provides methods for format
     conversion, scaling, and area calculation. Bounding box data should be provided as numpy arrays.
@@ -61,8 +60,7 @@ class Bboxes:
     """
 
     def __init__(self, bboxes: np.ndarray, format: str = "xyxy") -> None:
-        """
-        Initialize the Bboxes class with bounding box data in a specified format.
+        """Initialize the Bboxes class with bounding box data in a specified format.
 
         Args:
             bboxes (np.ndarray): Array of bounding boxes with shape (N, 4) or (4,).
@@ -76,8 +74,7 @@ class Bboxes:
         self.format = format
 
     def convert(self, format: str) -> None:
-        """
-        Convert bounding box format from one type to another.
+        """Convert bounding box format from one type to another.
 
         Args:
             format (str): Target format for conversion, one of 'xyxy', 'xywh', or 'ltwh'.
@@ -103,12 +100,11 @@ class Bboxes:
         )
 
     def mul(self, scale: int | tuple | list) -> None:
-        """
-        Multiply bounding box coordinates by scale factor(s).
+        """Multiply bounding box coordinates by scale factor(s).
 
         Args:
-            scale (int | tuple | list): Scale factor(s) for four coordinates. If int, the same scale is applied to
-                all coordinates.
+            scale (int | tuple | list): Scale factor(s) for four coordinates. If int, the same scale is applied to all
+                coordinates.
         """
         if isinstance(scale, Number):
             scale = to_4tuple(scale)
@@ -120,12 +116,11 @@ class Bboxes:
         self.bboxes[:, 3] *= scale[3]
 
     def add(self, offset: int | tuple | list) -> None:
-        """
-        Add offset to bounding box coordinates.
+        """Add offset to bounding box coordinates.
 
         Args:
-            offset (int | tuple | list): Offset(s) for four coordinates. If int, the same offset is applied to
-                all coordinates.
+            offset (int | tuple | list): Offset(s) for four coordinates. If int, the same offset is applied to all
+                coordinates.
         """
         if isinstance(offset, Number):
             offset = to_4tuple(offset)
@@ -142,8 +137,7 @@ class Bboxes:
 
     @classmethod
     def concatenate(cls, boxes_list: list[Bboxes], axis: int = 0) -> Bboxes:
-        """
-        Concatenate a list of Bboxes objects into a single Bboxes object.
+        """Concatenate a list of Bboxes objects into a single Bboxes object.
 
         Args:
             boxes_list (list[Bboxes]): A list of Bboxes objects to concatenate.
@@ -165,8 +159,7 @@ class Bboxes:
         return cls(np.concatenate([b.bboxes for b in boxes_list], axis=axis))
 
     def __getitem__(self, index: int | np.ndarray | slice) -> Bboxes:
-        """
-        Retrieve a specific bounding box or a set of bounding boxes using indexing.
+        """Retrieve a specific bounding box or a set of bounding boxes using indexing.
 
         Args:
             index (int | slice | np.ndarray): The index, slice, or boolean array to select the desired bounding boxes.
@@ -186,12 +179,11 @@ class Bboxes:
 
 
 class Instances:
-    """
-    Container for bounding boxes, segments, and keypoints of detected objects in an image.
+    """Container for bounding boxes, segments, and keypoints of detected objects in an image.
 
-    This class provides a unified interface for handling different types of object annotations including bounding
-    boxes, segmentation masks, and keypoints. It supports various operations like scaling, normalization, clipping,
-    and format conversion.
+    This class provides a unified interface for handling different types of object annotations including bounding boxes,
+    segmentation masks, and keypoints. It supports various operations like scaling, normalization, clipping, and format
+    conversion.
 
     Attributes:
         _bboxes (Bboxes): Internal object for handling bounding box operations.
@@ -229,8 +221,7 @@ class Instances:
         bbox_format: str = "xywh",
         normalized: bool = True,
     ) -> None:
-        """
-        Initialize the Instances object with bounding boxes, segments, and keypoints.
+        """Initialize the Instances object with bounding boxes, segments, and keypoints.
 
         Args:
             bboxes (np.ndarray): Bounding boxes with shape (N, 4).
@@ -245,8 +236,7 @@ class Instances:
         self.segments = segments
 
     def convert_bbox(self, format: str) -> None:
-        """
-        Convert bounding box format.
+        """Convert bounding box format.
 
         Args:
             format (str): Target format for conversion, one of 'xyxy', 'xywh', or 'ltwh'.
@@ -259,8 +249,7 @@ class Instances:
         return self._bboxes.areas()
 
     def scale(self, scale_w: float, scale_h: float, bbox_only: bool = False):
-        """
-        Scale coordinates by given factors.
+        """Scale coordinates by given factors.
 
         Args:
             scale_w (float): Scale factor for width.
@@ -277,8 +266,7 @@ class Instances:
             self.keypoints[..., 1] *= scale_h
 
     def denormalize(self, w: int, h: int) -> None:
-        """
-        Convert normalized coordinates to absolute coordinates.
+        """Convert normalized coordinates to absolute coordinates.
 
         Args:
             w (int): Image width.
@@ -295,8 +283,7 @@ class Instances:
         self.normalized = False
 
     def normalize(self, w: int, h: int) -> None:
-        """
-        Convert absolute coordinates to normalized coordinates.
+        """Convert absolute coordinates to normalized coordinates.
 
         Args:
             w (int): Image width.
@@ -313,8 +300,7 @@ class Instances:
         self.normalized = True
 
     def add_padding(self, padw: int, padh: int) -> None:
-        """
-        Add padding to coordinates.
+        """Add padding to coordinates.
 
         Args:
             padw (int): Padding width.
@@ -329,8 +315,7 @@ class Instances:
             self.keypoints[..., 1] += padh
 
     def __getitem__(self, index: int | np.ndarray | slice) -> Instances:
-        """
-        Retrieve a specific instance or a set of instances using indexing.
+        """Retrieve a specific instance or a set of instances using indexing.
 
         Args:
             index (int | slice | np.ndarray): The index, slice, or boolean array to select the desired instances.
@@ -355,8 +340,7 @@ class Instances:
         )
 
     def flipud(self, h: int) -> None:
-        """
-        Flip coordinates vertically.
+        """Flip coordinates vertically.
 
         Args:
             h (int): Image height.
@@ -373,8 +357,7 @@ class Instances:
             self.keypoints[..., 1] = h - self.keypoints[..., 1]
 
     def fliplr(self, w: int) -> None:
-        """
-        Flip coordinates horizontally.
+        """Flip coordinates horizontally.
 
         Args:
             w (int): Image width.
@@ -391,8 +374,7 @@ class Instances:
             self.keypoints[..., 0] = w - self.keypoints[..., 0]
 
     def clip(self, w: int, h: int) -> None:
-        """
-        Clip coordinates to stay within image boundaries.
+        """Clip coordinates to stay within image boundaries.
 
         Args:
             w (int): Image width.
@@ -418,8 +400,7 @@ class Instances:
             self.keypoints[..., 1] = self.keypoints[..., 1].clip(0, h)
 
     def remove_zero_area_boxes(self) -> np.ndarray:
-        """
-        Remove zero-area boxes, i.e. after clipping some boxes may have zero width or height.
+        """Remove zero-area boxes, i.e. after clipping some boxes may have zero width or height.
 
         Returns:
             (np.ndarray): Boolean array indicating which boxes were kept.
@@ -434,8 +415,7 @@ class Instances:
         return good
 
     def update(self, bboxes: np.ndarray, segments: np.ndarray = None, keypoints: np.ndarray = None):
-        """
-        Update instance variables.
+        """Update instance variables.
 
         Args:
             bboxes (np.ndarray): New bounding boxes.
@@ -454,16 +434,15 @@ class Instances:
 
     @classmethod
     def concatenate(cls, instances_list: list[Instances], axis=0) -> Instances:
-        """
-        Concatenate a list of Instances objects into a single Instances object.
+        """Concatenate a list of Instances objects into a single Instances object.
 
         Args:
             instances_list (list[Instances]): A list of Instances objects to concatenate.
             axis (int, optional): The axis along which the arrays will be concatenated.
 
         Returns:
-            (Instances): A new Instances object containing the concatenated bounding boxes, segments, and keypoints
-                if present.
+            (Instances): A new Instances object containing the concatenated bounding boxes, segments, and keypoints if
+                present.
 
         Notes:
             The `Instances` objects in the list should have the same properties, such as the format of the bounding