ultralytics 8.0.159__py3-none-any.whl → 8.0.161__py3-none-any.whl

ultralytics/models/yolo/segment/predict.py

@@ -1,7 +1,5 @@
 # Ultralytics YOLO 🚀, AGPL-3.0 license
 
-import torch
-
 from ultralytics.engine.results import Results
 from ultralytics.models.yolo.detect.predict import DetectionPredictor
 from ultralytics.utils import DEFAULT_CFG, ops
@@ -27,7 +25,6 @@ class SegmentationPredictor(DetectionPredictor):
         self.args.task = 'segment'
 
     def postprocess(self, preds, img, orig_imgs):
-        """TODO: filter by classes."""
         p = ops.non_max_suppression(preds[0],
                                     self.args.conf,
                                     self.args.iou,
@@ -36,22 +33,20 @@ class SegmentationPredictor(DetectionPredictor):
                                     nc=len(self.model.names),
                                     classes=self.args.classes)
         results = []
+        is_list = isinstance(orig_imgs, list)  # input images are a list, not a torch.Tensor
         proto = preds[1][-1] if len(preds[1]) == 3 else preds[1]  # second output is len 3 if pt, but only 1 if exported
         for i, pred in enumerate(p):
-            orig_img = orig_imgs[i] if isinstance(orig_imgs, list) else orig_imgs
-            path = self.batch[0]
-            img_path = path[i] if isinstance(path, list) else path
+            orig_img = orig_imgs[i] if is_list else orig_imgs
+            img_path = self.batch[0][i]
             if not len(pred):  # save empty boxes
-                results.append(Results(orig_img=orig_img, path=img_path, names=self.model.names, boxes=pred[:, :6]))
-                continue
-            if self.args.retina_masks:
-                if not isinstance(orig_imgs, torch.Tensor):
+                masks = None
+            elif self.args.retina_masks:
+                if is_list:
                     pred[:, :4] = ops.scale_boxes(img.shape[2:], pred[:, :4], orig_img.shape)
                 masks = ops.process_mask_native(proto[i], pred[:, 6:], pred[:, :4], orig_img.shape[:2])  # HWC
             else:
                 masks = ops.process_mask(proto[i], pred[:, 6:], pred[:, :4], img.shape[2:], upsample=True)  # HWC
-                if not isinstance(orig_imgs, torch.Tensor):
+                if is_list:
                     pred[:, :4] = ops.scale_boxes(img.shape[2:], pred[:, :4], orig_img.shape)
-            results.append(
-                Results(orig_img=orig_img, path=img_path, names=self.model.names, boxes=pred[:, :6], masks=masks))
+            results.append(Results(orig_img, path=img_path, names=self.model.names, boxes=pred[:, :6], masks=masks))
         return results

ultralytics/nn/modules/conv.py

@@ -9,7 +9,7 @@ import numpy as np
 import torch
 import torch.nn as nn
 
-__all__ = ('Conv', 'LightConv', 'DWConv', 'DWConvTranspose2d', 'ConvTranspose', 'Focus', 'GhostConv',
+__all__ = ('Conv', 'Conv2', 'LightConv', 'DWConv', 'DWConvTranspose2d', 'ConvTranspose', 'Focus', 'GhostConv',
            'ChannelAttention', 'SpatialAttention', 'CBAM', 'Concat', 'RepConv')
 
 
@@ -54,6 +54,10 @@ class Conv2(Conv):
         """Apply convolution, batch normalization and activation to input tensor."""
         return self.act(self.bn(self.conv(x) + self.cv2(x)))
 
+    def forward_fuse(self, x):
+        """Apply fused convolution, batch normalization and activation to input tensor."""
+        return self.act(self.bn(self.conv(x)))
+
     def fuse_convs(self):
         """Fuse parallel convolutions."""
         w = torch.zeros_like(self.conv.weight.data)
@@ -61,6 +65,7 @@ class Conv2(Conv):
         w[:, :, i[0]:i[0] + 1, i[1]:i[1] + 1] = self.cv2.weight.data.clone()
         self.conv.weight.data += w
         self.__delattr__('cv2')
+        self.forward = self.forward_fuse
 
 
 class LightConv(nn.Module):

ultralytics/trackers/utils/kalman_filter.py

@@ -6,20 +6,13 @@ import scipy.linalg
 
 class KalmanFilterXYAH:
     """
-    For bytetrack
-    A simple Kalman filter for tracking bounding boxes in image space.
+    For bytetrack. A simple Kalman filter for tracking bounding boxes in image space.
 
-    The 8-dimensional state space
-
-        x, y, a, h, vx, vy, va, vh
-
-    contains the bounding box center position (x, y), aspect ratio a, height h,
-    and their respective velocities.
-
-    Object motion follows a constant velocity model. The bounding box location
-    (x, y, a, h) is taken as direct observation of the state space (linear
-    observation model).
+    The 8-dimensional state space (x, y, a, h, vx, vy, va, vh) contains the bounding box center position (x, y),
+    aspect ratio a, height h, and their respective velocities.
 
+    Object motion follows a constant velocity model. The bounding box location (x, y, a, h) is taken as direct
+    observation of the state space (linear observation model).
     """
 
     def __init__(self):
@@ -32,14 +25,14 @@ class KalmanFilterXYAH:
             self._motion_mat[i, ndim + i] = dt
         self._update_mat = np.eye(ndim, 2 * ndim)
 
-        # Motion and observation uncertainty are chosen relative to the current
-        # state estimate. These weights control the amount of uncertainty in
-        # the model. This is a bit hacky.
+        # Motion and observation uncertainty are chosen relative to the current state estimate. These weights control
+        # the amount of uncertainty in the model. This is a bit hacky.
         self._std_weight_position = 1. / 20
         self._std_weight_velocity = 1. / 160
 
     def initiate(self, measurement):
-        """Create track from unassociated measurement.
+        """
+        Create track from unassociated measurement.
 
         Parameters
         ----------
@@ -53,7 +46,6 @@ class KalmanFilterXYAH:
             Returns the mean vector (8 dimensional) and covariance matrix (8x8
             dimensional) of the new track. Unobserved velocities are initialized
             to 0 mean.
-
         """
         mean_pos = measurement
         mean_vel = np.zeros_like(mean_pos)
@@ -67,23 +59,21 @@ class KalmanFilterXYAH:
         return mean, covariance
 
     def predict(self, mean, covariance):
-        """Run Kalman filter prediction step.
+        """
+        Run Kalman filter prediction step.
 
         Parameters
         ----------
         mean : ndarray
-            The 8 dimensional mean vector of the object state at the previous
-            time step.
+            The 8 dimensional mean vector of the object state at the previous time step.
         covariance : ndarray
-            The 8x8 dimensional covariance matrix of the object state at the
-            previous time step.
+            The 8x8 dimensional covariance matrix of the object state at the previous time step.
 
         Returns
         -------
         (ndarray, ndarray)
-            Returns the mean vector and covariance matrix of the predicted
-            state. Unobserved velocities are initialized to 0 mean.
-
+            Returns the mean vector and covariance matrix of the predicted state. Unobserved velocities are
+            initialized to 0 mean.
         """
         std_pos = [
             self._std_weight_position * mean[3], self._std_weight_position * mean[3], 1e-2,
@@ -100,7 +90,8 @@ class KalmanFilterXYAH:
         return mean, covariance
 
     def project(self, mean, covariance):
-        """Project state distribution to measurement space.
+        """
+        Project state distribution to measurement space.
 
         Parameters
         ----------
@@ -112,9 +103,7 @@ class KalmanFilterXYAH:
         Returns
         -------
         (ndarray, ndarray)
-            Returns the projected mean and covariance matrix of the given state
-            estimate.
-
+            Returns the projected mean and covariance matrix of the given state estimate.
         """
         std = [
             self._std_weight_position * mean[3], self._std_weight_position * mean[3], 1e-1,
@@ -126,20 +115,21 @@ class KalmanFilterXYAH:
         return mean, covariance + innovation_cov
 
     def multi_predict(self, mean, covariance):
-        """Run Kalman filter prediction step (Vectorized version).
+        """
+        Run Kalman filter prediction step (Vectorized version).
+
         Parameters
         ----------
         mean : ndarray
-            The Nx8 dimensional mean matrix of the object states at the previous
-            time step.
+            The Nx8 dimensional mean matrix of the object states at the previous time step.
         covariance : ndarray
-            The Nx8x8 dimensional covariance matrix of the object states at the
-            previous time step.
+            The Nx8x8 dimensional covariance matrix of the object states at the previous time step.
+
         Returns
         -------
         (ndarray, ndarray)
-            Returns the mean vector and covariance matrix of the predicted
-            state. Unobserved velocities are initialized to 0 mean.
+            Returns the mean vector and covariance matrix of the predicted state. Unobserved velocities are
+            initialized to 0 mean.
         """
         std_pos = [
             self._std_weight_position * mean[:, 3], self._std_weight_position * mean[:, 3],
@@ -159,7 +149,8 @@ class KalmanFilterXYAH:
         return mean, covariance
 
     def update(self, mean, covariance, measurement):
-        """Run Kalman filter correction step.
+        """
+        Run Kalman filter correction step.
 
         Parameters
         ----------
@@ -168,15 +159,13 @@ class KalmanFilterXYAH:
         covariance : ndarray
             The state's covariance matrix (8x8 dimensional).
         measurement : ndarray
-            The 4 dimensional measurement vector (x, y, a, h), where (x, y)
-            is the center position, a the aspect ratio, and h the height of the
-            bounding box.
+            The 4 dimensional measurement vector (x, y, a, h), where (x, y) is the center position, a the aspect
+            ratio, and h the height of the bounding box.
 
         Returns
         -------
         (ndarray, ndarray)
             Returns the measurement-corrected state distribution.
-
         """
         projected_mean, projected_cov = self.project(mean, covariance)
 
@@ -191,10 +180,11 @@ class KalmanFilterXYAH:
         return new_mean, new_covariance
 
     def gating_distance(self, mean, covariance, measurements, only_position=False, metric='maha'):
-        """Compute gating distance between state distribution and measurements.
-        A suitable distance threshold can be obtained from `chi2inv95`. If
-        `only_position` is False, the chi-square distribution has 4 degrees of
+        """
+        Compute gating distance between state distribution and measurements. A suitable distance threshold can be
+        obtained from `chi2inv95`. If `only_position` is False, the chi-square distribution has 4 degrees of
         freedom, otherwise 2.
+
         Parameters
         ----------
         mean : ndarray
@@ -202,18 +192,16 @@ class KalmanFilterXYAH:
         covariance : ndarray
             Covariance of the state distribution (8x8 dimensional).
         measurements : ndarray
-            An Nx4 dimensional matrix of N measurements, each in
-            format (x, y, a, h) where (x, y) is the bounding box center
-            position, a the aspect ratio, and h the height.
+            An Nx4 dimensional matrix of N measurements, each in format (x, y, a, h) where (x, y) is the bounding box
+            center position, a the aspect ratio, and h the height.
         only_position : Optional[bool]
-            If True, distance computation is done with respect to the bounding
-            box center position only.
+            If True, distance computation is done with respect to the bounding box center position only.
+
         Returns
         -------
         ndarray
-            Returns an array of length N, where the i-th element contains the
-            squared Mahalanobis distance between (mean, covariance) and
-            `measurements[i]`.
+            Returns an array of length N, where the i-th element contains the squared Mahalanobis distance between
+            (mean, covariance) and `measurements[i]`.
         """
         mean, covariance = self.project(mean, covariance)
         if only_position:
@@ -233,38 +221,29 @@ class KalmanFilterXYAH:
 
 class KalmanFilterXYWH(KalmanFilterXYAH):
     """
-    For BoT-SORT
-    A simple Kalman filter for tracking bounding boxes in image space.
+    For BoT-SORT. A simple Kalman filter for tracking bounding boxes in image space.
 
-    The 8-dimensional state space
-
-        x, y, w, h, vx, vy, vw, vh
-
-    contains the bounding box center position (x, y), width w, height h,
-    and their respective velocities.
-
-    Object motion follows a constant velocity model. The bounding box location
-    (x, y, w, h) is taken as direct observation of the state space (linear
-    observation model).
+    The 8-dimensional state space (x, y, w, h, vx, vy, vw, vh) contains the bounding box center position (x, y),
+    width w, height h, and their respective velocities.
 
+    Object motion follows a constant velocity model. The bounding box location (x, y, w, h) is taken as direct
+    observation of the state space (linear observation model).
     """
 
     def initiate(self, measurement):
-        """Create track from unassociated measurement.
+        """
+        Create track from unassociated measurement.
 
         Parameters
         ----------
         measurement : ndarray
-            Bounding box coordinates (x, y, w, h) with center position (x, y),
-            width w, and height h.
+            Bounding box coordinates (x, y, w, h) with center position (x, y), width w, and height h.
 
         Returns
         -------
         (ndarray, ndarray)
-            Returns the mean vector (8 dimensional) and covariance matrix (8x8
-            dimensional) of the new track. Unobserved velocities are initialized
-            to 0 mean.
-
+            Returns the mean vector (8 dimensional) and covariance matrix (8x8 dimensional) of the new track.
+            Unobserved velocities are initialized to 0 mean.
         """
         mean_pos = measurement
         mean_vel = np.zeros_like(mean_pos)
@@ -279,23 +258,21 @@ class KalmanFilterXYWH(KalmanFilterXYAH):
         return mean, covariance
 
     def predict(self, mean, covariance):
-        """Run Kalman filter prediction step.
+        """
+        Run Kalman filter prediction step.
 
         Parameters
         ----------
         mean : ndarray
-            The 8 dimensional mean vector of the object state at the previous
-            time step.
+            The 8 dimensional mean vector of the object state at the previous time step.
         covariance : ndarray
-            The 8x8 dimensional covariance matrix of the object state at the
-            previous time step.
+            The 8x8 dimensional covariance matrix of the object state at the previous time step.
 
         Returns
         -------
         (ndarray, ndarray)
-            Returns the mean vector and covariance matrix of the predicted
-            state. Unobserved velocities are initialized to 0 mean.
-
+            Returns the mean vector and covariance matrix of the predicted state. Unobserved velocities are
+            initialized to 0 mean.
         """
         std_pos = [
             self._std_weight_position * mean[2], self._std_weight_position * mean[3],
@@ -311,7 +288,8 @@ class KalmanFilterXYWH(KalmanFilterXYAH):
         return mean, covariance
 
     def project(self, mean, covariance):
-        """Project state distribution to measurement space.
+        """
+        Project state distribution to measurement space.
 
         Parameters
         ----------
@@ -323,9 +301,7 @@ class KalmanFilterXYWH(KalmanFilterXYAH):
         Returns
         -------
         (ndarray, ndarray)
-            Returns the projected mean and covariance matrix of the given state
-            estimate.
-
+            Returns the projected mean and covariance matrix of the given state estimate.
         """
         std = [
             self._std_weight_position * mean[2], self._std_weight_position * mean[3],
@@ -337,20 +313,21 @@ class KalmanFilterXYWH(KalmanFilterXYAH):
         return mean, covariance + innovation_cov
 
     def multi_predict(self, mean, covariance):
-        """Run Kalman filter prediction step (Vectorized version).
+        """
+        Run Kalman filter prediction step (Vectorized version).
+
         Parameters
         ----------
         mean : ndarray
-            The Nx8 dimensional mean matrix of the object states at the previous
-            time step.
+            The Nx8 dimensional mean matrix of the object states at the previous time step.
         covariance : ndarray
-            The Nx8x8 dimensional covariance matrix of the object states at the
-            previous time step.
+            The Nx8x8 dimensional covariance matrix of the object states at the previous time step.
+
         Returns
         -------
         (ndarray, ndarray)
-            Returns the mean vector and covariance matrix of the predicted
-            state. Unobserved velocities are initialized to 0 mean.
+            Returns the mean vector and covariance matrix of the predicted state. Unobserved velocities are
+            initialized to 0 mean.
         """
         std_pos = [
             self._std_weight_position * mean[:, 2], self._std_weight_position * mean[:, 3],
@@ -370,7 +347,8 @@ class KalmanFilterXYWH(KalmanFilterXYAH):
         return mean, covariance
 
     def update(self, mean, covariance, measurement):
-        """Run Kalman filter correction step.
+        """
+        Run Kalman filter correction step.
 
         Parameters
         ----------
@@ -379,14 +357,12 @@ class KalmanFilterXYWH(KalmanFilterXYAH):
         covariance : ndarray
             The state's covariance matrix (8x8 dimensional).
         measurement : ndarray
-            The 4 dimensional measurement vector (x, y, w, h), where (x, y)
-            is the center position, w the width, and h the height of the
-            bounding box.
+            The 4 dimensional measurement vector (x, y, w, h), where (x, y) is the center position, w the width,
+            and h the height of the bounding box.
 
         Returns
         -------
         (ndarray, ndarray)
             Returns the measurement-corrected state distribution.
-
         """
         return super().update(mean, covariance, measurement)

ultralytics/utils/callbacks/tensorboard.py

@@ -32,9 +32,9 @@ def _log_tensorboard_graph(trainer):
         imgsz = trainer.args.imgsz
         imgsz = (imgsz, imgsz) if isinstance(imgsz, int) else imgsz
         p = next(trainer.model.parameters())  # for device, type
-        im = torch.zeros((1, 3, *imgsz), device=p.device, dtype=p.dtype)  # input (WARNING: must be zeros, not empty)
-        with warnings.catch_warnings(category=UserWarning):
-            warnings.simplefilter('ignore')  # suppress jit trace warning
+        im = torch.zeros((1, 3, *imgsz), device=p.device, dtype=p.dtype)  # input image (must be zeros, not empty)
+        with warnings.catch_warnings():
+            warnings.simplefilter('ignore', category=UserWarning)  # suppress jit trace warning
             WRITER.add_graph(torch.jit.trace(de_parallel(trainer.model), im, strict=False), [])
     except Exception as e:
         LOGGER.warning(f'WARNING ⚠️ TensorBoard graph visualization failure {e}')

ultralytics/utils/checks.py

@@ -20,9 +20,9 @@ import requests
 import torch
 from matplotlib import font_manager
 
-from ultralytics.utils import (ASSETS, AUTOINSTALL, LOGGER, ONLINE, ROOT, USER_CONFIG_DIR, ThreadingLocked, TryExcept,
-                               clean_url, colorstr, downloads, emojis, is_colab, is_docker, is_jupyter, is_kaggle,
-                               is_online, is_pip_package, url2file)
+from ultralytics.utils import (ASSETS, AUTOINSTALL, LINUX, LOGGER, ONLINE, ROOT, USER_CONFIG_DIR, ThreadingLocked,
+                               TryExcept, clean_url, colorstr, downloads, emojis, is_colab, is_docker, is_jupyter,
+                               is_kaggle, is_online, is_pip_package, url2file)
 
 
 def is_ascii(s) -> bool:
@@ -389,8 +389,9 @@ def check_yaml(file, suffix=('.yaml', '.yml'), hard=True):
 def check_imshow(warn=False):
     """Check if environment supports image displays."""
     try:
-        assert not any((is_colab(), is_kaggle(), is_docker()))
-        cv2.imshow('test', np.zeros((1, 1, 3)))
+        if LINUX:
+            assert 'DISPLAY' in os.environ and not is_docker() and not is_colab() and not is_kaggle()
+        cv2.imshow('test', np.zeros((8, 8, 3), dtype=np.uint8))  # show a small 8-pixel image
         cv2.waitKey(1)
         cv2.destroyAllWindows()
         cv2.waitKey(1)

ultralytics/utils/downloads.py

@@ -39,16 +39,17 @@ def is_url(url, check=True):
     return False
 
 
-def delete_dsstore(path):
+def delete_dsstore(path, files_to_delete=('.DS_Store', '__MACOSX')):
     """
     Deletes all ".DS_store" files under a specified directory.
 
     Args:
         path (str, optional): The directory path where the ".DS_store" files should be deleted.
+        files_to_delete (tuple): The files to be deleted.
 
     Example:
         ```python
-        from ultralytics.data.utils import delete_dsstore
+        from ultralytics.utils.downloads import delete_dsstore
 
         delete_dsstore('path/to/dir')
         ```
@@ -58,10 +59,11 @@ def delete_dsstore(path):
         are hidden system files and can cause issues when transferring files between different operating systems.
     """
     # Delete Apple .DS_store files
-    files = list(Path(path).rglob('.DS_store'))
-    LOGGER.info(f'Deleting *.DS_store files: {files}')
-    for f in files:
-        f.unlink()
+    for file in files_to_delete:
+        matches = list(Path(path).rglob(file))
+        LOGGER.info(f'Deleting {file} files: {matches}')
+        for f in matches:
+            f.unlink()
 
 
 def zip_directory(directory, compress=True, exclude=('.DS_Store', '__MACOSX'), progress=True):
@@ -212,21 +214,18 @@ def get_google_drive_file_info(link):
     """
     file_id = link.split('/d/')[1].split('/view')[0]
     drive_url = f'https://drive.google.com/uc?export=download&id={file_id}'
+    filename = None
 
     # Start session
-    filename = None
     with requests.Session() as session:
         response = session.get(drive_url, stream=True)
         if 'quota exceeded' in str(response.content.lower()):
             raise ConnectionError(
                 emojis(f'❌  Google Drive file download quota exceeded. '
                        f'Please try again later or download this file manually at {link}.'))
-        token = None
-        for key, value in response.cookies.items():
-            if key.startswith('download_warning'):
-                token = value
-        if token:
-            drive_url = f'https://drive.google.com/uc?export=download&confirm={token}&id={file_id}'
+        for k, v in response.cookies.items():
+            if k.startswith('download_warning'):
+                drive_url += f'&confirm={v}'  # v is token
         cd = response.headers.get('content-disposition')
         if cd:
             filename = re.findall('filename="(.+)"', cd)[0]

ultralytics/utils/metrics.py

@@ -15,12 +15,6 @@ from ultralytics.utils import LOGGER, SimpleClass, TryExcept, plt_settings
 OKS_SIGMA = np.array([.26, .25, .25, .35, .35, .79, .79, .72, .72, .62, .62, 1.07, 1.07, .87, .87, .89, .89]) / 10.0
 
 
-# Boxes
-def box_area(box):
-    """Return box area, where box shape is xyxy(4,n)."""
-    return (box[2] - box[0]) * (box[3] - box[1])
-
-
 def bbox_ioa(box1, box2, iou=False, eps=1e-7):
     """
     Calculate the intersection over box2 area given box1 and box2. Boxes are in x1y1x2y2 format.
@@ -869,11 +863,6 @@ class PoseMetrics(SegmentMetrics):
         self.pose = Metric()
         self.speed = {'preprocess': 0.0, 'inference': 0.0, 'loss': 0.0, 'postprocess': 0.0}
 
-    def __getattr__(self, attr):
-        """Raises an AttributeError if an invalid attribute is accessed."""
-        name = self.__class__.__name__
-        raise AttributeError(f"'{name}' object has no attribute '{attr}'. See valid attributes below.\n{self.__doc__}")
-
     def process(self, tp_b, tp_p, conf, pred_cls, target_cls):
         """
         Processes the detection and pose metrics over the given set of predictions.