Transformers documentation
OmDet-Turbo
Ce modèle a été publié dans HF papers le 2024-03-11 et ajouté à Hugging Face Transformers le 2024-09-25.
OmDet-Turbo
Aperçu
Le modèle OmDet-Turbo a été proposé dans Real-time Transformer-based Open-Vocabulary Detection with Efficient Fusion Head par Tiancheng Zhao, Peng Liu, Xuan He, Lu Zhang, Kyusong Lee. OmDet-Turbo intègre des composants de RT-DETR et introduit un module de fusion multimodale rapide afin d'atteindre des capacités de détection d'objets en vocabulaire ouvert en temps réel tout en maintenant une haute précision. Le modèle de base atteint des performances allant jusqu'à 100,2 FPS et 53,4 AP sur COCO zero-shot.
L'abstract de l'article est le suivant :
Les détecteurs basés sur des transformers de bout en bout (DETR) ont démontré des performances exceptionnelles dans les tâches de détection d'objets à ensemble fermé et à vocabulaire ouvert (OVD) grâce à l'intégration de modalités linguistiques. Cependant, leurs exigences computationnelles élevées ont freiné leur application pratique dans les scénarios de détection d'objets en temps réel (OD). Dans cet article, nous examinons les limites de deux modèles de référence du benchmark OVDEval, OmDet et Grounding-DINO, et nous présentons OmDet-Turbo. Ce nouveau modèle OVD en temps réel basé sur un transformer intègre un module innovant de tête de fusion efficace (EFH) conçu pour atténuer les goulots d'étranglement observés dans OmDet et Grounding-DINO. Notamment, OmDet-Turbo-Base atteint 100,2 images par seconde (FPS) avec l'application de TensorRT et de techniques de cache linguistique. Notons qu'en scénarios zero-shot sur les jeux de données COCO et LVIS, OmDet-Turbo atteint des niveaux de performance quasi équivalents à ceux des modèles supervisés de l'état de l'art actuels. De plus, il établit de nouveaux benchmarks de l'état de l'art sur ODinW et OVDEval, avec un AP de 30,1 et un NMS-AP de 26,86, respectivement. La praticité d'OmDet-Turbo dans les applications industrielles est soulignée par ses performances exceptionnelles sur les jeux de données de référence et sa vitesse d'inférence supérieure, ce qui en fait un choix convaincant pour les tâches de détection d'objets en temps réel.
OmDet-Turbo architecture overview. Taken from the original paper. Ce modèle a été contribué par yonigozlan. Le code d'origine peut être trouvé ici.
Conseils d'utilisation
Une propriété unique d'OmDet-Turbo par rapport à d'autres modèles de détection d'objets en zéro tirage, tels que Grounding DINO, est la structure découplée des classes et des embeddings de prompt, qui permet la mise en cache des embeddings de texte. Cela signifie que le modèle a besoin à la fois des classes et de la tâche en entrée, où classes est une liste d'objets que nous souhaitons détecter et task est le texte ancré utilisé pour guider la détection en vocabulaire ouvert. Cette approche limite le périmètre de la détection en vocabulaire ouvert et accélère le processus de décodage.
OmDetTurboProcessor est utilisé pour préparer le triplet classes, tâche et image. L’entrée de la tâche est facultative et, lorsqu’elle n’est pas fournie, elle prend par défaut la valeur "Detect [class1], [class2], [class3], ...". Pour traiter les résultats du modèle, on peut utiliser post_process_grounded_object_detection de OmDetTurboProcessor. Notamment, cette fonction reçoit les classes en entrée, car, contrairement à d’autres modèles de détection d’objets zéro-shot, le découplage des embeddings de classes et de tâches signifie qu’aucun décodage des embeddings de classes prédites n’est nécessaire à l’étape de post-traitement, et les classes prédites peuvent être appariées directement aux classes fournies.
Exemple d'utilisation
Inférence sur une image unique
Voici comment charger le modèle et préparer les entrées pour effectuer la détection d’objets en zéro tir sur une image unique :
import torch
import requests
from PIL import Image
from transformers import AutoProcessor, OmDetTurboForObjectDetection
processor = AutoProcessor.from_pretrained("omlab/omdet-turbo-swin-tiny-hf")
model = OmDetTurboForObjectDetection.from_pretrained("omlab/omdet-turbo-swin-tiny-hf", device_map="auto")
url = "http://images.cocodataset.org/val2017/000000039769.jpg"
image = Image.open(requests.get(url, stream=True).raw)
text_labels = ["cat", "remote"]
inputs = processor(image, text=text_labels, return_tensors="pt").to(model.device)
with torch.no_grad():
outputs = model(**inputs)
# convert outputs (bounding boxes and class logits)
results = processor.post_process_grounded_object_detection(
outputs,
target_sizes=[(image.height, image.width)],
text_labels=text_labels,
threshold=0.3,
nms_threshold=0.3,
)
result = results[0]
boxes, scores, text_labels = result["boxes"], result["scores"], result["text_labels"]
for box, score, text_label in zip(boxes, scores, text_labels):
box = [round(i, 2) for i in box.tolist()]
print(f"Detected {text_label} with confidence {round(score.item(), 3)} at location {box}")
Detected remote with confidence 0.768 at location [39.89, 70.35, 176.74, 118.04]
Detected cat with confidence 0.72 at location [11.6, 54.19, 314.8, 473.95]
Detected remote with confidence 0.563 at location [333.38, 75.77, 370.7, 187.03]
Detected cat with confidence 0.552 at location [345.15, 23.95, 639.75, 371.67]Inférence multi-image
OmDet-Turbo peut effectuer une inférence par lots sur plusieurs images, avec prise en charge de différents prompts de texte et de classes dans le même lot :
import torch
import requests
from io import BytesIO
from PIL import Image
from transformers import AutoProcessor, OmDetTurboForObjectDetection
processor = AutoProcessor.from_pretrained("omlab/omdet-turbo-swin-tiny-hf")
model = OmDetTurboForObjectDetection.from_pretrained("omlab/omdet-turbo-swin-tiny-hf", device_map="auto")
url1 = "http://images.cocodataset.org/val2017/000000039769.jpg"
image1 = Image.open(BytesIO(requests.get(url1).content)).convert("RGB")
text_labels1 = ["cat", "remote"]
task1 = "Detect {}.".format(", ".join(text_labels1))
url2 = "http://images.cocodataset.org/train2017/000000257813.jpg"
image2 = Image.open(BytesIO(requests.get(url2).content)).convert("RGB")
text_labels2 = ["boat"]
task2 = "Detect everything that looks like a boat."
url3 = "https://huggingface.co/datasets/hf-internal-testing/transformers-synthetic-assets/resolve/main/images/statue_of_liberty.jpg"
image3 = Image.open(BytesIO(requests.get(url3).content)).convert("RGB")
text_labels3 = ["statue", "trees"]
task3 = "Focus on the foreground, detect statue and trees."
inputs = processor(
images=[image1, image2, image3],
text=[text_labels1, text_labels2, text_labels3],
task=[task1, task2, task3],
return_tensors="pt",
)
with torch.no_grad():
outputs = model(**inputs)
# convert outputs (bounding boxes and class logits)
results = processor.post_process_grounded_object_detection(
outputs,
text_labels=[text_labels1, text_labels2, text_labels3],
target_sizes=[(image.height, image.width) for image in [image1, image2, image3]],
threshold=0.2,
nms_threshold=0.3,
)
for i, result in enumerate(results):
for score, text_label, box in zip(
result["scores"], result["text_labels"], result["boxes"]
):
box = [round(i, 1) for i in box.tolist()]
print(
f"Detected {text_label} with confidence "
f"{round(score.item(), 2)} at location {box} in image {i}"
)
Detected remote with confidence 0.77 at location [39.9, 70.4, 176.7, 118.0] in image 0
Detected cat with confidence 0.72 at location [11.6, 54.2, 314.8, 474.0] in image 0
Detected remote with confidence 0.56 at location [333.4, 75.8, 370.7, 187.0] in image 0
Detected cat with confidence 0.55 at location [345.2, 24.0, 639.8, 371.7] in image 0
Detected boat with confidence 0.32 at location [146.9, 219.8, 209.6, 250.7] in image 1
Detected boat with confidence 0.3 at location [319.1, 223.2, 403.2, 238.4] in image 1
Detected boat with confidence 0.27 at location [37.7, 220.3, 84.0, 235.9] in image 1
Detected boat with confidence 0.22 at location [407.9, 207.0, 441.7, 220.2] in image 1
Detected statue with confidence 0.73 at location [544.7, 210.2, 651.9, 502.8] in image 2
Detected trees with confidence 0.25 at location [3.9, 584.3, 391.4, 785.6] in image 2
Detected trees with confidence 0.25 at location [1.4, 621.2, 118.2, 787.8] in image 2
Detected statue with confidence 0.2 at location [428.1, 205.5, 767.3, 759.5] in image 2
OmDetTurboConfig
classe transformers.OmDetTurboConfig
< 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 = Truetext_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonebackbone_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Noneapply_layernorm_after_vision_backbone: bool = Trueimage_size: int | list[int] | tuple[int, int] = 640disable_custom_kernels: bool = Falselayer_norm_eps: float = 1e-05batch_norm_eps: float = 1e-05init_std: float = 0.02text_projection_in_dim: int = 512text_projection_out_dim: int = 512task_encoder_hidden_dim: int = 1024class_embed_dim: int = 512class_distance_type: typing.Literal['cosine', 'dot'] = 'cosine'num_queries: int = 900csp_activation: str = 'silu'conv_norm_activation: str = 'gelu'encoder_feedforward_activation: str = 'relu'encoder_feedforward_dropout: float | int = 0.0encoder_dropout: float | int = 0.0hidden_expansion: int = 1encoder_hidden_dim: int = 256vision_features_channels: list[int] | tuple[int, ...] = (256, 256, 256)encoder_in_channels: list[int] | tuple[int, ...] = (192, 384, 768)encoder_projection_indices: list[int] | tuple[int, ...] = (2,)encoder_attention_heads: int = 8encoder_dim_feedforward: int = 2048encoder_layers: int = 1positional_encoding_temperature: int = 10000num_feature_levels: int = 3decoder_hidden_dim: int = 256decoder_num_heads: int = 8decoder_num_layers: int = 6decoder_activation: str = 'relu'decoder_dim_feedforward: int = 2048decoder_num_points: int = 4decoder_dropout: float | int = 0.0eval_size: int | None = Nonelearn_initial_query: bool = Falsecache_size: int = 100 )
Paramètres
- is_encoder_decoder (
bool, facultatif, valeur par défautTrue) — Indique si le modèle est utilisé comme encodeur/décodeur ou non. - text_config (
Union[dict, ~configuration_utils.PreTrainedConfig], facultatif) — L'objet de configuration ou le dictionnaire du backbone de texte. - backbone_config (
Union[dict, ~configuration_utils.PreTrainedConfig], facultatif) — La configuration du modèle backbone. - apply_layernorm_after_vision_backbone (
bool, facultatif, valeur par défautTrue) — Indique s'il faut appliquer une normalisation de couche aux cartes de caractéristiques de la sortie du backbone visuel. - image_size (
Union[int, list[int], tuple[int, int]], facultatif, par défaut640) — La taille (résolution) de chaque image. - disable_custom_kernels (
bool, facultatif, valeur par défautFalse) — Indique s'il faut désactiver les noyaux personnalisés. - layer_norm_eps (
float, facultatif, valeur par défaut1e-05) — L'épsilon utilisé par les couches de normalisation de couche. - batch_norm_eps (
float, facultatif, valeur par défaut1e-05) — L'épsilon utilisé par les couches de normalisation par lot. - 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. - text_projection_in_dim (
int, facultatif, par défaut 512) — La dimension d'entrée pour la projection du texte. - text_projection_out_dim (
int, facultatif, par défaut 512) — La dimension de sortie pour la projection du texte. - task_encoder_hidden_dim (
int, facultatif, valeur par défaut 1024) — La dimension du réseau de neurones à propagation avant pour l'encodeur de tâche. - class_embed_dim (
int, facultatif, par défaut 512) — La dimension des embeddings de classes. - class_distance_type (
str, facultatif, par défaut"cosine") — Le type de distance à utiliser pour comparer les classes prédites aux embeddings des classes projetées. Peut être"cosine"ou"dot". - num_queries (
int, facultatif, par défaut 900) — Le nombre de requêtes. - csp_activation (
str, facultatif, par défaut"silu") — La fonction d'activation des réseaux Cross Stage Partial (CSP) de l'encodeur. - conv_norm_activation (
str, facultatif, par défaut"gelu") — La fonction d'activation des couches ConvNormLayer de l'encodeur. - encoder_feedforward_activation (
str, facultatif, par défaut"relu") — La fonction d'activation du réseau feedforward de l'encodeur. - encoder_feedforward_dropout (
float, facultatif, valeur par défaut 0.0) — Taux de dropout appliqué après l'activation du réseau feedforward de l'encodeur. - encoder_dropout (
Union[float, int], facultatif, valeur par défaut0.0) — Le taux pour toutes les couches de dropout. - hidden_expansion (
int, facultatif, valeur par défaut 1) — Le facteur d'expansion des couches cachées des réseaux CSP dans l'encodeur. - encoder_hidden_dim (
int, facultatif, par défaut256) — Dimension des représentations cachées. - vision_features_channels (
tuple(int), facultatif, par défaut[256, 256, 256]) — Les canaux des fonctionnalités visuelles projetées utilisés comme entrées pour le décodeur. - encoder_in_channels (
List(int), facultatif, par défaut[192, 384, 768]) — Les canaux d'entrée pour l'encodeur. - encoder_projection_indices (
List(int), facultatif, valeur par défaut[2]) — Les indices des fonctionnalités d'entrée projetées par chaque couche. - encoder_attention_heads (
int, facultatif, valeur par défaut8) — Nombre de têtes d'attention pour chaque couche d'attention dans l'encodeur Transformer. - encoder_dim_feedforward (
int, facultatif, valeur par défaut 2048) — La dimension du réseau de propagation avant pour l'encodeur. - encoder_layers (
int, facultatif, valeur par défaut1) — Nombre de couches cachées dans l’encodeur Transformer. Utilise la même valeur quenum_layerssi non défini. - positional_encoding_temperature (
int, facultatif, valeur par défaut 10000) — La température du codage positionnel dans l'encodeur. - num_feature_levels (
int, facultatif, valeur par défaut 3) — Le nombre de niveaux de caractéristiques pour le module d'attention déformable multi-échelle du décodeur. - decoder_hidden_dim (
int, facultatif, valeur par défaut256) — Dimension des représentations cachées. - decoder_num_heads (
int, facultatif, valeur par défaut8) — Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer. - decoder_num_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_activation (
str, facultatif, par défaut"relu") — La fonction d'activation du décodeur. - decoder_dim_feedforward (
int, facultatif, valeur par défaut 2048) — La dimension du réseau de neurones à propagation avant du décodeur. - decoder_num_points (
int, facultatif, valeur par défaut 4) — Le nombre de points échantillonnés dans le module d'attention déformable multi-échelle du décodeur. - decoder_dropout (
float, facultatif, valeur par défaut 0.0) — Taux de dropout pour le décodeur. - eval_size (
tuple[int, int], facultatif) — Hauteur et largeur utilisées pour calculer la hauteur et la largeur effectives des embeddings de position après prise en compte du pas (voir RTDetr). - learn_initial_query (
bool, facultatif, par défautFalse) — Indique s'il faut apprendre la requête initiale. - cache_size (
int, facultatif, valeur par défaut 100) — Taille du cache pour les caches de classes et de prompts.
Ceci est la classe de configuration destinée à stocker la configuration d'un Omdet TurboModel. Elle est utilisée pour instancier un modèle Omdet Turbo 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 omlab/omdet-turbo-swin-tiny-hf
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 OmDetTurboConfig, OmDetTurboForObjectDetection
>>> # Initializing a OmDet-Turbo omlab/omdet-turbo-swin-tiny-hf style configuration
>>> configuration = OmDetTurboConfig()
>>> # Initializing a model (with random weights) from the omlab/omdet-turbo-swin-tiny-hf style configuration
>>> model = OmDetTurboForObjectDetection(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configOmDetTurboProcessor
classe transformers.OmDetTurboProcessor
< source >( image_processortokenizer )
Construit un OmDetTurboProcessor qui encapsule un processeur d’images et un tokeniseur en un seul processeur.
OmDetTurboProcessor offre toutes les fonctionnalités de DetrImageProcessor et de CLIPTokenizer. Consultez ~DetrImageProcessor et ~CLIPTokenizer pour plus d’informations.
__call__
< source >( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = Nonetext: list[str] | list[list[str]] | None = None**kwargs: *<class 'transformers.models.omdet_turbo.processing_omdet_turbo.OmDetTurboProcessorKwargs'> ) → ~feature_extraction_utils.BatchFeature
Paramètres
- images (
Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]], facultatif) — 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. - text (
Union[list[str], list[list[str]]], facultatif) — La séquence ou le lot de séquences à encoder. Chaque séquence peut être une chaîne de caractères ou une liste de chaînes de caractères (chaînes pré-tokenisées). Si vous passez une entrée pré-tokenisée, définissezis_split_into_words=Truepour éviter toute ambiguïté avec les entrées en lot. - task (
str, kwargs,list[str],TextInputouPreTokenizedInput, facultatif) — La ou les descriptions de tâche de détection à encoder. Si non fournie, une description de tâche par défaut est générée à partir de l'entréetext(par ex. « Detect {text}. »). Peut être une chaîne unique, une liste de chaînes (une par image) ou une entrée pré-tokenisée. La description de tâche guide le modèle sur les objets à détecter dans les images. - return_tensors (
strou TensorType, facultatif) — Si défini, renvoie des tenseurs d'un framework particulier. Les valeurs acceptées sont :'pt': Renvoie des objetstorch.Tensorde PyTorch.'np': Renvoie des objets NumPynp.ndarray.
- **kwargs (ProcessingKwargs, facultatif) — Options de traitement supplémentaires pour chaque modalité (texte, images, vidéos, audio). Les paramètres spécifiques au modèle sont répertoriés ci-dessus ; consultez la classe TypedDict pour la liste complète des arguments pris en charge.
Retourne
~feature_extraction_utils.BatchFeature
- data (
dict, facultatif) — Dictionnaire de listes/tableaux/tenseurs renvoyé par les méthodes call/pad (« input_values », « attention_mask », 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. - skip_tensor_conversion (
list[str]ouset[str], facultatif) — Liste ou ensemble de clés qui ne doivent PAS être converties en tenseurs, même sitensor_typeest spécifié.
post_process_grounded_object_detection
< source >( outputs: OmDetTurboObjectDetectionOutputtext_labels: list[str] | list[list[str]] | None = Nonethreshold: float = 0.3nms_threshold: float = 0.5target_sizes: transformers.utils.generic.TensorType | list[tuple] | None = Nonemax_num_det: int | None = None ) → list[Dict]
Paramètres
- outputs (
OmDetTurboObjectDetectionOutput) — Sorties brutes du modèle. - text_labels (Union[list[str], list[list[str]]], facultatif) —
Les noms des classes d'entrée. S'ils ne sont pas fournis,
text_labelssera défini surNonedansoutputs. - threshold (float, par défaut 0.3) — Ne renvoyer que les détections dont le score de confiance dépasse ce seuil.
- nms_threshold (float, par défaut 0.5) — Le seuil à utiliser pour la suppression du maximum non maximal des boîtes. Valeur dans [0, 1].
- 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. - max_num_det (
int, facultatif) — Le nombre maximal de détections à retourner.
Retourne
list[Dict]
Une liste de dictionnaires, chaque dictionnaire contenant les scores, les classes et les boîtes pour une image du lot, telles que prédites par le modèle.
Convertit la sortie brute de OmDetTurboForObjectDetection en boîtes englobantes finales au format (top_left_x, top_left_y, bottom_right_x, bottom_right_y) et récupère la classe de texte associée.
OmDetTurboForObjectDetection
classe transformers.OmDetTurboForObjectDetection
< source >( config: OmDetTurboConfig )
Paramètres
- config (OmDetTurboConfig) — 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 OmDetTurbo (composé d'un backbone visuel et d'un backbone textuel, et d'une architecture encodeur-décodeur) produisant des boîtes englobantes et des scores de classes 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: Tensorclasses_input_ids: LongTensorclasses_attention_mask: LongTensortasks_input_ids: LongTensortasks_attention_mask: LongTensorclasses_structure: LongTensorlabels: typing.Optional[torch.LongTensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → OmDetTurboObjectDetectionOutput 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 de DetrImageProcessor. Voir DetrImageProcessor.call() pour plus de détails (OmDetTurboProcessor utilise DetrImageProcessor pour le traitement des images). - classes_input_ids (
torch.LongTensorde forme(total_classes (>= batch_size), sequence_length)) — Indices des jetons de la séquence de classes d'entrée dans le vocabulaire du modèle de langage. Plusieurs classes peuvent être fournies pour chaque tâche, les classes tokenisées sont donc aplaties et la structure des classes est fournie dans l'argumentclasses_structure.Les indices peuvent être obtenus à l'aide de OmDetTurboProcessor. Consultez OmDetTurboProcessor.call() pour plus de détails.
- classes_attention_mask (
torch.BoolTensorde forme(total_classes (>= batch_size), num_classes, sequence_length)) — Masque d'attention pour les classes. Il s'agit d'un masque binaire indiquant quels jetons doivent être pris en compte par l'attention et lesquels non. - tasks_input_ids (
torch.LongTensorde forme(batch_size, sequence_length)) — Indices des jetons de la séquence de tâches d'entrée dans le vocabulaire du modèle de langage.Les indices peuvent être obtenus à l'aide de OmDetTurboProcessor. Consultez OmDetTurboProcessor.call() pour plus de détails.
- tasks_attention_mask (
torch.BoolTensorde forme(batch_size, sequence_length)) — Masque d'attention pour les tâches. Il s'agit d'un masque binaire qui indique quels jetons doivent être pris en compte et lesquels non. - classes_structure (
torch.LongTensorde forme(batch_size)) — Structure des classes. Ce tenseur indique le nombre de classes pour chaque tâche. - 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). - output_attentions (
bool, facultatif) — Indique s'il faut ou non retourner les tenseurs d'attention de toutes les couches d'attention. Consultezattentionssous les tenseurs retournés pour plus de détails. - output_hidden_states (
bool, facultatif) — Indique s'il faut retourner les états cachés de toutes les couches. Voirhidden_statessous les tenseurs retournés pour plus de détails. - return_dict (
bool, facultatif) — Indique s'il faut retourner un ModelOutput plutôt qu'un simple tuple.
Retourne
OmDetTurboObjectDetectionOutput ou tuple(torch.Tensor)
Un OmDetTurboObjectDetectionOutput 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 (OmDetTurboConfig) et des entrées.
La méthode forward de OmDetTurboForObjectDetection 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.Tensor, facultatif) — La valeur de la perte. - decoder_coord_logits (
torch.Tensorde forme(batch_size, num_queries, 4)) — Les logits de coordonnées prédits des objets. - decoder_class_logits (
torch.Tensorde forme(batch_size, num_queries, num_classes)) — La classe prédite des objets. - init_reference_points (
torch.Tensorde forme(batch_size, num_queries, 4)) — Les points de référence initiaux. - intermediate_reference_points (
tuple[tuple[torch.Tensor]], facultatif) — Les points de référence intermédiaires. - encoder_coord_logits (
torch.Tensorde forme(batch_size, num_queries, 4)) — Les coordonnées prédites des objets par l'encodeur. - encoder_class_logits (
tuple[torch.Tensor], facultatif) — La classe prédite des objets par l'encodeur. - encoder_extracted_states (
torch.Tensor, facultatif) — Les états extraits du Feature Pyramid Network (FPN) et du Path Aggregation Network (PAN) de l’encodeur. - decoder_hidden_states (
tuple[torch.Tensor], facultatif) — Tuple detorch.Tensor(un pour la sortie des embeddings + un pour la sortie de chaque couche) de forme(batch_size, sequence_length, hidden_size). États cachés du modèle à la sortie de chaque couche plus les sorties des embeddings initiaux. - decoder_attentions (
tuple[tuple[torch.Tensor]], facultatif) — Tuple de tuples detorch.Tensor(un pour l'attention de chaque couche) de forme(batch_size, num_heads, sequence_length, sequence_length). Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention, d'attention croisée et d'attention déformable multi-échelle. - encoder_hidden_states (
tuple[torch.Tensor], facultatif) — Tuple detorch.Tensor(un pour la sortie des embeddings + un pour la sortie de chaque couche) de forme(batch_size, sequence_length, hidden_size). États cachés du modèle à la sortie de chaque couche plus les sorties des embeddings initiaux. - encoder_attentions (
tuple[tuple[torch.Tensor]], facultatif) — Tuple de tuples detorch.Tensor(un pour l'attention de chaque couche) de forme(batch_size, num_heads, sequence_length, sequence_length). Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention, d'attention croisée et d'attention déformable multi-échelle. - classes_structure (
torch.LongTensor, facultatif) — Le nombre de classes interrogées pour chaque image.
Exemples :
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO
>>> from PIL import Image
>>> from transformers import AutoProcessor, OmDetTurboForObjectDetection
>>> processor = AutoProcessor.from_pretrained("omlab/omdet-turbo-swin-tiny-hf")
>>> model = OmDetTurboForObjectDetection.from_pretrained("omlab/omdet-turbo-swin-tiny-hf")
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> with httpx.stream("GET", url) as response:
... image = Image.open(BytesIO(response.read()))
>>> classes = ["cat", "remote"]
>>> task = "Detect {}.".format(", ".join(classes))
>>> inputs = processor(image, text=classes, task=task, return_tensors="pt")
>>> outputs = model(**inputs)
>>> # convert outputs (bounding boxes and class logits)
>>> results = processor.post_process_grounded_object_detection(
... outputs,
... classes=classes,
... target_sizes=[image.size[::-1]],
... score_threshold=0.3,
... nms_threshold=0.3,
>>> )[0]
>>> for score, class_name, box in zip(results["scores"], results["classes"], results["boxes"]):
... box = [round(i, 1) for i in box.tolist()]
... print(
... f"Detected {class_name} with confidence "
... f"{round(score.item(), 2)} at location {box}"
... )
Detected remote with confidence 0.76 at location [39.9, 71.3, 176.5, 117.9]
Detected cat with confidence 0.72 at location [345.1, 22.5, 639.7, 371.9]
Detected cat with confidence 0.65 at location [12.7, 53.8, 315.5, 475.3]
Detected remote with confidence 0.57 at location [333.4, 75.6, 370.7, 187.0]