Transformers documentation
OmDet-Turbo
Model ini dipublikasikan di HF papers pada 2024-03-11 dan disumbangkan ke Hugging Face Transformers pada 2024-09-25.
OmDet-Turbo
Ikhtisar
Model OmDet-Turbo diusulkan dalam Real-time Transformer-based Open-Vocabulary Detection with Efficient Fusion Head 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.
OmDet-Turbo architecture overview. Taken from the original paper. Model ini disumbangkan oleh yonigozlan. Kode aslinya dapat ditemukan di sini.
Tips penggunaan
Satu sifat unik OmDet-Turbo dibandingkan model deteksi objek zero-shot lainnya, seperti 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 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. 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:
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:
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
kelas 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 )
Parameter
- is_encoder_decoder (
bool, opsional, defaultnyaTrue) — 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, defaultTrue) — Apakah akan menerapkan layer normalization pada feature maps dari output vision backbone. - image_size (
Union[int, list[int], tuple[int, int]], opsional, defaultnya640) — Ukuran (resolusi) setiap gambar. - disable_custom_kernels (
bool, opsional, defaultFalse) — Apakah akan menonaktifkan custom kernels. - layer_norm_eps (
float, opsional, defaultnya1e-05) — Epsilon yang digunakan oleh lapisan normalisasi lapisan. - batch_norm_eps (
float, opsional, defaultnya1e-05) — Epsilon yang digunakan oleh lapisan normalisasi batch. - init_std (
float, opsional, defaultnya0.02) — Standar deviasi 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, default 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, default"silu") — Fungsi aktivasi dari jaringan Cross Stage Partial (CSP) pada encoder. - conv_norm_activation (
str, opsional, default"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, default0.0) — Rasio untuk semua lapisan dropout. - hidden_expansion (
int, opsional, default 1) — Ekspansi tersembunyi dari jaringan CSP di encoder. - encoder_hidden_dim (
int, opsional, defaultnya256) — Dimensi dari representasi tersembunyi. - vision_features_channels (
tuple(int), opsional, defaultnya[256, 256, 256]) — Jumlah channel 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 fitur input yang diproyeksikan oleh setiap lapisan. - encoder_attention_heads (
int, opsional, default8) — 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, default1) — Jumlah lapisan tersembunyi pada encoder Transformer. Akan menggunakan nilai yang sama dengannum_layersjika tidak diatur. - positional_encoding_temperature (
int, opsional, default 10000) — Suhu positional encoding 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, defaultnya256) — Dimensi dari representasi tersembunyi. - decoder_num_heads (
int, opsional, default8) — Jumlah kepala perhatian untuk setiap lapisan perhatian dalam decoder Transformer. - decoder_num_layers (
int, opsional, defaultnya6) — Jumlah lapisan tersembunyi dalam decoder Transformer. Akan menggunakan nilai yang sama dengannum_layersjika tidak diatur. - decoder_activation (
str, opsional, defaultnya"relu") — Fungsi aktivasi untuk decoder. - decoder_dim_feedforward (
int, opsional, default 2048) — Dimensi feedforward untuk decoder. - decoder_num_points (
int, opsional, defaultnya 4) — Jumlah titik yang disampelkan dalam modul perhatian deformable multi-skala 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 position embeddings setelah memperhitungkan stride (lihat RTDetr). - learn_initial_query (
bool, opsional, defaultFalse) — 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
Objek konfigurasi mewarisi dari PreTrainedConfig dan dapat digunakan untuk mengontrol output model. Baca dokumentasi dari PreTrainedConfig untuk informasi lebih lanjut.
Contoh:
>>> 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
kelas transformers.OmDetTurboProcessor
< source >( image_processortokenizer )
Membangun OmDetTurboProcessor yang membungkus image processor dan tokenizer menjadi satu processor.
OmDetTurboProcessor menyediakan semua fungsionalitas dari DetrImageProcessor dan CLIPTokenizer. Lihat ~DetrImageProcessor dan ~CLIPTokenizer untuk informasi lebih lanjut.
__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
Parameter
- images (
Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]], opsional) — Gambar yang akan dipreprocess. Mengharapkan satu gambar atau batch gambar dengan nilai piksel berkisar dari 0 hingga 255. Jika mengirimkan gambar dengan nilai piksel antara 0 dan 1, aturdo_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, aturis_split_into_words=Trueuntuk menghindari ambiguitas dengan input yang di-batch. - task (
str, kwargs,list[str],TextInput, atauPreTokenizedInput, opsional) — Deskripsi tugas deteksi yang akan di-encode. Jika tidak diberikan, deskripsi tugas default akan dibuat dari inputtext(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 (
stratau TensorType, opsional) — Jika diset, akan mengembalikan tensor dari framework tertentu. Nilai yang dapat diterima adalah:'pt': Mengembalikan objek PyTorchtorch.Tensor.'np': Mengembalikan objek NumPynp.ndarray.
- **kwargs (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’, dst.). - 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]atauset[str], opsional) — Daftar atau himpunan kunci yang TIDAK boleh dikonversi menjadi tensor, bahkan ketikatensor_typeditentukan.
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]
Parameter
- outputs (
OmDetTurboObjectDetectionOutput) — Output mentah dari model. - text_labels (Union[list[str], list[list[str]]], opsional) —
Nama kelas input. Jika tidak disediakan,
text_labelsakan diset keNonedioutputs. - threshold (float, defaultnya 0.3) — Hanya kembalikan deteksi dengan skor kepercayaan yang melebihi ambang batas ini.
- nms_threshold (float, defaultnya 0.5) — Ambang batas yang digunakan untuk non-maximum suppression pada kotak. Nilai dalam [0, 1].
- target_sizes (
torch.Tensorataulist[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 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
kelas transformers.OmDetTurboForObjectDetection
< source >( config: OmDetTurboConfig )
Parameter
- config (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() untuk memuat bobot model.
OmDetTurbo Model (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. Periksa dokumentasi kelas induk untuk metode generik yang diimplementasikan oleh pustaka untuk semua model (seperti mengunduh atau menyimpan, mengubah ukuran embedding input, memangkas kepala, dll.)
Model ini juga merupakan subclass dari 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
< 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)
Parameter
- pixel_values (
torch.Tensordengan bentuk(batch_size, num_channels, image_size, image_size)) — Tensor yang sesuai dengan gambar input. Nilai piksel dapat diperoleh menggunakan DetrImageProcessor. Lihat DetrImageProcessor.call() untuk detailnya (OmDetTurboProcessor menggunakan DetrImageProcessor untuk memproses gambar). - classes_input_ids (
torch.LongTensordengan bentuk(total_classes (>= batch_size), sequence_length)) — Indeks token urutan kelas input dalam kosakata model bahasa. Beberapa kelas dapat disediakan untuk setiap tugas, sehingga kelas yang ditokenisasi diratakan (struktur kelas) dan strukturnya disediakan dalamclasses_structureargumen.Indeks dapat diperoleh menggunakan OmDetTurboProcessor. Lihat OmDetTurboProcessor.call() untuk detailnya.
- classes_attention_mask (
torch.BoolTensordengan bentuk(total_classes (>= batch_size), num_classes, sequence_length)) — Attention mask untuk kelas. Ini adalah mask biner yang menunjukkan token mana yang harus diperhatikan dan mana yang tidak. - tasks_input_ids (
torch.LongTensordengan bentuk(batch_size, sequence_length)) — Indeks token urutan tugas input dalam kosakata model bahasa. Indeks dapat diperoleh menggunakan OmDetTurboProcessor. Lihat OmDetTurboProcessor.call() untuk detailnya. Apa itu input ID?Indeks dapat diperoleh menggunakan OmDetTurboProcessor. Lihat OmDetTurboProcessor.call() untuk detailnya.
- tasks_attention_mask (
torch.BoolTensordengan 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.LongTensordengan 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 dictionary mengandung setidaknya 2 kunci berikut: ‘class_labels’ dan ‘boxes’ (masing-masing label kelas dan bounding box dari sebuah gambar dalam batch). Label kelas itu sendiri harus berupatorch.LongTensorof len(number of bounding boxes in the image,)dan boxes berupatorch.Tensorof shape(number of bounding boxes in the image, 4). - output_attentions (
bool, opsional) — Apakah akan mengembalikan tensor attentions dari semua lapisan attention. Lihatattentionsdi bawah tensor yang dikembalikan untuk detail lebih lanjut. - output_hidden_states (
bool, opsional) — Apakah akan mengembalikan hidden states dari semua lapisan. Lihathidden_statesdi bawah tensor yang dikembalikan untuk detail lebih lanjut. - return_dict (
bool, opsional) — Apakah akan mengembalikan ModelOutput alih-alih tuple biasa.
Mengembalikan
OmDetTurboObjectDetectionOutput atau tuple(torch.Tensor)
OmDetTurboObjectDetectionOutput atau tuple dari
torch.Tensor (jika return_dict=False diteruskan atau ketika config.return_dict=False) yang terdiri dari berbagai
elemen tergantung pada konfigurasi (OmDetTurboConfig) dan input.
Metode forward dari OmDetTurboForObjectDetection menimpa metode khusus __call__.
Meskipun resep untuk forward pass perlu didefinisikan di dalam fungsi ini, sebaiknya panggil instance
Modulesetelahnya 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.Tensordengan bentuk(batch_size, num_queries, 4)) — Logit koordinat prediksi dari objek-objek tersebut. - decoder_class_logits (
torch.Tensordengan bentuk(batch_size, num_queries, num_classes)) — Kelas yang diprediksi dari objek. - init_reference_points (
torch.Tensordengan bentuk(batch_size, num_queries, 4)) — Titik referensi awal. - intermediate_reference_points (
tuple[tuple[torch.Tensor]], opsional) — Titik referensi antara. - encoder_coord_logits (
torch.Tensordengan 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) dari encoder. - decoder_hidden_states (
tuple[torch.Tensor], opsional) — Tuple daritorch.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 oftorch.Tensor(satu untuk attention pada setiap layer) dengan bentuk(batch_size, num_heads, sequence_length, sequence_length). Bobot attention setelah softmax attention, 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 daritorch.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. - encoder_attentions (
tuple[tuple[torch.Tensor]], opsional) — Tuple of tuples oftorch.Tensor(satu untuk attention pada setiap layer) dengan bentuk(batch_size, num_heads, sequence_length, sequence_length). Bobot attention setelah softmax attention, 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:
>>> 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]