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

ultralytics/yolo/utils/callbacks/comet.py

@@ -1,5 +1,8 @@
 # Ultralytics YOLO 🚀, GPL-3.0 license
-from ultralytics.yolo.utils import LOGGER, TESTS_RUNNING
+import os
+from pathlib import Path
+
+from ultralytics.yolo.utils import LOGGER, RANK, TESTS_RUNNING, ops
 from ultralytics.yolo.utils.torch_utils import get_flops, get_num_params
 
 try:
@@ -10,41 +13,308 @@ try:
 except (ImportError, AssertionError):
     comet_ml = None
 
+COMET_MODE = os.getenv('COMET_MODE', 'online')
+COMET_MODEL_NAME = os.getenv('COMET_MODEL_NAME', 'YOLOv8')
+# determines how many batches of image predictions to log from the validation set
+COMET_EVAL_BATCH_LOGGING_INTERVAL = int(os.getenv('COMET_EVAL_BATCH_LOGGING_INTERVAL', 1))
+# determines whether to log confusion matrix every evaluation epoch
+COMET_EVAL_LOG_CONFUSION_MATRIX = (os.getenv('COMET_EVAL_LOG_CONFUSION_MATRIX', 'true').lower() == 'true')
+# determines whether to log image predictions every evaluation epoch
+COMET_EVAL_LOG_IMAGE_PREDICTIONS = (os.getenv('COMET_EVAL_LOG_IMAGE_PREDICTIONS', 'true').lower() == 'true')
+COMET_MAX_IMAGE_PREDICTIONS = int(os.getenv('COMET_MAX_IMAGE_PREDICTIONS', 100))
 
-def on_pretrain_routine_start(trainer):
+# ensures certain logging functions only run for supported tasks
+COMET_SUPPORTED_TASKS = ['detect']
+# scales reported confidence scores (0.0-1.0) by this value
+COMET_MAX_CONFIDENCE_SCORE = int(os.getenv('COMET_MAX_CONFIDENCE_SCORE', 100))
+
+# names of plots created by YOLOv8 that are logged to Comet
+EVALUATION_PLOT_NAMES = 'F1_curve', 'P_curve', 'R_curve', 'PR_curve', 'confusion_matrix'
+LABEL_PLOT_NAMES = 'labels', 'labels_correlogram'
+
+_comet_image_prediction_count = 0
+
+
+def _get_experiment_type(mode, project_name):
+    if mode == 'offline':
+        return comet_ml.OfflineExperiment(project_name=project_name)
+
+    return comet_ml.Experiment(project_name=project_name)
+
+
+def _create_experiment(args):
+    # Ensures that the experiment object is only created in a single process during distributed training.
+    if RANK not in (-1, 0):
+        return
     try:
-        experiment = comet_ml.Experiment(project_name=trainer.args.project or 'YOLOv8')
-        experiment.set_name(trainer.args.name)
-        experiment.log_parameters(vars(trainer.args))
+        experiment = _get_experiment_type(COMET_MODE, args.project)
+        experiment.log_parameters(vars(args))
+        experiment.log_others({
+            'eval_batch_logging_interval': COMET_EVAL_BATCH_LOGGING_INTERVAL,
+            'log_confusion_matrix': COMET_EVAL_LOG_CONFUSION_MATRIX,
+            'log_image_predictions': COMET_EVAL_LOG_IMAGE_PREDICTIONS,
+            'max_image_predictions': COMET_MAX_IMAGE_PREDICTIONS, })
+        experiment.log_other('Created from', 'yolov8')
+
     except Exception as e:
         LOGGER.warning(f'WARNING ⚠️ Comet installed but not initialized correctly, not logging this run. {e}')
 
 
+def _fetch_trainer_metadata(trainer):
+    curr_epoch = trainer.epoch + 1
+
+    train_num_steps_per_epoch = len(trainer.train_loader.dataset) // trainer.batch_size
+    curr_step = curr_epoch * train_num_steps_per_epoch
+    final_epoch = curr_epoch == trainer.epochs
+
+    save = trainer.args.save
+    save_period = trainer.args.save_period
+    save_interval = curr_epoch % save_period == 0
+    save_assets = save and save_period > 0 and save_interval and not final_epoch
+
+    return dict(curr_epoch=curr_epoch, curr_step=curr_step, save_assets=save_assets, final_epoch=final_epoch)
+
+
+def _scale_bounding_box_to_original_image_shape(box, resized_image_shape, original_image_shape, ratio_pad):
+    """YOLOv8 resizes images during training and the label values
+    are normalized based on this resized shape. This function rescales the
+    bounding box labels to the original image shape.
+    """
+
+    resized_image_height, resized_image_width = resized_image_shape
+
+    # convert normalized xywh format predictions to xyxy in resized scale format
+    box = ops.xywhn2xyxy(box, h=resized_image_height, w=resized_image_width)
+    # scale box predictions from resized image scale back to original image scale
+    box = ops.scale_boxes(resized_image_shape, box, original_image_shape, ratio_pad)
+    # Convert bounding box format from xyxy to xywh for Comet logging
+    box = ops.xyxy2xywh(box)
+    # adjust xy center to correspond top-left corner
+    box[:2] -= box[2:] / 2
+    box = box.tolist()
+
+    return box
+
+
+def _format_ground_truth_annotations_for_detection(img_idx, image_path, batch, class_name_map=None):
+    indices = batch['batch_idx'] == img_idx
+    bboxes = batch['bboxes'][indices]
+    if len(bboxes) == 0:
+        LOGGER.debug(f'COMET WARNING: Image: {image_path} has no bounding boxes labels')
+        return None
+
+    cls_labels = batch['cls'][indices].squeeze(1).tolist()
+    if class_name_map:
+        cls_labels = [str(class_name_map[label]) for label in cls_labels]
+
+    original_image_shape = batch['ori_shape'][img_idx]
+    resized_image_shape = batch['resized_shape'][img_idx]
+    ratio_pad = batch['ratio_pad'][img_idx]
+
+    data = []
+    for box, label in zip(bboxes, cls_labels):
+        box = _scale_bounding_box_to_original_image_shape(box, resized_image_shape, original_image_shape, ratio_pad)
+        data.append({'boxes': [box], 'label': f'gt_{label}', 'score': COMET_MAX_CONFIDENCE_SCORE})
+
+    return {'name': 'ground_truth', 'data': data}
+
+
+def _format_prediction_annotations_for_detection(image_path, metadata, class_label_map=None):
+    stem = image_path.stem
+    image_id = int(stem) if stem.isnumeric() else stem
+
+    predictions = metadata.get(image_id)
+    if not predictions:
+        LOGGER.debug(f'COMET WARNING: Image: {image_path} has no bounding boxes predictions')
+        return None
+
+    data = []
+    for prediction in predictions:
+        boxes = prediction['bbox']
+        score = prediction['score'] * COMET_MAX_CONFIDENCE_SCORE
+        cls_label = prediction['category_id']
+        if class_label_map:
+            cls_label = str(class_label_map[cls_label])
+
+        data.append({'boxes': [boxes], 'label': cls_label, 'score': score})
+
+    return {'name': 'prediction', 'data': data}
+
+
+def _fetch_annotations(img_idx, image_path, batch, prediction_metadata_map, class_label_map):
+    ground_truth_annotations = _format_ground_truth_annotations_for_detection(img_idx, image_path, batch,
+                                                                              class_label_map)
+    prediction_annotations = _format_prediction_annotations_for_detection(image_path, prediction_metadata_map,
+                                                                          class_label_map)
+
+    annotations = [
+        annotation for annotation in [ground_truth_annotations, prediction_annotations] if annotation is not None]
+    return [annotations] if annotations else None
+
+
+def _create_prediction_metadata_map(model_predictions):
+    pred_metadata_map = {}
+    for prediction in model_predictions:
+        pred_metadata_map.setdefault(prediction['image_id'], [])
+        pred_metadata_map[prediction['image_id']].append(prediction)
+
+    return pred_metadata_map
+
+
+def _log_confusion_matrix(experiment, trainer, curr_step, curr_epoch):
+    conf_mat = trainer.validator.confusion_matrix.matrix
+    names = list(trainer.data['names'].values()) + ['background']
+    experiment.log_confusion_matrix(
+        matrix=conf_mat,
+        labels=names,
+        max_categories=len(names),
+        epoch=curr_epoch,
+        step=curr_step,
+    )
+
+
+def _log_images(experiment, image_paths, curr_step, annotations=None):
+    if annotations:
+        for image_path, annotation in zip(image_paths, annotations):
+            experiment.log_image(image_path, name=image_path.stem, step=curr_step, annotations=annotation)
+
+    else:
+        for image_path in image_paths:
+            experiment.log_image(image_path, name=image_path.stem, step=curr_step)
+
+
+def _log_image_predictions(experiment, validator, curr_step):
+    global _comet_image_prediction_count
+
+    task = validator.args.task
+    if task not in COMET_SUPPORTED_TASKS:
+        return
+
+    jdict = validator.jdict
+    if not jdict:
+        return
+
+    predictions_metadata_map = _create_prediction_metadata_map(jdict)
+    dataloader = validator.dataloader
+    class_label_map = validator.names
+
+    for batch_idx, batch in enumerate(dataloader):
+        if (batch_idx + 1) % COMET_EVAL_BATCH_LOGGING_INTERVAL != 0:
+            continue
+
+        image_paths = batch['im_file']
+        for img_idx, image_path in enumerate(image_paths):
+            if _comet_image_prediction_count >= COMET_MAX_IMAGE_PREDICTIONS:
+                return
+
+            image_path = Path(image_path)
+            annotations = _fetch_annotations(
+                img_idx,
+                image_path,
+                batch,
+                predictions_metadata_map,
+                class_label_map,
+            )
+            _log_images(
+                experiment,
+                [image_path],
+                curr_step,
+                annotations=annotations,
+            )
+            _comet_image_prediction_count += 1
+
+
+def _log_plots(experiment, trainer):
+    plot_filenames = [trainer.save_dir / f'{plots}.png' for plots in EVALUATION_PLOT_NAMES]
+    _log_images(experiment, plot_filenames, None)
+
+    label_plot_filenames = [trainer.save_dir / f'{labels}.jpg' for labels in LABEL_PLOT_NAMES]
+    _log_images(experiment, label_plot_filenames, None)
+
+
+def _log_model(experiment, trainer):
+    experiment.log_model(
+        COMET_MODEL_NAME,
+        file_or_folder=str(trainer.best),
+        file_name='best.pt',
+        overwrite=True,
+    )
+
+
+def on_pretrain_routine_start(trainer):
+    experiment = comet_ml.get_global_experiment()
+    if not experiment:
+        _create_experiment(trainer.args)
+
+
 def on_train_epoch_end(trainer):
     experiment = comet_ml.get_global_experiment()
-    if experiment:
-        experiment.log_metrics(trainer.label_loss_items(trainer.tloss, prefix='train'), step=trainer.epoch + 1)
-        if trainer.epoch == 1:
-            for f in trainer.save_dir.glob('train_batch*.jpg'):
-                experiment.log_image(f, name=f.stem, step=trainer.epoch + 1)
+    if not experiment:
+        return
+
+    metadata = _fetch_trainer_metadata(trainer)
+    curr_epoch = metadata['curr_epoch']
+    curr_step = metadata['curr_step']
+
+    experiment.log_metrics(
+        trainer.label_loss_items(trainer.tloss, prefix='train'),
+        step=curr_step,
+        epoch=curr_epoch,
+    )
+
+    if curr_epoch == 1:
+        _log_images(experiment, trainer.save_dir.glob('train_batch*.jpg'), curr_step)
 
 
 def on_fit_epoch_end(trainer):
     experiment = comet_ml.get_global_experiment()
-    if experiment:
-        experiment.log_metrics(trainer.metrics, step=trainer.epoch + 1)
-        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)}
-            experiment.log_metrics(model_info, step=trainer.epoch + 1)
+    if not experiment:
+        return
+
+    metadata = _fetch_trainer_metadata(trainer)
+    curr_epoch = metadata['curr_epoch']
+    curr_step = metadata['curr_step']
+    save_assets = metadata['save_assets']
+
+    experiment.log_metrics(trainer.metrics, step=curr_step, epoch=curr_epoch)
+    experiment.log_metrics(trainer.lr, step=curr_step, epoch=curr_epoch)
+    if curr_epoch == 1:
+        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)}
+        experiment.log_metrics(model_info, step=curr_step, epoch=curr_epoch)
+
+    if not save_assets:
+        return
+
+    _log_model(experiment, trainer)
+    if COMET_EVAL_LOG_CONFUSION_MATRIX:
+        _log_confusion_matrix(experiment, trainer, curr_step, curr_epoch)
+    if COMET_EVAL_LOG_IMAGE_PREDICTIONS:
+        _log_image_predictions(experiment, trainer.validator, curr_step)
 
 
 def on_train_end(trainer):
     experiment = comet_ml.get_global_experiment()
-    if experiment:
-        experiment.log_model('YOLOv8', file_or_folder=str(trainer.best), file_name='best.pt', overwrite=True)
+    if not experiment:
+        return
+
+    metadata = _fetch_trainer_metadata(trainer)
+    curr_epoch = metadata['curr_epoch']
+    curr_step = metadata['curr_step']
+    plots = trainer.args.plots
+
+    _log_model(experiment, trainer)
+    if plots:
+        _log_plots(experiment, trainer)
+
+    _log_confusion_matrix(experiment, trainer, curr_step, curr_epoch)
+    _log_image_predictions(experiment, trainer.validator, curr_step)
+    experiment.end()
+
+    global _comet_image_prediction_count
+    _comet_image_prediction_count = 0
 
 
 callbacks = {

ultralytics/yolo/utils/checks.py

@@ -8,7 +8,6 @@ import platform
 import re
 import shutil
 import subprocess
-import urllib
 from pathlib import Path
 from typing import Optional
 
@@ -20,8 +19,9 @@ import requests
 import torch
 from matplotlib import font_manager
 
-from ultralytics.yolo.utils import (AUTOINSTALL, LOGGER, ONLINE, ROOT, USER_CONFIG_DIR, TryExcept, colorstr, downloads,
-                                    emojis, is_colab, is_docker, is_kaggle, is_online, is_pip_package)
+from ultralytics.yolo.utils import (AUTOINSTALL, LOGGER, ONLINE, ROOT, USER_CONFIG_DIR, TryExcept, clean_url, colorstr,
+                                    downloads, emojis, is_colab, is_docker, is_kaggle, is_online, is_pip_package,
+                                    url2file)
 
 
 def is_ascii(s) -> bool:
@@ -267,9 +267,9 @@ def check_file(file, suffix='', download=True, hard=True):
         return file
     elif download and file.lower().startswith(('https://', 'http://', 'rtsp://', 'rtmp://')):  # download
         url = file  # warning: Pathlib turns :// -> :/
-        file = Path(urllib.parse.unquote(file).split('?')[0]).name  # '%2F' to '/', split https://url.com/file.txt?auth
+        file = url2file(file)  # '%2F' to '/', split https://url.com/file.txt?auth
         if Path(file).exists():
-            LOGGER.info(f'Found {url} locally at {file}')  # file already exists
+            LOGGER.info(f'Found {clean_url(url)} locally at {file}')  # file already exists
         else:
             downloads.safe_download(url=url, file=file, unzip=False)
         return file

ultralytics/yolo/utils/downloads.py

@@ -12,7 +12,7 @@ import requests
 import torch
 from tqdm import tqdm
 
-from ultralytics.yolo.utils import LOGGER, checks, emojis, is_online
+from ultralytics.yolo.utils import LOGGER, checks, clean_url, emojis, is_online, url2file
 
 GITHUB_ASSET_NAMES = [f'yolov8{k}{suffix}.pt' for k in 'nsmlx' for suffix in ('', '6', '-cls', '-seg', '-pose')] + \
                      [f'yolov5{k}u.pt' for k in 'nsmlx'] + \
@@ -43,10 +43,18 @@ def unzip_file(file, path=None, exclude=('.DS_Store', '__MACOSX')):
     if path is None:
         path = Path(file).parent  # default path
     with ZipFile(file) as zipObj:
-        for f in zipObj.namelist():  # list all archived filenames in the zip
+        for i, f in enumerate(zipObj.namelist()):  # list all archived filenames in the zip
+            # If zip does not expand into a directory create a new directory to expand into
+            if i == 0:
+                info = zipObj.getinfo(f)
+                if info.file_size > 0 or not info.filename.endswith('/'):  # element is a file and not a directory
+                    path = Path(path) / Path(file).stem  # define new unzip directory
+                    unzip_dir = path
+                else:
+                    unzip_dir = f
             if all(x not in f for x in exclude):
                 zipObj.extract(f, path=path)
-        return zipObj.namelist()[0]  # return unzip dir
+        return unzip_dir  # return unzip dir
 
 
 def safe_download(url,
@@ -79,8 +87,8 @@ def safe_download(url,
         f = Path(url)  # filename
     else:  # does not exist
         assert dir or file, 'dir or file required for download'
-        f = dir / Path(url).name if dir else Path(file)
-        desc = f'Downloading {url} to {f}'
+        f = dir / url2file(url) if dir else Path(file)
+        desc = f'Downloading {clean_url(url)} to {f}'
         LOGGER.info(f'{desc}...')
         f.parent.mkdir(parents=True, exist_ok=True)  # make directory if missing
         for i in range(retry + 1):
@@ -118,10 +126,10 @@ def safe_download(url,
                     raise ConnectionError(emojis(f'❌  Download failure for {url}. Retry limit reached.')) from e
                 LOGGER.warning(f'⚠️ Download failure, retrying {i + 1}/{retry} {url}...')
 
-    if unzip and f.exists() and f.suffix in ('.zip', '.tar', '.gz'):
+    if unzip and f.exists() and f.suffix in ('', '.zip', '.tar', '.gz'):
         unzip_dir = dir or f.parent  # unzip to dir if provided else unzip in place
         LOGGER.info(f'Unzipping {f} to {unzip_dir}...')
-        if f.suffix == '.zip':
+        if is_zipfile(f):
             unzip_dir = unzip_file(file=f, path=unzip_dir)  # unzip
         elif f.suffix == '.tar':
             subprocess.run(['tar', 'xf', f, '--directory', unzip_dir], check=True)  # unzip
@@ -156,9 +164,9 @@ def attempt_download_asset(file, repo='ultralytics/assets', release='v0.0.0'):
         name = Path(parse.unquote(str(file))).name  # decode '%2F' to '/' etc.
         if str(file).startswith(('http:/', 'https:/')):  # download
             url = str(file).replace(':/', '://')  # Pathlib turns :// -> :/
-            file = name.split('?')[0]  # parse authentication https://url.com/file.txt?auth...
+            file = url2file(name)  # parse authentication https://url.com/file.txt?auth...
             if Path(file).is_file():
-                LOGGER.info(f'Found {url} locally at {file}')  # file already exists
+                LOGGER.info(f'Found {clean_url(url)} locally at {file}')  # file already exists
             else:
                 safe_download(url=url, file=file, min_bytes=1E5)
             return file

ultralytics/yolo/utils/files.py

@@ -3,7 +3,6 @@
 import contextlib
 import glob
 import os
-import urllib
 from datetime import datetime
 from pathlib import Path
 
@@ -80,12 +79,6 @@ def file_size(path):
     return 0.0
 
 
-def url2file(url):
-    # Convert URL to filename, i.e. https://url.com/file.txt?auth -> file.txt
-    url = str(Path(url)).replace(':/', '://')  # Pathlib turns :// -> :/
-    return Path(urllib.parse.unquote(url)).name.split('?')[0]  # '%2F' to '/', split https://url.com/file.txt?auth
-
-
 def get_latest_run(search_dir='.'):
     # Return path to most recent 'last.pt' in /runs (i.e. to --resume from)
     last_list = glob.glob(f'{search_dir}/**/last*.pt', recursive=True)

ultralytics/yolo/v8/classify/train.py

@@ -13,11 +13,11 @@ from ultralytics.yolo.utils.torch_utils import is_parallel, strip_optimizer
 
 class ClassificationTrainer(BaseTrainer):
 
-    def __init__(self, cfg=DEFAULT_CFG, overrides=None):
+    def __init__(self, cfg=DEFAULT_CFG, overrides=None, _callbacks=None):
         if overrides is None:
             overrides = {}
         overrides['task'] = 'classify'
-        super().__init__(cfg, overrides)
+        super().__init__(cfg, overrides, _callbacks)
 
     def set_model_attributes(self):
         self.model.names = self.data['names']

ultralytics/yolo/v8/classify/val.py

@@ -8,8 +8,8 @@ from ultralytics.yolo.utils.metrics import ClassifyMetrics
 
 class ClassificationValidator(BaseValidator):
 
-    def __init__(self, dataloader=None, save_dir=None, pbar=None, args=None):
-        super().__init__(dataloader, save_dir, pbar, args)
+    def __init__(self, dataloader=None, save_dir=None, pbar=None, args=None, _callbacks=None):
+        super().__init__(dataloader, save_dir, pbar, args, _callbacks)
         self.args.task = 'classify'
         self.metrics = ClassifyMetrics()
 

ultralytics/yolo/v8/detect/val.py

@@ -18,8 +18,8 @@ from ultralytics.yolo.utils.torch_utils import de_parallel
 
 class DetectionValidator(BaseValidator):
 
-    def __init__(self, dataloader=None, save_dir=None, pbar=None, args=None):
-        super().__init__(dataloader, save_dir, pbar, args)
+    def __init__(self, dataloader=None, save_dir=None, pbar=None, args=None, _callbacks=None):
+        super().__init__(dataloader, save_dir, pbar, args, _callbacks)
         self.args.task = 'detect'
         self.is_coco = False
         self.class_map = None

ultralytics/yolo/v8/pose/train.py

@@ -20,11 +20,11 @@ from ultralytics.yolo.v8.detect.train import Loss
 # BaseTrainer python usage
 class PoseTrainer(v8.detect.DetectionTrainer):
 
-    def __init__(self, cfg=DEFAULT_CFG, overrides=None):
+    def __init__(self, cfg=DEFAULT_CFG, overrides=None, _callbacks=None):
         if overrides is None:
             overrides = {}
         overrides['task'] = 'pose'
-        super().__init__(cfg, overrides)
+        super().__init__(cfg, overrides, _callbacks)
 
     def get_model(self, cfg=None, weights=None, verbose=True):
         model = PoseModel(cfg, ch=3, nc=self.data['nc'], data_kpt_shape=self.data['kpt_shape'], verbose=verbose)

ultralytics/yolo/v8/pose/val.py

@@ -14,8 +14,8 @@ from ultralytics.yolo.v8.detect import DetectionValidator
 
 class PoseValidator(DetectionValidator):
 
-    def __init__(self, dataloader=None, save_dir=None, pbar=None, args=None):
-        super().__init__(dataloader, save_dir, pbar, args)
+    def __init__(self, dataloader=None, save_dir=None, pbar=None, args=None, _callbacks=None):
+        super().__init__(dataloader, save_dir, pbar, args, _callbacks)
         self.args.task = 'pose'
         self.metrics = PoseMetrics(save_dir=self.save_dir)
 

ultralytics/yolo/v8/segment/train.py

@@ -17,11 +17,11 @@ from ultralytics.yolo.v8.detect.train import Loss
 # BaseTrainer python usage
 class SegmentationTrainer(v8.detect.DetectionTrainer):
 
-    def __init__(self, cfg=DEFAULT_CFG, overrides=None):
+    def __init__(self, cfg=DEFAULT_CFG, overrides=None, _callbacks=None):
         if overrides is None:
             overrides = {}
         overrides['task'] = 'segment'
-        super().__init__(cfg, overrides)
+        super().__init__(cfg, overrides, _callbacks)
 
     def get_model(self, cfg=None, weights=None, verbose=True):
         model = SegmentationModel(cfg, ch=3, nc=self.data['nc'], verbose=verbose and RANK == -1)

ultralytics/yolo/v8/segment/val.py

@@ -16,8 +16,8 @@ from ultralytics.yolo.v8.detect import DetectionValidator
 
 class SegmentationValidator(DetectionValidator):
 
-    def __init__(self, dataloader=None, save_dir=None, pbar=None, args=None):
-        super().__init__(dataloader, save_dir, pbar, args)
+    def __init__(self, dataloader=None, save_dir=None, pbar=None, args=None, _callbacks=None):
+        super().__init__(dataloader, save_dir, pbar, args, _callbacks)
         self.args.task = 'segment'
         self.metrics = SegmentMetrics(save_dir=self.save_dir)
 

{ultralytics-8.0.66.dist-info → ultralytics-8.0.68.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ultralytics
-Version: 8.0.66
+Version: 8.0.68
 Summary: Ultralytics YOLOv8
 Home-page: https://github.com/ultralytics/ultralytics
 Author: Ultralytics
@@ -250,12 +250,12 @@ See [Pose Docs](https://docs.ultralytics.com/tasks/) for usage examples with the
 
 | Model                                                                                                | size<br><sup>(pixels) | mAP<sup>box<br>50-95 | mAP<sup>pose<br>50-95 | Speed<br><sup>CPU ONNX<br>(ms) | Speed<br><sup>A100 TensorRT<br>(ms) | params<br><sup>(M) | FLOPs<br><sup>(B) |
 | ---------------------------------------------------------------------------------------------------- | --------------------- | -------------------- | --------------------- | ------------------------------ | ----------------------------------- | ------------------ | ----------------- |
-| [YOLOv8n-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n-pose.pt)       | 640                   | -                    | 49.7                  | -                              | -                                   | 3.3                | 9.2               |
-| [YOLOv8s-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s-pose.pt)       | 640                   | -                    | 59.2                  | -                              | -                                   | 11.6               | 30.2              |
-| [YOLOv8m-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m-pose.pt)       | 640                   | -                    | 63.6                  | -                              | -                                   | 26.4               | 81.0              |
-| [YOLOv8l-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l-pose.pt)       | 640                   | -                    | 67.0                  | -                              | -                                   | 44.4               | 168.6             |
-| [YOLOv8x-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-pose.pt)       | 640                   | -                    | 68.9                  | -                              | -                                   | 69.4               | 263.2             |
-| [YOLOv8x-pose-p6](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-pose-p6.pt) | 1280                  | -                    | 71.5                  | -                              | -                                   | 99.1               | 1066.4            |
+| [YOLOv8n-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n-pose.pt)       | 640                   | -                    | 49.7                  | 131.8                          | 1.18                                | 3.3                | 9.2               |
+| [YOLOv8s-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s-pose.pt)       | 640                   | -                    | 59.2                  | 233.2                          | 1.42                                | 11.6               | 30.2              |
+| [YOLOv8m-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m-pose.pt)       | 640                   | -                    | 63.6                  | 456.3                          | 2.00                                | 26.4               | 81.0              |
+| [YOLOv8l-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l-pose.pt)       | 640                   | -                    | 67.0                  | 784.5                          | 2.59                                | 44.4               | 168.6             |
+| [YOLOv8x-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-pose.pt)       | 640                   | -                    | 68.9                  | 1607.1                         | 3.73                                | 69.4               | 263.2             |
+| [YOLOv8x-pose-p6](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-pose-p6.pt) | 1280                  | -                    | 71.5                  | 4088.7                         | 10.04                               | 99.1               | 1066.4            |
 
 - **mAP<sup>val</sup>** values are for single-model single-scale on [COCO Keypoints val2017](http://cocodataset.org)
   dataset.
@@ -281,16 +281,16 @@ See [Pose Docs](https://docs.ultralytics.com/tasks/) for usage examples with the
   <a href="https://cutt.ly/yolov5-readme-clearml">
     <img src="https://github.com/ultralytics/assets/raw/main/partners/logo-clearml.png" width="10%" /></a>
   <img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="15%" height="0" alt="" />
-  <a href="https://bit.ly/yolov5-readme-comet2">
+  <a href="https://bit.ly/yolov8-readme-comet">
     <img src="https://github.com/ultralytics/assets/raw/main/partners/logo-comet.png" width="10%" /></a>
   <img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="15%" height="0" alt="" />
   <a href="https://bit.ly/yolov5-neuralmagic">
     <img src="https://github.com/ultralytics/assets/raw/main/partners/logo-neuralmagic.png" width="10%" /></a>
 </div>
 
-|                                                           Roboflow                                                           |                                                            ClearML ⭐ NEW                                                            |                                                                        Comet ⭐ NEW                                                                         |                                           Neural Magic ⭐ NEW                                           |
-| :--------------------------------------------------------------------------------------------------------------------------: | :---------------------------------------------------------------------------------------------------------------------------------: | :--------------------------------------------------------------------------------------------------------------------------------------------------------: | :----------------------------------------------------------------------------------------------------: |
-| Label and export your custom datasets directly to YOLOv8 for training with [Roboflow](https://roboflow.com/?ref=ultralytics) | Automatically track, visualize and even remotely train YOLOv8 using [ClearML](https://cutt.ly/yolov5-readme-clearml) (open-source!) | Free forever, [Comet](https://bit.ly/yolov5-readme-comet2) lets you save YOLOv8 models, resume training, and interactively visualize and debug predictions | Run YOLOv8 inference up to 6x faster with [Neural Magic DeepSparse](https://bit.ly/yolov5-neuralmagic) |
+|                                                           Roboflow                                                           |                                                            ClearML ⭐ NEW                                                            |                                                                        Comet ⭐ NEW                                                                        |                                           Neural Magic ⭐ NEW                                           |
+| :--------------------------------------------------------------------------------------------------------------------------: | :---------------------------------------------------------------------------------------------------------------------------------: | :-------------------------------------------------------------------------------------------------------------------------------------------------------: | :----------------------------------------------------------------------------------------------------: |
+| Label and export your custom datasets directly to YOLOv8 for training with [Roboflow](https://roboflow.com/?ref=ultralytics) | Automatically track, visualize and even remotely train YOLOv8 using [ClearML](https://cutt.ly/yolov5-readme-clearml) (open-source!) | Free forever, [Comet](https://bit.ly/yolov8-readme-comet) lets you save YOLOv8 models, resume training, and interactively visualize and debug predictions | Run YOLOv8 inference up to 6x faster with [Neural Magic DeepSparse](https://bit.ly/yolov5-neuralmagic) |
 
 ## <div align="center">Ultralytics HUB</div>