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

ultralytics/yolo/v8/pose/train.py

@@ -0,0 +1,170 @@
+# Ultralytics YOLO 🚀, GPL-3.0 license
+
+from copy import copy
+
+import torch
+import torch.nn as nn
+
+from ultralytics.nn.tasks import PoseModel
+from ultralytics.yolo import v8
+from ultralytics.yolo.utils import DEFAULT_CFG
+from ultralytics.yolo.utils.loss import KeypointLoss
+from ultralytics.yolo.utils.metrics import OKS_SIGMA
+from ultralytics.yolo.utils.ops import xyxy2xywh
+from ultralytics.yolo.utils.plotting import plot_images, plot_results
+from ultralytics.yolo.utils.tal import make_anchors
+from ultralytics.yolo.utils.torch_utils import de_parallel
+from ultralytics.yolo.v8.detect.train import Loss
+
+
+# BaseTrainer python usage
+class PoseTrainer(v8.detect.DetectionTrainer):
+
+    def __init__(self, cfg=DEFAULT_CFG, overrides=None):
+        if overrides is None:
+            overrides = {}
+        overrides['task'] = 'pose'
+        super().__init__(cfg, overrides)
+
+    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)
+        if weights:
+            model.load(weights)
+
+        return model
+
+    def set_model_attributes(self):
+        super().set_model_attributes()
+        self.model.kpt_shape = self.data['kpt_shape']
+
+    def get_validator(self):
+        self.loss_names = 'box_loss', 'pose_loss', 'kobj_loss', 'cls_loss', 'dfl_loss'
+        return v8.pose.PoseValidator(self.test_loader, save_dir=self.save_dir, args=copy(self.args))
+
+    def criterion(self, preds, batch):
+        if not hasattr(self, 'compute_loss'):
+            self.compute_loss = PoseLoss(de_parallel(self.model))
+        return self.compute_loss(preds, batch)
+
+    def plot_training_samples(self, batch, ni):
+        images = batch['img']
+        kpts = batch['keypoints']
+        cls = batch['cls'].squeeze(-1)
+        bboxes = batch['bboxes']
+        paths = batch['im_file']
+        batch_idx = batch['batch_idx']
+        plot_images(images,
+                    batch_idx,
+                    cls,
+                    bboxes,
+                    kpts=kpts,
+                    paths=paths,
+                    fname=self.save_dir / f'train_batch{ni}.jpg')
+
+    def plot_metrics(self):
+        plot_results(file=self.csv, pose=True)  # save results.png
+
+
+# Criterion class for computing training losses
+class PoseLoss(Loss):
+
+    def __init__(self, model):  # model must be de-paralleled
+        super().__init__(model)
+        self.kpt_shape = model.model[-1].kpt_shape
+        self.bce_pose = nn.BCEWithLogitsLoss()
+        is_pose = self.kpt_shape == [17, 3]
+        nkpt = self.kpt_shape[0]  # number of keypoints
+        sigmas = torch.from_numpy(OKS_SIGMA).to(self.device) if is_pose else torch.ones(nkpt, device=self.device) / nkpt
+        self.keypoint_loss = KeypointLoss(sigmas=sigmas)
+
+    def __call__(self, preds, batch):
+        loss = torch.zeros(5, device=self.device)  # box, cls, dfl, kpt_location, kpt_visibility
+        feats, pred_kpts = preds if isinstance(preds[0], list) else preds[1]
+        pred_distri, pred_scores = torch.cat([xi.view(feats[0].shape[0], self.no, -1) for xi in feats], 2).split(
+            (self.reg_max * 4, self.nc), 1)
+
+        # b, grids, ..
+        pred_scores = pred_scores.permute(0, 2, 1).contiguous()
+        pred_distri = pred_distri.permute(0, 2, 1).contiguous()
+        pred_kpts = pred_kpts.permute(0, 2, 1).contiguous()
+
+        dtype = pred_scores.dtype
+        imgsz = torch.tensor(feats[0].shape[2:], device=self.device, dtype=dtype) * self.stride[0]  # image size (h,w)
+        anchor_points, stride_tensor = make_anchors(feats, self.stride, 0.5)
+
+        # targets
+        batch_size = pred_scores.shape[0]
+        batch_idx = batch['batch_idx'].view(-1, 1)
+        targets = torch.cat((batch_idx, batch['cls'].view(-1, 1), batch['bboxes']), 1)
+        targets = self.preprocess(targets.to(self.device), batch_size, scale_tensor=imgsz[[1, 0, 1, 0]])
+        gt_labels, gt_bboxes = targets.split((1, 4), 2)  # cls, xyxy
+        mask_gt = gt_bboxes.sum(2, keepdim=True).gt_(0)
+
+        # pboxes
+        pred_bboxes = self.bbox_decode(anchor_points, pred_distri)  # xyxy, (b, h*w, 4)
+        pred_kpts = self.kpts_decode(anchor_points, pred_kpts.view(batch_size, -1, *self.kpt_shape))  # (b, h*w, 17, 3)
+
+        _, target_bboxes, target_scores, fg_mask, target_gt_idx = self.assigner(
+            pred_scores.detach().sigmoid(), (pred_bboxes.detach() * stride_tensor).type(gt_bboxes.dtype),
+            anchor_points * stride_tensor, gt_labels, gt_bboxes, mask_gt)
+
+        target_scores_sum = max(target_scores.sum(), 1)
+
+        # cls loss
+        # loss[1] = self.varifocal_loss(pred_scores, target_scores, target_labels) / target_scores_sum  # VFL way
+        loss[3] = self.bce(pred_scores, target_scores.to(dtype)).sum() / target_scores_sum  # BCE
+
+        # bbox loss
+        if fg_mask.sum():
+            target_bboxes /= stride_tensor
+            loss[0], loss[4] = self.bbox_loss(pred_distri, pred_bboxes, anchor_points, target_bboxes, target_scores,
+                                              target_scores_sum, fg_mask)
+            keypoints = batch['keypoints'].to(self.device).float().clone()
+            keypoints[..., 0] *= imgsz[1]
+            keypoints[..., 1] *= imgsz[0]
+            for i in range(batch_size):
+                if fg_mask[i].sum():
+                    idx = target_gt_idx[i][fg_mask[i]]
+                    gt_kpt = keypoints[batch_idx.view(-1) == i][idx]  # (n, 51)
+                    gt_kpt[..., 0] /= stride_tensor[fg_mask[i]]
+                    gt_kpt[..., 1] /= stride_tensor[fg_mask[i]]
+                    area = xyxy2xywh(target_bboxes[i][fg_mask[i]])[:, 2:].prod(1, keepdim=True)
+                    pred_kpt = pred_kpts[i][fg_mask[i]]
+                    kpt_mask = gt_kpt[..., 2] != 0
+                    loss[1] += self.keypoint_loss(pred_kpt, gt_kpt, kpt_mask, area)  # pose loss
+                    # kpt_score loss
+                    if pred_kpt.shape[-1] == 3:
+                        loss[2] += self.bce_pose(pred_kpt[..., 2], kpt_mask.float())  # keypoint obj loss
+
+        loss[0] *= self.hyp.box  # box gain
+        loss[1] *= self.hyp.pose / batch_size  # pose gain
+        loss[2] *= self.hyp.kobj / batch_size  # kobj gain
+        loss[3] *= self.hyp.cls  # cls gain
+        loss[4] *= self.hyp.dfl  # dfl gain
+
+        return loss.sum() * batch_size, loss.detach()  # loss(box, cls, dfl)
+
+    def kpts_decode(self, anchor_points, pred_kpts):
+        y = pred_kpts.clone()
+        y[..., :2] *= 2.0
+        y[..., 0] += anchor_points[:, [0]] - 0.5
+        y[..., 1] += anchor_points[:, [1]] - 0.5
+        return y
+
+
+def train(cfg=DEFAULT_CFG, use_python=False):
+    model = cfg.model or 'yolov8n-pose.yaml'
+    data = cfg.data or 'coco8-pose.yaml'
+    device = cfg.device if cfg.device is not None else ''
+
+    args = dict(model=model, data=data, device=device)
+    if use_python:
+        from ultralytics import YOLO
+        YOLO(model).train(**args)
+    else:
+        trainer = PoseTrainer(overrides=args)
+        trainer.train()
+
+
+if __name__ == '__main__':
+    train()

ultralytics/yolo/v8/pose/val.py

@@ -0,0 +1,213 @@
+# Ultralytics YOLO 🚀, GPL-3.0 license
+
+from pathlib import Path
+
+import numpy as np
+import torch
+
+from ultralytics.yolo.utils import DEFAULT_CFG, LOGGER, ops
+from ultralytics.yolo.utils.checks import check_requirements
+from ultralytics.yolo.utils.metrics import OKS_SIGMA, PoseMetrics, box_iou, kpt_iou
+from ultralytics.yolo.utils.plotting import output_to_target, plot_images
+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)
+        self.args.task = 'pose'
+        self.metrics = PoseMetrics(save_dir=self.save_dir)
+
+    def preprocess(self, batch):
+        batch = super().preprocess(batch)
+        batch['keypoints'] = batch['keypoints'].to(self.device).float()
+        return batch
+
+    def get_desc(self):
+        return ('%22s' + '%11s' * 10) % ('Class', 'Images', 'Instances', 'Box(P', 'R', 'mAP50', 'mAP50-95)', 'Pose(P',
+                                         'R', 'mAP50', 'mAP50-95)')
+
+    def postprocess(self, preds):
+        preds = ops.non_max_suppression(preds,
+                                        self.args.conf,
+                                        self.args.iou,
+                                        labels=self.lb,
+                                        multi_label=True,
+                                        agnostic=self.args.single_cls,
+                                        max_det=self.args.max_det,
+                                        nc=self.nc)
+        return preds
+
+    def init_metrics(self, model):
+        super().init_metrics(model)
+        self.kpt_shape = self.data['kpt_shape']
+        is_pose = self.kpt_shape == [17, 3]
+        nkpt = self.kpt_shape[0]
+        self.sigma = OKS_SIGMA if is_pose else np.ones(nkpt) / nkpt
+
+    def update_metrics(self, preds, batch):
+        # Metrics
+        for si, pred in enumerate(preds):
+            idx = batch['batch_idx'] == si
+            cls = batch['cls'][idx]
+            bbox = batch['bboxes'][idx]
+            kpts = batch['keypoints'][idx]
+            nl, npr = cls.shape[0], pred.shape[0]  # number of labels, predictions
+            nk = kpts.shape[1]  # number of keypoints
+            shape = batch['ori_shape'][si]
+            correct_kpts = torch.zeros(npr, self.niou, dtype=torch.bool, device=self.device)  # init
+            correct_bboxes = torch.zeros(npr, self.niou, dtype=torch.bool, device=self.device)  # init
+            self.seen += 1
+
+            if npr == 0:
+                if nl:
+                    self.stats.append((correct_bboxes, correct_kpts, *torch.zeros(
+                        (2, 0), device=self.device), cls.squeeze(-1)))
+                    if self.args.plots:
+                        self.confusion_matrix.process_batch(detections=None, labels=cls.squeeze(-1))
+                continue
+
+            # Predictions
+            if self.args.single_cls:
+                pred[:, 5] = 0
+            predn = pred.clone()
+            ops.scale_boxes(batch['img'][si].shape[1:], predn[:, :4], shape,
+                            ratio_pad=batch['ratio_pad'][si])  # native-space pred
+            pred_kpts = predn[:, 6:].view(npr, nk, -1)
+            ops.scale_coords(batch['img'][si].shape[1:], pred_kpts, shape, ratio_pad=batch['ratio_pad'][si])
+
+            # Evaluate
+            if nl:
+                height, width = batch['img'].shape[2:]
+                tbox = ops.xywh2xyxy(bbox) * torch.tensor(
+                    (width, height, width, height), device=self.device)  # target boxes
+                ops.scale_boxes(batch['img'][si].shape[1:], tbox, shape,
+                                ratio_pad=batch['ratio_pad'][si])  # native-space labels
+                tkpts = kpts.clone()
+                tkpts[..., 0] *= width
+                tkpts[..., 1] *= height
+                tkpts = ops.scale_coords(batch['img'][si].shape[1:], tkpts, shape, ratio_pad=batch['ratio_pad'][si])
+                labelsn = torch.cat((cls, tbox), 1)  # native-space labels
+                correct_bboxes = self._process_batch(predn[:, :6], labelsn)
+                correct_kpts = self._process_batch(predn[:, :6], labelsn, pred_kpts, tkpts)
+                if self.args.plots:
+                    self.confusion_matrix.process_batch(predn, labelsn)
+
+            # Append correct_masks, correct_boxes, pconf, pcls, tcls
+            self.stats.append((correct_bboxes, correct_kpts, pred[:, 4], pred[:, 5], cls.squeeze(-1)))
+
+            # Save
+            if self.args.save_json:
+                self.pred_to_json(predn, batch['im_file'][si])
+            # if self.args.save_txt:
+            #    save_one_txt(predn, save_conf, shape, file=save_dir / 'labels' / f'{path.stem}.txt')
+
+    def _process_batch(self, detections, labels, pred_kpts=None, gt_kpts=None):
+        """
+        Return correct prediction matrix
+        Arguments:
+            detections (array[N, 6]), x1, y1, x2, y2, conf, class
+            labels (array[M, 5]), class, x1, y1, x2, y2
+            pred_kpts (array[N, 51]), 51 = 17 * 3
+            gt_kpts (array[N, 51])
+        Returns:
+            correct (array[N, 10]), for 10 IoU levels
+        """
+        if pred_kpts is not None and gt_kpts is not None:
+            # `0.53` is from https://github.com/jin-s13/xtcocoapi/blob/master/xtcocotools/cocoeval.py#L384
+            area = ops.xyxy2xywh(labels[:, 1:])[:, 2:].prod(1) * 0.53
+            iou = kpt_iou(gt_kpts, pred_kpts, sigma=self.sigma, area=area)
+        else:  # boxes
+            iou = box_iou(labels[:, 1:], detections[:, :4])
+
+        correct = np.zeros((detections.shape[0], self.iouv.shape[0])).astype(bool)
+        correct_class = labels[:, 0:1] == detections[:, 5]
+        for i in range(len(self.iouv)):
+            x = torch.where((iou >= self.iouv[i]) & correct_class)  # IoU > threshold and classes match
+            if x[0].shape[0]:
+                matches = torch.cat((torch.stack(x, 1), iou[x[0], x[1]][:, None]),
+                                    1).cpu().numpy()  # [label, detect, iou]
+                if x[0].shape[0] > 1:
+                    matches = matches[matches[:, 2].argsort()[::-1]]
+                    matches = matches[np.unique(matches[:, 1], return_index=True)[1]]
+                    # matches = matches[matches[:, 2].argsort()[::-1]]
+                    matches = matches[np.unique(matches[:, 0], return_index=True)[1]]
+                correct[matches[:, 1].astype(int), i] = True
+        return torch.tensor(correct, dtype=torch.bool, device=detections.device)
+
+    def plot_val_samples(self, batch, ni):
+        plot_images(batch['img'],
+                    batch['batch_idx'],
+                    batch['cls'].squeeze(-1),
+                    batch['bboxes'],
+                    kpts=batch['keypoints'],
+                    paths=batch['im_file'],
+                    fname=self.save_dir / f'val_batch{ni}_labels.jpg',
+                    names=self.names)
+
+    def plot_predictions(self, batch, preds, ni):
+        pred_kpts = torch.cat([p[:, 6:].view(-1, *self.kpt_shape)[:15] for p in preds], 0)
+        plot_images(batch['img'],
+                    *output_to_target(preds, max_det=15),
+                    kpts=pred_kpts,
+                    paths=batch['im_file'],
+                    fname=self.save_dir / f'val_batch{ni}_pred.jpg',
+                    names=self.names)  # pred
+
+    def pred_to_json(self, predn, filename):
+        stem = Path(filename).stem
+        image_id = int(stem) if stem.isnumeric() else stem
+        box = ops.xyxy2xywh(predn[:, :4])  # xywh
+        box[:, :2] -= box[:, 2:] / 2  # xy center to top-left corner
+        for p, b in zip(predn.tolist(), box.tolist()):
+            self.jdict.append({
+                'image_id': image_id,
+                'category_id': self.class_map[int(p[5])],
+                'bbox': [round(x, 3) for x in b],
+                'keypoints': p[6:],
+                'score': round(p[4], 5)})
+
+    def eval_json(self, stats):
+        if self.args.save_json and self.is_coco and len(self.jdict):
+            anno_json = self.data['path'] / 'annotations/person_keypoints_val2017.json'  # annotations
+            pred_json = self.save_dir / 'predictions.json'  # predictions
+            LOGGER.info(f'\nEvaluating pycocotools mAP using {pred_json} and {anno_json}...')
+            try:  # https://github.com/cocodataset/cocoapi/blob/master/PythonAPI/pycocoEvalDemo.ipynb
+                check_requirements('pycocotools>=2.0.6')
+                from pycocotools.coco import COCO  # noqa
+                from pycocotools.cocoeval import COCOeval  # noqa
+
+                for x in anno_json, pred_json:
+                    assert x.is_file(), f'{x} file not found'
+                anno = COCO(str(anno_json))  # init annotations api
+                pred = anno.loadRes(str(pred_json))  # init predictions api (must pass string, not Path)
+                for i, eval in enumerate([COCOeval(anno, pred, 'bbox'), COCOeval(anno, pred, 'keypoints')]):
+                    if self.is_coco:
+                        eval.params.imgIds = [int(Path(x).stem) for x in self.dataloader.dataset.im_files]  # im to eval
+                    eval.evaluate()
+                    eval.accumulate()
+                    eval.summarize()
+                    idx = i * 4 + 2
+                    stats[self.metrics.keys[idx + 1]], stats[
+                        self.metrics.keys[idx]] = eval.stats[:2]  # update mAP50-95 and mAP50
+            except Exception as e:
+                LOGGER.warning(f'pycocotools unable to run: {e}')
+        return stats
+
+
+def val(cfg=DEFAULT_CFG, use_python=False):
+    model = cfg.model or 'yolov8n-pose.pt'
+    data = cfg.data or 'coco128-pose.yaml'
+
+    args = dict(model=model, data=data)
+    if use_python:
+        from ultralytics import YOLO
+        YOLO(model).val(**args)
+    else:
+        validator = PoseValidator(args=args)
+        validator(model=args['model'])
+
+
+if __name__ == '__main__':
+    val()

ultralytics/yolo/v8/segment/val.py

@@ -65,7 +65,7 @@ class SegmentationValidator(DetectionValidator):
 
             if npr == 0:
                 if nl:
-                    self.stats.append((correct_masks, correct_bboxes, *torch.zeros(
+                    self.stats.append((correct_bboxes, correct_masks, *torch.zeros(
                         (2, 0), device=self.device), cls.squeeze(-1)))
                     if self.args.plots:
                         self.confusion_matrix.process_batch(detections=None, labels=cls.squeeze(-1))
@@ -103,7 +103,7 @@ class SegmentationValidator(DetectionValidator):
                     self.confusion_matrix.process_batch(predn, labelsn)
 
             # Append correct_masks, correct_boxes, pconf, pcls, tcls
-            self.stats.append((correct_masks, correct_bboxes, pred[:, 4], pred[:, 5], cls.squeeze(-1)))
+            self.stats.append((correct_bboxes, correct_masks, pred[:, 4], pred[:, 5], cls.squeeze(-1)))
 
             pred_masks = torch.as_tensor(pred_masks, dtype=torch.uint8)
             if self.args.plots and self.batch_i < 3:
@@ -220,8 +220,7 @@ class SegmentationValidator(DetectionValidator):
                 pred = anno.loadRes(str(pred_json))  # init predictions api (must pass string, not Path)
                 for i, eval in enumerate([COCOeval(anno, pred, 'bbox'), COCOeval(anno, pred, 'segm')]):
                     if self.is_coco:
-                        eval.params.imgIds = [int(Path(x).stem)
-                                              for x in self.dataloader.dataset.im_files]  # images to eval
+                        eval.params.imgIds = [int(Path(x).stem) for x in self.dataloader.dataset.im_files]  # im to eval
                     eval.evaluate()
                     eval.accumulate()
                     eval.summarize()

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ultralytics
-Version: 8.0.64
+Version: 8.0.66
 Summary: Ultralytics YOLOv8
 Home-page: https://github.com/ultralytics/ultralytics
 Author: Ultralytics
@@ -176,7 +176,10 @@ YOLOv8 [Python Docs](https://docs.ultralytics.com/usage/python) for more example
 
 ## <div align="center">Models</div>
 
-All YOLOv8 pretrained models are available here. Detect, Segment and Pose models are pretrained on the [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/datasets/coco.yaml) dataset, while Classify models are pretrained on the [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/datasets/ImageNet.yaml) dataset.
+All YOLOv8 pretrained models are available here. Detect, Segment and Pose models are pretrained on
+the [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/datasets/coco.yaml) dataset, while Classify
+models are pretrained on
+the [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/datasets/ImageNet.yaml) dataset.
 
 [Models](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/models) download automatically from the latest
 Ultralytics [release](https://github.com/ultralytics/assets/releases) on first use.
@@ -241,6 +244,28 @@ See [Classification Docs](https://docs.ultralytics.com/tasks/classify/) for usag
 
 </details>
 
+<details><summary>Pose</summary>
+
+See [Pose Docs](https://docs.ultralytics.com/tasks/) for usage examples with these models.
+
+| 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            |
+
+- **mAP<sup>val</sup>** values are for single-model single-scale on [COCO Keypoints val2017](http://cocodataset.org)
+  dataset.
+  <br>Reproduce by `yolo val pose data=coco-pose.yaml device=0`
+- **Speed** averaged over COCO val images using an [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/)
+  instance.
+  <br>Reproduce by `yolo val pose data=coco8-pose.yaml batch=1 device=0|cpu`
+
+</details>
+
 ## <div align="center">Integrations</div>
 
 <br>

{ultralytics-8.0.64.dist-info → ultralytics-8.0.66.dist-info}/RECORD

@@ -1,4 +1,4 @@
-ultralytics/__init__.py,sha256=caU_6II0yY1JeYfGXzhqgIu-EZpjbbVcLiC74uT93aI,295
+ultralytics/__init__.py,sha256=oOVc92vx-QWmdYNEm-dfOr4GkkPh9t830W4a5oCLZ5Q,295
 ultralytics/assets/bus.jpg,sha256=wCAZxJecGR63Od3ZRERe9Aja1Weayrb9Ug751DS_vGM,137419
 ultralytics/assets/zidane.jpg,sha256=Ftc4aeMmen1O0A3o6GCDO9FlfBslLpTAw0gnetx7bts,50427
 ultralytics/datasets/Argoverse.yaml,sha256=EOZ3aUOi9mgCVot4TMiUBXVuovIdTAZ1FSOy7G224vA,2750
@@ -8,9 +8,11 @@ ultralytics/datasets/Objects365.yaml,sha256=B4vt7iF_Yr9Qcd8-5udfAf7BYVP75SQBhrSd
 ultralytics/datasets/SKU-110K.yaml,sha256=Iwnz9GoTH1fcd0VmplvWGvW9MPeybG0UKaFEIwH_s68,2436
 ultralytics/datasets/VOC.yaml,sha256=cM9VTm8kd_WmZwZjSZ5zliHTwfXvbe-nPgJfSfD_nFs,3511
 ultralytics/datasets/VisDrone.yaml,sha256=EKuXI2oVQ8sC5wNVzgD_6ZEVv6EWROt7SiNVY7_wk88,3013
+ultralytics/datasets/coco-pose.yaml,sha256=bnFaDJF9ZMCg8t4qjhowfuWGJWFcLAqvo5eAltVTv3M,1546
 ultralytics/datasets/coco.yaml,sha256=VVh6tOkTiXxDm_IYxLPTlecxjCJCvk06DMTfy-VVM30,2525
 ultralytics/datasets/coco128-seg.yaml,sha256=v2ZZhMyxm1dGSXu1p4vJsPywaYfGa-78q3G6NIg1eY4,1861
 ultralytics/datasets/coco128.yaml,sha256=Sb1F9i2lQLC0IsKsAnrOUdpU6TkXWD7eftcre0sfSic,1845
+ultralytics/datasets/coco8-pose.yaml,sha256=esaL4WvRK_NgcRSB9G3WMIDdUiOc0buuGyL6-CJwKzw,894
 ultralytics/datasets/coco8-seg.yaml,sha256=tsdE6xhhQ2EgjXvasn7YWJoAsvo7BpRUvHDs0JLwg2c,1796
 ultralytics/datasets/coco8.yaml,sha256=YIlvnkEGEk9KOX9PtwQkr3gLvLY4CzSCMBXouP66WKQ,1776
 ultralytics/datasets/xView.yaml,sha256=5JIVo4LOvkm8XJZ8Vxp-2SZMNG-K6ED9jfjG305-_cY,5177
@@ -26,15 +28,17 @@ ultralytics/models/v5/yolov5.yaml,sha256=jgUXGol5ynZROkXb9fCUwB5iIzHHrIDBLPVGkAq
 ultralytics/models/v8/yolov8-cls.yaml,sha256=QLTZE6ckxsgrhki-X0S8EqLK0inMBuAV6nn4VCVazmc,919
 ultralytics/models/v8/yolov8-p2.yaml,sha256=CkEyzoowGl4uryD1NJs_IhbszPB74k0jr_-PMgI5EwU,1750
 ultralytics/models/v8/yolov8-p6.yaml,sha256=KrNCp46jg8LVvKftL90BhYjgCSfJ8KP5JgALY0J4wWA,1855
+ultralytics/models/v8/yolov8-pose-p6.yaml,sha256=v_Biz744Hiu1ipkjR0L6FGmucgUThYN8wjDW4lr0Dfw,1952
+ultralytics/models/v8/yolov8-pose.yaml,sha256=DhCAzlGzlMvgolvIeUXzYVRcdyRZE9w-_Cmpxpga4J8,1579
 ultralytics/models/v8/yolov8-seg.yaml,sha256=LbwC_yaSMJrsHQYb2zrlCY0utQJN53L-Z6n-T8MwFRY,1489
 ultralytics/models/v8/yolov8.yaml,sha256=Mt5Sza9rvG0OVJ0XhuZDZXPrqGW6pTbesXXPR0JfGVs,1912
 ultralytics/nn/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ultralytics/nn/autobackend.py,sha256=eU-pfV8zra7hmJVJiz2fjTCjcLtWmL-cM6xXdvnWIH0,23818
+ultralytics/nn/autobackend.py,sha256=zR3gnXOiRJHlGJk1lps0EUIVW5pqmSjfQTeUc77A9lI,24083
 ultralytics/nn/autoshape.py,sha256=oB3unCdTIMlvsheWx_q5PQjGh79uPD2m04lvTB5T5Ik,11839
-ultralytics/nn/modules.py,sha256=rEk6z78ZHNV-z7_qacODzrcqVbq2pBzBLGO9yliWzGM,18620
-ultralytics/nn/tasks.py,sha256=QR92dJ6s8xAvzcivBv0atel1bdTLOYioKl7RWuuM6zo,25772
+ultralytics/nn/modules.py,sha256=DbaF1MtcPO0qHAYQZ_Ha_cHImYY3rnnMFeR8IsEmgkY,20043
+ultralytics/nn/tasks.py,sha256=b48fDKZKosQn389Hnvhqo1h7irJvq8dG_EIYOMqdDFg,26611
 ultralytics/tracker/__init__.py,sha256=WAkNFWbZYTMiaK63GeBWYJ-HEcKwXOl2pTtmQTfOI5I,201
-ultralytics/tracker/track.py,sha256=Kvo9_pG4G46lXQjVN8oWmKjmGUVcllRiepQfTJcr20M,1580
+ultralytics/tracker/track.py,sha256=_Z-8EYRCxi3RwNplTl3zJkiZDkpNXWAxQ_jP70PB2Ik,1509
 ultralytics/tracker/cfg/botsort.yaml,sha256=YPqsA_iuLjLC6HxjgWREvaEBFnSRIR1F9q5Cfrmm0Aw,889
 ultralytics/tracker/cfg/bytetrack.yaml,sha256=l7KWuUNux3GEoCOskwQDVxUvsG8xDKGGzTQ52tjf8sU,693
 ultralytics/tracker/trackers/__init__.py,sha256=nkYYehL4XUhXmSUt7BFAENsYk9CRwB7mAW4yHddxAd8,170
@@ -46,40 +50,40 @@ ultralytics/tracker/utils/gmc.py,sha256=L5r7WAt7_UD6r4AU0XnledolqdeLqHnd4ejMY-7z
 ultralytics/tracker/utils/kalman_filter.py,sha256=kthztWM9R7Gsl9f9FduqY-GuCQIgzVBFpjobCDJjy40,18219
 ultralytics/tracker/utils/matching.py,sha256=o6d-7qXYLBxaV766v3GwUXa9SFO3qvmzdnfq1eBMw2U,7511
 ultralytics/yolo/__init__.py,sha256=GZ9sffmGZl0xK2yjXZFyZroVpdcwmWrvGu6QwnEXY4w,93
-ultralytics/yolo/cfg/__init__.py,sha256=OQmndA6IyYjIjEfXpQ5BTTOTqtI-22zEreebKip9SGw,17604
-ultralytics/yolo/cfg/default.yaml,sha256=cmILLl7uy3tSDO9HVQ4yXo7363jYn4sYnMOoHcBMqXI,6237
+ultralytics/yolo/cfg/__init__.py,sha256=aA0OtWJHeOzYsTtcPzB4nFH5fsk7CJa-yJ_3HnUo3yI,17596
+ultralytics/yolo/cfg/default.yaml,sha256=fjKgLCJN621kI2XBovo7SGs_zEAfXo1wfh6U7XZa97c,6302
 ultralytics/yolo/data/__init__.py,sha256=ui2V_756otLaIU1E_AtUflt9KsJta4ylLHt8rbKX-Dw,483
-ultralytics/yolo/data/augment.py,sha256=REodw1EnVIL9jtaYbK8XMJjZXVjbcRLClyIA7DTRsgQ,30892
+ultralytics/yolo/data/augment.py,sha256=ikrc-13omwlhqP3-UWnJlfU3RGLOyfMqJZJrvWDKvN4,31119
 ultralytics/yolo/data/base.py,sha256=HadwteNfW8XxAg4I80IUYxhcVG3e3JcqHpc_2dp-vWw,8819
-ultralytics/yolo/data/build.py,sha256=2bC0MeFjsBpIIaQCkTMSZEc0amwoabAkHqhEH2V_h5s,7874
-ultralytics/yolo/data/dataset.py,sha256=ycVmC1Fe4XnTlfuKzBTAdifl1wvNK7Cr1Kae0BkZ8Y4,12289
+ultralytics/yolo/data/build.py,sha256=kRJaWB6uAtGSePpcob5bcWvPMfIjyL-TYGJcp9Kg9Yc,7872
+ultralytics/yolo/data/dataset.py,sha256=CDZifLTdesDPgaAdIIE1ouiSEeWs2EEtxtUxcp9Au2M,12760
 ultralytics/yolo/data/dataset_wrappers.py,sha256=IyP-MGHGO75LjX9mqL-17rLpT-m9_rHUZfop6W2y_mw,1330
-ultralytics/yolo/data/utils.py,sha256=NtLeEFNClyvVqfnI0NxXHclN9cNPDOK7SAJanIVm3mE,19900
+ultralytics/yolo/data/utils.py,sha256=7NRxG6FVyIOmlskfW270t3tzx334-wal2Vnp7oD-gaM,22552
 ultralytics/yolo/data/dataloaders/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ultralytics/yolo/data/dataloaders/stream_loaders.py,sha256=rkRe98hh_jKIv-bt0tDRqjwbt7dVlKyy3es0FFeIdog,15194
 ultralytics/yolo/data/dataloaders/v5augmentations.py,sha256=1cHLok8gmlgNMsGVIvjLJkkmIwfs2MU4ZJ-PwJEiYyE,17226
 ultralytics/yolo/data/dataloaders/v5loader.py,sha256=vThacCrsXCVtfMiUA1scmEpvjN9ASrdU7Lk_33XFbyI,49861
 ultralytics/yolo/engine/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ultralytics/yolo/engine/exporter.py,sha256=kz1lb8pH_lK27REiDygWQzbt9zS6wYBcDwpEioG88M4,41589
-ultralytics/yolo/engine/model.py,sha256=whZHAcEms7uVzmwtI5PA5mOm6Xiw8pEyTGwHDnF7kDk,16992
-ultralytics/yolo/engine/predictor.py,sha256=NwtnbZS2A1w59IJixKQRnExjSqCek97wBRP0-2u81lw,13492
-ultralytics/yolo/engine/results.py,sha256=PG0GuDvaBjrKj4-sfd09THeba9_C0LS7nCU1M3tqIq8,13735
+ultralytics/yolo/engine/exporter.py,sha256=u9sVuEdJybqXGIQkp1NOmrUcgN1vw932Y2LKlKC4EUc,41715
+ultralytics/yolo/engine/model.py,sha256=k6JX6vIaI4uvdvQanZvu40VMqIYUu9oXdXFJo2k_Oys,17109
+ultralytics/yolo/engine/predictor.py,sha256=v8fHYp0vXecRxE_8zFHl5aJ3QZKj5Pmpo2hswR3Kfx4,13536
+ultralytics/yolo/engine/results.py,sha256=nu44NnAK_tksSImnlbpRCkeUuMmgrHzpXxt4QhNp5Jw,14114
 ultralytics/yolo/engine/trainer.py,sha256=U3eYLYJGfMPOb019OXJTk_T26um4QNv6XQFaHsrYmg0,29877
 ultralytics/yolo/engine/validator.py,sha256=B9Vu6KSQ1jiWOgPPo37hfGgpq4PeGIYlHzvCIaR43q4,10235
 ultralytics/yolo/utils/__init__.py,sha256=8fNLkdZ0aWYxoLxfEYphZ4bkxEDafAgvCNxJPjl0L4I,23705
 ultralytics/yolo/utils/autobatch.py,sha256=I09al9DZbo6aNyf-GS1N1WFBOWC4xmHB2Yt81SvDd1o,3823
-ultralytics/yolo/utils/benchmarks.py,sha256=QMT1LqZOFPyIyYLYNxqlTI6o68wNsUu7CQb3jdaELJ8,5310
+ultralytics/yolo/utils/benchmarks.py,sha256=_fo6TzZ8YLEJOQa7rG9hjjg2XIkKd-NnoiYNas0tB3k,5414
 ultralytics/yolo/utils/checks.py,sha256=tv1Mz4okutFNoRZ_YbUHur1Kf9-Q39hGjTYifRv_Skc,13841
 ultralytics/yolo/utils/dist.py,sha256=6on1z6Jo6VbHwTg5V3yprEwJwkFUdNLJxf1gqDGx_Ks,2412
-ultralytics/yolo/utils/downloads.py,sha256=39WPNYYT0OVkNfllX8D2IgHyyelKHMtldfNeSIpbDyY,9571
+ultralytics/yolo/utils/downloads.py,sha256=_qQrVb8PGPRrvGNOxZqRdwwJdTvEqYMGPJyageL0fas,9562
 ultralytics/yolo/utils/files.py,sha256=41egcQxsUgxN02UbcOGZfobeHQpOjVJu2Sg5fuKbyfo,3406
-ultralytics/yolo/utils/instance.py,sha256=vy-AZ01l7CehZIGQjEbBgAhf-lWVyMn0-x0cdZgoSrQ,11379
-ultralytics/yolo/utils/loss.py,sha256=zAq5FT_bmsI7yqnZil7DZqPhb__vbiTNbj3xKjxTMWU,2261
-ultralytics/yolo/utils/metrics.py,sha256=3Ogbjj_YG5m8VMrWJJbxRmZ-6VQu96GgxrcB0L_bLCA,30437
-ultralytics/yolo/utils/ops.py,sha256=eMN8q-01zB8c1lLLQvNNM330dRaw_fj4H31QVPXmKoU,28320
-ultralytics/yolo/utils/plotting.py,sha256=0M89MxuWKFvYNxOf76UGsUDy5u9obVAVYSJG_bi5Kgo,16743
+ultralytics/yolo/utils/instance.py,sha256=rMxybRdrilqpWAOfUtH-YQx4wHNj2Y2lR48u2G8V4bk,11394
+ultralytics/yolo/utils/loss.py,sha256=JTgCauhA-gHhYn7IaMhR5UAUVHG_wx3S8YR5XhkRs88,2889
+ultralytics/yolo/utils/metrics.py,sha256=4nsmjk1-Gp5LLaoT4jo7zfox23qcF2drbqGzzI5EoR8,35011
+ultralytics/yolo/utils/ops.py,sha256=3FX78RW3zZBlkh5ykCMLUDC88YZiE8fp3eDO7tC4JDg,27980
+ultralytics/yolo/utils/plotting.py,sha256=RyCgUwfCKasHLUwgAsyoCvJaWUV1xhIejsZ6XeZD9CY,20717
 ultralytics/yolo/utils/tal.py,sha256=mL-olmUSXUj9bAl1s11K21OopomZif3Q-SwdgBJ6Pvs,10233
-ultralytics/yolo/utils/torch_utils.py,sha256=w0Q-9GZC15okh_ocDIFUROyW1mDqly-YPeO5GeMwHHY,19652
+ultralytics/yolo/utils/torch_utils.py,sha256=S8CD1-pPX6k0IGTb6Bue9_syYEftQjayJ7EDIT5l73Y,19694
 ultralytics/yolo/utils/callbacks/__init__.py,sha256=D7j66dJn6N6hqmP8dop75_G0TiKR9a3SD6ceOyc3UNw,123
 ultralytics/yolo/utils/callbacks/base.py,sha256=z2NLGBegE2zdtl_dDVPDK6yO_03o4f9_8JLUb7Kt-6I,3503
 ultralytics/yolo/utils/callbacks/clearml.py,sha256=YwSkhC8ohAoISxDesXVv6k2Bnp9QCvJ1_9sUKhAk0bI,2145
@@ -87,22 +91,26 @@ ultralytics/yolo/utils/callbacks/comet.py,sha256=Y1dsAMovZ40iUXOnFVApuT05Wl9yChz
 ultralytics/yolo/utils/callbacks/hub.py,sha256=TdGS9uA7zDU6IP_GWns76VUQxcE3dgXfUMj_qQR-Nd8,3154
 ultralytics/yolo/utils/callbacks/mlflow.py,sha256=VvpMP4hrF5Tjgx_TNL7BCoo9pd6q-WZaIA6oIkYFDqE,2512
 ultralytics/yolo/utils/callbacks/tensorboard.py,sha256=pCDad52mQSuT5aouEU57izkjGvG2OnAzxdk0mSysoOc,1297
-ultralytics/yolo/v8/__init__.py,sha256=noK3X4pfP1dYtHRyB6NhXhh3y78AOjgB2Ka1momjhdQ,143
+ultralytics/yolo/v8/__init__.py,sha256=aEhezkHyW1R-wRF3HyagSCfMy6xhCZj6m4bbIAi6HT0,157
 ultralytics/yolo/v8/classify/__init__.py,sha256=lm4bNTAfDS2ZTljojApMqAKDmDTVlFpq-EC5jjbS31Q,390
 ultralytics/yolo/v8/classify/predict.py,sha256=QUeohoSb1R5sgLKBv_eI1M2vFh8BOe2CcZiepz2Ec4U,3162
 ultralytics/yolo/v8/classify/train.py,sha256=4sajgp7_Tfj0SkV0LdLXwuN2sa1x4av-JNxbeYKMHL0,6359
 ultralytics/yolo/v8/classify/val.py,sha256=vHmqMfJhPm2fGZGKlFWiQ5UsHxkCDYSzl7_D8P3YK20,2554
 ultralytics/yolo/v8/detect/__init__.py,sha256=Z3h2Qu_ebeQFOOrl1OQgpyGkzWBrFJ5ygf7uL8X9Mkc,276
 ultralytics/yolo/v8/detect/predict.py,sha256=XMGriSo24npeiPxNZ81W6BL-jB_qb45VtRWKaky1KY0,4370
-ultralytics/yolo/v8/detect/train.py,sha256=5EntmLU8l54heUNjo5XdMz-GqnZgWZBHBrifC5UNiFo,9891
-ultralytics/yolo/v8/detect/val.py,sha256=hcfrWBnF3kOK32tHbj9ewW5e7xW0HWeMDIYH90MUJTE,12486
+ultralytics/yolo/v8/detect/train.py,sha256=-wVP4smHE7q7K8AS91BoyHymM2Q5ePOUEPYtw5E5NxU,9886
+ultralytics/yolo/v8/detect/val.py,sha256=Vku-GmDXKQBqtnOvcebiArcVjXQSpGfYEfSM8n5rP4A,12487
+ultralytics/yolo/v8/pose/__init__.py,sha256=Q94UAg9QgQqi8EATtkllJUBV9weg7Uig8CcO0-ybLw0,246
+ultralytics/yolo/v8/pose/predict.py,sha256=zohT09vdkrlIDo8qgj616HD5TwJfLRAbsD-sm_tNqQw,4619
+ultralytics/yolo/v8/pose/train.py,sha256=0cZiQu15Fl6jWtxqtm3_Vtq6xgGGbwTsSYUYmahXKqM,7116
+ultralytics/yolo/v8/pose/val.py,sha256=2sO_c9vmqgPFGSjTV25o5x71BxN8K6S2lFJjxzP9vmE,10023
 ultralytics/yolo/v8/segment/__init__.py,sha256=1OK2oVv3A-iWPf_V4Jz0uXhBQZyLd7dlI5rAzxu_IvU,294
 ultralytics/yolo/v8/segment/predict.py,sha256=hmgTGQTnk2nrS6XMLD7VgiLoXd-ZFuwNw7wKGGK0obo,5446
 ultralytics/yolo/v8/segment/train.py,sha256=ryiPZl7F-EuE2pzXWlpgceDy6jK2nyFP8YHAOBBtL4M,7645
-ultralytics/yolo/v8/segment/val.py,sha256=xoA33JliVH3F1jgPxsKvhh0w7aeO85vMtdl0TfMqzag,12016
-ultralytics-8.0.64.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-ultralytics-8.0.64.dist-info/METADATA,sha256=HxDk5fB-FiPg6I4Bi7TNtn1KoLp6jOhfz--mgLKHqYU,23116
-ultralytics-8.0.64.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
-ultralytics-8.0.64.dist-info/entry_points.txt,sha256=Ck1F6qKNokeHozQD5pmaFgXHL6dKyC2qCdyXao2e6Yg,103
-ultralytics-8.0.64.dist-info/top_level.txt,sha256=XP49TwiMw4QGsvTLSYiJhz1xF_k7ev5mQ8jJXaXi45Q,12
-ultralytics-8.0.64.dist-info/RECORD,,
+ultralytics/yolo/v8/segment/val.py,sha256=MovmKcVjcN_ZOSu4oyu1EdHxZ5q-0F800hipaxLAysM,11966
+ultralytics-8.0.66.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+ultralytics-8.0.66.dist-info/METADATA,sha256=D8LazZc0DYyLZIZ9zhWEiTWSO3ucn0ie5cp08iy_6hs,25956
+ultralytics-8.0.66.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
+ultralytics-8.0.66.dist-info/entry_points.txt,sha256=Ck1F6qKNokeHozQD5pmaFgXHL6dKyC2qCdyXao2e6Yg,103
+ultralytics-8.0.66.dist-info/top_level.txt,sha256=XP49TwiMw4QGsvTLSYiJhz1xF_k7ev5mQ8jJXaXi45Q,12
+ultralytics-8.0.66.dist-info/RECORD,,