# OmDet-Turbo

## Ikhtisar

Model OmDet-Turbo diusulkan dalam [Real-time Transformer-based Open-Vocabulary Detection with Efficient Fusion Head](https://huggingface.co/papers/2403.06892) oleh Tiancheng Zhao, Peng Liu, Xuan He, Lu Zhang, Kyusong Lee. OmDet-Turbo mengintegrasikan komponen dari RT-DETR dan memperkenalkan modul fusi multimodal yang cepat untuk mencapai kemampuan deteksi objek open-vocabulary secara real-time sambil mempertahankan akurasi tinggi. Model dasar mencapai kinerja hingga 100.2 FPS dan 53.4 AP pada COCO zero-shot.

Abstrak dari makalah tersebut adalah sebagai berikut:

*Detektor berbasis transformer end-to-end (DETR) telah menunjukkan kinerja luar biasa dalam tugas deteksi objek closed-set dan open-vocabulary (OVD) melalui integrasi modalitas bahasa. Namun, persyaratan komputasi yang berat telah menghambat penerapan praktisnya dalam skenario deteksi objek (OD) real-time. Dalam makalah ini, kami menelaah keterbatasan dua model terkemuka dalam benchmark OVDEval, yaitu OmDet dan Grounding-DINO, serta memperkenalkan OmDet-Turbo. Model OVD real-time berbasis transformer yang baru ini memiliki modul Efficient Fusion Head (EFH) yang inovatif, dirancang untuk meredakan bottleneck yang diamati pada OmDet dan Grounding-DINO. Secara khusus, OmDet-Turbo-Base mencapai 100,2 frame per detik (FPS) dengan penerapan TensorRT dan teknik bahasa cache. Yang patut dicatat, dalam skenario zero-shot pada dataset COCO dan LVIS, OmDet-Turbo mencapai tingkat kinerja yang hampir setara dengan model supervised state-of-the-art saat ini. Selain itu, model ini menetapkan benchmark state-of-the-art baru pada ODinW dan OVDEval, dengan AP sebesar 30,1 dan NMS-AP sebesar 26,86, masing-masing. Kelayakan OmDet-Turbo dalam aplikasi industri ditegaskan oleh kinerjanya yang luar biasa pada dataset benchmark dan kecepatan inferensi yang unggul, menjadikannya pilihan yang menarik untuk tugas deteksi objek real-time.*

 Gambaran arsitektur OmDet-Turbo. Diambil dari makalah aslinya.

Model ini disumbangkan oleh [yonigozlan](https://huggingface.co/yonigozlan). Kode aslinya dapat ditemukan [di sini](https://github.com/om-ai-lab/OmDet).

## Tips penggunaan

Satu sifat unik OmDet-Turbo dibandingkan model deteksi objek zero-shot lainnya, seperti [Grounding DINO](grounding-dino), adalah struktur kelas dan prompt embedding yang terpisah (decoupled) yang memungkinkan peng-cache-an (caching) text embeddings. Artinya, model memerlukan kelas dan tugas sebagai input, di mana kelas adalah daftar objek yang ingin dideteksi dan tugas adalah teks grounded yang digunakan untuk memandu deteksi open-vocabulary. Pendekatan ini membatasi cakupan deteksi open-vocabulary dan membuat proses decoding lebih cepat.

[OmDetTurboProcessor](/docs/transformers/main/id/model_doc/omdet-turbo#transformers.OmDetTurboProcessor) digunakan untuk menyiapkan triplet kelas, tugas, dan gambar. Input tugas bersifat opsional, dan jika tidak diberikan, nilainya akan secara default menjadi `"Detect [class1], [class2], [class3], ..."`. Untuk memproses hasil dari model, seseorang dapat menggunakan `post_process_grounded_object_detection` dari [OmDetTurboProcessor](/docs/transformers/main/id/model_doc/omdet-turbo#transformers.OmDetTurboProcessor). Perlu dicatat, fungsi ini menerima kelas input, karena berbeda dengan model deteksi objek zero-shot lainnya, pemisahan antara embedding kelas dan embedding tugas berarti tidak diperlukan decoding dari embedding kelas yang diprediksi pada langkah pasca-pemrosesan, dan kelas yang diprediksi dapat langsung dicocokkan dengan kelas yang diinputkan.

## Contoh penggunaan

### Inferensi gambar tunggal

Berikut cara memuat model dan menyiapkan input untuk melakukan deteksi objek zero-shot pada satu gambar:

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

### Inferensi multi gambar

OmDet-Turbo dapat melakukan inferensi multi-gambar secara batch, dengan dukungan untuk prompt teks dan kelas yang berbeda dalam batch yang sama:

```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)
```

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

**Parameter:**

is_encoder_decoder (`bool`, *opsional*, defaultnya `True`) : Apakah model digunakan sebagai encoder/decoder atau tidak.

text_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *opsional*) : Objek config atau dictionary dari text backbone.

backbone_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *opsional*) : Konfigurasi dari model backbone.

apply_layernorm_after_vision_backbone (`bool`, *opsional*, defaultnya `True`) : Apakah akan menerapkan layer normalization pada feature maps dari output vision backbone.

image_size (`Union[int, list[int], tuple[int, int]]`, *opsional*, defaultnya `640`) : Ukuran (resolusi) dari setiap gambar.

disable_custom_kernels (`bool`, *opsional*, defaultnya `False`) : Apakah akan menonaktifkan kernel kustom.

layer_norm_eps (`float`, *opsional*, defaultnya `1e-05`) : Epsilon yang digunakan oleh lapisan normalisasi lapisan.

batch_norm_eps (`float`, *opsional*, defaultnya `1e-05`) : Epsilon yang digunakan oleh lapisan normalisasi batch.

init_std (`float`, *opsional*, defaultnya `0.02`) : Deviasi standar dari truncated_normal_initializer untuk menginisialisasi semua matriks bobot.

text_projection_in_dim (`int`, *opsional*, default 512) : Dimensi input untuk proyeksi teks.

text_projection_out_dim (`int`, *opsional*, defaultnya 512) : Dimensi output untuk proyeksi teks.

task_encoder_hidden_dim (`int`, *opsional*, default 1024) : Dimensi feedforward untuk task encoder.

class_embed_dim (`int`, *opsional*, defaultnya 512) : Dimensi dari embedding kelas.

class_distance_type (`str`, *opsional*, defaultnya `"cosine"`) : Jenis jarak untuk membandingkan kelas prediksi dengan embedding kelas proyeksi. Bisa berupa `"cosine"` atau `"dot"`.

num_queries (`int`, *opsional*, default 900) : Jumlah query.

csp_activation (`str`, *opsional*, defaultnya `"silu"`) : Fungsi aktivasi dari jaringan Cross Stage Partial (CSP) pada encoder.

conv_norm_activation (`str`, *opsional*, defaultnya `"gelu"`) : Fungsi aktivasi dari lapisan ConvNormLayer pada encoder.

encoder_feedforward_activation (`str`, *opsional*, defaultnya `"relu"`) : Fungsi aktivasi untuk jaringan feedforward dari encoder.

encoder_feedforward_dropout (`float`, *opsional*, default 0.0) : Tingkat dropout setelah aktivasi jaringan feedforward encoder.

encoder_dropout (`Union[float, int]`, *opsional*, defaultnya `0.0`) : Rasio untuk semua lapisan dropout.

hidden_expansion (`int`, *opsional*, default 1) : Ekspansi tersembunyi dari jaringan CSP dalam encoder.

encoder_hidden_dim (`int`, *opsional*, defaultnya `256`) : Dimensi dari representasi tersembunyi.

vision_features_channels (`tuple(int)`, *opsional*, defaultnya `[256, 256, 256]`) : Kanal fitur visual yang diproyeksikan dan digunakan sebagai input untuk decoder.

encoder_in_channels (`List(int)`, *opsional*, defaultnya `[192, 384, 768]`) : Saluran input untuk encoder.

encoder_projection_indices (`List(int)`, *opsional*, defaultnya `[2]`) : Indeks dari fitur input yang diproyeksikan oleh setiap lapisan.

encoder_attention_heads (`int`, *opsional*, defaultnya `8`) : Jumlah kepala perhatian untuk setiap lapisan perhatian dalam encoder Transformer.

encoder_dim_feedforward (`int`, *opsional*, default 2048) : Dimensi feedforward untuk encoder.

encoder_layers (`int`, *opsional*, defaultnya `1`) : Jumlah lapisan tersembunyi dalam encoder Transformer. Akan menggunakan nilai yang sama dengan `num_layers` jika tidak diatur.

positional_encoding_temperature (`int`, *opsional*, default 10000) : Suhu encoding posisi di encoder.

num_feature_levels (`int`, *opsional*, defaultnya 3) : Jumlah level fitur untuk modul multi-scale deformable attention dari decoder.

decoder_hidden_dim (`int`, *opsional*, defaultnya `256`) : Dimensi dari representasi tersembunyi.

decoder_num_heads (`int`, *opsional*, defaultnya `8`) : Jumlah kepala perhatian untuk setiap lapisan perhatian dalam decoder Transformer.

decoder_num_layers (`int`, *opsional*, defaultnya `6`) : Jumlah lapisan tersembunyi dalam decoder Transformer. Akan menggunakan nilai yang sama dengan `num_layers` jika tidak diatur.

decoder_activation (`str`, *opsional*, defaultnya `"relu"`) : Fungsi aktivasi untuk decoder.

decoder_dim_feedforward (`int`, *opsional*, defaultnya 2048) : Dimensi feedforward untuk decoder.

decoder_num_points (`int`, *opsional*, defaultnya 4) : Jumlah titik yang disampelkan dalam modul perhatian deformable multi-skala pada decoder.

decoder_dropout (`float`, *opsional*, default 0.0) : Tingkat dropout untuk decoder.

eval_size (`tuple[int, int]`, *opsional*) : Tinggi dan lebar yang digunakan untuk menghitung tinggi dan lebar efektif dari posisi embedding setelah memperhitungkan stride (lihat RTDetr).

learn_initial_query (`bool`, *opsional*, defaultnya `False`) : Apakah akan mempelajari query awal.

cache_size (`int`, *opsional*, default 100) : Ukuran cache untuk cache kelas dan prompt.

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari Omdet TurboModel. Kelas ini digunakan untuk membuat instans model Omdet Turbo sesuai dengan argumen yang ditentukan, sehingga mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari [omlab/omdet-turbo-swin-tiny-hf](https://huggingface.co/omlab/omdet-turbo-swin-tiny-hf)

Objek konfigurasi mewarisi dari [PreTrainedConfig](/docs/transformers/main/id/main_classes/configuration#transformers.PreTrainedConfig) dan dapat digunakan untuk mengontrol keluaran model. Baca dokumentasi dari [PreTrainedConfig](/docs/transformers/main/id/main_classes/configuration#transformers.PreTrainedConfig) untuk informasi lebih lanjut.

Contoh:

```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)
```

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

**Parameter:**

image_processor (`DetrImageProcessor`) : Prosesor gambar adalah input yang wajib.

tokenizer (`CLIPTokenizer`) : Tokenizer adalah input yang wajib.

Membangun OmDetTurboProcessor yang membungkus image processor dan tokenizer menjadi satu processor.

[OmDetTurboProcessor](/docs/transformers/main/id/model_doc/omdet-turbo#transformers.OmDetTurboProcessor) menyediakan semua fungsionalitas dari [DetrImageProcessor](/docs/transformers/main/id/model_doc/detr#transformers.DetrImageProcessor) dan [CLIPTokenizer](/docs/transformers/main/id/model_doc/clip#transformers.CLIPTokenizer). Lihat [~DetrImageProcessor](/docs/transformers/main/id/model_doc/detr#transformers.DetrImageProcessor) dan [~CLIPTokenizer](/docs/transformers/main/id/model_doc/clip#transformers.CLIPTokenizer) untuk informasi lebih lanjut.

#### __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'>)
```

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

**Parameter:**

images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`, *opsional*) : Gambar untuk dipreprocess. Mengharapkan satu gambar atau batch gambar dengan nilai piksel berkisar dari 0 hingga 255. Jika memasukkan gambar dengan nilai piksel antara 0 dan 1, atur `do_rescale=False`.

text (`Union[list[str], list[list[str]]]`, *opsional*) : Urutan atau batch dari urutan yang akan dienkod. Setiap urutan dapat berupa string atau daftar string (string yang sudah dipretokenisasi). Jika Anda memasukkan input yang sudah dipretokenisasi, atur `is_split_into_words=True` untuk menghindari ambiguitas dengan input yang di-batch.

task (`str`, *kwargs*, `list[str]`, `TextInput`, atau `PreTokenizedInput`, *opsional*) : Deskripsi tugas deteksi yang akan dienkod. Jika tidak disediakan, deskripsi tugas default akan dihasilkan dari input `text` (misalnya, "Detect {text}."). Dapat berupa satu string, daftar string (satu per gambar), atau input pre-tokenized. Deskripsi tugas memandu model tentang objek apa yang harus dideteksi dalam gambar.

return_tensors (`str` atau [TensorType](/docs/transformers/main/id/internal/file_utils#transformers.TensorType), *opsional*) : Jika diatur, akan mengembalikan tensor dari framework tertentu. Nilai yang dapat diterima adalah:  - `'pt'`: Mengembalikan objek `torch.Tensor` PyTorch. - `'np'`: Mengembalikan objek `np.ndarray` NumPy.

- ****kwargs** ([ProcessingKwargs](/docs/transformers/main/id/main_classes/processors#transformers.ProcessingKwargs), *opsional*) : Opsi pemrosesan tambahan untuk setiap modalitas (teks, gambar, video, audio). Parameter spesifik model tercantum di atas; lihat kelas TypedDict untuk daftar lengkap argumen yang didukung.

**Mengembalikan:** `~feature_extraction_utils.BatchFeature`

- **data** (`dict`, *opsional*) -- Kamus berisi daftar/array/tensor yang dikembalikan oleh metode __call__/pad ('input_values', 'attention_mask', dll.).
- **tensor_type** (`Union[None, str, TensorType]`, *opsional*) -- Anda dapat memberikan tensor_type di sini untuk mengonversi daftar bilangan bulat menjadi Tensor PyTorch/Numpy saat inisialisasi.
- **skip_tensor_conversion** (`list[str]` atau `set[str]`, *opsional*) -- Daftar atau himpunan kunci yang TIDAK boleh dikonversi menjadi tensor, bahkan ketika `tensor_type` ditentukan.

#### 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)
```

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

**Parameter:**

outputs (`OmDetTurboObjectDetectionOutput`) : Output mentah dari model.

text_labels (Union[list[str], list[list[str]]], *opsional*) : Nama kelas input. Jika tidak disediakan, `text_labels` akan diset ke `None` di `outputs`.

threshold (float, default 0.3) : Hanya kembalikan deteksi dengan skor kepercayaan yang melebihi ambang batas ini.

nms_threshold (float, default 0.5) : Ambang batas yang digunakan untuk non-maximum suppression pada kotak. Nilai dalam [0, 1].

target_sizes (`torch.Tensor` atau `list[tuple[int, int]]`, *opsional*) : Tensor dengan bentuk `(batch_size, 2)` atau daftar tuple (`tuple[int, int]`) yang berisi ukuran target `(height, width)` dari setiap gambar dalam batch. Jika tidak diset, prediksi tidak akan di-resize.

max_num_det (`int`, *opsional*) : Jumlah maksimum deteksi yang akan dikembalikan.

**Mengembalikan:** `list[Dict]`

Daftar kamus, di mana setiap kamus berisi skor, kelas, dan kotak untuk sebuah gambar dalam batch sebagaimana diprediksi oleh model.

Mengonversi output mentah dari [OmDetTurboForObjectDetection](/docs/transformers/main/id/model_doc/omdet-turbo#transformers.OmDetTurboForObjectDetection) menjadi kotak batas akhir dalam format (top_left_x, top_left_y, bottom_right_x, bottom_right_y) dan mendapatkan kelas teks yang terkait.

## OmDetTurboForObjectDetection[[transformers.OmDetTurboForObjectDetection]]

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

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

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

**Parameter:**

config ([OmDetTurboConfig](/docs/transformers/main/id/model_doc/omdet-turbo#transformers.OmDetTurboConfig)) : Kelas konfigurasi model dengan semua parameter model. Inisialisasi dengan file konfigurasi tidak memuat bobot yang terkait dengan model, hanya konfigurasinya. Lihat metode [from_pretrained()](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk memuat bobot model.

Model OmDetTurbo (terdiri dari backbone visual dan teks, serta arsitektur encoder-decoder) yang menghasilkan bounding box dan skor kelas untuk tugas seperti deteksi COCO.

Model ini mewarisi dari [PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel). Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka ini untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran input embeddings, memangkas heads, dll.)

Model ini juga merupakan subclass dari [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) PyTorch. Gunakan sebagai PyTorch Module biasa dan merujuk ke dokumentasi PyTorch untuk semua hal yang berkaitan dengan penggunaan dan perilaku umum.

#### 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)
```

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

**Parameter:**

pixel_values (`torch.Tensor` dengan bentuk `(batch_size, num_channels, image_size, image_size)`) : Tensor yang sesuai dengan gambar input. Nilai piksel dapat diperoleh menggunakan [DetrImageProcessor](/docs/transformers/main/id/model_doc/detr#transformers.DetrImageProcessor). Lihat [DetrImageProcessor.__call__()](/docs/transformers/main/id/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) untuk detailnya ([OmDetTurboProcessor](/docs/transformers/main/id/model_doc/omdet-turbo#transformers.OmDetTurboProcessor) menggunakan [DetrImageProcessor](/docs/transformers/main/id/model_doc/detr#transformers.DetrImageProcessor) untuk memproses gambar).

classes_input_ids (`torch.LongTensor` dengan bentuk `(total_classes (>= batch_size), sequence_length)`) : Indeks token kelas input dalam kosakata model bahasa. Beberapa kelas dapat disediakan untuk setiap tugas, sehingga kelas yang ditokenisasi diratakan dan struktur kelasnya diberikan dalam argumen `classes_structure`. Indeks dapat diperoleh menggunakan [OmDetTurboProcessor](/docs/transformers/main/id/model_doc/omdet-turbo#transformers.OmDetTurboProcessor). Lihat [OmDetTurboProcessor.__call__()](/docs/transformers/main/id/model_doc/omdet-turbo#transformers.OmDetTurboProcessor.__call__) untuk detail. [Apa itu input IDs?](../glossary#input-ids)

classes_attention_mask (`torch.BoolTensor` dengan bentuk `(total_classes (>= batch_size), num_classes, sequence_length)`) : Attention mask untuk kelas-kelas. Ini adalah mask biner yang menunjukkan token mana yang harus diperhatikan dan mana yang tidak.

tasks_input_ids (`torch.LongTensor` dengan bentuk `(batch_size, sequence_length)`) : Indeks token urutan tugas input dalam kosakata model bahasa. Indeks dapat diperoleh menggunakan [OmDetTurboProcessor](/docs/transformers/main/id/model_doc/omdet-turbo#transformers.OmDetTurboProcessor). Lihat [OmDetTurboProcessor.__call__()](/docs/transformers/main/id/model_doc/omdet-turbo#transformers.OmDetTurboProcessor.__call__) untuk detail. [Apa itu input IDs?](../glossary#input-ids)

tasks_attention_mask (`torch.BoolTensor` dengan bentuk `(batch_size, sequence_length)`) : Attention mask untuk tugas. Ini adalah mask biner yang menunjukkan token mana yang harus diperhatikan dan mana yang tidak.

classes_structure (`torch.LongTensor` dengan bentuk `(batch_size)`) : Struktur dari kelas. Tensor ini menunjukkan jumlah kelas untuk setiap tugas.

labels (`list[Dict]` of len `(batch_size,)`, *opsional*) : Label untuk menghitung bipartite matching loss. Daftar dict, di mana setiap dict setidaknya berisi 2 kunci berikut: 'class_labels' dan 'boxes' (masing-masing label kelas dan bounding box dari sebuah gambar dalam batch). Label kelas itu sendiri harus berupa `torch.LongTensor` of len `(number of bounding boxes in the image,)` dan boxes a `torch.Tensor` of shape `(number of bounding boxes in the image, 4)`.

output_attentions (`bool`, *opsional*) : Apakah akan mengembalikan tensor perhatian dari semua lapisan perhatian. Lihat `attentions` di bawah tensor yang dikembalikan untuk detail lebih lanjut.

output_hidden_states (`bool`, *opsional*) : Apakah akan mengembalikan hidden states dari semua lapisan. Lihat `hidden_states` di bawah tensor yang dikembalikan untuk detail lebih lanjut.

return_dict (`bool`, *opsional*) : Apakah akan mengembalikan [ModelOutput](/docs/transformers/main/id/main_classes/output#transformers.utils.ModelOutput) alih-alih tuple biasa.

**Mengembalikan:** `OmDetTurboObjectDetectionOutput` atau `tuple(torch.Tensor)`

A `OmDetTurboObjectDetectionOutput` atau tuple dari `torch.Tensor` (jika `return_dict=False` dilewatkan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([OmDetTurboConfig](/docs/transformers/main/id/model_doc/omdet-turbo#transformers.OmDetTurboConfig)) dan input.

Metode forward dari [OmDetTurboForObjectDetection](/docs/transformers/main/id/model_doc/omdet-turbo#transformers.OmDetTurboForObjectDetection) menimpa metode khusus `__call__`.

Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance `Module` setelahnya alih-alih fungsi ini, karena yang pertama menangani langkah-langkah pra-pemrosesan dan pasca-pemrosesan, sedangkan yang kedua mengabaikannya secara diam-diam.

- **loss** (`torch.Tensor`, *opsional*) -- Nilai loss.
- **decoder_coord_logits** (`torch.Tensor` dengan bentuk `(batch_size, num_queries, 4)`) -- Logit koordinat prediksi dari objek-objek tersebut.
- **decoder_class_logits** (`torch.Tensor` dengan bentuk `(batch_size, num_queries, num_classes)`) -- Kelas objek yang diprediksi.
- **init_reference_points** (`torch.Tensor` dengan bentuk `(batch_size, num_queries, 4)`) -- Titik referensi awal.
- **intermediate_reference_points** (`tuple[tuple[torch.Tensor]]`, *opsional*) -- Titik referensi antara.
- **encoder_coord_logits** (`torch.Tensor` dengan bentuk `(batch_size, num_queries, 4)`) -- Koordinat objek yang diprediksi dari encoder.
- **encoder_class_logits** (`tuple[torch.Tensor]`, *opsional*) -- Kelas objek yang diprediksi dari encoder.
- **encoder_extracted_states** (`torch.Tensor`, *opsional*) -- State yang diekstrak dari Feature Pyramid Network (FPN) dan Path Aggregation Network (PAN) pada encoder.
- **decoder_hidden_states** (`tuple[torch.Tensor]`, *opsional*) -- Tuple dari `torch.Tensor` (satu untuk output embeddings + satu untuk output setiap layer) dengan bentuk `(batch_size, sequence_length, hidden_size)`. Hidden-states model pada output setiap layer ditambah output embedding awal.
- **decoder_attentions** (`tuple[tuple[torch.Tensor]]`, *opsional*) -- Tuple of tuples of `torch.Tensor` (satu untuk attention pada setiap layer) dengan bentuk `(batch_size, num_heads, sequence_length, sequence_length)`. Bobot attention setelah softmax attention, yang digunakan untuk menghitung rata-rata berbobot pada head self-attention, cross-attention, dan multi-scale deformable attention.
- **encoder_hidden_states** (`tuple[torch.Tensor]`, *opsional*) -- Tuple dari `torch.Tensor` (satu untuk output dari embeddings + satu untuk output dari setiap layer) dengan bentuk `(batch_size, sequence_length, hidden_size)`. Hidden-states dari model pada output dari setiap layer ditambah output dari embedding awal.
- **encoder_attentions** (`tuple[tuple[torch.Tensor]]`, *opsional*) -- Tuple of tuples of `torch.Tensor` (satu untuk attention pada setiap layer) dengan bentuk `(batch_size, num_heads, sequence_length, sequence_length)`. Bobot attention setelah softmax attention, yang digunakan untuk menghitung rata-rata berbobot pada head self-attention, cross-attention, dan multi-scale deformable attention.
- **classes_structure** (`torch.LongTensor`, *opsional*) -- Jumlah kelas yang ditanyakan untuk setiap gambar.

Contoh:

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