Skip to content

Référence pour ultralytics/models/rtdetr/val.py

Note

Ce fichier est disponible à l'adresse https://github.com/ultralytics/ ultralytics/blob/main/ ultralytics/models/rtdetr/val .py. Si tu repères un problème, aide à le corriger en contribuant à une Pull Request 🛠️. Merci 🙏 !



ultralytics.models.rtdetr.val.RTDETRDataset

Bases : YOLODataset

Classe de jeu de données de détection et de suivi en temps réel (RT-DETR) étendant la classe de jeu de données YOLOD de base.

Cette classe de données spécialisée est conçue pour être utilisée avec le modèle de détection d'objets RT-DETR et est optimisée pour les tâches de détection et de suivi en temps réel. pour les tâches de détection et de suivi en temps réel.

Code source dans ultralytics/models/rtdetr/val.py
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)

Initialise la classe RTDETRDataset en héritant de la classe YOLODataset.

Code source dans 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)

Temporaire, uniquement pour l'Ă©valuation.

Code source dans ultralytics/models/rtdetr/val.py
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)

Charge 1 image à partir de l'index 'i' de l'ensemble de données, renvoie (im, hw redimensionné).

Code source dans 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 étend la classe DetectionValidator pour fournir des capacités de validation spécifiquement adaptées au modèle de détection d'objets en temps réel (DETR). pour le modèle de détection d'objets RT-DETR (Real-Time DETR).

La classe permet de construire un ensemble de données spécifique à RTDETR pour la validation, applique la suppression du non-maximum pour le post-traitement et met à jour les mesures d'évaluation en conséquence. pour le post-traitement, et met à jour les mesures d'évaluation en conséquence.

Exemple
from ultralytics.models.rtdetr import RTDETRValidator

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

Pour plus de détails sur les attributs et les méthodes, reporte-toi à la classe parentale DetectionValidator.

Code source dans ultralytics/models/rtdetr/val.py
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)

Construire un ensemble de données RTDETR.

Paramètres :

Nom Type Description DĂ©faut
img_path str

Chemin d'accès au dossier contenant les images.

requis
mode str

train ou val les utilisateurs peuvent personnaliser différentes augmentations pour chaque mode.

'val'
batch int

Taille des lots, c'est pour rect. La valeur par défaut est Aucun.

None
Code source dans ultralytics/models/rtdetr/val.py
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)

Applique une suppression non maximale aux sorties de prédiction.

Code source dans ultralytics/models/rtdetr/val.py
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





Créé le 2023-11-12, Mis à jour le 2023-11-25
Auteurs : glenn-jocher (3), Laughing-q (1)