ultralytics 8.0.66__py3-none-any.whl → 8.0.68__py3-none-any.whl

ultralytics/__init__.py

@@ -1,6 +1,6 @@
 # Ultralytics YOLO 🚀, GPL-3.0 license
 
-__version__ = '8.0.66'
+__version__ = '8.0.68'
 
 from ultralytics.hub import start
 from ultralytics.yolo.engine.model import YOLO

ultralytics/hub/__init__.py

@@ -3,7 +3,7 @@
 import requests
 
 from ultralytics.hub.utils import PREFIX, split_key
-from ultralytics.yolo.utils import LOGGER
+from ultralytics.yolo.utils import LOGGER, SETTINGS, USER_CONFIG_DIR, yaml_save
 
 
 def login(api_key=''):
@@ -15,7 +15,7 @@ def login(api_key=''):
 
     Example:
         from ultralytics import hub
-        hub.login('your_api_key')
+        hub.login('API_KEY')
     """
     from ultralytics.hub.auth import Auth
     Auth(api_key)
@@ -23,13 +23,15 @@ def login(api_key=''):
 
 def logout():
     """
-    Logout Ultralytics HUB
+    Log out of Ultralytics HUB by removing the API key from the settings file. To log in again, use 'yolo hub login'.
 
     Example:
         from ultralytics import hub
         hub.logout()
     """
-    LOGGER.warning('WARNING ⚠️ This method is not yet implemented.')
+    SETTINGS['api_key'] = ''
+    yaml_save(USER_CONFIG_DIR / 'settings.yaml', SETTINGS)
+    LOGGER.info(f"{PREFIX}logged out ✅. To log in again, use 'yolo hub login'.")
 
 
 def start(key=''):

ultralytics/hub/auth.py

@@ -11,7 +11,7 @@ API_KEY_URL = 'https://hub.ultralytics.com/settings?tab=api+keys'
 class Auth:
     id_token = api_key = model_key = False
 
-    def __init__(self, api_key=''):
+    def __init__(self, api_key='', verbose=True):
         """
         Initialize the Auth class with an optional API key.
 
@@ -29,7 +29,8 @@ class Auth:
             # If the provided API key matches the API key in the SETTINGS
             if self.api_key == SETTINGS.get('api_key'):
                 # Log that the user is already logged in
-                LOGGER.info(f'{PREFIX}Authenticated ✅')
+                if verbose:
+                    LOGGER.info(f'{PREFIX}Authenticated ✅')
                 return
             else:
                 # Attempt to authenticate with the provided API key
@@ -46,8 +47,9 @@ class Auth:
         if success:
             set_settings({'api_key': self.api_key})
             # Log that the new login was successful
-            LOGGER.info(f'{PREFIX}New authentication successful ✅')
-        else:
+            if verbose:
+                LOGGER.info(f'{PREFIX}New authentication successful ✅')
+        elif verbose:
             LOGGER.info(f'{PREFIX}Retrieve API key from {API_KEY_URL}')
 
     def request_api_key(self, max_attempts=3):

ultralytics/hub/session.py

@@ -58,7 +58,7 @@ class HUBTrainingSession:
             raise ValueError(f'Invalid HUBTrainingSession input: {url}')
 
         # Authorize
-        auth = Auth(key)
+        auth = Auth(key, verbose=False)
         self.agent_id = None  # identifies which instance is communicating with server
         self.model_id = model_id
         self.model_url = f'https://hub.ultralytics.com/models/{model_id}'

ultralytics/yolo/data/utils.py

@@ -17,7 +17,7 @@ from PIL import ExifTags, Image, ImageOps
 from tqdm import tqdm
 
 from ultralytics.nn.autobackend import check_class_names
-from ultralytics.yolo.utils import DATASETS_DIR, LOGGER, NUM_THREADS, ROOT, colorstr, emojis, yaml_load
+from ultralytics.yolo.utils import DATASETS_DIR, LOGGER, NUM_THREADS, ROOT, clean_url, colorstr, emojis, yaml_load
 from ultralytics.yolo.utils.checks import check_file, check_font, is_ascii
 from ultralytics.yolo.utils.downloads import download, safe_download, unzip_file
 from ultralytics.yolo.utils.ops import segments2boxes
@@ -241,7 +241,7 @@ def check_det_dataset(dataset, autodownload=True):
     if val:
         val = [Path(x).resolve() for x in (val if isinstance(val, list) else [val])]  # val path
         if not all(x.exists() for x in val):
-            name = str(dataset).split('?')[0]  # dataset name with URL auth stripped
+            name = clean_url(dataset)  # dataset name with URL auth stripped
             m = f"\nDataset '{name}' images not found ⚠️, missing paths %s" % [str(x) for x in val if not x.exists()]
             if s and autodownload:
                 LOGGER.warning(m)

ultralytics/yolo/engine/exporter.py

@@ -53,7 +53,6 @@ import platform
 import subprocess
 import time
 import warnings
-from collections import defaultdict
 from copy import deepcopy
 from pathlib import Path
 
@@ -130,7 +129,7 @@ class Exporter:
         save_dir (Path): Directory to save results.
     """
 
-    def __init__(self, cfg=DEFAULT_CFG, overrides=None):
+    def __init__(self, cfg=DEFAULT_CFG, overrides=None, _callbacks=None):
         """
         Initializes the Exporter class.
 
@@ -139,7 +138,7 @@ class Exporter:
             overrides (dict, optional): Configuration overrides. Defaults to None.
         """
         self.args = get_cfg(cfg, overrides)
-        self.callbacks = defaultdict(list, callbacks.default_callbacks)  # add callbacks
+        self.callbacks = _callbacks if _callbacks else callbacks.get_default_callbacks()
         callbacks.add_integration_callbacks(self)
 
     @smart_inference_mode()
@@ -854,6 +853,12 @@ class Exporter:
         LOGGER.info(f'{prefix} pipeline success')
         return model
 
+    def add_callback(self, event: str, callback):
+        """
+        Appends the given callback.
+        """
+        self.callbacks[event].append(callback)
+
     def run_callbacks(self, event: str):
         for callback in self.callbacks.get(event, []):
             callback(self)

ultralytics/yolo/engine/model.py

@@ -78,7 +78,7 @@ class YOLO:
             task (Any, optional): Task type for the YOLO model. Defaults to None.
 
         """
-        self._reset_callbacks()
+        self.callbacks = callbacks.get_default_callbacks()
         self.predictor = None  # reuse predictor
         self.model = None  # model object
         self.trainer = None  # trainer object
@@ -238,7 +238,7 @@ class YOLO:
         overrides['save'] = kwargs.get('save', False)  # not save files by default
         if not self.predictor:
             self.task = overrides.get('task') or self.task
-            self.predictor = TASK_MAP[self.task][3](overrides=overrides)
+            self.predictor = TASK_MAP[self.task][3](overrides=overrides, _callbacks=self.callbacks)
             self.predictor.setup_model(model=self.model, verbose=is_cli)
         else:  # only update args if predictor is already setup
             self.predictor.args = get_cfg(self.predictor.args, overrides)
@@ -277,7 +277,7 @@ class YOLO:
             args.imgsz = self.model.args['imgsz']  # use trained imgsz unless custom value is passed
         args.imgsz = check_imgsz(args.imgsz, max_dim=1)
 
-        validator = TASK_MAP[self.task][2](args=args)
+        validator = TASK_MAP[self.task][2](args=args, _callbacks=self.callbacks)
         validator(model=self.model)
         self.metrics = validator.metrics
 
@@ -316,7 +316,7 @@ class YOLO:
             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)
+        return Exporter(overrides=args, _callbacks=self.callbacks)(model=self.model)
 
     def train(self, **kwargs):
         """
@@ -344,7 +344,7 @@ class YOLO:
             overrides['resume'] = self.ckpt_path
 
         self.task = overrides.get('task') or self.task
-        self.trainer = TASK_MAP[self.task][1](overrides=overrides)
+        self.trainer = TASK_MAP[self.task][1](overrides=overrides, _callbacks=self.callbacks)
         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
@@ -387,19 +387,17 @@ class YOLO:
         """
         return self.model.transforms if hasattr(self.model, 'transforms') else None
 
-    @staticmethod
-    def add_callback(event: str, func):
+    def add_callback(self, event: str, func):
         """
         Add callback
         """
-        callbacks.default_callbacks[event].append(func)
+        self.callbacks[event].append(func)
 
     @staticmethod
     def _reset_ckpt_args(args):
         include = {'imgsz', 'data', 'task', 'single_cls'}  # only remember these arguments when loading a PyTorch model
         return {k: v for k, v in args.items() if k in include}
 
-    @staticmethod
-    def _reset_callbacks():
+    def _reset_callbacks(self):
         for event in callbacks.default_callbacks.keys():
-            callbacks.default_callbacks[event] = [callbacks.default_callbacks[event][0]]
+            self.callbacks[event] = [callbacks.default_callbacks[event][0]]

ultralytics/yolo/engine/predictor.py

@@ -28,7 +28,6 @@ Usage - formats:
                               yolov8n_paddle_model       # PaddlePaddle
 """
 import platform
-from collections import defaultdict
 from pathlib import Path
 
 import cv2
@@ -75,7 +74,7 @@ class BasePredictor:
         data_path (str): Path to data.
     """
 
-    def __init__(self, cfg=DEFAULT_CFG, overrides=None):
+    def __init__(self, cfg=DEFAULT_CFG, overrides=None, _callbacks=None):
         """
         Initializes the BasePredictor class.
 
@@ -104,7 +103,7 @@ class BasePredictor:
         self.data_path = None
         self.source_type = None
         self.batch = None
-        self.callbacks = defaultdict(list, callbacks.default_callbacks)  # add callbacks
+        self.callbacks = _callbacks if _callbacks else callbacks.get_default_callbacks()
         callbacks.add_integration_callbacks(self)
 
     def preprocess(self, img):
@@ -283,3 +282,9 @@ class BasePredictor:
     def run_callbacks(self, event: str):
         for callback in self.callbacks.get(event, []):
             callback(self)
+
+    def add_callback(self, event: str, func):
+        """
+        Add callback
+        """
+        self.callbacks[event].append(func)

ultralytics/yolo/engine/trainer.py

@@ -8,7 +8,6 @@ Usage:
 import os
 import subprocess
 import time
-from collections import defaultdict
 from copy import deepcopy
 from datetime import datetime
 from pathlib import Path
@@ -26,7 +25,7 @@ from ultralytics.nn.tasks import attempt_load_one_weight, attempt_load_weights
 from ultralytics.yolo.cfg import get_cfg
 from ultralytics.yolo.data.utils import check_cls_dataset, check_det_dataset
 from ultralytics.yolo.utils import (DEFAULT_CFG, LOGGER, ONLINE, RANK, ROOT, SETTINGS, TQDM_BAR_FORMAT, __version__,
-                                    callbacks, colorstr, emojis, yaml_save)
+                                    callbacks, clean_url, colorstr, emojis, yaml_save)
 from ultralytics.yolo.utils.autobatch import check_train_batch_size
 from ultralytics.yolo.utils.checks import check_file, check_imgsz, print_args
 from ultralytics.yolo.utils.dist import ddp_cleanup, generate_ddp_command
@@ -72,7 +71,7 @@ class BaseTrainer:
         csv (Path): Path to results CSV file.
     """
 
-    def __init__(self, cfg=DEFAULT_CFG, overrides=None):
+    def __init__(self, cfg=DEFAULT_CFG, overrides=None, _callbacks=None):
         """
         Initializes the BaseTrainer class.
 
@@ -124,7 +123,7 @@ class BaseTrainer:
                 if 'yaml_file' in self.data:
                     self.args.data = self.data['yaml_file']  # for validating 'yolo train data=url.zip' usage
         except Exception as e:
-            raise RuntimeError(emojis(f"Dataset '{self.args.data}' error ❌ {e}")) from e
+            raise RuntimeError(emojis(f"Dataset '{clean_url(self.args.data)}' error ❌ {e}")) from e
 
         self.trainset, self.testset = self.get_dataset(self.data)
         self.ema = None
@@ -143,7 +142,7 @@ class BaseTrainer:
         self.plot_idx = [0, 1, 2]
 
         # Callbacks
-        self.callbacks = defaultdict(list, callbacks.default_callbacks)  # add callbacks
+        self.callbacks = _callbacks if _callbacks else callbacks.get_default_callbacks()
         if RANK in (-1, 0):
             callbacks.add_integration_callbacks(self)
 

ultralytics/yolo/engine/validator.py

@@ -19,7 +19,6 @@ Usage - formats:
                           yolov8n_paddle_model       # PaddlePaddle
 """
 import json
-from collections import defaultdict
 from pathlib import Path
 
 import torch
@@ -55,7 +54,7 @@ class BaseValidator:
         save_dir (Path): Directory to save results.
     """
 
-    def __init__(self, dataloader=None, save_dir=None, pbar=None, args=None):
+    def __init__(self, dataloader=None, save_dir=None, pbar=None, args=None, _callbacks=None):
         """
         Initializes a BaseValidator instance.
 
@@ -85,7 +84,7 @@ class BaseValidator:
         if self.args.conf is None:
             self.args.conf = 0.001  # default conf=0.001
 
-        self.callbacks = defaultdict(list, callbacks.default_callbacks)  # add callbacks
+        self.callbacks = _callbacks if _callbacks else callbacks.get_default_callbacks()
 
     @smart_inference_mode()
     def __call__(self, trainer=None, model=None):
@@ -195,6 +194,12 @@ class BaseValidator:
                 LOGGER.info(f"Results saved to {colorstr('bold', self.save_dir)}")
             return stats
 
+    def add_callback(self, event: str, callback):
+        """
+        Appends the given callback.
+        """
+        self.callbacks[event].append(callback)
+
     def run_callbacks(self, event: str):
         for callback in self.callbacks.get(event, []):
             callback(self)

ultralytics/yolo/utils/__init__.py

@@ -10,6 +10,7 @@ import subprocess
 import sys
 import tempfile
 import threading
+import urllib
 import uuid
 from pathlib import Path
 from types import SimpleNamespace
@@ -165,7 +166,7 @@ class IterableSimpleNamespace(SimpleNamespace):
 def set_logging(name=LOGGING_NAME, verbose=True):
     # sets up logging for the given name
     rank = int(os.getenv('RANK', -1))  # rank in world for Multi-GPU trainings
-    level = logging.INFO if verbose and rank in (-1, 0) else logging.ERROR
+    level = logging.INFO if verbose and rank in {-1, 0} else logging.ERROR
     logging.config.dictConfig({
         'version': 1,
         'disable_existing_loggers': False,
@@ -649,10 +650,20 @@ def set_settings(kwargs, file=USER_CONFIG_DIR / 'settings.yaml'):
 
 def deprecation_warn(arg, new_arg, version=None):
     if not version:
-        version = float(__version__[0:3]) + 0.2  # deprecate after 2nd major release
-    LOGGER.warning(
-        f'WARNING: `{arg}` is deprecated and will be removed in upcoming major release {version}. Use `{new_arg}` instead'
-    )
+        version = float(__version__[:3]) + 0.2  # deprecate after 2nd major release
+    LOGGER.warning(f"WARNING ⚠️ '{arg}' is deprecated and will be removed in 'ultralytics {version}' in the future. "
+                   f"Please use '{new_arg}' instead.")
+
+
+def clean_url(url):
+    # Strip auth from URL, i.e. https://url.com/file.txt?auth -> https://url.com/file.txt
+    url = str(Path(url)).replace(':/', '://')  # Pathlib turns :// -> :/
+    return urllib.parse.unquote(url).split('?')[0]  # '%2F' to '/', split https://url.com/file.txt?auth
+
+
+def url2file(url):
+    # Convert URL to filename, i.e. https://url.com/file.txt?auth -> file.txt
+    return Path(clean_url(url)).name
 
 
 # Run below code on yolo/utils init ------------------------------------------------------------------------------------

ultralytics/yolo/utils/callbacks/__init__.py

@@ -1,3 +1,3 @@
-from .base import add_integration_callbacks, default_callbacks
+from .base import add_integration_callbacks, default_callbacks, get_default_callbacks
 
-__all__ = 'add_integration_callbacks', 'default_callbacks'
+__all__ = 'add_integration_callbacks', 'default_callbacks', 'get_default_callbacks'

ultralytics/yolo/utils/callbacks/base.py

@@ -2,6 +2,8 @@
 """
 Base callbacks
 """
+from collections import defaultdict
+from copy import deepcopy
 
 
 # Trainer callbacks ----------------------------------------------------------------------------------------------------
@@ -143,6 +145,10 @@ default_callbacks = {
     'on_export_end': [on_export_end]}
 
 
+def get_default_callbacks():
+    return defaultdict(list, deepcopy(default_callbacks))
+
+
 def add_integration_callbacks(instance):
     from .clearml import callbacks as clearml_callbacks
     from .comet import callbacks as comet_callbacks

ultralytics/yolo/utils/callbacks/clearml.py

@@ -1,10 +1,17 @@
 # Ultralytics YOLO 🚀, GPL-3.0 license
+import re
+
+import matplotlib.image as mpimg
+import matplotlib.pyplot as plt
+
 from ultralytics.yolo.utils import LOGGER, TESTS_RUNNING
 from ultralytics.yolo.utils.torch_utils import get_flops, get_num_params
 
 try:
     import clearml
     from clearml import Task
+    from clearml.binding.frameworks.pytorch_bind import PatchPyTorchModelIO
+    from clearml.binding.matplotlib_bind import PatchedMatplotlib
 
     assert hasattr(clearml, '__version__')  # verify package is not directory
     assert not TESTS_RUNNING  # do not log pytest
@@ -12,21 +19,61 @@ except (ImportError, AssertionError):
     clearml = None
 
 
-def _log_images(imgs_dict, group='', step=0):
-    task = Task.current_task()
-    if task:
-        for k, v in imgs_dict.items():
-            task.get_logger().report_image(group, k, step, v)
+def _log_debug_samples(files, title='Debug Samples'):
+    """
+        Log files (images) as debug samples in the ClearML task.
+
+        arguments:
+        files (List(PosixPath)) a list of file paths in PosixPath format
+        title (str) A title that groups together images with the same values
+        """
+    for f in files:
+        if f.exists():
+            it = re.search(r'_batch(\d+)', f.name)
+            iteration = int(it.groups()[0]) if it else 0
+            Task.current_task().get_logger().report_image(title=title,
+                                                          series=f.name.replace(it.group(), ''),
+                                                          local_path=str(f),
+                                                          iteration=iteration)
+
+
+def _log_plot(title, plot_path):
+    """
+        Log image as plot in the plot section of ClearML
+
+        arguments:
+        title (str) Title of the plot
+        plot_path (PosixPath or str) Path to the saved image file
+        """
+    img = mpimg.imread(plot_path)
+    fig = plt.figure()
+    ax = fig.add_axes([0, 0, 1, 1], frameon=False, aspect='auto', xticks=[], yticks=[])  # no ticks
+    ax.imshow(img)
+
+    Task.current_task().get_logger().report_matplotlib_figure(title, '', figure=fig, report_interactive=False)
 
 
 def on_pretrain_routine_start(trainer):
+    # TODO: reuse existing task
     try:
-        task = Task.init(project_name=trainer.args.project or 'YOLOv8',
-                         task_name=trainer.args.name,
-                         tags=['YOLOv8'],
-                         output_uri=True,
-                         reuse_last_task_id=False,
-                         auto_connect_frameworks={'pytorch': False})
+        if Task.current_task():
+            task = Task.current_task()
+
+            # Make sure the automatic pytorch and matplotlib bindings are disabled!
+            # We are logging these plots and model files manually in the integration
+            PatchPyTorchModelIO.update_current_task(None)
+            PatchedMatplotlib.update_current_task(None)
+        else:
+            task = Task.init(project_name=trainer.args.project or 'YOLOv8',
+                             task_name=trainer.args.name,
+                             tags=['YOLOv8'],
+                             output_uri=True,
+                             reuse_last_task_id=False,
+                             auto_connect_frameworks={
+                                 'pytorch': False,
+                                 'matplotlib': False})
+            LOGGER.warning('ClearML Initialized a new task. If you want to run remotely, '
+                           'please add clearml-init and connect your arguments before initializing YOLO.')
         task.connect(vars(trainer.args), name='General')
     except Exception as e:
         LOGGER.warning(f'WARNING ⚠️ ClearML installed but not initialized correctly, not logging this run. {e}')
@@ -34,27 +81,47 @@ def on_pretrain_routine_start(trainer):
 
 def on_train_epoch_end(trainer):
     if trainer.epoch == 1:
-        _log_images({f.stem: str(f) for f in trainer.save_dir.glob('train_batch*.jpg')}, 'Mosaic', trainer.epoch)
+        _log_debug_samples(sorted(trainer.save_dir.glob('train_batch*.jpg')), 'Mosaic')
 
 
 def on_fit_epoch_end(trainer):
-    task = Task.current_task()
-    if task and trainer.epoch == 0:
+    # You should have access to the validation bboxes under jdict
+    Task.current_task().get_logger().report_scalar(title='Epoch Time',
+                                                   series='Epoch Time',
+                                                   value=trainer.epoch_time,
+                                                   iteration=trainer.epoch)
+    if trainer.epoch == 0:
         model_info = {
             'model/parameters': get_num_params(trainer.model),
             'model/GFLOPs': round(get_flops(trainer.model), 3),
             'model/speed(ms)': round(trainer.validator.speed['inference'], 3)}
-        task.connect(model_info, name='Model')
+        for k, v in model_info.items():
+            Task.current_task().get_logger().report_single_value(k, v)
+
+
+def on_val_end(validator):
+    # Log val_labels and val_pred
+    _log_debug_samples(sorted(validator.save_dir.glob('val*.jpg')), 'Validation')
 
 
 def on_train_end(trainer):
-    task = Task.current_task()
-    if task:
-        task.update_output_model(model_path=str(trainer.best), model_name=trainer.args.name, auto_delete_file=False)
+    # Log final results, CM matrix + PR plots
+    files = ['results.png', 'confusion_matrix.png', *(f'{x}_curve.png' for x in ('F1', 'PR', 'P', 'R'))]
+    files = [(trainer.save_dir / f) for f in files if (trainer.save_dir / f).exists()]  # filter
+    for f in files:
+        _log_plot(title=f.stem, plot_path=f)
+    # Report final metrics
+    for k, v in trainer.validator.metrics.results_dict.items():
+        Task.current_task().get_logger().report_single_value(k, v)
+    # Log the final model
+    Task.current_task().update_output_model(model_path=str(trainer.best),
+                                            model_name=trainer.args.name,
+                                            auto_delete_file=False)
 
 
 callbacks = {
     'on_pretrain_routine_start': on_pretrain_routine_start,
     'on_train_epoch_end': on_train_epoch_end,
     'on_fit_epoch_end': on_fit_epoch_end,
+    'on_val_end': on_val_end,
     'on_train_end': on_train_end} if clearml else {}