# EoMT

## 개요

[The Encoder-only Mask Transformer](https://www.tue-mps.org/eomt)(EoMT) 모델은 Tommie Kerssies, Niccolò Cavagnero, Alexander Hermans, Narges Norouzi, Giuseppe Averta, Bastian Leibe, Gijs Dubbelman, Daan de Geus가 발표한 CVPR 2025 하이라이트 논문 *[Your ViT is Secretly an Image Segmentation Model](https://huggingface.co/papers/2503.19108)*에서 소개되었습니다. EoMT는 Vision Transformers가 작업 전용 구성 요소 없이도 효율적으로 이미지 분할을 수행할 수 있음을 보여줍니다.

해당 논문의 초록은 다음과 같습니다:

*Vision Transformer(ViT)는 다양한 컴퓨터 비전 작업에서 뛰어난 성능과 확장성을 입증했습니다. 단일 스케일 ViT를 이미지 분할에 적용하기 위해 기존 방법들은 컨볼루션 어댑터를 사용해 다중 스케일 특징을 생성하고, 픽셀 디코더로 이러한 특징을 융합하며, 융합된 특징을 이용해 예측을 수행하는 Transformer 디코더를 채택합니다. 본 논문에서는 충분히 큰 모델과 광범위한 사전 학습이 주어지면, 이러한 작업별 구성 요소가 도입하는 유도 편향(inductive bias)을 ViT 자체로 학습할 수 있음을 보여줍니다. 이러한 발견을 바탕으로, 평범한 ViT 아키텍처를 재사용하여 이미지 분할을 수행하는 Encoder-only Mask Transformer(EoMT)를 소개합니다. 대규모 모델과 사전 학습을 통해 EoMT는 작업별 구성 요소를 사용하는 최첨단 모델과 유사한 분할 정확도를 달성합니다. 동시에 EoMT는 아키텍처의 단순성 덕분에 이러한 방법들보다 현저히 빠르며, 예를 들어 ViT-L을 사용할 경우 최대 4배까지 빠릅니다. 다양한 모델 크기에서 EoMT는 분할 정확도와 예측 속도 사이의 최적의 균형을 보여주며, 이는 아키텍처의 복잡성을 추가하는 것보다 ViT 자체를 확장하는 데 컴퓨트 리소스를 사용하는 것이 더 효과적임을 시사합니다.*

이 모델은 [Yaswanth Gali](https://huggingface.co/yaswanthgali)님이 기여했습니다. 원본 코드는 [여기](https://github.com/tue-mps/eomt)에서 찾을 수 있습니다.

## 아키텍처 정보

`EoMT` 모델은 **register tokens**를 갖춘 DINOv2 사전 학습 Vision Transformer를 백본으로 사용합니다. EoMT는 인코더에만 의존하여 세그멘테이션 파이프라인을 단순화하며, 기존 접근 방식에서 일반적으로 사용되던 작업별 디코더의 필요성을 제거합니다.

구조적으로 EoMT는 소수의 **학습된 쿼리**와 경량 **마스크 예측 모듈**을 도입합니다. 이러한 쿼리는 최종 인코더 블록에 주입되어 이미지 패치와 객체 쿼리 간의 **공동 주의**를 가능하게 합니다. 학습 단계에서는 **마스크된 주의**를 적용하여 각 쿼리가 해당 영역에 집중하도록 제한하며, 이는 크로스 어텐션을 효과적으로 모방합니다. 이러한 제약은 **마스크 어닐링 전략**을 통해 점진적으로 완화되어, 분할 성능을 저해하지 않으면서 **디코더 없이 효율적인 추론**이 가능합니다.

  <img src="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/model_doc/eomt_architecture.png"
       alt="drawing" width="500"/>

이 모델은 통합 아키텍처와 작업별 후처리(post-processing)를 사용하여 의미론적, 인스턴스, 팬옵틱 분할을 지원합니다.

## 사용 예시

Hugging Face의 EoMT 구현을 사용하여 사전 학습된 모델로 추론을 수행합니다.

### 의미 분할

EoMT 모델은 슬라이딩 윈도우 추론을 사용하여 의미론적 분할을 수행합니다. 입력 이미지는 짧은 변이 대상 입력 크기와 일치하도록 리사이즈된 후, 겹치는 크롭으로 분할됩니다. 각 크롭은 모델에 전달됩니다. 추론이 완료되면, 각 크롭에서 생성된 예측 로짓을 다시 이어 붙이고 원래 이미지 크기로 다시 스케일링하여 최종 분할 마스크를 얻습니다.

> **참고:**   **semantic segmentation**에 커스텀 target size를 사용하려면 다음 형식으로 지정하세요: `{"shortest_edge": 512}` 여기서 `longest_edge`가 제공되지 않는다는 점에 유의하세요. 이는 의도된 것입니다. semantic segmentation에서는 이미지가 일반적으로 **가장 짧은 변이 target size보다 크거나 같도록** scale되므로 longest_edge는 필요하지 않습니다.

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

### 인스턴스 분할

EoMT 모델은 패딩된 추론을 사용하여 인스턴스 분할을 수행합니다. 입력 이미지는 긴 변이 대상 입력 크기와 일치하도록 리사이즈되고, 짧은 변은 제로 패딩을 적용하여 정사각형을 형성합니다. 생성된 마스크와 클래스 로짓은 후처리( Mask2Former에서 수정)를 통해 통합되어 통합된 인스턴스 분할 맵을 생성하며, 세그먼트 ID, 클래스 라벨, 신뢰도 점수와 같은 세그먼트 메타데이터도 함께 제공됩니다.

> **참고:**   커스텀 대상 크기를 사용하려면, 크기를 다음 형식의 사전으로 지정하세요: `{"shortest_edge": 512, "longest_edge": 512}` instance segmentation과 panoptic segmentation 모두에서 입력 이미지는 이 대상 크기로 **확대/축소되고 패딩됩니다**.

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

### 팬옵틱 세그멘테이션

EoMT 모델은 인스턴스 분할과 동일한 패딩된 추론 전략을 사용하여 팬옵틱 분할을 수행합니다. 패딩 및 정규화 이후, 모델은 thing(인스턴스) 클래스와 stuff(비정형 영역) 클래스를 모두 예측합니다. 생성된 마스크와 클래스 로짓은 후처리(Mask2Former에서 수정 적용)를 통해 통합된 팬옵틱 분할 맵을 생성하며, 세그먼트 ID, 클래스 라벨, 신뢰도 점수와 같은 세그먼트 메타데이터도 함께 생성됩니다.

```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: *<class 'transformers.models.eomt.image_processing_eomt.EomtImageProcessorKwargs'>)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/eomt/image_processing_eomt.py#L214)

**매개변수:**

do_convert_rgb (`bool`, *kwargs*, *선택*) : 이미지를 RGB로 변환할지 여부.

do_resize (`bool`, *kwargs*, *선택 사항*, 기본값 `True`) : 이미지를 리사이즈할지 여부.

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, 기본값 `{'shortest_edge' : 640, 'longest_edge': 640}`): 모델에 전달되는 최대 입력 차원을 설명합니다.

default_to_square (`bool`, *kwargs*, *선택 사항*, 기본값 `False`) : size가 int인 경우 리사이즈 시 정사각형 이미지로 설정할지 여부.

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : `center_crop`를 적용한 후의 출력 이미지 크기.

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, 기본값 `2`) : 이미지를 리사이즈할 때 사용할 리샘플링 필터입니다. 이는 `PILImageResampling` enum 중 하나일 수 있습니다. `do_resize`가 `True`로 설정된 경우에만 효과가 있습니다.

do_rescale (`bool`, *kwargs*, *선택 사항*, 기본값 `True`) : 이미지를 다시 스케일링할지 여부.

rescale_factor (`float`, *kwargs*, *선택 사항*, 기본값 `0.00392156862745098`) : `do_rescale`이 `True`로 설정된 경우 이미지를 재조정하는 데 사용되는 재조정 계수입니다.

do_normalize (`bool`, *kwargs*, *선택 사항*, 기본값 `True`) : 이미지를 정규화할지 여부.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *선택 사항*, 기본값은 `[0.485, 0.456, 0.406]`) : 정규화에 사용할 이미지 평균입니다. `do_normalize`가 `True`로 설정된 경우에만 효과가 있습니다.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *선택 사항*, 기본값은 `[0.229, 0.224, 0.225]`) : 정규화에 사용할 이미지 표준 편차입니다. `do_normalize`가 `True`로 설정된 경우에만 효과가 있습니다.

do_pad (`bool`, *kwargs*, *선택 사항*, 기본값 `False`) : 이미지를 패딩할지 여부입니다. 패딩은 배치 내 가장 큰 크기로 수행하거나 이미지마다 고정된 정사각형 크기로 수행합니다. 정확한 패딩 전략은 모델에 따라 달라집니다.

pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : 이미지를 패딩할 `{"height": int, "width" int}` 크기를 지정합니다. 전처리용으로 제공된 모든 이미지 크기보다 커야 합니다. `pad_size`가 제공되지 않으면, 이미지는 배치 내 가장 큰 높이와 너비로 패딩됩니다. `do_pad=True.`일 때만 적용됩니다.

do_center_crop (`bool`, *kwargs*, *선택*) : 이미지를 중앙 크롭할지 여부.

data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *선택*) : `ChannelDimension.FIRST`만 지원됩니다. 느린 프로세서와의 호환성을 위해 추가되었습니다.

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *선택*) : 입력 이미지의 채널 차원 형식입니다. 설정하지 않으면 입력 이미지에서 채널 차원 형식을 추론합니다. 다음 중 하나일 수 있습니다: - `"channels_first"` 또는 `ChannelDimension.FIRST`: (num_channels, height, width) 형식의 이미지. - `"channels_last"` 또는 `ChannelDimension.LAST`: (height, width, num_channels) 형식의 이미지. - `"none"` 또는 `ChannelDimension.NONE`: (height, width) 형식의 이미지.

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : 비디오를 처리할 장치입니다. 설정되지 않은 경우, 입력 비디오에서 장치를 추론합니다.

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : `'pt'`로 설정된 경우 스택된 텐서를 반환하고, 그렇지 않으면 텐서 목록을 반환합니다.

disable_grouping (`bool`, *kwargs*, *선택*) : 이미지의 크기에 따른 그룹화를 비활성화하여 이미지를 배치 대신 개별적으로 처리할지 여부입니다. None인 경우, 이미지가 CPU에 있으면 True, 그렇지 않으면 False로 설정됩니다. 이 선택은 https://github.com/huggingface/transformers/pull/38157에 자세히 설명된 경험적 관찰에 기반합니다.

image_seq_length (`int`, *kwargs*, *선택*) : 입력의 각 이미지에 사용할 이미지 토큰의 수입니다. 하위 호환성을 위해 추가되었지만, 향후 모델에서는 프로세서 속성으로 설정해야 합니다.

do_split_image (`bool`, *kwargs*, *선택 사항*, 기본값은 `self.do_split_image`) : 의미론적 분할을 위해 입력 이미지를 겹치는 패치로 분할할지 여부입니다. `True`로 설정하면, 입력 이미지는 패치 간 겹침이 있는 `size["shortest_edge"]` 크기의 패치로 분할됩니다. 그렇지 않으면, 입력 이미지는 대상 크기로 패딩됩니다.

ignore_index (`int`, *kwargs*, *선택 사항*, 기본값은 `self.ignore_index`) : 세그멘테이션 맵의 배경 픽셀에 할당할 라벨입니다. 값이 제공되면, 세그멘테이션 맵에서 0(배경)으로 표시된 픽셀은 `ignore_index`로 대체됩니다.

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: *<class 'transformers.models.eomt.image_processing_eomt.EomtImageProcessorKwargs'>)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/eomt/image_processing_eomt.py#L273)

**매개변수:**

images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`) : 전처리할 이미지. 픽셀 값이 0에서 255 범위로 이루어진 단일 이미지 또는 배치 이미지를 기대합니다. 픽셀 값이 0에서 1 범위로 이루어진 이미지를 전달하는 경우 `do_rescale=False`로 설정하세요.

segmentation_maps (`ImageInput`, *선택 사항*) : 해당 이미지에 대해 전처리할 분할 맵입니다.

instance_id_to_semantic_id (`list[dict[int, int]]` 또는 `dict[int, int]`, *선택 사항*) : 객체 인스턴스 ID와 클래스 ID 사이의 매핑입니다.

do_convert_rgb (`bool`, *kwargs*, *선택*) : 이미지를 RGB로 변환할지 여부.

do_resize (`bool`, *kwargs*, *선택*) : 이미지를 리사이즈할지 여부.

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : 모델의 최대 입력 차원을 설명합니다.

default_to_square (`bool`, *kwargs*, *선택*) : size가 int인 경우 리사이즈 시 정사각형 이미지로 기본 설정할지 여부.

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : `center_crop`를 적용한 후의 출력 이미지 크기.

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*) : 이미지를 리사이즈할 때 사용할 리샘플링 필터입니다. `PILImageResampling` enum 중 하나를 사용할 수 있습니다. `do_resize`가 `True`로 설정된 경우에만 효과가 있습니다.

do_rescale (`bool`, *kwargs*, *선택*) : 이미지를 다시 스케일링할지 여부.

rescale_factor (`float`, *kwargs*, *선택*) : `do_rescale`가 `True`로 설정된 경우 이미지를 재조정하는 데 사용되는 재조정 계수입니다.

do_normalize (`bool`, *kwargs*, *선택*) : 이미지를 정규화할지 여부.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *선택*) : 정규화에 사용할 이미지 평균값. `do_normalize`이 `True`로 설정된 경우에만 효과가 있습니다.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *선택*) : 정규화에 사용할 이미지 표준 편차. `do_normalize`가 `True`로 설정된 경우에만 효과가 있습니다.

do_pad (`bool`, *kwargs*, *선택*) : 이미지를 패딩할지 여부입니다. 패딩은 배치 내 가장 큰 크기로 수행하거나, 이미지마다 고정된 정사각형 크기로 수행합니다. 정확한 패딩 전략은 모델에 따라 달라집니다.

pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : 이미지를 패딩할 `{"height": int, "width" int}` 크기를 지정합니다. 전처리용으로 제공된 모든 이미지 크기보다 커야 합니다. `pad_size`가 제공되지 않으면, 이미지는 배치 내 가장 큰 높이와 너비로 패딩됩니다. `do_pad=True.`일 때만 적용됩니다.

do_center_crop (`bool`, *kwargs*, *선택*) : 이미지를 중앙 크롭할지 여부.

data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *선택*) : `ChannelDimension.FIRST`만 지원됩니다. 느린 프로세서와의 호환성을 위해 추가되었습니다.

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *선택*) : 입력 이미지의 채널 차원 형식입니다. 설정하지 않으면 입력 이미지에서 채널 차원 형식을 추론합니다. 다음 중 하나일 수 있습니다: - `"channels_first"` 또는 `ChannelDimension.FIRST`: (num_channels, height, width) 형식의 이미지. - `"channels_last"` 또는 `ChannelDimension.LAST`: (height, width, num_channels) 형식의 이미지. - `"none"` 또는 `ChannelDimension.NONE`: (height, width) 형식의 이미지.

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : 비디오를 처리할 장치입니다. 설정되지 않은 경우, 입력 비디오에서 장치를 추론합니다.

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : `'pt'`로 설정된 경우 스택된 텐서를 반환하고, 그렇지 않으면 텐서 목록을 반환합니다.

disable_grouping (`bool`, *kwargs*, *선택*) : 이미지의 크기에 따른 그룹화를 비활성화하여 이미지를 배치 대신 개별적으로 처리할지 여부입니다. None인 경우, 이미지가 CPU에 있으면 True, 그렇지 않으면 False로 설정됩니다. 이 선택은 https://github.com/huggingface/transformers/pull/38157에 자세히 설명된 경험적 관찰에 기반합니다.

image_seq_length (`int`, *kwargs*, *선택*) : 입력의 각 이미지에 사용할 이미지 토큰의 수입니다. 하위 호환성을 위해 추가되었지만, 향후 모델에서는 프로세서 속성으로 설정해야 합니다.

do_split_image (`bool`, *kwargs*, *선택 사항*, 기본값은 `self.do_split_image`) : 의미론적 분할을 위해 입력 이미지를 겹치는 패치로 분할할지 여부입니다. `True`로 설정하면, 입력 이미지는 패치 간 겹침이 있는 `size["shortest_edge"]` 크기의 패치로 분할됩니다. 그렇지 않으면, 입력 이미지는 대상 크기로 패딩됩니다.

ignore_index (`int`, *kwargs*, *선택 사항*, 기본값은 `self.ignore_index`) : 세그멘테이션 맵의 배경 픽셀에 할당할 라벨입니다. 값이 제공되면, 세그멘테이션 맵에서 0(배경)으로 표시된 픽셀은 `ignore_index`로 대체됩니다.

**반환값:** `~image_processing_base.BatchFeature`

- **data** (`dict`) -- __call__ 메서드가 반환하는 리스트/배열/텐서 딕셔너리('pixel_values' 등).
- **tensor_type** (`Union[None, str, TensorType]`, *선택 사항*) -- 초기화 시 PyTorch/Numpy 텐서에서 정수 목록을 변환하려면 여기에 tensor_type을 지정할 수 있습니다.

#### post_process_semantic_segmentation[[transformers.EomtImageProcessor.post_process_semantic_segmentation]]

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

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/eomt/image_processing_eomt.py#L502)

**매개변수:**

outputs ([EomtForUniversalSegmentation](/docs/transformers/v5.23.0/ko/model_doc/eomt#transformers.EomtForUniversalSegmentation)) : 모델의 원시 출력

target_sizes (`list[tuple[int, int]]`) : 배치 내 각 이미지의 대상 크기(높이, 너비)를 포함하는 튜플(`tuple[int, int]`)의 목록.

size (`dict[str, int]`, *선택 사항*) : 중간 마스크가 보간될 크기입니다. 기본값은 `self.size`입니다.

return_segmentation_scores (`bool`, *선택 사항*, 기본값 `False`) : 분할 맵과 함께 분할 점수를 반환할지 여부입니다. `True`인 경우, 반환된 리스트의 각 요소는 `segmentation` 필드(클래스 ID, shape `(height, width)`)와 `segmentation_scores` 필드(shape `(num_classes, height, width)`)를 가진 `SemanticSegmentationPostProcessorOutput`입니다.

**반환값:** `list[torch.Tensor]` 또는 `list[SemanticSegmentationPostProcessorOutput]`

`return_segmentation_scores=False`(기본값)인 경우, 각 항목이 클래스 ID를 가진 `(height, width)` 모양의 세그멘테이션 맵인 길이 `batch_size`의 리스트를 반환합니다. `return_segmentation_scores=True`인 경우, `segmentation`(클래스 ID, 모양 `(height, width)`)와 `segmentation_scores`(모양 `(num_classes, height, width)`) 필드를 가진 `SemanticSegmentationPostProcessorOutput`의 리스트를 반환합니다. 두 경우 모두 `(height, width)`는 대상 크기에 해당합니다.

[EomtForUniversalSegmentation](/docs/transformers/v5.23.0/ko/model_doc/eomt#transformers.EomtForUniversalSegmentation)의 출력을 의미 분할 맵으로 변환합니다.

#### post_process_instance_segmentation[[transformers.EomtImageProcessor.post_process_instance_segmentation]]

```python
post_process_instance_segmentation(outputs, target_sizes: list[tuple[int, int]], threshold: float = 0.8, size: dict[str, int] | None = None)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/eomt/image_processing_eomt.py#L635)

모델 출력을 Instance Segmentation Predictions으로 후처리합니다.

#### post_process_panoptic_segmentation[[transformers.EomtImageProcessor.post_process_panoptic_segmentation]]

```python
post_process_panoptic_segmentation(outputs, target_sizes: list[tuple[int, int]], 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)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/eomt/image_processing_eomt.py#L578)

모델 출력을 최종 panoptic segmentation 예측으로 후처리합니다.

## EomtImageProcessorPil[[transformers.EomtImageProcessorPil]]

#### transformers.EomtImageProcessorPil[[transformers.EomtImageProcessorPil]]

```python
transformers.EomtImageProcessorPil(**kwargs: *<class 'transformers.models.eomt.image_processing_pil_eomt.EomtImageProcessorKwargs'>)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/eomt/image_processing_pil_eomt.py#L215)

**매개변수:**

do_convert_rgb (`bool`, *kwargs*, *선택*) : 이미지를 RGB로 변환할지 여부.

do_resize (`bool`, *kwargs*, *선택 사항*, 기본값 `True`) : 이미지를 리사이즈할지 여부.

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, 기본값 `{'shortest_edge' : 640, 'longest_edge': 640}`): 모델에 전달되는 최대 입력 차원을 설명합니다.

default_to_square (`bool`, *kwargs*, *선택 사항*, 기본값 `False`) : size가 int인 경우 리사이즈 시 정사각형 이미지로 설정할지 여부.

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : `center_crop`를 적용한 후의 출력 이미지 크기.

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, 기본값 `2`) : 이미지를 리사이즈할 때 사용할 리샘플링 필터입니다. 이는 `PILImageResampling` enum 중 하나일 수 있습니다. `do_resize`가 `True`로 설정된 경우에만 효과가 있습니다.

do_rescale (`bool`, *kwargs*, *선택 사항*, 기본값 `True`) : 이미지를 다시 스케일링할지 여부.

rescale_factor (`float`, *kwargs*, *선택 사항*, 기본값 `0.00392156862745098`) : `do_rescale`이 `True`로 설정된 경우 이미지를 재조정하는 데 사용되는 재조정 계수입니다.

do_normalize (`bool`, *kwargs*, *선택 사항*, 기본값 `True`) : 이미지를 정규화할지 여부.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *선택 사항*, 기본값은 `[0.485, 0.456, 0.406]`) : 정규화에 사용할 이미지 평균입니다. `do_normalize`가 `True`로 설정된 경우에만 효과가 있습니다.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *선택 사항*, 기본값은 `[0.229, 0.224, 0.225]`) : 정규화에 사용할 이미지 표준 편차입니다. `do_normalize`가 `True`로 설정된 경우에만 효과가 있습니다.

do_pad (`bool`, *kwargs*, *선택 사항*, 기본값 `False`) : 이미지를 패딩할지 여부입니다. 패딩은 배치 내 가장 큰 크기로 수행하거나 이미지마다 고정된 정사각형 크기로 수행합니다. 정확한 패딩 전략은 모델에 따라 달라집니다.

pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : 이미지를 패딩할 `{"height": int, "width" int}` 크기를 지정합니다. 전처리용으로 제공된 모든 이미지 크기보다 커야 합니다. `pad_size`가 제공되지 않으면, 이미지는 배치 내 가장 큰 높이와 너비로 패딩됩니다. `do_pad=True.`일 때만 적용됩니다.

do_center_crop (`bool`, *kwargs*, *선택*) : 이미지를 중앙 크롭할지 여부.

data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *선택*) : `ChannelDimension.FIRST`만 지원됩니다. 느린 프로세서와의 호환성을 위해 추가되었습니다.

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *선택*) : 입력 이미지의 채널 차원 형식입니다. 설정하지 않으면 입력 이미지에서 채널 차원 형식을 추론합니다. 다음 중 하나일 수 있습니다: - `"channels_first"` 또는 `ChannelDimension.FIRST`: (num_channels, height, width) 형식의 이미지. - `"channels_last"` 또는 `ChannelDimension.LAST`: (height, width, num_channels) 형식의 이미지. - `"none"` 또는 `ChannelDimension.NONE`: (height, width) 형식의 이미지.

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : 비디오를 처리할 장치입니다. 설정되지 않은 경우, 입력 비디오에서 장치를 추론합니다.

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : `'pt'`로 설정된 경우 스택된 텐서를 반환하고, 그렇지 않으면 텐서 목록을 반환합니다.

disable_grouping (`bool`, *kwargs*, *선택*) : 이미지의 크기에 따른 그룹화를 비활성화하여 이미지를 배치 대신 개별적으로 처리할지 여부입니다. None인 경우, 이미지가 CPU에 있으면 True, 그렇지 않으면 False로 설정됩니다. 이 선택은 https://github.com/huggingface/transformers/pull/38157에 자세히 설명된 경험적 관찰에 기반합니다.

image_seq_length (`int`, *kwargs*, *선택*) : 입력의 각 이미지에 사용할 이미지 토큰의 수입니다. 하위 호환성을 위해 추가되었지만, 향후 모델에서는 프로세서 속성으로 설정해야 합니다.

do_split_image (`bool`, *kwargs*, *선택 사항*, 기본값은 `self.do_split_image`) : 의미론적 분할을 위해 입력 이미지를 겹치는 패치로 분할할지 여부입니다. `True`로 설정하면, 입력 이미지는 패치 간 겹침이 있는 `size["shortest_edge"]` 크기의 패치로 분할됩니다. 그렇지 않으면, 입력 이미지는 대상 크기로 패딩됩니다.

ignore_index (`int`, *kwargs*, *선택 사항*, 기본값은 `self.ignore_index`) : 세그멘테이션 맵의 배경 픽셀에 할당할 라벨입니다. 값이 제공되면, 세그멘테이션 맵에서 0(배경)으로 표시된 픽셀은 `ignore_index`로 대체됩니다.

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: *<class 'transformers.models.eomt.image_processing_pil_eomt.EomtImageProcessorKwargs'>)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/eomt/image_processing_pil_eomt.py#L281)

**매개변수:**

images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`) : 전처리할 이미지. 픽셀 값이 0에서 255 범위로 이루어진 단일 이미지 또는 배치 이미지를 기대합니다. 픽셀 값이 0에서 1 범위로 이루어진 이미지를 전달하는 경우 `do_rescale=False`로 설정하세요.

segmentation_maps (`ImageInput`, *선택 사항*) : 해당 이미지에 대해 전처리할 분할 맵입니다.

instance_id_to_semantic_id (`list[dict[int, int]]` 또는 `dict[int, int]`, *선택 사항*) : 객체 인스턴스 ID와 클래스 ID 사이의 매핑입니다.

do_convert_rgb (`bool`, *kwargs*, *선택*) : 이미지를 RGB로 변환할지 여부.

do_resize (`bool`, *kwargs*, *선택*) : 이미지를 리사이즈할지 여부.

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : 모델의 최대 입력 차원을 설명합니다.

default_to_square (`bool`, *kwargs*, *선택*) : size가 int인 경우 리사이즈 시 정사각형 이미지로 기본 설정할지 여부.

crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : `center_crop`를 적용한 후의 출력 이미지 크기.

resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*) : 이미지를 리사이즈할 때 사용할 리샘플링 필터입니다. `PILImageResampling` enum 중 하나를 사용할 수 있습니다. `do_resize`가 `True`로 설정된 경우에만 효과가 있습니다.

do_rescale (`bool`, *kwargs*, *선택*) : 이미지를 다시 스케일링할지 여부.

rescale_factor (`float`, *kwargs*, *선택*) : `do_rescale`가 `True`로 설정된 경우 이미지를 재조정하는 데 사용되는 재조정 계수입니다.

do_normalize (`bool`, *kwargs*, *선택*) : 이미지를 정규화할지 여부.

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *선택*) : 정규화에 사용할 이미지 평균값. `do_normalize`이 `True`로 설정된 경우에만 효과가 있습니다.

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *선택*) : 정규화에 사용할 이미지 표준 편차. `do_normalize`가 `True`로 설정된 경우에만 효과가 있습니다.

do_pad (`bool`, *kwargs*, *선택*) : 이미지를 패딩할지 여부입니다. 패딩은 배치 내 가장 큰 크기로 수행하거나, 이미지마다 고정된 정사각형 크기로 수행합니다. 정확한 패딩 전략은 모델에 따라 달라집니다.

pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : 이미지를 패딩할 `{"height": int, "width" int}` 크기를 지정합니다. 전처리용으로 제공된 모든 이미지 크기보다 커야 합니다. `pad_size`가 제공되지 않으면, 이미지는 배치 내 가장 큰 높이와 너비로 패딩됩니다. `do_pad=True.`일 때만 적용됩니다.

do_center_crop (`bool`, *kwargs*, *선택*) : 이미지를 중앙 크롭할지 여부.

data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *선택*) : `ChannelDimension.FIRST`만 지원됩니다. 느린 프로세서와의 호환성을 위해 추가되었습니다.

input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *선택*) : 입력 이미지의 채널 차원 형식입니다. 설정하지 않으면 입력 이미지에서 채널 차원 형식을 추론합니다. 다음 중 하나일 수 있습니다: - `"channels_first"` 또는 `ChannelDimension.FIRST`: (num_channels, height, width) 형식의 이미지. - `"channels_last"` 또는 `ChannelDimension.LAST`: (height, width, num_channels) 형식의 이미지. - `"none"` 또는 `ChannelDimension.NONE`: (height, width) 형식의 이미지.

device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : 비디오를 처리할 장치입니다. 설정되지 않은 경우, 입력 비디오에서 장치를 추론합니다.

return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : `'pt'`로 설정된 경우 스택된 텐서를 반환하고, 그렇지 않으면 텐서 목록을 반환합니다.

disable_grouping (`bool`, *kwargs*, *선택*) : 이미지의 크기에 따른 그룹화를 비활성화하여 이미지를 배치 대신 개별적으로 처리할지 여부입니다. None인 경우, 이미지가 CPU에 있으면 True, 그렇지 않으면 False로 설정됩니다. 이 선택은 https://github.com/huggingface/transformers/pull/38157에 자세히 설명된 경험적 관찰에 기반합니다.

image_seq_length (`int`, *kwargs*, *선택*) : 입력의 각 이미지에 사용할 이미지 토큰의 수입니다. 하위 호환성을 위해 추가되었지만, 향후 모델에서는 프로세서 속성으로 설정해야 합니다.

do_split_image (`bool`, *kwargs*, *선택 사항*, 기본값은 `self.do_split_image`) : 의미론적 분할을 위해 입력 이미지를 겹치는 패치로 분할할지 여부입니다. `True`로 설정하면, 입력 이미지는 패치 간 겹침이 있는 `size["shortest_edge"]` 크기의 패치로 분할됩니다. 그렇지 않으면, 입력 이미지는 대상 크기로 패딩됩니다.

ignore_index (`int`, *kwargs*, *선택 사항*, 기본값은 `self.ignore_index`) : 세그멘테이션 맵의 배경 픽셀에 할당할 라벨입니다. 값이 제공되면, 세그멘테이션 맵에서 0(배경)으로 표시된 픽셀은 `ignore_index`로 대체됩니다.

**반환값:** `~image_processing_base.BatchFeature`

- **data** (`dict`) -- __call__ 메서드가 반환하는 리스트/배열/텐서 딕셔너리('pixel_values' 등).
- **tensor_type** (`Union[None, str, TensorType]`, *선택 사항*) -- 초기화 시 PyTorch/Numpy 텐서에서 정수 목록을 변환하려면 여기에 tensor_type을 지정할 수 있습니다.

#### post_process_semantic_segmentation[[transformers.EomtImageProcessorPil.post_process_semantic_segmentation]]

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

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/eomt/image_processing_pil_eomt.py#L495)

**매개변수:**

outputs ([EomtForUniversalSegmentation](/docs/transformers/v5.23.0/ko/model_doc/eomt#transformers.EomtForUniversalSegmentation)) : 모델의 원시 출력

target_sizes (`list[tuple[int, int]]`) : 배치 내 각 이미지의 대상 크기(높이, 너비)를 포함하는 튜플(`tuple[int, int]`)의 목록.

size (`dict[str, int]`, *선택 사항*) : 중간 마스크가 보간될 크기입니다. 기본값은 `self.size`입니다.

return_segmentation_scores (`bool`, *선택 사항*, 기본값 `False`) : 분할 맵과 함께 분할 점수를 반환할지 여부입니다. `True`인 경우, 반환된 리스트의 각 요소는 `segmentation` 필드(클래스 ID, shape `(height, width)`)와 `segmentation_scores` 필드(shape `(num_classes, height, width)`)를 가진 `SemanticSegmentationPostProcessorOutput`입니다.

**반환값:** `list[torch.Tensor]` 또는 `list[SemanticSegmentationPostProcessorOutput]`

`return_segmentation_scores=False`(기본값)인 경우, 각 항목이 클래스 ID를 가진 `(height, width)` 모양의 세그멘테이션 맵인 길이 `batch_size`의 리스트를 반환합니다. `return_segmentation_scores=True`인 경우, `segmentation`(클래스 ID, 모양 `(height, width)`)와 `segmentation_scores`(모양 `(num_classes, height, width)`) 필드를 가진 `SemanticSegmentationPostProcessorOutput`의 리스트를 반환합니다. 두 경우 모두 `(height, width)`는 대상 크기에 해당합니다.

[EomtForUniversalSegmentation](/docs/transformers/v5.23.0/ko/model_doc/eomt#transformers.EomtForUniversalSegmentation)의 출력을 의미 분할 맵으로 변환합니다.

#### post_process_instance_segmentation[[transformers.EomtImageProcessorPil.post_process_instance_segmentation]]

```python
post_process_instance_segmentation(outputs, target_sizes: list[tuple[int, int]], threshold: float = 0.8, size: dict[str, int] | None = None)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/eomt/image_processing_pil_eomt.py#L620)

모델 출력을 Instance Segmentation Predictions으로 후처리합니다.

#### post_process_panoptic_segmentation[[transformers.EomtImageProcessorPil.post_process_panoptic_segmentation]]

```python
post_process_panoptic_segmentation(outputs, target_sizes: list[tuple[int, int]], 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)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/eomt/image_processing_pil_eomt.py#L567)

모델 출력을 최종 panoptic segmentation 예측으로 후처리합니다.

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

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/eomt/configuration_eomt.py#L28)

**매개변수:**

hidden_size (`int`, *선택 사항*, 기본값 `1024`) : 숨겨진 표현의 차원.

num_hidden_layers (`int`, *선택 사항*, 기본값 `24`) : Transformer decoder의 숨겨진 레이어 수.

num_attention_heads (`int`, *선택 사항*, 기본값 `16`) : Transformer decoder의 각 attention layer에 사용할 attention head의 수입니다.

hidden_act (`str`, *선택 사항*, 기본값 `gelu`) : 디코더에서 사용되는 비선형 활성화 함수(함수 또는 문자열). 예를 들어, `"gelu"`, `"relu"`, `"silu"` 등이 있습니다.

hidden_dropout_prob (`Union[float, int]`, *선택 사항*, 기본값 `0.0`) : 임베딩, 인코더, 풀러의 모든 완전 연결 계층에 적용되는 dropout 확률입니다.

initializer_range (`float`, *선택 사항*, 기본값 `0.02`) : 모든 가중치 행렬을 초기화하는 truncated_normal_initializer의 표준 편차입니다.

layer_norm_eps (`float`, *선택 사항*, 기본값 `1e-06`) : 레이어 정규화 레이어에서 사용되는 epsilon 값입니다.

image_size (`Union[int, list[int], tuple[int, int]]`, *선택 사항*, 기본값 `640`) : 각 이미지의 크기(해상도).

patch_size (`Union[int, list[int], tuple[int, int]]`, *선택*, 기본값 `16`) : 각 패치의 크기(해상도).

num_channels (`int`, *선택 사항*, 기본값 `3`) : 입력 채널의 수입니다.

mlp_ratio (`int`, *선택 사항*, 기본값 `4`) : MLP 숨겨진 차원과 임베딩 차원의 비율입니다.

layerscale_value (`float`, *선택 사항*, 기본값 1.0) : LayerScale 매개변수의 초기 값입니다.

drop_path_rate (`Union[float, int]`, *선택 사항*, 기본값 `0.0`) : 패치 퓨전용 드롭 패스 비율입니다.

num_upscale_blocks (`int`, *선택 사항*, 기본값 2) : 디코더 또는 분할 헤드에 사용되는 업샘플링 블록의 수.

attention_dropout (`Union[float, int]`, *선택 사항*, 기본값 `0.0`) : attention 확률에 적용할 dropout 비율입니다.

use_swiglu_ffn (`bool`, *선택 사항*, 기본값 `False`) : SwiGLU 피드포워드 신경망을 사용할지 여부.

num_blocks (`int`, *선택 사항*, 기본값 4) : 아키텍처의 특징 블록 또는 단계 수.

no_object_weight (`float`, *선택 사항*, 기본값 0.1) : 판옵틱/인스턴스 분할에서 'no object' 클래스의 손실 가중치입니다.

class_weight (`float`, *선택 사항*, 기본값 2.0) : 분류 대상의 손실 가중치입니다.

mask_weight (`float`, *선택 사항*, 기본값 5.0) : 마스크 예측의 손실 가중치입니다.

dice_weight (`float`, *선택 사항*, 기본값 `5.0`) : 파노픽 세분화 손실에서 dice loss의 상대적 가중치입니다.

train_num_points (`int`, *선택 사항*, 기본값 12544) : 학습 중 마스크 손실 계산에 사용할 샘플링 포인트 수.

oversample_ratio (`float`, *선택 사항*, 기본값 3.0) : 마스크 학습을 위한 포인트 샘플링에 사용되는 오버샘플링 비율입니다.

importance_sample_ratio (`float`, *선택 사항*, 기본값 0.75) : 학습 중에 중요도에 따라 샘플링할 포인트의 비율.

num_queries (`int`, *선택 사항*, 기본값 200) : Transformer의 객체 쿼리 수.

num_register_tokens (`int`, *선택 사항*, 기본값 4) : Transformer 입력에 추가되는 학습 가능한 register 토큰의 수.

이것은 EomtModel의 구성을 저장하기 위한 구성 클래스입니다. 지정된 인자에 따라 Eomt 모델을 인스턴스화하여 모델 아키텍처를 정의하는 데 사용됩니다. 기본값으로 구성을 인스턴스화하면 [tue-mps/coco_panoptic_eomt_large_640](https://huggingface.co/tue-mps/coco_panoptic_eomt_large_640)의 구성과 유사한 구성이 생성됩니다.

Configuration 객체는 [PreTrainedConfig](/docs/transformers/v5.23.0/ko/main_classes/configuration#transformers.PreTrainedConfig)를 상속하며, 모델 출력을 제어하는 데 사용할 수 있습니다. 자세한 내용은 [PreTrainedConfig](/docs/transformers/v5.23.0/ko/main_classes/configuration#transformers.PreTrainedConfig)의 문서를 참고하세요.

예:

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

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/eomt/modeling_eomt.py#L1016)

**매개변수:**

config ([EomtConfig](/docs/transformers/v5.23.0/ko/model_doc/eomt#transformers.EomtConfig)) : 모델의 모든 매개변수를 포함하는 모델 구성 클래스입니다. 구성 파일로 초기화하는 것은 모델과 관련된 가중치를 로드하지 않으며, 구성 정보만 로드합니다. 모델 가중치를 로드하려면 [from_pretrained()](/docs/transformers/v5.23.0/ko/main_classes/model#transformers.PreTrainedModel.from_pretrained) 메서드를 확인하세요.

인스턴스/시맨틱/팬옵틱 분할을 위해 상단에 head가 있는 EoMT 모델.

이 모델은 [PreTrainedModel](/docs/transformers/v5.23.0/ko/main_classes/model#transformers.PreTrainedModel)에서 상속됩니다. 라이브러리가 모든 모델에 대해 구현하는 일반적 메서드(다운로드 또는 저장, 입력 임베딩 크기 조정, 헤드 프루닝 등)에 대해서는 상위 클래스 문서를 확인하세요.

이 모델은 또한 PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module)의 하위 클래스입니다. 일반적인 PyTorch Module처럼 사용하며, 일반적인 사용법과 동작에 관한 모든 사항은 PyTorch 문서를 참조하세요.

#### 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: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/eomt/modeling_eomt.py#L1074)

**매개변수:**

pixel_values (`torch.Tensor`, shape `(batch_size, num_channels, image_size, image_size)`) : 입력 이미지에 해당하는 텐서입니다. 픽셀 값은 [EomtImageProcessor](/docs/transformers/v5.23.0/ko/model_doc/eomt#transformers.EomtImageProcessor)를 사용하여 얻을 수 있습니다. 자세한 내용은 [EomtImageProcessor.__call__()](/docs/transformers/v5.23.0/ko/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__)를 참조하세요 (`processor_class`는 이미지 처리에 [EomtImageProcessor](/docs/transformers/v5.23.0/ko/model_doc/eomt#transformers.EomtImageProcessor)를 사용합니다).

mask_labels (`list[torch.Tensor]`, *선택 사항*) : 모델에 전달할 `(num_labels, height, width)` 모양의 마스크 라벨 목록

class_labels (`list[torch.LongTensor]`, *선택 사항*) : 모델에 전달할 `(num_labels, height, width)` 형식의 대상 클래스 라벨 목록입니다. `mask_labels`의 라벨을 식별하며, 예를 들어 `class_labels[i][j]`인 경우 `mask_labels[i][j]`의 라벨을 나타냅니다.

patch_offsets (`list[torch.Tensor]`, *선택 사항*) : 시맨틱 세분화를 위한 패치의 이미지 인덱스와 시작 및 끝 위치를 나타내는 튜플의 목록.

**반환값:** `EomtForUniversalSegmentationOutput` 또는 `tuple(torch.Tensor)`

`EomtForUniversalSegmentationOutput` 또는 `torch.Tensor` 튜플(`return_dict=False`이 전달되거나 `config.return_dict=False`인 경우)로, 구성([EomtConfig](/docs/transformers/v5.23.0/ko/model_doc/eomt#transformers.EomtConfig)) 및 입력에 따라 다양한 요소를 포함합니다.

[EomtForUniversalSegmentation](/docs/transformers/v5.23.0/ko/model_doc/eomt#transformers.EomtForUniversalSegmentation)의 forward 메서드는 `__call__` 특수 메서드를 오버라이드합니다.

`Module` 인스턴스는 전처리 및 후처리 단계를 실행하는 것을 처리하지만, 이 함수는 해당 단계를 조용히 무시하므로, 순전파(forward pass) 레시피를 이 함수 내에서 정의해야 하더라도 이후에는 이 함수 대신 `Module` 인스턴스를 호출해야 합니다.

- **loss** (`torch.Tensor`, *선택 사항*) -- 라벨이 존재할 때 반환되는 계산된 손실입니다.
- **class_queries_logits** (`torch.Tensor`, *선택*) -- 각 query에 대해 제안된 클래스를 나타내는 shape가 `(batch_size, num_queries, num_labels + 1)`인 텐서입니다. null 클래스를 포함하기 때문에 `+ 1`이 필요합니다.
- **masks_queries_logits** (`torch.Tensor`, *선택 사항*) -- 각 쿼리에 대한 제안된 마스크를 나타내는 `(batch_size, num_queries, height, width)` 형태의 텐서입니다.
- **last_hidden_state** (`torch.Tensor`, shape `(batch_size, num_channels, height, width)`) -- 마지막 레이어의 마지막 hidden states(최종 feature map).
- **hidden_states** (`tuple(torch.Tensor)`, *선택*, `output_hidden_states=True`가 전달되었을 때 또는 `config.output_hidden_states=True`일 때 반환) -- `torch.Tensor`의 튜플 (임베딩 출력 1개 + 각 스테이지 출력 1개), shape `(batch_size, sequence_length, hidden_size)`. 모델의 모든 레이어의 hidden states입니다.
- **attentions** (`tuple(tuple(torch.Tensor))`, *optional*, `output_attentions=True`가 전달되었거나 `config.output_attentions=True`인 경우 반환) -- shape가 `(batch_size, num_heads, sequence_length, sequence_length)`인 `tuple(torch.Tensor)`의 Tuple (레이어당 하나). transformer decoder의 Self Attention과 Cross Attention 가중치입니다.
- **patch_offsets** (`list[torch.Tensor]`, *선택 사항*) -- 의미론적 분할을 위한 패치의 이미지 인덱스와 시작 및 끝 위치를 나타내는 튜플 목록.

