# OmDet-Turbo

## Visão geral

O modelo OmDet-Turbo foi proposto em [Real-time Transformer-based Open-Vocabulary Detection with Efficient Fusion Head](https://huggingface.co/papers/2403.06892) por Tiancheng Zhao, Peng Liu, Xuan He, Lu Zhang, Kyusong Lee. O OmDet-Turbo incorpora componentes do RT-DETR e introduz um módulo de fusão multimodal ágil para alcançar capacidades de detecção de objetos em vocabulário aberto em tempo real, mantendo alta precisão. O modelo base atinge desempenho de até 100,2 FPS e 53,4 AP no COCO zero-shot.

O resumo do artigo é o seguinte:

*Detectores baseados em transformers de ponta a ponta (DETRs) demonstraram desempenho excepcional em tarefas de detecção de objetos em conjunto fechado e de vocabulário aberto (OVD) por meio da integração de modalidades de linguagem. No entanto, seus requisitos computacionais exigentes têm impedido sua aplicação prática em cenários de detecção de objetos em tempo real (OD). Neste artigo, analisamos as limitações de dois modelos de destaque no benchmark OVDEval, OmDet e Grounding-DINO, e apresentamos o OmDet-Turbo. Este novo modelo de OVD em tempo real baseado em transformers apresenta um módulo inovador de Cabeça de Fusão Eficiente (EFH) projetado para aliviar os gargalos observados no OmDet e no Grounding-DINO. Notavelmente, o OmDet-Turbo-Base atinge 100,2 quadros por segundo (FPS) com a aplicação de técnicas de TensorRT e cache de linguagem. Notavelmente, em cenários zero-shot nos conjuntos de dados COCO e LVIS, o OmDet-Turbo atinge níveis de desempenho quase equivalentes aos dos modelos supervisionados de estado da arte atuais. Além disso, ele estabelece novos benchmarks de estado da arte no ODinW e no OVDEval, com um AP de 30,1 e um NMS-AP de 26,86, respectivamente. A praticidade do OmDet-Turbo em aplicações industriais é destacada por seu desempenho excepcional em conjuntos de dados de referência e pela sua velocidade de inferência superior, posicionando-o como uma escolha atraente para tarefas de detecção de objetos em tempo real.*

 Visão geral da arquitetura do OmDet-Turbo. Retirada do artigo original.

Este modelo foi contribuído por [yonigozlan](https://huggingface.co/yonigozlan). O código original pode ser encontrado [aqui](https://github.com/om-ai-lab/OmDet).

## Dicas de uso

Uma propriedade única do OmDet-Turbo em comparação com outros modelos de detecção de objetos zero-shot, como o [Grounding DINO](grounding-dino), é a estrutura desacoplada de classes e embeddings de prompt, que permite o cache de embeddings de texto. Isso significa que o modelo requer tanto classes quanto a tarefa como entradas, em que classes é uma lista de objetos que queremos detectar e task é o texto ancorado usado para orientar a detecção de vocabulário aberto. Essa abordagem limita o escopo da detecção de vocabulário aberto e torna o processo de decodificação mais rápido.

[OmDetTurboProcessor](/docs/transformers/main/pt/model_doc/omdet-turbo#transformers.OmDetTurboProcessor) é usado para preparar a tríade de classes, tarefa e imagem. A entrada de tarefa é opcional e, quando não fornecida, o valor padrão será `"Detect [class1], [class2], [class3], ..."`. Para processar os resultados do modelo, é possível usar `post_process_grounded_object_detection` de [OmDetTurboProcessor](/docs/transformers/main/pt/model_doc/omdet-turbo#transformers.OmDetTurboProcessor). Notavelmente, essa função recebe as classes de entrada, pois, ao contrário de outros modelos de detecção de objetos zero-shot, o desacoplamento dos embeddings de classes e de tarefa significa que não é necessário decodificar os embeddings de classe previstos na etapa de pós-processamento, e as classes previstas podem ser correspondidas diretamente às fornecidas.

## Exemplo de uso

### Inferência de uma única imagem

Aqui está como carregar o modelo e preparar as entradas para realizar a detecção de objetos zero-shot em uma única imagem:

```python
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]
```

### Inferência com múltiplas imagens

O OmDet-Turbo pode executar inferência em lote com múltiplas imagens, com suporte a diferentes prompts de texto e classes no mesmo lote:

```python
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[[transformers.OmDetTurboConfig]]

#### transformers.OmDetTurboConfig[[transformers.OmDetTurboConfig]]

```python
transformers.OmDetTurboConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, is_encoder_decoder: bool = True, text_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, backbone_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, apply_layernorm_after_vision_backbone: bool = True, image_size: int | list[int] | tuple[int, int] = 640, disable_custom_kernels: bool = False, layer_norm_eps: float = 1e-05, batch_norm_eps: float = 1e-05, init_std: float = 0.02, text_projection_in_dim: int = 512, text_projection_out_dim: int = 512, task_encoder_hidden_dim: int = 1024, class_embed_dim: int = 512, class_distance_type: typing.Literal['cosine', 'dot'] = 'cosine', num_queries: int = 900, csp_activation: str = 'silu', conv_norm_activation: str = 'gelu', encoder_feedforward_activation: str = 'relu', encoder_feedforward_dropout: float | int = 0.0, encoder_dropout: float | int = 0.0, hidden_expansion: int = 1, encoder_hidden_dim: int = 256, vision_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 = 8, encoder_dim_feedforward: int = 2048, encoder_layers: int = 1, positional_encoding_temperature: int = 10000, num_feature_levels: int = 3, decoder_hidden_dim: int = 256, decoder_num_heads: int = 8, decoder_num_layers: int = 6, decoder_activation: str = 'relu', decoder_dim_feedforward: int = 2048, decoder_num_points: int = 4, decoder_dropout: float | int = 0.0, eval_size: int | None = None, learn_initial_query: bool = False, cache_size: int = 100)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/omdet_turbo/configuration_omdet_turbo.py#L30)

**Parâmetros:**

is_encoder_decoder (`bool`, *opcional*, padrão `True`) : Indica se o modelo é usado como codificador/decodificador ou não.

text_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *opcional*) : O objeto de configuração ou dicionário do backbone de texto.

backbone_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *opcional*) : A configuração do modelo backbone.

apply_layernorm_after_vision_backbone (`bool`, *opcional*, padrão `True`) : Se deve aplicar a normalização de camada nos mapas de características da saída do backbone de visão.

image_size (`Union[int, list[int], tuple[int, int]]`, *opcional*, padrão `640`) : O tamanho (resolução) de cada imagem.

disable_custom_kernels (`bool`, *opcional*, padrão `False`) : Se deve desativar kernels personalizados.

layer_norm_eps (`float`, *opcional*, padrão `1e-05`) : O epsilon usado pelas camadas de normalização de camada.

batch_norm_eps (`float`, *opcional*, padrão `1e-05`) : O epsilon usado pelas camadas de normalização de lote.

init_std (`float`, *opcional*, padrão `0.02`) : O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos.

text_projection_in_dim (`int`, *opcional*, padrão 512) : A dimensão de entrada para a projeção de texto.

text_projection_out_dim (`int`, *opcional*, padrão 512) : A dimensão de saída para a projeção de texto.

task_encoder_hidden_dim (`int`, *opcional*, padrão 1024) : A dimensão do feedforward para o codificador de tarefa.

class_embed_dim (`int`, *opcional*, padrão 512) : A dimensão dos embeddings de classes.

class_distance_type (`str`, *opcional*, padrão `"cosine"`) : O tipo de distância para comparar as classes previstas com os embeddings das classes projetadas. Pode ser `"cosine"` ou `"dot"`.

num_queries (`int`, *opcional*, padrão 900) : O número de consultas.

csp_activation (`str`, *opcional*, padrão `"silu"`) : A função de ativação das redes Cross Stage Partial (CSP) do codificador.

conv_norm_activation (`str`, *opcional*, padrão `"gelu"`) : A função de ativação das camadas ConvNormLayer do codificador.

encoder_feedforward_activation (`str`, *opcional*, padrão `"relu"`) : A função de ativação para a rede feedforward do codificador.

encoder_feedforward_dropout (`float`, *opcional*, padrão 0.0) : A taxa de dropout após a ativação da rede feedforward do codificador.

encoder_dropout (`Union[float, int]`, *opcional*, padrão `0.0`) : A proporção para todas as camadas de dropout.

hidden_expansion (`int`, *opcional*, padrão 1) : A expansão oculta das redes CSP no codificador.

encoder_hidden_dim (`int`, *opcional*, padrão `256`) : Dimensão das representações ocultas.

vision_features_channels (`tuple(int)`, *opcional*, padrão `[256, 256, 256]`) : Os canais de recursos visuais projetados usados como entradas para o decodificador.

encoder_in_channels (`List(int)`, *opcional*, padrão `[192, 384, 768]`) : Os canais de entrada para o codificador.

encoder_projection_indices (`List(int)`, *opcional*, padrão `[2]`) : Os índices dos recursos de entrada projetados por cada camada.

encoder_attention_heads (`int`, *opcional*, padrão `8`) : Número de cabeças de atenção para cada camada de atenção no codificador do Transformer.

encoder_dim_feedforward (`int`, *opcional*, padrão 2048) : A dimensão do feedforward para o codificador.

encoder_layers (`int`, *opcional*, padrão `1`) : Número de camadas ocultas no codificador do Transformer. Usará o mesmo valor de `num_layers` se não for definido.

positional_encoding_temperature (`int`, *opcional*, padrão 10000) : A temperatura da codificação posicional no codificador.

num_feature_levels (`int`, *opcional*, padrão 3) : O número de níveis de características para o módulo de atenção deformável multiescala do decodificador.

decoder_hidden_dim (`int`, *opcional*, padrão `256`) : Dimensão das representações ocultas.

decoder_num_heads (`int`, *opcional*, padrão `8`) : Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer.

decoder_num_layers (`int`, *opcional*, padrão `6`) : Número de camadas ocultas no decodificador do Transformer. Usará o mesmo valor de `num_layers` se não for definido.

decoder_activation (`str`, *opcional*, padrão `"relu"`) : A função de ativação para o decodificador.

decoder_dim_feedforward (`int`, *opcional*, padrão 2048) : A dimensão do feedforward para o decodificador.

decoder_num_points (`int`, *opcional*, padrão 4) : O número de pontos amostrados no módulo de atenção deformável multiescala do decodificador.

decoder_dropout (`float`, *opcional*, padrão 0.0) : A taxa de dropout para o decodificador.

eval_size (`tuple[int, int]`, *opcional*) : Altura e largura usadas para calcular a altura e a largura efetivas dos embeddings de posição após considerar o stride (veja RTDetr).

learn_initial_query (`bool`, *opcional*, padrão `False`) : Se deve aprender a consulta inicial.

cache_size (`int`, *opcional*, padrão 100) : O tamanho do cache para os caches de classes e prompts.

Esta é a classe de configuração para armazenar a configuração de um Omdet TurboModel. Ela é usada para instanciar um modelo Omdet Turbo de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do [omlab/omdet-turbo-swin-tiny-hf](https://huggingface.co/omlab/omdet-turbo-swin-tiny-hf)

Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações.

Exemplos:

```python
>>> 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.config
```

## OmDetTurboProcessor[[transformers.OmDetTurboProcessor]]

#### transformers.OmDetTurboProcessor[[transformers.OmDetTurboProcessor]]

```python
transformers.OmDetTurboProcessor(image_processor, tokenizer)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/omdet_turbo/processing_omdet_turbo.py#L190)

**Parâmetros:**

image_processor (`DetrImageProcessor`) : O processador de imagem é uma entrada obrigatória.

tokenizer (`CLIPTokenizer`) : O tokenizer é uma entrada obrigatória.

Constrói um OmDetTurboProcessor que encapsula um processador de imagem e um tokenizer em um único processador.

[OmDetTurboProcessor](/docs/transformers/main/pt/model_doc/omdet-turbo#transformers.OmDetTurboProcessor) oferece todas as funcionalidades de [DetrImageProcessor](/docs/transformers/main/pt/model_doc/detr#transformers.DetrImageProcessor) e [CLIPTokenizer](/docs/transformers/main/pt/model_doc/clip#transformers.CLIPTokenizer). Consulte [~DetrImageProcessor](/docs/transformers/main/pt/model_doc/detr#transformers.DetrImageProcessor) e [~CLIPTokenizer](/docs/transformers/main/pt/model_doc/clip#transformers.CLIPTokenizer) para mais informações.

#### __call__[[transformers.OmDetTurboProcessor.__call__]]

```python
__call__(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = None, text: list[str] | list[list[str]] | None = None, **kwargs: *<class 'transformers.models.omdet_turbo.processing_omdet_turbo.OmDetTurboProcessorKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/omdet_turbo/processing_omdet_turbo.py#L196)

**Parâmetros:**

images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`, *opcional*) : Imagem a ser pré-processada. Espera uma única imagem ou um lote de imagens com valores de pixel variando de 0 a 255. Se estiver passando imagens com valores de pixel entre 0 e 1, defina `do_rescale=False`.

text (`Union[list[str], list[list[str]]]`, *opcional*) : A sequência ou lote de sequências a serem codificadas. Cada sequência pode ser uma string ou uma lista de strings (string pretokenizada). Se você passar uma entrada pretokenizada, defina `is_split_into_words=True` para evitar ambiguidade com entradas em lote.

task (`str`, *kwargs*, `list[str]`, `TextInput` ou `PreTokenizedInput`, *opcional*) : As descrições de tarefa de detecção a serem codificadas. Se não fornecidas, uma descrição de tarefa padrão é gerada a partir da entrada `text` (por exemplo, "Detect {text}."). Pode ser uma única string, uma lista de strings (uma por imagem) ou entrada pré-tokenizada. A descrição da tarefa orienta o modelo sobre quais objetos detectar nas imagens.

return_tensors (`str` ou [TensorType](/docs/transformers/main/pt/internal/file_utils#transformers.TensorType), *opcional*) : Se definido, retornará tensores de um framework específico. Os valores aceitos são:  - `'pt'`: Retorna objetos `torch.Tensor` do PyTorch. - `'np'`: Retorna objetos `np.ndarray` do NumPy.

- ****kwargs** ([ProcessingKwargs](/docs/transformers/main/pt/main_classes/processors#transformers.ProcessingKwargs), *opcional*) : Opções de processamento adicionais para cada modalidade (texto, imagens, vídeos, áudio). Os parâmetros específicos do modelo estão listados acima; consulte a classe TypedDict para a lista completa de argumentos suportados.

**Retorna:** `~feature_extraction_utils.BatchFeature`

- **data** (`dict`, *opcional*) -- Dicionário de listas/arrays/tensors retornados pelos métodos __call__/pad ('input_values', 'attention_mask', etc.).
- **tensor_type** (`Union[None, str, TensorType]`, *opcional*) -- Você pode fornecer um tensor_type aqui para converter as listas de inteiros em Tensors do PyTorch/Numpy na inicialização.
- **skip_tensor_conversion** (`list[str]` ou `set[str]`, *opcional*) -- Lista ou conjunto de chaves que NÃO devem ser convertidas em tensores, mesmo quando `tensor_type` for especificado.

#### post_process_grounded_object_detection[[transformers.OmDetTurboProcessor.post_process_grounded_object_detection]]

```python
post_process_grounded_object_detection(outputs: OmDetTurboObjectDetectionOutput, text_labels: list[str] | list[list[str]] | None = None, threshold: float = 0.3, nms_threshold: float = 0.5, target_sizes: transformers.utils.generic.TensorType | list[tuple] | None = None, max_num_det: int | None = None)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/omdet_turbo/processing_omdet_turbo.py#L266)

**Parâmetros:**

outputs (`OmDetTurboObjectDetectionOutput`) : Saídas brutas do modelo.

text_labels (Union[list[str], list[list[str]]], *opcional*) : Os nomes das classes de entrada. Se não for fornecido, `text_labels` será definido como `None` em `outputs`.

threshold (float, padrão 0,3) : Retorna apenas detecções com uma pontuação de confiança que exceda este limite.

nms_threshold (float, padrão 0.5) : O limiar a ser usado para a supressão de máximos não máximos de caixas. Valor em [0, 1].

target_sizes (`torch.Tensor` ou `list[tuple[int, int]]`, *opcional*) : Tensor de forma `(batch_size, 2)` ou lista de tuplas (`tuple[int, int]`) contendo o tamanho alvo `(height, width)` de cada imagem no lote. Se não definido, as previsões não serão redimensionadas.

max_num_det (`int`, *opcional*) : O número máximo de detecções a serem retornadas.

**Retorna:** `list[Dict]`

Uma lista de dicionários, em que cada dicionário contém as pontuações, classes e caixas para uma imagem no lote, conforme previsto pelo modelo.

Converte a saída bruta de [OmDetTurboForObjectDetection](/docs/transformers/main/pt/model_doc/omdet-turbo#transformers.OmDetTurboForObjectDetection) em caixas delimitadoras finais no formato (top_left_x, top_left_y, bottom_right_x, bottom_right_y) e obtém a classe de texto associada.

## OmDetTurboForObjectDetection[[transformers.OmDetTurboForObjectDetection]]

#### transformers.OmDetTurboForObjectDetection[[transformers.OmDetTurboForObjectDetection]]

```python
transformers.OmDetTurboForObjectDetection(config: OmDetTurboConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/omdet_turbo/modeling_omdet_turbo.py#L1464)

**Parâmetros:**

config ([OmDetTurboConfig](/docs/transformers/main/pt/model_doc/omdet-turbo#transformers.OmDetTurboConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo.

Modelo OmDetTurbo (composto por um backbone de visão e um backbone de texto, e arquitetura encoder-decoder) que gera bounding boxes e scores de classes para tarefas como detecção COCO.

Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.).

Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais.

#### forward[[transformers.OmDetTurboForObjectDetection.forward]]

```python
forward(pixel_values: Tensor, classes_input_ids: LongTensor, classes_attention_mask: LongTensor, tasks_input_ids: LongTensor, tasks_attention_mask: LongTensor, classes_structure: LongTensor, labels: typing.Optional[torch.LongTensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/omdet_turbo/modeling_omdet_turbo.py#L1494)

**Parâmetros:**

pixel_values (`torch.Tensor` de forma `(batch_size, num_channels, image_size, image_size)`) : Os tensores correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usando [DetrImageProcessor](/docs/transformers/main/pt/model_doc/detr#transformers.DetrImageProcessor). Veja [DetrImageProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para detalhes ([OmDetTurboProcessor](/docs/transformers/main/pt/model_doc/omdet-turbo#transformers.OmDetTurboProcessor) usa [DetrImageProcessor](/docs/transformers/main/pt/model_doc/detr#transformers.DetrImageProcessor) para processar imagens).

classes_input_ids (`torch.LongTensor` de forma `(total_classes (>= batch_size), sequence_length)`) : Índices dos tokens da sequência de classes de entrada no vocabulário do modelo de linguagem. Várias classes podem ser fornecidas para cada tarefa, portanto, as classes tokenizadas são achatadas e a estrutura das classes é fornecida no argumento `classes_structure`. Os índices podem ser obtidos usando [OmDetTurboProcessor](/docs/transformers/main/pt/model_doc/omdet-turbo#transformers.OmDetTurboProcessor). Veja [OmDetTurboProcessor.__call__()](/docs/transformers/main/pt/model_doc/omdet-turbo#transformers.OmDetTurboProcessor.__call__) para detalhes. [O que são IDs de entrada?](../glossary#input-ids)

classes_attention_mask (`torch.BoolTensor` de forma `(total_classes (>= batch_size), num_classes, sequence_length)`) : Máscara de atenção para as classes. Esta é uma máscara binária que indica quais tokens devem ser considerados na atenção e quais não devem.

tasks_input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices dos tokens da sequência de tarefas de entrada no vocabulário do modelo de linguagem. Os índices podem ser obtidos usando [OmDetTurboProcessor](/docs/transformers/main/pt/model_doc/omdet-turbo#transformers.OmDetTurboProcessor). Veja [OmDetTurboProcessor.__call__()](/docs/transformers/main/pt/model_doc/omdet-turbo#transformers.OmDetTurboProcessor.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids)

tasks_attention_mask (`torch.BoolTensor` de forma `(batch_size, sequence_length)`) : Máscara de atenção para as tarefas. Esta é uma máscara binária que indica quais tokens devem ser considerados na atenção e quais não devem.

classes_structure (`torch.LongTensor` de forma `(batch_size)`) : Estrutura das classes. Este tensor indica o número de classes para cada tarefa.

labels (`list[Dict]` of len `(batch_size,)`, *optional*) : Labels for computing the bipartite matching loss. List of dicts, each dictionary containing at least the following 2 keys: 'class_labels' and 'boxes' (the class labels and bounding boxes of an image in the batch respectively). The class labels themselves should be a `torch.LongTensor` of len `(number of bounding boxes in the image,)` and the boxes a `torch.Tensor` of shape `(number of bounding boxes in the image, 4)`.

output_attentions (`bool`, *opcional*) : Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulte `attentions` nos tensores retornados para mais detalhes.

output_hidden_states (`bool`, *opcional*) : Indica se os estados ocultos de todas as camadas devem ser retornados. Consulte `hidden_states` em tensores retornados para mais detalhes.

return_dict (`bool`, *opcional*) : Se deve ou não retornar um [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput) em vez de uma tupla simples.

**Retorna:** `OmDetTurboObjectDetectionOutput` ou `tuple(torch.Tensor)`

Um `OmDetTurboObjectDetectionOutput` ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos, dependendo da configuração ([OmDetTurboConfig](/docs/transformers/main/pt/model_doc/omdet-turbo#transformers.OmDetTurboConfig)) e das entradas.

O método forward da [OmDetTurboForObjectDetection](/docs/transformers/main/pt/model_doc/omdet-turbo#transformers.OmDetTurboForObjectDetection) substitui o método especial `__call__`.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

- **loss** (`torch.Tensor`, *opcional*) -- O valor da perda.
- **decoder_coord_logits** (`torch.Tensor` de forma `(batch_size, num_queries, 4)`) -- Os logits de coordenadas previstos dos objetos.
- **decoder_class_logits** (`torch.Tensor` de forma `(batch_size, num_queries, num_classes)`) -- A classe prevista dos objetos.
- **init_reference_points** (`torch.Tensor` de forma `(batch_size, num_queries, 4)`) -- Os pontos de referência iniciais.
- **intermediate_reference_points** (`tuple[tuple[torch.Tensor]]`, *opcional*) -- Os pontos de referência intermediários.
- **encoder_coord_logits** (`torch.Tensor` de forma `(batch_size, num_queries, 4)`) -- As coordenadas previstas dos objetos pelo codificador.
- **encoder_class_logits** (`tuple[torch.Tensor]`, *opcional*) -- A classe prevista dos objetos pelo encoder.
- **encoder_extracted_states** (`torch.Tensor`, *opcional*) -- Os estados extraídos da Feature Pyramid Network (FPN) e da Path Aggregation Network (PAN) do encoder.
- **decoder_hidden_states** (`tuple[torch.Tensor]`, *opcional*) -- Tupla de `torch.Tensor` (um para a saída dos embeddings + um para a saída de cada camada) com forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos do modelo na saída de cada camada, além das saídas dos embeddings iniciais.
- **decoder_attentions** (`tuple[tuple[torch.Tensor]]`, *opcional*) -- Tupla de tuplas de `torch.Tensor` (uma para a atenção de cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção, atenção cruzada e atenção deformável multiescala.
- **encoder_hidden_states** (`tuple[torch.Tensor]`, *opcional*) -- Tupla de `torch.Tensor` (um para a saída dos embeddings + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`. Hidden-states do modelo na saída de cada camada, além das saídas dos embeddings iniciais.
- **encoder_attentions** (`tuple[tuple[torch.Tensor]]`, *opcional*) -- Tupla de tuplas de `torch.Tensor` (uma para a atenção de cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção, atenção cruzada e atenção deformável multiescala.
- **classes_structure** (`torch.LongTensor`, *opcional*) -- O número de classes consultadas para cada imagem.

Exemplos:

```python
>>> 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]
```