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

ultralytics/utils/ops.py

@@ -18,15 +18,16 @@ class Profile(contextlib.ContextDecorator):
     """
     YOLOv8 Profile class. Use as a decorator with @Profile() or as a context manager with 'with Profile():'.
 
-    Example:
-        ```python
-        from ultralytics.utils.ops import Profile
+    Attributes:
+        t (float): Accumulated time.
+        device (torch.device): Device used for model inference.
+        cuda (bool): Whether CUDA is being used.
 
-        with Profile(device=device) as dt:
-            pass  # slow operation here
-
-        print(dt)  # prints "Elapsed time is 9.5367431640625e-07 s"
-        ```
+    Examples:
+        >>> from ultralytics.utils.ops import Profile
+        >>> with Profile(device=device) as dt:
+        ...     pass  # slow operation here
+        >>> print(dt)  # prints "Elapsed time is 9.5367431640625e-07 s"
     """
 
     def __init__(self, t=0.0, device: torch.device = None):
@@ -34,8 +35,8 @@ class Profile(contextlib.ContextDecorator):
         Initialize the Profile class.
 
         Args:
-            t (float): Initial time. Defaults to 0.0.
-            device (torch.device): Devices used for model inference. Defaults to None (cpu).
+            t (float): Initial time.
+            device (torch.device): Device used for model inference.
         """
         self.t = t
         self.device = device
@@ -67,12 +68,12 @@ def segment2box(segment, width=640, height=640):
     Convert 1 segment label to 1 box label, applying inside-image constraint, i.e. (xy1, xy2, ...) to (xyxy).
 
     Args:
-        segment (torch.Tensor): the segment label
-        width (int): the width of the image. Defaults to 640
-        height (int): The height of the image. Defaults to 640
+        segment (torch.Tensor): The segment label.
+        width (int): The width of the image.
+        height (int): The height of the image.
 
     Returns:
-        (np.ndarray): the minimum and maximum x and y values of the segment.
+        (np.ndarray): The minimum and maximum x and y values of the segment.
     """
     x, y = segment.T  # segment xy
     # any 3 out of 4 sides are outside the image, clip coordinates first, https://github.com/ultralytics/ultralytics/pull/18294
@@ -91,21 +92,20 @@ def segment2box(segment, width=640, height=640):
 
 def scale_boxes(img1_shape, boxes, img0_shape, ratio_pad=None, padding=True, xywh=False):
     """
-    Rescales bounding boxes (in the format of xyxy by default) from the shape of the image they were originally
-    specified in (img1_shape) to the shape of a different image (img0_shape).
+    Rescale bounding boxes from img1_shape to img0_shape.
 
     Args:
         img1_shape (tuple): The shape of the image that the bounding boxes are for, in the format of (height, width).
-        boxes (torch.Tensor): the bounding boxes of the objects in the image, in the format of (x1, y1, x2, y2)
-        img0_shape (tuple): the shape of the target image, in the format of (height, width).
-        ratio_pad (tuple): a tuple of (ratio, pad) for scaling the boxes. If not provided, the ratio and pad will be
+        boxes (torch.Tensor): The bounding boxes of the objects in the image, in the format of (x1, y1, x2, y2).
+        img0_shape (tuple): The shape of the target image, in the format of (height, width).
+        ratio_pad (tuple): A tuple of (ratio, pad) for scaling the boxes. If not provided, the ratio and pad will be
             calculated based on the size difference between the two images.
         padding (bool): If True, assuming the boxes is based on image augmented by yolo style. If False then do regular
             rescaling.
-        xywh (bool): The box format is xywh or not, default=False.
+        xywh (bool): The box format is xywh or not.
 
     Returns:
-        boxes (torch.Tensor): The scaled bounding boxes, in the format of (x1, y1, x2, y2)
+        (torch.Tensor): The scaled bounding boxes, in the format of (x1, y1, x2, y2).
     """
     if ratio_pad is None:  # calculate from img0_shape
         gain = min(img1_shape[0] / img0_shape[0], img1_shape[1] / img0_shape[1])  # gain  = old / new
@@ -150,8 +150,8 @@ def nms_rotated(boxes, scores, threshold=0.45, use_triu=True):
     Args:
         boxes (torch.Tensor): Rotated bounding boxes, shape (N, 5), format xywhr.
         scores (torch.Tensor): Confidence scores, shape (N,).
-        threshold (float, optional): IoU threshold. Defaults to 0.45.
-        use_triu (bool, optional): Whether to use `torch.triu` operator. It'd be useful for disable it
+        threshold (float): IoU threshold.
+        use_triu (bool): Whether to use `torch.triu` operator. It'd be useful for disable it
             when exporting obb models to some formats that do not support `torch.triu`.
 
     Returns:
@@ -214,7 +214,7 @@ def non_max_suppression(
             list contains the apriori labels for a given image. The list should be in the format
             output by a dataloader, with each label being a tuple of (class_index, x1, y1, x2, y2).
         max_det (int): The maximum number of boxes to keep after NMS.
-        nc (int, optional): The number of classes output by the model. Any indices after this will be considered masks.
+        nc (int): The number of classes output by the model. Any indices after this will be considered masks.
         max_time_img (float): The maximum time (seconds) for processing one image.
         max_nms (int): The maximum number of boxes into torchvision.ops.nms().
         max_wh (int): The maximum box width and height in pixels.
@@ -337,7 +337,7 @@ def clip_boxes(boxes, shape):
     Takes a list of bounding boxes and a shape (height, width) and clips the bounding boxes to the shape.
 
     Args:
-        boxes (torch.Tensor): The bounding boxes to clip.
+        boxes (torch.Tensor | numpy.ndarray): The bounding boxes to clip.
         shape (tuple): The shape of the image.
 
     Returns:
@@ -363,7 +363,7 @@ def clip_coords(coords, shape):
         shape (tuple): A tuple of integers representing the size of the image in the format (height, width).
 
     Returns:
-        (torch.Tensor | numpy.ndarray): Clipped coordinates
+        (torch.Tensor | numpy.ndarray): Clipped coordinates.
     """
     if isinstance(coords, torch.Tensor):  # faster individually (WARNING: inplace .clamp_() Apple MPS bug)
         coords[..., 0] = coords[..., 0].clamp(0, shape[1])  # x
@@ -455,10 +455,11 @@ def xywhn2xyxy(x, w=640, h=640, padw=0, padh=0):
 
     Args:
         x (np.ndarray | torch.Tensor): The bounding box coordinates.
-        w (int): Width of the image. Defaults to 640
-        h (int): Height of the image. Defaults to 640
-        padw (int): Padding width. Defaults to 0
-        padh (int): Padding height. Defaults to 0
+        w (int): Width of the image.
+        h (int): Height of the image.
+        padw (int): Padding width.
+        padh (int): Padding height.
+
     Returns:
         y (np.ndarray | torch.Tensor): The coordinates of the bounding box in the format [x1, y1, x2, y2] where
             x1,y1 is the top-left corner, x2,y2 is the bottom-right corner of the bounding box.
@@ -479,10 +480,10 @@ def xyxy2xywhn(x, w=640, h=640, clip=False, eps=0.0):
 
     Args:
         x (np.ndarray | torch.Tensor): The input bounding box coordinates in (x1, y1, x2, y2) format.
-        w (int): The width of the image. Defaults to 640
-        h (int): The height of the image. Defaults to 640
-        clip (bool): If True, the boxes will be clipped to the image boundaries. Defaults to False
-        eps (float): The minimum value of the box's width and height. Defaults to 0.0
+        w (int): The width of the image.
+        h (int): The height of the image.
+        clip (bool): If True, the boxes will be clipped to the image boundaries.
+        eps (float): The minimum value of the box's width and height.
 
     Returns:
         y (np.ndarray | torch.Tensor): The bounding box coordinates in (x, y, width, height, normalized) format
@@ -602,13 +603,13 @@ def xywhr2xyxyxyxy(x):
 
 def ltwh2xyxy(x):
     """
-    It converts the bounding box from [x1, y1, w, h] to [x1, y1, x2, y2] where xy1=top-left, xy2=bottom-right.
+    Convert bounding box from [x1, y1, w, h] to [x1, y1, x2, y2] where xy1=top-left, xy2=bottom-right.
 
     Args:
-        x (np.ndarray | torch.Tensor): the input image
+        x (np.ndarray | torch.Tensor): The input image.
 
     Returns:
-        y (np.ndarray | torch.Tensor): the xyxy coordinates of the bounding boxes.
+        (np.ndarray | torch.Tensor): The xyxy coordinates of the bounding boxes.
     """
     y = x.clone() if isinstance(x, torch.Tensor) else np.copy(x)
     y[..., 2] = x[..., 2] + x[..., 0]  # width
@@ -618,13 +619,13 @@ def ltwh2xyxy(x):
 
 def segments2boxes(segments):
     """
-    It converts segment labels to box labels, i.e. (cls, xy1, xy2, ...) to (cls, xywh).
+    Convert segment labels to box labels, i.e. (cls, xy1, xy2, ...) to (cls, xywh).
 
     Args:
-        segments (list): list of segments, each segment is a list of points, each point is a list of x, y coordinates
+        segments (List): List of segments, each segment is a list of points, each point is a list of x, y coordinates.
 
     Returns:
-        (np.ndarray): the xywh coordinates of the bounding boxes.
+        (np.ndarray): The xywh coordinates of the bounding boxes.
     """
     boxes = []
     for s in segments:
@@ -638,11 +639,11 @@ def resample_segments(segments, n=1000):
     Inputs a list of segments (n,2) and returns a list of segments (n,2) up-sampled to n points each.
 
     Args:
-        segments (list): a list of (n,2) arrays, where n is the number of points in the segment.
-        n (int): number of points to resample the segment to. Defaults to 1000
+        segments (List): A list of (n,2) arrays, where n is the number of points in the segment.
+        n (int): Number of points to resample the segment to.
 
     Returns:
-        segments (list): the resampled segments.
+        segments (List): The resampled segments.
     """
     for i, s in enumerate(segments):
         if len(s) == n:
@@ -659,14 +660,14 @@ def resample_segments(segments, n=1000):
 
 def crop_mask(masks, boxes):
     """
-    It takes a mask and a bounding box, and returns a mask that is cropped to the bounding box.
+    Crop masks to bounding boxes.
 
     Args:
-        masks (torch.Tensor): [n, h, w] tensor of masks
-        boxes (torch.Tensor): [n, 4] tensor of bbox coordinates in relative point form
+        masks (torch.Tensor): [n, h, w] tensor of masks.
+        boxes (torch.Tensor): [n, 4] tensor of bbox coordinates in relative point form.
 
     Returns:
-        (torch.Tensor): The masks are being cropped to the bounding box.
+        (torch.Tensor): Cropped masks.
     """
     _, h, w = masks.shape
     x1, y1, x2, y2 = torch.chunk(boxes[:, :, None], 4, 1)  # x1 shape(n,1,1)
@@ -685,7 +686,7 @@ def process_mask(protos, masks_in, bboxes, shape, upsample=False):
         masks_in (torch.Tensor): A tensor of shape [n, mask_dim], where n is the number of masks after NMS.
         bboxes (torch.Tensor): A tensor of shape [n, 4], where n is the number of masks after NMS.
         shape (tuple): A tuple of integers representing the size of the input image in the format (h, w).
-        upsample (bool): A flag to indicate whether to upsample the mask to the original image size. Default is False.
+        upsample (bool): A flag to indicate whether to upsample the mask to the original image size.
 
     Returns:
         (torch.Tensor): A binary mask tensor of shape [n, h, w], where n is the number of masks after NMS, and h and w
@@ -711,16 +712,16 @@ def process_mask(protos, masks_in, bboxes, shape, upsample=False):
 
 def process_mask_native(protos, masks_in, bboxes, shape):
     """
-    It takes the output of the mask head, and crops it after upsampling to the bounding boxes.
+    Apply masks to bounding boxes using the output of the mask head with native upsampling.
 
     Args:
-        protos (torch.Tensor): [mask_dim, mask_h, mask_w]
+        protos (torch.Tensor): [mask_dim, mask_h, mask_w].
         masks_in (torch.Tensor): [n, mask_dim], n is number of masks after nms.
         bboxes (torch.Tensor): [n, 4], n is number of masks after nms.
         shape (tuple): The size of the input image (h,w).
 
     Returns:
-        masks (torch.Tensor): The returned masks with dimensions [h, w, n].
+        (torch.Tensor): The returned masks with dimensions [h, w, n].
     """
     c, mh, mw = protos.shape  # CHW
     masks = (masks_in @ protos.float().view(c, -1)).view(-1, mh, mw)
@@ -738,6 +739,9 @@ def scale_masks(masks, shape, padding=True):
         shape (tuple): Height and width.
         padding (bool): If True, assuming the boxes is based on image augmented by yolo style. If False then do regular
             rescaling.
+
+    Returns:
+        (torch.Tensor): Rescaled masks.
     """
     mh, mw = masks.shape[2:]
     gain = min(mh / shape[0], mw / shape[1])  # gain  = old / new
@@ -759,10 +763,10 @@ def scale_coords(img1_shape, coords, img0_shape, ratio_pad=None, normalize=False
 
     Args:
         img1_shape (tuple): The shape of the image that the coords are from.
-        coords (torch.Tensor): the coords to be scaled of shape n,2.
-        img0_shape (tuple): the shape of the image that the segmentation is being applied to.
-        ratio_pad (tuple): the ratio of the image size to the padded image size.
-        normalize (bool): If True, the coordinates will be normalized to the range [0, 1]. Defaults to False.
+        coords (torch.Tensor): The coords to be scaled of shape n,2.
+        img0_shape (tuple): The shape of the image that the segmentation is being applied to.
+        ratio_pad (tuple): The ratio of the image size to the padded image size.
+        normalize (bool): If True, the coordinates will be normalized to the range [0, 1].
         padding (bool): If True, assuming the boxes is based on image augmented by yolo style. If False then do regular
             rescaling.
 
@@ -809,14 +813,14 @@ def regularize_rboxes(rboxes):
 
 def masks2segments(masks, strategy="all"):
     """
-    It takes a list of masks(n,h,w) and returns a list of segments(n,xy).
+    Convert masks to segments.
 
     Args:
-        masks (torch.Tensor): the output of the model, which is a tensor of shape (batch_size, 160, 160)
-        strategy (str): 'all' or 'largest'. Defaults to all
+        masks (torch.Tensor): The output of the model, which is a tensor of shape (batch_size, 160, 160).
+        strategy (str): 'all' or 'largest'.
 
     Returns:
-        segments (List): list of segment masks
+        (List): List of segment masks.
     """
     from ultralytics.data.converter import merge_multi_segment
 
@@ -856,10 +860,10 @@ def clean_str(s):
     Cleans a string by replacing special characters with '_' character.
 
     Args:
-        s (str): a string needing special characters replaced
+        s (str): A string needing special characters replaced.
 
     Returns:
-        (str): a string with special characters replaced by an underscore _
+        (str): A string with special characters replaced by an underscore _.
     """
     return re.sub(pattern="[|@#!¡·$€%&()=?¿^*;:,¨´><+]", repl="_", string=s)
 

ultralytics/utils/patches.py

@@ -18,7 +18,7 @@ def imread(filename: str, flags: int = cv2.IMREAD_COLOR):
 
     Args:
         filename (str): Path to the file to read.
-        flags (int, optional): Flag that can take values of cv2.IMREAD_*. Defaults to cv2.IMREAD_COLOR.
+        flags (int, optional): Flag that can take values of cv2.IMREAD_*.
 
     Returns:
         (np.ndarray): The read image.
@@ -33,7 +33,7 @@ def imwrite(filename: str, img: np.ndarray, params=None):
     Args:
         filename (str): Path to the file to write.
         img (np.ndarray): Image to write.
-        params (list of ints, optional): Additional parameters. See OpenCV documentation.
+        params (List[int], optional): Additional parameters for image encoding.
 
     Returns:
         (bool): True if the file was written, False otherwise.
@@ -47,7 +47,7 @@ def imwrite(filename: str, img: np.ndarray, params=None):
 
 def imshow(winname: str, mat: np.ndarray):
     """
-    Displays an image in the specified window.
+    Display an image in the specified window.
 
     Args:
         winname (str): Name of the window.
@@ -88,11 +88,13 @@ def torch_load(*args, **kwargs):
 
 def torch_save(*args, **kwargs):
     """
-    Optionally use dill to serialize lambda functions where pickle does not, adding robustness with 3 retries and
-    exponential standoff in case of save failure.
+    Save PyTorch objects with retry mechanism for robustness.
+
+    This function wraps torch.save with 3 retries and exponential backoff in case of save failures, which can occur
+    due to device flushing delays or antivirus scanning.
 
     Args:
-        *args (tuple): Positional arguments to pass to torch.save.
+        *args (Any): Positional arguments to pass to torch.save.
         **kwargs (Any): Keyword arguments to pass to torch.save.
     """
     for i in range(4):  # 3 retries

ultralytics/utils/plotting.py

@@ -25,9 +25,9 @@ class Colors:
     RGB values.
 
     Attributes:
-        palette (list of tuple): List of RGB color values.
+        palette (List[Tuple]): List of RGB color values.
         n (int): The number of colors in the palette.
-        pose_palette (np.ndarray): A specific color palette array with dtype np.uint8.
+        pose_palette (np.ndarray): A specific color palette array for pose estimation with dtype np.uint8.
 
     Examples:
         >>> from ultralytics.utils.plotting import Colors
@@ -142,13 +142,13 @@ class Colors:
         )
 
     def __call__(self, i, bgr=False):
-        """Converts hex color codes to RGB values."""
+        """Convert hex color codes to RGB values."""
         c = self.palette[int(i) % self.n]
         return (c[2], c[1], c[0]) if bgr else c
 
     @staticmethod
     def hex2rgb(h):
-        """Converts hex color codes to RGB values (i.e. default PIL order)."""
+        """Convert hex color codes to RGB values (i.e. default PIL order)."""
         return tuple(int(h[1 + i : 1 + i + 2], 16) for i in (0, 2, 4))
 
 
@@ -160,13 +160,15 @@ class Annotator:
     Ultralytics Annotator for train/val mosaics and JPGs and predictions annotations.
 
     Attributes:
-        im (Image.Image or numpy array): The image to annotate.
+        im (Image.Image or np.ndarray): The image to annotate.
         pil (bool): Whether to use PIL or cv2 for drawing annotations.
         font (ImageFont.truetype or ImageFont.load_default): Font used for text annotations.
         lw (float): Line width for drawing.
         skeleton (List[List[int]]): Skeleton structure for keypoints.
         limb_color (List[int]): Color palette for limbs.
         kpt_color (List[int]): Color palette for keypoints.
+        dark_colors (set): Set of colors considered dark for text contrast.
+        light_colors (set): Set of colors considered light for text contrast.
 
     Examples:
         >>> from ultralytics.utils.plotting import Annotator
@@ -256,7 +258,7 @@ class Annotator:
             txt_color (tuple, optional): The color of the text (R, G, B).
 
         Returns:
-            txt_color (tuple): Text color for label
+            (tuple): Text color for label.
 
         Examples:
             >>> from ultralytics.utils.plotting import Annotator
@@ -273,14 +275,14 @@ class Annotator:
 
     def box_label(self, box, label="", color=(128, 128, 128), txt_color=(255, 255, 255), rotated=False):
         """
-        Draws a bounding box to image with label.
+        Draw a bounding box on an image with a given label.
 
         Args:
             box (tuple): The bounding box coordinates (x1, y1, x2, y2).
-            label (str): The text label to be displayed.
+            label (str, optional): The text label to be displayed.
             color (tuple, optional): The background color of the rectangle (B, G, R).
             txt_color (tuple, optional): The color of the text (R, G, B).
-            rotated (bool, optional): Variable used to check if task is OBB
+            rotated (bool, optional): Whether the task is oriented bounding box detection.
 
         Examples:
             >>> from ultralytics.utils.plotting import Annotator
@@ -340,11 +342,11 @@ class Annotator:
         Plot masks on image.
 
         Args:
-            masks (tensor): Predicted masks on cuda, shape: [n, h, w]
-            colors (List[List[Int]]): Colors for predicted masks, [[r, g, b] * n]
-            im_gpu (tensor): Image is in cuda, shape: [3, h, w], range: [0, 1]
-            alpha (float): Mask transparency: 0.0 fully transparent, 1.0 opaque
-            retina_masks (bool): Whether to use high resolution masks or not. Defaults to False.
+            masks (torch.Tensor): Predicted masks on cuda, shape: [n, h, w]
+            colors (List[List[int]]): Colors for predicted masks, [[r, g, b] * n]
+            im_gpu (torch.Tensor): Image is in cuda, shape: [3, h, w], range: [0, 1]
+            alpha (float, optional): Mask transparency: 0.0 fully transparent, 1.0 opaque.
+            retina_masks (bool, optional): Whether to use high resolution masks or not.
         """
         if self.pil:
             # Convert to numpy first
@@ -377,11 +379,11 @@ class Annotator:
 
         Args:
             kpts (torch.Tensor): Keypoints, shape [17, 3] (x, y, confidence).
-            shape (tuple, optional): Image shape (h, w). Defaults to (640, 640).
-            radius (int, optional): Keypoint radius. Defaults to 5.
-            kpt_line (bool, optional): Draw lines between keypoints. Defaults to True.
-            conf_thres (float, optional): Confidence threshold. Defaults to 0.25.
-            kpt_color (tuple, optional): Keypoint color (B, G, R). Defaults to None.
+            shape (tuple, optional): Image shape (h, w).
+            radius (int, optional): Keypoint radius.
+            kpt_line (bool, optional): Draw lines between keypoints.
+            conf_thres (float, optional): Confidence threshold.
+            kpt_color (tuple, optional): Keypoint color (B, G, R).
 
         Note:
             - `kpt_line=True` currently only supports human pose plotting.
@@ -436,7 +438,16 @@ class Annotator:
         self.draw.rectangle(xy, fill, outline, width)
 
     def text(self, xy, text, txt_color=(255, 255, 255), anchor="top", box_style=False):
-        """Adds text to an image using PIL or cv2."""
+        """
+        Add text to an image using PIL or cv2.
+
+        Args:
+            xy (List[int]): Top-left coordinates for text placement.
+            text (str): Text to be drawn.
+            txt_color (tuple, optional): Text color (R, G, B).
+            anchor (str, optional): Text anchor position ('top' or 'bottom').
+            box_style (bool, optional): Whether to draw text with a background box.
+        """
         if anchor == "bottom":  # start y from font bottom
             w, h = self.font.getsize(text)  # text width, height
             xy[1] += 1 - h
@@ -492,7 +503,7 @@ class Annotator:
     @staticmethod
     def get_bbox_dimension(bbox=None):
         """
-        Calculate the area of a bounding box.
+        Calculate the dimensions and area of a bounding box.
 
         Args:
             bbox (tuple): Bounding box coordinates in the format (x_min, y_min, x_max, y_max).
@@ -517,7 +528,16 @@ class Annotator:
 @TryExcept()  # known issue https://github.com/ultralytics/yolov5/issues/5395
 @plt_settings()
 def plot_labels(boxes, cls, names=(), save_dir=Path(""), on_plot=None):
-    """Plot training labels including class histograms and box statistics."""
+    """
+    Plot training labels including class histograms and box statistics.
+
+    Args:
+        boxes (np.ndarray): Bounding box coordinates in format [x, y, width, height].
+        cls (np.ndarray): Class indices.
+        names (Dict, optional): Dictionary mapping class indices to class names.
+        save_dir (Path, optional): Directory to save the plot.
+        on_plot (Callable, optional): Function to call after plot is saved.
+    """
     import pandas  # scope for faster 'import ultralytics'
     import seaborn  # scope for faster 'import ultralytics'
 
@@ -580,25 +600,22 @@ def save_one_box(xyxy, im, file=Path("im.jpg"), gain=1.02, pad=10, square=False,
 
     Args:
         xyxy (torch.Tensor or list): A tensor or list representing the bounding box in xyxy format.
-        im (numpy.ndarray): The input image.
-        file (Path, optional): The path where the cropped image will be saved. Defaults to 'im.jpg'.
-        gain (float, optional): A multiplicative factor to increase the size of the bounding box. Defaults to 1.02.
-        pad (int, optional): The number of pixels to add to the width and height of the bounding box. Defaults to 10.
-        square (bool, optional): If True, the bounding box will be transformed into a square. Defaults to False.
-        BGR (bool, optional): If True, the image will be saved in BGR format, otherwise in RGB. Defaults to False.
-        save (bool, optional): If True, the cropped image will be saved to disk. Defaults to True.
+        im (np.ndarray): The input image.
+        file (Path, optional): The path where the cropped image will be saved.
+        gain (float, optional): A multiplicative factor to increase the size of the bounding box.
+        pad (int, optional): The number of pixels to add to the width and height of the bounding box.
+        square (bool, optional): If True, the bounding box will be transformed into a square.
+        BGR (bool, optional): If True, the image will be saved in BGR format, otherwise in RGB.
+        save (bool, optional): If True, the cropped image will be saved to disk.
 
     Returns:
-        (numpy.ndarray): The cropped image.
-
-    Example:
-        ```python
-        from ultralytics.utils.plotting import save_one_box
+        (np.ndarray): The cropped image.
 
-        xyxy = [50, 50, 150, 150]
-        im = cv2.imread("image.jpg")
-        cropped_im = save_one_box(xyxy, im, file="cropped.jpg", square=True)
-        ```
+    Examples:
+        >>> from ultralytics.utils.plotting import save_one_box
+        >>> xyxy = [50, 50, 150, 150]
+        >>> im = cv2.imread("image.jpg")
+        >>> cropped_im = save_one_box(xyxy, im, file="cropped.jpg", square=True)
     """
     if not isinstance(xyxy, torch.Tensor):  # may be list
         xyxy = torch.stack(xyxy)
@@ -656,7 +673,7 @@ def plot_images(
         conf_thres: Confidence threshold for displaying detections.
 
     Returns:
-        np.ndarray: Plotted image grid as a numpy array if save is False, None otherwise.
+        (np.ndarray): Plotted image grid as a numpy array if save is False, None otherwise.
 
     Note:
         This function supports both tensor and numpy array inputs. It will automatically
@@ -792,20 +809,16 @@ def plot_results(file="path/to/results.csv", dir="", segment=False, pose=False,
     pose estimation, and classification. Plots are saved as 'results.png' in the directory where the CSV is located.
 
     Args:
-        file (str, optional): Path to the CSV file containing the training results. Defaults to 'path/to/results.csv'.
-        dir (str, optional): Directory where the CSV file is located if 'file' is not provided. Defaults to ''.
-        segment (bool, optional): Flag to indicate if the data is for segmentation. Defaults to False.
-        pose (bool, optional): Flag to indicate if the data is for pose estimation. Defaults to False.
-        classify (bool, optional): Flag to indicate if the data is for classification. Defaults to False.
+        file (str, optional): Path to the CSV file containing the training results.
+        dir (str, optional): Directory where the CSV file is located if 'file' is not provided.
+        segment (bool, optional): Flag to indicate if the data is for segmentation.
+        pose (bool, optional): Flag to indicate if the data is for pose estimation.
+        classify (bool, optional): Flag to indicate if the data is for classification.
         on_plot (callable, optional): Callback function to be executed after plotting. Takes filename as an argument.
-            Defaults to None.
-
-    Example:
-        ```python
-        from ultralytics.utils.plotting import plot_results
 
-        plot_results("path/to/results.csv", segment=True)
-        ```
+    Examples:
+        >>> from ultralytics.utils.plotting import plot_results
+        >>> plot_results("path/to/results.csv", segment=True)
     """
     import pandas as pd  # scope for faster 'import ultralytics'
     from scipy.ndimage import gaussian_filter1d
@@ -851,15 +864,15 @@ def plot_results(file="path/to/results.csv", dir="", segment=False, pose=False,
 
 def plt_color_scatter(v, f, bins=20, cmap="viridis", alpha=0.8, edgecolors="none"):
     """
-    Plots a scatter plot with points colored based on a 2D histogram.
+    Plot a scatter plot with points colored based on a 2D histogram.
 
     Args:
         v (array-like): Values for the x-axis.
         f (array-like): Values for the y-axis.
-        bins (int, optional): Number of bins for the histogram. Defaults to 20.
-        cmap (str, optional): Colormap for the scatter plot. Defaults to 'viridis'.
-        alpha (float, optional): Alpha for the scatter plot. Defaults to 0.8.
-        edgecolors (str, optional): Edge colors for the scatter plot. Defaults to 'none'.
+        bins (int, optional): Number of bins for the histogram.
+        cmap (str, optional): Colormap for the scatter plot.
+        alpha (float, optional): Alpha for the scatter plot.
+        edgecolors (str, optional): Edge colors for the scatter plot.
 
     Examples:
         >>> v = np.random.rand(100)
@@ -886,7 +899,7 @@ def plot_tune_results(csv_file="tune_results.csv"):
     in the CSV, color-coded based on fitness scores. The best-performing configurations are highlighted on the plots.
 
     Args:
-        csv_file (str, optional): Path to the CSV file containing the tuning results. Defaults to 'tune_results.csv'.
+        csv_file (str, optional): Path to the CSV file containing the tuning results.
 
     Examples:
         >>> plot_tune_results("path/to/tune_results.csv")
@@ -965,8 +978,8 @@ def feature_visualization(x, module_type, stage, n=32, save_dir=Path("runs/detec
         x (torch.Tensor): Features to be visualized.
         module_type (str): Module type.
         stage (int): Module stage within the model.
-        n (int, optional): Maximum number of feature maps to plot. Defaults to 32.
-        save_dir (Path, optional): Directory to save results. Defaults to Path('runs/detect/exp').
+        n (int, optional): Maximum number of feature maps to plot.
+        save_dir (Path, optional): Directory to save results.
     """
     for m in {"Detect", "Segment", "Pose", "Classify", "OBB", "RTDETRDecoder"}:  # all model heads
         if m in module_type: