# Deformable DETR [Deformable DETR](https://huggingface.co/papers/2010.04159) meningkatkan [DETR](./detr) asli dengan menggunakan modul deformable attention. Mekanisme ini secara selektif memperhatikan sejumlah kecil titik sampling kunci di sekitar referensi. Hal ini meningkatkan kecepatan pelatihan dan akurasi. drawing Arsitektur Deformable DETR. Diambil dari paper aslinya. Anda dapat menemukan semua checkpoint Deformable DETR yang tersedia di bawah organisasi [SenseTime](https://huggingface.co/SenseTime). > [!TIP] > Model ini disumbangkan oleh [nielsr](https://huggingface.co/nielsr). > > Klik pada model Deformable DETR di bilah sisi kanan untuk melihat lebih banyak contoh cara menerapkan Deformable DETR ke berbagai tugas deteksi objek dan segmentasi. Contoh di bawah ini menunjukkan cara melakukan deteksi objek dengan [Pipeline](/docs/transformers/v5.23.0/id/main_classes/pipelines#transformers.Pipeline) dan kelas [AutoModel](/docs/transformers/v5.23.0/id/model_doc/auto#transformers.AutoModel). ```python from transformers import pipeline pipeline = pipeline( "object-detection", model="SenseTime/deformable-detr", device_map=0 ) pipeline("http://images.cocodataset.org/val2017/000000039769.jpg") ``` ```python import requests import torch from PIL import Image from transformers import AutoImageProcessor, AutoModelForObjectDetection url = "http://images.cocodataset.org/val2017/000000039769.jpg" image = Image.open(requests.get(url, stream=True).raw) image_processor = AutoImageProcessor.from_pretrained("SenseTime/deformable-detr") model = AutoModelForObjectDetection.from_pretrained("SenseTime/deformable-detr", device_map="auto") # prepare image for the model inputs = image_processor(images=image, return_tensors="pt").to(model.device) with torch.no_grad(): outputs = model(**inputs) results = image_processor.post_process_object_detection(outputs, target_sizes=torch.tensor([image.size[::-1]]), threshold=0.3) for result in results: for score, label_id, box in zip(result["scores"], result["labels"], result["boxes"]): score, label = score.item(), label_id.item() box = [round(i, 2) for i in box.tolist()] print(f"{model.config.id2label[label]}: {score:.2f} {box}") ``` ## Sumber daya - Lihat kumpulan [notebook](https://github.com/NielsRogge/Transformers-Tutorials/tree/master/Deformable-DETR) ini untuk inferensi dan fine-tuning [DeformableDetrForObjectDetection](/docs/transformers/v5.23.0/id/model_doc/deformable_detr#transformers.DeformableDetrForObjectDetection) pada dataset kustom. ## DeformableDetrImageProcessor[[transformers.DeformableDetrImageProcessor]] #### transformers.DeformableDetrImageProcessor[[transformers.DeformableDetrImageProcessor]] ```python transformers.DeformableDetrImageProcessor(**kwargs: *) ``` [Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/deformable_detr/image_processing_deformable_detr.py#L271) **Parameter:** do_convert_rgb (`bool`, *kwargs*, *opsional*) : Apakah akan mengkonversi gambar ke RGB. do_resize (`bool`, *kwargs*, *opsional*, defaultnya `True`) : Apakah akan mengubah ukuran gambar. size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, defaultnya `{'shortest_edge' : 800, 'longest_edge': 1333}`): Menjelaskan dimensi input maksimum ke model. default_to_square (`bool`, *kwargs*, *opsional*, defaultnya `False`) : Apakah secara default menggunakan gambar persegi saat mengubah ukuran, jika size berupa int. crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Ukuran gambar keluaran setelah menerapkan `center_crop`. resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, defaultnya `2`) : Filter resampling yang digunakan jika mengubah ukuran gambar. Ini bisa berupa salah satu enum `PILImageResampling`. Hanya berdampak jika `do_resize` diatur ke `True`. do_rescale (`bool`, *kwargs*, *opsional*, defaultnya `True`) : Apakah akan melakukan penskalaan ulang pada gambar. rescale_factor (`float`, *kwargs*, *opsional*, defaultnya `0.00392156862745098`) : Faktor rescale untuk melakukan rescale pada gambar jika `do_rescale` diatur ke `True`. do_normalize (`bool`, *kwargs*, *opsional*, defaultnya `True`) : Apakah akan menormalisasi gambar. image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opsional*, defaultnya `[0.485, 0.456, 0.406]`) : Rata-rata gambar yang digunakan untuk normalisasi. Hanya berpengaruh jika `do_normalize` diatur ke `True`. image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opsional*, defaultnya `[0.229, 0.224, 0.225]`) : Standar deviasi gambar yang digunakan untuk normalisasi. Hanya berpengaruh jika `do_normalize` diatur ke `True`. do_pad (`bool`, *kwargs*, *opsional*, defaultnya `True`) : Apakah akan melakukan padding pada gambar. Padding dilakukan hingga ukuran terbesar dalam batch atau hingga ukuran persegi tetap per gambar. Strategi padding yang tepat bergantung pada model. pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Ukuran dalam `{"height": int, "width" int}` untuk melakukan padding pada gambar. Harus lebih besar dari ukuran gambar mana pun yang diberikan untuk pra-pemrosesan. Jika `pad_size` tidak diberikan, gambar akan di-pad hingga tinggi dan lebar terbesar dalam batch. Diterapkan hanya ketika `do_pad=True.` do_center_crop (`bool`, *kwargs*, *opsional*) : Apakah akan melakukan center crop pada gambar. data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opsional*) : Hanya `ChannelDimension.FIRST` yang didukung. Ditambahkan untuk kompatibilitas dengan prosesor lambat. input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opsional*) : Format dimensi channel untuk gambar input. Jika tidak disetel, format dimensi channel akan disimpulkan dari gambar input. Bisa berupa salah satu dari: - `"channels_first"` atau `ChannelDimension.FIRST`: gambar dalam format (num_channels, height, width). - `"channels_last"` atau `ChannelDimension.LAST`: gambar dalam format (height, width, num_channels). - `"none"` atau `ChannelDimension.NONE`: gambar dalam format (height, width). device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : Perangkat untuk memproses video. Jika tidak disetel, perangkat akan disimpulkan dari video input. return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Mengembalikan tensor yang ditumpuk jika disetel ke `'pt'`, selain itu mengembalikan daftar tensor. disable_grouping (`bool`, *kwargs*, *opsional*) : Apakah akan menonaktifkan pengelompokan gambar berdasarkan ukuran untuk memprosesnya secara individual dan tidak dalam batch. Jika None, akan diset ke True jika gambar berada di CPU, dan False selain itu. Pilihan ini didasarkan pada pengamatan empiris, seperti yang dijelaskan di sini: https://github.com/huggingface/transformers/pull/38157 image_seq_length (`int`, *kwargs*, *opsional*) : Jumlah token gambar yang akan digunakan untuk setiap gambar dalam input. Ditambahkan untuk kompatibilitas mundur, tetapi ini sebaiknya diatur sebagai atribut prosesor pada model-model mendatang. format (`str`, *kwargs*, *opsional*, defaultnya `AnnotationFormat.COCO_DETECTION`) : Format data anotasi. Salah satu dari "coco_detection" atau "coco_panoptic". do_convert_annotations (`bool`, *kwargs*, *opsional*, defaultnya `True`) : Mengontrol apakah anotasi akan dikonversi ke format yang diharapkan oleh model DEFORMABLE_DETR. Mengonversi kotak batas ke format `(center_x, center_y, width, height)` dan dalam rentang `[0, 1]`. Dapat ditimpa oleh parameter `do_convert_annotations` di metode `preprocess`. Membangun pemroses gambar DeformableDetrImageProcessor. #### preprocess[[transformers.DeformableDetrImageProcessor.preprocess]] ```python preprocess(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']], annotations: dict[str, int | str | list[dict]] | list[dict[str, int | str | list[dict]]] | None = None, return_segmentation_masks: bool | None = None, masks_path: str | pathlib.Path | None = None, **kwargs: *) ``` [Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/deformable_detr/image_processing_deformable_detr.py#L526) **Parameter:** images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`) : Gambar yang akan 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`. annotations (`AnnotationType` atau `list[AnnotationType]`, *opsional*) : Anotasi yang akan ditransformasikan sesuai dengan padding yang diterapkan pada gambar. return_segmentation_masks (`bool`, *opsional*, defaultnya `self.return_segmentation_masks`) : Apakah akan mengembalikan masker segmentasi. masks_path (`str` atau `pathlib.Path`, *opsional*) : Path ke direktori yang berisi mask segmentasi. do_convert_rgb (`bool`, *kwargs*, *opsional*) : Apakah akan mengkonversi gambar ke RGB. do_resize (`bool`, *kwargs*, *opsional*) : Apakah akan mengubah ukuran gambar. size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Menjelaskan dimensi input maksimum ke model. default_to_square (`bool`, *kwargs*, *opsional*) : Apakah secara default menggunakan gambar persegi saat mengubah ukuran, jika size berupa int. crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Ukuran gambar keluaran setelah menerapkan `center_crop`. resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*) : Filter resampling yang digunakan saat mengubah ukuran gambar. Nilai ini dapat berupa salah satu enum `PILImageResampling`. Hanya berpengaruh jika `do_resize` diatur ke `True`. do_rescale (`bool`, *kwargs*, *opsional*) : Apakah akan melakukan penskalaan ulang pada gambar. rescale_factor (`float`, *kwargs*, *opsional*) : Faktor penskalaan ulang untuk menskalakan ulang gambar jika `do_rescale` diatur ke `True`. do_normalize (`bool`, *kwargs*, *opsional*) : Apakah akan menormalisasi gambar. image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opsional*) : Rata-rata gambar yang digunakan untuk normalisasi. Hanya berpengaruh jika `do_normalize` diatur ke `True`. image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opsional*) : Standar deviasi gambar yang digunakan untuk normalisasi. Hanya berpengaruh jika `do_normalize` diatur ke `True`. do_pad (`bool`, *kwargs*, *opsional*) : Apakah akan melakukan padding pada gambar. Padding dilakukan hingga ukuran terbesar dalam batch atau hingga ukuran persegi tetap per gambar. Strategi padding yang tepat bergantung pada model. pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Ukuran dalam `{"height": int, "width" int}` untuk melakukan padding pada gambar. Harus lebih besar dari ukuran gambar mana pun yang diberikan untuk pra-pemrosesan. Jika `pad_size` tidak diberikan, gambar akan di-pad hingga tinggi dan lebar terbesar dalam batch. Diterapkan hanya ketika `do_pad=True.` do_center_crop (`bool`, *kwargs*, *opsional*) : Apakah akan melakukan center crop pada gambar. data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opsional*) : Hanya `ChannelDimension.FIRST` yang didukung. Ditambahkan untuk kompatibilitas dengan prosesor lambat. input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opsional*) : Format dimensi channel untuk gambar input. Jika tidak disetel, format dimensi channel akan disimpulkan dari gambar input. Bisa berupa salah satu dari: - `"channels_first"` atau `ChannelDimension.FIRST`: gambar dalam format (num_channels, height, width). - `"channels_last"` atau `ChannelDimension.LAST`: gambar dalam format (height, width, num_channels). - `"none"` atau `ChannelDimension.NONE`: gambar dalam format (height, width). device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : Perangkat untuk memproses video. Jika tidak disetel, perangkat akan disimpulkan dari video input. return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Mengembalikan tensor yang ditumpuk jika disetel ke `'pt'`, selain itu mengembalikan daftar tensor. disable_grouping (`bool`, *kwargs*, *opsional*) : Apakah akan menonaktifkan pengelompokan gambar berdasarkan ukuran untuk memprosesnya secara individual dan tidak dalam batch. Jika None, akan diset ke True jika gambar berada di CPU, dan False selain itu. Pilihan ini didasarkan pada pengamatan empiris, seperti yang dijelaskan di sini: https://github.com/huggingface/transformers/pull/38157 image_seq_length (`int`, *kwargs*, *opsional*) : Jumlah token gambar yang akan digunakan untuk setiap gambar dalam input. Ditambahkan untuk kompatibilitas mundur, tetapi ini sebaiknya diatur sebagai atribut prosesor pada model-model mendatang. format (`str`, *kwargs*, *opsional*, defaultnya `AnnotationFormat.COCO_DETECTION`) : Format data anotasi. Salah satu dari "coco_detection" atau "coco_panoptic". do_convert_annotations (`bool`, *kwargs*, *opsional*, defaultnya `True`) : Mengontrol apakah anotasi akan dikonversi ke format yang diharapkan oleh model DEFORMABLE_DETR. Mengonversi kotak batas ke format `(center_x, center_y, width, height)` dan dalam rentang `[0, 1]`. Dapat ditimpa oleh parameter `do_convert_annotations` di metode `preprocess`. **Mengembalikan:** `~image_processing_base.BatchFeature` - **data** (`dict`) -- Dictionary berisi list/array/tensor yang dikembalikan oleh metode __call__ ('pixel_values', 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. #### post_process_object_detection[[transformers.DeformableDetrImageProcessor.post_process_object_detection]] ```python post_process_object_detection(outputs, threshold: float = 0.5, target_sizes: transformers.utils.generic.TensorType | list[tuple] = None, top_k: int = 100) ``` [Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/deformable_detr/image_processing_deformable_detr.py#L667) **Parameter:** outputs (`DetrObjectDetectionOutput`) : Output mentah dari model. threshold (`float`, *opsional*) : Ambang batas skor untuk mempertahankan prediksi deteksi objek. 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 (tinggi, lebar) dari setiap gambar dalam batch. Jika dibiarkan None, prediksi tidak akan di-resize. top_k (`int`, *opsional*, default 100) : Simpan hanya k bounding box teratas sebelum penyaringan dengan ambang batas. **Mengembalikan:** `list[Dict]` Daftar kamus, di mana setiap kamus berisi skor, label, dan kotak untuk sebuah gambar dalam batch sebagaimana diprediksi oleh model. Mengonversi output mentah dari [DeformableDetrForObjectDetection](/docs/transformers/v5.23.0/id/model_doc/deformable_detr#transformers.DeformableDetrForObjectDetection) menjadi kotak batas akhir dalam format (top_left_x, top_left_y, bottom_right_x, bottom_right_y). Hanya mendukung PyTorch. ## DeformableDetrImageProcessorPil[[transformers.DeformableDetrImageProcessorPil]] #### transformers.DeformableDetrImageProcessorPil[[transformers.DeformableDetrImageProcessorPil]] ```python transformers.DeformableDetrImageProcessorPil(**kwargs: *) ``` [Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/deformable_detr/image_processing_pil_deformable_detr.py#L263) **Parameter:** do_convert_rgb (`bool`, *kwargs*, *opsional*) : Apakah akan mengkonversi gambar ke RGB. do_resize (`bool`, *kwargs*, *opsional*, defaultnya `True`) : Apakah akan mengubah ukuran gambar. size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, defaultnya `{'shortest_edge' : 800, 'longest_edge': 1333}`): Menjelaskan dimensi input maksimum ke model. default_to_square (`bool`, *kwargs*, *opsional*, defaultnya `False`) : Apakah secara default menggunakan gambar persegi saat mengubah ukuran, jika size berupa int. crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Ukuran gambar keluaran setelah menerapkan `center_crop`. resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, defaultnya `2`) : Filter resampling yang digunakan jika mengubah ukuran gambar. Ini bisa berupa salah satu enum `PILImageResampling`. Hanya berdampak jika `do_resize` diatur ke `True`. do_rescale (`bool`, *kwargs*, *opsional*, defaultnya `True`) : Apakah akan melakukan penskalaan ulang pada gambar. rescale_factor (`float`, *kwargs*, *opsional*, defaultnya `0.00392156862745098`) : Faktor rescale untuk melakukan rescale pada gambar jika `do_rescale` diatur ke `True`. do_normalize (`bool`, *kwargs*, *opsional*, defaultnya `True`) : Apakah akan menormalisasi gambar. image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opsional*, defaultnya `[0.485, 0.456, 0.406]`) : Rata-rata gambar yang digunakan untuk normalisasi. Hanya berpengaruh jika `do_normalize` diatur ke `True`. image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opsional*, defaultnya `[0.229, 0.224, 0.225]`) : Standar deviasi gambar yang digunakan untuk normalisasi. Hanya berpengaruh jika `do_normalize` diatur ke `True`. do_pad (`bool`, *kwargs*, *opsional*, defaultnya `True`) : Apakah akan melakukan padding pada gambar. Padding dilakukan hingga ukuran terbesar dalam batch atau hingga ukuran persegi tetap per gambar. Strategi padding yang tepat bergantung pada model. pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Ukuran dalam `{"height": int, "width" int}` untuk melakukan padding pada gambar. Harus lebih besar dari ukuran gambar mana pun yang diberikan untuk pra-pemrosesan. Jika `pad_size` tidak diberikan, gambar akan di-pad hingga tinggi dan lebar terbesar dalam batch. Diterapkan hanya ketika `do_pad=True.` do_center_crop (`bool`, *kwargs*, *opsional*) : Apakah akan melakukan center crop pada gambar. data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opsional*) : Hanya `ChannelDimension.FIRST` yang didukung. Ditambahkan untuk kompatibilitas dengan prosesor lambat. input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opsional*) : Format dimensi channel untuk gambar input. Jika tidak disetel, format dimensi channel akan disimpulkan dari gambar input. Bisa berupa salah satu dari: - `"channels_first"` atau `ChannelDimension.FIRST`: gambar dalam format (num_channels, height, width). - `"channels_last"` atau `ChannelDimension.LAST`: gambar dalam format (height, width, num_channels). - `"none"` atau `ChannelDimension.NONE`: gambar dalam format (height, width). device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : Perangkat untuk memproses video. Jika tidak disetel, perangkat akan disimpulkan dari video input. return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Mengembalikan tensor yang ditumpuk jika disetel ke `'pt'`, selain itu mengembalikan daftar tensor. disable_grouping (`bool`, *kwargs*, *opsional*) : Apakah akan menonaktifkan pengelompokan gambar berdasarkan ukuran untuk memprosesnya secara individual dan tidak dalam batch. Jika None, akan diset ke True jika gambar berada di CPU, dan False selain itu. Pilihan ini didasarkan pada pengamatan empiris, seperti yang dijelaskan di sini: https://github.com/huggingface/transformers/pull/38157 image_seq_length (`int`, *kwargs*, *opsional*) : Jumlah token gambar yang akan digunakan untuk setiap gambar dalam input. Ditambahkan untuk kompatibilitas mundur, tetapi ini sebaiknya diatur sebagai atribut prosesor pada model-model mendatang. format (`str`, *kwargs*, *opsional*, defaultnya `AnnotationFormat.COCO_DETECTION`) : Format data anotasi. Salah satu dari "coco_detection" atau "coco_panoptic". do_convert_annotations (`bool`, *kwargs*, *opsional*, defaultnya `True`) : Mengontrol apakah anotasi akan dikonversi ke format yang diharapkan oleh model DEFORMABLE_DETR. Mengonversi kotak batas ke format `(center_x, center_y, width, height)` dan dalam rentang `[0, 1]`. Dapat ditimpa oleh parameter `do_convert_annotations` di metode `preprocess`. Membangun pemroses gambar DeformableDetrImageProcessor. #### preprocess[[transformers.DeformableDetrImageProcessorPil.preprocess]] ```python preprocess(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']], annotations: dict[str, int | str | list[dict]] | list[dict[str, int | str | list[dict]]] | None = None, return_segmentation_masks: bool | None = None, masks_path: str | pathlib.Path | None = None, **kwargs: *) ``` [Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/deformable_detr/image_processing_pil_deformable_detr.py#L531) **Parameter:** images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`) : Gambar yang akan 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`. annotations (`AnnotationType` atau `list[AnnotationType]`, *opsional*) : Anotasi yang akan ditransformasikan sesuai dengan padding yang diterapkan pada gambar. return_segmentation_masks (`bool`, *opsional*, defaultnya `self.return_segmentation_masks`) : Apakah akan mengembalikan masker segmentasi. masks_path (`str` atau `pathlib.Path`, *opsional*) : Path ke direktori yang berisi mask segmentasi. do_convert_rgb (`bool`, *kwargs*, *opsional*) : Apakah akan mengkonversi gambar ke RGB. do_resize (`bool`, *kwargs*, *opsional*) : Apakah akan mengubah ukuran gambar. size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Menjelaskan dimensi input maksimum ke model. default_to_square (`bool`, *kwargs*, *opsional*) : Apakah secara default menggunakan gambar persegi saat mengubah ukuran, jika size berupa int. crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Ukuran gambar keluaran setelah menerapkan `center_crop`. resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*) : Filter resampling yang digunakan saat mengubah ukuran gambar. Nilai ini dapat berupa salah satu enum `PILImageResampling`. Hanya berpengaruh jika `do_resize` diatur ke `True`. do_rescale (`bool`, *kwargs*, *opsional*) : Apakah akan melakukan penskalaan ulang pada gambar. rescale_factor (`float`, *kwargs*, *opsional*) : Faktor penskalaan ulang untuk menskalakan ulang gambar jika `do_rescale` diatur ke `True`. do_normalize (`bool`, *kwargs*, *opsional*) : Apakah akan menormalisasi gambar. image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opsional*) : Rata-rata gambar yang digunakan untuk normalisasi. Hanya berpengaruh jika `do_normalize` diatur ke `True`. image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opsional*) : Standar deviasi gambar yang digunakan untuk normalisasi. Hanya berpengaruh jika `do_normalize` diatur ke `True`. do_pad (`bool`, *kwargs*, *opsional*) : Apakah akan melakukan padding pada gambar. Padding dilakukan hingga ukuran terbesar dalam batch atau hingga ukuran persegi tetap per gambar. Strategi padding yang tepat bergantung pada model. pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Ukuran dalam `{"height": int, "width" int}` untuk melakukan padding pada gambar. Harus lebih besar dari ukuran gambar mana pun yang diberikan untuk pra-pemrosesan. Jika `pad_size` tidak diberikan, gambar akan di-pad hingga tinggi dan lebar terbesar dalam batch. Diterapkan hanya ketika `do_pad=True.` do_center_crop (`bool`, *kwargs*, *opsional*) : Apakah akan melakukan center crop pada gambar. data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opsional*) : Hanya `ChannelDimension.FIRST` yang didukung. Ditambahkan untuk kompatibilitas dengan prosesor lambat. input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opsional*) : Format dimensi channel untuk gambar input. Jika tidak disetel, format dimensi channel akan disimpulkan dari gambar input. Bisa berupa salah satu dari: - `"channels_first"` atau `ChannelDimension.FIRST`: gambar dalam format (num_channels, height, width). - `"channels_last"` atau `ChannelDimension.LAST`: gambar dalam format (height, width, num_channels). - `"none"` atau `ChannelDimension.NONE`: gambar dalam format (height, width). device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : Perangkat untuk memproses video. Jika tidak disetel, perangkat akan disimpulkan dari video input. return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Mengembalikan tensor yang ditumpuk jika disetel ke `'pt'`, selain itu mengembalikan daftar tensor. disable_grouping (`bool`, *kwargs*, *opsional*) : Apakah akan menonaktifkan pengelompokan gambar berdasarkan ukuran untuk memprosesnya secara individual dan tidak dalam batch. Jika None, akan diset ke True jika gambar berada di CPU, dan False selain itu. Pilihan ini didasarkan pada pengamatan empiris, seperti yang dijelaskan di sini: https://github.com/huggingface/transformers/pull/38157 image_seq_length (`int`, *kwargs*, *opsional*) : Jumlah token gambar yang akan digunakan untuk setiap gambar dalam input. Ditambahkan untuk kompatibilitas mundur, tetapi ini sebaiknya diatur sebagai atribut prosesor pada model-model mendatang. format (`str`, *kwargs*, *opsional*, defaultnya `AnnotationFormat.COCO_DETECTION`) : Format data anotasi. Salah satu dari "coco_detection" atau "coco_panoptic". do_convert_annotations (`bool`, *kwargs*, *opsional*, defaultnya `True`) : Mengontrol apakah anotasi akan dikonversi ke format yang diharapkan oleh model DEFORMABLE_DETR. Mengonversi kotak batas ke format `(center_x, center_y, width, height)` dan dalam rentang `[0, 1]`. Dapat ditimpa oleh parameter `do_convert_annotations` di metode `preprocess`. **Mengembalikan:** `~image_processing_base.BatchFeature` - **data** (`dict`) -- Dictionary berisi list/array/tensor yang dikembalikan oleh metode __call__ ('pixel_values', 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. #### post_process_object_detection[[transformers.DeformableDetrImageProcessorPil.post_process_object_detection]] ```python post_process_object_detection(outputs, threshold: float = 0.5, target_sizes: transformers.utils.generic.TensorType | list[tuple] = None, top_k: int = 100) ``` [Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/deformable_detr/image_processing_pil_deformable_detr.py#L676) **Parameter:** outputs (`DetrObjectDetectionOutput`) : Output mentah dari model. threshold (`float`, *opsional*) : Ambang batas skor untuk mempertahankan prediksi deteksi objek. 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 (tinggi, lebar) dari setiap gambar dalam batch. Jika dibiarkan None, prediksi tidak akan di-resize. top_k (`int`, *opsional*, default 100) : Simpan hanya k bounding box teratas sebelum penyaringan dengan ambang batas. **Mengembalikan:** `list[Dict]` Daftar kamus, di mana setiap kamus berisi skor, label, dan kotak untuk sebuah gambar dalam batch sebagaimana diprediksi oleh model. Mengonversi output mentah dari [DeformableDetrForObjectDetection](/docs/transformers/v5.23.0/id/model_doc/deformable_detr#transformers.DeformableDetrForObjectDetection) menjadi kotak batas akhir dalam format (top_left_x, top_left_y, bottom_right_x, bottom_right_y). Hanya mendukung PyTorch. ## DeformableDetrConfig[[transformers.DeformableDetrConfig]] #### transformers.DeformableDetrConfig[[transformers.DeformableDetrConfig]] ```python transformers.DeformableDetrConfig(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, backbone_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, num_channels: int = 3, num_queries: int = 300, max_position_embeddings: int = 1024, encoder_layers: int = 6, encoder_ffn_dim: int = 1024, encoder_attention_heads: int = 8, decoder_layers: int = 6, decoder_ffn_dim: int = 1024, decoder_attention_heads: int = 8, encoder_layerdrop: float | int = 0.0, activation_function: str = 'relu', d_model: int = 256, dropout: float | int = 0.1, attention_dropout: float | int = 0.0, activation_dropout: float | int = 0.0, init_std: float = 0.02, init_xavier_std: float = 1.0, return_intermediate: bool = True, auxiliary_loss: bool = False, position_embedding_type: str = 'sine', dilation: bool = False, num_feature_levels: int = 4, encoder_n_points: int = 4, decoder_n_points: int = 4, two_stage: bool = False, two_stage_num_proposals: int = 300, with_box_refine: bool = False, class_cost: int = 1, bbox_cost: int = 5, giou_cost: int = 2, mask_loss_coefficient: int = 1, dice_loss_coefficient: int = 1, bbox_loss_coefficient: int = 5, giou_loss_coefficient: int = 2, eos_coefficient: float = 0.1, focal_alpha: float = 0.25, disable_custom_kernels: bool = False, tie_word_embeddings: bool = True) ``` [Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/deformable_detr/configuration_deformable_detr.py#L25) **Parameter:** is_encoder_decoder (`bool`, *opsional*, defaultnya `True`) : Apakah model digunakan sebagai encoder/decoder atau tidak. backbone_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *opsional*) : Konfigurasi dari model backbone. num_channels (`int`, *opsional*, default `3`) : Jumlah saluran input. num_queries (`int`, *opsional*, default 300) : Jumlah query objek, yaitu slot deteksi. Ini adalah jumlah maksimal objek yang dapat dideteksi oleh [DeformableDetrModel](/docs/transformers/v5.23.0/id/model_doc/deformable_detr#transformers.DeformableDetrModel) dalam satu gambar. Jika `two_stage` diatur ke `True`, kami menggunakan `two_stage_num_proposals` sebagai gantinya. max_position_embeddings (`int`, *opsional*, defaultnya `1024`) : Panjang urutan maksimum yang mungkin digunakan oleh model ini. encoder_layers (`int`, *opsional*, defaultnya `6`) : Jumlah lapisan tersembunyi dalam encoder Transformer. Akan menggunakan nilai yang sama dengan `num_layers` jika tidak diatur. encoder_ffn_dim (`int`, *opsional*, defaultnya `1024`) : Dimensi dari lapisan "intermediate" (sering disebut feed-forward) dalam encoder. encoder_attention_heads (`int`, *opsional*, defaultnya `8`) : Jumlah kepala perhatian untuk setiap lapisan perhatian dalam encoder Transformer. decoder_layers (`int`, *opsional*, defaultnya `6`) : Jumlah lapisan tersembunyi dalam decoder Transformer. Akan menggunakan nilai yang sama dengan `num_layers` jika tidak diatur. decoder_ffn_dim (`int`, *opsional*, defaultnya `1024`) : Dimensi dari lapisan "intermediate" (sering disebut feed-forward) dalam decoder. decoder_attention_heads (`int`, *opsional*, defaultnya `8`) : Jumlah kepala perhatian untuk setiap lapisan perhatian dalam decoder Transformer. encoder_layerdrop (`Union[float, int]`, *opsional*, defaultnya `0.0`) : Probabilitas LayerDrop untuk encoder. Lihat [makalah LayerDrop](see https://huggingface.co/papers/1909.11556) untuk detail lebih lanjut. activation_function (`str`, *opsional*, defaultnya `relu`) : Fungsi aktivasi non-linear (fungsi atau string) di decoder. Misalnya, `"gelu"`, `"relu"`, `"silu"`, dan sebagainya. d_model (`int`, *opsional*, defaultnya `256`) : Ukuran lapisan encoder dan lapisan pooler. dropout (`Union[float, int]`, *opsional*, defaultnya `0.1`) : Rasio untuk semua lapisan dropout. attention_dropout (`Union[float, int]`, *opsional*, defaultnya `0.0`) : Rasio dropout untuk probabilitas perhatian. activation_dropout (`Union[float, int]`, *opsional*, defaultnya `0.0`) : Rasio dropout untuk aktivasi di dalam lapisan fully connected. init_std (`float`, *opsional*, defaultnya `0.02`) : Deviasi standar dari truncated_normal_initializer untuk menginisialisasi semua matriks bobot. init_xavier_std (`float`, *opsional*, defaultnya `1.0`) : Faktor penskalaan yang digunakan untuk inisialisasi Xavier pada bobot cross-attention. return_intermediate (`bool`, *opsional*, defaultnya True) : Apakah akan mengembalikan keadaan perantara atau tidak auxiliary_loss (`bool`, *opsional*, defaultnya `False`) : Apakah kerugian dekode bantu (kerugian di setiap lapisan decoder) akan digunakan. position_embedding_type (`str`, *opsional*, defaultnya `"sine"`) : Jenis position embeddings yang akan digunakan di atas fitur gambar. Salah satu dari `"sine"` atau `"learned"`. dilation (`bool`, *opsional*, defaultnya `False`) : Apakah akan mengganti stride dengan dilation pada blok konvolusional terakhir (DC5). Hanya didukung ketika `use_timm_backbone` = `True`. num_feature_levels (`int`, *opsional*, defaultnya 4) : Jumlah level fitur input. encoder_n_points (`int`, *opsional*, defaultnya 4) : Jumlah kunci yang disampelkan di setiap tingkat fitur untuk setiap kepala perhatian dalam encoder. decoder_n_points (`int`, *opsional*, defaultnya 4) : Jumlah kunci yang disampelkan di setiap tingkat fitur untuk setiap kepala perhatian dalam decoder. two_stage (`bool`, *opsional*, defaultnya `False`) : Apakah akan menerapkan deformable DETR dua tahap, di mana proposal region juga dihasilkan oleh varian Deformable DETR, yang kemudian dimasukkan ke dalam decoder untuk penyempurnaan kotak batas secara iteratif. two_stage_num_proposals (`int`, *opsional*, default 300) : Jumlah proposal region yang akan dihasilkan, jika `two_stage` diatur ke `True`. with_box_refine (`bool`, *opsional*, defaultnya `False`) : Apakah akan menerapkan penyempurnaan kotak batas iteratif, di mana setiap lapisan decoder menyempurnakan kotak batas berdasarkan prediksi dari lapisan sebelumnya. class_cost (`int`, *opsional*, defaultnya `1`) : Bobot relatif dari error klasifikasi dalam biaya pencocokan Hungarian. bbox_cost (`int`, *opsional*, defaultnya `5`) : Bobot relatif dari error kotak pembatas L1 dalam biaya pencocokan Hungaria. giou_cost (`int`, *opsional*, defaultnya `2`) : Bobot relatif dari kerugian IoU umum dalam biaya pencocokan Hungaria. mask_loss_coefficient (`int`, *opsional*, defaultnya `1`) : Bobot relatif dari focal loss dalam loss segmentasi panoptik. dice_loss_coefficient (`int`, *opsional*, defaultnya `1`) : Bobot relatif dari dice loss dalam loss segmentasi panoptik. bbox_loss_coefficient (`int`, *opsional*, defaultnya `5`) : Bobot relatif dari kerugian kotak batas L1 dalam kerugian segmentasi panoptik. giou_loss_coefficient (`int`, *opsional*, defaultnya `2`) : Bobot relatif dari kerugian IoU umum dalam kerugian segmentasi panoptik. eos_coefficient (`float`, *opsional*, default `0.1`) : Bobot klasifikasi relatif untuk kelas 'no-object' dalam loss deteksi objek. focal_alpha (`float`, *opsional*, default `0.25`) : Parameter alpha dalam focal loss. disable_custom_kernels (`bool`, *opsional*, defaultnya `False`) : Menonaktifkan penggunaan kernel CUDA dan CPU kustom. Opsi ini diperlukan untuk ekspor ONNX, karena kernel kustom tidak didukung oleh ekspor ONNX PyTorch. tie_word_embeddings (`bool`, *opsional*, defaultnya `True`) : Apakah mengikat embedding bobot sesuai dengan pemetaan `tied_weights_keys` model. Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari DeformableDetrModel. Kelas ini digunakan untuk membuat instans model Deformable Detr sesuai dengan argumen yang ditentukan, sehingga mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari [SenseTime/deformable-detr](https://huggingface.co/SenseTime/deformable-detr) Objek konfigurasi mewarisi dari [PreTrainedConfig](/docs/transformers/v5.23.0/id/main_classes/configuration#transformers.PreTrainedConfig) dan dapat digunakan untuk mengontrol keluaran model. Baca dokumentasi dari [PreTrainedConfig](/docs/transformers/v5.23.0/id/main_classes/configuration#transformers.PreTrainedConfig) untuk informasi lebih lanjut. Contoh: ```python >>> from transformers import DeformableDetrConfig, DeformableDetrModel >>> # Initializing a Deformable DETR SenseTime/deformable-detr style configuration >>> configuration = DeformableDetrConfig() >>> # Initializing a model (with random weights) from the SenseTime/deformable-detr style configuration >>> model = DeformableDetrModel(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## DeformableDetrModel[[transformers.DeformableDetrModel]] #### transformers.DeformableDetrModel[[transformers.DeformableDetrModel]] ```python transformers.DeformableDetrModel(config: DeformableDetrConfig) ``` [Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/deformable_detr/modeling_deformable_detr.py#L1145) **Parameter:** config ([DeformableDetrConfig](/docs/transformers/v5.23.0/id/model_doc/deformable_detr#transformers.DeformableDetrConfig)) : 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/v5.23.0/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk memuat bobot model. Model Deformable DETR polos (terdiri dari backbone dan Transformer encoder-decoder) yang menghasilkan hidden-states mentah tanpa head spesifik di atasnya. Model ini mewarisi dari [PreTrainedModel](/docs/transformers/v5.23.0/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.DeformableDetrModel.forward]] ```python forward(pixel_values: Tensor, pixel_mask: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.Tensor] = None, encoder_outputs: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, decoder_inputs_embeds: typing.Optional[torch.Tensor] = None, **kwargs: *) ``` [Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/deformable_detr/modeling_deformable_detr.py#L1319) **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 `image_processor_class`. Lihat `image_processor_class.__call__` untuk detailnya (`processor_class` menggunakan `image_processor_class` untuk memproses gambar). pixel_mask (`torch.LongTensor` dengan bentuk `(batch_size, height, width)`, *opsional*) : Mask untuk menghindari pelaksanaan perhatian pada nilai piksel padding. Nilai mask yang dipilih dalam `[0, 1]`: - 1 untuk piksel yang asli (yaitu **tidak dimask**), - 0 untuk piksel yang merupakan padding (yaitu **dimask**). [Apa itu attention mask?](../glossary#attention-mask) decoder_attention_mask (`torch.Tensor` dengan bentuk `(batch_size, num_queries)`, *opsional*) : Tidak digunakan secara default. Dapat digunakan untuk memasker kueri objek. encoder_outputs (`torch.Tensor`, *opsional*) : Tuple terdiri dari (`last_hidden_state`, *opsional*: `hidden_states`, *opsional*: `attentions`) `last_hidden_state` dengan bentuk `(batch_size, sequence_length, hidden_size)`, *opsional*) adalah urutan hidden-states pada keluaran lapisan terakhir encoder. Digunakan dalam cross-attention decoder. inputs_embeds (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`, *opsional*) : Secara opsional, alih-alih meneruskan peta fitur yang telah diratakan (output dari backbone + lapisan proyeksi), Anda dapat memilih untuk langsung meneruskan representasi ratakan dari sebuah gambar. decoder_inputs_embeds (`torch.Tensor` dengan bentuk `(batch_size, num_queries, hidden_size)`, *opsional*) : Secara opsional, alih-alih menginisialisasi query dengan tensor nol, Anda dapat memilih untuk langsung meneruskan representasi tertanam. **Mengembalikan:** `DeformableDetrModelOutput` atau `tuple(torch.Tensor)` Sebuah `DeformableDetrModelOutput` atau tuple dari `torch.Tensor` (jika `return_dict=False` diteruskan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi (`None`) dan input. Metode forward dari [DeformableDetrModel](/docs/transformers/v5.23.0/id/model_doc/deformable_detr#transformers.DeformableDetrModel) 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. - **init_reference_points** (`torch.Tensor` dengan bentuk `(batch_size, num_queries, 4)`) -- Titik referensi awal yang dikirim melalui decoder Transformer. - **last_hidden_state** (`torch.Tensor` dengan bentuk `(batch_size, num_queries, hidden_size)`) -- Urutan hidden-states pada keluaran lapisan terakhir dari decoder model. - **intermediate_hidden_states** (`torch.Tensor` dengan bentuk `(batch_size, config.decoder_layers, num_queries, hidden_size)`) -- Hidden states antara yang ditumpuk (output dari setiap layer decoder). - **intermediate_reference_points** (`torch.Tensor` dengan bentuk `(batch_size, config.decoder_layers, num_queries, 4)`) -- Titik referensi antara yang ditumpuk (titik referensi dari setiap lapisan decoder). - **decoder_hidden_states** (`tuple[torch.Tensor]`, *opsional*, dikembalikan ketika `output_hidden_states=True` dilewatkan atau ketika `config.output_hidden_states=True`) -- Tuple dari `torch.Tensor` (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk `(batch_size, sequence_length, hidden_size)`. Hidden-states dari decoder pada output setiap layer ditambah output embedding awal. - **decoder_attentions** (`tuple[torch.Tensor]`, *opsional*, dikembalikan ketika `output_attentions=True` dilewatkan atau ketika `config.output_attentions=True`) -- Tuple dari `torch.Tensor` (satu untuk setiap layer) dengan bentuk `(batch_size, num_heads, sequence_length, sequence_length)`. Bobot perhatian dari decoder, setelah softmax perhatian, yang digunakan untuk menghitung rata-rata berbobot di kepala self-attention. - **cross_attentions** (`tuple[torch.Tensor]`, *opsional*, dikembalikan ketika `output_attentions=True` dilewatkan atau ketika `config.output_attentions=True`) -- Tuple dari `torch.Tensor` (satu untuk setiap layer) dengan bentuk `(batch_size, num_heads, sequence_length, sequence_length)`. Bobot perhatian dari lapisan cross-attention decoder, setelah softmax perhatian, yang digunakan untuk menghitung rata-rata berbobot di kepala cross-attention. - **encoder_last_hidden_state** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`, *opsional*) -- Urutan hidden-states pada keluaran lapisan terakhir dari encoder model. - **encoder_hidden_states** (`tuple[torch.Tensor]`, *opsional*, dikembalikan ketika `output_hidden_states=True` dilewatkan atau ketika `config.output_hidden_states=True`) -- Tuple dari `torch.Tensor` (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk `(batch_size, sequence_length, hidden_size)`. Hidden-states dari encoder pada output setiap layer ditambah output embedding awal. - **encoder_attentions** (`tuple[torch.Tensor]`, *opsional*, dikembalikan ketika `output_attentions=True` dilewatkan atau ketika `config.output_attentions=True`) -- Tuple dari `torch.Tensor` (satu untuk setiap layer) dengan bentuk `(batch_size, num_heads, sequence_length, sequence_length)`. Bobot perhatian dari encoder, setelah softmax perhatian, yang digunakan untuk menghitung rata-rata berbobot di kepala self-attention. - **enc_outputs_class** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, config.num_labels)`, *opsional*, dikembalikan ketika `config.with_box_refine=True` dan `config.two_stage=True`) -- Skor kotak pembatas yang diprediksi, di mana `config.two_stage_num_proposals` kotak pembatas dengan skor tertinggi dipilih sebagai usulan wilayah pada tahap pertama. Output dari klasifikasi biner kotak pembatas (yaitu latar depan dan latar belakang). - **enc_outputs_coord_logits** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, 4)`, *opsional*, dikembalikan ketika `config.with_box_refine=True` dan `config.two_stage=True`) -- Logits dari koordinat bounding box yang diprediksi pada tahap pertama. Contoh: ```python >>> from transformers import AutoImageProcessor, DeformableDetrModel >>> from PIL import Image >>> from huggingface_hub.utils import httpx >>> from io import BytesIO >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg" >>> with httpx.stream("GET", url) as response: ... image = Image.open(BytesIO(response.read())) >>> image_processor = AutoImageProcessor.from_pretrained("SenseTime/deformable-detr") >>> model = DeformableDetrModel.from_pretrained("SenseTime/deformable-detr") >>> inputs = image_processor(images=image, return_tensors="pt") >>> outputs = model(**inputs) >>> last_hidden_states = outputs.last_hidden_state >>> list(last_hidden_states.shape) [1, 300, 256] ``` ## DeformableDetrForObjectDetection[[transformers.DeformableDetrForObjectDetection]] #### transformers.DeformableDetrForObjectDetection[[transformers.DeformableDetrForObjectDetection]] ```python transformers.DeformableDetrForObjectDetection(config: DeformableDetrConfig) ``` [Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/deformable_detr/modeling_deformable_detr.py#L1542) **Parameter:** config ([DeformableDetrConfig](/docs/transformers/v5.23.0/id/model_doc/deformable_detr#transformers.DeformableDetrConfig)) : 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/v5.23.0/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk memuat bobot model. Model Deformable DETR (terdiri dari backbone dan Transformer encoder-decoder) dengan kepala deteksi objek di atasnya, untuk tugas seperti deteksi COCO. Model ini mewarisi dari [PreTrainedModel](/docs/transformers/v5.23.0/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.DeformableDetrForObjectDetection.forward]] ```python forward(pixel_values: Tensor, pixel_mask: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.Tensor] = None, encoder_outputs: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, decoder_inputs_embeds: typing.Optional[torch.Tensor] = None, labels: list[dict] | None = None, **kwargs: *) ``` [Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/deformable_detr/modeling_deformable_detr.py#L1580) **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 `image_processor_class`. Lihat `image_processor_class.__call__` untuk detailnya (`processor_class` menggunakan `image_processor_class` untuk memproses gambar). pixel_mask (`torch.LongTensor` dengan bentuk `(batch_size, height, width)`, *opsional*) : Mask untuk menghindari pelaksanaan perhatian pada nilai piksel padding. Nilai mask yang dipilih dalam `[0, 1]`: - 1 untuk piksel yang asli (yaitu **tidak dimask**), - 0 untuk piksel yang merupakan padding (yaitu **dimask**). [Apa itu attention mask?](../glossary#attention-mask) decoder_attention_mask (`torch.Tensor` dengan bentuk `(batch_size, num_queries)`, *opsional*) : Tidak digunakan secara default. Dapat digunakan untuk memasker kueri objek. encoder_outputs (`torch.Tensor`, *opsional*) : Tuple terdiri dari (`last_hidden_state`, *opsional*: `hidden_states`, *opsional*: `attentions`) `last_hidden_state` dengan bentuk `(batch_size, sequence_length, hidden_size)`, *opsional*) adalah urutan hidden-states pada keluaran lapisan terakhir encoder. Digunakan dalam cross-attention decoder. inputs_embeds (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`, *opsional*) : Secara opsional, alih-alih meneruskan peta fitur yang telah diratakan (output dari backbone + lapisan proyeksi), Anda dapat memilih untuk langsung meneruskan representasi ratakan dari sebuah gambar. decoder_inputs_embeds (`torch.Tensor` dengan bentuk `(batch_size, num_queries, hidden_size)`, *opsional*) : Secara opsional, alih-alih menginisialisasi query dengan tensor nol, Anda dapat memilih untuk langsung meneruskan representasi tertanam. 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)`. **Mengembalikan:** `DeformableDetrObjectDetectionOutput` atau `tuple(torch.Tensor)` `DeformableDetrObjectDetectionOutput` atau tuple dari `torch.Tensor` (jika `return_dict=False` dilewatkan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi (`None`) dan input. Metode forward dari [DeformableDetrForObjectDetection](/docs/transformers/v5.23.0/id/model_doc/deformable_detr#transformers.DeformableDetrForObjectDetection) 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` dengan bentuk `(1,)`, *opsional*, dikembalikan ketika `labels` disediakan)) -- Total loss sebagai kombinasi linear dari negative log-likelihood (cross-entropy) untuk prediksi kelas dan bounding box loss. Yang terakhir didefinisikan sebagai kombinasi linear dari L1 loss dan generalized scale-invariant IoU loss. - **loss_dict** (`Dict`, *opsional*) -- Kamus yang berisi kerugian individual. Berguna untuk pencatatan. - **logits** (`torch.Tensor` dengan bentuk `(batch_size, num_queries, num_classes + 1)`) -- Logit klasifikasi (termasuk no-object) untuk semua query. - **pred_boxes** (`torch.Tensor` dengan bentuk `(batch_size, num_queries, 4)`) -- Koordinat kotak yang dinormalisasi untuk semua query, direpresentasikan sebagai (center_x, center_y, width, height). Nilai-nilai ini dinormalisasi dalam rentang [0, 1], relatif terhadap ukuran masing-masing gambar dalam batch (mengabaikan padding yang mungkin ada). Anda dapat menggunakan `~DeformableDetrProcessor.post_process_object_detection` untuk mengambil kotak batas yang tidak dinormalisasi. - **auxiliary_outputs** (`list[Dict]`, *opsional*) -- Opsional, hanya dikembalikan ketika auxiliary losses diaktifkan (yaitu `config.auxiliary_loss` diatur ke `True`) dan label disediakan. Ini adalah daftar kamus yang berisi dua kunci di atas (`logits` dan `pred_boxes`) untuk setiap lapisan decoder. - **last_hidden_state** (`torch.Tensor` dengan bentuk `(batch_size, num_queries, hidden_size)`, *opsional*) -- Urutan hidden-states pada keluaran lapisan terakhir dari decoder model. - **decoder_hidden_states** (`tuple[torch.Tensor]`, *opsional*, dikembalikan ketika `output_hidden_states=True` dilewatkan atau ketika `config.output_hidden_states=True`) -- Tuple dari `torch.Tensor` (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk `(batch_size, sequence_length, hidden_size)`. Hidden-states dari decoder pada output setiap layer ditambah output embedding awal. - **decoder_attentions** (`tuple[torch.Tensor]`, *opsional*, dikembalikan ketika `output_attentions=True` dilewatkan atau ketika `config.output_attentions=True`) -- Tuple dari `torch.Tensor` (satu untuk setiap layer) dengan bentuk `(batch_size, num_heads, sequence_length, sequence_length)`. Bobot perhatian dari decoder, setelah softmax perhatian, yang digunakan untuk menghitung rata-rata berbobot di kepala self-attention. - **cross_attentions** (`tuple[torch.Tensor]`, *opsional*, dikembalikan ketika `output_attentions=True` dilewatkan atau ketika `config.output_attentions=True`) -- Tuple dari `torch.Tensor` (satu untuk setiap layer) dengan bentuk `(batch_size, num_heads, sequence_length, sequence_length)`. Bobot perhatian dari lapisan cross-attention decoder, setelah softmax perhatian, yang digunakan untuk menghitung rata-rata berbobot di kepala cross-attention. - **encoder_last_hidden_state** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, hidden_size)`, *opsional*) -- Urutan hidden-states pada keluaran lapisan terakhir dari encoder model. - **encoder_hidden_states** (`tuple[torch.Tensor]`, *opsional*, dikembalikan ketika `output_hidden_states=True` dilewatkan atau ketika `config.output_hidden_states=True`) -- Tuple dari `torch.Tensor` (satu untuk output dari embeddings, jika model memiliki lapisan embedding, + satu untuk output dari setiap lapisan) dengan bentuk `(batch_size, sequence_length, hidden_size)`. Hidden-states dari encoder pada output setiap layer ditambah output embedding awal. - **encoder_attentions** (`tuple[torch.Tensor]`, *opsional*, dikembalikan ketika `output_attentions=True` dilewatkan atau ketika `config.output_attentions=True`) -- Tuple dari `torch.Tensor` (satu untuk setiap layer) dengan bentuk `(batch_size, num_heads, sequence_length, sequence_length)`. Bobot perhatian dari encoder, setelah softmax perhatian, yang digunakan untuk menghitung rata-rata berbobot di kepala self-attention. - **init_reference_points** (`torch.Tensor` dengan bentuk `(batch_size, num_queries, 4)`) -- Titik referensi awal yang dikirim melalui decoder Transformer. - **intermediate_hidden_states** (`torch.Tensor` dengan bentuk `(batch_size, config.decoder_layers, num_queries, hidden_size)`) -- Hidden states antara yang ditumpuk (output dari setiap layer decoder). - **intermediate_reference_points** (`torch.Tensor` dengan bentuk `(batch_size, config.decoder_layers, num_queries, 4)`) -- Titik referensi antara yang ditumpuk (titik referensi dari setiap lapisan decoder). - **enc_outputs_class** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, config.num_labels)`, *opsional*, dikembalikan ketika `config.with_box_refine=True` dan `config.two_stage=True`) -- Skor kotak pembatas yang diprediksi, di mana `config.two_stage_num_proposals` kotak pembatas dengan skor tertinggi dipilih sebagai usulan wilayah pada tahap pertama. Output dari klasifikasi biner kotak pembatas (yaitu latar depan dan latar belakang). - **enc_outputs_coord_logits** (`torch.Tensor` dengan bentuk `(batch_size, sequence_length, 4)`, *opsional*, dikembalikan ketika `config.with_box_refine=True` dan `config.two_stage=True`) -- Logits dari koordinat bounding box yang diprediksi pada tahap pertama. Contoh: ```python >>> from transformers import AutoImageProcessor, DeformableDetrForObjectDetection >>> from PIL import Image >>> from huggingface_hub.utils import httpx >>> from io import BytesIO >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg" >>> with httpx.stream("GET", url) as response: ... image = Image.open(BytesIO(response.read())) >>> image_processor = AutoImageProcessor.from_pretrained("SenseTime/deformable-detr") >>> model = DeformableDetrForObjectDetection.from_pretrained("SenseTime/deformable-detr") >>> inputs = image_processor(images=image, return_tensors="pt") >>> outputs = model(**inputs) >>> # convert outputs (bounding boxes and class logits) to Pascal VOC format (xmin, ymin, xmax, ymax) >>> target_sizes = torch.tensor([image.size[::-1]]) >>> results = image_processor.post_process_object_detection(outputs, threshold=0.5, target_sizes=target_sizes)[ ... 0 ... ] >>> for score, label, box in zip(results["scores"], results["labels"], results["boxes"]): ... box = [round(i, 2) for i in box.tolist()] ... print( ... f"Detected {model.config.id2label[label.item()]} with confidence " ... f"{round(score.item(), 3)} at location {box}" ... ) Detected cat with confidence 0.8 at location [16.5, 52.84, 318.25, 470.78] Detected cat with confidence 0.789 at location [342.19, 24.3, 640.02, 372.25] Detected remote with confidence 0.633 at location [40.79, 72.78, 176.76, 117.25] ```