Transformers documentation

RT-DETR

Transformers

Commencer

Transformers Installation Démarrage rapide

Classes de base

Modèles

Préprocesseurs

Inférence

API Pipeline

Générer l'API

Optimisation

Discuter avec des modèles

Mise en production

Entraînement

Commencer

Personnalisation

Ajustement fin efficace en termes de paramètres

Performance

Entraînement distribué

Matériel

Quantification

Intégrations à l'écosystème

Ressources

API

Classes principales

Modèles

Modèles de texte

Modèles de vision

Modèles audio

Modèles vidéo

Modèles multimodaux

Modèles d'apprentissage par renforcement

Modèles de séries temporelles

Aides internes

Référence

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.1).

Join the Hugging Face community

and get access to the augmented documentation experience

Collaborate on models, datasets and Spaces

Faster examples with accelerated inference

Switch between documentation themes

to get started

Ce modèle a été publié dans HF papers le 2023-04-17 et ajouté à Hugging Face Transformers le 2024-06-22.

RT-DETR

Aperçu

Le modèle RT-DETR a été proposé dans DETRs Beat YOLOs on Real-time Object Detection par Wenyu Lv, Yian Zhao, Shangliang Xu, Jinman Wei, Guanzhong Wang, Cheng Cui, Yuning Du, Qingqing Dang, Yi Liu.

RT-DETR est un modèle de détection d'objets dont l'acronyme signifie « Real-Time DEtection Transformer ». Ce modèle est conçu pour effectuer des tâches de détection d'objets en mettant l'accent sur l'obtention de performances en temps réel tout en maintenant une haute précision. En s'appuyant sur l'architecture transformer, qui a gagné une popularité considérable dans divers domaines de l'apprentissage profond, RT-DETR traite les images afin d'identifier et de localiser plusieurs objets présents en leur sein.

L'abstract de l'article est le suivant :

Récemment, les détecteurs basés sur des transformers de bout en bout (DETR) ont atteint des performances remarquables. Cependant, le problème du coût de calcul élevé des DETR n'a pas été traité de manière efficace, ce qui limite leur application pratique et les empêche de tirer pleinement parti des avantages de l'absence de post-traitement, tels que la suppression du maximum non maximal (NMS). Dans cet article, nous analysons d'abord l'influence du NMS sur la vitesse d'inférence des détecteurs d'objets en temps réel modernes, et nous établissons un benchmark de vitesse de bout en bout. Pour éviter le délai d'inférence causé par le NMS, nous proposons un Real-Time DEtection TRansformer (RT-DETR), le premier détecteur d'objets en temps réel de bout en bout à notre connaissance. Plus précisément, nous concevons un encodeur hybride efficace pour traiter efficacement les caractéristiques multi-échelles en découplant l'interaction intra-échelle et la fusion inter-échelles, et nous proposons une sélection de requêtes sensible à l'IoU pour améliorer l'initialisation des requêtes d'objets. En outre, notre détecteur proposé permet un ajustement flexible de la vitesse d'inférence en utilisant différentes couches de décodeur sans avoir besoin de réentraîner, ce qui facilite l'application pratique des détecteurs d'objets en temps réel. Notre RT-DETR-L atteint 53,0 % d'AP sur COCO val2017 et 114 FPS sur GPU T4, tandis que RT-DETR-X atteint 54,8 % d'AP et 74 FPS, surpassant tous les détecteurs YOLO de la même échelle en termes de vitesse et de précision. De plus, notre RT-DETR-R50 atteint 53,1 % d'AP et 108 FPS, surpassant DINO-Deformable-DETR-R50 de 2,2 % d'AP en précision et d'environ 21 fois en FPS.

RT-DETR performance relative to YOLO models. Taken from the original paper.

La version du modèle a été proposée par rafaelpadilla et sangbumchoi. Le code d'origine est disponible ici.

Conseils d'utilisation

Initialement, une image est traitée à l'aide d'un réseau de neurones convolutif pré-entraîné, plus précisément une variante Resnet-D, comme indiqué dans le code d'origine. Ce réseau extrait les caractéristiques des trois dernières couches de l'architecture. Ensuite, un encodeur hybride est utilisé pour convertir les caractéristiques multi-échelles en un tableau séquentiel de caractéristiques d'image. Puis, un décodeur, équipé de têtes de prédiction auxiliaires, est employé pour affiner les requêtes d'objets. Ce processus permet la génération directe des boîtes englobantes, éliminant le besoin de tout post-traitement supplémentaire pour obtenir les logits et les coordonnées des boîtes englobantes. Le modèle est conçu pour être utilisé sur des images redimensionnées à la taille 640x640 avec l'ImageProcessor correspondant. Le redimensionnement vers d'autres tailles dégradera généralement les performances.

import requests
import torch
from PIL import Image

from transformers import RTDetrForObjectDetection, RTDetrImageProcessor


url = 'http://images.cocodataset.org/val2017/000000039769.jpg'
image = Image.open(requests.get(url, stream=True).raw)

image_processor = RTDetrImageProcessor.from_pretrained("PekingU/rtdetr_r50vd")
model = RTDetrForObjectDetection.from_pretrained("PekingU/rtdetr_r50vd", device_map="auto")

inputs = image_processor(images=image, return_tensors="pt").to(model.device)

with torch.no_grad():
    outputs = model(**inputs)

results = image_processor.post_process_object_detection(outputs, target_sizes=torch.tensor([(image.height, image.width)]), threshold=0.3)

for result in results:
    for score, label_id, box in zip(result["scores"], result["labels"], result["boxes"]):
        score, label = score.item(), label_id.item()
        box = [round(i, 2) for i in box.tolist()]
        print(f"{model.config.id2label[label]}: {score:.2f} {box}")
sofa: 0.97 [0.14, 0.38, 640.13, 476.21]
cat: 0.96 [343.38, 24.28, 640.14, 371.5]
cat: 0.96 [13.23, 54.18, 318.98, 472.22]
remote: 0.95 [40.11, 73.44, 175.96, 118.48]
remote: 0.92 [333.73, 76.58, 369.97, 186.99]

Ressources

Une liste de ressources officielles de Hugging Face et de la communauté (indiquées par 🌎) pour vous aider à démarrer avec RT-DETR.

Object Detection

Voir aussi : Guide de la tâche de détection d'objets.
Des notebooks concernant l’inférence et l’ajustement fin de RT-DETR sur un jeu de données personnalisé sont disponibles ici. 🌎

RTDetrConfig

classe transformers.RTDetrConfig

< source >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0id2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Noneis_encoder_decoder: bool = Trueinitializer_range: float = 0.01initializer_bias_prior_prob: float | None = Nonelayer_norm_eps: float = 1e-05batch_norm_eps: float = 1e-05backbone_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonefreeze_backbone_batch_norms: bool = Trueencoder_hidden_dim: int = 256encoder_in_channels: list[int] | tuple[int, ...] = (512, 1024, 2048)feat_strides: list[int] | tuple[int, ...] = (8, 16, 32)encoder_layers: int = 1encoder_ffn_dim: int = 1024encoder_attention_heads: int = 8dropout: float | int = 0.0activation_dropout: float | int = 0.0encode_proj_layers: list[int] | tuple[int, ...] = (2,)positional_encoding_temperature: int = 10000encoder_activation_function: str = 'gelu'activation_function: str = 'silu'eval_size: int | None = Nonenormalize_before: bool = Falsehidden_expansion: float = 1.0d_model: int = 256num_queries: int = 300decoder_in_channels: list[int] | tuple[int, ...] = (256, 256, 256)decoder_ffn_dim: int = 1024num_feature_levels: int = 3decoder_n_points: int = 4decoder_layers: int = 6decoder_attention_heads: int = 8decoder_activation_function: str = 'relu'attention_dropout: float | int = 0.0num_denoising: int = 100label_noise_ratio: float = 0.5box_noise_scale: float = 1.0learn_initial_query: bool = Falseanchor_image_size: int | list[int] | None = Nonedisable_custom_kernels: bool = Truewith_box_refine: bool = Truematcher_alpha: float = 0.25matcher_gamma: float = 2.0matcher_class_cost: float = 2.0matcher_bbox_cost: float = 5.0matcher_giou_cost: float = 2.0use_focal_loss: bool = Trueauxiliary_loss: bool = Truefocal_loss_alpha: float = 0.75focal_loss_gamma: float = 2.0weight_loss_vfl: float = 1.0weight_loss_bbox: float = 5.0weight_loss_giou: float = 2.0eos_coefficient: float = 0.0001 )

Paramètres

is_encoder_decoder (bool, facultatif, valeur par défaut True) — Indique si le modèle est utilisé comme encodeur/décodeur ou non.
initializer_range (float, facultatif, par défaut 0.01) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser toutes les matrices de poids.
initializer_bias_prior_prob (float, facultatif) — La probabilité a priori utilisée par l’initialiseur de biais pour initialiser les biais de enc_score_head et class_embed. Si None, prior_prob est calculé comme prior_prob = 1 / (num_labels + 1) lors de l’initialisation des poids du modèle.
layer_norm_eps (float, facultatif, valeur par défaut 1e-05) — L'épsilon utilisé par les couches de normalisation de couche.
batch_norm_eps (float, facultatif, valeur par défaut 1e-05) — L'épsilon utilisé par les couches de normalisation par lot.
backbone_config (Union[dict, ~configuration_utils.PreTrainedConfig], facultatif) — La configuration du modèle backbone.
freeze_backbone_batch_norms (bool, facultatif, valeur par défaut True) — Indique s'il faut figer les couches de normalisation par lot dans le backbone.
encoder_hidden_dim (int, facultatif, par défaut 256) — Dimension des représentations cachées.
encoder_in_channels (list, facultatif, par défaut [512, 1024, 2048]) — Entrées de caractéristiques multi-niveaux pour l’encodeur.
feat_strides (list[int], facultatif, par défaut [8, 16, 32]) — Pas utilisés dans chaque carte de caractéristiques.
encoder_layers (int, facultatif, valeur par défaut 1) — Nombre de couches cachées dans l’encodeur Transformer. Utilise la même valeur que num_layers si non défini.
encoder_ffn_dim (int, facultatif, par défaut 1024) — Dimension de la couche « intermédiaire » (souvent appelée couche feed-forward) de l’encodeur.
encoder_attention_heads (int, facultatif, valeur par défaut 8) — Nombre de têtes d'attention pour chaque couche d'attention dans l'encodeur Transformer.
dropout (Union[float, int], facultatif, par défaut 0.0) — Le taux appliqué à toutes les couches de dropout.
activation_dropout (Union[float, int], facultatif, valeur par défaut 0.0) — Le taux de dropout appliqué aux activations à l'intérieur de la couche entièrement connectée.
encode_proj_layers (list[int], facultatif, par défaut [2]) — Indices des couches projetées à utiliser dans l'encodeur.
positional_encoding_temperature (int, facultatif, valeur par défaut 10000) — Le paramètre de température utilisé pour créer les encodages positionnels.
encoder_activation_function (str, facultatif, par défaut "gelu") — La fonction d'activation non linéaire (fonction ou chaîne de caractères) dans l'encodeur et le pooler. Si c'est une chaîne de caractères, "gelu", "relu", "silu" et "gelu_new" sont pris en charge.
activation_function (str, facultatif, par défaut silu) — La fonction d'activation non linéaire (fonction ou chaîne de caractères) du décodeur. Par exemple, "gelu", "relu", "silu", etc.
eval_size (tuple[int, int], facultatif) — Hauteur et largeur utilisées pour calculer la hauteur et la largeur effectives des embeddings de position après prise en compte du pas (stride).
normalize_before (bool, facultatif, par défaut False) — Détermine si la normalisation par couche doit être appliquée dans la couche d'encodeur du transformer avant les modules d'auto-attention et de réseau de neurones à propagation avant.
hidden_expansion (float, facultatif, valeur par défaut 1.0) — Ratio d'expansion pour agrandir la taille de la dimension de RepVGGBlock et CSPRepLayer.
d_model (int, facultatif, par défaut 256) — Taille des couches encodeur et de la couche pooler.
num_queries (int, facultatif, valeur par défaut 300) — Nombre de requêtes d'objets.
decoder_in_channels (list, facultatif, par défaut [256, 256, 256]) — Dimensions des caractéristiques multi-niveaux pour le décodeur
decoder_ffn_dim (int, facultatif, valeur par défaut 1024) — Dimension de la couche « intermédiaire » (souvent appelée couche feed-forward) du décodeur.
num_feature_levels (int, facultatif, valeur par défaut 3) — Le nombre de niveaux de caractéristiques d'entrée.
decoder_n_points (int, facultatif, valeur par défaut 4) — Le nombre de clés échantillonnées à chaque niveau de fonctionnalités pour chaque tête d’attention du décodeur.
decoder_layers (int, facultatif, valeur par défaut 6) — Nombre de couches cachées dans le décodeur Transformer. Utilise la même valeur que num_layers si non défini.
decoder_attention_heads (int, facultatif, valeur par défaut 8) — Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer.
decoder_activation_function (str, facultatif, par défaut "relu") — La fonction d’activation non linéaire (fonction ou chaîne de caractères) du décodeur. Si c’est une chaîne de caractères, "gelu", "relu", "silu" et "gelu_new" sont pris en charge.
attention_dropout (Union[float, int], facultatif, valeur par défaut 0.0) — Le taux de dropout appliqué aux probabilités d'attention.
num_denoising (int, facultatif, valeur par défaut 100) — Nombre total de tâches ou de requêtes de débruitage à utiliser pour le débruitage contrastif.
label_noise_ratio (float, facultatif, valeur par défaut 0.5) — La proportion d'étiquettes de débruitage auxquelles du bruit aléatoire doit être ajouté.
box_noise_scale (float, facultatif, valeur par défaut 1.0) — Échelle ou amplitude du bruit à ajouter aux boîtes englobantes.
learn_initial_query (bool, facultatif, par défaut False) — Indique si les embeddings de requête initiaux du décodeur doivent être appris pendant l’entraînement
anchor_image_size (tuple[int, int], facultatif) — Hauteur et largeur de l'image d'entrée utilisée lors de l'évaluation pour générer les ancres de boîtes englobantes. Si None, la génération automatique des ancres est appliquée.
disable_custom_kernels (bool, facultatif, valeur par défaut True) — Indique s'il faut désactiver les noyaux personnalisés.
with_box_refine (bool, facultatif, valeur par défaut True) — Indique s'il faut appliquer un raffinement itératif des boîtes englobantes, où chaque couche du décodeur affine les boîtes englobantes sur la base des prédictions de la couche précédente.
matcher_alpha (float, facultatif, valeur par défaut 0.25) — Paramètre alpha utilisé par le Hungarian Matcher.
matcher_gamma (float, facultatif, valeur par défaut 2.0) — Paramètre gamma utilisé par le Hungarian Matcher.
matcher_class_cost (float, facultatif, valeur par défaut 2.0) — Le poids relatif de la perte de classe utilisé par le Hungarian Matcher.
matcher_bbox_cost (float, facultatif, valeur par défaut 5.0) — Le poids relatif de la perte de boîte englobante utilisé par le Matcher hongrois.
matcher_giou_cost (float, facultatif, valeur par défaut 2.0) — Le poids relatif de la perte giou utilisée par le Hungarian Matcher.
use_focal_loss (bool, facultatif, valeur par défaut True) — Paramètre indiquant si la focal loss doit être utilisée.
auxiliary_loss (bool, facultatif, par défaut True) — Indique si les pertes de décodage auxiliaires (pertes à chaque couche du décodeur) doivent être utilisées.
focal_loss_alpha (float, facultatif, valeur par défaut 0.75) — Paramètre alpha utilisé pour calculer la focal loss.
focal_loss_gamma (float, facultatif, valeur par défaut 2.0) — Paramètre gamma utilisé pour calculer la focal loss.
weight_loss_vfl (float, facultatif, valeur par défaut 1.0) — Poids relatif de la perte varifocal dans la perte de détection d'objets.
weight_loss_bbox (float, facultatif, valeur par défaut 5.0) — Poids relatif de la perte de boîte englobante L1 dans la perte de détection d'objets.
weight_loss_giou (float, facultatif, valeur par défaut 2.0) — Poids relatif de la perte d'IoU généralisée dans la perte de détection d'objets.
eos_coefficient (float, facultatif, par défaut 0.0001) — Poids de classification relatif de la classe « no-object » dans la perte de détection d’objets.

Ceci est la classe de configuration destinée à stocker la configuration d'un RTDetrModel. Elle est utilisée pour instancier un modèle Rt Detr en fonction des arguments spécifiés, en définissant l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de PekingU/rtdetr_r50vd

Les objets de configuration héritent de PreTrainedConfig et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de PreTrainedConfig pour plus d’informations.

Exemples :

>>> from transformers import RTDetrConfig, RTDetrModel

>>> # Initializing a RT-DETR configuration
>>> configuration = RTDetrConfig()

>>> # Initializing a model (with random weights) from the configuration
>>> model = RTDetrModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

RTDetrResNetConfig

classe transformers.RTDetrResNetConfig

< source >

Paramètres

num_channels (int, facultatif, par défaut 3) — Le nombre de canaux d'entrée.
embedding_size (int, facultatif, par défaut 64) — Dimension des embeddings et des états cachés.
hidden_sizes (Union[list[int], tuple[int, ...]], facultatif, par défaut (256, 512, 1024, 2048)) — Dimension (taille cachée) à chaque étape du modèle.
depths (list[int], facultatif, par défaut [3, 4, 6, 3]) — Profondeur (nombre de couches) de chaque étape.
layer_type (str, facultatif, par défaut "bottleneck") — La couche à utiliser, qui peut être "basic" (utilisée pour les modèles plus petits, comme resnet-18 ou resnet-34) ou "bottleneck" (utilisée pour les modèles plus grands, comme resnet-50 et au-delà).
hidden_act (str, facultatif, par défaut "relu") — Fonction d’activation non linéaire de chaque bloc. Si c’est une chaîne, "gelu", "relu", "selu" et "gelu_new" sont pris en charge.
downsample_in_first_stage (bool, facultatif, valeur par défaut False) — Si True, la première étape effectue un sous-échantillonnage des entrées avec un stride de 2.
downsample_in_bottleneck (bool, facultatif, valeur par défaut False) — Si True, la première convolution 1x1 de ResNetBottleNeckLayer effectue un sous-échantillonnage des entrées en utilisant un stride de 2.

Ceci est la classe de configuration destinée à stocker la configuration d'un modèle Rt Detr Resnet. Elle est utilisée pour instancier un modèle Rt Detr Resnet en fonction des arguments spécifiés, en définissant l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de microsoft/resnet-50

Les objets de configuration héritent de PreTrainedConfig et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de PreTrainedConfig pour plus d’informations.

Exemple :

>>> from transformers import RTDetrResNetConfig, RTDetrResnetBackbone

>>> # Initializing a ResNet resnet-50 style configuration
>>> configuration = RTDetrResNetConfig()

>>> # Initializing a model (with random weights) from the resnet-50 style configuration
>>> model = RTDetrResnetBackbone(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

RTDetrImageProcessor

classe transformers.RTDetrImageProcessor

< source >

( **kwargs: *<class 'transformers.models.rt_detr.image_processing_rt_detr.RTDetrImageProcessorKwargs'> )

Paramètres

do_convert_rgb (bool, kwargs, facultatif) — Indique s'il faut convertir l'image en RGB.
do_resize (bool, kwargs, facultatif, valeur par défaut True) — Indique s'il faut redimensionner l'image.
size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs, par défaut {'height' -- 640, 'width': 640}) : Définit les dimensions d'entrée maximales du modèle.
default_to_square (bool, kwargs, facultatif, valeur par défaut False) — Indique s'il faut utiliser une image carrée par défaut lors du redimensionnement, si size est un entier.
crop_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Taille de l'image de sortie après application de center_crop.
resample (Annotated[Union[int, PILImageResampling, NoneType], None], kwargs, par défaut 2) — Filtre de rééchantillonnage à utiliser lors du redimensionnement de l’image. Il peut s’agir de l’une des valeurs de l’enum PILImageResampling. N’a un effet que si do_resize est défini sur True.
do_rescale (bool, kwargs, facultatif, par défaut True) — Indique s'il faut rééchelonner l'image.
rescale_factor (float, kwargs, facultatif, valeur par défaut 0.00392156862745098) — Facteur de remise à l'échelle appliqué à l'image si do_rescale est défini sur True.
do_normalize (bool, kwargs, facultatif, valeur par défaut False) — Indique s'il faut normaliser l'image.
image_mean (Union[float, list[float], tuple[float, ...]], kwargs, facultatif, valeur par défaut [0.485, 0.456, 0.406]) — Moyenne de l'image à utiliser pour la normalisation. N'a un effet que si do_normalize est défini sur True.
image_std (Union[float, list[float], tuple[float, ...]], kwargs, facultatif, valeur par défaut [0.229, 0.224, 0.225]) — Écart-type de l'image à utiliser pour la normalisation. N'a un effet que si do_normalize est défini sur True.
do_pad (bool, kwargs, facultatif, valeur par défaut False) — Indique s'il faut appliquer un bourrage (padding) à l'image. Le bourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de bourrage exacte dépend du modèle.
pad_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — La taille au format {"height": int, "width" int} à laquelle les images doivent être remplies. Elle doit être supérieure à la taille de n'importe quelle image fournie pour la prétraitement. Si pad_size n'est pas fourni, les images seront remplies jusqu'à la hauteur et la largeur maximales du lot. Appliqué uniquement lorsque do_pad=True.
do_center_crop (bool, kwargs, facultatif) — Indique s'il faut effectuer un recadrage centré de l'image.
data_format (Union[str, ~image_utils.ChannelDimension], kwargs, facultatif) — Seul ChannelDimension.FIRST est pris en charge. Ajouté pour la compatibilité avec les processeurs lents.
input_data_format (Union[str, ~image_utils.ChannelDimension], kwargs, facultatif) — Le format de la dimension des canaux pour l'image d'entrée. Si non défini, le format de la dimension des canaux est déduit de l'image d'entrée. Peut être l'un des éléments suivants :
- "channels_first" ou ChannelDimension.FIRST : image au format (num_channels, height, width).
- "channels_last" ou ChannelDimension.LAST : image au format (hauteur, largeur, nombre de canaux).
- "none" ou ChannelDimension.NONE : image au format (hauteur, largeur).
device (Annotated[Union[str, torch.device, NoneType], None], kwargs) — L’appareil sur lequel traiter les vidéos. Si non défini, l’appareil est déduit des vidéos d’entrée.
return_tensors (Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Retourne des tenseurs empilés si défini sur 'pt', sinon retourne une liste de tenseurs.
disable_grouping (bool, kwargs, facultatif) — Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle est définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157
image_seq_length (int, kwargs, facultatif) — Le nombre de jetons d’image à utiliser pour chaque image de l’entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles.
format (str, kwargs, facultatif, par défaut AnnotationFormat.COCO_DETECTION) — Format des données des annotations. L’un des « coco_detection » ou « coco_panoptic ».
do_convert_annotations (bool, kwargs, facultatif, valeur par défaut True) — Contrôle la conversion des annotations au format attendu par le modèle RT_DETR. Convertit les boîtes englobantes au format (center_x, center_y, width, height) et dans l'intervalle [0, 1]. Peut être remplacé par le paramètre do_convert_annotations de la méthode preprocess.

Construit un processeur d’images RTDetrImageProcessor.

prétraiter

< source >

( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']]annotations: dict[str, int | str | list[dict]] | list[dict[str, int | str | list[dict]]] | None = Nonereturn_segmentation_masks: bool | None = Nonemasks_path: str | pathlib.Path | None = None**kwargs: *<class 'transformers.models.rt_detr.image_processing_rt_detr.RTDetrImageProcessorKwargs'> ) → ~image_processing_base.BatchFeature

Paramètres

images (Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]) — Image à prétraiter. S'attend à une image unique ou à un lot d'images dont les valeurs de pixels vont de 0 à 255. Si vous passez des images dont les valeurs de pixels sont comprises entre 0 et 1, définissez do_rescale=False.
annotations (AnnotationType ou list[AnnotationType], facultatif) — Annotations à transformer en fonction du bourrage appliqué aux images.
return_segmentation_masks (bool, facultatif, par défaut self.return_segmentation_masks) — Indique s'il faut retourner les masques de segmentation.
masks_path (str ou pathlib.Path, facultatif) — Chemin vers le répertoire contenant les masques de segmentation.
do_convert_rgb (bool, kwargs, facultatif) — Indique s'il faut convertir l'image en RGB.
do_resize (bool, kwargs, facultatif) — Indique s'il faut redimensionner l'image.
size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Définit les dimensions maximales des entrées du modèle.
default_to_square (bool, kwargs, facultatif) — Indique s'il faut par défaut redimensionner l'image en carré si la taille est un entier.
crop_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Taille de l'image de sortie après application de center_crop.
resample (Annotated[Union[int, PILImageResampling, NoneType], None], kwargs) — Filtre de rééchantillonnage à utiliser lors du redimensionnement de l’image. Il peut s’agir de l’une des valeurs de l’enum PILImageResampling. N’a un effet que si do_resize est défini sur True.
do_rescale (bool, kwargs, facultatif) — Indique s'il faut rééchelonner l'image.
rescale_factor (float, kwargs, facultatif) — Facteur de remise à l'échelle à appliquer à l'image si do_rescale est défini sur True.
do_normalize (bool, kwargs, facultatif) — Indique s'il faut normaliser l'image.
image_mean (Union[float, list[float], tuple[float, ...]], kwargs, facultatif) — Moyenne de l'image à utiliser pour la normalisation. N'a un effet que si do_normalize est défini sur True.
image_std (Union[float, list[float], tuple[float, ...]], kwargs, facultatif) — Écart-type de l'image à utiliser pour la normalisation. N'a un effet que si do_normalize est défini sur True.
do_pad (bool, kwargs, facultatif) — Indique s'il faut effectuer un bourrage (padding) de l'image. Le bourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de bourrage exacte dépend du modèle.
pad_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — La taille au format {"height": int, "width" int} à laquelle les images doivent être remplies. Elle doit être supérieure à la taille de n'importe quelle image fournie pour la prétraitement. Si pad_size n'est pas fourni, les images seront remplies jusqu'à la hauteur et la largeur maximales du lot. Appliqué uniquement lorsque do_pad=True.
do_center_crop (bool, kwargs, facultatif) — Indique s'il faut effectuer un recadrage centré de l'image.
data_format (Union[str, ~image_utils.ChannelDimension], kwargs, facultatif) — Seul ChannelDimension.FIRST est pris en charge. Ajouté pour la compatibilité avec les processeurs lents.
input_data_format (Union[str, ~image_utils.ChannelDimension], kwargs, facultatif) — Le format de la dimension des canaux pour l'image d'entrée. Si non défini, le format de la dimension des canaux est déduit de l'image d'entrée. Peut être l'un des éléments suivants :
- "channels_first" ou ChannelDimension.FIRST : image au format (num_channels, height, width).
- "channels_last" ou ChannelDimension.LAST : image au format (hauteur, largeur, nombre de canaux).
- "none" ou ChannelDimension.NONE : image au format (hauteur, largeur).
device (Annotated[Union[str, torch.device, NoneType], None], kwargs) — L’appareil sur lequel traiter les vidéos. Si non défini, l’appareil est déduit des vidéos d’entrée.
return_tensors (Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Retourne des tenseurs empilés si défini sur 'pt', sinon retourne une liste de tenseurs.
disable_grouping (bool, kwargs, facultatif) — Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle est définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157
image_seq_length (int, kwargs, facultatif) — Le nombre de jetons d’image à utiliser pour chaque image de l’entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles.
format (str, kwargs, facultatif, par défaut AnnotationFormat.COCO_DETECTION) — Format des données des annotations. L’un des « coco_detection » ou « coco_panoptic ».
do_convert_annotations (bool, kwargs, facultatif, valeur par défaut True) — Contrôle la conversion des annotations au format attendu par le modèle RT_DETR. Convertit les boîtes englobantes au format (center_x, center_y, width, height) et dans l'intervalle [0, 1]. Peut être remplacé par le paramètre do_convert_annotations de la méthode preprocess.

Retourne

~image_processing_base.BatchFeature

data (dict) — Dictionnaire de listes/tableaux/tenseurs renvoyé par la méthode call (« pixel_values », etc.).
tensor_type (Union[None, str, TensorType], facultatif) — Vous pouvez spécifier un tensor_type ici pour convertir les listes d'entiers en tenseurs PyTorch/Numpy lors de l'initialisation.

post_process_object_detection

< source >

( outputsthreshold: float = 0.5target_sizes: transformers.utils.generic.TensorType | list[tuple] = Noneuse_focal_loss: bool = True ) → list[Dict]

Paramètres

outputs (DetrObjectDetectionOutput) — Sorties brutes du modèle.
threshold (float, facultatif, par défaut 0.5) — Seuil de score pour conserver les prédictions de détection d'objets.
target_sizes (torch.Tensor ou list[tuple[int, int]], facultatif) — Tenseur de forme (batch_size, 2) ou liste de tuples (tuple[int, int]) contenant la taille cible (height, width) de chaque image du lot. Si non défini, les prédictions ne seront pas redimensionnées.
use_focal_loss (bool, par défaut True) — Variable indiquant si la focal loss a été utilisée pour prédire les sorties. Si True, une fonction sigmoïde est appliquée pour calculer les scores de chaque détection, sinon, une fonction softmax est utilisée.

Retourne

list[Dict]

Une liste de dictionnaires, chaque dictionnaire contenant les scores, les étiquettes et les boîtes pour une image du lot, tels que prédits par le modèle.

Convertit la sortie brute de DetrForObjectDetection en boîtes englobantes finales au format (top_left_x, top_left_y, bottom_right_x, bottom_right_y). Prend uniquement en charge PyTorch.

RTDetrImageProcessorPil

classe transformers.RTDetrImageProcessorPil

< source >

( **kwargs: *<class 'transformers.models.rt_detr.image_processing_pil_rt_detr.RTDetrImageProcessorKwargs'> )

Paramètres

do_convert_rgb (bool, kwargs, facultatif) — Indique s'il faut convertir l'image en RGB.
do_resize (bool, kwargs, facultatif, valeur par défaut True) — Indique s'il faut redimensionner l'image.
size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs, par défaut {'height' -- 640, 'width': 640}) : Définit les dimensions d'entrée maximales du modèle.
default_to_square (bool, kwargs, facultatif, valeur par défaut False) — Indique s'il faut utiliser une image carrée par défaut lors du redimensionnement, si size est un entier.
crop_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Taille de l'image de sortie après application de center_crop.
resample (Annotated[Union[int, PILImageResampling, NoneType], None], kwargs, par défaut 2) — Filtre de rééchantillonnage à utiliser lors du redimensionnement de l’image. Il peut s’agir de l’une des valeurs de l’enum PILImageResampling. N’a un effet que si do_resize est défini sur True.
do_rescale (bool, kwargs, facultatif, par défaut True) — Indique s'il faut rééchelonner l'image.
rescale_factor (float, kwargs, facultatif, valeur par défaut 0.00392156862745098) — Facteur de remise à l'échelle appliqué à l'image si do_rescale est défini sur True.
do_normalize (bool, kwargs, facultatif, valeur par défaut False) — Indique s'il faut normaliser l'image.
image_mean (Union[float, list[float], tuple[float, ...]], kwargs, facultatif, valeur par défaut [0.485, 0.456, 0.406]) — Moyenne de l'image à utiliser pour la normalisation. N'a un effet que si do_normalize est défini sur True.
image_std (Union[float, list[float], tuple[float, ...]], kwargs, facultatif, valeur par défaut [0.229, 0.224, 0.225]) — Écart-type de l'image à utiliser pour la normalisation. N'a un effet que si do_normalize est défini sur True.
do_pad (bool, kwargs, facultatif, valeur par défaut False) — Indique s'il faut appliquer un bourrage (padding) à l'image. Le bourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de bourrage exacte dépend du modèle.
pad_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — La taille au format {"height": int, "width" int} à laquelle les images doivent être remplies. Elle doit être supérieure à la taille de n'importe quelle image fournie pour la prétraitement. Si pad_size n'est pas fourni, les images seront remplies jusqu'à la hauteur et la largeur maximales du lot. Appliqué uniquement lorsque do_pad=True.
do_center_crop (bool, kwargs, facultatif) — Indique s'il faut effectuer un recadrage centré de l'image.
data_format (Union[str, ~image_utils.ChannelDimension], kwargs, facultatif) — Seul ChannelDimension.FIRST est pris en charge. Ajouté pour la compatibilité avec les processeurs lents.
input_data_format (Union[str, ~image_utils.ChannelDimension], kwargs, facultatif) — Le format de la dimension des canaux pour l'image d'entrée. Si non défini, le format de la dimension des canaux est déduit de l'image d'entrée. Peut être l'un des éléments suivants :
- "channels_first" ou ChannelDimension.FIRST : image au format (num_channels, height, width).
- "channels_last" ou ChannelDimension.LAST : image au format (hauteur, largeur, nombre de canaux).
- "none" ou ChannelDimension.NONE : image au format (hauteur, largeur).
device (Annotated[Union[str, torch.device, NoneType], None], kwargs) — L’appareil sur lequel traiter les vidéos. Si non défini, l’appareil est déduit des vidéos d’entrée.
return_tensors (Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Retourne des tenseurs empilés si défini sur 'pt', sinon retourne une liste de tenseurs.
disable_grouping (bool, kwargs, facultatif) — Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle est définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157
image_seq_length (int, kwargs, facultatif) — Le nombre de jetons d’image à utiliser pour chaque image de l’entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles.
format (str, kwargs, facultatif, par défaut AnnotationFormat.COCO_DETECTION) — Format des données des annotations. L’un des « coco_detection » ou « coco_panoptic ».
do_convert_annotations (bool, kwargs, facultatif, valeur par défaut True) — Contrôle la conversion des annotations au format attendu par le modèle RT_DETR. Convertit les boîtes englobantes au format (center_x, center_y, width, height) et dans l'intervalle [0, 1]. Peut être remplacé par le paramètre do_convert_annotations de la méthode preprocess.

Construit un processeur d’images RTDetrImageProcessor.

prétraiter

< source >

( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']]annotations: dict[str, int | str | list[dict]] | list[dict[str, int | str | list[dict]]] | None = Nonereturn_segmentation_masks: bool | None = Nonemasks_path: str | pathlib.Path | None = None**kwargs: *<class 'transformers.models.rt_detr.image_processing_pil_rt_detr.RTDetrImageProcessorKwargs'> ) → ~image_processing_base.BatchFeature

Paramètres

images (Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]) — Image à prétraiter. S'attend à une image unique ou à un lot d'images dont les valeurs de pixels vont de 0 à 255. Si vous passez des images dont les valeurs de pixels sont comprises entre 0 et 1, définissez do_rescale=False.
annotations (AnnotationType ou list[AnnotationType], facultatif) — Annotations à transformer en fonction du bourrage appliqué aux images.
return_segmentation_masks (bool, facultatif, par défaut self.return_segmentation_masks) — Indique s'il faut retourner les masques de segmentation.
masks_path (str ou pathlib.Path, facultatif) — Chemin vers le répertoire contenant les masques de segmentation.
do_convert_rgb (bool, kwargs, facultatif) — Indique s'il faut convertir l'image en RGB.
do_resize (bool, kwargs, facultatif) — Indique s'il faut redimensionner l'image.
size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Définit les dimensions maximales des entrées du modèle.
default_to_square (bool, kwargs, facultatif) — Indique s'il faut par défaut redimensionner l'image en carré si la taille est un entier.
crop_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Taille de l'image de sortie après application de center_crop.
resample (Annotated[Union[int, PILImageResampling, NoneType], None], kwargs) — Filtre de rééchantillonnage à utiliser lors du redimensionnement de l’image. Il peut s’agir de l’une des valeurs de l’enum PILImageResampling. N’a un effet que si do_resize est défini sur True.
do_rescale (bool, kwargs, facultatif) — Indique s'il faut rééchelonner l'image.
rescale_factor (float, kwargs, facultatif) — Facteur de remise à l'échelle à appliquer à l'image si do_rescale est défini sur True.
do_normalize (bool, kwargs, facultatif) — Indique s'il faut normaliser l'image.
image_mean (Union[float, list[float], tuple[float, ...]], kwargs, facultatif) — Moyenne de l'image à utiliser pour la normalisation. N'a un effet que si do_normalize est défini sur True.
image_std (Union[float, list[float], tuple[float, ...]], kwargs, facultatif) — Écart-type de l'image à utiliser pour la normalisation. N'a un effet que si do_normalize est défini sur True.
do_pad (bool, kwargs, facultatif) — Indique s'il faut effectuer un bourrage (padding) de l'image. Le bourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de bourrage exacte dépend du modèle.
pad_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — La taille au format {"height": int, "width" int} à laquelle les images doivent être remplies. Elle doit être supérieure à la taille de n'importe quelle image fournie pour la prétraitement. Si pad_size n'est pas fourni, les images seront remplies jusqu'à la hauteur et la largeur maximales du lot. Appliqué uniquement lorsque do_pad=True.
do_center_crop (bool, kwargs, facultatif) — Indique s'il faut effectuer un recadrage centré de l'image.
data_format (Union[str, ~image_utils.ChannelDimension], kwargs, facultatif) — Seul ChannelDimension.FIRST est pris en charge. Ajouté pour la compatibilité avec les processeurs lents.
input_data_format (Union[str, ~image_utils.ChannelDimension], kwargs, facultatif) — Le format de la dimension des canaux pour l'image d'entrée. Si non défini, le format de la dimension des canaux est déduit de l'image d'entrée. Peut être l'un des éléments suivants :
- "channels_first" ou ChannelDimension.FIRST : image au format (num_channels, height, width).
- "channels_last" ou ChannelDimension.LAST : image au format (hauteur, largeur, nombre de canaux).
- "none" ou ChannelDimension.NONE : image au format (hauteur, largeur).
device (Annotated[Union[str, torch.device, NoneType], None], kwargs) — L’appareil sur lequel traiter les vidéos. Si non défini, l’appareil est déduit des vidéos d’entrée.
return_tensors (Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Retourne des tenseurs empilés si défini sur 'pt', sinon retourne une liste de tenseurs.
disable_grouping (bool, kwargs, facultatif) — Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle est définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157
image_seq_length (int, kwargs, facultatif) — Le nombre de jetons d’image à utiliser pour chaque image de l’entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles.
format (str, kwargs, facultatif, par défaut AnnotationFormat.COCO_DETECTION) — Format des données des annotations. L’un des « coco_detection » ou « coco_panoptic ».
do_convert_annotations (bool, kwargs, facultatif, valeur par défaut True) — Contrôle la conversion des annotations au format attendu par le modèle RT_DETR. Convertit les boîtes englobantes au format (center_x, center_y, width, height) et dans l'intervalle [0, 1]. Peut être remplacé par le paramètre do_convert_annotations de la méthode preprocess.

Retourne

~image_processing_base.BatchFeature

data (dict) — Dictionnaire de listes/tableaux/tenseurs renvoyé par la méthode call (« pixel_values », etc.).
tensor_type (Union[None, str, TensorType], facultatif) — Vous pouvez spécifier un tensor_type ici pour convertir les listes d'entiers en tenseurs PyTorch/Numpy lors de l'initialisation.

post_process_object_detection

< source >

( outputsthreshold: float = 0.5target_sizes: transformers.utils.generic.TensorType | list[tuple] = Noneuse_focal_loss: bool = True ) → list[Dict]

Paramètres

outputs (DetrObjectDetectionOutput) — Sorties brutes du modèle.
threshold (float, facultatif, par défaut 0.5) — Seuil de score pour conserver les prédictions de détection d'objets.
target_sizes (torch.Tensor ou list[tuple[int, int]], facultatif) — Tenseur de forme (batch_size, 2) ou liste de tuples (tuple[int, int]) contenant la taille cible (height, width) de chaque image du lot. Si non défini, les prédictions ne seront pas redimensionnées.
use_focal_loss (bool, par défaut True) — Variable indiquant si la focal loss a été utilisée pour prédire les sorties. Si True, une fonction sigmoïde est appliquée pour calculer les scores de chaque détection, sinon, une fonction softmax est utilisée.

Retourne

list[Dict]

Une liste de dictionnaires, chaque dictionnaire contenant les scores, les étiquettes et les boîtes pour une image du lot, tels que prédits par le modèle.

Convertit la sortie brute de DetrForObjectDetection en boîtes englobantes finales au format (top_left_x, top_left_y, bottom_right_x, bottom_right_y). Prend uniquement en charge PyTorch.

RTDetrModel

classe transformers.RTDetrModel

< source >

( config: RTDetrConfig )

Paramètres

config (RTDetrConfig) — Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.

Modèle RT-DETR (composé d'un backbone et d'un encodeur-décodeur) produisant des états cachés bruts sans aucune tête au sommet.

Ce modèle hérite de PreTrainedModel. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, la taille des têtes, etc.)

Ce modèle est également une sous-classe de torch.nn.Module de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l'utilisation et le comportement généraux.

forward

< source >

( pixel_values: Tensorpixel_mask: typing.Optional[torch.LongTensor] = Noneencoder_outputs: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: list[dict] | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → RTDetrModelOutput or tuple(torch.Tensor)

Paramètres

pixel_values (torch.Tensor de forme (batch_size, num_channels, image_size, image_size)) — Les tenseurs correspondant aux images d'entrée. Les valeurs de pixels peuvent être obtenues à l'aide de image_processor_class. Voir image_processor_class.__call__ pour plus de détails (processor_class utilise image_processor_class pour le traitement des images).
pixel_mask (torch.LongTensor de forme (batch_size, height, width), facultatif) — Masque pour éviter d'appliquer l'attention aux valeurs de pixels de bourrage. Les valeurs du masque sont sélectionnées dans [0, 1]:
- 1 pour les pixels réels (c.-à-d. non masqués),
- 0 pour les pixels qui sont du bourrage (c.-à-d. masqués).
Qu'est-ce que les masques d'attention ?
encoder_outputs (torch.Tensor, facultatif) — Tuple composé de (last_hidden_state, facultatif : hidden_states, facultatif : attentions) last_hidden_state de forme (batch_size, sequence_length, hidden_size), facultatif) est une séquence d’états cachés à la sortie de la dernière couche de l’encodeur. Utilisé dans l’attention croisée du décodeur.
inputs_embeds (torch.Tensor de forme (batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passer la carte de caractéristiques aplatie (sortie du backbone + couche de projection), vous pouvez choisir de passer directement une représentation aplatie d'une image.
labels (list[Dict] de longueur (batch_size,), facultatif) — Étiquettes pour le calcul de la perte de correspondance bipartite. Liste de dictionnaires, chaque dictionnaire contenant au moins les 2 clés suivantes : ‘class_labels’ et ‘boxes’ (les étiquettes de classes et les boîtes englobantes d’une image du lot, respectivement). Les étiquettes de classes elles-mêmes doivent être un torch.LongTensor de longueur (number of bounding boxes in the image,) et les boîtes un torch.Tensor de forme (number of bounding boxes in the image, 4).

Retourne

RTDetrModelOutput ou tuple(torch.Tensor)

Un RTDetrModelOutput ou un tuple de torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers éléments en fonction de la configuration (None) et des entrées.

La méthode forward de RTDetrModel redéfinit la méthode spéciale __call__.

Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance Module plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.

last_hidden_state (torch.Tensor de forme (batch_size, num_queries, hidden_size)) — Séquence d'états cachés à la sortie de la dernière couche du décodeur du modèle.
intermediate_hidden_states (torch.Tensor de forme (batch_size, config.decoder_layers, num_queries, hidden_size)) — États cachés intermédiaires empilés (sortie de chaque couche du décodeur).
intermediate_logits (torch.Tensor de forme (batch_size, config.decoder_layers, sequence_length, config.num_labels)) — Logits intermédiaires empilés (logits de chaque couche du décodeur).
intermediate_reference_points (torch.Tensor de forme (batch_size, config.decoder_layers, num_queries, 4)) — Points de référence intermédiaires empilés (points de référence de chaque couche du décodeur).
intermediate_predicted_corners (torch.Tensor de forme (batch_size, config.decoder_layers, num_queries, 4)) — Coins intermédiaires prédits empilés (coins prédits de chaque couche du décodeur).
initial_reference_points (torch.Tensor de forme (batch_size, num_queries, 4)) — Points de référence initiaux utilisés pour la première couche du décodeur.
decoder_hidden_states (tuple[torch.Tensor], facultatif, renvoyé lorsque output_hidden_states=True est passé ou lorsque config.output_hidden_states=True) — Tuple de torch.Tensor (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme (batch_size, sequence_length, hidden_size).

États cachés du décodeur à la sortie de chaque couche, plus les sorties de l'intégration initiale.
decoder_attentions (tuple[torch.Tensor], facultatif, renvoyé lorsque output_attentions=True est passé ou lorsque config.output_attentions=True) — Tuple de torch.Tensor (un par couche) de forme (batch_size, num_heads, sequence_length, sequence_length).

Poids d'attention du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
cross_attentions (tuple[torch.Tensor], facultatif, renvoyé lorsque output_attentions=True est passé ou lorsque config.output_attentions=True) — Tuple de torch.Tensor (un par couche) de forme (batch_size, num_heads, sequence_length, sequence_length).

Poids d'attention de la couche d'attention croisée du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'attention croisée.
encoder_last_hidden_state (torch.Tensor de forme (batch_size, sequence_length, hidden_size), facultatif) — Séquence d'états cachés à la sortie de la dernière couche de l'encodeur du modèle.
encoder_hidden_states (tuple[torch.Tensor], facultatif, renvoyé lorsque output_hidden_states=True est passé ou lorsque config.output_hidden_states=True) — Tuple de torch.Tensor (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme (batch_size, sequence_length, hidden_size).

États cachés de l'encodeur à la sortie de chaque couche, plus les sorties des embeddings initiaux.
encoder_attentions (tuple[torch.Tensor], facultatif, renvoyé lorsque output_attentions=True est passé ou lorsque config.output_attentions=True) — Tuple de torch.Tensor (un par couche) de forme (batch_size, num_heads, sequence_length, sequence_length).

Poids d'attention de l'encodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
init_reference_points (torch.Tensor de forme (batch_size, num_queries, 4)) — Points de référence initiaux transmis au décodeur du Transformer.
enc_topk_logits (torch.Tensor de forme (batch_size, sequence_length, config.num_labels)) — Scores des boîtes englobantes prédites, où les config.two_stage_num_proposals boîtes englobantes ayant les scores les plus élevés sont sélectionnées comme propositions de régions à l’étape de l’encodeur. Sortie de la classification binaire des boîtes englobantes (c’est-à-dire premier plan et arrière-plan).
enc_topk_bboxes (torch.Tensor de forme (batch_size, sequence_length, 4)) — Logits des coordonnées des boîtes englobantes prédites à l'étape de l'encodeur.
enc_outputs_class (torch.Tensor de forme (batch_size, sequence_length, config.num_labels), facultatif, renvoyé lorsque config.with_box_refine=True et config.two_stage=True) — Scores des boîtes englobantes prédites, où les config.two_stage_num_proposals boîtes englobantes ayant les scores les plus élevés sont sélectionnées comme propositions de régions dans la première étape. Sortie de la classification binaire des boîtes englobantes (c.-à-d. premier plan et arrière-plan).
enc_outputs_coord_logits (torch.Tensor de forme (batch_size, sequence_length, 4), facultatif, renvoyé lorsque config.with_box_refine=True et config.two_stage=True) — Logits des coordonnées des boîtes englobantes prédites à la première étape.
denoising_meta_values (dict, facultatif) — Dictionnaire supplémentaire pour les valeurs liées au débruitage.

Exemples :

>>> from transformers import AutoImageProcessor, RTDetrModel
>>> from PIL import Image
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> with httpx.stream("GET", url) as response:
...     image = Image.open(BytesIO(response.read()))

>>> image_processor = AutoImageProcessor.from_pretrained("PekingU/rtdetr_r50vd")
>>> model = RTDetrModel.from_pretrained("PekingU/rtdetr_r50vd")

>>> inputs = image_processor(images=image, return_tensors="pt")

>>> outputs = model(**inputs)

>>> last_hidden_states = outputs.last_hidden_state
>>> list(last_hidden_states.shape)
[1, 300, 256]

RTDetrForObjectDetection

classe transformers.RTDetrForObjectDetection

< source >

( config: RTDetrConfig )

Paramètres

config (RTDetrConfig) — Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.

Le modèle RT-DETR (composé d'un backbone et d'un encodeur-décodeur) produit des boîtes englobantes et des logits qui sont ensuite décodés en scores et en classes.

forward

< source >

Paramètres

pixel_values (torch.Tensor de forme (batch_size, num_channels, image_size, image_size)) — Les tenseurs correspondant aux images d'entrée. Les valeurs de pixels peuvent être obtenues à l'aide de image_processor_class. Voir image_processor_class.__call__ pour plus de détails (processor_class utilise image_processor_class pour le traitement des images).
pixel_mask (torch.LongTensor de forme (batch_size, height, width), facultatif) — Masque pour éviter d'appliquer l'attention aux valeurs de pixels de bourrage. Les valeurs du masque sont sélectionnées dans [0, 1]:
- 1 pour les pixels réels (c.-à-d. non masqués),
- 0 pour les pixels qui sont du bourrage (c.-à-d. masqués).
Qu'est-ce que les masques d'attention ?
encoder_outputs (torch.Tensor, facultatif) — Tuple composé de (last_hidden_state, facultatif : hidden_states, facultatif : attentions) last_hidden_state de forme (batch_size, sequence_length, hidden_size), facultatif) est une séquence d’états cachés à la sortie de la dernière couche de l’encodeur. Utilisé dans l’attention croisée du décodeur.
inputs_embeds (torch.Tensor de forme (batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passer la carte de caractéristiques aplatie (sortie du backbone + couche de projection), vous pouvez choisir de passer directement une représentation aplatie d'une image.
labels (list[Dict] de longueur (batch_size,), facultatif) — Étiquettes pour le calcul de la perte de correspondance bipartite. Liste de dictionnaires, chaque dictionnaire contenant au moins les 2 clés suivantes : ‘class_labels’ et ‘boxes’ (les étiquettes de classes et les boîtes englobantes d’une image du lot, respectivement). Les étiquettes de classes elles-mêmes doivent être un torch.LongTensor de longueur (number of bounding boxes in the image,) et les boîtes un torch.Tensor de forme (number of bounding boxes in the image, 4).

Retourne

RTDetrObjectDetectionOutput ou tuple(torch.Tensor)

Un RTDetrObjectDetectionOutput ou un tuple de torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers éléments en fonction de la configuration (None) et des entrées.

La méthode forward de RTDetrForObjectDetection redéfinit la méthode spéciale __call__.

Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance Module plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.

loss (torch.Tensor de forme (1,), facultatif, renvoyé lorsque labels est fourni)) — Perte totale en tant que combinaison linéaire d'une négative log-vraisemblance (entropie croisée) pour la prédiction de classe et d'une perte de boîte englobante. Cette dernière est définie comme une combinaison linéaire de la perte L1 et de la perte d'IoU généralisée insensible à l'échelle.
loss_dict (Dict, facultatif) — Un dictionnaire contenant les pertes individuelles. Utile pour la journalisation.
logits (torch.Tensor de forme (batch_size, num_queries, num_classes + 1)) — Logits de classification (y compris no-object) pour toutes les requêtes.
pred_boxes (torch.Tensor de forme (batch_size, num_queries, 4)) — Coordonnées des boîtes normalisées pour toutes les requêtes, représentées sous la forme (center_x, center_y, width, height). Ces valeurs sont normalisées dans [0, 1], par rapport à la taille de chaque image individuelle du lot (en ignorant le padding éventuel). Vous pouvez utiliser post_process_object_detection() pour récupérer les boîtes englobantes non normalisées (absolues).
auxiliary_outputs (list[Dict], facultatif) — Facultatif, renvoyé uniquement lorsque les pertes auxiliaires sont activées (c.-à-d. config.auxiliary_loss est défini sur True) et que des étiquettes sont fournies. C'est une liste de dictionnaires contenant les deux clés ci-dessus (logits et pred_boxes) pour chaque couche du décodeur.
last_hidden_state (torch.Tensor de forme (batch_size, num_queries, hidden_size)) — Séquence d'états cachés à la sortie de la dernière couche du décodeur du modèle.
intermediate_hidden_states (torch.Tensor de forme (batch_size, config.decoder_layers, num_queries, hidden_size)) — États cachés intermédiaires empilés (sortie de chaque couche du décodeur).
intermediate_logits (torch.Tensor de forme (batch_size, config.decoder_layers, num_queries, config.num_labels)) — Logits intermédiaires empilés (logits de chaque couche du décodeur).
intermediate_reference_points (torch.Tensor de forme (batch_size, config.decoder_layers, num_queries, 4)) — Points de référence intermédiaires empilés (points de référence de chaque couche du décodeur).
intermediate_predicted_corners (torch.Tensor de forme (batch_size, config.decoder_layers, num_queries, 4)) — Coins intermédiaires prédits empilés (coins prédits de chaque couche du décodeur).
initial_reference_points (torch.Tensor de forme (batch_size, config.decoder_layers, num_queries, 4)) — Points de référence initiaux empilés (points de référence initiaux de chaque couche du décodeur).
decoder_hidden_states (tuple[torch.Tensor], facultatif, renvoyé lorsque output_hidden_states=True est passé ou lorsque config.output_hidden_states=True) — Tuple de torch.Tensor (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme (batch_size, sequence_length, hidden_size).

États cachés du décodeur à la sortie de chaque couche, plus les sorties de l'intégration initiale.
decoder_attentions (tuple[torch.Tensor], facultatif, renvoyé lorsque output_attentions=True est passé ou lorsque config.output_attentions=True) — Tuple de torch.Tensor (un par couche) de forme (batch_size, num_heads, sequence_length, sequence_length).

Poids d'attention du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
cross_attentions (tuple[torch.Tensor], facultatif, renvoyé lorsque output_attentions=True est passé ou lorsque config.output_attentions=True) — Tuple de torch.Tensor (un par couche) de forme (batch_size, num_heads, sequence_length, sequence_length).

Poids d'attention de la couche d'attention croisée du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'attention croisée.
encoder_last_hidden_state (torch.Tensor de forme (batch_size, sequence_length, hidden_size), facultatif) — Séquence d'états cachés à la sortie de la dernière couche de l'encodeur du modèle.
encoder_hidden_states (tuple[torch.Tensor], facultatif, renvoyé lorsque output_hidden_states=True est passé ou lorsque config.output_hidden_states=True) — Tuple de torch.Tensor (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme (batch_size, sequence_length, hidden_size).

États cachés de l'encodeur à la sortie de chaque couche, plus les sorties des embeddings initiaux.
encoder_attentions (tuple[torch.Tensor], facultatif, renvoyé lorsque output_attentions=True est passé ou lorsque config.output_attentions=True) — Tuple de torch.Tensor (un par couche) de forme (batch_size, num_heads, sequence_length, sequence_length).

Poids d'attention de l'encodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
init_reference_points (torch.Tensor de forme (batch_size, num_queries, 4)) — Points de référence initiaux transmis au décodeur du Transformer.
enc_topk_logits (torch.Tensor de forme (batch_size, sequence_length, config.num_labels), facultatif, renvoyé lorsque config.with_box_refine=True et config.two_stage=True) — Logits des coordonnées des boîtes englobantes prédites dans l’encodeur.
enc_topk_bboxes (torch.Tensor de forme (batch_size, sequence_length, 4), facultatif, renvoyé lorsque config.with_box_refine=True et config.two_stage=True) — Logits des coordonnées des boîtes englobantes prédites dans l’encodeur.
enc_outputs_class (torch.Tensor de forme (batch_size, sequence_length, config.num_labels), facultatif, renvoyé lorsque config.with_box_refine=True et config.two_stage=True) — Scores des boîtes englobantes prédites, où les config.two_stage_num_proposals boîtes englobantes ayant les scores les plus élevés sont sélectionnées comme propositions de régions dans la première étape. Sortie de la classification binaire des boîtes englobantes (c.-à-d. premier plan et arrière-plan).
enc_outputs_coord_logits (torch.Tensor de forme (batch_size, sequence_length, 4), facultatif, renvoyé lorsque config.with_box_refine=True et config.two_stage=True) — Logits des coordonnées des boîtes englobantes prédites à la première étape.
denoising_meta_values (dict, facultatif) — Dictionnaire supplémentaire pour les valeurs liées au débruitage

Exemples :

>>> from transformers import RTDetrImageProcessor, RTDetrForObjectDetection
>>> from PIL import Image
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO
>>> import torch

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> with httpx.stream("GET", url) as response:
...     image = Image.open(BytesIO(response.read()))

>>> image_processor = RTDetrImageProcessor.from_pretrained("PekingU/rtdetr_r50vd")
>>> model = RTDetrForObjectDetection.from_pretrained("PekingU/rtdetr_r50vd")

>>> # prepare image for the model
>>> inputs = image_processor(images=image, return_tensors="pt")

>>> # forward pass
>>> outputs = model(**inputs)

>>> logits = outputs.logits
>>> list(logits.shape)
[1, 300, 80]

>>> boxes = outputs.pred_boxes
>>> list(boxes.shape)
[1, 300, 4]

>>> # convert outputs (bounding boxes and class logits) to Pascal VOC format (xmin, ymin, xmax, ymax)
>>> target_sizes = torch.tensor([image.size[::-1]])
>>> results = image_processor.post_process_object_detection(outputs, threshold=0.9, target_sizes=target_sizes)[
...     0
... ]

>>> for score, label, box in zip(results["scores"], results["labels"], results["boxes"]):
...     box = [round(i, 2) for i in box.tolist()]
...     print(
...         f"Detected {model.config.id2label[label.item()]} with confidence "
...         f"{round(score.item(), 3)} at location {box}"
...     )
Detected sofa with confidence 0.97 at location [0.14, 0.38, 640.13, 476.21]
Detected cat with confidence 0.96 at location [343.38, 24.28, 640.14, 371.5]
Detected cat with confidence 0.958 at location [13.23, 54.18, 318.98, 472.22]
Detected remote with confidence 0.951 at location [40.11, 73.44, 175.96, 118.48]
Detected remote with confidence 0.924 at location [333.73, 76.58, 369.97, 186.99]

RTDetrResNetBackbone

classe transformers.RTDetrResNetBackbone

< source >

( config: RTDetrResNetConfig )

Paramètres

config (RTDetrResNetConfig) — Classe de configuration du modèle contenant tous les paramètres du modèle. L'initialisation à partir d'un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.

Backbone ResNet, à utiliser avec des frameworks comme RTDETR.

forward

< source >

( pixel_values: Tensoroutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → BackboneOutput or tuple(torch.Tensor)

Paramètres

pixel_values (torch.Tensor de forme (batch_size, num_channels, image_size, image_size)) — Les tenseurs correspondant aux images d'entrée. Les valeurs de pixels peuvent être obtenues à l'aide de image_processor_class. Voir image_processor_class.__call__ pour plus de détails (processor_class utilise image_processor_class pour le traitement des images).
output_hidden_states (bool, facultatif) — Indique s'il faut retourner les états cachés de toutes les couches. Voir hidden_states sous les tenseurs retournés pour plus de détails.
return_dict (bool, facultatif) — Indique s'il faut retourner un ModelOutput plutôt qu'un simple tuple.

Retourne

BackboneOutput ou tuple(torch.Tensor)

Un BackboneOutput ou un tuple de torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers éléments en fonction de la configuration (RTDetrResNetConfig) et des entrées.

La méthode forward de RTDetrResNetBackbone redéfinit la méthode spéciale __call__.

Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance Module plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.

feature_maps (tuple(torch.Tensor) de forme (batch_size, num_channels, height, width)) — Cartes de caractéristiques des étapes.
hidden_states (tuple(torch.Tensor), facultatif, renvoyé lorsque output_hidden_states=True est passé ou lorsque config.output_hidden_states=True) — Tuple de torch.Tensor (un pour la sortie des embeddings + un pour la sortie de chaque couche) de forme (batch_size, sequence_length, hidden_size) ou (batch_size, num_channels, height, width), selon le backbone.

États cachés du modèle à la sortie de chaque étape, ainsi que les sorties des embeddings initiaux.
attentions (tuple(torch.Tensor), facultatif, renvoyé lorsque output_attentions=True est passé ou lorsque config.output_attentions=True) — Tuple de torch.Tensor (un par couche) de forme (batch_size, num_heads, sequence_length, sequence_length). Applicable uniquement si le backbone utilise l'attention.

Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.

Exemples :

>>> from transformers import RTDetrResNetConfig, RTDetrResNetBackbone
>>> import torch
precation import deprecate_kwarg
precation import deprecate_kwarg
precation import deprecate_kwarg
utils.deprecation import deprecate_kwarg
utils.deprecation import deprecate_kwarg

>>> config = RTDetrResNetConfig()
>>> model = RTDetrResNetBackbone(config)

>>> pixel_values = torch.randn(1, 3, 224, 224)

>>> with torch.no_grad():
...     outputs = model(pixel_values)

>>> feature_maps = outputs.feature_maps
>>> list(feature_maps[-1].shape)
[1, 2048, 7, 7]

Update on GitHub

←RF-DETR RT-DETRv2→