ultralytics 8.3.120__tar.gz → 8.3.122__tar.gz

{ultralytics-8.3.120/ultralytics.egg-info → ultralytics-8.3.122}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ultralytics
-Version: 8.3.120
+Version: 8.3.122
 Summary: Ultralytics YOLO 🚀 for SOTA object detection, multi-object tracking, instance segmentation, pose estimation and image classification.
 Author-email: Glenn Jocher <glenn.jocher@ultralytics.com>, Jing Qiu <jing.qiu@ultralytics.com>
 Maintainer-email: Ultralytics <hello@ultralytics.com>
@@ -68,8 +68,8 @@ Requires-Dist: tensorflowjs>=2.0.0; extra == "export"
 Requires-Dist: tensorstore>=0.1.63; (platform_machine == "aarch64" and python_version >= "3.9") and extra == "export"
 Requires-Dist: h5py!=3.11.0; platform_machine == "aarch64" and extra == "export"
 Provides-Extra: solutions
-Requires-Dist: shapely<2.1.0,>=2.0.0; extra == "solutions"
-Requires-Dist: streamlit<1.44.0,>=1.29.0; extra == "solutions"
+Requires-Dist: shapely>=2.0.0; extra == "solutions"
+Requires-Dist: streamlit>=1.29.0; extra == "solutions"
 Provides-Extra: logging
 Requires-Dist: wandb; extra == "logging"
 Requires-Dist: tensorboard; extra == "logging"

{ultralytics-8.3.120 → ultralytics-8.3.122}/pyproject.toml

@@ -103,8 +103,8 @@ export = [
     "h5py!=3.11.0; platform_machine == 'aarch64'", # fix h5py build issues due to missing aarch64 wheels in 3.11 release
 ]
 solutions = [
-    "shapely>=2.0.0,<2.1.0",    # shapely for point and polygon data matching
-    "streamlit>=1.29.0,<1.44.0",    # for live inference on web browser, i.e `yolo streamlit-predict`
+    "shapely>=2.0.0",    # shapely for point and polygon data matching
+    "streamlit>=1.29.0",    # for live inference on web browser, i.e `yolo streamlit-predict`
 ]
 logging = [
     "wandb", # https://docs.ultralytics.com/integrations/weights-biases/

{ultralytics-8.3.120 → ultralytics-8.3.122}/ultralytics/__init__.py

@@ -1,6 +1,6 @@
 # Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
 
-__version__ = "8.3.120"
+__version__ = "8.3.122"
 
 import os
 

{ultralytics-8.3.120 → ultralytics-8.3.122}/ultralytics/cfg/__init__.py

@@ -701,7 +701,7 @@ def handle_yolo_solutions(args: List[str]) -> None:
         solution_name = "count"  # Default for invalid solution
 
     if solution_name == "inference":
-        checks.check_requirements("streamlit>=1.29.0,<1.44.0")
+        checks.check_requirements("streamlit>=1.29.0")
         LOGGER.info("💡 Loading Ultralytics live inference app...")
         subprocess.run(
             [  # Run subprocess with Streamlit custom argument

{ultralytics-8.3.120 → ultralytics-8.3.122}/ultralytics/cfg/trackers/botsort.yaml

@@ -17,6 +17,6 @@ fuse_score: True # Whether to fuse confidence scores with the iou distances befo
 gmc_method: sparseOptFlow # method of global motion compensation
 # ReID model related thresh
 proximity_thresh: 0.5 # minimum IoU for valid match with ReID
-appearance_thresh: 0.25 # minimum appearance similarity for ReID
+appearance_thresh: 0.8 # minimum appearance similarity for ReID
 with_reid: False
 model: auto # uses native features if detector is YOLO else yolo11n-cls.pt

{ultralytics-8.3.120 → ultralytics-8.3.122}/ultralytics/data/augment.py

@@ -1026,7 +1026,9 @@ class CutMix(BaseMixTransform):
         labels2 = labels.pop("mix_labels")[0]
         area = cut_areas[np.random.choice(idx)]  # randomle select one
         ioa2 = bbox_ioa(area[None], labels2["instances"].bboxes).squeeze(0)
-        indexes2 = np.nonzero(ioa2 >= 0.01 if len(labels["instances"].segments) else 0.1)[0]
+        indexes2 = np.nonzero(ioa2 >= (0.01 if len(labels["instances"].segments) else 0.1))[0]
+        if len(indexes2) == 0:
+            return labels
 
         instances2 = labels2["instances"][indexes2]
         instances2.convert_bbox("xyxy")

{ultralytics-8.3.120 → ultralytics-8.3.122}/ultralytics/data/split_dota.py

@@ -30,7 +30,7 @@ def bbox_iof(polygon1, bbox2, eps=1e-6):
         Polygon format: [x1, y1, x2, y2, x3, y3, x4, y4].
         Bounding box format: [x_min, y_min, x_max, y_max].
     """
-    check_requirements("shapely")
+    check_requirements("shapely>=2.0.0")
     from shapely.geometry import Polygon
 
     polygon1 = polygon1.reshape(-1, 4, 2)

{ultralytics-8.3.120 → ultralytics-8.3.122}/ultralytics/engine/exporter.py

@@ -636,6 +636,8 @@ class Exporter:
         if self.args.int8:
             fq = str(self.file).replace(self.file.suffix, f"_int8_openvino_model{os.sep}")
             fq_ov = str(Path(fq) / self.file.with_suffix(".xml").name)
+            # INT8 requires nncf, nncf requires packaging>=23.2 https://github.com/openvinotoolkit/nncf/issues/3463
+            check_requirements("packaging>=23.2")  # must be installed first to build nncf wheel
             check_requirements("nncf>=2.14.0")
             import nncf
 
@@ -849,6 +851,9 @@ class Exporter:
         ct_model.license = m.pop("license")
         ct_model.version = m.pop("version")
         ct_model.user_defined_metadata.update({k: str(v) for k, v in m.items()})
+        if self.model.task == "classify":
+            ct_model.user_defined_metadata.update({"com.apple.coreml.model.preview.type": "imageClassifier"})
+
         try:
             ct_model.save(str(f))  # save *.mlpackage
         except Exception as e:

{ultralytics-8.3.120 → ultralytics-8.3.122}/ultralytics/models/utils/loss.py

@@ -58,7 +58,7 @@ class DETRLoss(nn.Module):
             use_uni_match (bool): Whether to use fixed layer for auxiliary branch label assignment.
             uni_match_ind (int): Index of fixed layer for uni_match.
             gamma (float): The focusing parameter that controls how much the loss focuses on hard-to-classify examples.
-            alpha (float): The balancing factor used to address class imbalance.
+            alpha (float | list): The balancing factor used to address class imbalance.
         """
         super().__init__()
 

{ultralytics-8.3.120 → ultralytics-8.3.122}/ultralytics/solutions/solutions.py

@@ -53,7 +53,7 @@ class BaseSolution:
             is_cli (bool): Enables CLI mode if set to True.
             **kwargs (Any): Additional configuration parameters that override defaults.
         """
-        check_requirements("shapely>=2.0.0,<2.1.0")
+        check_requirements("shapely>=2.0.0")
         from shapely.geometry import LineString, Point, Polygon
         from shapely.prepared import prep
 

ultralytics-8.3.122/ultralytics/solutions/speed_estimation.py

@@ -0,0 +1,110 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+from collections import deque
+from math import sqrt
+
+from ultralytics.solutions.solutions import BaseSolution, SolutionAnnotator, SolutionResults
+from ultralytics.utils.plotting import colors
+
+
+class SpeedEstimator(BaseSolution):
+    """
+    A class to estimate the speed of objects in a real-time video stream based on their tracks.
+
+    This class extends the BaseSolution class and provides functionality for estimating object speeds using
+    tracking data in video streams.
+
+    Attributes:
+        spd (Dict[int, float]): Dictionary storing speed data for tracked objects.
+        trk_hist (Dict[int, float]): Dictionary storing the object tracking data.
+        max_hist (int): maximum track history before computing speed
+        meters_per_pixel (float): Real-world meters represented by one pixel (e.g., 0.04 for 4m over 100px).
+        max_speed (int): Maximum allowed object speed; values above this will be capped at 120 km/h.
+
+    Methods:
+        initialize_region: Initializes the speed estimation region.
+        process: Processes input frames to estimate object speeds.
+        store_tracking_history: Stores the tracking history for an object.
+        extract_tracks: Extracts tracks from the current frame.
+        display_output: Displays the output with annotations.
+
+    Examples:
+        >>> estimator = SpeedEstimator()
+        >>> frame = cv2.imread("frame.jpg")
+        >>> results = estimator.process(frame)
+        >>> cv2.imshow("Speed Estimation", results.plot_im)
+    """
+
+    def __init__(self, **kwargs):
+        """
+        Initialize the SpeedEstimator object with speed estimation parameters and data structures.
+
+        Args:
+            **kwargs (Any): Additional keyword arguments passed to the parent class.
+        """
+        super().__init__(**kwargs)
+
+        self.fps = kwargs.get("fps", 30)  # assumed video FPS
+        self.frame_count = 0  # global frame count
+        self.trk_frame_ids = {}  # Track ID → first frame index
+        self.spd = {}  # Final speed per object (km/h), once locked
+        self.trk_hist = {}  # Track ID → deque of (time, position)
+        self.locked_ids = set()  # Track IDs whose speed has been finalized
+        self.max_hist = kwargs.get("max_hist", 5)  # Required frame history before computing speed
+        self.meter_per_pixel = kwargs.get("meter_per_pixel", 0.05)  # Scene scale, depends on camera details
+        self.max_speed = kwargs.get("max_speed", 120)  # max_speed adjustment
+
+    def process(self, im0):
+        """
+        Process an input frame to estimate object speeds based on tracking data.
+
+        Args:
+            im0 (np.ndarray): Input image for processing with shape (H, W, C) for RGB images.
+
+        Returns:
+            (SolutionResults): Contains processed image `plot_im` and `total_tracks` (number of tracked objects).
+
+        Examples:
+            >>> estimator = SpeedEstimator()
+            >>> image = np.random.randint(0, 255, (480, 640, 3), dtype=np.uint8)
+            >>> results = estimator.process(image)
+        """
+        self.frame_count += 1
+        self.extract_tracks(im0)
+        annotator = SolutionAnnotator(im0, line_width=self.line_width)
+
+        for box, track_id, _, _ in zip(self.boxes, self.track_ids, self.clss, self.confs):
+            self.store_tracking_history(track_id, box)
+
+            if track_id not in self.trk_hist:  # Initialize history if new track found
+                self.trk_hist[track_id] = deque(maxlen=self.max_hist)
+                self.trk_frame_ids[track_id] = self.frame_count
+
+            if track_id not in self.locked_ids:  # Update history until speed is locked
+                trk_hist = self.trk_hist[track_id]
+                trk_hist.append(self.track_line[-1])
+
+                # Compute and lock speed once enough history is collected
+                if len(trk_hist) == self.max_hist:
+                    p0, p1 = trk_hist[0], trk_hist[-1]  # First and last points of track
+                    dt = (self.frame_count - self.trk_frame_ids[track_id]) / self.fps  # Time in seconds
+                    if dt > 0:
+                        dx, dy = p1[0] - p0[0], p1[1] - p0[1]  # pixel displacement
+                        pixel_distance = sqrt(dx * dx + dy * dy)  # get pixel distance
+                        meters = pixel_distance * self.meter_per_pixel  # convert to meters
+                        self.spd[track_id] = int(
+                            min((meters / dt) * 3.6, self.max_speed)
+                        )  # convert to km/h and store final speed
+                        self.locked_ids.add(track_id)  # prevent further updates
+                        self.trk_hist.pop(track_id, None)  # free memory
+                        self.trk_frame_ids.pop(track_id, None)  # optional: remove frame start too
+
+            if track_id in self.spd:
+                speed_label = f"{self.spd[track_id]} km/h"
+                annotator.box_label(box, label=speed_label, color=colors(track_id, True))  # Draw bounding box
+
+        plot_im = annotator.result()
+        self.display_output(plot_im)  # Display output with base class function
+
+        # Return results with processed image and tracking summary
+        return SolutionResults(plot_im=plot_im, total_tracks=len(self.track_ids))

{ultralytics-8.3.120 → ultralytics-8.3.122}/ultralytics/trackers/bot_sort.py

@@ -255,4 +255,6 @@ class ReID:
     def __call__(self, img, dets):
         """Extract embeddings for detected objects."""
         feats = self.model([save_one_box(det, img, save=False) for det in xywh2xyxy(torch.from_numpy(dets[:, :4]))])
+        if feats.shape[0] != dets.shape[0] and feats[0].shape[0] == dets.shape[0]:
+            feats = feats[0]  # batched prediction with non-PyTorch backend
         return [f.cpu().numpy() for f in feats]

{ultralytics-8.3.120 → ultralytics-8.3.122}/ultralytics/utils/downloads.py

@@ -320,9 +320,10 @@ def safe_download(
         LOGGER.info(f"{desc}...")
         f.parent.mkdir(parents=True, exist_ok=True)  # make directory if missing
         check_disk_space(url, path=f.parent)
+        curl_installed = shutil.which("curl")
         for i in range(retry + 1):
             try:
-                if curl or i > 0:  # curl download with retry, continue
+                if (curl or i > 0) and curl_installed:  # curl download with retry, continue
                     s = "sS" * (not progress)  # silent
                     r = subprocess.run(["curl", "-#", f"-{s}L", url, "-o", f, "--retry", "3", "-C", "-"]).returncode
                     assert r == 0, f"Curl return value {r}"

{ultralytics-8.3.120 → ultralytics-8.3.122}/ultralytics/utils/export.py

@@ -167,7 +167,7 @@ def export_engine(
                 trt.IInt8Calibrator.__init__(self)
                 self.dataset = dataset
                 self.data_iter = iter(dataset)
-                self.algo = trt.CalibrationAlgoType.ENTROPY_CALIBRATION_2
+                self.algo = trt.CalibrationAlgoType.MINMAX_CALIBRATION
                 self.batch = dataset.batch_size
                 self.cache = Path(cache)
 

{ultralytics-8.3.120 → ultralytics-8.3.122}/ultralytics/utils/loss.py

@@ -48,14 +48,14 @@ class FocalLoss(nn.Module):
 
     Args:
         gamma (float): The focusing parameter that controls how much the loss focuses on hard-to-classify examples.
-        alpha (float): The balancing factor used to address class imbalance.
+        alpha (float | list): The balancing factor used to address class imbalance.
     """
 
     def __init__(self, gamma=1.5, alpha=0.25):
         """Initialize FocalLoss class with no parameters."""
         super().__init__()
         self.gamma = gamma
-        self.alpha = alpha
+        self.alpha = torch.tensor(alpha)
 
     def forward(self, pred, label):
         """Calculate focal loss with modulating factors for class imbalance."""
@@ -68,7 +68,8 @@ class FocalLoss(nn.Module):
         p_t = label * pred_prob + (1 - label) * (1 - pred_prob)
         modulating_factor = (1.0 - p_t) ** self.gamma
         loss *= modulating_factor
-        if self.alpha > 0:
+        if (self.alpha > 0).any():
+            self.alpha = self.alpha.to(device=pred.device, dtype=pred.dtype)
             alpha_factor = label * self.alpha + (1 - label) * (1 - self.alpha)
             loss *= alpha_factor
         return loss.mean(1).sum()

{ultralytics-8.3.120 → ultralytics-8.3.122/ultralytics.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ultralytics
-Version: 8.3.120
+Version: 8.3.122
 Summary: Ultralytics YOLO 🚀 for SOTA object detection, multi-object tracking, instance segmentation, pose estimation and image classification.
 Author-email: Glenn Jocher <glenn.jocher@ultralytics.com>, Jing Qiu <jing.qiu@ultralytics.com>
 Maintainer-email: Ultralytics <hello@ultralytics.com>
@@ -68,8 +68,8 @@ Requires-Dist: tensorflowjs>=2.0.0; extra == "export"
 Requires-Dist: tensorstore>=0.1.63; (platform_machine == "aarch64" and python_version >= "3.9") and extra == "export"
 Requires-Dist: h5py!=3.11.0; platform_machine == "aarch64" and extra == "export"
 Provides-Extra: solutions
-Requires-Dist: shapely<2.1.0,>=2.0.0; extra == "solutions"
-Requires-Dist: streamlit<1.44.0,>=1.29.0; extra == "solutions"
+Requires-Dist: shapely>=2.0.0; extra == "solutions"
+Requires-Dist: streamlit>=1.29.0; extra == "solutions"
 Provides-Extra: logging
 Requires-Dist: wandb; extra == "logging"
 Requires-Dist: tensorboard; extra == "logging"

{ultralytics-8.3.120 → ultralytics-8.3.122}/ultralytics.egg-info/requires.txt

@@ -56,5 +56,5 @@ tensorboard
 mlflow
 
 [solutions]
-shapely<2.1.0,>=2.0.0
-streamlit<1.44.0,>=1.29.0
+shapely>=2.0.0
+streamlit>=1.29.0

ultralytics-8.3.120/ultralytics/solutions/speed_estimation.py

@@ -1,114 +0,0 @@
-# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
-
-from time import time
-
-from ultralytics.solutions.solutions import BaseSolution, SolutionAnnotator, SolutionResults
-from ultralytics.utils.plotting import colors
-
-
-class SpeedEstimator(BaseSolution):
-    """
-    A class to estimate the speed of objects in a real-time video stream based on their tracks.
-
-    This class extends the BaseSolution class and provides functionality for estimating object speeds using
-    tracking data in video streams.
-
-    Attributes:
-        spd (Dict[int, float]): Dictionary storing speed data for tracked objects.
-        trkd_ids (List[int]): List of tracked object IDs that have already been speed-estimated.
-        trk_pt (Dict[int, float]): Dictionary storing previous timestamps for tracked objects.
-        trk_pp (Dict[int, Tuple[float, float]]): Dictionary storing previous positions for tracked objects.
-        region (List[Tuple[int, int]]): List of points defining the speed estimation region.
-        track_line (List[Tuple[float, float]]): List of points representing the object's track.
-        r_s (LineString): LineString object representing the speed estimation region.
-
-    Methods:
-        initialize_region: Initializes the speed estimation region.
-        process: Processes input frames to estimate object speeds.
-        store_tracking_history: Stores the tracking history for an object.
-        extract_tracks: Extracts tracks from the current frame.
-        display_output: Displays the output with annotations.
-
-    Examples:
-        >>> estimator = SpeedEstimator()
-        >>> frame = cv2.imread("frame.jpg")
-        >>> results = estimator.process(frame)
-        >>> cv2.imshow("Speed Estimation", results.plot_im)
-    """
-
-    def __init__(self, **kwargs):
-        """
-        Initialize the SpeedEstimator object with speed estimation parameters and data structures.
-
-        Args:
-            **kwargs (Any): Additional keyword arguments passed to the parent class.
-        """
-        super().__init__(**kwargs)
-
-        self.initialize_region()  # Initialize speed region
-
-        self.spd = {}  # Dictionary for speed data
-        self.trkd_ids = []  # List for already speed-estimated and tracked IDs
-        self.trk_pt = {}  # Dictionary for tracks' previous timestamps
-        self.trk_pp = {}  # Dictionary for tracks' previous positions
-
-    def process(self, im0):
-        """
-        Process an input frame to estimate object speeds based on tracking data.
-
-        Args:
-            im0 (np.ndarray): Input image for processing with shape (H, W, C) for RGB images.
-
-        Returns:
-            (SolutionResults): Contains processed image `plot_im` and `total_tracks` (number of tracked objects).
-
-        Examples:
-            >>> estimator = SpeedEstimator()
-            >>> image = np.random.randint(0, 255, (480, 640, 3), dtype=np.uint8)
-            >>> results = estimator.process(image)
-        """
-        self.extract_tracks(im0)  # Extract tracks
-        annotator = SolutionAnnotator(im0, line_width=self.line_width)  # Initialize annotator
-
-        # Draw speed estimation region
-        annotator.draw_region(reg_pts=self.region, color=(104, 0, 123), thickness=self.line_width * 2)
-
-        for box, track_id, cls, conf in zip(self.boxes, self.track_ids, self.clss, self.confs):
-            self.store_tracking_history(track_id, box)  # Store track history
-
-            # Initialize tracking data for new objects
-            if track_id not in self.trk_pt:
-                self.trk_pt[track_id] = 0
-            if track_id not in self.trk_pp:
-                self.trk_pp[track_id] = self.track_line[-1]
-
-            speed_label = (
-                f"{int(self.spd[track_id])} km/h"
-                if track_id in self.spd and self.show_labels
-                else self.adjust_box_label(cls, conf, track_id)
-            )
-            annotator.box_label(box, label=speed_label, color=colors(track_id, True))  # Draw bounding box
-
-            # Determine if object is crossing the speed estimation region
-            if self.LineString([self.trk_pp[track_id], self.track_line[-1]]).intersects(self.r_s):
-                direction = "known"
-            else:
-                direction = "unknown"
-
-            # Calculate speed for objects crossing the region for the first time
-            if direction == "known" and track_id not in self.trkd_ids:
-                self.trkd_ids.append(track_id)
-                time_difference = time() - self.trk_pt[track_id]
-                if time_difference > 0:
-                    # Calculate speed based on vertical displacement and time
-                    self.spd[track_id] = abs(self.track_line[-1][1] - self.trk_pp[track_id][1]) / time_difference
-
-            # Update tracking data for next frame
-            self.trk_pt[track_id] = time()
-            self.trk_pp[track_id] = self.track_line[-1]
-
-        plot_im = annotator.result()
-        self.display_output(plot_im)  # Display output with base class function
-
-        # Return results with processed image and tracking summary
-        return SolutionResults(plot_im=plot_im, total_tracks=len(self.track_ids))