# SegGPT

## Ikhtisar

Model SegGPT diusulkan dalam [SegGPT: Segmenting Everything In Context](https://huggingface.co/papers/2304.03284) oleh Xinlong Wang, Xiaosong Zhang, Yue Cao, Wen Wang, Chunhua Shen, Tiejun Huang. SegGPT menggunakan Transformer ber-decoder saja yang dapat menghasilkan mask segmentasi berdasarkan gambar input, gambar prompt, dan mask prompt yang bersesuaian. Model ini mencapai hasil one-shot yang luar biasa dengan 56,1 mIoU pada COCO-20 dan 85,6 mIoU pada FSS-1000.

Abstrak dari makalah tersebut adalah sebagai berikut:

*Kami memperkenalkan SegGPT, sebuah model generalis untuk melakukan segmentasi segala sesuatu dalam konteks. Kami menyatukan berbagai tugas segmentasi ke dalam kerangka pembelajaran in-context yang generalis, yang mengakomodasi berbagai jenis data segmentasi dengan mentransformasikannya ke dalam format gambar yang sama. Pelatihan SegGPT diformulasikan sebagai masalah pewarnaan in-context dengan pemetaan warna acak untuk setiap sampel data. Tujuannya adalah untuk menyelesaikan berbagai tugas sesuai dengan konteks, alih-alih bergantung pada warna tertentu. Setelah pelatihan, SegGPT dapat melakukan tugas segmentasi apa pun pada gambar atau video melalui inferensi in-context, seperti instance objek, stuff, bagian, kontur, dan teks. SegGPT dievaluasi pada berbagai tugas, termasuk segmentasi semantik few-shot, segmentasi objek video, segmentasi semantik, dan segmentasi panoptik. Hasil kami menunjukkan kemampuan yang kuat dalam melakukan segmentasi pada domain dan di luar domain*

Tips:

- Anda dapat menggunakan [SegGptImageProcessor](/docs/transformers/v5.23.0/id/model_doc/seggpt#transformers.SegGptImageProcessor) untuk menyiapkan input gambar, prompt, dan mask untuk model.
- Anda dapat menggunakan peta segmentasi atau citra RGB sebagai prompt mask. Jika menggunakan yang terakhir, pastikan untuk mengatur `do_convert_rgb=False` pada metode `preprocess`.
- Sangat disarankan untuk meneruskan `num_labels` saat menggunakan `segmentation_maps` (tanpa mempertimbangkan latar belakang) selama pra-pemrosesan dan pasca-pemrosesan dengan [SegGptImageProcessor](/docs/transformers/v5.23.0/id/model_doc/seggpt#transformers.SegGptImageProcessor) untuk kasus penggunaan Anda.
- Saat melakukan inferensi dengan [SegGptForImageSegmentation](/docs/transformers/v5.23.0/id/model_doc/seggpt#transformers.SegGptForImageSegmentation), jika `batch_size` Anda lebih dari 1, Anda dapat menggunakan feature ensemble di antara gambar-gambar Anda dengan meneruskan `feature_ensemble=True` ke metode forward.

Berikut cara menggunakan model untuk segmentasi semantik satu-shot:

```python
import torch
from datasets import load_dataset

from transformers import SegGptForImageSegmentation, SegGptImageProcessor

checkpoint = "BAAI/seggpt-vit-large"
image_processor = SegGptImageProcessor.from_pretrained(checkpoint)
model = SegGptForImageSegmentation.from_pretrained(checkpoint, device_map="auto")

dataset_id = "EduardoPacheco/FoodSeg103"
ds = load_dataset(dataset_id, split="train")
# Number of labels in FoodSeg103 (not including background)
num_labels = 103

image_input = ds[4]["image"]
ground_truth = ds[4]["label"]
image_prompt = ds[29]["image"]
mask_prompt = ds[29]["label"]

inputs = image_processor(
    images=image_input,
    prompt_images=image_prompt,
    segmentation_maps=mask_prompt,
    num_labels=num_labels,
    return_tensors="pt"
)

with torch.no_grad():
    outputs = model(**inputs)

target_sizes = [image_input.size[::-1]]
mask = image_processor.post_process_semantic_segmentation(outputs, target_sizes, num_labels=num_labels)[0]
```

Model ini disumbangkan oleh [EduardoPacheco](https://huggingface.co/EduardoPacheco). Kode aslinya dapat ditemukan [di sini](https://github.com/baaivision/Painter/tree/main).

## SegGptConfig[[transformers.SegGptConfig]]

#### transformers.SegGptConfig[[transformers.SegGptConfig]]

```python
transformers.SegGptConfig(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, ...] = (896, 448), patch_size: int | list[int] | tuple[int, int] = 16, num_channels: int = 3, qkv_bias: bool = True, mlp_dim: int | None = None, drop_path_rate: float | int = 0.1, pretrain_image_size: int | list[int] | tuple[int, int] = 224, decoder_hidden_size: int = 64, use_relative_position_embeddings: bool = True, merge_index: int = 2, intermediate_hidden_state_indices: list[int] | tuple[int, ...] = (5, 11, 17, 23), beta: float = 0.01)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/seggpt/configuration_seggpt.py#L24)

**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, ...]]`, *opsional*, defaultnya `(896, 448)`) : 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.

qkv_bias (`bool`, *opsional*, defaultnya `True`) : Apakah akan menambahkan bias ke queries, keys, dan values.

mlp_dim (`int`, *opsional*) : Dimensi dari lapisan MLP dalam encoder Transformer. Jika tidak diset, defaultnya adalah `hidden_size` * 4.

drop_path_rate (`Union[float, int]`, *opsional*, defaultnya `0.1`) : Tingkat drop path untuk fusi patch.

pretrain_image_size (`int`, *opsional*, defaultnya 224) : Ukuran pretrained dari embedding posisi absolut.

decoder_hidden_size (`int`, *opsional*, defaultnya `64`) : Dimensi dari representasi tersembunyi.

use_relative_position_embeddings (`bool`, *opsional*, defaultnya `True`) : Apakah akan menggunakan relative position embeddings di lapisan attention.

merge_index (`int`, *opsional*, defaultnya 2) : Indeks lapisan encoder untuk menggabungkan embedding.

intermediate_hidden_state_indices (`list[int]`, *opsional*, defaultnya `[5, 11, 17, 23]`) : Indeks dari lapisan encoder yang disimpan sebagai fitur untuk decoder.

beta (`float`, *opsional*, default 0.01) : Faktor regularisasi untuk SegGptLoss (smooth-l1 loss).

Ini adalah kelas konfigurasi untuk menyimpan konfigurasi dari SegGptModel. Kelas ini digunakan untuk membuat instans model Seggpt sesuai dengan argumen yang ditentukan, sehingga mendefinisikan arsitektur model. Membuat instans konfigurasi dengan nilai bawaan akan menghasilkan konfigurasi yang serupa dengan konfigurasi dari [BAAI/seggpt-vit-large](https://huggingface.co/BAAI/seggpt-vit-large)

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 SegGptConfig, SegGptModel

>>> # Initializing a SegGPT seggpt-vit-large style configuration
>>> configuration = SegGptConfig()

>>> # Initializing a model (with random weights) from the seggpt-vit-large style configuration
>>> model = SegGptModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config
```

## SegGptImageProcessor[[transformers.SegGptImageProcessor]]

#### transformers.SegGptImageProcessor[[transformers.SegGptImageProcessor]]

```python
transformers.SegGptImageProcessor(**kwargs: *<class 'transformers.models.seggpt.image_processing_seggpt.SegGptImageProcessorKwargs'>)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/seggpt/image_processing_seggpt.py#L74)

**Parameter:**

do_convert_rgb (`bool`, *kwargs*, *opsional*, defaultnya `True`) : Apakah akan mengonversi 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 `{'height' : 448, 'width': 448}`): Menjelaskan dimensi input maksimum ke model.

default_to_square (`bool`, *kwargs*, *opsional*, defaultnya `True`) : 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 `3`) : 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*) : 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.

num_labels (`int`, *kwargs*, *opsional*) : Jumlah kelas dalam tugas segmentasi (tidak termasuk latar belakang). Jika ditentukan, sebuah palet akan dibangun, dengan asumsi bahwa class_idx 0 adalah latar belakang, untuk memetakan prompt mask dari peta segmentasi biasa ke gambar RGB 3-channel. Jika tidak ditentukan, prompt mask akan diduplikasi di sepanjang dimensi channel ketika `do_convert_rgb` bernilai `True`.

Membangun pemroses gambar SegGptImageProcessor.

#### preprocess[[transformers.SegGptImageProcessor.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'], NoneType] = None, prompt_images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = None, prompt_masks: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = None, **kwargs: *<class 'transformers.models.seggpt.image_processing_seggpt.SegGptImageProcessorKwargs'>)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/seggpt/image_processing_seggpt.py#L135)

**Parameter:**

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

prompt_images (`ImageInput`, *opsional*) : Gambar prompt untuk dipreprocess. Mengharapkan satu gambar atau batch gambar dengan nilai piksel berkisar dari 0 hingga 255.

prompt_masks (`ImageInput`, *opsional*) : Prompt masks untuk dipreprocess. Dapat berupa peta segmentasi (tanpa channel) atau gambar RGB. Jika dalam format gambar RGB, `do_convert_rgb` harus diset ke `False`. Jika dalam format peta segmentasi, disarankan untuk menentukan `num_labels` guna membangun palet yang memetakan prompt mask dari satu channel ke RGB 3-channel. Jika `num_labels` tidak ditentukan, prompt mask akan diduplikasi di sepanjang dimensi channel.

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.

num_labels (`int`, *kwargs*, *opsional*) : Jumlah kelas dalam tugas segmentasi (tidak termasuk latar belakang). Jika ditentukan, sebuah palet akan dibangun, dengan asumsi bahwa class_idx 0 adalah latar belakang, untuk memetakan prompt mask dari peta segmentasi biasa ke gambar RGB 3-channel. Jika tidak ditentukan, prompt mask akan diduplikasi di sepanjang dimensi channel ketika `do_convert_rgb` bernilai `True`.

**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.SegGptImageProcessor.post_process_semantic_segmentation]]

```python
post_process_semantic_segmentation(outputs, target_sizes: list[tuple[int, int]] | None = None, num_labels: int | None = None, return_segmentation_scores: bool = False)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/seggpt/image_processing_seggpt.py#L256)

**Parameter:**

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

target_sizes (`list[tuple[int, int]]`, *opsional*) : Daftar dengan panjang `batch_size`, di mana setiap item sesuai dengan ukuran akhir yang diminta `(height, width)` untuk setiap prediksi. Jika dibiarkan sebagai `None`, prediksi tidak akan di-resize.

num_labels (`int`, *opsional*) : Jumlah kelas dalam tugas segmentasi (tidak termasuk latar belakang). Jika ditentukan, palet akan dibangun untuk memetakan kembali mask prediksi dari nilai RGB ke indeks kelas. Harus sesuai dengan nilai yang digunakan selama pra-pemrosesan.

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_labels+1, height, width)` dari jarak kuadrat L2 negatif ke setiap warna palet, atau `None` ketika `num_labels` tidak disediakan).

**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_labels+1, height, width)`). Dalam kedua kasus, `(height, width)` sesuai dengan ukuran target (jika `target_sizes` ditentukan).

Mengonversi output dari `SegGptImageSegmentationOutput` menjadi peta segmentasi. Hanya mendukung PyTorch.

## SegGptImageProcessorPil[[transformers.SegGptImageProcessorPil]]

#### transformers.SegGptImageProcessorPil[[transformers.SegGptImageProcessorPil]]

```python
transformers.SegGptImageProcessorPil(**kwargs: *<class 'transformers.models.seggpt.image_processing_pil_seggpt.SegGptImageProcessorKwargs'>)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/seggpt/image_processing_pil_seggpt.py#L75)

**Parameter:**

do_convert_rgb (`bool`, *kwargs*, *opsional*, defaultnya `True`) : Apakah akan mengonversi 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 `{'height' : 448, 'width': 448}`): Menjelaskan dimensi input maksimum ke model.

default_to_square (`bool`, *kwargs*, *opsional*, defaultnya `True`) : 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 `3`) : 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*) : 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.

num_labels (`int`, *kwargs*, *opsional*) : Jumlah kelas dalam tugas segmentasi (tidak termasuk latar belakang). Jika ditentukan, sebuah palet akan dibangun, dengan asumsi bahwa class_idx 0 adalah latar belakang, untuk memetakan prompt mask dari peta segmentasi biasa ke gambar RGB 3-channel. Jika tidak ditentukan, prompt mask akan diduplikasi di sepanjang dimensi channel ketika `do_convert_rgb` bernilai `True`.

Membangun pemroses gambar SegGptImageProcessor.

#### preprocess[[transformers.SegGptImageProcessorPil.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'], NoneType] = None, prompt_images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = None, prompt_masks: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = None, **kwargs: *<class 'transformers.models.seggpt.image_processing_pil_seggpt.SegGptImageProcessorKwargs'>)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/seggpt/image_processing_pil_seggpt.py#L136)

**Parameter:**

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

prompt_images (`ImageInput`, *opsional*) : Gambar prompt untuk dipreprocess. Mengharapkan satu gambar atau batch gambar dengan nilai piksel berkisar dari 0 hingga 255.

prompt_masks (`ImageInput`, *opsional*) : Prompt masks untuk dipreprocess. Dapat berupa peta segmentasi (tanpa channel) atau gambar RGB. Jika dalam format gambar RGB, `do_convert_rgb` harus diset ke `False`. Jika dalam format peta segmentasi, disarankan untuk menentukan `num_labels` guna membangun palet yang memetakan prompt mask dari satu channel ke RGB 3-channel. Jika `num_labels` tidak ditentukan, prompt mask akan diduplikasi di sepanjang dimensi channel.

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.

num_labels (`int`, *kwargs*, *opsional*) : Jumlah kelas dalam tugas segmentasi (tidak termasuk latar belakang). Jika ditentukan, sebuah palet akan dibangun, dengan asumsi bahwa class_idx 0 adalah latar belakang, untuk memetakan prompt mask dari peta segmentasi biasa ke gambar RGB 3-channel. Jika tidak ditentukan, prompt mask akan diduplikasi di sepanjang dimensi channel ketika `do_convert_rgb` bernilai `True`.

**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.SegGptImageProcessorPil.post_process_semantic_segmentation]]

```python
post_process_semantic_segmentation(outputs, target_sizes: list[tuple[int, int]] | None = None, num_labels: int | None = None, return_segmentation_scores: bool = False)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/seggpt/image_processing_pil_seggpt.py#L238)

**Parameter:**

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

target_sizes (`list[tuple[int, int]]`, *opsional*) : Daftar dengan panjang `batch_size`, di mana setiap item sesuai dengan ukuran akhir yang diminta `(height, width)` untuk setiap prediksi. Jika dibiarkan sebagai `None`, prediksi tidak akan di-resize.

num_labels (`int`, *opsional*) : Jumlah kelas dalam tugas segmentasi (tidak termasuk latar belakang). Jika ditentukan, palet akan dibangun untuk memetakan kembali mask prediksi dari nilai RGB ke indeks kelas. Harus sesuai dengan nilai yang digunakan selama pra-pemrosesan.

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_labels+1, height, width)` dari jarak kuadrat L2 negatif ke setiap warna palet, atau `None` ketika `num_labels` tidak disediakan).

**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_labels+1, height, width)`). Dalam kedua kasus, `(height, width)` sesuai dengan ukuran target (jika `target_sizes` ditentukan).

Mengonversi output dari `SegGptImageSegmentationOutput` menjadi peta segmentasi. Hanya mendukung PyTorch.

## SegGptModel[[transformers.SegGptModel]]

#### transformers.SegGptModel[[transformers.SegGptModel]]

```python
transformers.SegGptModel(config: SegGptConfig)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/seggpt/modeling_seggpt.py#L613)

**Parameter:**

config ([SegGptConfig](/docs/transformers/v5.23.0/id/model_doc/seggpt#transformers.SegGptConfig)) : 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 Seggpt polos 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.SegGptModel.forward]]

```python
forward(pixel_values: Tensor, prompt_pixel_values: Tensor, prompt_masks: Tensor, bool_masked_pos: typing.Optional[torch.BoolTensor] = None, feature_ensemble: bool | None = None, embedding_type: str | None = None, labels: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/seggpt/modeling_seggpt.py#L627)

**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 [SegGptImageProcessor](/docs/transformers/v5.23.0/id/model_doc/seggpt#transformers.SegGptImageProcessor). Lihat [SegGptImageProcessor.__call__()](/docs/transformers/v5.23.0/id/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) untuk detailnya (`processor_class` menggunakan [SegGptImageProcessor](/docs/transformers/v5.23.0/id/model_doc/seggpt#transformers.SegGptImageProcessor) untuk memproses gambar).

prompt_pixel_values (`torch.Tensor` dengan bentuk `(batch_size, num_channels, height, width)`) : Nilai piksel prompt. Nilai piksel prompt dapat diperoleh menggunakan [AutoImageProcessor](/docs/transformers/v5.23.0/id/model_doc/auto#transformers.AutoImageProcessor). Lihat [SegGptImageProcessor.__call__()](/docs/transformers/v5.23.0/id/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) untuk detailnya.

prompt_masks (`torch.Tensor` dengan bentuk `(batch_size, num_channels, height, width)`) : Prompt mask. Prompt mask dapat diperoleh menggunakan [AutoImageProcessor](/docs/transformers/v5.23.0/id/model_doc/auto#transformers.AutoImageProcessor). Lihat [SegGptImageProcessor.__call__()](/docs/transformers/v5.23.0/id/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) untuk detailnya.

bool_masked_pos (`torch.BoolTensor` dengan bentuk `(batch_size, num_patches)`, *opsional*) : Posisi yang dimask secara boolean. Menunjukkan patch mana yang dimask (1) dan mana yang tidak (0).

feature_ensemble (`bool`, *opsional*) : Boolean yang menunjukkan apakah akan menggunakan feature ensemble atau tidak. Jika `True`, model akan menggunakan feature ensemble jika kami memiliki setidaknya dua prompt. Jika `False`, model tidak akan menggunakan feature ensemble. Argumen ini perlu dipertimbangkan saat melakukan few-shot inference pada gambar input, yaitu lebih dari satu prompt untuk gambar yang sama.

embedding_type (`str`, *opsional*) : Jenis embedding. Menunjukkan apakah prompt adalah embedding semantik atau instance. Bisa berupa instance atau semantic.

labels (`torch.Tensor` of shape `(batch_size, num_channels, height, width)`, `optional`) : Mask ground truth untuk gambar input.

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

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

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

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

A `SegGptEncoderOutput` atau tuple dari `torch.Tensor` (jika `return_dict=False` dilewatkan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([SegGptConfig](/docs/transformers/v5.23.0/id/model_doc/seggpt#transformers.SegGptConfig)) dan input.

Metode forward dari [SegGptModel](/docs/transformers/v5.23.0/id/model_doc/seggpt#transformers.SegGptModel) 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.

- **last_hidden_state** (`torch.Tensor` dengan bentuk `(batch_size, patch_height, patch_width, hidden_size)`) -- Urutan hidden-states pada keluaran dari lapisan terakhir model.
- **hidden_states** (`tuple[torch.Tensor]`, `optional`, dikembalikan saat `config.output_hidden_states=True`) -- Tuple dari `torch.Tensor` (satu untuk output embeddings + satu untuk output setiap layer) dengan bentuk `(batch_size, patch_height, patch_width, hidden_size)`.
- **attentions** (`tuple[torch.Tensor]`, `optional`, dikembalikan saat `config.output_attentions=True`) -- Tuple dari *torch.Tensor* (satu untuk setiap layer) dengan bentuk `(batch_size, num_heads, seq_len, seq_len)`.
- **intermediate_hidden_states** (`tuple[torch.Tensor]`, *opsional*, dikembalikan saat `config.intermediate_hidden_state_indices` diset) -- Tuple dari `torch.Tensor` dengan bentuk `(batch_size, patch_height, patch_width, hidden_size)`. Setiap elemen dalam Tuple tersebut sesuai dengan output dari layer yang ditentukan dalam `config.intermediate_hidden_state_indices`. Selain itu, setiap fitur melewati LayerNorm.

Contoh:

```python
>>> from transformers import SegGptImageProcessor, SegGptModel
>>> from PIL import Image
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO

>>> image_input_url = "https://raw.githubusercontent.com/baaivision/Painter/main/SegGPT/SegGPT_inference/examples/hmbb_2.jpg"
>>> image_prompt_url = "https://raw.githubusercontent.com/baaivision/Painter/main/SegGPT/SegGPT_inference/examples/hmbb_1.jpg"
>>> mask_prompt_url = "https://raw.githubusercontent.com/baaivision/Painter/main/SegGPT/SegGPT_inference/examples/hmbb_1_target.png"

>>> with httpx.stream("GET", image_input_url) as response:
...     image_input = Image.open(BytesIO(response.read()))

>>> with httpx.stream("GET", image_prompt_url) as response:
...     image_prompt = Image.open(BytesIO(response.read()))

>>> with httpx.stream("GET", mask_prompt_url) as response:
...     mask_prompt = Image.open(BytesIO(response.read())).convert("L")

>>> checkpoint = "BAAI/seggpt-vit-large"
>>> model = SegGptModel.from_pretrained(checkpoint)
>>> image_processor = SegGptImageProcessor.from_pretrained(checkpoint)

>>> inputs = image_processor(images=image_input, prompt_images=image_prompt, prompt_masks=mask_prompt, return_tensors="pt")

>>> outputs = model(**inputs)
>>> list(outputs.last_hidden_state.shape)
[1, 56, 28, 1024]
```

## SegGptForImageSegmentation[[transformers.SegGptForImageSegmentation]]

#### transformers.SegGptForImageSegmentation[[transformers.SegGptForImageSegmentation]]

```python
transformers.SegGptForImageSegmentation(config: SegGptConfig)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/seggpt/modeling_seggpt.py#L819)

**Parameter:**

config ([SegGptConfig](/docs/transformers/v5.23.0/id/model_doc/seggpt#transformers.SegGptConfig)) : 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 SegGpt dengan decoder di atasnya untuk segmentasi gambar satu-shot.

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.SegGptForImageSegmentation.forward]]

```python
forward(pixel_values: Tensor, prompt_pixel_values: Tensor, prompt_masks: Tensor, bool_masked_pos: typing.Optional[torch.BoolTensor] = None, feature_ensemble: bool | None = None, embedding_type: str | None = None, labels: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Sumber](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/seggpt/modeling_seggpt.py#L830)

**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 [SegGptImageProcessor](/docs/transformers/v5.23.0/id/model_doc/seggpt#transformers.SegGptImageProcessor). Lihat [SegGptImageProcessor.__call__()](/docs/transformers/v5.23.0/id/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) untuk detailnya (`processor_class` menggunakan [SegGptImageProcessor](/docs/transformers/v5.23.0/id/model_doc/seggpt#transformers.SegGptImageProcessor) untuk memproses gambar).

prompt_pixel_values (`torch.Tensor` dengan bentuk `(batch_size, num_channels, height, width)`) : Nilai piksel prompt. Nilai piksel prompt dapat diperoleh menggunakan [AutoImageProcessor](/docs/transformers/v5.23.0/id/model_doc/auto#transformers.AutoImageProcessor). Lihat [SegGptImageProcessor.__call__()](/docs/transformers/v5.23.0/id/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) untuk detailnya.

prompt_masks (`torch.Tensor` dengan bentuk `(batch_size, num_channels, height, width)`) : Prompt mask. Prompt mask dapat diperoleh menggunakan [AutoImageProcessor](/docs/transformers/v5.23.0/id/model_doc/auto#transformers.AutoImageProcessor). Lihat [SegGptImageProcessor.__call__()](/docs/transformers/v5.23.0/id/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) untuk detailnya.

bool_masked_pos (`torch.BoolTensor` dengan bentuk `(batch_size, num_patches)`, *opsional*) : Posisi yang dimask secara boolean. Menunjukkan patch mana yang dimask (1) dan mana yang tidak (0).

feature_ensemble (`bool`, *opsional*) : Boolean yang menunjukkan apakah akan menggunakan feature ensemble atau tidak. Jika `True`, model akan menggunakan feature ensemble jika kami memiliki setidaknya dua prompt. Jika `False`, model tidak akan menggunakan feature ensemble. Argumen ini perlu dipertimbangkan saat melakukan few-shot inference pada gambar input, yaitu lebih dari satu prompt untuk gambar yang sama.

embedding_type (`str`, *opsional*) : Jenis embedding. Menunjukkan apakah prompt adalah embedding semantik atau instance. Bisa berupa instance atau semantic.

labels (`torch.Tensor` of shape `(batch_size, num_channels, height, width)`, `optional`) : Mask ground truth untuk gambar input.

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

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

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

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

A `SegGptImageSegmentationOutput` atau tuple dari `torch.Tensor` (jika `return_dict=False` diberikan atau ketika `config.return_dict=False`) yang terdiri dari berbagai elemen tergantung pada konfigurasi ([SegGptConfig](/docs/transformers/v5.23.0/id/model_doc/seggpt#transformers.SegGptConfig)) dan input.

Metode forward dari [SegGptForImageSegmentation](/docs/transformers/v5.23.0/id/model_doc/seggpt#transformers.SegGptForImageSegmentation) 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*, dikembalikan saat `labels` disediakan) -- Nilai loss.
- **pred_masks** (`torch.Tensor` dengan bentuk `(batch_size, num_channels, height, width)`) -- Mask yang diprediksi.
- **hidden_states** (`tuple[torch.Tensor]`, `optional`, dikembalikan saat `config.output_hidden_states=True`) -- Tuple dari `torch.Tensor` (satu untuk output embeddings + satu untuk output setiap layer) dengan bentuk `(batch_size, patch_height, patch_width, hidden_size)`.
- **attentions** (`tuple[torch.Tensor]`, `optional`, dikembalikan saat `config.output_attentions=True`) -- Tuple dari `torch.Tensor` (satu untuk setiap layer) dengan bentuk `(batch_size, num_heads, seq_len, seq_len)`.

Contoh:

```python
>>> from transformers import SegGptImageProcessor, SegGptForImageSegmentation
>>> from PIL import Image
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO

>>> image_input_url = "https://raw.githubusercontent.com/baaivision/Painter/main/SegGPT/SegGPT_inference/examples/hmbb_2.jpg"
>>> image_prompt_url = "https://raw.githubusercontent.com/baaivision/Painter/main/SegGPT/SegGPT_inference/examples/hmbb_1.jpg"
>>> mask_prompt_url = "https://raw.githubusercontent.com/baaivision/Painter/main/SegGPT/SegGPT_inference/examples/hmbb_1_target.png"

>>> with httpx.stream("GET", image_input_url) as response:
...     image_input = Image.open(BytesIO(response.read()))

>>> with httpx.stream("GET", image_prompt_url) as response:
...     image_prompt = Image.open(BytesIO(response.read()))

>>> with httpx.stream("GET", mask_prompt_url) as response:
...     mask_prompt = Image.open(BytesIO(response.read())).convert("L")

>>> checkpoint = "BAAI/seggpt-vit-large"
>>> model = SegGptForImageSegmentation.from_pretrained(checkpoint)
>>> image_processor = SegGptImageProcessor.from_pretrained(checkpoint)

>>> inputs = image_processor(images=image_input, prompt_images=image_prompt, prompt_masks=mask_prompt, return_tensors="pt")
>>> outputs = model(**inputs)
>>> result = image_processor.post_process_semantic_segmentation(outputs, target_sizes=[(image_input.height, image_input.width)])[0]
>>> print(list(result.shape))
[170, 297]
```

