# EoMT ## Ikhtisar Model [The Encoder-only Mask Transformer](https://www.tue-mps.org/eomt) (EoMT) diperkenalkan dalam CVPR 2025 Highlight Paper *[Your ViT is Secretly an Image Segmentation Model](https://huggingface.co/papers/2503.19108)* oleh Tommie Kerssies, Niccolò Cavagnero, Alexander Hermans, Narges Norouzi, Giuseppe Averta, Bastian Leibe, Gijs Dubbelman, dan Daan de Geus. EoMT mengungkapkan bahwa Vision Transformers dapat melakukan segmentasi gambar secara efisien tanpa komponen khusus tugas. Abstrak dari makalah tersebut adalah sebagai berikut: *Vision Transformers (ViTs) telah menunjukkan kinerja dan skalabilitas yang luar biasa di berbagai tugas computer vision. Untuk menerapkan ViTs berskala tunggal pada segmentasi gambar, metode yang ada mengadopsi adapter konvolusional untuk menghasilkan fitur multi-skala, pixel decoder untuk menggabungkan fitur-fitur tersebut, dan Transformer decoder yang menggunakan fitur gabungan untuk membuat prediksi. Dalam makalah ini, kami menunjukkan bahwa bias induktif yang diperkenalkan oleh komponen khusus tugas ini justru dapat dipelajari oleh ViT itu sendiri, asalkan modelnya cukup besar dan pre-training-nya cukup luas. Berdasarkan temuan ini, kami memperkenalkan Encoder-only Mask Transformer (EoMT), yang memanfaatkan ulang arsitektur ViT polos untuk melakukan segmentasi gambar. Dengan model berskala besar dan pre-training, EoMT memperoleh akurasi segmentasi yang serupa dengan model state-of-the-art yang menggunakan komponen khusus tugas. Pada saat yang sama, EoMT jauh lebih cepat daripada metode-metode tersebut berkat kesederhanaan arsitekturnya, misalnya hingga 4x lebih cepat dengan ViT-L. Di berbagai ukuran model, EoMT menunjukkan keseimbangan optimal antara akurasi segmentasi dan kecepatan prediksi, yang menunjukkan bahwa sumber daya komputasi lebih baik digunakan untuk menskalakan ViT itu sendiri daripada menambah kompleksitas arsitektur.* Model ini disumbangkan oleh [Yaswanth Gali](https://huggingface.co/yaswanthgali). Kode aslinya dapat ditemukan [di sini](https://github.com/tue-mps/eomt). ## Info Arsitektur Model `EoMT` menggunakan Vision Transformer yang telah dilatih sebelumnya dengan DINOv2 dan dilengkapi **register tokens** sebagai backbonenya. EoMT menyederhanakan pipeline segmentasi dengan hanya mengandalkan encoder, sehingga menghilangkan kebutuhan akan decoder khusus tugas yang umum digunakan dalam pendekatan sebelumnya. Secara arsitektural, EoMT memperkenalkan seperangkat kecil **learned queries** dan modul prediksi mask yang ringan (**mask prediction module**). Query-query ini disuntikkan ke dalam blok encoder terakhir, memungkinkan **joint attention** antara patch gambar dan query objek. Selama pelatihan, **masked attention** diterapkan untuk membatasi setiap query agar berfokus pada region yang bersesuaian—efektif meniru cross-attention. Batasan ini secara bertahap dihilangkan melalui **mask annealing strategy**, sehingga memungkinkan **efficient, decoder-free inference** tanpa mengorbankan kinerja segmentasi. drawing Model ini mendukung segmentasi semantik, instance, dan panoptik menggunakan arsitektur terpadu dan pascapemrosesan yang spesifik untuk tugas. ## Contoh Penggunaan Gunakan implementasi EoMT dari Hugging Face untuk inferensi dengan model terlatih. ### Segmentasi Semantik Model EoMT melakukan segmentasi semantik menggunakan inferensi jendela geser. Gambar input di-resize sehingga sisi yang lebih pendek sesuai dengan ukuran input target, kemudian dipecah menjadi potongan-potongan yang tumpang tindih. Setiap potongan kemudian diproses melalui model. Setelah inferensi, logit prediksi dari setiap potongan disatukan kembali dan di-rescale ke ukuran gambar asli untuk mendapatkan mask segmentasi akhir. > **Catatan:** Jika Anda ingin menggunakan ukuran target kustom untuk **semantic segmentation**, tentukan dalam format berikut: `{"shortest_edge": 512}` Perhatikan bahwa `longest_edge` tidak disediakan di sini — ini disengaja. Untuk semantic segmentation, gambar biasanya **diskala sehingga sisi terpendek lebih besar atau sama dengan ukuran target** sehingga longest_edge tidak diperlukan. ```python import matplotlib.pyplot as plt import requests import torch from PIL import Image from transformers import AutoImageProcessor, EomtForUniversalSegmentation model_id = "tue-mps/ade20k_semantic_eomt_large_512" processor = AutoImageProcessor.from_pretrained(model_id) model = EomtForUniversalSegmentation.from_pretrained(model_id, device_map="auto") image = Image.open(requests.get("http://images.cocodataset.org/val2017/000000039769.jpg", stream=True).raw) inputs = processor( images=image, return_tensors="pt", ) with torch.inference_mode(): outputs = model(**inputs) # Prepare the original image size in the format (height, width) target_sizes = [(image.height, image.width)] # Post-process the model outputs to get final segmentation prediction preds = processor.post_process_semantic_segmentation( outputs, target_sizes=target_sizes, ) # Visualize the segmentation mask plt.imshow(preds[0]) plt.axis("off") plt.title("Semantic Segmentation") plt.show() ``` ### Segmentasi Instans Model EoMT melakukan segmentasi instance menggunakan inferensi dengan padding. Gambar input di-resize sehingga sisi yang lebih panjang sesuai dengan ukuran input target, dan sisi yang lebih pendek di-pad dengan nol untuk membentuk persegi. Mask dan logits kelas yang dihasilkan digabungkan melalui pascaproses (diadaptasi dari Mask2Former) untuk menghasilkan peta segmentasi instance yang terpadu, bersama dengan metadata segmen seperti id segmen, label kelas, dan skor kepercayaan. > **Catatan:** Untuk menggunakan ukuran target kustom, tentukan ukuran sebagai kamus dalam format berikut: `{"shortest_edge": 512, "longest_edge": 512}` Untuk segmentasi instance dan panoptic, gambar input akan **diskala dan diberi padding** ke ukuran target ini. ```python import matplotlib.pyplot as plt import requests import torch from PIL import Image from transformers import AutoImageProcessor, EomtForUniversalSegmentation model_id = "tue-mps/coco_instance_eomt_large_640" processor = AutoImageProcessor.from_pretrained(model_id) model = EomtForUniversalSegmentation.from_pretrained(model_id, device_map="auto") image = Image.open(requests.get("http://images.cocodataset.org/val2017/000000039769.jpg", stream=True).raw) inputs = processor( images=image, return_tensors="pt", ) with torch.inference_mode(): outputs = model(**inputs) # Prepare the original image size in the format (height, width) target_sizes = [(image.height, image.width)] # Post-process the model outputs to get final segmentation prediction preds = processor.post_process_instance_segmentation( outputs, target_sizes=target_sizes, ) # Visualize the segmentation mask plt.imshow(preds[0]["segmentation"]) plt.axis("off") plt.title("Instance Segmentation") plt.show() ``` ### Segmentasi Panoptik Model EoMT melakukan segmentasi panoptik menggunakan strategi inferensi bantalan yang sama seperti pada segmentasi instance. Setelah pembantalan dan normalisasi, model memprediksi kelas thing (instance) dan stuff (wilayah amorf). Mask dan logit kelas yang dihasilkan digabungkan melalui pascaproses (diadaptasi dari Mask2Former) untuk menghasilkan peta segmentasi panoptik yang terpadu, bersama dengan metadata segmen seperti id segmen, label kelas, dan skor kepercayaan. ```python import matplotlib.pyplot as plt import requests import torch from PIL import Image from transformers import AutoImageProcessor, EomtForUniversalSegmentation model_id = "tue-mps/coco_panoptic_eomt_large_640" processor = AutoImageProcessor.from_pretrained(model_id) model = EomtForUniversalSegmentation.from_pretrained(model_id, device_map="auto") image = Image.open(requests.get("http://images.cocodataset.org/val2017/000000039769.jpg", stream=True).raw) inputs = processor( images=image, return_tensors="pt", ) with torch.inference_mode(): outputs = model(**inputs) # Prepare the original image size in the format (height, width) target_sizes = [(image.height, image.width)] # Post-process the model outputs to get final segmentation prediction preds = processor.post_process_panoptic_segmentation( outputs, target_sizes=target_sizes, ) # Visualize the panoptic segmentation mask plt.imshow(preds[0]["segmentation"]) plt.axis("off") plt.title("Panoptic Segmentation") plt.show() ``` ## EomtImageProcessor[[transformers.EomtImageProcessor]] #### transformers.EomtImageProcessor[[transformers.EomtImageProcessor]] ```python transformers.EomtImageProcessor(**kwargs: *) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/eomt/image_processing_eomt.py#L214) **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' : 640, 'longest_edge': 640}`): 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 `False`) : Apakah akan melakukan padding pada gambar. Padding dilakukan ke ukuran terbesar dalam batch atau ke 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. do_split_image (`bool`, *kwargs*, *opsional*, defaultnya `self.do_split_image`) : Apakah akan membagi gambar input menjadi patch yang tumpang tindih untuk segmentasi semantik. Jika diset ke `True`, gambar input akan dibagi menjadi patch berukuran `size["shortest_edge"]` dengan tumpang tindih antar patch. Sebaliknya, gambar input akan di-pad hingga ukuran target. ignore_index (`int`, *kwargs*, *opsional*, defaultnya `self.ignore_index`) : Label yang akan ditugaskan ke piksel latar belakang pada peta segmentasi. Jika disediakan, piksel peta segmentasi yang ditandai dengan 0 (latar belakang) akan diganti dengan `ignore_index`. Membangun pemroses gambar EomtImageProcessor. #### preprocess[[transformers.EomtImageProcessor.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']], segmentation_maps: list[torch.Tensor] | None = None, instance_id_to_semantic_id: dict[int, int] | None = None, **kwargs: *) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/eomt/image_processing_eomt.py#L273) **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`. segmentation_maps (`ImageInput`, *opsional*) : Peta segmentasi untuk praproses untuk gambar yang sesuai. instance_id_to_semantic_id (`list[dict[int, int]]` atau `dict[int, int]`, *opsional*) : Pemetaan antara id instance objek dan id kelas. 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. do_split_image (`bool`, *kwargs*, *opsional*, defaultnya `self.do_split_image`) : Apakah akan membagi gambar input menjadi patch yang tumpang tindih untuk segmentasi semantik. Jika diset ke `True`, gambar input akan dibagi menjadi patch berukuran `size["shortest_edge"]` dengan tumpang tindih antar patch. Sebaliknya, gambar input akan di-pad hingga ukuran target. ignore_index (`int`, *kwargs*, *opsional*, defaultnya `self.ignore_index`) : Label yang akan ditugaskan ke piksel latar belakang pada peta segmentasi. Jika disediakan, piksel peta segmentasi yang ditandai dengan 0 (latar belakang) akan diganti dengan `ignore_index`. **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_semantic_segmentation[[transformers.EomtImageProcessor.post_process_semantic_segmentation]] ```python post_process_semantic_segmentation(outputs, target_sizes: list, size: dict[str, int] | None = None, return_segmentation_scores: bool = False) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/eomt/image_processing_eomt.py#L502) **Parameter:** outputs ([EomtForUniversalSegmentation](/docs/transformers/main/id/model_doc/eomt#transformers.EomtForUniversalSegmentation)) : Output mentah dari model. target_sizes (`list[tuple[int, int]]`) : Daftar tuple (`tuple[int, int]`) yang berisi ukuran target (tinggi, lebar) dari setiap gambar dalam batch. size (`dict[str, int]`, *opsional*) : Ukuran di mana masker antara diinterpolasi. Bawaan adalah `self.size`. return_segmentation_scores (`bool`, *opsional*, defaultnya `False`) : Apakah akan mengembalikan skor segmentasi bersama dengan peta segmentasi. Ketika `True`, setiap elemen dari daftar yang dikembalikan adalah `SemanticSegmentationPostProcessorOutput` dengan field `segmentation` (ID kelas, bentuk `(height, width)`) dan `segmentation_scores` (bentuk `(num_classes, height, width)`). **Mengembalikan:** `list[torch.Tensor]` atau `list[SemanticSegmentationPostProcessorOutput]` Ketika `return_segmentation_scores=False` (default), sebuah daftar dengan panjang `batch_size` di mana setiap item adalah peta segmentasi dengan bentuk `(height, width)` berisi ID kelas. Ketika `return_segmentation_scores=True`, sebuah daftar `SemanticSegmentationPostProcessorOutput` dengan bidang `segmentation` (ID kelas, bentuk `(height, width)`) dan `segmentation_scores` (bentuk `(num_classes, height, width)`). Dalam kedua kasus, `(height, width)` sesuai dengan ukuran target. Mengonversi output dari [EomtForUniversalSegmentation](/docs/transformers/main/id/model_doc/eomt#transformers.EomtForUniversalSegmentation) menjadi peta segmentasi semantik. #### post_process_instance_segmentation[[transformers.EomtImageProcessor.post_process_instance_segmentation]] ```python post_process_instance_segmentation(outputs, target_sizes: list, threshold: float = 0.8, size: dict[str, int] | None = None) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/eomt/image_processing_eomt.py#L635) Memproses ulang keluaran model menjadi Prediksi Segmentasi Instans. #### post_process_panoptic_segmentation[[transformers.EomtImageProcessor.post_process_panoptic_segmentation]] ```python post_process_panoptic_segmentation(outputs, target_sizes: list, threshold: float = 0.8, mask_threshold: float = 0.5, overlap_mask_area_threshold: float = 0.8, stuff_classes: list[int] | None = None, size: dict[str, int] | None = None) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/eomt/image_processing_eomt.py#L578) Memproses ulang keluaran model menjadi prediksi segmentasi panoptik akhir. ## EomtImageProcessorPil[[transformers.EomtImageProcessorPil]] #### transformers.EomtImageProcessorPil[[transformers.EomtImageProcessorPil]] ```python transformers.EomtImageProcessorPil(**kwargs: *) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/eomt/image_processing_pil_eomt.py#L215) **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' : 640, 'longest_edge': 640}`): 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 `False`) : Apakah akan melakukan padding pada gambar. Padding dilakukan ke ukuran terbesar dalam batch atau ke 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. do_split_image (`bool`, *kwargs*, *opsional*, defaultnya `self.do_split_image`) : Apakah akan membagi gambar input menjadi patch yang tumpang tindih untuk segmentasi semantik. Jika diset ke `True`, gambar input akan dibagi menjadi patch berukuran `size["shortest_edge"]` dengan tumpang tindih antar patch. Sebaliknya, gambar input akan di-pad hingga ukuran target. ignore_index (`int`, *kwargs*, *opsional*, defaultnya `self.ignore_index`) : Label yang akan ditugaskan ke piksel latar belakang pada peta segmentasi. Jika disediakan, piksel peta segmentasi yang ditandai dengan 0 (latar belakang) akan diganti dengan `ignore_index`. Membangun pemroses gambar EomtImageProcessor. #### preprocess[[transformers.EomtImageProcessorPil.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']], segmentation_maps: list[torch.Tensor] | None = None, instance_id_to_semantic_id: dict[int, int] | None = None, **kwargs: *) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/eomt/image_processing_pil_eomt.py#L281) **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`. segmentation_maps (`ImageInput`, *opsional*) : Peta segmentasi untuk praproses untuk gambar yang sesuai. instance_id_to_semantic_id (`list[dict[int, int]]` atau `dict[int, int]`, *opsional*) : Pemetaan antara id instance objek dan id kelas. 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. do_split_image (`bool`, *kwargs*, *opsional*, defaultnya `self.do_split_image`) : Apakah akan membagi gambar input menjadi patch yang tumpang tindih untuk segmentasi semantik. Jika diset ke `True`, gambar input akan dibagi menjadi patch berukuran `size["shortest_edge"]` dengan tumpang tindih antar patch. Sebaliknya, gambar input akan di-pad hingga ukuran target. ignore_index (`int`, *kwargs*, *opsional*, defaultnya `self.ignore_index`) : Label yang akan ditugaskan ke piksel latar belakang pada peta segmentasi. Jika disediakan, piksel peta segmentasi yang ditandai dengan 0 (latar belakang) akan diganti dengan `ignore_index`. **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_semantic_segmentation[[transformers.EomtImageProcessorPil.post_process_semantic_segmentation]] ```python post_process_semantic_segmentation(outputs, target_sizes: list, size: dict[str, int] | None = None, return_segmentation_scores: bool = False) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/eomt/image_processing_pil_eomt.py#L495) **Parameter:** outputs ([EomtForUniversalSegmentation](/docs/transformers/main/id/model_doc/eomt#transformers.EomtForUniversalSegmentation)) : Output mentah dari model. target_sizes (`list[tuple[int, int]]`) : Daftar tuple (`tuple[int, int]`) yang berisi ukuran target (tinggi, lebar) dari setiap gambar dalam batch. size (`dict[str, int]`, *opsional*) : Ukuran di mana masker antara diinterpolasi. Bawaan adalah `self.size`. return_segmentation_scores (`bool`, *opsional*, defaultnya `False`) : Apakah akan mengembalikan skor segmentasi bersama dengan peta segmentasi. Ketika `True`, setiap elemen dari daftar yang dikembalikan adalah `SemanticSegmentationPostProcessorOutput` dengan field `segmentation` (ID kelas, bentuk `(height, width)`) dan `segmentation_scores` (bentuk `(num_classes, height, width)`). **Mengembalikan:** `list[torch.Tensor]` atau `list[SemanticSegmentationPostProcessorOutput]` Ketika `return_segmentation_scores=False` (default), sebuah daftar dengan panjang `batch_size` di mana setiap item adalah peta segmentasi dengan bentuk `(height, width)` berisi ID kelas. Ketika `return_segmentation_scores=True`, sebuah daftar `SemanticSegmentationPostProcessorOutput` dengan bidang `segmentation` (ID kelas, bentuk `(height, width)`) dan `segmentation_scores` (bentuk `(num_classes, height, width)`). Dalam kedua kasus, `(height, width)` sesuai dengan ukuran target. Mengonversi output dari [EomtForUniversalSegmentation](/docs/transformers/main/id/model_doc/eomt#transformers.EomtForUniversalSegmentation) menjadi peta segmentasi semantik. #### post_process_instance_segmentation[[transformers.EomtImageProcessorPil.post_process_instance_segmentation]] ```python post_process_instance_segmentation(outputs, target_sizes: list, threshold: float = 0.8, size: dict[str, int] | None = None) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/eomt/image_processing_pil_eomt.py#L620) Memproses ulang keluaran model menjadi Prediksi Segmentasi Instans. #### post_process_panoptic_segmentation[[transformers.EomtImageProcessorPil.post_process_panoptic_segmentation]] ```python post_process_panoptic_segmentation(outputs, target_sizes: list, threshold: float = 0.8, mask_threshold: float = 0.5, overlap_mask_area_threshold: float = 0.8, stuff_classes: list[int] | None = None, size: dict[str, int] | None = None) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/eomt/image_processing_pil_eomt.py#L567) Memproses ulang keluaran model menjadi prediksi segmentasi panoptik akhir. ## EomtConfig[[transformers.EomtConfig]] #### transformers.EomtConfig[[transformers.EomtConfig]] ```python transformers.EomtConfig(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, is_encoder_decoder: bool = False, 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, hidden_size: int = 1024, num_hidden_layers: int = 24, num_attention_heads: int = 16, hidden_act: str = 'gelu', hidden_dropout_prob: float | int = 0.0, initializer_range: float = 0.02, layer_norm_eps: float = 1e-06, image_size: int | list[int] | tuple[int, int] = 640, patch_size: int | list[int] | tuple[int, int] = 16, num_channels: int = 3, mlp_ratio: int = 4, layerscale_value: float = 1.0, drop_path_rate: float | int = 0.0, num_upscale_blocks: int = 2, attention_dropout: float | int = 0.0, use_swiglu_ffn: bool = False, num_blocks: int = 4, no_object_weight: float = 0.1, class_weight: float = 2.0, mask_weight: float = 5.0, dice_weight: float = 5.0, train_num_points: int = 12544, oversample_ratio: float = 3.0, importance_sample_ratio: float = 0.75, num_queries: int = 200, num_register_tokens: int = 4) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/eomt/configuration_eomt.py#L28) **Parameter:** hidden_size (`int`, *opsional*, defaultnya `1024`) : Dimensi dari representasi tersembunyi. num_hidden_layers (`int`, *opsional*, defaultnya `24`) : Jumlah lapisan tersembunyi dalam decoder Transformer. num_attention_heads (`int`, *opsional*, defaultnya `16`) : Jumlah kepala perhatian untuk setiap lapisan perhatian dalam decoder Transformer. hidden_act (`str`, *opsional*, defaultnya `gelu`) : Fungsi aktivasi non-linear (fungsi atau string) di decoder. Misalnya, `"gelu"`, `"relu"`, `"silu"`, dan sebagainya. hidden_dropout_prob (`Union[float, int]`, *opsional*, defaultnya `0.0`) : Probabilitas dropout untuk semua lapisan fully connected di embeddings, encoder, dan pooler. initializer_range (`float`, *opsional*, defaultnya `0.02`) : Deviasi standar dari truncated_normal_initializer untuk menginisialisasi semua matriks bobot. layer_norm_eps (`float`, *opsional*, defaultnya `1e-06`) : Epsilon yang digunakan oleh lapisan normalisasi lapisan. image_size (`Union[int, list[int], tuple[int, int]]`, *opsional*, defaultnya `640`) : Ukuran (resolusi) dari setiap gambar. patch_size (`Union[int, list[int], tuple[int, int]]`, *opsional*, defaultnya `16`) : Ukuran (resolusi) dari setiap patch. num_channels (`int`, *opsional*, default `3`) : Jumlah saluran input. mlp_ratio (`int`, *opsional*, defaultnya `4`) : Rasio dimensi tersembunyi MLP terhadap dimensi embedding. layerscale_value (`float`, *opsional*, default 1.0) : Nilai awal untuk parameter LayerScale. drop_path_rate (`Union[float, int]`, *opsional*, defaultnya `0.0`) : Tingkat drop path untuk fusi patch. num_upscale_blocks (`int`, *opsional*, defaultnya 2) : Jumlah blok upsampling yang digunakan dalam decoder atau kepala segmentasi. attention_dropout (`Union[float, int]`, *opsional*, defaultnya `0.0`) : Rasio dropout untuk probabilitas perhatian. use_swiglu_ffn (`bool`, *opsional*, defaultnya `False`) : Apakah akan menggunakan jaringan saraf feedforward SwiGLU. num_blocks (`int`, *opsional*, default 4) : Jumlah blok fitur atau tahap dalam arsitektur. no_object_weight (`float`, *opsional*, default 0.1) : Bobot loss untuk kelas 'no object' dalam segmentasi panoptik/instans. class_weight (`float`, *opsional*, default 2.0) : Bobot loss untuk target klasifikasi. mask_weight (`float`, *opsional*, default 5.0) : Bobot loss untuk prediksi mask. dice_weight (`float`, *opsional*, defaultnya `5.0`) : Bobot relatif dari dice loss dalam loss segmentasi panoptik. train_num_points (`int`, *opsional*, default 12544) : Jumlah titik yang akan disampel untuk perhitungan mask loss selama pelatihan. oversample_ratio (`float`, *opsional*, default 3.0) : Rasio oversampling yang digunakan dalam point sampling untuk pelatihan mask. importance_sample_ratio (`float`, *opsional*, default 0.75) : Rasio titik yang akan disampel berdasarkan kepentingan selama pelatihan. num_queries (`int`, *opsional*, default 200) : Jumlah kueri objek dalam Transformer. num_register_tokens (`int`, *opsional*, default 4) : Jumlah token register yang dapat dipelajari (learnable) yang ditambahkan ke input transformer. Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari EomtModel. Kelas ini digunakan untuk membuat instans model Eomt berdasarkan argumen yang ditentukan, sehingga mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari [tue-mps/coco_panoptic_eomt_large_640](https://huggingface.co/tue-mps/coco_panoptic_eomt_large_640) 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 EomtConfig, EomtForUniversalSegmentation >>> # Initialize configuration >>> config = EomtConfig() >>> # Initialize model >>> model = EomtForUniversalSegmentation(config) >>> # Access config >>> config = model.config ``` ## EomtForUniversalSegmentation[[transformers.EomtForUniversalSegmentation]] #### transformers.EomtForUniversalSegmentation[[transformers.EomtForUniversalSegmentation]] ```python transformers.EomtForUniversalSegmentation(config: EomtConfig) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/eomt/modeling_eomt.py#L1016) **Parameter:** config ([EomtConfig](/docs/transformers/main/id/model_doc/eomt#transformers.EomtConfig)) : 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 EoMT dengan head di bagian atas untuk segmentasi instance/semantic/panoptic. 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.EomtForUniversalSegmentation.forward]] ```python forward(pixel_values: Tensor, mask_labels: list[torch.Tensor] | None = None, class_labels: list[torch.Tensor] | None = None, patch_offsets: list[torch.Tensor] | None = None, **kwargs: *) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/models/eomt/modeling_eomt.py#L1074) **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 [EomtImageProcessor](/docs/transformers/main/id/model_doc/eomt#transformers.EomtImageProcessor). Lihat [EomtImageProcessor.__call__()](/docs/transformers/main/id/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) untuk detailnya (`processor_class` menggunakan [EomtImageProcessor](/docs/transformers/main/id/model_doc/eomt#transformers.EomtImageProcessor) untuk memproses gambar). mask_labels (`list[torch.Tensor]`, *opsional*) : daftar label mask dengan bentuk `(num_labels, height, width)` untuk diberikan ke model class_labels (`list[torch.LongTensor]`, *opsional*) : daftar label kelas target dengan bentuk `(num_labels, height, width)` untuk diberikan ke model. Label ini mengidentifikasi label dari `mask_labels`, misalnya label dari `mask_labels[i][j]` jika `class_labels[i][j]`. patch_offsets (`list[torch.Tensor]`, *opsional*) : daftar tuple yang menunjukkan indeks gambar serta posisi awal dan akhir patch untuk segmentasi semantik. **Mengembalikan:** `EomtForUniversalSegmentationOutput` atau `tuple(torch.Tensor)` Sebuah `EomtForUniversalSegmentationOutput` atau tuple dari `torch.Tensor` (jika `return_dict=False` diteruskan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([EomtConfig](/docs/transformers/main/id/model_doc/eomt#transformers.EomtConfig)) dan input. Metode forward dari [EomtForUniversalSegmentation](/docs/transformers/main/id/model_doc/eomt#transformers.EomtForUniversalSegmentation) 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*) -- Loss yang dihitung, dikembalikan saat label ada. - **class_queries_logits** (`torch.Tensor`, *opsional*) -- Tensor dengan bentuk `(batch_size, num_queries, num_labels + 1)` yang merepresentasikan kelas yang diusulkan untuk setiap query. Perhatikan bahwa `+ 1` diperlukan karena kami mengikutsertakan kelas null. - **masks_queries_logits** (`torch.Tensor`, *opsional*) -- Tensor dengan bentuk `(batch_size, num_queries, height, width)` yang merepresentasikan mask yang diusulkan untuk setiap query. - **last_hidden_state** (`torch.Tensor` dengan bentuk `(batch_size, num_channels, height, width)`) -- State tersembunyi terakhir (peta fitur akhir) dari lapisan terakhir. - **hidden_states** (`tuple(torch.Tensor)`, *opsional*, dikembalikan saat `output_hidden_states=True` dilewatkan atau saat `config.output_hidden_states=True`) -- Tuple dari `torch.Tensor` (satu untuk output embeddings + satu untuk output setiap stage) dengan bentuk `(batch_size, sequence_length, hidden_size)`. Hidden-states dari semua lapisan model. - **attentions** (`tuple(tuple(torch.Tensor))`, *opsional*, dikembalikan ketika `output_attentions=True` dilewatkan atau ketika `config.output_attentions=True`) -- Tuple dari `tuple(torch.Tensor)` (satu untuk setiap layer) dengan bentuk `(batch_size, num_heads, sequence_length, sequence_length)`. Bobot Self dan Cross Attentions dari decoder transformer. - **patch_offsets** (`list[torch.Tensor]`, *opsional*) -- daftar tuple yang menunjukkan indeks gambar serta posisi awal dan akhir patch untuk segmentasi semantik.