ultralytics 8.3.163__py3-none-any.whl → 8.3.164__py3-none-any.whl

ultralytics/models/sam/modules/memory_attention.py

@@ -4,7 +4,7 @@ import copy
 from typing import Optional
 
 import torch
-from torch import Tensor, nn
+from torch import nn
 
 from .blocks import RoPEAttention
 
@@ -103,7 +103,7 @@ class MemoryAttentionLayer(nn.Module):
         self.pos_enc_at_cross_attn_queries = pos_enc_at_cross_attn_queries
         self.pos_enc_at_cross_attn_keys = pos_enc_at_cross_attn_keys
 
-    def _forward_sa(self, tgt: Tensor, query_pos: Optional[Tensor]) -> Tensor:
+    def _forward_sa(self, tgt: torch.Tensor, query_pos: Optional[torch.Tensor]) -> torch.Tensor:
         """Perform self-attention on input tensor using positional encoding and RoPE attention mechanism."""
         tgt2 = self.norm1(tgt)
         q = k = tgt2 + query_pos if self.pos_enc_at_attn else tgt2
@@ -113,12 +113,12 @@ class MemoryAttentionLayer(nn.Module):
 
     def _forward_ca(
         self,
-        tgt: Tensor,
-        memory: Tensor,
-        query_pos: Optional[Tensor],
-        pos: Optional[Tensor],
+        tgt: torch.Tensor,
+        memory: torch.Tensor,
+        query_pos: Optional[torch.Tensor],
+        pos: Optional[torch.Tensor],
         num_k_exclude_rope: int = 0,
-    ) -> Tensor:
+    ) -> torch.Tensor:
         """Perform cross-attention between target and memory tensors using RoPEAttention mechanism."""
         kwds = {}
         if num_k_exclude_rope > 0:
@@ -138,20 +138,20 @@ class MemoryAttentionLayer(nn.Module):
 
     def forward(
         self,
-        tgt: Tensor,
-        memory: Tensor,
-        pos: Optional[Tensor] = None,
-        query_pos: Optional[Tensor] = None,
+        tgt: torch.Tensor,
+        memory: torch.Tensor,
+        pos: Optional[torch.Tensor] = None,
+        query_pos: Optional[torch.Tensor] = None,
         num_k_exclude_rope: int = 0,
     ) -> torch.Tensor:
         """
         Process input tensors through self-attention, cross-attention, and feedforward network layers.
 
         Args:
-            tgt (Tensor): Target tensor for self-attention with shape (N, L, D).
-            memory (Tensor): Memory tensor for cross-attention with shape (N, S, D).
-            pos (Optional[Tensor]): Positional encoding for memory tensor.
-            query_pos (Optional[Tensor]): Positional encoding for target tensor.
+            tgt (torch.Tensor): Target tensor for self-attention with shape (N, L, D).
+            memory (torch.Tensor): Memory tensor for cross-attention with shape (N, S, D).
+            pos (Optional[torch.Tensor]): Positional encoding for memory tensor.
+            query_pos (Optional[torch.Tensor]): Positional encoding for target tensor.
             num_k_exclude_rope (int): Number of keys to exclude from rotary position embedding.
 
         Returns:
@@ -242,8 +242,8 @@ class MemoryAttention(nn.Module):
         self,
         curr: torch.Tensor,  # self-attention inputs
         memory: torch.Tensor,  # cross-attention inputs
-        curr_pos: Optional[Tensor] = None,  # pos_enc for self-attention inputs
-        memory_pos: Optional[Tensor] = None,  # pos_enc for cross-attention inputs
+        curr_pos: Optional[torch.Tensor] = None,  # pos_enc for self-attention inputs
+        memory_pos: Optional[torch.Tensor] = None,  # pos_enc for cross-attention inputs
         num_obj_ptr_tokens: int = 0,  # number of object pointer *tokens*
     ) -> torch.Tensor:
         """
@@ -252,8 +252,8 @@ class MemoryAttention(nn.Module):
         Args:
             curr (torch.Tensor): Self-attention input tensor, representing the current state.
             memory (torch.Tensor): Cross-attention input tensor, representing memory information.
-            curr_pos (Optional[Tensor]): Positional encoding for self-attention inputs.
-            memory_pos (Optional[Tensor]): Positional encoding for cross-attention inputs.
+            curr_pos (Optional[torch.Tensor]): Positional encoding for self-attention inputs.
+            memory_pos (Optional[torch.Tensor]): Positional encoding for cross-attention inputs.
             num_obj_ptr_tokens (int): Number of object pointer tokens to exclude from rotary position embedding.
 
         Returns:

ultralytics/models/sam/modules/transformer.py

@@ -82,21 +82,21 @@ class TwoWayTransformer(nn.Module):
 
     def forward(
         self,
-        image_embedding: Tensor,
-        image_pe: Tensor,
-        point_embedding: Tensor,
-    ) -> Tuple[Tensor, Tensor]:
+        image_embedding: torch.Tensor,
+        image_pe: torch.Tensor,
+        point_embedding: torch.Tensor,
+    ) -> Tuple[torch.Tensor, torch.Tensor]:
         """
         Process image and point embeddings through the Two-Way Transformer.
 
         Args:
-            image_embedding (Tensor): Image to attend to, with shape (B, embedding_dim, H, W).
-            image_pe (Tensor): Positional encoding to add to the image, with same shape as image_embedding.
-            point_embedding (Tensor): Embedding to add to query points, with shape (B, N_points, embedding_dim).
+            image_embedding (torch.Tensor): Image to attend to, with shape (B, embedding_dim, H, W).
+            image_pe (torch.Tensor): Positional encoding to add to the image, with same shape as image_embedding.
+            point_embedding (torch.Tensor): Embedding to add to query points, with shape (B, N_points, embedding_dim).
 
         Returns:
-            queries (Tensor): Processed point embeddings with shape (B, N_points, embedding_dim).
-            keys (Tensor): Processed image embeddings with shape (B, H*W, embedding_dim).
+            queries (torch.Tensor): Processed point embeddings with shape (B, N_points, embedding_dim).
+            keys (torch.Tensor): Processed image embeddings with shape (B, H*W, embedding_dim).
         """
         # BxCxHxW -> BxHWxC == B x N_image_tokens x C
         image_embedding = image_embedding.flatten(2).permute(0, 2, 1)
@@ -196,19 +196,21 @@ class TwoWayAttentionBlock(nn.Module):
 
         self.skip_first_layer_pe = skip_first_layer_pe
 
-    def forward(self, queries: Tensor, keys: Tensor, query_pe: Tensor, key_pe: Tensor) -> Tuple[Tensor, Tensor]:
+    def forward(
+        self, queries: torch.Tensor, keys: torch.Tensor, query_pe: torch.Tensor, key_pe: torch.Tensor
+    ) -> Tuple[torch.Tensor, torch.Tensor]:
         """
         Apply two-way attention to process query and key embeddings in a transformer block.
 
         Args:
-            queries (Tensor): Query embeddings with shape (B, N_queries, embedding_dim).
-            keys (Tensor): Key embeddings with shape (B, N_keys, embedding_dim).
-            query_pe (Tensor): Positional encodings for queries with same shape as queries.
-            key_pe (Tensor): Positional encodings for keys with same shape as keys.
+            queries (torch.Tensor): Query embeddings with shape (B, N_queries, embedding_dim).
+            keys (torch.Tensor): Key embeddings with shape (B, N_keys, embedding_dim).
+            query_pe (torch.Tensor): Positional encodings for queries with same shape as queries.
+            key_pe (torch.Tensor): Positional encodings for keys with same shape as keys.
 
         Returns:
-            queries (Tensor): Processed query embeddings with shape (B, N_queries, embedding_dim).
-            keys (Tensor): Processed key embeddings with shape (B, N_keys, embedding_dim).
+            queries (torch.Tensor): Processed query embeddings with shape (B, N_queries, embedding_dim).
+            keys (torch.Tensor): Processed key embeddings with shape (B, N_keys, embedding_dim).
         """
         # Self attention block
         if self.skip_first_layer_pe:
@@ -304,7 +306,7 @@ class Attention(nn.Module):
         self.out_proj = nn.Linear(self.internal_dim, embedding_dim)
 
     @staticmethod
-    def _separate_heads(x: Tensor, num_heads: int) -> Tensor:
+    def _separate_heads(x: torch.Tensor, num_heads: int) -> torch.Tensor:
         """Separate the input tensor into the specified number of attention heads."""
         b, n, c = x.shape
         x = x.reshape(b, n, num_heads, c // num_heads)
@@ -317,17 +319,17 @@ class Attention(nn.Module):
         x = x.transpose(1, 2)
         return x.reshape(b, n_tokens, n_heads * c_per_head)  # B x N_tokens x C
 
-    def forward(self, q: Tensor, k: Tensor, v: Tensor) -> Tensor:
+    def forward(self, q: torch.Tensor, k: torch.Tensor, v: torch.Tensor) -> torch.Tensor:
         """
         Apply multi-head attention to query, key, and value tensors with optional downsampling.
 
         Args:
-            q (Tensor): Query tensor with shape (B, N_q, embedding_dim).
-            k (Tensor): Key tensor with shape (B, N_k, embedding_dim).
-            v (Tensor): Value tensor with shape (B, N_k, embedding_dim).
+            q (torch.Tensor): Query tensor with shape (B, N_q, embedding_dim).
+            k (torch.Tensor): Key tensor with shape (B, N_k, embedding_dim).
+            v (torch.Tensor): Value tensor with shape (B, N_k, embedding_dim).
 
         Returns:
-            (Tensor): Output tensor after attention with shape (B, N_q, embedding_dim).
+            (torch.Tensor): Output tensor after attention with shape (B, N_q, embedding_dim).
         """
         # Input projections
         q = self.q_proj(q)

ultralytics/models/yolo/detect/val.py

@@ -450,8 +450,8 @@ class DetectionValidator(BaseValidator):
                     val.summarize()
 
                     # update mAP50-95 and mAP50
-                    stats[f"metrics/mAP50({suffix[i][0]})"] = val.stats_as_dict["AP_all"]
-                    stats[f"metrics/mAP50-95({suffix[i][0]})"] = val.stats_as_dict["AP_50"]
+                    stats[f"metrics/mAP50({suffix[i][0]})"] = val.stats_as_dict["AP_50"]
+                    stats[f"metrics/mAP50-95({suffix[i][0]})"] = val.stats_as_dict["AP_all"]
 
                     if self.is_lvis:
                         stats[f"metrics/APr({suffix[i][0]})"] = val.stats_as_dict["APr"]

ultralytics/models/yolo/world/train_world.py

@@ -107,7 +107,15 @@ class WorldTrainerFromScratch(WorldTrainer):
         datasets = [
             build_yolo_dataset(self.args, im_path, batch, self.training_data[im_path], stride=gs, multi_modal=True)
             if isinstance(im_path, str)
-            else build_grounding(self.args, im_path["img_path"], im_path["json_file"], batch, stride=gs)
+            else build_grounding(
+                # assign `nc` from validation set to max number of text samples for training consistency
+                self.args,
+                im_path["img_path"],
+                im_path["json_file"],
+                batch,
+                stride=gs,
+                max_samples=self.data["nc"],
+            )
             for im_path in img_path
         ]
         self.set_text_embeddings(datasets, batch)  # cache text embeddings to accelerate training

ultralytics/solutions/distance_calculation.py

@@ -76,7 +76,7 @@ class DistanceCalculation(BaseSolution):
         between two user-selected objects if they have been chosen.
 
         Args:
-            im0 (numpy.ndarray): The input image frame to process.
+            im0 (np.ndarray): The input image frame to process.
 
         Returns:
             (SolutionResults): Contains processed image `plot_im`, `total_tracks` (int) representing the total number

ultralytics/solutions/instance_segmentation.py

@@ -19,7 +19,7 @@ class InstanceSegmentation(BaseSolution):
         names (Dict[int, str]): Dictionary mapping class indices to class names.
         clss (List[int]): List of detected class indices.
         track_ids (List[int]): List of track IDs for detected instances.
-        masks (List[numpy.ndarray]): List of segmentation masks for detected instances.
+        masks (List[np.ndarray]): List of segmentation masks for detected instances.
         show_conf (bool): Whether to display confidence scores.
         show_labels (bool): Whether to display class labels.
         show_boxes (bool): Whether to display bounding boxes.
@@ -55,7 +55,7 @@ class InstanceSegmentation(BaseSolution):
         Perform instance segmentation on the input image and annotate the results.
 
         Args:
-            im0 (numpy.ndarray): The input image for segmentation.
+            im0 (np.ndarray): The input image for segmentation.
 
         Returns:
             (SolutionResults): Object containing the annotated image and total number of tracked instances.

ultralytics/solutions/object_blurrer.py

@@ -56,11 +56,11 @@ class ObjectBlurrer(BaseSolution):
         and annotates the image with bounding boxes.
 
         Args:
-            im0 (numpy.ndarray): The input image containing detected objects.
+            im0 (np.ndarray): The input image containing detected objects.
 
         Returns:
             (SolutionResults): Object containing the processed image and number of tracked objects.
-                - plot_im (numpy.ndarray): The annotated output image with blurred objects.
+                - plot_im (np.ndarray): The annotated output image with blurred objects.
                 - total_tracks (int): The total number of tracked objects in the frame.
 
         Examples:

ultralytics/solutions/object_counter.py

@@ -122,7 +122,7 @@ class ObjectCounter(BaseSolution):
         Display object counts on the input image or frame.
 
         Args:
-            plot_im (numpy.ndarray): The image or frame to display counts on.
+            plot_im (np.ndarray): The image or frame to display counts on.
 
         Examples:
             >>> counter = ObjectCounter()
@@ -146,7 +146,7 @@ class ObjectCounter(BaseSolution):
         object counts, and displays the results on the input image.
 
         Args:
-            im0 (numpy.ndarray): The input image or frame to be processed.
+            im0 (np.ndarray): The input image or frame to be processed.
 
         Returns:
             (SolutionResults): Contains processed image `im0`, 'in_count' (int, count of objects entering the region),

ultralytics/solutions/object_cropper.py

@@ -57,7 +57,7 @@ class ObjectCropper(BaseSolution):
         Crop detected objects from the input image and save them as separate images.
 
         Args:
-            im0 (numpy.ndarray): The input image containing detected objects.
+            im0 (np.ndarray): The input image containing detected objects.
 
         Returns:
             (SolutionResults): A SolutionResults object containing the total number of cropped objects and processed

ultralytics/solutions/queue_management.py

@@ -50,7 +50,7 @@ class QueueManager(BaseSolution):
         Process queue management for a single frame of video.
 
         Args:
-            im0 (numpy.ndarray): Input image for processing, typically a frame from a video stream.
+            im0 (np.ndarray): Input image for processing, typically a frame from a video stream.
 
         Returns:
             (SolutionResults): Contains processed image `im0`, 'queue_count' (int, number of objects in the queue) and

ultralytics/solutions/security_alarm.py

@@ -76,7 +76,7 @@ class SecurityAlarm(BaseSolution):
         Send an email notification with an image attachment indicating the number of objects detected.
 
         Args:
-            im0 (numpy.ndarray): The input image or frame to be attached to the email.
+            im0 (np.ndarray): The input image or frame to be attached to the email.
             records (int, optional): The number of detected objects to be included in the email message.
 
         This method encodes the input image, composes the email message with details about the detection, and sends it
@@ -121,7 +121,7 @@ class SecurityAlarm(BaseSolution):
         Monitor the frame, process object detections, and trigger alerts if thresholds are exceeded.
 
         Args:
-            im0 (numpy.ndarray): The input image or frame to be processed and annotated.
+            im0 (np.ndarray): The input image or frame to be processed and annotated.
 
         Returns:
             (SolutionResults): Contains processed image `plot_im`, 'total_tracks' (total number of tracked objects) and

ultralytics/solutions/templates/similarity-search.html

@@ -35,7 +35,6 @@
         align-items: center;
         gap: 1rem;
         margin-bottom: 3rem;
-        animation: fadeIn 1s ease-in-out;
       }
 
       input[type="text"] {
@@ -78,7 +77,6 @@
         gap: 1.5rem;
         max-width: 1600px;
         margin: auto;
-        animation: fadeInUp 1s ease-in-out;
       }
 
       .card {
@@ -102,28 +100,6 @@
         object-fit: cover;
         display: block;
       }
-
-      @keyframes fadeIn {
-        0% {
-          opacity: 0;
-          transform: scale(0.95);
-        }
-        100% {
-          opacity: 1;
-          transform: scale(1);
-        }
-      }
-
-      @keyframes fadeInUp {
-        0% {
-          opacity: 0;
-          transform: translateY(20px);
-        }
-        100% {
-          opacity: 1;
-          transform: translateY(0);
-        }
-      }
     </style>
   </head>
   <script>

ultralytics/solutions/vision_eye.py

@@ -42,7 +42,7 @@ class VisionEye(BaseSolution):
         Perform object detection, vision mapping, and annotation on the input image.
 
         Args:
-            im0 (numpy.ndarray): The input image for detection and annotation.
+            im0 (np.ndarray): The input image for detection and annotation.
 
         Returns:
             (SolutionResults): Object containing the annotated image and tracking statistics.

ultralytics/utils/benchmarks.py

@@ -520,12 +520,12 @@ class ProfileModels:
         Apply iterative sigma clipping to data to remove outliers.
 
         Args:
-            data (numpy.ndarray): Input data array.
+            data (np.ndarray): Input data array.
             sigma (float): Number of standard deviations to use for clipping.
             max_iters (int): Maximum number of iterations for the clipping process.
 
         Returns:
-            (numpy.ndarray): Clipped data array with outliers removed.
+            (np.ndarray): Clipped data array with outliers removed.
         """
         data = np.array(data)
         for _ in range(max_iters):

ultralytics/utils/export.py

@@ -135,8 +135,6 @@ def export_engine(
         LOGGER.info(f'{prefix} output "{out.name}" with shape{out.shape} {out.dtype}')
 
     if dynamic:
-        if shape[0] <= 1:
-            LOGGER.warning(f"{prefix} 'dynamic=True' model requires max batch size, i.e. 'batch=16'")
         profile = builder.create_optimization_profile()
         min_shape = (1, shape[1], 32, 32)  # minimum input shape
         max_shape = (*shape[:2], *(int(max(2, workspace or 2) * d) for d in shape[2:]))  # max input shape

ultralytics/utils/instance.py

@@ -3,7 +3,7 @@
 from collections import abc
 from itertools import repeat
 from numbers import Number
-from typing import List
+from typing import List, Union
 
 import numpy as np
 
@@ -59,7 +59,7 @@ class Bboxes:
         This class does not handle normalization or denormalization of bounding boxes.
     """
 
-    def __init__(self, bboxes, format="xyxy") -> None:
+    def __init__(self, bboxes: np.ndarray, format: str = "xyxy") -> None:
         """
         Initialize the Bboxes class with bounding box data in a specified format.
 
@@ -74,7 +74,7 @@ class Bboxes:
         self.bboxes = bboxes
         self.format = format
 
-    def convert(self, format):
+    def convert(self, format: str) -> None:
         """
         Convert bounding box format from one type to another.
 
@@ -93,7 +93,7 @@ class Bboxes:
         self.bboxes = func(self.bboxes)
         self.format = format
 
-    def areas(self):
+    def areas(self) -> np.ndarray:
         """Calculate the area of bounding boxes."""
         return (
             (self.bboxes[:, 2] - self.bboxes[:, 0]) * (self.bboxes[:, 3] - self.bboxes[:, 1])  # format xyxy
@@ -101,7 +101,7 @@ class Bboxes:
             else self.bboxes[:, 3] * self.bboxes[:, 2]  # format xywh or ltwh
         )
 
-    def mul(self, scale):
+    def mul(self, scale: Union[int, tuple, list]) -> None:
         """
         Multiply bounding box coordinates by scale factor(s).
 
@@ -118,7 +118,7 @@ class Bboxes:
         self.bboxes[:, 2] *= scale[2]
         self.bboxes[:, 3] *= scale[3]
 
-    def add(self, offset):
+    def add(self, offset: Union[int, tuple, list]) -> None:
         """
         Add offset to bounding box coordinates.
 
@@ -135,12 +135,12 @@ class Bboxes:
         self.bboxes[:, 2] += offset[2]
         self.bboxes[:, 3] += offset[3]
 
-    def __len__(self):
+    def __len__(self) -> int:
         """Return the number of bounding boxes."""
         return len(self.bboxes)
 
     @classmethod
-    def concatenate(cls, boxes_list: List["Bboxes"], axis=0) -> "Bboxes":
+    def concatenate(cls, boxes_list: List["Bboxes"], axis: int = 0) -> "Bboxes":
         """
         Concatenate a list of Bboxes objects into a single Bboxes object.
 
@@ -163,7 +163,7 @@ class Bboxes:
             return boxes_list[0]
         return cls(np.concatenate([b.bboxes for b in boxes_list], axis=axis))
 
-    def __getitem__(self, index) -> "Bboxes":
+    def __getitem__(self, index: Union[int, np.ndarray, slice]) -> "Bboxes":
         """
         Retrieve a specific bounding box or a set of bounding boxes using indexing.
 
@@ -220,13 +220,20 @@ class Instances:
         ... )
     """
 
-    def __init__(self, bboxes, segments=None, keypoints=None, bbox_format="xywh", normalized=True) -> None:
+    def __init__(
+        self,
+        bboxes: np.ndarray,
+        segments: np.ndarray = None,
+        keypoints: np.ndarray = None,
+        bbox_format: str = "xywh",
+        normalized: bool = True,
+    ) -> None:
         """
         Initialize the Instances object with bounding boxes, segments, and keypoints.
 
         Args:
             bboxes (np.ndarray): Bounding boxes with shape (N, 4).
-            segments (List | np.ndarray, optional): Segmentation masks.
+            segments (np.ndarray, optional): Segmentation masks.
             keypoints (np.ndarray, optional): Keypoints with shape (N, 17, 3) in format (x, y, visible).
             bbox_format (str): Format of bboxes.
             normalized (bool): Whether the coordinates are normalized.
@@ -236,7 +243,7 @@ class Instances:
         self.normalized = normalized
         self.segments = segments
 
-    def convert_bbox(self, format):
+    def convert_bbox(self, format: str) -> None:
         """
         Convert bounding box format.
 
@@ -246,11 +253,11 @@ class Instances:
         self._bboxes.convert(format=format)
 
     @property
-    def bbox_areas(self):
+    def bbox_areas(self) -> np.ndarray:
         """Calculate the area of bounding boxes."""
         return self._bboxes.areas()
 
-    def scale(self, scale_w, scale_h, bbox_only=False):
+    def scale(self, scale_w: float, scale_h: float, bbox_only: bool = False):
         """
         Scale coordinates by given factors.
 
@@ -268,7 +275,7 @@ class Instances:
             self.keypoints[..., 0] *= scale_w
             self.keypoints[..., 1] *= scale_h
 
-    def denormalize(self, w, h):
+    def denormalize(self, w: int, h: int) -> None:
         """
         Convert normalized coordinates to absolute coordinates.
 
@@ -286,7 +293,7 @@ class Instances:
             self.keypoints[..., 1] *= h
         self.normalized = False
 
-    def normalize(self, w, h):
+    def normalize(self, w: int, h: int) -> None:
         """
         Convert absolute coordinates to normalized coordinates.
 
@@ -304,7 +311,7 @@ class Instances:
             self.keypoints[..., 1] /= h
         self.normalized = True
 
-    def add_padding(self, padw, padh):
+    def add_padding(self, padw: int, padh: int) -> None:
         """
         Add padding to coordinates.
 
@@ -320,7 +327,7 @@ class Instances:
             self.keypoints[..., 0] += padw
             self.keypoints[..., 1] += padh
 
-    def __getitem__(self, index) -> "Instances":
+    def __getitem__(self, index: Union[int, np.ndarray, slice]) -> "Instances":
         """
         Retrieve a specific instance or a set of instances using indexing.
 
@@ -346,7 +353,7 @@ class Instances:
             normalized=self.normalized,
         )
 
-    def flipud(self, h):
+    def flipud(self, h: int) -> None:
         """
         Flip coordinates vertically.
 
@@ -364,7 +371,7 @@ class Instances:
         if self.keypoints is not None:
             self.keypoints[..., 1] = h - self.keypoints[..., 1]
 
-    def fliplr(self, w):
+    def fliplr(self, w: int) -> None:
         """
         Flip coordinates horizontally.
 
@@ -382,7 +389,7 @@ class Instances:
         if self.keypoints is not None:
             self.keypoints[..., 0] = w - self.keypoints[..., 0]
 
-    def clip(self, w, h):
+    def clip(self, w: int, h: int) -> None:
         """
         Clip coordinates to stay within image boundaries.
 
@@ -409,7 +416,7 @@ class Instances:
             self.keypoints[..., 0] = self.keypoints[..., 0].clip(0, w)
             self.keypoints[..., 1] = self.keypoints[..., 1].clip(0, h)
 
-    def remove_zero_area_boxes(self):
+    def remove_zero_area_boxes(self) -> np.ndarray:
         """
         Remove zero-area boxes, i.e. after clipping some boxes may have zero width or height.
 
@@ -425,7 +432,7 @@ class Instances:
                 self.keypoints = self.keypoints[good]
         return good
 
-    def update(self, bboxes, segments=None, keypoints=None):
+    def update(self, bboxes: np.ndarray, segments: np.ndarray = None, keypoints: np.ndarray = None):
         """
         Update instance variables.
 
@@ -440,7 +447,7 @@ class Instances:
         if keypoints is not None:
             self.keypoints = keypoints
 
-    def __len__(self):
+    def __len__(self) -> int:
         """Return the number of instances."""
         return len(self.bboxes)
 
@@ -492,6 +499,6 @@ class Instances:
         return cls(cat_boxes, cat_segments, cat_keypoints, bbox_format, normalized)
 
     @property
-    def bboxes(self):
+    def bboxes(self) -> np.ndarray:
         """Return bounding boxes."""
         return self._bboxes.bboxes

ultralytics/utils/ops.py

@@ -343,11 +343,11 @@ def clip_boxes(boxes, shape):
     Clip bounding boxes to image boundaries.
 
     Args:
-        boxes (torch.Tensor | numpy.ndarray): Bounding boxes to clip.
+        boxes (torch.Tensor | np.ndarray): Bounding boxes to clip.
         shape (tuple): Image shape as (height, width).
 
     Returns:
-        (torch.Tensor | numpy.ndarray): Clipped bounding boxes.
+        (torch.Tensor | np.ndarray): Clipped bounding boxes.
     """
     if isinstance(boxes, torch.Tensor):  # faster individually (WARNING: inplace .clamp_() Apple MPS bug)
         boxes[..., 0] = boxes[..., 0].clamp(0, shape[1])  # x1
@@ -365,11 +365,11 @@ def clip_coords(coords, shape):
     Clip line coordinates to image boundaries.
 
     Args:
-        coords (torch.Tensor | numpy.ndarray): Line coordinates to clip.
+        coords (torch.Tensor | np.ndarray): Line coordinates to clip.
         shape (tuple): Image shape as (height, width).
 
     Returns:
-        (torch.Tensor | numpy.ndarray): Clipped coordinates.
+        (torch.Tensor | np.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
@@ -564,10 +564,10 @@ def xyxyxyxy2xywhr(x):
     Convert batched Oriented Bounding Boxes (OBB) from [xy1, xy2, xy3, xy4] to [xywh, rotation] format.
 
     Args:
-        x (numpy.ndarray | torch.Tensor): Input box corners with shape (N, 8) in [xy1, xy2, xy3, xy4] format.
+        x (np.ndarray | torch.Tensor): Input box corners with shape (N, 8) in [xy1, xy2, xy3, xy4] format.
 
     Returns:
-        (numpy.ndarray | torch.Tensor): Converted data in [cx, cy, w, h, rotation] format with shape (N, 5).
+        (np.ndarray | torch.Tensor): Converted data in [cx, cy, w, h, rotation] format with shape (N, 5).
             Rotation values are in radians from 0 to pi/2.
     """
     is_torch = isinstance(x, torch.Tensor)
@@ -587,11 +587,11 @@ def xywhr2xyxyxyxy(x):
     Convert batched Oriented Bounding Boxes (OBB) from [xywh, rotation] to [xy1, xy2, xy3, xy4] format.
 
     Args:
-        x (numpy.ndarray | torch.Tensor): Boxes in [cx, cy, w, h, rotation] format with shape (N, 5) or (B, N, 5).
+        x (np.ndarray | torch.Tensor): Boxes in [cx, cy, w, h, rotation] format with shape (N, 5) or (B, N, 5).
             Rotation values should be in radians from 0 to pi/2.
 
     Returns:
-        (numpy.ndarray | torch.Tensor): Converted corner points with shape (N, 4, 2) or (B, N, 4, 2).
+        (np.ndarray | torch.Tensor): Converted corner points with shape (N, 4, 2) or (B, N, 4, 2).
     """
     cos, sin, cat, stack = (
         (torch.cos, torch.sin, torch.cat, torch.stack)