Transformers documentation
DETR
Ce modèle a été publié dans HF papers le 2020-05-26 et a été ajouté à Hugging Face Transformers le 2021-06-09.
DETR
DETR est composé d’un backbone convolutif suivi d’un Transformer encodeur-décodeur, qui peut être entraîné de bout en bout pour la détection d’objets. Il simplifie considérablement la complexité de nombreux modèles tels que Faster-R-CNN et Mask-R-CNN, qui utilisent des éléments comme les propositions de régions, la procédure de suppression du maximum non maximal et la génération d’ancres. De plus, DETR peut également être étendu naturellement pour effectuer la segmentation panoptique, en ajoutant simplement une tête de masque au-dessus des sorties du décodeur.
Vous pouvez trouver tous les points de contrôle originaux de DETR sous l'organisation AI at Meta.
Ce modèle a été contribué par nielsr.
Cliquez sur les modèles DETR dans la barre latérale droite pour plus d’exemples sur la façon d’appliquer DETR à différentes tâches de détection d’objets et de segmentation.
Définissez
use_kernels=Truedans from_pretrained() pour remplacer les couches prises en charge par des noyaux optimisés du Hub. Consultez Chargement des noyaux pour en savoir plus.
L'exemple ci-dessous montre comment effectuer la détection d'objets avec la classe Pipeline ou la classe AutoModel.
from transformers import pipeline
pipeline = pipeline(
"object-detection",
model="facebook/detr-resnet-50",
device_map=0
)
pipeline("http://images.cocodataset.org/val2017/000000039769.jpg")import requests
import torch
from PIL import Image
from transformers import AutoImageProcessor, AutoModelForObjectDetection
url = "http://images.cocodataset.org/val2017/000000039769.jpg"
image = Image.open(requests.get(url, stream=True).raw)
image_processor = AutoImageProcessor.from_pretrained("facebook/detr-resnet-50")
model = AutoModelForObjectDetection.from_pretrained("facebook/detr-resnet-50", device_map="auto")
# prepare image for the model
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.size[::-1]]), 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}")How DETR works
Voici un résumé expliquant le fonctionnement de DetrForObjectDetection :
Tout d’abord, une image est transmise à un tronc convolutif pré-entraîné (dans l’article, les auteurs utilisent ResNet-50/ResNet-101). Supposons que nous ajoutions également une dimension de lot. Cela signifie que l’entrée du tronc est un tenseur de forme (batch_size, 3, height, width), en supposant que l’image possède 3 canaux de couleur (RVB). Le tronc CNN produit une nouvelle carte de caractéristiques à plus basse résolution, généralement de forme (batch_size, 2048, height/32, width/32). Celle-ci est ensuite projetée pour correspondre à la dimension cachée du Transformer de DETR, qui est de 256 par défaut, à l’aide d’une couche nn.Conv2D. Nous disposons donc maintenant d’un tenseur de forme (batch_size, 256, height/32, width/32). Ensuite, la carte de caractéristiques est aplatie et transposée pour obtenir un tenseur de forme (batch_size, seq_len, d_model) = (batch_size, width/32*height/32, 256). Une différence avec les modèles de NLP est donc que la longueur de séquence est en réalité plus longue que d’habitude, mais avec un d_model plus petit (qui en NLP est typiquement de 768 ou plus).
Ensuite, cela est transmis à l’encodeur, qui produit encoder_hidden_states de la même forme (vous pouvez considérer ces éléments comme des caractéristiques d’image). Puis, les requêtes d’objet sont envoyées au décodeur. Il s’agit d’un tenseur de forme (batch_size, num_queries, d_model), où num_queries est généralement fixé à 100 et initialisé avec des zéros. Ces plongements d’entrée sont des encodages positionnels appris que les auteurs appellent requêtes d’objet et, de manière similaire à l’encodeur, ils sont ajoutés à l’entrée de chaque couche d’attention. Chaque requête d’objet recherche un objet particulier dans l’image. Le décodeur met à jour ces plongements à travers plusieurs couches d’auto-attention et d’attention encodeur-décodeur pour produire decoder_hidden_states de la même forme : (batch_size, num_queries, d_model). Ensuite, deux têtes sont ajoutées au sommet pour la détection d’objets : une couche linéaire pour classifier chaque requête d’objet en un des objets ou « aucun objet », et un MLP pour prédire les boîtes englobantes pour chaque requête.
Le modèle est entraîné à l’aide d’une fonction de perte par appariement biparti : nous comparons donc les classes et les boîtes englobantes prédites de chacun des N = 100 requêtes d’objets aux annotations de référence, remplies jusqu’à la même longueur N (ainsi, si une image ne contient que 4 objets, 96 annotations auront simplement la classe « aucun objet » et la boîte englobante « aucune boîte englobante »). L’algorithme d’appariement hongrois est utilisé pour trouver un mappage optimal un-à-un entre chacune des N requêtes et chacune des N annotations. Ensuite, une entropie croisée standard (pour les classes) et une combinaison linéaire de la perte L1 et de la perte d’IoU généralisée (pour les boîtes englobantes) sont utilisées pour optimiser les paramètres du modèle.
DETR peut être naturellement étendu pour effectuer la segmentation panoptique (qui unifie la segmentation sémantique et la segmentation d’instances). DetrForSegmentation ajoute une tête de masque de segmentation au-dessus de DetrForObjectDetection. La tête de masque peut être entraînée soit conjointement, soit en deux étapes : on entraîne d’abord un modèle DetrForObjectDetection pour détecter des boîtes englobant à la fois les « things » (instances) et les « stuff » (éléments d’arrière-plan comme les arbres, les routes, le ciel), puis on fige tous les poids et on n’entraîne que la tête de masque pendant 25 époques. Expérimentalement, ces deux approches donnent des résultats similaires. Notez que la prédiction des boîtes est requise pour que l’entraînement soit possible, car l’appariement hongrois est calculé à l’aide des distances entre les boîtes.
Notes
- DETR utilise des requêtes d’objets pour détecter les objets dans une image. Le nombre de requêtes détermine le nombre maximal d’objets qui peuvent être détectés dans une image unique et est fixé à 100 par défaut (voir le paramètre
num_queriesde DetrConfig). Il est bon de prévoir une marge (dans COCO, les auteurs ont utilisé 100, alors que le nombre maximal d’objets dans une image COCO est d’environ 70). - Le décodeur de DETR met à jour les embeddings de requête en parallèle. Cela diffère des modèles de langage comme GPT-2, qui utilisent un décodage autorégressif plutôt que parallèle. Par conséquent, aucun masque d'attention causale n'est utilisé.
- DETR ajoute des embeddings de position aux états cachés à chaque couche d'auto-attention et d'attention croisée avant la projection en requêtes et clés. Pour les embeddings de position de l'image, on peut choisir entre des embeddings de position absolus sinusoïdaux fixes ou appris. Par défaut, le paramètre
position_embedding_typede DetrConfig est défini sur"sine". - Lors de l’entraînement, les auteurs de DETR ont constaté qu’il était utile d’utiliser des pertes auxiliaires dans le décodeur, en particulier pour aider le modèle à prédire le bon nombre d’objets de chaque classe. Si vous définissez le paramètre
auxiliary_lossde DetrConfig surTrue, des réseaux de neurones feedforward de prédiction et des pertes hongroises sont ajoutés après chaque couche du décodeur (les FFN partageant leurs paramètres). - Si vous souhaitez entraîner le modèle dans un environnement distribué sur plusieurs nœuds, il convient de mettre à jour la variable num_boxes dans la classe DetrLoss du fichier modeling_detr.py. Lors de l’entraînement sur plusieurs nœuds, cette valeur doit être définie comme le nombre moyen de boîtes cibles sur l’ensemble des nœuds, comme on peut le voir dans l’implémentation d’origine ici.
- DetrForObjectDetection et DetrForSegmentation peuvent être initialisés avec n’importe quel backbone convolutif disponible dans la bibliothèque timm. Par exemple, pour initialiser avec un backbone MobileNet, il suffit de définir l’attribut
backbonede DetrConfig sur"tf_mobilenetv3_small_075", puis d’initialiser le modèle avec cette configuration. - DER redimensionne les images d'entrée de sorte que le côté le plus court soit d'au moins un certain nombre de pixels, tandis que le côté le plus long est d'au plus 1333 pixels. Lors de l'entraînement, une augmentation d'échelle est utilisée, de sorte que le côté le plus court est défini aléatoirement entre au moins 480 et au plus 800 pixels. Lors de l'inférence, le côté le plus court est fixé à 800. On peut utiliser DetrImageProcessor pour préparer les images (et les annotations optionnelles au format COCO) pour le modèle. En raison de ce redimensionnement, les images d'un lot peuvent avoir des tailles différentes. DETR résout ce problème en remplissant les images jusqu'à la plus grande taille du lot, et en créant un masque de pixels qui indique quels pixels sont réels et lesquels sont du remplissage. Alternativement, on peut également définir une fonction
collate_fnpersonnalisée afin de regrouper les images en lots, en utilisant~transformers.DetrImageProcessor.pad_and_create_pixel_mask. - La taille des images déterminera la quantité de mémoire utilisée et, par conséquent, le
batch_size. Il est conseillé d'utiliser une taille de lot de 2 par GPU. Consultez ce fil GitHub pour plus d'informations.
Il existe trois autres façons d'instantier un modèle DETR (selon vos préférences) :
- Option 1 : Instancier DETR avec des poids pré-entraînés pour le modèle entier
from transformers import DetrForObjectDetection
model = DetrForObjectDetection.from_pretrained("facebook/detr-resnet-50", device_map="auto")- Option 2 : Instancier DETR avec des poids initialisés aléatoirement pour le Transformer, mais des poids pré-entraînés pour le backbone
from transformers import DetrConfig, DetrForObjectDetection
config = DetrConfig()
model = DetrForObjectDetection(config)- Option 3 : Instancier DETR avec des poids initialisés aléatoirement pour le backbone + le Transformer
config = DetrConfig() model = DetrForObjectDetection(config)
En résumé, considérez le tableau suivant :
| Tâche | Détection d'objets | Segmentation d'instances | Segmentation panoptique |
|---|---|---|---|
| Description | Prédiction des boîtes englobantes et des étiquettes de classes autour des objets dans une image | Prédiction de masques autour des objets (c.-à-d. des instances) dans une image | Prédire des masques autour des deux objets (c’est-à-dire des instances) ainsi que des « stuff » (c’est-à-dire des éléments d’arrière-plan comme les arbres et les routes) dans une image |
| Modèle | DetrForObjectDetection | DetrForSegmentation | DetrForSegmentation |
| Jeu de données d’exemple | Détection COCO | Détection COCO, panoptique COCO | COCO panoptique |
| Format des annotations à fournir à DetrImageProcessor | {‘image_id’: int, ‘annotations’: list[Dict]} chaque Dict étant une annotation d’objet COCO | {‘image_id’: int, ‘annotations’: list[Dict]} (en cas de détection COCO) ou {‘file_name’: str, ‘image_id’: int, ‘segments_info’: list[Dict]} (en cas de panoptique COCO) | {‘file_name’: str, ‘image_id’: int, ‘segments_info’: list[Dict]} et masks_path (chemin vers le répertoire contenant les fichiers PNG des masques) |
| Post-traitement (c'est-à-dire la conversion de la sortie du modèle au format Pascal VOC) | ~transformers.DetrImageProcessor.post_process | ~transformers.DetrImageProcessor.post_process_segmentation | ~transformers.DetrImageProcessor.post_process_segmentation, ~transformers.DetrImageProcessor.post_process_panoptic |
| évaluateurs | CocoEvaluator avec iou_types="bbox" | CocoEvaluator avec iou_types="bbox" ou "segm" | CocoEvaluator avec iou_types="bbox" ou "segm", PanopticEvaluator |
- En résumé, il convient de préparer les données au format COCO detection ou COCO panoptic, puis d’utiliser DetrImageProcessor pour créer
pixel_values,pixel_masket, le cas échéant,labels, qui peuvent ensuite être utilisés pour entraîner (ou affiner) un modèle. - Pour l'évaluation, il convient d'abord de convertir les sorties du modèle à l'aide de l'une des méthodes de post-traitement de DetrImageProcessor. Ces sorties peuvent être transmises à
CocoEvaluatorouPanopticEvaluator, qui permettent de calculer des métriques telles que la précision moyenne (mAP) et la qualité panoptique (PQ). Ces derniers objets sont implémentés dans le dépôt original. Consultez les notebooks d'exemple pour plus d'informations sur l'évaluation.
Ressources
- Reportez-vous à ces notebooks pour des exemples de fine-tuning de DetrForObjectDetection et DetrForSegmentation sur un jeu de données personnalisé.
DetrConfig
classe transformers.DetrConfig
< 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 = Truebackbone_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonenum_channels: int = 3num_queries: int = 100encoder_layers: int = 6encoder_ffn_dim: int = 2048encoder_attention_heads: int = 8decoder_layers: int = 6decoder_ffn_dim: int = 2048decoder_attention_heads: int = 8encoder_layerdrop: float | int = 0.0decoder_layerdrop: float | int = 0.0activation_function: str = 'relu'd_model: int = 256dropout: float | int = 0.1attention_dropout: float | int = 0.0activation_dropout: float | int = 0.0init_std: float = 0.02init_xavier_std: float = 1.0auxiliary_loss: bool = Falseposition_embedding_type: str = 'sine'dilation: bool = Falseclass_cost: int = 1bbox_cost: int = 5giou_cost: int = 2mask_loss_coefficient: int = 1dice_loss_coefficient: int = 1bbox_loss_coefficient: int = 5giou_loss_coefficient: int = 2eos_coefficient: float = 0.1 )
Paramètres
- is_encoder_decoder (
bool, facultatif, valeur par défautTrue) — Indique si le modèle est utilisé comme encodeur/décodeur ou non. - backbone_config (
Union[dict, ~configuration_utils.PreTrainedConfig], facultatif) — La configuration du modèle backbone. - num_channels (
int, facultatif, par défaut3) — Le nombre de canaux d'entrée. - num_queries (
int, facultatif, par défaut 100) — Nombre de requêtes d’objets, c’est-à-dire de slots de détection. Il s’agit du nombre maximal d’objets que ConditionalDetrModel peut détecter dans une image unique. Pour COCO, nous recommandons 100 requêtes. - encoder_layers (
int, facultatif, valeur par défaut6) — Nombre de couches cachées dans l'encodeur Transformer. Utilise la même valeur quenum_layerssi non défini. - encoder_ffn_dim (
int, facultatif, valeur par défaut2048) — Dimension de la couche « intermédiaire » (souvent appelée couche feed-forward) de l’encodeur. - encoder_attention_heads (
int, facultatif, valeur par défaut8) — Nombre de têtes d'attention pour chaque couche d'attention dans l'encodeur Transformer. - decoder_layers (
int, facultatif, valeur par défaut6) — Nombre de couches cachées dans le décodeur Transformer. Utilise la même valeur quenum_layerssi non défini. - decoder_ffn_dim (
int, facultatif, valeur par défaut2048) — Dimension de la couche « intermédiaire » (souvent appelée couche feed-forward) du décodeur. - decoder_attention_heads (
int, facultatif, valeur par défaut8) — Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer. - encoder_layerdrop (
Union[float, int], facultatif, valeur par défaut0.0) — Probabilité de LayerDrop pour l'encodeur. Consultez l'article [LayerDrop](voir https://huggingface.co/papers/1909.11556) pour plus de détails. - decoder_layerdrop (
Union[float, int], facultatif, valeur par défaut0.0) — Probabilité de LayerDrop pour le décodeur. Consultez l’article [LayerDrop](voir https://huggingface.co/papers/1909.11556) pour plus de détails. - activation_function (
str, facultatif, par défautrelu) — La fonction d'activation non linéaire (fonction ou chaîne de caractères) dans le décodeur. Par exemple,"gelu","relu","silu", etc. - d_model (
int, facultatif, par défaut256) — Taille des couches encodeur et de la couche pooler. - dropout (
Union[float, int], facultatif, par défaut0.1) — Le taux appliqué à toutes les couches de dropout. - attention_dropout (
Union[float, int], facultatif, valeur par défaut0.0) — Le taux de dropout appliqué aux probabilités d'attention. - activation_dropout (
Union[float, int], facultatif, valeur par défaut0.0) — Le taux de dropout appliqué aux activations à l'intérieur de la couche entièrement connectée. - init_std (
float, facultatif, valeur par défaut0.02) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser toutes les matrices de poids. - init_xavier_std (
float, facultatif, valeur par défaut1.0) — Le facteur d'échelle utilisé pour l'initialisation de Xavier des poids de l'attention croisée. - auxiliary_loss (
bool, facultatif, par défautFalse) — Indique si les pertes de décodage auxiliaires (pertes à chaque couche du décodeur) doivent être utilisées. - position_embedding_type (
str, facultatif, par défaut"sine") — Type d'embeddings de position à utiliser au-dessus des caractéristiques de l'image. L'un des"sine"ou"learned". - dilation (
bool, facultatif, par défautFalse) — Indique s'il faut remplacer le pas (stride) par la dilatation dans le dernier bloc convolutif (DC5). Pris en charge uniquement lorsqueuse_timm_backbone=True. - class_cost (
int, facultatif, par défaut1) — Poids relatif de l'erreur de classification dans le coût d'appariement hongrois. - bbox_cost (
int, facultatif, valeur par défaut5) — Poids relatif de l'erreur de boîte englobante L1 dans le coût d'appariement hongrois. - giou_cost (
int, facultatif, par défaut2) — Poids relatif de la perte d'IoU généralisée dans le coût d'appariement hongrois. - mask_loss_coefficient (
int, facultatif, valeur par défaut1) — Poids relatif de la perte focale dans la perte de segmentation panoptique. - dice_loss_coefficient (
int, facultatif, valeur par défaut1) — Poids relatif de la perte dice dans la perte de segmentation panoptique. - bbox_loss_coefficient (
int, facultatif, valeur par défaut5) — Poids relatif de la perte L1 des boîtes englobantes dans la perte de segmentation panoptique. - giou_loss_coefficient (
int, facultatif, valeur par défaut2) — Poids relatif de la perte d'IoU généralisée dans la perte de segmentation panoptique. - eos_coefficient (
float, facultatif, par défaut0.1) — 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 DetrModel. Elle est utilisée pour instancier un modèle Detr en fonction des arguments spécifiés, définissant ainsi l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de facebook/detr-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.
Exemples :
>>> from transformers import DetrConfig, DetrModel
>>> # Initializing a DETR facebook/detr-resnet-50 style configuration
>>> configuration = DetrConfig()
>>> # Initializing a model (with random weights) from the facebook/detr-resnet-50 style configuration
>>> model = DetrModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configDetrImageProcessor
classe transformers.DetrImageProcessor
< source >( **kwargs: *<class 'transformers.models.detr.image_processing_detr.DetrImageProcessorKwargs'> )
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éfautTrue) — Indique s'il faut redimensionner l'image. - size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs, par défaut{'shortest_edge' -- 800, 'longest_edge': 1333}) : Définit les dimensions maximales de l'entrée du modèle. - default_to_square (
bool, kwargs, facultatif, valeur par défautFalse) — 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 decenter_crop. - resample (
Annotated[Union[int, PILImageResampling, NoneType], None], kwargs, par défaut2) — Filtre de rééchantillonnage à utiliser lors du redimensionnement de l’image. Il peut s’agir de l’une des valeurs de l’enumPILImageResampling. N’a un effet que sido_resizeest défini surTrue. - do_rescale (
bool, kwargs, facultatif, par défautTrue) — Indique s'il faut rééchelonner l'image. - rescale_factor (
float, kwargs, facultatif, valeur par défaut0.00392156862745098) — Facteur de remise à l'échelle appliqué à l'image sido_rescaleest défini surTrue. - do_normalize (
bool, kwargs, facultatif, valeur par défautTrue) — 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 sido_normalizeest défini surTrue. - 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 sido_normalizeest défini surTrue. - do_pad (
bool, kwargs, facultatif, valeur par défautTrue) — 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. Sipad_sizen'est pas fourni, les images seront remplies jusqu'à la hauteur et la largeur maximales du lot. Appliqué uniquement lorsquedo_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) — SeulChannelDimension.FIRSTest 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"ouChannelDimension.FIRST: image au format (num_channels, height, width)."channels_last"ouChannelDimension.LAST: image au format (hauteur, largeur, nombre de canaux)."none"ouChannelDimension.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éfautAnnotationFormat.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éfautTrue) — Contrôle la conversion des annotations au format attendu par le modèle 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ètredo_convert_annotationsde la méthodepreprocess.
Construit un processeur d’images DetrImageProcessor.
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.detr.image_processing_detr.DetrImageProcessorKwargs'> ) → ~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éfinissezdo_rescale=False. - annotations (
AnnotationTypeoulist[AnnotationType], facultatif) — Annotations à transformer en fonction du bourrage appliqué aux images. - return_segmentation_masks (
bool, facultatif, par défautself.return_segmentation_masks) — Indique s'il faut retourner les masques de segmentation. - masks_path (
stroupathlib.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 decenter_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’enumPILImageResampling. N’a un effet que sido_resizeest défini surTrue. - 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 sido_rescaleest défini surTrue. - 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 sido_normalizeest défini surTrue. - image_std (
Union[float, list[float], tuple[float, ...]], kwargs, facultatif) — Écart-type de l'image à utiliser pour la normalisation. N'a un effet que sido_normalizeest défini surTrue. - 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. Sipad_sizen'est pas fourni, les images seront remplies jusqu'à la hauteur et la largeur maximales du lot. Appliqué uniquement lorsquedo_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) — SeulChannelDimension.FIRSTest 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"ouChannelDimension.FIRST: image au format (num_channels, height, width)."channels_last"ouChannelDimension.LAST: image au format (hauteur, largeur, nombre de canaux)."none"ouChannelDimension.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éfautAnnotationFormat.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éfautTrue) — Contrôle la conversion des annotations au format attendu par le modèle 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ètredo_convert_annotationsde la méthodepreprocess.
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] | None = None ) → list[Dict]
Paramètres
- outputs (
DetrObjectDetectionOutput) — Sorties brutes du modèle. - threshold (
float, facultatif) — Seuil de score pour conserver les prédictions de détection d'objets. - target_sizes (
torch.Tensoroulist[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.
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.
post_process_semantic_segmentation
< source >( outputstarget_sizes: list[tuple[int, int]] | None = Nonereturn_segmentation_scores: bool = False ) → list[torch.Tensor] or list[SemanticSegmentationPostProcessorOutput]
Paramètres
- outputs (DetrForSegmentation) — Sorties brutes du modèle.
- target_sizes (
list[tuple[int, int]], facultatif) — Une liste de tuples (tuple[int, int]) contenant la taille cible (hauteur, largeur) de chaque image du lot. Si non défini, les prédictions ne seront pas redimensionnées. - return_segmentation_scores (
bool, facultatif, par défautFalse) — Indique s'il faut retourner les scores de segmentation en plus de la carte de segmentation. SiTrue, chaque élément de la liste retournée est unSemanticSegmentationPostProcessorOutputavec les champssegmentation(IDs de classes, forme(height, width)) etsegmentation_scores(forme(num_classes, height, width)).
Retourne
list[torch.Tensor] ou list[SemanticSegmentationPostProcessorOutput]
Lorsque
return_segmentation_scores=False (par défaut), une liste de longueur batch_size où chaque élément est une
carte de segmentation de forme (height, width) avec des identifiants de classes. Lorsque return_segmentation_scores=True,
une liste de SemanticSegmentationPostProcessorOutput avec les champs segmentation (identifiants de classes, forme
(height, width)) et segmentation_scores (forme (num_classes, height, width)). Dans les deux cas,
(height, width) correspond à la taille cible (si target_sizes est spécifiée).
Convertit la sortie de DetrForSegmentation en cartes de segmentation sémantique. Prend uniquement en charge PyTorch.
post_process_instance_segmentation
< source >( outputsthreshold: float = 0.5mask_threshold: float = 0.5overlap_mask_area_threshold: float = 0.8target_sizes: list[tuple[int, int]] | None = Nonereturn_coco_annotation: bool | None = False ) → list[Dict]
Paramètres
- outputs (DetrForSegmentation) — Sorties brutes du modèle.
- threshold (
float, facultatif, valeur par défaut 0.5) — Seuil de score de probabilité pour conserver les masques d’instances prédits. - mask_threshold (
float, facultatif, valeur par défaut 0.5) — Seuil à utiliser pour convertir les masques prédits en valeurs binaires. - overlap_mask_area_threshold (
float, facultatif, valeur par défaut 0.8) — Seuil de la zone du masque de chevauchement pour fusionner ou supprimer les petites parties déconnectées au sein de chaque masque d'instance binaire. - target_sizes (
list[Tuple], facultatif) — Liste de longueur (batch_size), où chaque élément de la liste (tuple[int, int]]) correspond à la taille finale demandée (hauteur, largeur) de chaque prédiction. Si non défini, les prédictions ne seront pas redimensionnées. - return_coco_annotation (
bool, facultatif) — Valeur par défaut :False. Si défini surTrue, les cartes de segmentation sont renvoyées au format d'encodage par longueur de course (RLE) de COCO.
Retourne
list[Dict]
Une liste de dictionnaires, un par image, chaque dictionnaire contenant deux clés :
- segmentation — Un tenseur de forme
(height, width)où chaque pixel représente unsegment_idoulist[List]encodage par longueur d’exécution (RLE) de la carte de segmentation si return_coco_annotation est défini surTrue. Défini surNonesi aucun masque n’est trouvé au-dessus dethreshold. - segments_info — Un dictionnaire contenant des informations supplémentaires sur chaque segment.
- id — Un entier représentant le
segment_id. - label_id — Un entier représentant l’identifiant de la classe sémantique correspondant à
segment_id. - score — Score de prédiction du segment portant l'identifiant
segment_id.
- id — Un entier représentant le
Convertit la sortie de DetrForSegmentation en prédictions de segmentation d'instances. Prend uniquement en charge PyTorch.
post_process_panoptic_segmentation
< source >( outputsthreshold: float = 0.5mask_threshold: float = 0.5overlap_mask_area_threshold: float = 0.8label_ids_to_fuse: set[int] | None = Nonetarget_sizes: list[tuple[int, int]] | None = None ) → list[Dict]
Paramètres
- outputs (DetrForSegmentation) — Les sorties de DetrForSegmentation.
- threshold (
float, facultatif, valeur par défaut 0.5) — Seuil de score de probabilité pour conserver les masques d’instances prédits. - mask_threshold (
float, facultatif, valeur par défaut 0.5) — Seuil à utiliser pour convertir les masques prédits en valeurs binaires. - overlap_mask_area_threshold (
float, facultatif, valeur par défaut 0.8) — Seuil de la zone du masque de chevauchement pour fusionner ou supprimer les petites parties déconnectées au sein de chaque masque d'instance binaire. - label_ids_to_fuse (
Set[int], facultatif) — Les étiquettes de cet état verront toutes leurs instances fusionnées ensemble. Par exemple, on peut considérer qu’une image ne peut contenir qu’un seul ciel, mais plusieurs personnes ; l’identifiant de l’étiquette « sky » serait donc présent dans cet ensemble, mais pas celui de « person ». - target_sizes (
list[Tuple], facultatif) — Liste de longueur (batch_size), où chaque élément de la liste (tuple[int, int]]) correspond à la taille finale demandée (hauteur, largeur) de chaque prédiction du lot. Si non défini, les prédictions ne seront pas redimensionnées.
Retourne
list[Dict]
Une liste de dictionnaires, un par image, chaque dictionnaire contenant deux clés :
- segmentation — un tenseur de forme
(height, width)où chaque pixel représente unsegment_idouNonesi aucun masque n’est trouvé au-dessus dethreshold. Sitarget_sizesest spécifié, la segmentation est redimensionnée à l’entrée correspondante detarget_sizes. - segments_info — Un dictionnaire contenant des informations supplémentaires sur chaque segment.
- id — un entier représentant le
segment_id. - label_id — Un entier représentant l’identifiant de la classe sémantique correspondant à
segment_id. - was_fused — un booléen,
Truesilabel_idétait danslabel_ids_to_fuse,Falsesinon. Plusieurs instances de la même classe / étiquette ont été fusionnées et ont reçu un uniquesegment_id. - score — Score de prédiction du segment portant l'identifiant
segment_id.
- id — un entier représentant le
Convertit la sortie de DetrForSegmentation en prédictions de segmentation panoptique d’image. Prend uniquement en charge PyTorch.
DetrImageProcessorPil
classe transformers.DetrImageProcessorPil
< source >( **kwargs: *<class 'transformers.models.detr.image_processing_pil_detr.DetrImageProcessorKwargs'> )
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éfautTrue) — Indique s'il faut redimensionner l'image. - size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs, par défaut{'shortest_edge' -- 800, 'longest_edge': 1333}) : Définit les dimensions maximales de l'entrée du modèle. - default_to_square (
bool, kwargs, facultatif, valeur par défautFalse) — 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 decenter_crop. - resample (
Annotated[Union[int, PILImageResampling, NoneType], None], kwargs, par défaut2) — Filtre de rééchantillonnage à utiliser lors du redimensionnement de l’image. Il peut s’agir de l’une des valeurs de l’enumPILImageResampling. N’a un effet que sido_resizeest défini surTrue. - do_rescale (
bool, kwargs, facultatif, par défautTrue) — Indique s'il faut rééchelonner l'image. - rescale_factor (
float, kwargs, facultatif, valeur par défaut0.00392156862745098) — Facteur de remise à l'échelle appliqué à l'image sido_rescaleest défini surTrue. - do_normalize (
bool, kwargs, facultatif, valeur par défautTrue) — 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 sido_normalizeest défini surTrue. - 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 sido_normalizeest défini surTrue. - do_pad (
bool, kwargs, facultatif, valeur par défautTrue) — 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. Sipad_sizen'est pas fourni, les images seront remplies jusqu'à la hauteur et la largeur maximales du lot. Appliqué uniquement lorsquedo_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) — SeulChannelDimension.FIRSTest 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"ouChannelDimension.FIRST: image au format (num_channels, height, width)."channels_last"ouChannelDimension.LAST: image au format (hauteur, largeur, nombre de canaux)."none"ouChannelDimension.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éfautAnnotationFormat.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éfautTrue) — Contrôle la conversion des annotations au format attendu par le modèle 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ètredo_convert_annotationsde la méthodepreprocess.
Construit un processeur d’images DetrImageProcessor.
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.detr.image_processing_pil_detr.DetrImageProcessorKwargs'> ) → ~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éfinissezdo_rescale=False. - annotations (
AnnotationTypeoulist[AnnotationType], facultatif) — Annotations à transformer en fonction du bourrage appliqué aux images. - return_segmentation_masks (
bool, facultatif, par défautself.return_segmentation_masks) — Indique s'il faut retourner les masques de segmentation. - masks_path (
stroupathlib.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 decenter_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’enumPILImageResampling. N’a un effet que sido_resizeest défini surTrue. - 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 sido_rescaleest défini surTrue. - 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 sido_normalizeest défini surTrue. - image_std (
Union[float, list[float], tuple[float, ...]], kwargs, facultatif) — Écart-type de l'image à utiliser pour la normalisation. N'a un effet que sido_normalizeest défini surTrue. - 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. Sipad_sizen'est pas fourni, les images seront remplies jusqu'à la hauteur et la largeur maximales du lot. Appliqué uniquement lorsquedo_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) — SeulChannelDimension.FIRSTest 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"ouChannelDimension.FIRST: image au format (num_channels, height, width)."channels_last"ouChannelDimension.LAST: image au format (hauteur, largeur, nombre de canaux)."none"ouChannelDimension.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éfautAnnotationFormat.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éfautTrue) — Contrôle la conversion des annotations au format attendu par le modèle 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ètredo_convert_annotationsde la méthodepreprocess.
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] | None = None ) → list[Dict]
Paramètres
- outputs (
DetrObjectDetectionOutput) — Sorties brutes du modèle. - threshold (
float, facultatif) — Seuil de score pour conserver les prédictions de détection d'objets. - target_sizes (
torch.Tensoroulist[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.
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.
post_process_semantic_segmentation
< source >( outputstarget_sizes: list[tuple[int, int]] | None = Nonereturn_segmentation_scores: bool = False ) → list[torch.Tensor] or list[SemanticSegmentationPostProcessorOutput]
Paramètres
- outputs (DetrForSegmentation) — Sorties brutes du modèle.
- target_sizes (
list[tuple[int, int]], facultatif) — Une liste de tuples (tuple[int, int]) contenant la taille cible (hauteur, largeur) de chaque image du lot. Si non défini, les prédictions ne seront pas redimensionnées. - return_segmentation_scores (
bool, facultatif, par défautFalse) — Indique s'il faut retourner les scores de segmentation en plus de la carte de segmentation. SiTrue, chaque élément de la liste retournée est unSemanticSegmentationPostProcessorOutputavec les champssegmentation(IDs de classes, forme(height, width)) etsegmentation_scores(forme(num_classes, height, width)).
Retourne
list[torch.Tensor] ou list[SemanticSegmentationPostProcessorOutput]
Lorsque
return_segmentation_scores=False (par défaut), une liste de longueur batch_size où chaque élément est une
carte de segmentation de forme (height, width) avec des identifiants de classes. Lorsque return_segmentation_scores=True,
une liste de SemanticSegmentationPostProcessorOutput avec les champs segmentation (identifiants de classes, forme
(height, width)) et segmentation_scores (forme (num_classes, height, width)). Dans les deux cas,
(height, width) correspond à la taille cible (si target_sizes est spécifiée).
Convertit la sortie de DetrForSegmentation en cartes de segmentation sémantique. Prend uniquement en charge PyTorch.
post_process_instance_segmentation
< source >( outputsthreshold: float = 0.5mask_threshold: float = 0.5overlap_mask_area_threshold: float = 0.8target_sizes: list[tuple[int, int]] | None = Nonereturn_coco_annotation: bool | None = False ) → list[Dict]
Paramètres
- outputs (DetrForSegmentation) — Sorties brutes du modèle.
- threshold (
float, facultatif, valeur par défaut 0.5) — Seuil de score de probabilité pour conserver les masques d’instances prédits. - mask_threshold (
float, facultatif, valeur par défaut 0.5) — Seuil à utiliser pour convertir les masques prédits en valeurs binaires. - overlap_mask_area_threshold (
float, facultatif, valeur par défaut 0.8) — Seuil de la zone du masque de chevauchement pour fusionner ou supprimer les petites parties déconnectées au sein de chaque masque d'instance binaire. - target_sizes (
list[Tuple], facultatif) — Liste de longueur (batch_size), où chaque élément de la liste (tuple[int, int]]) correspond à la taille finale demandée (hauteur, largeur) de chaque prédiction. Si non défini, les prédictions ne seront pas redimensionnées. - return_coco_annotation (
bool, facultatif) — Valeur par défaut :False. Si défini surTrue, les cartes de segmentation sont renvoyées au format d'encodage par longueur de course (RLE) de COCO.
Retourne
list[Dict]
Une liste de dictionnaires, un par image, chaque dictionnaire contenant deux clés :
- segmentation — Un tenseur de forme
(height, width)où chaque pixel représente unsegment_idoulist[List]encodage par longueur d’exécution (RLE) de la carte de segmentation si return_coco_annotation est défini surTrue. Défini surNonesi aucun masque n’est trouvé au-dessus dethreshold. - segments_info — Un dictionnaire contenant des informations supplémentaires sur chaque segment.
- id — Un entier représentant le
segment_id. - label_id — Un entier représentant l’identifiant de la classe sémantique correspondant à
segment_id. - score — Score de prédiction du segment portant l'identifiant
segment_id.
- id — Un entier représentant le
Convertit la sortie de DetrForSegmentation en prédictions de segmentation d'instances. Prend uniquement en charge PyTorch.
post_process_panoptic_segmentation
< source >( outputsthreshold: float = 0.5mask_threshold: float = 0.5overlap_mask_area_threshold: float = 0.8label_ids_to_fuse: set[int] | None = Nonetarget_sizes: list[tuple[int, int]] | None = None ) → list[Dict]
Paramètres
- outputs (DetrForSegmentation) — Les sorties de DetrForSegmentation.
- threshold (
float, facultatif, valeur par défaut 0.5) — Seuil de score de probabilité pour conserver les masques d’instances prédits. - mask_threshold (
float, facultatif, valeur par défaut 0.5) — Seuil à utiliser pour convertir les masques prédits en valeurs binaires. - overlap_mask_area_threshold (
float, facultatif, valeur par défaut 0.8) — Seuil de la zone du masque de chevauchement pour fusionner ou supprimer les petites parties déconnectées au sein de chaque masque d'instance binaire. - label_ids_to_fuse (
Set[int], facultatif) — Les étiquettes de cet état verront toutes leurs instances fusionnées ensemble. Par exemple, on peut considérer qu’une image ne peut contenir qu’un seul ciel, mais plusieurs personnes ; l’identifiant de l’étiquette « sky » serait donc présent dans cet ensemble, mais pas celui de « person ». - target_sizes (
list[Tuple], facultatif) — Liste de longueur (batch_size), où chaque élément de la liste (tuple[int, int]]) correspond à la taille finale demandée (hauteur, largeur) de chaque prédiction du lot. Si non défini, les prédictions ne seront pas redimensionnées.
Retourne
list[Dict]
Une liste de dictionnaires, un par image, chaque dictionnaire contenant deux clés :
- segmentation — un tenseur de forme
(height, width)où chaque pixel représente unsegment_idouNonesi aucun masque n’est trouvé au-dessus dethreshold. Sitarget_sizesest spécifié, la segmentation est redimensionnée à l’entrée correspondante detarget_sizes. - segments_info — Un dictionnaire contenant des informations supplémentaires sur chaque segment.
- id — un entier représentant le
segment_id. - label_id — Un entier représentant l’identifiant de la classe sémantique correspondant à
segment_id. - was_fused — un booléen,
Truesilabel_idétait danslabel_ids_to_fuse,Falsesinon. Plusieurs instances de la même classe / étiquette ont été fusionnées et ont reçu un uniquesegment_id. - score — Score de prédiction du segment portant l'identifiant
segment_id.
- id — un entier représentant le
Convertit la sortie de DetrForSegmentation en prédictions de segmentation panoptique d’image. Prend uniquement en charge PyTorch.
Sorties spécifiques à DETR
classe transformers.models.detr.modeling_detr.DetrModelOutput
< source >( last_hidden_state: typing.Optional[torch.Tensor] = Nonepast_key_values: transformers.cache_utils.EncoderDecoderCache | None = Nonedecoder_hidden_states: tuple[torch.Tensor, ...] | None = Nonedecoder_attentions: tuple[torch.Tensor, ...] | None = Nonecross_attentions: tuple[torch.Tensor, ...] | None = Noneencoder_last_hidden_state: typing.Optional[torch.Tensor] = Noneencoder_hidden_states: tuple[torch.Tensor, ...] | None = Noneencoder_attentions: tuple[torch.Tensor, ...] | None = Noneintermediate_hidden_states: typing.Optional[torch.Tensor] = None )
Paramètres
- last_hidden_state (
torch.Tensorde forme(batch_size, sequence_length, hidden_size)) — Séquence d'états cachés à la sortie de la dernière couche du décodeur du modèle.Si
past_key_valuesest utilisé, seule la dernière hidden-state des séquences de forme(batch_size, 1, hidden_size)est renvoyée. - past_key_values (
EncoderDecoderCache, facultatif, renvoyé lorsqueuse_cache=Trueest passé ou lorsqueconfig.use_cache=True) — C'est une EncoderDecoderCache instance. Pour plus de détails, consultez notre guide sur le cache kv.Contient des états cachés précalculés (clés et valeurs dans les blocs d'auto-attention et dans les blocs d'attention croisée) qui peuvent être utilisés (voir l'entrée
past_key_values) pour accélérer le décodage séquentiel. - decoder_hidden_states (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.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 d'incorporation initiale facultatives.
- decoder_attentions (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.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é lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.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.Tensorde 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é lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.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 d'incorporation initiales facultatives.
- encoder_attentions (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.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.
- intermediate_hidden_states (
torch.Tensorde forme(config.decoder_layers, batch_size, sequence_length, hidden_size), facultatif, renvoyé lorsqueconfig.auxiliary_loss=True) — Activations intermédiaires du décodeur, c’est-à-dire la sortie de chaque couche du décodeur, chacune ayant passé par une layernorm.
Classe de base pour les sorties du modèle encodeur-décodeur DETR. Cette classe ajoute un attribut à Seq2SeqModelOutput, à savoir une pile optionnelle d'activations intermédiaires du décodeur, c'est-à-dire la sortie de chaque couche du décodeur, chacune ayant passé par une normalisation de couche. Cela est utile lors de l'entraînement du modèle avec des pertes de décodage auxiliaires.
classe transformers.models.detr.modeling_detr.DetrObjectDetectionOutput
< source >( loss: typing.Optional[torch.Tensor] = Noneloss_dict: dict | None = Nonelogits: typing.Optional[torch.Tensor] = Nonepred_boxes: typing.Optional[torch.Tensor] = Noneauxiliary_outputs: list[dict] | None = Nonelast_hidden_state: typing.Optional[torch.Tensor] = Nonedecoder_hidden_states: tuple[torch.Tensor] | None = Nonedecoder_attentions: tuple[torch.Tensor] | None = Nonecross_attentions: tuple[torch.Tensor] | None = Noneencoder_last_hidden_state: typing.Optional[torch.Tensor] = Noneencoder_hidden_states: tuple[torch.Tensor] | None = Noneencoder_attentions: tuple[torch.Tensor] | None = None )
Paramètres
- loss (
torch.Tensorde forme(1,), facultatif, renvoyé lorsquelabelsest fourni)) — Perte totale en tant que combinaison linéaire d'une négation de la 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.Tensorde forme(batch_size, num_queries, num_classes + 1)) — Logits de classification (y compris no-object) pour toutes les requêtes. - pred_boxes (
torch.Tensorde 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. - auxiliary_outputs (
list[Dict], facultatif) — Facultatif, renvoyé uniquement lorsque les pertes auxiliaires sont activées (c.-à-d.config.auxiliary_lossest défini surTrue) et que des étiquettes sont fournies. C'est une liste de dictionnaires contenant les deux clés ci-dessus (logitsetpred_boxes) pour chaque couche du décodeur. - last_hidden_state (
torch.Tensorde forme(batch_size, sequence_length, hidden_size), facultatif) — Séquence d'états cachés à la sortie de la dernière couche du décodeur du modèle. - decoder_hidden_states (
tuple[torch.Tensor], facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.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é lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.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é lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.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.Tensorde 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é lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.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é lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.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.
Type de sortie de DetrForObjectDetection.
classe transformers.models.detr.modeling_detr.DetrSegmentationOutput
< source >( loss: typing.Optional[torch.Tensor] = Noneloss_dict: dict | None = Nonelogits: typing.Optional[torch.Tensor] = Nonepred_boxes: typing.Optional[torch.Tensor] = Nonepred_masks: typing.Optional[torch.Tensor] = Noneauxiliary_outputs: list[dict] | None = Nonelast_hidden_state: typing.Optional[torch.Tensor] = Nonedecoder_hidden_states: tuple[torch.Tensor] | None = Nonedecoder_attentions: tuple[torch.Tensor] | None = Nonecross_attentions: tuple[torch.Tensor] | None = Noneencoder_last_hidden_state: typing.Optional[torch.Tensor] = Noneencoder_hidden_states: tuple[torch.Tensor] | None = Noneencoder_attentions: tuple[torch.Tensor] | None = None )
Paramètres
- loss (
torch.Tensorde forme(1,), facultatif, renvoyé lorsquelabelsest fourni)) — Perte totale en tant que combinaison linéaire d'une négation de la 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.Tensorde forme(batch_size, num_queries, num_classes + 1)) — Logits de classification (y compris no-object) pour toutes les requêtes. - pred_boxes (
torch.Tensorde 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. - pred_masks (
torch.Tensorde forme(batch_size, num_queries, height/4, width/4)) — Logits des masques de segmentation pour toutes les requêtes. Voir également post_process_semantic_segmentation() ou post_process_instance_segmentation() post_process_panoptic_segmentation() pour évaluer respectivement les masques de segmentation sémantique, d’instance et panoramique. - auxiliary_outputs (
list[Dict], facultatif) — Facultatif, renvoyé uniquement lorsque les pertes auxiliaires sont activées (c.-à-d.config.auxiliary_lossest défini surTrue) et que des étiquettes sont fournies. C'est une liste de dictionnaires contenant les deux clés ci-dessus (logitsetpred_boxes) pour chaque couche du décodeur. - last_hidden_state (
torch.Tensorde forme(batch_size, sequence_length, hidden_size), facultatif) — Séquence d'états cachés à la sortie de la dernière couche du décodeur du modèle. - decoder_hidden_states (
tuple[torch.Tensor], facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.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é lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.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é lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.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.Tensorde 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é lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.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é lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.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.
Type de sortie de DetrForSegmentation.
DetrModel
classe transformers.DetrModel
< source >( config: DetrConfig )
Paramètres
- config (DetrConfig) — 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 DETR brut (composé d'un backbone et d'un Transformer encodeur-décodeur) qui produit des états cachés bruts sans aucune tête spécifique 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: typing.Optional[torch.Tensor] = Nonepixel_mask: typing.Optional[torch.LongTensor] = Nonedecoder_attention_mask: typing.Optional[torch.Tensor] = Noneencoder_outputs: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonedecoder_inputs_embeds: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → DetrModelOutput or tuple(torch.Tensor)
Paramètres
- pixel_values (
torch.Tensorde forme(batch_size, num_channels, image_size, image_size), facultatif) — Les tenseurs correspondant aux images d’entrée. Les valeurs de pixels peuvent être obtenues à l’aide deimage_processor_class. Voirimage_processor_class.__call__pour plus de détails (processor_classutiliseimage_processor_classpour le traitement des images). - pixel_mask (
torch.LongTensorde 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).
- decoder_attention_mask (
torch.Tensorde forme(batch_size, num_queries), facultatif) — Masque pour éviter d'effectuer l'attention sur certaines requêtes d'objets dans le décodeur. Les valeurs du masque sont sélectionnées dans[0, 1]:- 1 pour les requêtes qui ne sont pas masquées,
- 0 pour les requêtes masquées.
- encoder_outputs (
torch.Tensor, facultatif) — Tuple composé de (last_hidden_state, facultatif :hidden_states, facultatif :attentions)last_hidden_statede 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.Tensorde 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. Utile pour contourner le backbone visuel. - decoder_inputs_embeds (
torch.Tensorde forme(batch_size, num_queries, hidden_size), facultatif) — Facultativement, au lieu d’initialiser les requêtes avec un tenseur de zéros, vous pouvez choisir de passer directement une représentation intégrée. Utile pour les tâches qui nécessitent une initialisation personnalisée des requêtes.
Retourne
DetrModelOutput ou tuple(torch.Tensor)
Un DetrModelOutput 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 DetrModel 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
Moduleplutô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.Tensorde forme(batch_size, sequence_length, hidden_size)) — Séquence d'états cachés à la sortie de la dernière couche du décodeur du modèle.Si
past_key_valuesest utilisé, seule la dernière hidden-state des séquences de forme(batch_size, 1, hidden_size)est renvoyée.past_key_values (
EncoderDecoderCache, facultatif, renvoyé lorsqueuse_cache=Trueest passé ou lorsqueconfig.use_cache=True) — Il s’agit d’une instance de EncoderDecoderCache. Pour plus de détails, consultez notre guide sur le cache kv.Contient des états cachés précalculés (clés et valeurs dans les blocs d'auto-attention et dans les blocs d'attention croisée) qui peuvent être utilisés (voir l'entrée
past_key_values) pour accélérer le décodage séquentiel.decoder_hidden_states (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.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 d'incorporation initiale facultatives.
decoder_attentions (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.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é lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.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.Tensorde 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é lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.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 d'incorporation initiales facultatives.
encoder_attentions (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.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.
intermediate_hidden_states (
torch.Tensorde forme(config.decoder_layers, batch_size, sequence_length, hidden_size), facultatif, renvoyé lorsqueconfig.auxiliary_loss=True) — Activations intermédiaires du décodeur, c’est-à-dire la sortie de chaque couche du décodeur, chacune ayant passé par une layernorm.
Exemples :
>>> from transformers import AutoImageProcessor, DetrModel
>>> 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("facebook/detr-resnet-50")
>>> model = DetrModel.from_pretrained("facebook/detr-resnet-50")
>>> # prepare image for the model
>>> inputs = image_processor(images=image, return_tensors="pt")
>>> # forward pass
>>> outputs = model(**inputs)
>>> # the last hidden states are the final query embeddings of the Transformer decoder
>>> # these are of shape (batch_size, num_queries, hidden_size)
>>> last_hidden_states = outputs.last_hidden_state
>>> list(last_hidden_states.shape)
[1, 100, 256]DetrForObjectDetection
classe transformers.DetrForObjectDetection
< source >( config: DetrConfig )
Paramètres
- config (DetrConfig) — 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 DETR (composé d'un backbone et d'un Transformer encodeur-décodeur) avec des têtes de détection d'objets au sommet, pour des tâches telles que la détection COCO.
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] = Nonedecoder_attention_mask: typing.Optional[torch.Tensor] = Noneencoder_outputs: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonedecoder_inputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: list[dict] | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → DetrObjectDetectionOutput or tuple(torch.Tensor)
Paramètres
- pixel_values (
torch.Tensorde 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 deimage_processor_class. Voirimage_processor_class.__call__pour plus de détails (processor_classutiliseimage_processor_classpour le traitement des images). - pixel_mask (
torch.LongTensorde 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).
- decoder_attention_mask (
torch.Tensorde forme(batch_size, num_queries), facultatif) — Masque pour éviter d'effectuer l'attention sur certaines requêtes d'objets dans le décodeur. Les valeurs du masque sont sélectionnées dans[0, 1]:- 1 pour les requêtes qui ne sont pas masquées,
- 0 pour les requêtes masquées.
- encoder_outputs (
torch.Tensor, facultatif) — Tuple composé de (last_hidden_state, facultatif :hidden_states, facultatif :attentions)last_hidden_statede 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.Tensorde 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. Utile pour contourner le backbone visuel. - decoder_inputs_embeds (
torch.Tensorde forme(batch_size, num_queries, hidden_size), facultatif) — Facultativement, au lieu d’initialiser les requêtes avec un tenseur de zéros, vous pouvez choisir de passer directement une représentation intégrée. Utile pour les tâches qui nécessitent une initialisation personnalisée des requêtes. - 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 untorch.LongTensorde longueur(number of bounding boxes in the image,)et les boîtes untorch.Tensorde forme(number of bounding boxes in the image, 4).
Retourne
DetrObjectDetectionOutput ou tuple(torch.Tensor)
Un DetrObjectDetectionOutput 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 DetrForObjectDetection 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
Moduleplutô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.Tensorde forme(1,), facultatif, renvoyé lorsquelabelsest 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.Tensorde forme(batch_size, num_queries, num_classes + 1)) — Logits de classification (y compris no-object) pour toutes les requêtes.pred_boxes (
torch.Tensorde 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.auxiliary_outputs (
list[Dict], facultatif) — Facultatif, renvoyé uniquement lorsque les pertes auxiliaires sont activées (c.-à-d.config.auxiliary_lossest défini surTrue) et que des étiquettes sont fournies. C'est une liste de dictionnaires contenant les deux clés ci-dessus (logitsetpred_boxes) pour chaque couche du décodeur.last_hidden_state (
torch.Tensorde forme(batch_size, sequence_length, hidden_size), facultatif) — Séquence d'états cachés à la sortie de la dernière couche du décodeur du modèle.decoder_hidden_states (
tuple[torch.Tensor], facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.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é lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.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é lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.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.Tensorde 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é lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.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é lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.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.
Exemples :
>>> from transformers import AutoImageProcessor, DetrForObjectDetection
>>> import torch
>>> 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("facebook/detr-resnet-50")
>>> model = DetrForObjectDetection.from_pretrained("facebook/detr-resnet-50")
>>> inputs = image_processor(images=image, return_tensors="pt")
>>> outputs = model(**inputs)
>>> # 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 remote with confidence 0.998 at location [40.16, 70.81, 175.55, 117.98]
Detected remote with confidence 0.996 at location [333.24, 72.55, 368.33, 187.66]
Detected couch with confidence 0.995 at location [-0.02, 1.15, 639.73, 473.76]
Detected cat with confidence 0.999 at location [13.24, 52.05, 314.02, 470.93]
Detected cat with confidence 0.999 at location [345.4, 23.85, 640.37, 368.72]DetrForSegmentation
classe transformers.DetrForSegmentation
< source >( config: DetrConfig )
Paramètres
- config (DetrConfig) — 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 DETR (composé d'un backbone et d'un Transformer encodeur-décodeur) avec une tête de segmentation au sommet, pour des tâches telles que la segmentation panoptique COCO.
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] = Nonedecoder_attention_mask: typing.Optional[torch.Tensor] = Noneencoder_outputs: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonedecoder_inputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: list[dict] | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → DetrSegmentationOutput or tuple(torch.Tensor)
Paramètres
- pixel_values (
torch.Tensorde 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 deimage_processor_class. Voirimage_processor_class.__call__pour plus de détails (processor_classutiliseimage_processor_classpour le traitement des images). - pixel_mask (
torch.LongTensorde 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).
- decoder_attention_mask (
torch.Tensorde forme(batch_size, num_queries), facultatif) — Masque pour éviter d'effectuer l'attention sur certaines requêtes d'objets dans le décodeur. Les valeurs du masque sont sélectionnées dans[0, 1]:- 1 pour les requêtes qui ne sont pas masquées,
- 0 pour les requêtes masquées.
- encoder_outputs (
torch.Tensor, facultatif) — Tuple composé de (last_hidden_state, facultatif :hidden_states, facultatif :attentions)last_hidden_statede 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.Tensorde forme(batch_size, sequence_length, hidden_size), facultatif) — Conservé pour la compatibilité ascendante, mais ne peut pas être utilisé pour la segmentation, car la segmentation nécessite des caractéristiques multi-échelles issues du backbone, qui ne sont pas disponibles lorsqu’on le contourne avec inputs_embeds. - decoder_inputs_embeds (
torch.Tensorde forme(batch_size, num_queries, hidden_size), facultatif) — Facultativement, au lieu d’initialiser les requêtes avec un tenseur de zéros, vous pouvez choisir de passer directement une représentation intégrée. Utile pour les tâches qui nécessitent une initialisation personnalisée des requêtes. - labels (
list[Dict]de longueur(batch_size,), facultatif) — Étiquettes pour le calcul de la perte de correspondance bipartite, de la perte DICE/F-1 et de la perte Focal. Liste de dictionnaires, chaque dictionnaire contenant au moins les 3 clés suivantes : ‘class_labels’, ‘boxes’ et ‘masks’ (respectivement les étiquettes de classe, les boîtes englobantes et les masques de segmentation d’une image du lot). Les étiquettes de classe elles-mêmes devraient être untorch.LongTensorde longueur(number of bounding boxes in the image,), les boîtes untorch.Tensorde forme(number of bounding boxes in the image, 4)et les masques untorch.Tensorde forme(number of bounding boxes in the image, height, width).
Retourne
DetrSegmentationOutput ou tuple(torch.Tensor)
Un DetrSegmentationOutput 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 DetrForSegmentation 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
Moduleplutô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.Tensorde forme(1,), facultatif, renvoyé lorsquelabelsest 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.Tensorde forme(batch_size, num_queries, num_classes + 1)) — Logits de classification (y compris no-object) pour toutes les requêtes.pred_boxes (
torch.Tensorde 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.pred_masks (
torch.Tensorde forme(batch_size, num_queries, height/4, width/4)) — Logits des masques de segmentation pour toutes les requêtes. Consultez également post_process_semantic_segmentation() ou post_process_instance_segmentation() post_process_panoptic_segmentation() pour évaluer respectivement les masques de segmentation sémantique, d’instance et panoptique.auxiliary_outputs (
list[Dict], facultatif) — Facultatif, renvoyé uniquement lorsque les pertes auxiliaires sont activées (c.-à-d.config.auxiliary_lossest défini surTrue) et que des étiquettes sont fournies. C'est une liste de dictionnaires contenant les deux clés ci-dessus (logitsetpred_boxes) pour chaque couche du décodeur.last_hidden_state (
torch.Tensorde forme(batch_size, sequence_length, hidden_size), facultatif) — Séquence d'états cachés à la sortie de la dernière couche du décodeur du modèle.decoder_hidden_states (
tuple[torch.Tensor], facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.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é lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.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é lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.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.Tensorde 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é lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.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é lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.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.
Exemples :
>>> import io
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO
>>> from PIL import Image
>>> import torch
>>> import numpy
>>> from transformers import AutoImageProcessor, DetrForSegmentation
>>> from transformers.image_transforms import rgb_to_id
>>> 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("facebook/detr-resnet-50-panoptic")
>>> model = DetrForSegmentation.from_pretrained("facebook/detr-resnet-50-panoptic")
>>> # prepare image for the model
>>> inputs = image_processor(images=image, return_tensors="pt")
>>> # forward pass
>>> outputs = model(**inputs)
>>> # Use the `post_process_panoptic_segmentation` method of the `image_processor` to retrieve post-processed panoptic segmentation maps
>>> # Segmentation results are returned as a list of dictionaries
>>> result = image_processor.post_process_panoptic_segmentation(outputs, target_sizes=[(300, 500)])
>>> # A tensor of shape (height, width) where each value denotes a segment id, filled with -1 if no segment is found
>>> panoptic_seg = result[0]["segmentation"]
>>> panoptic_seg.shape
torch.Size([300, 500])
>>> # Get prediction score and segment_id to class_id mapping of each segment
>>> panoptic_segments_info = result[0]["segments_info"]
>>> len(panoptic_segments_info)
5