सामग्री पर जाएं

के लिए संदर्भ ultralytics/models/rtdetr/val.py

नोट

यह फ़ाइल यहाँ उपलब्ध है https://github.com/ultralytics/ultralytics/बूँद/मुख्य/ultralytics/models/rtdetr/val.py का उपयोग करें। यदि आप कोई समस्या देखते हैं तो कृपया पुल अनुरोध का योगदान करके इसे ठीक करने में मदद करें 🛠️। 🙏 धन्यवाद !



ultralytics.models.rtdetr.val.RTDETRDataset

का रूप: YOLODataset

रीयल-टाइम डिटेक्शन और ट्रैकिंग (RT-DETR) डेटासेट क्लास बेस YOLODataset क्लास का विस्तार करता है।

यह विशेष डेटासेट वर्ग के साथ उपयोग के लिए डिज़ाइन किया गया है RT-DETR ऑब्जेक्ट डिटेक्शन मॉडल और इसके लिए अनुकूलित है वास्तविक समय का पता लगाने और कार्यों को ट्रैक करना।

में स्रोत कोड ultralytics/models/rtdetr/val.py
13 बांग्लादेश 13 बांग्लादेश बांग्लादेश 13 बांग्लादेश 13 बांग्लादेश बांग्लादेश 13 बांग्लादेश बांग्लादेश 13 बांग्लादेश बांग्लादेश 13 बांग्लादेश बांग्लादेश 13 बांग्लादेश बांग्लादेश 13 बांग्लादेश बांग्लादेश 13 4 5  29 30 30 13 13 44 4546 4748 4950
class RTDETRDataset(YOLODataset):
    """
    Real-Time DEtection and TRacking (RT-DETR) dataset class extending the base YOLODataset class.

    This specialized dataset class is designed for use with the RT-DETR object detection model and is optimized for
    real-time detection and tracking tasks.
    """

    def __init__(self, *args, data=None, **kwargs):
        """Initialize the RTDETRDataset class by inheriting from the YOLODataset class."""
        super().__init__(*args, data=data, **kwargs)

    # NOTE: add stretch version load_image for RTDETR mosaic
    def load_image(self, i, rect_mode=False):
        """Loads 1 image from dataset index 'i', returns (im, resized hw)."""
        return super().load_image(i=i, rect_mode=rect_mode)

    def build_transforms(self, hyp=None):
        """Temporary, only for evaluation."""
        if self.augment:
            hyp.mosaic = hyp.mosaic if self.augment and not self.rect else 0.0
            hyp.mixup = hyp.mixup if self.augment and not self.rect else 0.0
            transforms = v8_transforms(self, self.imgsz, hyp, stretch=True)
        else:
            # transforms = Compose([LetterBox(new_shape=(self.imgsz, self.imgsz), auto=False, scaleFill=True)])
            transforms = Compose([])
        transforms.append(
            Format(
                bbox_format="xywh",
                normalize=True,
                return_mask=self.use_segments,
                return_keypoint=self.use_keypoints,
                batch_idx=True,
                mask_ratio=hyp.mask_ratio,
                mask_overlap=hyp.overlap_mask,
            )
        )
        return transforms

__init__(*args, data=None, **kwargs)

YOLODataset वर्ग से इनहेरिट करके RTDETRDataset वर्ग प्रारंभ करें।

में स्रोत कोड ultralytics/models/rtdetr/val.py
def __init__(self, *args, data=None, **kwargs):
    """Initialize the RTDETRDataset class by inheriting from the YOLODataset class."""
    super().__init__(*args, data=data, **kwargs)

build_transforms(hyp=None)

अस्थायी, केवल मूल्यांकन के लिए।

में स्रोत कोड ultralytics/models/rtdetr/val.py
30 बांग्लादेश 30 बांग्लादेश 31 32 33 34 35 36 37 38 39 40 41424344454647484950
def build_transforms(self, hyp=None):
    """Temporary, only for evaluation."""
    if self.augment:
        hyp.mosaic = hyp.mosaic if self.augment and not self.rect else 0.0
        hyp.mixup = hyp.mixup if self.augment and not self.rect else 0.0
        transforms = v8_transforms(self, self.imgsz, hyp, stretch=True)
    else:
        # transforms = Compose([LetterBox(new_shape=(self.imgsz, self.imgsz), auto=False, scaleFill=True)])
        transforms = Compose([])
    transforms.append(
        Format(
            bbox_format="xywh",
            normalize=True,
            return_mask=self.use_segments,
            return_keypoint=self.use_keypoints,
            batch_idx=True,
            mask_ratio=hyp.mask_ratio,
            mask_overlap=hyp.overlap_mask,
        )
    )
    return transforms

load_image(i, rect_mode=False)

डेटासेट इंडेक्स 'i' से 1 छवि लोड करता है, रिटर्न (im, आकार hw)।

में स्रोत कोड ultralytics/models/rtdetr/val.py
def load_image(self, i, rect_mode=False):
    """Loads 1 image from dataset index 'i', returns (im, resized hw)."""
    return super().load_image(i=i, rect_mode=rect_mode)



ultralytics.models.rtdetr.val.RTDETRValidator

Bases: DetectionValidator

RTDETRValidator विशेष रूप से अनुरूप सत्यापन क्षमताओं को प्रदान करने के लिए DetectionValidator वर्ग का विस्तार करता है वही RT-DETR (रीयल-टाइम DETR) ऑब्जेक्ट डिटेक्शन मॉडल।

वर्ग सत्यापन के लिए RTDETR- विशिष्ट डेटासेट के निर्माण की अनुमति देता है, के लिए गैर-अधिकतम दमन लागू करता है पोस्ट-प्रोसेसिंग, और तदनुसार मूल्यांकन मेट्रिक्स अपडेट करता है।

उदाहरण
from ultralytics.models.rtdetr import RTDETRValidator

args = dict(model='rtdetr-l.pt', data='coco8.yaml')
validator = RTDETRValidator(args=args)
validator()
नोट

विशेषताओं और विधियों के बारे में अधिक जानकारी के लिए, पैरेंट DetectionValidator क्लास देखें।

में स्रोत कोड ultralytics/models/rtdetr/val.py
53 54 55 56 57 58  59 60 61 62 63 64 65 66 67  68 69 70  71 72 73 74  75 76 77 78             79 80 81  82 83   84 85  86       87  88 89 90 91 92 93 94 95 96 97 98  99 100 101 102 103 104 105 106 107 108  109   110 111  112 113 114 115  116 117 118 119 120 121 122 123 124 125 126 127 128129 130131132
class RTDETRValidator(DetectionValidator):
    """
    RTDETRValidator extends the DetectionValidator class to provide validation capabilities specifically tailored for
    the RT-DETR (Real-Time DETR) object detection model.

    The class allows building of an RTDETR-specific dataset for validation, applies Non-maximum suppression for
    post-processing, and updates evaluation metrics accordingly.

    Example:
        ```python
        from ultralytics.models.rtdetr import RTDETRValidator

        args = dict(model='rtdetr-l.pt', data='coco8.yaml')
        validator = RTDETRValidator(args=args)
        validator()
        ```

    Note:
        For further details on the attributes and methods, refer to the parent DetectionValidator class.
    """

    def build_dataset(self, img_path, mode="val", batch=None):
        """
        Build an RTDETR Dataset.

        Args:
            img_path (str): Path to the folder containing images.
            mode (str): `train` mode or `val` mode, users are able to customize different augmentations for each mode.
            batch (int, optional): Size of batches, this is for `rect`. Defaults to None.
        """
        return RTDETRDataset(
            img_path=img_path,
            imgsz=self.args.imgsz,
            batch_size=batch,
            augment=False,  # no augmentation
            hyp=self.args,
            rect=False,  # no rect
            cache=self.args.cache or None,
            prefix=colorstr(f"{mode}: "),
            data=self.data,
        )

    def postprocess(self, preds):
        """Apply Non-maximum suppression to prediction outputs."""
        bs, _, nd = preds[0].shape
        bboxes, scores = preds[0].split((4, nd - 4), dim=-1)
        bboxes *= self.args.imgsz
        outputs = [torch.zeros((0, 6), device=bboxes.device)] * bs
        for i, bbox in enumerate(bboxes):  # (300, 4)
            bbox = ops.xywh2xyxy(bbox)
            score, cls = scores[i].max(-1)  # (300, )
            # Do not need threshold for evaluation as only got 300 boxes here
            # idx = score > self.args.conf
            pred = torch.cat([bbox, score[..., None], cls[..., None]], dim=-1)  # filter
            # Sort by confidence to correctly get internal metrics
            pred = pred[score.argsort(descending=True)]
            outputs[i] = pred  # [idx]

        return outputs

    def _prepare_batch(self, si, batch):
        """Prepares a batch for training or inference by applying transformations."""
        idx = batch["batch_idx"] == si
        cls = batch["cls"][idx].squeeze(-1)
        bbox = batch["bboxes"][idx]
        ori_shape = batch["ori_shape"][si]
        imgsz = batch["img"].shape[2:]
        ratio_pad = batch["ratio_pad"][si]
        if len(cls):
            bbox = ops.xywh2xyxy(bbox)  # target boxes
            bbox[..., [0, 2]] *= ori_shape[1]  # native-space pred
            bbox[..., [1, 3]] *= ori_shape[0]  # native-space pred
        return dict(cls=cls, bbox=bbox, ori_shape=ori_shape, imgsz=imgsz, ratio_pad=ratio_pad)

    def _prepare_pred(self, pred, pbatch):
        """Prepares and returns a batch with transformed bounding boxes and class labels."""
        predn = pred.clone()
        predn[..., [0, 2]] *= pbatch["ori_shape"][1] / self.args.imgsz  # native-space pred
        predn[..., [1, 3]] *= pbatch["ori_shape"][0] / self.args.imgsz  # native-space pred
        return predn.float()

build_dataset(img_path, mode='val', batch=None)

RTDETR डेटासेट बनाएँ।

पैरामीटर:

नाम प्रकार विवरण: __________ चूक
img_path str

छवियों वाले फ़ोल्डर का पथ।

आवश्यक
mode str

train mode या val मोड, उपयोगकर्ता प्रत्येक मोड के लिए अलग-अलग वृद्धि को अनुकूलित करने में सक्षम हैं।

'val'
batch int

बैचों का आकार, यह rect. कोई नहीं करने के लिए डिफ़ॉल्ट।

None
में स्रोत कोड ultralytics/models/rtdetr/val.py
74 75 76 77 78 79 80 81 82 83 848586878889 909192 93
def build_dataset(self, img_path, mode="val", batch=None):
    """
    Build an RTDETR Dataset.

    Args:
        img_path (str): Path to the folder containing images.
        mode (str): `train` mode or `val` mode, users are able to customize different augmentations for each mode.
        batch (int, optional): Size of batches, this is for `rect`. Defaults to None.
    """
    return RTDETRDataset(
        img_path=img_path,
        imgsz=self.args.imgsz,
        batch_size=batch,
        augment=False,  # no augmentation
        hyp=self.args,
        rect=False,  # no rect
        cache=self.args.cache or None,
        prefix=colorstr(f"{mode}: "),
        data=self.data,
    )

postprocess(preds)

भविष्यवाणी आउटपुट पर गैर-अधिकतम दमन लागू करें।

में स्रोत कोड ultralytics/models/rtdetr/val.py
95 96 97  98 99 100 101 102 103 104  105 106 107 108 109 110111
def postprocess(self, preds):
    """Apply Non-maximum suppression to prediction outputs."""
    bs, _, nd = preds[0].shape
    bboxes, scores = preds[0].split((4, nd - 4), dim=-1)
    bboxes *= self.args.imgsz
    outputs = [torch.zeros((0, 6), device=bboxes.device)] * bs
    for i, bbox in enumerate(bboxes):  # (300, 4)
        bbox = ops.xywh2xyxy(bbox)
        score, cls = scores[i].max(-1)  # (300, )
        # Do not need threshold for evaluation as only got 300 boxes here
        # idx = score > self.args.conf
        pred = torch.cat([bbox, score[..., None], cls[..., None]], dim=-1)  # filter
        # Sort by confidence to correctly get internal metrics
        pred = pred[score.argsort(descending=True)]
        outputs[i] = pred  # [idx]

    return outputs





2023-11-12 बनाया गया, अपडेट किया गया 2023-11-25
लेखक: ग्लेन-जोचर (3), लाफिंग-क्यू (1)