ultralytics 8.3.162__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/nn/tasks.py

@@ -249,6 +249,8 @@ class BaseModel(torch.nn.Module):
                     m.forward = m.forward_fuse
                 if isinstance(m, v10Detect):
                     m.fuse()  # remove one2many head
+                if isinstance(m, YOLOEDetect) and hasattr(self, "pe"):
+                    m.fuse(self.pe.to(next(self.model.parameters()).device))
             self.info(verbose=verbose)
 
         return self

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/region_counter.py

@@ -1,6 +1,6 @@
 # Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
 
-from typing import Any, List, Tuple
+from typing import Any, Dict, List, Tuple
 
 import numpy as np
 
@@ -26,6 +26,7 @@ class RegionCounter(BaseSolution):
     Methods:
         add_region: Add a new counting region with specified attributes.
         process: Process video frames to count objects in each region.
+        initialize_regions: Initialize zones to count the objects in each one. Zones could be multiple as well.
 
     Examples:
         Initialize a RegionCounter and add a counting region
@@ -42,12 +43,12 @@ class RegionCounter(BaseSolution):
             "name": "Default Region",
             "polygon": None,
             "counts": 0,
-            "dragging": False,
             "region_color": (255, 255, 255),
             "text_color": (0, 0, 0),
         }
         self.region_counts = {}
         self.counting_regions = []
+        self.initialize_regions()
 
     def add_region(
         self,
@@ -55,7 +56,7 @@ class RegionCounter(BaseSolution):
         polygon_points: List[Tuple],
         region_color: Tuple[int, int, int],
         text_color: Tuple[int, int, int],
-    ) -> None:
+    ) -> Dict[str, Any]:
         """
         Add a new region to the counting list based on the provided template with specific attributes.
 
@@ -64,6 +65,9 @@ class RegionCounter(BaseSolution):
             polygon_points (List[Tuple]): List of (x, y) coordinates defining the region's polygon.
             region_color (Tuple[int, int, int]): BGR color for region visualization.
             text_color (Tuple[int, int, int]): BGR color for the text within the region.
+
+        Returns:
+            (Dict[str, any]): Returns a dictionary including the region information i.e. name, region_color etc.
         """
         region = self.region_template.copy()
         region.update(
@@ -75,6 +79,17 @@ class RegionCounter(BaseSolution):
             }
         )
         self.counting_regions.append(region)
+        return region
+
+    def initialize_regions(self):
+        """Initialize regions only once."""
+        if self.region is None:
+            self.initialize_region()
+        if not isinstance(self.region, dict):  # Ensure self.region is initialized and structured as a dictionary
+            self.region = {"Region#01": self.region}
+        for i, (name, pts) in enumerate(self.region.items()):
+            region = self.add_region(name, pts, colors(i, True), (255, 255, 255))
+            region["prepared_polygon"] = self.prep(region["polygon"])
 
     def process(self, im0: np.ndarray) -> SolutionResults:
         """
@@ -90,39 +105,21 @@ class RegionCounter(BaseSolution):
         self.extract_tracks(im0)
         annotator = SolutionAnnotator(im0, line_width=self.line_width)
 
-        # Ensure self.region is initialized and structured as a dictionary
-        if not isinstance(self.region, dict):
-            self.region = {"Region#01": self.region or self.initialize_region()}
-
-        # Draw only valid regions
-        for idx, (region_name, reg_pts) in enumerate(self.region.items(), start=1):
-            color = colors(idx, True)
-            annotator.draw_region(reg_pts, color, self.line_width * 2)
-            self.add_region(region_name, reg_pts, color, annotator.get_txt_color())
-
-        # Prepare regions for containment check (only process valid ones)
-        for region in self.counting_regions:
-            if "prepared_polygon" not in region:
-                region["prepared_polygon"] = self.prep(region["polygon"])
-
-        # Convert bounding boxes to NumPy array for center points
-        boxes_np = np.array([((box[0] + box[2]) / 2, (box[1] + box[3]) / 2) for box in self.boxes], dtype=np.float32)
-        points = [self.Point(pt) for pt in boxes_np]  # Convert centers to Point objects
-
-        # Process bounding boxes & check containment
-        if points:
-            for point, cls, track_id, box, conf in zip(points, self.clss, self.track_ids, self.boxes, self.confs):
-                annotator.box_label(box, label=self.adjust_box_label(cls, conf, track_id), color=colors(track_id, True))
-
-                for region in self.counting_regions:
-                    if region["prepared_polygon"].contains(point):
-                        region["counts"] += 1
-                        self.region_counts[region["name"]] = region["counts"]
+        for box, cls, track_id, conf in zip(self.boxes, self.clss, self.track_ids, self.confs):
+            annotator.box_label(box, label=self.adjust_box_label(cls, conf, track_id), color=colors(track_id, True))
+            center = self.Point(((box[0] + box[2]) / 2, (box[1] + box[3]) / 2))
+            for region in self.counting_regions:
+                if region["prepared_polygon"].contains(center):
+                    region["counts"] += 1
+                    self.region_counts[region["name"]] = region["counts"]
 
         # Display region counts
         for region in self.counting_regions:
+            x1, y1, x2, y2 = map(int, region["polygon"].bounds)
+            pts = [(x1, y1), (x2, y1), (x2, y2), (x1, y2)]
+            annotator.draw_region(pts, region["region_color"], self.line_width * 2)
             annotator.text_label(
-                region["polygon"].bounds,
+                [x1, y1, x2, y2],
                 label=str(region["counts"]),
                 color=region["region_color"],
                 txt_color=region["text_color"],

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