ultralytics 8.0.142__py3-none-any.whl → 8.0.144__py3-none-any.whl

ultralytics/models/nas/model.py

@@ -13,105 +13,36 @@ from pathlib import Path
 
 import torch
 
-from ultralytics.cfg import get_cfg
-from ultralytics.engine.exporter import Exporter
-from ultralytics.utils import DEFAULT_CFG, DEFAULT_CFG_DICT, LOGGER, ROOT, is_git_dir
-from ultralytics.utils.checks import check_imgsz
+from ultralytics.engine.model import Model
 from ultralytics.utils.torch_utils import model_info, smart_inference_mode
 
 from .predict import NASPredictor
 from .val import NASValidator
 
 
-class NAS:
+class NAS(Model):
 
     def __init__(self, model='yolo_nas_s.pt') -> None:
+        assert Path(model).suffix != '.yaml', 'YOLO-NAS models only support pre-trained models.'
+        super().__init__(model, task='detect')
+
+    @smart_inference_mode()
+    def _load(self, weights: str, task: str):
         # Load or create new NAS model
         import super_gradients
-
-        self.predictor = None
-        suffix = Path(model).suffix
+        suffix = Path(weights).suffix
         if suffix == '.pt':
-            self._load(model)
+            self.model = torch.load(weights)
         elif suffix == '':
-            self.model = super_gradients.training.models.get(model, pretrained_weights='coco')
-        self.task = 'detect'
-        self.model.args = DEFAULT_CFG_DICT  # attach args to model
-
+            self.model = super_gradients.training.models.get(weights, pretrained_weights='coco')
         # Standardize model
         self.model.fuse = lambda verbose=True: self.model
         self.model.stride = torch.tensor([32])
         self.model.names = dict(enumerate(self.model._class_names))
         self.model.is_fused = lambda: False  # for info()
         self.model.yaml = {}  # for info()
-        self.model.pt_path = model  # for export()
+        self.model.pt_path = weights  # for export()
         self.model.task = 'detect'  # for export()
-        self.info()
-
-    @smart_inference_mode()
-    def _load(self, weights: str):
-        self.model = torch.load(weights)
-
-    @smart_inference_mode()
-    def predict(self, source=None, stream=False, **kwargs):
-        """
-        Perform prediction using the YOLO model.
-
-        Args:
-            source (str | int | PIL | np.ndarray): The source of the image to make predictions on.
-                          Accepts all source types accepted by the YOLO model.
-            stream (bool): Whether to stream the predictions or not. Defaults to False.
-            **kwargs : Additional keyword arguments passed to the predictor.
-                       Check the 'configuration' section in the documentation for all available options.
-
-        Returns:
-            (List[ultralytics.engine.results.Results]): The prediction results.
-        """
-        if source is None:
-            source = ROOT / 'assets' if is_git_dir() else 'https://ultralytics.com/images/bus.jpg'
-            LOGGER.warning(f"WARNING ⚠️ 'source' is missing. Using 'source={source}'.")
-        overrides = dict(conf=0.25, task='detect', mode='predict')
-        overrides.update(kwargs)  # prefer kwargs
-        if not self.predictor:
-            self.predictor = NASPredictor(overrides=overrides)
-            self.predictor.setup_model(model=self.model)
-        else:  # only update args if predictor is already setup
-            self.predictor.args = get_cfg(self.predictor.args, overrides)
-        return self.predictor(source, stream=stream)
-
-    def train(self, **kwargs):
-        """Function trains models but raises an error as NAS models do not support training."""
-        raise NotImplementedError("NAS models don't support training")
-
-    def val(self, **kwargs):
-        """Run validation given dataset."""
-        overrides = dict(task='detect', mode='val')
-        overrides.update(kwargs)  # prefer kwargs
-        args = get_cfg(cfg=DEFAULT_CFG, overrides=overrides)
-        args.imgsz = check_imgsz(args.imgsz, max_dim=1)
-        validator = NASValidator(args=args)
-        validator(model=self.model)
-        self.metrics = validator.metrics
-        return validator.metrics
-
-    @smart_inference_mode()
-    def export(self, **kwargs):
-        """
-        Export model.
-
-        Args:
-            **kwargs : Any other args accepted by the predictors. To see all args check 'configuration' section in docs
-        """
-        overrides = dict(task='detect')
-        overrides.update(kwargs)
-        overrides['mode'] = 'export'
-        args = get_cfg(cfg=DEFAULT_CFG, overrides=overrides)
-        args.task = self.task
-        if args.imgsz == DEFAULT_CFG.imgsz:
-            args.imgsz = self.model.args['imgsz']  # use trained imgsz unless custom value is passed
-        if args.batch == DEFAULT_CFG.batch:
-            args.batch = 1  # default to 1 if not modified
-        return Exporter(overrides=args)(model=self.model)
 
     def info(self, detailed=False, verbose=True):
         """
@@ -123,11 +54,6 @@ class NAS:
         """
         return model_info(self.model, detailed=detailed, verbose=verbose, imgsz=640)
 
-    def __call__(self, source=None, stream=False, **kwargs):
-        """Calls the 'predict' function with given arguments to perform object detection."""
-        return self.predict(source, stream, **kwargs)
-
-    def __getattr__(self, attr):
-        """Raises error if object has no requested attribute."""
-        name = self.__class__.__name__
-        raise AttributeError(f"'{name}' object has no attribute '{attr}'. See valid attributes below.\n{self.__doc__}")
+    @property
+    def task_map(self):
+        return {'detect': {'predictor': NASPredictor, 'validator': NASValidator}}

ultralytics/models/rtdetr/model.py

@@ -2,172 +2,29 @@
 """
 RT-DETR model interface
 """
-
-from pathlib import Path
-
-import torch.nn as nn
-
-from ultralytics.cfg import get_cfg
-from ultralytics.engine.exporter import Exporter
-from ultralytics.nn.tasks import RTDETRDetectionModel, attempt_load_one_weight, yaml_model_load
-from ultralytics.utils import DEFAULT_CFG, DEFAULT_CFG_DICT, LOGGER, RANK, ROOT, is_git_dir
-from ultralytics.utils.checks import check_imgsz
-from ultralytics.utils.torch_utils import model_info, smart_inference_mode
+from ultralytics.engine.model import Model
+from ultralytics.nn.tasks import RTDETRDetectionModel
 
 from .predict import RTDETRPredictor
 from .train import RTDETRTrainer
 from .val import RTDETRValidator
 
 
-class RTDETR:
+class RTDETR(Model):
+    """
+    RTDETR model interface.
+    """
 
     def __init__(self, model='rtdetr-l.pt') -> None:
         if model and not model.endswith('.pt') and not model.endswith('.yaml'):
             raise NotImplementedError('RT-DETR only supports creating from pt file or yaml file.')
-        # Load or create new YOLO model
-        self.predictor = None
-        self.ckpt = None
-        suffix = Path(model).suffix
-        if suffix == '.yaml':
-            self._new(model)
-        else:
-            self._load(model)
-
-    def _new(self, cfg: str, verbose=True):
-        cfg_dict = yaml_model_load(cfg)
-        self.cfg = cfg
-        self.task = 'detect'
-        self.model = RTDETRDetectionModel(cfg_dict, verbose=verbose)  # build model
-
-        # Below added to allow export from YAMLs
-        self.model.args = DEFAULT_CFG_DICT  # attach args to model
-        self.model.task = self.task
-
-    @smart_inference_mode()
-    def _load(self, weights: str):
-        self.model, self.ckpt = attempt_load_one_weight(weights)
-        self.model.args = DEFAULT_CFG_DICT  # attach args to model
-        self.task = self.model.args['task']
-
-    @smart_inference_mode()
-    def load(self, weights='yolov8n.pt'):
-        """
-        Transfers parameters with matching names and shapes from 'weights' to model.
-        """
-        if isinstance(weights, (str, Path)):
-            weights, self.ckpt = attempt_load_one_weight(weights)
-        self.model.load(weights)
-        return self
-
-    @smart_inference_mode()
-    def predict(self, source=None, stream=False, **kwargs):
-        """
-        Perform prediction using the YOLO model.
-
-        Args:
-            source (str | int | PIL | np.ndarray): The source of the image to make predictions on.
-                          Accepts all source types accepted by the YOLO model.
-            stream (bool): Whether to stream the predictions or not. Defaults to False.
-            **kwargs : Additional keyword arguments passed to the predictor.
-                       Check the 'configuration' section in the documentation for all available options.
-
-        Returns:
-            (List[ultralytics.engine.results.Results]): The prediction results.
-        """
-        if source is None:
-            source = ROOT / 'assets' if is_git_dir() else 'https://ultralytics.com/images/bus.jpg'
-            LOGGER.warning(f"WARNING ⚠️ 'source' is missing. Using 'source={source}'.")
-        overrides = dict(conf=0.25, task='detect', mode='predict')
-        overrides.update(kwargs)  # prefer kwargs
-        if not self.predictor:
-            self.predictor = RTDETRPredictor(overrides=overrides)
-            self.predictor.setup_model(model=self.model)
-        else:  # only update args if predictor is already setup
-            self.predictor.args = get_cfg(self.predictor.args, overrides)
-        return self.predictor(source, stream=stream)
-
-    def train(self, **kwargs):
-        """
-        Trains the model on a given dataset.
-
-        Args:
-            **kwargs (Any): Any number of arguments representing the training configuration.
-        """
-        overrides = dict(task='detect', mode='train')
-        overrides.update(kwargs)
-        overrides['deterministic'] = False
-        if not overrides.get('data'):
-            raise AttributeError("Dataset required but missing, i.e. pass 'data=coco128.yaml'")
-        if overrides.get('resume'):
-            overrides['resume'] = self.ckpt_path
-        self.task = overrides.get('task') or self.task
-        self.trainer = RTDETRTrainer(overrides=overrides)
-        if not overrides.get('resume'):  # manually set model only if not resuming
-            self.trainer.model = self.trainer.get_model(weights=self.model if self.ckpt else None, cfg=self.model.yaml)
-            self.model = self.trainer.model
-        self.trainer.train()
-        # Update model and cfg after training
-        if RANK in (-1, 0):
-            self.model, _ = attempt_load_one_weight(str(self.trainer.best))
-            self.overrides = self.model.args
-            self.metrics = getattr(self.trainer.validator, 'metrics', None)  # TODO: no metrics returned by DDP
-
-    def val(self, **kwargs):
-        """Run validation given dataset."""
-        overrides = dict(task='detect', mode='val')
-        overrides.update(kwargs)  # prefer kwargs
-        args = get_cfg(cfg=DEFAULT_CFG, overrides=overrides)
-        args.imgsz = check_imgsz(args.imgsz, max_dim=1)
-        validator = RTDETRValidator(args=args)
-        validator(model=self.model)
-        self.metrics = validator.metrics
-        return validator.metrics
-
-    def info(self, verbose=True):
-        """Get model info"""
-        return model_info(self.model, verbose=verbose)
-
-    def _check_is_pytorch_model(self):
-        """
-        Raises TypeError is model is not a PyTorch model
-        """
-        pt_str = isinstance(self.model, (str, Path)) and Path(self.model).suffix == '.pt'
-        pt_module = isinstance(self.model, nn.Module)
-        if not (pt_module or pt_str):
-            raise TypeError(f"model='{self.model}' must be a *.pt PyTorch model, but is a different type. "
-                            f'PyTorch models can be used to train, val, predict and export, i.e. '
-                            f"'yolo export model=yolov8n.pt', but exported formats like ONNX, TensorRT etc. only "
-                            f"support 'predict' and 'val' modes, i.e. 'yolo predict model=yolov8n.onnx'.")
-
-    def fuse(self):
-        """Fuse PyTorch Conv2d and BatchNorm2d layers."""
-        self._check_is_pytorch_model()
-        self.model.fuse()
-
-    @smart_inference_mode()
-    def export(self, **kwargs):
-        """
-        Export model.
-
-        Args:
-            **kwargs : Any other args accepted by the predictors. To see all args check 'configuration' section in docs
-        """
-        overrides = dict(task='detect')
-        overrides.update(kwargs)
-        overrides['mode'] = 'export'
-        args = get_cfg(cfg=DEFAULT_CFG, overrides=overrides)
-        args.task = self.task
-        if args.imgsz == DEFAULT_CFG.imgsz:
-            args.imgsz = self.model.args['imgsz']  # use trained imgsz unless custom value is passed
-        if args.batch == DEFAULT_CFG.batch:
-            args.batch = 1  # default to 1 if not modified
-        return Exporter(overrides=args)(model=self.model)
-
-    def __call__(self, source=None, stream=False, **kwargs):
-        """Calls the 'predict' function with given arguments to perform object detection."""
-        return self.predict(source, stream, **kwargs)
-
-    def __getattr__(self, attr):
-        """Raises error if object has no requested attribute."""
-        name = self.__class__.__name__
-        raise AttributeError(f"'{name}' object has no attribute '{attr}'. See valid attributes below.\n{self.__doc__}")
+        super().__init__(model=model, task='detect')
+
+    @property
+    def task_map(self):
+        return {
+            'detect': {
+                'predictor': RTDETRPredictor,
+                'validator': RTDETRValidator,
+                'trainer': RTDETRTrainer,
+                'model': RTDETRDetectionModel}}

ultralytics/models/sam/model.py

@@ -3,51 +3,38 @@
 SAM model interface
 """
 
-from ultralytics.cfg import get_cfg
+from ultralytics.engine.model import Model
 from ultralytics.utils.torch_utils import model_info
 
 from .build import build_sam
 from .predict import Predictor
 
 
-class SAM:
+class SAM(Model):
+    """
+    SAM model interface.
+    """
 
     def __init__(self, model='sam_b.pt') -> None:
         if model and not model.endswith('.pt') and not model.endswith('.pth'):
             # Should raise AssertionError instead?
             raise NotImplementedError('Segment anything prediction requires pre-trained checkpoint')
-        self.model = build_sam(model)
-        self.task = 'segment'  # required
-        self.predictor = None  # reuse predictor
+        super().__init__(model=model, task='segment')
+
+    def _load(self, weights: str, task=None):
+        self.model = build_sam(weights)
 
     def predict(self, source, stream=False, bboxes=None, points=None, labels=None, **kwargs):
         """Predicts and returns segmentation masks for given image or video source."""
         overrides = dict(conf=0.25, task='segment', mode='predict', imgsz=1024)
-        overrides.update(kwargs)  # prefer kwargs
-        if not self.predictor:
-            self.predictor = Predictor(overrides=overrides)
-            self.predictor.setup_model(model=self.model)
-        else:  # only update args if predictor is already setup
-            self.predictor.args = get_cfg(self.predictor.args, overrides)
-        return self.predictor(source, stream=stream, bboxes=bboxes, points=points, labels=labels)
-
-    def train(self, **kwargs):
-        """Function trains models but raises an error as SAM models do not support training."""
-        raise NotImplementedError("SAM models don't support training")
-
-    def val(self, **kwargs):
-        """Run validation given dataset."""
-        raise NotImplementedError("SAM models don't support validation")
+        kwargs.update(overrides)
+        prompts = dict(bboxes=bboxes, points=points, labels=labels)
+        return super().predict(source, stream, prompts=prompts, **kwargs)
 
     def __call__(self, source=None, stream=False, bboxes=None, points=None, labels=None, **kwargs):
         """Calls the 'predict' function with given arguments to perform object detection."""
         return self.predict(source, stream, bboxes, points, labels, **kwargs)
 
-    def __getattr__(self, attr):
-        """Raises error if object has no requested attribute."""
-        name = self.__class__.__name__
-        raise AttributeError(f"'{name}' object has no attribute '{attr}'. See valid attributes below.\n{self.__doc__}")
-
     def info(self, detailed=False, verbose=True):
         """
         Logs model info.
@@ -57,3 +44,7 @@ class SAM:
             verbose (bool): Controls verbosity.
         """
         return model_info(self.model, detailed=detailed, verbose=verbose)
+
+    @property
+    def task_map(self):
+        return {'segment': {'predictor': Predictor}}

ultralytics/models/sam/predict.py

@@ -28,6 +28,8 @@ class Predictor(BasePredictor):
         # Args for set_image
         self.im = None
         self.features = None
+        # Args for set_prompts
+        self.prompts = {}
         # Args for segment everything
         self.segment_all = False
 
@@ -92,6 +94,10 @@ class Predictor(BasePredictor):
                 of masks and H=W=256. These low resolution logits can be passed to
                 a subsequent iteration as mask input.
         """
+        # Get prompts from self.prompts first
+        bboxes = self.prompts.pop('bboxes', bboxes)
+        points = self.prompts.pop('points', points)
+        masks = self.prompts.pop('masks', masks)
         if all(i is None for i in [bboxes, points, masks]):
             return self.generate(im, *args, **kwargs)
         return self.prompt_inference(im, bboxes, points, labels, masks, multimask_output)
@@ -288,7 +294,7 @@ class Predictor(BasePredictor):
 
     def setup_model(self, model, verbose=True):
         """Set up YOLO model with specified thresholds and device."""
-        device = select_device(self.args.device)
+        device = select_device(self.args.device, verbose=verbose)
         if model is None:
             model = build_sam(self.args.model)
         model.eval()
@@ -348,6 +354,10 @@ class Predictor(BasePredictor):
             self.im = im
             break
 
+    def set_prompts(self, prompts):
+        """Set prompts in advance."""
+        self.prompts = prompts
+
     def reset_image(self):
         self.im = None
         self.features = None

ultralytics/models/yolo/__init__.py

@@ -2,4 +2,6 @@
 
 from ultralytics.models.yolo import classify, detect, pose, segment
 
-__all__ = 'classify', 'segment', 'detect', 'pose'
+from .model import YOLO
+
+__all__ = 'classify', 'segment', 'detect', 'pose', 'YOLO'

ultralytics/models/yolo/detect/train.py

@@ -1,4 +1,5 @@
 # Ultralytics YOLO 🚀, AGPL-3.0 license
+
 from copy import copy
 
 import numpy as np

ultralytics/models/yolo/model.py

@@ -0,0 +1,36 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+
+from ultralytics.engine.model import Model
+from ultralytics.models import yolo  # noqa
+from ultralytics.nn.tasks import ClassificationModel, DetectionModel, PoseModel, SegmentationModel
+
+
+class YOLO(Model):
+    """
+    YOLO (You Only Look Once) object detection model.
+    """
+
+    @property
+    def task_map(self):
+        """Map head to model, trainer, validator, and predictor classes"""
+        return {
+            'classify': {
+                'model': ClassificationModel,
+                'trainer': yolo.classify.ClassificationTrainer,
+                'validator': yolo.classify.ClassificationValidator,
+                'predictor': yolo.classify.ClassificationPredictor, },
+            'detect': {
+                'model': DetectionModel,
+                'trainer': yolo.detect.DetectionTrainer,
+                'validator': yolo.detect.DetectionValidator,
+                'predictor': yolo.detect.DetectionPredictor, },
+            'segment': {
+                'model': SegmentationModel,
+                'trainer': yolo.segment.SegmentationTrainer,
+                'validator': yolo.segment.SegmentationValidator,
+                'predictor': yolo.segment.SegmentationPredictor, },
+            'pose': {
+                'model': PoseModel,
+                'trainer': yolo.pose.PoseTrainer,
+                'validator': yolo.pose.PoseValidator,
+                'predictor': yolo.pose.PosePredictor, }, }

ultralytics/models/yolo/segment/train.py

@@ -1,4 +1,5 @@
 # Ultralytics YOLO 🚀, AGPL-3.0 license
+
 from copy import copy
 
 from ultralytics.models import yolo

ultralytics/nn/autobackend.py

@@ -400,21 +400,21 @@ class AutoBackend(nn.Module):
                     nc = y[ib].shape[1] - y[ip].shape[3] - 4  # y = (1, 160, 160, 32), (1, 116, 8400)
                     self.names = {i: f'class{i}' for i in range(nc)}
             else:  # Lite or Edge TPU
-                input = self.input_details[0]
-                int8 = input['dtype'] == np.int8  # is TFLite quantized int8 model
-                if int8:
-                    scale, zero_point = input['quantization']
-                    im = (im / scale + zero_point).astype(np.int8)  # de-scale
-                self.interpreter.set_tensor(input['index'], im)
+                details = self.input_details[0]
+                integer = details['dtype'] in (np.int8, np.int16)  # is TFLite quantized int8 or int16 model
+                if integer:
+                    scale, zero_point = details['quantization']
+                    im = (im / scale + zero_point).astype(details['dtype'])  # de-scale
+                self.interpreter.set_tensor(details['index'], im)
                 self.interpreter.invoke()
                 y = []
                 for output in self.output_details:
                     x = self.interpreter.get_tensor(output['index'])
-                    if int8:
+                    if integer:
                         scale, zero_point = output['quantization']
                         x = (x.astype(np.float32) - zero_point) * scale  # re-scale
                     if x.ndim > 2:  # if task is not classification
-                        # Unnormalize xywh with input image size
+                        # Denormalize xywh with input image size
                         # xywh are normalized in TFLite/EdgeTPU to mitigate quantization error of integer models
                         # See this PR for details: https://github.com/ultralytics/ultralytics/pull/1695
                         x[:, 0] *= w

ultralytics/utils/callbacks/hub.py

@@ -3,7 +3,7 @@
 import json
 from time import time
 
-from ultralytics.hub.utils import PREFIX, events
+from ultralytics.hub.utils import HUB_WEB_ROOT, PREFIX, events
 from ultralytics.utils import LOGGER, SETTINGS
 from ultralytics.utils.torch_utils import model_info_for_loggers
 
@@ -13,7 +13,7 @@ def on_pretrain_routine_end(trainer):
     session = getattr(trainer, 'hub_session', None)
     if session:
         # Start timer for upload rate limit
-        LOGGER.info(f'{PREFIX}View model at https://hub.ultralytics.com/models/{session.model_id} 🚀')
+        LOGGER.info(f'{PREFIX}View model at {HUB_WEB_ROOT}/models/{session.model_id} 🚀')
         session.timers = {'metrics': time(), 'ckpt': time()}  # start timer on session.rate_limit
 
 
@@ -39,7 +39,7 @@ def on_model_save(trainer):
         # Upload checkpoints with rate limiting
         is_best = trainer.best_fitness == trainer.fitness
         if time() - session.timers['ckpt'] > session.rate_limits['ckpt']:
-            LOGGER.info(f'{PREFIX}Uploading checkpoint https://hub.ultralytics.com/models/{session.model_id}')
+            LOGGER.info(f'{PREFIX}Uploading checkpoint {HUB_WEB_ROOT}/models/{session.model_id}')
             session.upload_model(trainer.epoch, trainer.last, is_best)
             session.timers['ckpt'] = time()  # reset timer
 
@@ -53,7 +53,7 @@ def on_train_end(trainer):
         session.upload_model(trainer.epoch, trainer.best, map=trainer.metrics.get('metrics/mAP50-95(B)', 0), final=True)
         session.alive = False  # stop heartbeats
         LOGGER.info(f'{PREFIX}Done ✅\n'
-                    f'{PREFIX}View model at https://hub.ultralytics.com/models/{session.model_id} 🚀')
+                    f'{PREFIX}View model at {HUB_WEB_ROOT}/models/{session.model_id} 🚀')
 
 
 def on_train_start(trainer):

ultralytics/utils/ops.py

@@ -321,7 +321,7 @@ def scale_image(masks, im0_shape, ratio_pad=None):
     Takes a mask, and resizes it to the original image size
 
     Args:
-      masks (torch.Tensor): resized and padded masks/images, [h, w, num]/[h, w, 3].
+      masks (np.ndarray): resized and padded masks/images, [h, w, num]/[h, w, 3].
       im0_shape (tuple): the original image shape
       ratio_pad (tuple): the ratio of the padding to the original image.
 
@@ -344,9 +344,6 @@ def scale_image(masks, im0_shape, ratio_pad=None):
     if len(masks.shape) < 2:
         raise ValueError(f'"len of masks shape" should be 2 or 3, but got {len(masks.shape)}')
     masks = masks[top:bottom, left:right]
-    # masks = masks.permute(2, 0, 1).contiguous()
-    # masks = F.interpolate(masks[None], im0_shape[:2], mode='bilinear', align_corners=False)[0]
-    # masks = masks.permute(1, 2, 0).contiguous()
     masks = cv2.resize(masks, (im0_shape[1], im0_shape[0]))
     if len(masks.shape) == 2:
         masks = masks[:, :, None]

{ultralytics-8.0.142.dist-info → ultralytics-8.0.144.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ultralytics
-Version: 8.0.142
+Version: 8.0.144
 Summary: Ultralytics YOLOv8 for SOTA object detection, multi-object tracking, instance segmentation, pose estimation and image classification.
 Home-page: https://github.com/ultralytics/ultralytics
 Author: Ultralytics