# DETR

[DETR](https://huggingface.co/papers/2005.12872)는 컨볼루션 백본과 객체 감지를 위해 엔드투엔드로 학습할 수 있는 인코더-디코더 Transformer로 구성됩니다. Faster-R-CNN과 Mask-R-CNN과 같은 모델은 region proposals, non-maximum suppression procedure, anchor generation 등을 사용하지만, DETR은 이러한 복잡성을 크게 단순화합니다. 또한, 디코더 출력 위에 mask head를 단순히 추가하는 것만으로 DETR을 자연스럽게 확장하여 panoptic segmentation을 수행할 수도 있습니다.

모든 원본 DETR 체크포인트는 [AI at Meta](https://huggingface.co/facebook/models?search=detr) 조직에서 찾을 수 있습니다.

> [!TIP]
> 이 모델은 [nielsr](https://huggingface.co/nielsr)에 의해 기여되었습니다.
>
> 오른쪽 사이드바의 DETR 모델에 클릭하여 DETR을 다양한 객체 감지 및 분할 작업에 적용하는 방법에 대한 추가 예제를 확인하세요.
>
> `use_kernels=True`를 [from_pretrained()](/docs/transformers/main/ko/main_classes/model#transformers.PreTrainedModel.from_pretrained)에 설정하여 Hub의 최적화 커널로 지원되는 레이어를 대체합니다. 자세한 내용은 [커널 로딩](../kernel_doc/loading_kernels)을 참고하세요.

아래 예제는 [Pipeline](/docs/transformers/main/ko/main_classes/pipelines#transformers.Pipeline) 또는 [AutoModel](/docs/transformers/main/ko/model_doc/auto#transformers.AutoModel) 클래스를 사용하여 객체 감지를 수행하는 방법을 보여줍니다.

```python

from transformers import pipeline

pipeline = pipeline(
    "object-detection",
    model="facebook/detr-resnet-50",
    device_map=0
)

pipeline("http://images.cocodataset.org/val2017/000000039769.jpg")
```

```python
import requests
import torch
from PIL import Image

from transformers import AutoImageProcessor, AutoModelForObjectDetection

url = "http://images.cocodataset.org/val2017/000000039769.jpg"
image = Image.open(requests.get(url, stream=True).raw)

image_processor = AutoImageProcessor.from_pretrained("facebook/detr-resnet-50")
model = AutoModelForObjectDetection.from_pretrained("facebook/detr-resnet-50", device_map="auto")

# prepare image for the model
inputs = image_processor(images=image, return_tensors="pt").to(model.device)

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

results = image_processor.post_process_object_detection(outputs, target_sizes=torch.tensor([image.size[::-1]]), threshold=0.3)

for result in results:
    for score, label_id, box in zip(result["scores"], result["labels"], result["boxes"]):
        score, label = score.item(), label_id.item()
        box = [round(i, 2) for i in box.tolist()]
        print(f"{model.config.id2label[label]}: {score:.2f} {box}")
```

DETR의 작동 방식

[DetrForObjectDetection](/docs/transformers/main/ko/model_doc/detr#transformers.DetrForObjectDetection)의 작동 방식을 요약하면 다음과 같습니다:

먼저, 이미지는 사전 학습된 합성곱 백본을 통과합니다(논문에서는 저자들이 ResNet-50/ResNet-101을 사용합니다). batch 차원도 추가한다고 가정해 보겠습니다. 즉, 이미지가 3개의 색상 채널(RGB)을 가진다고 가정하면, 백본의 입력은 `(batch_size, 3, height, width)` 형태의 텐서입니다. CNN 백본은 더 낮은 해상도의 새로운 특징 맵을 출력하며, 일반적으로 `(batch_size, 2048, height/32, width/32)` 형태입니다. 이후 `nn.Conv2D` 레이어를 사용하여 DETR의 Transformer hidden dimension(기본값 `256`)에 맞게 투영됩니다. 이제 `(batch_size, 256, height/32, width/32).` 형태의 텐서를 갖게 됩니다. 다음으로, 특징 맵을 flatten하고 전치하여 `(batch_size, seq_len, d_model)` = `(batch_size, width/32*height/32, 256)` 형태의 텐서를 얻습니다. 따라서 NLP 모델과의 차이점 중 하나는 시퀀스 길이가 실제로는 보통보다 길지만, `d_model`은 더 작다는 것입니다(NLP에서는 일반적으로 768 이상입니다).

다음으로, 이는 인코더를 통과하여 동일한 모양의 `encoder_hidden_states`를 출력합니다(이를 이미지 특징으로 간주할 수 있습니다). 다음으로, 이른바 **object queries**가 디코더를 통과합니다. 이는 `num_queries`가 일반적으로 100으로 설정되고 0으로 초기화되는 `(batch_size, num_queries, d_model)` 모양의 텐서입니다. 이러한 입력 임베딩은 저자들이 object queries라고 부르는 학습된 위치 인코딩이며, 인코더와 마찬가지로 각 어텐션 레이어의 입력에 추가됩니다. 각 object query는 이미지 내의 특정 객체를 찾습니다. 디코더는 여러 개의 셀프-어텐션 및 인코더-디코더 어텐션 레이어를 통해 이러한 임베딩을 업데이트하여 동일한 모양의 `decoder_hidden_states`를 출력합니다: `(batch_size, num_queries, d_model)`. 다음으로, 객체 감지를 위해 두 개의 헤드가 위에 추가됩니다: 각 object query를 객체 중 하나 또는 "no object"로 분류하는 선형 레이어와, 각 query에 대해 바운딩 박스를 예측하는 MLP입니다.

모델은 **이분 매칭 손실**을 사용하여 학습됩니다. 즉, 실제로 수행하는 작업은 N = 100개의 객체 쿼리 각각에 대한 예측된 클래스와 바운딩 박스를 지상 진실(ground truth) 어노테이션과 비교하는 것입니다. 이때 어노테이션은 동일한 길이 N으로 패딩됩니다(예를 들어 이미지에 객체가 4개만 포함된 경우, 나머지 96개의 어노테이션은 클래스가 "no object"이고 바운딩 박스가 "no bounding box"가 됩니다). [헝가리안 매칭 알고리즘](https://en.wikipedia.org/wiki/Hungarian_algorithm)은 N개의 쿼리 각각을 N개의 어노테이션과 1:1로 매핑하는 최적의 대응을 찾기 위해 사용됩니다. 다음으로, 모델의 파라미터를 최적화하기 위해 표준 교차 엔트로피(클래스에 대해)와 L1 및 [일반화 IoU 손실](https://giou.stanford.edu/)의 선형 결합(바운딩 박스에 대해)이 사용됩니다.

DETR는 파노픽 세그멘테이션(시맨틱 세그멘테이션과 인스턴스 세그멘테이션을 통합하는 작업)을 수행하도록 자연스럽게 확장할 수 있습니다. [DetrForSegmentation](/docs/transformers/main/ko/model_doc/detr#transformers.DetrForSegmentation)은 [DetrForObjectDetection](/docs/transformers/main/ko/model_doc/detr#transformers.DetrForObjectDetection) 위에 세그멘테이션 마스크 헤드를 추가합니다. 마스크 헤드는 결합하여 학습하거나, 두 단계의 과정으로 학습할 수 있습니다. 두 단계 과정에서는 먼저 "things"(인스턴스)와 "stuff"(나무, 도로, 하늘과 같은 배경 객체) 둘 다의 바운딩 박스를 감지하도록 [DetrForObjectDetection](/docs/transformers/main/ko/model_doc/detr#transformers.DetrForObjectDetection) 모델을 학습한 다음, 모든 가중치를 동결하고 25에폭 동안 마스크 헤드만 학습합니다. 실험적으로, 이 두 가지 접근 방식은 유사한 결과를 제공합니다. 헝가리안 매칭이 박스 간의 거리를 사용하여 계산되므로, 학습이 가능하려면 박스 예측이 필수적입니다.

## The input is a single word "Notes".

참고

- DETR은 이미지에서 객체를 감지하기 위해 소위 **object queries**를 사용합니다. 쿼리의 수는 단일 이미지에서 감지할 수 있는 최대 객체 수를 결정하며, 기본적으로 100으로 설정되어 있습니다([DetrConfig](/docs/transformers/main/ko/model_doc/detr#transformers.DetrConfig)의 `num_queries` 파라미터를 참조). 여유를 두는 것이 좋다는 점에 유의하세요(COCO의 경우, 저자들은 100을 사용했으며, COCO 이미지의 최대 객체 수는 약 70개입니다).
- DETR의 decoder는 query 임베딩을 병렬로 업데이트합니다. 이는 병렬 방식 대신 자기회귀(decoding) 방식을 사용하는 GPT-2와 같은 언어 모델과 다릅니다. 따라서 인과적 어텐션 마스크(causal attention mask)는 사용되지 않습니다.
- DETR은 self-attention 및 cross-attention 각 레이어에서 query와 key로 투영하기 전에 hidden states에 position embeddings를 추가합니다. 이미지의 position embeddings의 경우, 고정된 sinusoidal 또는 학습된 absolute position embeddings 중 하나를 선택할 수 있습니다. 기본적으로 [DetrConfig](/docs/transformers/main/ko/model_doc/detr#transformers.DetrConfig)의 `position_embedding_type` 매개변수는 `"sine"`로 설정되어 있습니다.
- 학습 과정에서 DETR의 저자들은 디코더에 보조 손실을 사용하는 것이 특히 각 클래스의 올바른 개수만큼의 객체를 출력하도록 모델을 돕는 데 유용하다는 것을 발견했습니다. [DetrConfig](/docs/transformers/main/ko/model_doc/detr#transformers.DetrConfig)의 `auxiliary_loss` 매개변수를 `True`로 설정하면, 각 디코더 레이어 뒤에 예측 피드포워드 신경망과 헝가리안 손실이 추가됩니다(FFN은 매개변수를 공유합니다).
- 여러 노드에 걸친 분산 환경에서 모델을 학습하려면 *modeling_detr.py*의 *DetrLoss* 클래스에서 *num_boxes* 변수를 업데이트해야 합니다. 여러 노드에서 학습하는 경우, [여기](https://github.com/facebookresearch/detr/blob/a54b77800eb8e64e3ad0d8237789fcbf2f8350c5/models/detr.py#L227-L232)에서 볼 수 있듯이 이 값은 모든 노드에 걸친 대상 박스의 평균 개수로 설정해야 합니다.
- [DetrForObjectDetection](/docs/transformers/main/ko/model_doc/detr#transformers.DetrForObjectDetection)와 [DetrForSegmentation](/docs/transformers/main/ko/model_doc/detr#transformers.DetrForSegmentation)은 [timm library](https://github.com/rwightman/pytorch-image-models)에서 사용할 수 있는 임의의 convolutional backbone으로 초기화할 수 있습니다. 예를 들어 MobileNet backbone으로 초기화하려면 [DetrConfig](/docs/transformers/main/ko/model_doc/detr#transformers.DetrConfig)의 `backbone` 속성을 `"tf_mobilenetv3_small_075"`로 설정한 후 해당 config로 모델을 초기화하면 됩니다.
- DETR은 가장 짧은 변이 최소한 특정 픽셀 수 이상이고 가장 긴 변이 최대 1333 픽셀이 되도록 입력 이미지를 리사이즈합니다. 학습 시에는 스케일 증강을 사용하여 가장 짧은 변이 480 픽셀 이상 800 픽셀 이하의 값으로 무작위로 설정됩니다. 추론 시에는 가장 짧은 변이 800 픽셀로 설정됩니다. [DetrImageProcessor](/docs/transformers/main/ko/model_doc/detr#transformers.DetrImageProcessor)를 사용하여 모델에 사용할 이미지(및 COCO 형식의 선택적 주석)를 준비할 수 있습니다. 이러한 리사이즈로 인해 배치 내 이미지의 크기가 서로 다를 수 있습니다. DETR은 배치 내 가장 큰 크기로 이미지를 패딩하고, 실제 픽셀인지 패딩인지 나타내는 픽셀 마스크를 생성하여 이를 해결합니다. 또는 `~transformers.DetrImageProcessor.pad_and_create_pixel_mask`를 사용하여 이미지를 배치로 묶기 위해 사용자 정의 `collate_fn`을 정의할 수도 있습니다.
- 이미지의 크기는 사용될 메모리 양을 결정하며, 이는 `batch_size`를 결정합니다. GPU당 배치 크기를 2로 사용하는 것이 권장됩니다. 자세한 내용은 [이 Github 스레드](https://github.com/facebookresearch/detr/issues/150)를 참고하세요.

DETR 모델을 인스턴스화하는 다른 세 가지 방법(선호도에 따라 선택)이 있습니다:

- 옵션 1: 전체 모델에 대해 사전 학습된 가중치로 DETR 인스턴스화

```python
from transformers import DetrForObjectDetection

model = DetrForObjectDetection.from_pretrained("facebook/detr-resnet-50", device_map="auto")
```

- 옵션 2: Transformer는 무작위 초기화 가중치, backbone은 사전 학습된 가중치로 DETR을 초기화

```python
from transformers import DetrConfig, DetrForObjectDetection

config = DetrConfig()
model = DetrForObjectDetection(config)
```

- 옵션 3: backbone + Transformer에 무작위 초기화 가중치를 사용하여 DETR 인스턴스화

```python
config = DetrConfig()
model = DetrForObjectDetection(config)
```

요약으로 다음 표를 고려해 보세요:

| 작업 | 객체 감지 | 인스턴스 분할 | 팬옵틱 세그멘테이션 |
|------|------------------|-----------------------|-----------------------|
| **설명** | 이미지의 객체 주위에 바운딩 박스와 클래스 라벨을 예측 | 이미지에서 객체(즉, 인스턴스) 주위의 마스크 예측 | 이미지에서 두 개체(즉, 인스턴스) 주변뿐만 아니라 "stuff"(나무나 도로와 같은 배경 객체)에 대한 마스크를 예측합니다 |
| **모델** | [DetrForObjectDetection](/docs/transformers/main/ko/model_doc/detr#transformers.DetrForObjectDetection) | [DetrForSegmentation](/docs/transformers/main/ko/model_doc/detr#transformers.DetrForSegmentation) | [DetrForSegmentation](/docs/transformers/main/ko/model_doc/detr#transformers.DetrForSegmentation) |
| **예제 데이터셋** | COCO 객체 감지 | COCO detection, COCO panoptic | COCO panoptic                           |
| **에 제공해야 하는 어노테이션 형식**  [DetrImageProcessor](/docs/transformers/main/ko/model_doc/detr#transformers.DetrImageProcessor) | {'image_id': `int`, 'annotations': `list[Dict]`} 각 Dict는 COCO 객체 어노테이션입니다  | {'image_id': `int`, 'annotations': `list[Dict]`} (COCO detection의 경우) 또는 {'file_name': `str`, 'image_id': `int`, 'segments_info': `list[Dict]`} (COCO panoptic의 경우) | {'file_name': `str`, 'image_id': `int`, 'segments_info': `list[Dict]`} 및 masks_path(마스크의 PNG 파일이 포함된 디렉토리의 경로) |
| **후처리**(즉, 모델 출력을 Pascal VOC 형식으로 변환하는 것) | `~transformers.DetrImageProcessor.post_process` | `~transformers.DetrImageProcessor.post_process_segmentation` | `~transformers.DetrImageProcessor.post_process_segmentation`, `~transformers.DetrImageProcessor.post_process_panoptic` |
| **평가자** | `iou_types="bbox"`를 사용하는 `CocoEvaluator` | `CocoEvaluator`를 `iou_types="bbox"` 또는 `"segm"`와 함께 | `CocoEvaluator`를 `iou_types="bbox"` 또는 `"segm"`와 함께, `PanopticEvaluator` |

- 요약하면, 데이터는 COCO detection 또는 COCO panoptic 형식으로 준비한 뒤, [DetrImageProcessor](/docs/transformers/main/ko/model_doc/detr#transformers.DetrImageProcessor)를 사용해 `pixel_values`, `pixel_mask` 및 선택 사항인 `labels`를 생성하고, 이를 통해 모델을 학습(또는 파인튜닝)할 수 있습니다.
- 평가하려면 먼저 [DetrImageProcessor](/docs/transformers/main/ko/model_doc/detr#transformers.DetrImageProcessor)의 후처리 방법 중 하나를 사용하여 모델의 출력을 변환해야 합니다. 변환된 결과는 `CocoEvaluator` 또는 `PanopticEvaluator`에 전달할 수 있으며, 이를 통해 mean Average Precision (mAP)과 Panoptic Quality (PQ)와 같은 지표를 계산할 수 있습니다. 후자의 객체는 [원본 저장소](https://github.com/facebookresearch/detr)에 구현되어 있습니다. 평가에 대한 자세한 내용은 [예제 노트북](https://github.com/NielsRogge/Transformers-Tutorials/tree/master/DETR)을 참고하세요.

## 리소스

- 커스텀 데이터셋에서 [DetrForObjectDetection](/docs/transformers/main/ko/model_doc/detr#transformers.DetrForObjectDetection)과 [DetrForSegmentation](/docs/transformers/main/ko/model_doc/detr#transformers.DetrForSegmentation)를 파인튜닝하는 예제는 이 [노트북](https://github.com/NielsRogge/Transformers-Tutorials/tree/master/DETR)을 참고하세요.

## DetrConfig[[transformers.DetrConfig]]

#### transformers.DetrConfig[[transformers.DetrConfig]]

```python
transformers.DetrConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, is_encoder_decoder: bool = True, backbone_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, num_channels: int = 3, num_queries: int = 100, encoder_layers: int = 6, encoder_ffn_dim: int = 2048, encoder_attention_heads: int = 8, decoder_layers: int = 6, decoder_ffn_dim: int = 2048, decoder_attention_heads: int = 8, encoder_layerdrop: float | int = 0.0, decoder_layerdrop: float | int = 0.0, activation_function: str = 'relu', d_model: int = 256, dropout: float | int = 0.1, attention_dropout: float | int = 0.0, activation_dropout: float | int = 0.0, init_std: float = 0.02, init_xavier_std: float = 1.0, auxiliary_loss: bool = False, position_embedding_type: str = 'sine', dilation: bool = False, class_cost: int = 1, bbox_cost: int = 5, giou_cost: int = 2, mask_loss_coefficient: int = 1, dice_loss_coefficient: int = 1, bbox_loss_coefficient: int = 5, giou_loss_coefficient: int = 2, eos_coefficient: float = 0.1)
```

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/detr/configuration_detr.py#L25)

**매개변수:**

is_encoder_decoder (`bool`, *선택 사항*, 기본값 `True`) : 모델이 인코더/디코더로 사용되는지 여부.

backbone_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *선택*) : 백본 모델의 구성입니다.

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

num_queries (`int`, *선택 사항*, 기본값 100) : 객체 쿼리의 수, 즉 감지 슬롯의 수입니다. 이는 [ConditionalDetrModel](/docs/transformers/main/ko/model_doc/conditional_detr#transformers.ConditionalDetrModel)이 단일 이미지에서 감지할 수 있는 최대 객체 수입니다. COCO의 경우 100개의 쿼리를 권장합니다.

encoder_layers (`int`, *선택 사항*, 기본값 `6`) : Transformer 인코더의 숨겨진 레이어 수. 설정되지 않으면 `num_layers`와 동일한 값을 사용합니다.

encoder_ffn_dim (`int`, *선택 사항*, 기본값 `2048`) : 인코더의 "중간"(일반적으로 feed-forward라고도 함) 레이어의 차원.

encoder_attention_heads (`int`, *선택 사항*, 기본값 `8`) : Transformer 인코더의 각 어텐션 레이어에 사용할 어텐션 헤드 수입니다.

decoder_layers (`int`, *선택 사항*, 기본값 `6`) : Transformer decoder의 숨겨진 레이어 수입니다. 설정하지 않으면 `num_layers`와 동일한 값을 사용합니다.

decoder_ffn_dim (`int`, *선택 사항*, 기본값 `2048`) : 디코더의 "intermediate"(일반적으로 feed-forward라고도 함) 레이어의 차원.

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

encoder_layerdrop (`Union[float, int]`, *선택 사항*, 기본값 `0.0`) : 인코더의 LayerDrop 확률입니다. 자세한 내용은 [LayerDrop 논문](see https://huggingface.co/papers/1909.11556)을 참고하세요.

decoder_layerdrop (`Union[float, int]`, *선택 사항*, 기본값 `0.0`) : 디코더의 LayerDrop 확률입니다. 자세한 내용은 [LayerDrop 논문](see https://huggingface.co/papers/1909.11556)을 참고하세요.

activation_function (`str`, *선택 사항*, 기본값 `relu`) : 디코더의 비선형 활성화 함수(함수 또는 문자열). 예를 들어, `"gelu"`, `"relu"`, `"silu"` 등.

d_model (`int`, *선택 사항*, 기본값 `256`) : 인코더 레이어와 풀러 레이어의 크기.

dropout (`Union[float, int]`, *선택 사항*, 기본값 `0.1`) : 모든 dropout 레이어의 비율입니다.

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

activation_dropout (`Union[float, int]`, *선택 사항*, 기본값 `0.0`) : 완전 연결 계층 내부 활성화에 적용되는 dropout 비율입니다.

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

init_xavier_std (`float`, *선택 사항*, 기본값 `1.0`) : cross-attention 가중치의 Xavier 초기화에 사용되는 스케일링 계수입니다.

auxiliary_loss (`bool`, *선택 사항*, 기본값 `False`) : 보조 디코딩 손실(각 디코더 레이어의 손실)을 사용할지 여부입니다.

position_embedding_type (`str`, *선택 사항*, 기본값 `"sine"`) : 이미지 특징 위에 사용할 위치 임베딩의 유형. `"sine"` 또는 `"learned"` 중 하나입니다.

dilation (`bool`, *선택 사항*, 기본값 `False`) : 마지막 컨볼루션 블록(DC5)에서 stride를 dilation으로 대체할지 여부. `use_timm_backbone` = `True`일 때만 지원됩니다.

class_cost (`int`, *선택 사항*, 기본값 `1`) : 헝가리안 매칭 비용에서 분류 오류의 상대적 가중치입니다.

bbox_cost (`int`, *선택 사항*, 기본값 `5`) : 헝가리안 매칭 비용에서 L1 바운딩 박스 오류의 상대적 가중치입니다.

giou_cost (`int`, *선택 사항*, 기본값 `2`) : 헝가리안 매칭 비용에서 일반화 IoU 손상의 상대적 가중치.

mask_loss_coefficient (`int`, *선택 사항*, 기본값 `1`) : 파노픽 세분화 손실에서 포칼 손실의 상대적 가중치.

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

bbox_loss_coefficient (`int`, *선택 사항*, 기본값 `5`) : 파노픽 세분화 손실에서 L1 바운딩 박스 손실의 상대적 가중치.

giou_loss_coefficient (`int`, *선택 사항*, 기본값 `2`) : 팬옵틱 세분화 손실에서 일반화 IoU 손실의 상대적 가중치.

eos_coefficient (`float`, *선택 사항*, 기본값 `0.1`) : 객체 감지 손실에서 'no-object' 클래스의 상대 분류 가중치입니다.

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

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

예:

```python
>>> from transformers import DetrConfig, DetrModel

>>> # Initializing a DETR facebook/detr-resnet-50 style configuration
>>> configuration = DetrConfig()

>>> # Initializing a model (with random weights) from the facebook/detr-resnet-50 style configuration
>>> model = DetrModel(configuration)

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

## DetrImageProcessor[[transformers.DetrImageProcessor]]

#### transformers.DetrImageProcessor[[transformers.DetrImageProcessor]]

```python
transformers.DetrImageProcessor(**kwargs: *<class 'transformers.models.detr.image_processing_detr.DetrImageProcessorKwargs'>)
```

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/detr/image_processing_detr.py#L426)

**매개변수:**

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' : 800, 'longest_edge': 1333}`): 모델에 입력되는 최대 차원을 설명합니다.

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

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*, *선택*) : 입력의 각 이미지에 사용할 이미지 토큰의 수입니다. 하위 호환성을 위해 추가되었지만, 향후 모델에서는 프로세서 속성으로 설정해야 합니다.

format (`str`, *kwargs*, *선택 사항*, 기본값은 `AnnotationFormat.COCO_DETECTION`) : 어노테이션의 데이터 형식. "coco_detection" 또는 "coco_panoptic" 중 하나입니다.

do_convert_annotations (`bool`, *kwargs*, *선택 사항*, 기본값 `True`) : 주석을 DETR 모델이 기대하는 형식으로 변환할지 여부를 제어합니다. 바운딩 박스를 `(center_x, center_y, width, height)` 형식으로 변환하고 범위를 `[0, 1]`로 설정합니다. `preprocess` 메서드의 `do_convert_annotations` 매개변수로 재정의할 수 있습니다.

DetrImageProcessor 이미지 프로세서 생성

#### preprocess[[transformers.DetrImageProcessor.preprocess]]

```python
preprocess(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']], annotations: dict[str, int | str | list[dict]] | list[dict[str, int | str | list[dict]]] | None = None, return_segmentation_masks: bool | None = None, masks_path: str | pathlib.Path | None = None, **kwargs: *<class 'transformers.models.detr.image_processing_detr.DetrImageProcessorKwargs'>)
```

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/detr/image_processing_detr.py#L681)

**매개변수:**

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`로 설정하세요.

annotations (`AnnotationType` 또는 `list[AnnotationType]`, *선택 사항*) : 이미지에 적용되는 패딩에 따라 변환할 어노테이션입니다.

return_segmentation_masks (`bool`, *선택 사항*, 기본값 `self.return_segmentation_masks`) : 분할 마스크를 반환할지 여부.

masks_path (`str` 또는 `pathlib.Path`, *선택 사항*) : 분할 마스크를 포함하는 디렉터리의 경로.

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*, *선택*) : 입력의 각 이미지에 사용할 이미지 토큰의 수입니다. 하위 호환성을 위해 추가되었지만, 향후 모델에서는 프로세서 속성으로 설정해야 합니다.

format (`str`, *kwargs*, *선택 사항*, 기본값은 `AnnotationFormat.COCO_DETECTION`) : 어노테이션의 데이터 형식. "coco_detection" 또는 "coco_panoptic" 중 하나입니다.

do_convert_annotations (`bool`, *kwargs*, *선택 사항*, 기본값 `True`) : 주석을 DETR 모델이 기대하는 형식으로 변환할지 여부를 제어합니다. 바운딩 박스를 `(center_x, center_y, width, height)` 형식으로 변환하고 범위를 `[0, 1]`로 설정합니다. `preprocess` 메서드의 `do_convert_annotations` 매개변수로 재정의할 수 있습니다.

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

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

#### post_process_object_detection[[transformers.DetrImageProcessor.post_process_object_detection]]

```python
post_process_object_detection(outputs, threshold: float = 0.5, target_sizes: transformers.utils.generic.TensorType | list[tuple] | None = None)
```

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/detr/image_processing_detr.py#L823)

**매개변수:**

outputs (`DetrObjectDetectionOutput`) : 모델의 원시 출력

threshold (`float`, *선택 사항*) : 객체 감지 예측을 유지하기 위한 점수 임계값.

target_sizes (`torch.Tensor` 또는 `list[tuple[int, int]]`, *선택 사항*) : 배치 내 각 이미지의 대상 크기 `(height, width)`를 포함하는 `(batch_size, 2)` 모양의 Tensor 또는 튜플(`tuple[int, int]`) 목록입니다. 설정되지 않으면 예측 결과가 리사이즈되지 않습니다.

**반환값:** `list[Dict]`

…

[DetrForObjectDetection](/docs/transformers/main/ko/model_doc/detr#transformers.DetrForObjectDetection)의 원시 출력을 (top_left_x, top_left_y, bottom_right_x, bottom_right_y) 형식의 최종 바운딩 박스로 변환합니다. PyTorch만 지원합니다.

#### post_process_semantic_segmentation[[transformers.DetrImageProcessor.post_process_semantic_segmentation]]

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

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/detr/image_processing_detr.py#L876)

**매개변수:**

outputs ([DetrForSegmentation](/docs/transformers/main/ko/model_doc/detr#transformers.DetrForSegmentation)) : 모델의 원시 출력

target_sizes (`list[tuple[int, int]]`, *선택 사항*) : 배치 내 각 이미지의 대상 크기(높이, 너비)를 포함하는 튜플(`tuple[int, int]`) 목록입니다. 설정되지 않으면 예측 결과가 리사이즈되지 않습니다.

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)`는 대상 크기(`target_sizes`가 지정된 경우)에 해당합니다.

[DetrForSegmentation](/docs/transformers/main/ko/model_doc/detr#transformers.DetrForSegmentation)의 출력을 의미 분할 맵으로 변환합니다. PyTorch만 지원합니다.

#### post_process_instance_segmentation[[transformers.DetrImageProcessor.post_process_instance_segmentation]]

```python
post_process_instance_segmentation(outputs, threshold: float = 0.5, mask_threshold: float = 0.5, overlap_mask_area_threshold: float = 0.8, target_sizes: list[tuple[int, int]] | None = None, return_coco_annotation: bool | None = False)
```

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/detr/image_processing_detr.py#L947)

**매개변수:**

outputs ([DetrForSegmentation](/docs/transformers/main/ko/model_doc/detr#transformers.DetrForSegmentation)) : 모델의 원시 출력

threshold (`float`, *선택 사항*, 기본값 0.5) : 예측된 인스턴스 마스크를 유지하기 위한 확률 점수 임계값입니다.

mask_threshold (`float`, *선택*, 기본값 0.5) : 예측된 마스크를 이진 값으로 변환할 때 사용할 임계값입니다.

overlap_mask_area_threshold (`float`, *선택 사항*, 기본값 0.8) : 각 바이너리 인스턴스 마스크 내에서 작은 분리된 부분을 병합하거나 제거하기 위한 오버랩 마스크 영역 임계값입니다.

target_sizes (`list[Tuple]`, *선택 사항*) : 길이가 (batch_size)인 리스트로, 각 리스트 항목(`tuple[int, int]]`)은 각 예측의 요청된 최종 크기(높이, 너비)에 해당합니다. 설정되지 않으면 예측은 리사이즈되지 않습니다.

return_coco_annotation (`bool`, *선택 사항*) : 기본값은 `False`입니다. `True`로 설정하면 분할 맵이 COCO run-length encoding(RLE) 형식으로 반환됩니다.

**반환값:** `list[Dict]`

이미지별로 하나씩 포함된 딕셔너리 목록이며, 각 딕셔너리에는 두 개의 키가 포함됩니다:
- **segmentation** -- 각 픽셀이 `segment_id`를 나타내는 `(height, width)` 형태의 텐서. return_coco_annotation이 `True`로 설정된 경우, 세그멘테이션 맵의 `list[List]` run-length encoding(RLE)입니다. `threshold`보다 높은 마스크가 발견되지 않으면 `None`으로 설정됩니다.
- **segments_info** -- 각 세그먼트에 대한 추가 정보를 포함하는 사전입니다.
  - **id** -- `segment_id`를 나타내는 정수입니다.
  - **label_id** -- `segment_id`에 해당하는 라벨/의미론적 클래스 ID를 나타내는 정수입니다.
  - **score** -- `segment_id`를 가진 세그먼트의 예측 점수.

[DetrForSegmentation](/docs/transformers/main/ko/model_doc/detr#transformers.DetrForSegmentation)의 출력을 인스턴스 분할 예측으로 변환합니다. PyTorch만 지원합니다.

#### post_process_panoptic_segmentation[[transformers.DetrImageProcessor.post_process_panoptic_segmentation]]

```python
post_process_panoptic_segmentation(outputs, threshold: float = 0.5, mask_threshold: float = 0.5, overlap_mask_area_threshold: float = 0.8, label_ids_to_fuse: set[int] | None = None, target_sizes: list[tuple[int, int]] | None = None)
```

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/detr/image_processing_detr.py#L1030)

**매개변수:**

outputs ([DetrForSegmentation](/docs/transformers/main/ko/model_doc/detr#transformers.DetrForSegmentation)) : [DetrForSegmentation](/docs/transformers/main/ko/model_doc/detr#transformers.DetrForSegmentation)의 출력

threshold (`float`, *선택 사항*, 기본값 0.5) : 예측된 인스턴스 마스크를 유지하기 위한 확률 점수 임계값입니다.

mask_threshold (`float`, *선택*, 기본값 0.5) : 예측된 마스크를 이진 값으로 변환할 때 사용할 임계값입니다.

overlap_mask_area_threshold (`float`, *선택 사항*, 기본값 0.8) : 각 바이너리 인스턴스 마스크 내에서 작은 분리된 부분을 병합하거나 제거하기 위한 오버랩 마스크 영역 임계값입니다.

label_ids_to_fuse (`Set[int]`, *선택 사항*) : 이 상태의 라벨은 모든 인스턴스가 하나로 병합됩니다. 예를 들어 이미지에는 하늘이 하나만 있을 수 있지만 여러 명의 사람이 있을 수 있으므로, 하늘의 라벨 ID는 해당 세트에 포함되지만 사람의 라벨 ID는 포함되지 않습니다.

target_sizes (`list[Tuple]`, *선택 사항*) : (batch_size) 길이의 리스트로, 각 리스트 항목(`tuple[int, int]]`)은 배치 내 각 예측의 요청된 최종 크기(높이, 너비)에 해당합니다. 설정되지 않으면 예측은 리사이즈되지 않습니다.

**반환값:** `list[Dict]`

이미지별로 하나씩 포함된 딕셔너리 목록이며, 각 딕셔너리에는 두 개의 키가 포함됩니다:
- **segmentation** -- 각 픽셀이 `segment_id`를 나타내거나, `threshold`를 초과하는 마스크가 없으면 `None`인 `(height, width)` 형태의 텐서. `target_sizes`가 지정된 경우, segmentation은 해당 `target_sizes` 항목으로 리사이즈됩니다.
- **segments_info** -- 각 세그먼트에 대한 추가 정보를 포함하는 사전입니다.
  - **id** -- `segment_id`를 나타내는 정수입니다.
  - **label_id** -- `segment_id`에 해당하는 라벨/의미론적 클래스 ID를 나타내는 정수입니다.
  - **was_fused** -- `label_id`가 `label_ids_to_fuse`에 포함되어 있으면 `True`, 그렇지 않으면 `False`인 불리언 값. 동일한 클래스/라벨의 여러 인스턴스가 병합되어 단일 `segment_id`가 할당되었습니다.
  - **score** -- `segment_id`를 가진 세그먼트의 예측 점수.

[DetrForSegmentation](/docs/transformers/main/ko/model_doc/detr#transformers.DetrForSegmentation)의 출력을 이미지 팬옵틱 세분화 예측으로 변환합니다. PyTorch만 지원합니다.

## DetrImageProcessorPil[[transformers.DetrImageProcessorPil]]

#### transformers.DetrImageProcessorPil[[transformers.DetrImageProcessorPil]]

```python
transformers.DetrImageProcessorPil(**kwargs: *<class 'transformers.models.detr.image_processing_pil_detr.DetrImageProcessorKwargs'>)
```

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/detr/image_processing_pil_detr.py#L432)

**매개변수:**

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' : 800, 'longest_edge': 1333}`): 모델에 입력되는 최대 차원을 설명합니다.

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

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*, *선택*) : 입력의 각 이미지에 사용할 이미지 토큰의 수입니다. 하위 호환성을 위해 추가되었지만, 향후 모델에서는 프로세서 속성으로 설정해야 합니다.

format (`str`, *kwargs*, *선택 사항*, 기본값은 `AnnotationFormat.COCO_DETECTION`) : 어노테이션의 데이터 형식. "coco_detection" 또는 "coco_panoptic" 중 하나입니다.

do_convert_annotations (`bool`, *kwargs*, *선택 사항*, 기본값 `True`) : 주석을 DETR 모델이 기대하는 형식으로 변환할지 여부를 제어합니다. 바운딩 박스를 `(center_x, center_y, width, height)` 형식으로 변환하고 범위를 `[0, 1]`로 설정합니다. `preprocess` 메서드의 `do_convert_annotations` 매개변수로 재정의할 수 있습니다.

DetrImageProcessor 이미지 프로세서 생성

#### preprocess[[transformers.DetrImageProcessorPil.preprocess]]

```python
preprocess(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']], annotations: dict[str, int | str | list[dict]] | list[dict[str, int | str | list[dict]]] | None = None, return_segmentation_masks: bool | None = None, masks_path: str | pathlib.Path | None = None, **kwargs: *<class 'transformers.models.detr.image_processing_pil_detr.DetrImageProcessorKwargs'>)
```

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/detr/image_processing_pil_detr.py#L700)

**매개변수:**

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`로 설정하세요.

annotations (`AnnotationType` 또는 `list[AnnotationType]`, *선택 사항*) : 이미지에 적용되는 패딩에 따라 변환할 어노테이션입니다.

return_segmentation_masks (`bool`, *선택 사항*, 기본값 `self.return_segmentation_masks`) : 분할 마스크를 반환할지 여부.

masks_path (`str` 또는 `pathlib.Path`, *선택 사항*) : 분할 마스크를 포함하는 디렉터리의 경로.

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*, *선택*) : 입력의 각 이미지에 사용할 이미지 토큰의 수입니다. 하위 호환성을 위해 추가되었지만, 향후 모델에서는 프로세서 속성으로 설정해야 합니다.

format (`str`, *kwargs*, *선택 사항*, 기본값은 `AnnotationFormat.COCO_DETECTION`) : 어노테이션의 데이터 형식. "coco_detection" 또는 "coco_panoptic" 중 하나입니다.

do_convert_annotations (`bool`, *kwargs*, *선택 사항*, 기본값 `True`) : 주석을 DETR 모델이 기대하는 형식으로 변환할지 여부를 제어합니다. 바운딩 박스를 `(center_x, center_y, width, height)` 형식으로 변환하고 범위를 `[0, 1]`로 설정합니다. `preprocess` 메서드의 `do_convert_annotations` 매개변수로 재정의할 수 있습니다.

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

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

#### post_process_object_detection[[transformers.DetrImageProcessorPil.post_process_object_detection]]

```python
post_process_object_detection(outputs, threshold: float = 0.5, target_sizes: transformers.utils.generic.TensorType | list[tuple] | None = None)
```

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/detr/image_processing_pil_detr.py#L845)

**매개변수:**

outputs (`DetrObjectDetectionOutput`) : 모델의 원시 출력

threshold (`float`, *선택 사항*) : 객체 감지 예측을 유지하기 위한 점수 임계값.

target_sizes (`torch.Tensor` 또는 `list[tuple[int, int]]`, *선택 사항*) : 배치 내 각 이미지의 대상 크기 `(height, width)`를 포함하는 `(batch_size, 2)` 모양의 Tensor 또는 튜플(`tuple[int, int]`) 목록입니다. 설정되지 않으면 예측 결과가 리사이즈되지 않습니다.

**반환값:** `list[Dict]`

…

[DetrForObjectDetection](/docs/transformers/main/ko/model_doc/detr#transformers.DetrForObjectDetection)의 원시 출력을 (top_left_x, top_left_y, bottom_right_x, bottom_right_y) 형식의 최종 바운딩 박스로 변환합니다. PyTorch만 지원합니다.

#### post_process_semantic_segmentation[[transformers.DetrImageProcessorPil.post_process_semantic_segmentation]]

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

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/detr/image_processing_pil_detr.py#L899)

**매개변수:**

outputs ([DetrForSegmentation](/docs/transformers/main/ko/model_doc/detr#transformers.DetrForSegmentation)) : 모델의 원시 출력

target_sizes (`list[tuple[int, int]]`, *선택 사항*) : 배치 내 각 이미지의 대상 크기(높이, 너비)를 포함하는 튜플(`tuple[int, int]`) 목록입니다. 설정되지 않으면 예측 결과가 리사이즈되지 않습니다.

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)`는 대상 크기(`target_sizes`가 지정된 경우)에 해당합니다.

[DetrForSegmentation](/docs/transformers/main/ko/model_doc/detr#transformers.DetrForSegmentation)의 출력을 의미 분할 맵으로 변환합니다. PyTorch만 지원합니다.

#### post_process_instance_segmentation[[transformers.DetrImageProcessorPil.post_process_instance_segmentation]]

```python
post_process_instance_segmentation(outputs, threshold: float = 0.5, mask_threshold: float = 0.5, overlap_mask_area_threshold: float = 0.8, target_sizes: list[tuple[int, int]] | None = None, return_coco_annotation: bool | None = False)
```

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/detr/image_processing_pil_detr.py#L971)

**매개변수:**

outputs ([DetrForSegmentation](/docs/transformers/main/ko/model_doc/detr#transformers.DetrForSegmentation)) : 모델의 원시 출력

threshold (`float`, *선택 사항*, 기본값 0.5) : 예측된 인스턴스 마스크를 유지하기 위한 확률 점수 임계값입니다.

mask_threshold (`float`, *선택*, 기본값 0.5) : 예측된 마스크를 이진 값으로 변환할 때 사용할 임계값입니다.

overlap_mask_area_threshold (`float`, *선택 사항*, 기본값 0.8) : 각 바이너리 인스턴스 마스크 내에서 작은 분리된 부분을 병합하거나 제거하기 위한 오버랩 마스크 영역 임계값입니다.

target_sizes (`list[Tuple]`, *선택 사항*) : 길이가 (batch_size)인 리스트로, 각 리스트 항목(`tuple[int, int]]`)은 각 예측의 요청된 최종 크기(높이, 너비)에 해당합니다. 설정되지 않으면 예측은 리사이즈되지 않습니다.

return_coco_annotation (`bool`, *선택 사항*) : 기본값은 `False`입니다. `True`로 설정하면 분할 맵이 COCO run-length encoding(RLE) 형식으로 반환됩니다.

**반환값:** `list[Dict]`

이미지별로 하나씩 포함된 딕셔너리 목록이며, 각 딕셔너리에는 두 개의 키가 포함됩니다:
- **segmentation** -- 각 픽셀이 `segment_id`를 나타내는 `(height, width)` 형태의 텐서. return_coco_annotation이 `True`로 설정된 경우, 세그멘테이션 맵의 `list[List]` run-length encoding(RLE)입니다. `threshold`보다 높은 마스크가 발견되지 않으면 `None`으로 설정됩니다.
- **segments_info** -- 각 세그먼트에 대한 추가 정보를 포함하는 사전입니다.
  - **id** -- `segment_id`를 나타내는 정수입니다.
  - **label_id** -- `segment_id`에 해당하는 라벨/의미론적 클래스 ID를 나타내는 정수입니다.
  - **score** -- `segment_id`를 가진 세그먼트의 예측 점수.

[DetrForSegmentation](/docs/transformers/main/ko/model_doc/detr#transformers.DetrForSegmentation)의 출력을 인스턴스 분할 예측으로 변환합니다. PyTorch만 지원합니다.

#### post_process_panoptic_segmentation[[transformers.DetrImageProcessorPil.post_process_panoptic_segmentation]]

```python
post_process_panoptic_segmentation(outputs, threshold: float = 0.5, mask_threshold: float = 0.5, overlap_mask_area_threshold: float = 0.8, label_ids_to_fuse: set[int] | None = None, target_sizes: list[tuple[int, int]] | None = None)
```

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/detr/image_processing_pil_detr.py#L1055)

**매개변수:**

outputs ([DetrForSegmentation](/docs/transformers/main/ko/model_doc/detr#transformers.DetrForSegmentation)) : [DetrForSegmentation](/docs/transformers/main/ko/model_doc/detr#transformers.DetrForSegmentation)의 출력

threshold (`float`, *선택 사항*, 기본값 0.5) : 예측된 인스턴스 마스크를 유지하기 위한 확률 점수 임계값입니다.

mask_threshold (`float`, *선택*, 기본값 0.5) : 예측된 마스크를 이진 값으로 변환할 때 사용할 임계값입니다.

overlap_mask_area_threshold (`float`, *선택 사항*, 기본값 0.8) : 각 바이너리 인스턴스 마스크 내에서 작은 분리된 부분을 병합하거나 제거하기 위한 오버랩 마스크 영역 임계값입니다.

label_ids_to_fuse (`Set[int]`, *선택 사항*) : 이 상태의 라벨은 모든 인스턴스가 하나로 병합됩니다. 예를 들어 이미지에는 하늘이 하나만 있을 수 있지만 여러 명의 사람이 있을 수 있으므로, 하늘의 라벨 ID는 해당 세트에 포함되지만 사람의 라벨 ID는 포함되지 않습니다.

target_sizes (`list[Tuple]`, *선택 사항*) : (batch_size) 길이의 리스트로, 각 리스트 항목(`tuple[int, int]]`)은 배치 내 각 예측의 요청된 최종 크기(높이, 너비)에 해당합니다. 설정되지 않으면 예측은 리사이즈되지 않습니다.

**반환값:** `list[Dict]`

이미지별로 하나씩 포함된 딕셔너리 목록이며, 각 딕셔너리에는 두 개의 키가 포함됩니다:
- **segmentation** -- 각 픽셀이 `segment_id`를 나타내거나, `threshold`를 초과하는 마스크가 없으면 `None`인 `(height, width)` 형태의 텐서. `target_sizes`가 지정된 경우, segmentation은 해당 `target_sizes` 항목으로 리사이즈됩니다.
- **segments_info** -- 각 세그먼트에 대한 추가 정보를 포함하는 사전입니다.
  - **id** -- `segment_id`를 나타내는 정수입니다.
  - **label_id** -- `segment_id`에 해당하는 라벨/의미론적 클래스 ID를 나타내는 정수입니다.
  - **was_fused** -- `label_id`가 `label_ids_to_fuse`에 포함되어 있으면 `True`, 그렇지 않으면 `False`인 불리언 값. 동일한 클래스/라벨의 여러 인스턴스가 병합되어 단일 `segment_id`가 할당되었습니다.
  - **score** -- `segment_id`를 가진 세그먼트의 예측 점수.

[DetrForSegmentation](/docs/transformers/main/ko/model_doc/detr#transformers.DetrForSegmentation)의 출력을 이미지 팬옵틱 세분화 예측으로 변환합니다. PyTorch만 지원합니다.

## DETR 전용 출력[[transformers.models.detr.modeling_detr.DetrModelOutput]]

#### transformers.models.detr.modeling_detr.DetrModelOutput[[transformers.models.detr.modeling_detr.DetrModelOutput]]

```python
transformers.models.detr.modeling_detr.DetrModelOutput(last_hidden_state: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.EncoderDecoderCache | None = None, decoder_hidden_states: tuple[torch.Tensor, ...] | None = None, decoder_attentions: tuple[torch.Tensor, ...] | None = None, cross_attentions: tuple[torch.Tensor, ...] | None = None, encoder_last_hidden_state: typing.Optional[torch.Tensor] = None, encoder_hidden_states: tuple[torch.Tensor, ...] | None = None, encoder_attentions: tuple[torch.Tensor, ...] | None = None, intermediate_hidden_states: typing.Optional[torch.Tensor] = None)
```

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/detr/modeling_detr.py#L76)

**매개변수:**

last_hidden_state (`torch.Tensor`, shape `(batch_size, sequence_length, hidden_size)`) : 모델의 decoder 마지막 레이어 출력의 hidden-states 시퀀스입니다. `past_key_values`를 사용하는 경우, shape가 `(batch_size, 1, hidden_size)`인 시퀀스의 마지막 hidden-state만 출력됩니다.

past_key_values (`EncoderDecoderCache`, *선택 사항*, `use_cache=True`가 전달되거나 `config.use_cache=True`인 경우 반환됨) : [EncoderDecoderCache](/docs/transformers/main/ko/internal/generation_utils#transformers.EncoderDecoderCache) 인스턴스입니다. 자세한 내용은 [kv cache 가이드](https://huggingface.co/docs/transformers/en/kv_cache)를 참조하세요. 순차적 디코딩을 가속화하는 데 사용할 수 있는 사전 계산된 hidden-states(셀프 어텐션 블록과 크로스 어텐션 블록의 key 및 value)를 포함합니다(입력 `past_key_values` 참조).

decoder_hidden_states (`tuple(torch.Tensor)`, *선택*, `output_hidden_states=True`가 전달되었거나 `config.output_hidden_states=True`인 경우 반환됨) : `torch.Tensor`의 튜플(모델에 임베딩 레이어가 있는 경우 임베딩의 출력에 대한 것 1개 + 각 레이어의 출력에 대한 것 1개)로, 모양은 `(batch_size, sequence_length, hidden_size)`입니다. 각 레이어 출력 시 디코더의 hidden-states와 선택적인 초기 임베딩 출력을 포함합니다.

decoder_attentions (`tuple(torch.Tensor)`, *선택 사항*, `output_attentions=True`가 전달되었거나 `config.output_attentions=True`인 경우 반환됨) : `torch.Tensor`의 튜플(레이어당 하나), shape은 `(batch_size, num_heads, sequence_length, sequence_length)`입니다. self-attention 헤드에서 가중 평균을 계산하는 데 사용되는, attention softmax 이후의 decoder attention 가중치입니다.

cross_attentions (`tuple(torch.Tensor)`, *선택 사항*, `output_attentions=True`가 전달되거나 `config.output_attentions=True`인 경우 반환됨) : `torch.Tensor`의 튜플(각 레이어마다 하나), shape은 `(batch_size, num_heads, sequence_length, sequence_length)`입니다. attention softmax 이후의 decoder cross-attention 레이어의 attention 가중치로, cross-attention 헤드에서 가중 평균을 계산하는 데 사용됩니다.

encoder_last_hidden_state (`torch.Tensor`, shape `(batch_size, sequence_length, hidden_size)`, *선택 사항*) : 모델 인코더의 마지막 레이어 출력에서 생성된 hidden-states 시퀀스입니다.

encoder_hidden_states (`tuple(torch.Tensor)`, *선택 사항*, `output_hidden_states=True`가 전달되었거나 `config.output_hidden_states=True`인 경우 반환됨) : `torch.Tensor`의 튜플(모델에 임베딩 레이어가 있는 경우 임베딩의 출력에 대한 것 1개 + 각 레이어의 출력에 대한 것 1개)로, 모양은 `(batch_size, sequence_length, hidden_size)`입니다. 각 레이어 출력 시점의 인코더 hidden-states와 선택적인 초기 임베딩 출력을 포함합니다.

encoder_attentions (`tuple(torch.Tensor)`, *선택 사항*, `output_attentions=True`가 전달되거나 `config.output_attentions=True`인 경우 반환됨) : `torch.Tensor`의 튜플(레이어당 하나), shape은 `(batch_size, num_heads, sequence_length, sequence_length)`입니다. attention softmax 이후의 인코더 attention 가중치로, self-attention 헤드에서 가중 평균을 계산하는 데 사용됩니다.

intermediate_hidden_states (`torch.Tensor`, shape `(config.decoder_layers, batch_size, sequence_length, hidden_size)`, *선택 사항*, `config.auxiliary_loss=True`일 때 반환됨) : decoder의 중간 activations, 즉 각 decoder layer의 출력으로, 각각 layernorm을 거친 값입니다.

DETR 인코더-디코더 모델의 출력에 대한 베이스 클래스입니다. 이 클래스는 Seq2SeqModelOutput에 선택적인 중간 디코더 활성화 스택, 즉 각 디코더 레이어의 출력(각 출력이 layernorm을 통과한 상태)이라는 속성을 하나 추가합니다. 이는 보조 디코딩 손실을 사용하여 모델을 학습할 때 유용합니다.

#### transformers.models.detr.modeling_detr.DetrObjectDetectionOutput[[transformers.models.detr.modeling_detr.DetrObjectDetectionOutput]]

```python
transformers.models.detr.modeling_detr.DetrObjectDetectionOutput(loss: typing.Optional[torch.Tensor] = None, loss_dict: dict | None = None, logits: typing.Optional[torch.Tensor] = None, pred_boxes: typing.Optional[torch.Tensor] = None, auxiliary_outputs: list[dict] | None = None, last_hidden_state: typing.Optional[torch.Tensor] = None, decoder_hidden_states: tuple[torch.Tensor] | None = None, decoder_attentions: tuple[torch.Tensor] | None = None, cross_attentions: tuple[torch.Tensor] | None = None, encoder_last_hidden_state: typing.Optional[torch.Tensor] = None, encoder_hidden_states: tuple[torch.Tensor] | None = None, encoder_attentions: tuple[torch.Tensor] | None = None)
```

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/detr/modeling_detr.py#L92)

**매개변수:**

loss (`torch.Tensor`, shape `(1,)`, *선택 사항*, `labels`이 제공될 때 반환)) : 클래스 예측에 대한 음의 로그 가능도(cross-entropy)와 바운딩 박스 손실의 선형 결합으로 계산된 총 손실입니다. 여기서 바운딩 박스 손실은 L1 손실과 일반화된 스케일 불변 IoU 손실의 선형 결합으로 정의됩니다.

loss_dict (`Dict`, *선택 사항*) : 개별 손실을 포함하는 사전입니다. 로깅에 유용합니다.

logits (`torch.Tensor`, shape `(batch_size, num_queries, num_classes + 1)`) : 모든 query에 대한 분류 logits(no-object 포함).

pred_boxes (`torch.Tensor`, shape `(batch_size, num_queries, 4)`) : 모든 query에 대한 정규화된 박스 좌표로, (center_x, center_y, width, height) 형식으로 표현됩니다. 이 값들은 배치 내 각 개별 이미지의 크기에 대해 [0, 1] 범위로 정규화되어 있습니다(가능한 패딩은 무시). [post_process_object_detection()](/docs/transformers/main/ko/model_doc/detr#transformers.DetrImageProcessor.post_process_object_detection)를 사용하면 정규화되지 않은 바운딩 박스를 가져올 수 있습니다.

auxiliary_outputs (`list[Dict]`, *선택 사항*) : 보조 손실이 활성화된 경우(즉, `config.auxiliary_loss`가 `True`로 설정된 경우)에만 반환되며, 라벨이 제공되어야 합니다. 각 디코더 레이어에 대해 위의 두 키(`logits`와 `pred_boxes`)를 포함하는 사전의 목록입니다.

last_hidden_state (`torch.Tensor`, shape `(batch_size, sequence_length, hidden_size)`, *선택 사항*) : 모델의 decoder 마지막 레이어 출력의 hidden-states 시퀀스.

decoder_hidden_states (`tuple[torch.Tensor]`, *선택*, `output_hidden_states=True`가 전달되거나 `config.output_hidden_states=True`인 경우 반환) : shape가 `(batch_size, sequence_length, hidden_size)`인 `torch.Tensor`의 튜플 (모델에 embedding 레이어가 있는 경우 embedding 출력 1개 + 각 레이어 출력 1개). 각 레이어 출력 시점의 decoder hidden-states와 초기 embedding 출력을 포함합니다.

decoder_attentions (`tuple[torch.Tensor]`, *선택*, `output_attentions=True`가 전달되거나 `config.output_attentions=True`일 때 반환됩니다) : 각 레이어마다 하나씩 포함된 `torch.Tensor`의 튜플로, shape는 `(batch_size, num_heads, sequence_length, sequence_length)`입니다. attention softmax 이후의 decoder attention 가중치로, self-attention heads에서 가중 평균을 계산하는 데 사용됩니다.

cross_attentions (`tuple[torch.Tensor]`, *선택 사항*, `output_attentions=True`가 전달되었거나 `config.output_attentions=True`인 경우 반환됨) : shape이 `(batch_size, num_heads, sequence_length, sequence_length)`인 `torch.Tensor`의 튜플 (레이어당 하나). attention softmax 이후 decoder의 cross-attention 레이어의 attention 가중치로, cross-attention head에서 가중 평균을 계산하는 데 사용됩니다.

encoder_last_hidden_state (`torch.Tensor`, shape `(batch_size, sequence_length, hidden_size)`, *선택 사항*) : 모델 인코더의 마지막 레이어 출력에서 생성된 hidden-states 시퀀스입니다.

encoder_hidden_states (`tuple[torch.Tensor]`, *선택*, `output_hidden_states=True`가 전달되었거나 `config.output_hidden_states=True`인 경우 반환) : `(batch_size, sequence_length, hidden_size)` 형태의 `torch.Tensor` 튜플 (모델에 임베딩 레이어가 있는 경우 임베딩 출력 1개 + 각 레이어의 출력 1개). 인코더의 각 레이어 출력 시점의 hidden states와 초기 임베딩 출력입니다.

encoder_attentions (`tuple[torch.Tensor]`, *선택 사항*, `output_attentions=True`가 전달되었거나 `config.output_attentions=True`인 경우 반환됨) : shape이 `(batch_size, num_heads, sequence_length, sequence_length)`인 `torch.Tensor`의 튜플 (레이어당 하나). attention softmax 이후의 인코더 attention weights로, self-attention heads에서 가중 평균을 계산하는 데 사용됩니다.

[DetrForObjectDetection](/docs/transformers/main/ko/model_doc/detr#transformers.DetrForObjectDetection)의 출력 유형.

#### transformers.models.detr.modeling_detr.DetrSegmentationOutput[[transformers.models.detr.modeling_detr.DetrSegmentationOutput]]

```python
transformers.models.detr.modeling_detr.DetrSegmentationOutput(loss: typing.Optional[torch.Tensor] = None, loss_dict: dict | None = None, logits: typing.Optional[torch.Tensor] = None, pred_boxes: typing.Optional[torch.Tensor] = None, pred_masks: typing.Optional[torch.Tensor] = None, auxiliary_outputs: list[dict] | None = None, last_hidden_state: typing.Optional[torch.Tensor] = None, decoder_hidden_states: tuple[torch.Tensor] | None = None, decoder_attentions: tuple[torch.Tensor] | None = None, cross_attentions: tuple[torch.Tensor] | None = None, encoder_last_hidden_state: typing.Optional[torch.Tensor] = None, encoder_hidden_states: tuple[torch.Tensor] | None = None, encoder_attentions: tuple[torch.Tensor] | None = None)
```

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/detr/modeling_detr.py#L135)

**매개변수:**

loss (`torch.Tensor`, shape `(1,)`, *선택 사항*, `labels`가 제공될 때 반환)) : 클래스 예측에 대한 negative log-likelihood(cross-entropy)와 bounding box loss의 선형 결합으로 계산된 총 손실. 후자는 L1 loss와 generalized scale-invariant IoU loss의 선형 결합으로 정의됩니다.

loss_dict (`Dict`, *선택 사항*) : 개별 손실을 포함하는 사전입니다. 로깅에 유용합니다.

logits (`torch.Tensor`, shape `(batch_size, num_queries, num_classes + 1)`) : 모든 query에 대한 분류 logits(no-object 포함).

pred_boxes (`torch.Tensor`, shape `(batch_size, num_queries, 4)`) : 모든 query에 대한 정규화된 박스 좌표로, (center_x, center_y, width, height) 형식으로 표현됩니다. 이 값들은 배치 내 각 개별 이미지의 크기에 대해 [0, 1] 범위로 정규화되어 있습니다(가능한 패딩은 무시). [post_process_object_detection()](/docs/transformers/main/ko/model_doc/detr#transformers.DetrImageProcessor.post_process_object_detection)를 사용하면 정규화되지 않은 바운딩 박스를 가져올 수 있습니다.

pred_masks (`torch.Tensor`, shape `(batch_size, num_queries, height/4, width/4)`) : 모든 쿼리에 대한 분할 마스크 로짓. 각각 시맨틱, 인스턴스, 팬옵틱 분할 마스크를 평가하려면 [post_process_semantic_segmentation()](/docs/transformers/main/ko/model_doc/detr#transformers.DetrImageProcessor.post_process_semantic_segmentation), [post_process_instance_segmentation()](/docs/transformers/main/ko/model_doc/detr#transformers.DetrImageProcessor.post_process_instance_segmentation), [post_process_panoptic_segmentation()](/docs/transformers/main/ko/model_doc/detr#transformers.DetrImageProcessor.post_process_panoptic_segmentation)을(를) 참조하세요.

auxiliary_outputs (`list[Dict]`, *선택 사항*) : 보조 손실이 활성화된 경우(즉, `config.auxiliary_loss`가 `True`로 설정된 경우)에만 반환되며, 라벨이 제공되어야 합니다. 각 디코더 레이어에 대해 위의 두 키(`logits`와 `pred_boxes`)를 포함하는 사전의 목록입니다.

last_hidden_state (`torch.Tensor`, shape `(batch_size, sequence_length, hidden_size)`, *선택 사항*) : 모델의 decoder 마지막 레이어 출력의 hidden-states 시퀀스.

decoder_hidden_states (`tuple[torch.Tensor]`, *선택*, `output_hidden_states=True`가 전달되거나 `config.output_hidden_states=True`인 경우 반환) : shape가 `(batch_size, sequence_length, hidden_size)`인 `torch.Tensor`의 튜플 (모델에 embedding 레이어가 있는 경우 embedding 출력 1개 + 각 레이어 출력 1개). 각 레이어 출력 시점의 decoder hidden-states와 초기 embedding 출력을 포함합니다.

decoder_attentions (`tuple[torch.Tensor]`, *선택*, `output_attentions=True`가 전달되거나 `config.output_attentions=True`일 때 반환됩니다) : 각 레이어마다 하나씩 포함된 `torch.Tensor`의 튜플로, shape는 `(batch_size, num_heads, sequence_length, sequence_length)`입니다. attention softmax 이후의 decoder attention 가중치로, self-attention heads에서 가중 평균을 계산하는 데 사용됩니다.

cross_attentions (`tuple[torch.Tensor]`, *선택 사항*, `output_attentions=True`가 전달되었거나 `config.output_attentions=True`인 경우 반환됨) : `torch.Tensor`의 Tuple (각 레이어마다 하나), shape은 `(batch_size, num_heads, sequence_length, sequence_length)`. attention softmax를 거친 decoder의 cross-attention 레이어의 attention 가중치로, cross-attention heads에서 가중 평균을 계산하는 데 사용됩니다.

encoder_last_hidden_state (`torch.Tensor`, shape `(batch_size, sequence_length, hidden_size)`, *선택 사항*) : 모델 인코더의 마지막 레이어 출력에서 생성된 hidden-states 시퀀스입니다.

encoder_hidden_states (`tuple[torch.Tensor]`, *선택*, `output_hidden_states=True`가 전달되었거나 `config.output_hidden_states=True`인 경우 반환) : `(batch_size, sequence_length, hidden_size)` 형태의 `torch.Tensor` 튜플 (모델에 임베딩 레이어가 있는 경우 임베딩 출력 1개 + 각 레이어의 출력 1개). 인코더의 각 레이어 출력 시점의 hidden states와 초기 임베딩 출력입니다.

encoder_attentions (`tuple[torch.Tensor]`, *optional*, `output_attentions=True`가 전달되었거나 `config.output_attentions=True`인 경우 반환) : `torch.Tensor`의 Tuple (각 레이어마다 하나)으로, shape이 `(batch_size, num_heads, sequence_length, sequence_length)`입니다. Encoder의 어텐션 가중치로, 어텐션 softmax 이후 self-attention heads에서 가중 평균을 계산하는 데 사용됩니다.

[DetrForSegmentation](/docs/transformers/main/ko/model_doc/detr#transformers.DetrForSegmentation)의 출력 유형.

## DetrModel[[transformers.DetrModel]]

#### transformers.DetrModel[[transformers.DetrModel]]

```python
transformers.DetrModel(config: DetrConfig)
```

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/detr/modeling_detr.py#L1115)

**매개변수:**

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

특정 헤드가 없는 맨 위의 raw hidden-states를 출력하는 순수 DETR 모델(백본과 인코더-디코더 Transformer로 구성됨).

이 모델은 [PreTrainedModel](/docs/transformers/main/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.DetrModel.forward]]

```python
forward(pixel_values: typing.Optional[torch.Tensor] = None, pixel_mask: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.Tensor] = None, encoder_outputs: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, decoder_inputs_embeds: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/detr/modeling_detr.py#L1144)

**매개변수:**

pixel_values (`torch.Tensor`, shape `(batch_size, num_channels, image_size, image_size)`, *선택 사항*) : 입력 이미지에 해당하는 텐서입니다. 픽셀 값은 `image_processor_class`를 사용하여 얻을 수 있습니다. 자세한 내용은 `image_processor_class.__call__`를 참조하세요 (`processor_class`는 이미지 처리에 `image_processor_class`를 사용합니다).

pixel_mask (`torch.LongTensor`, shape `(batch_size, height, width)`, *선택 사항*) : 패딩 픽셀 값에 대한 attention을 수행하지 않도록 하는 마스크. `[0, 1]`에서 선택된 마스크 값: - 실제 픽셀(즉, **마스크되지 않은** 픽셀)은 1, - 패딩 픽셀(즉, **마스크된** 픽셀)은 0. [attention 마스크란?](../glossary#attention-mask)

decoder_attention_mask (`torch.Tensor`, shape `(batch_size, num_queries)`, *선택 사항*) : decoder에서 특정 object query에 attention을 수행하지 않도록 하는 마스크. 마스크 값은 `[0, 1]`에서 선택: - **마스크되지 않은** query는 1, - **마스크된** query는 0.

encoder_outputs (`torch.Tensor`, *선택 사항*) : (`last_hidden_state`, *선택 사항*: `hidden_states`, *선택 사항*: `attentions`) `last_hidden_state`의 shape은 `(batch_size, sequence_length, hidden_size)`, *선택 사항*)이며, 인코더의 마지막 레이어 출력에서 생성된 hidden-states의 시퀀스입니다. 디코더의 cross-attention에 사용됩니다.

inputs_embeds (shape가 `(batch_size, sequence_length, hidden_size)`인 `torch.Tensor`, *선택 사항*) : backbone + projection layer의 출력인 평탄화된 feature map을 전달하는 대신, 이미지의 평탄화된 표현을 직접 전달할 수 있습니다. vision backbone을 우회하는 데 유용합니다.

decoder_inputs_embeds (`torch.Tensor`, shape `(batch_size, num_queries, hidden_size)`, *선택 사항*) : queries를 제로 텐서로 초기화하는 대신, 임베디드 표현을 직접 전달할 수 있습니다. custom query initialization이 필요한 작업에 유용합니다.

**반환값:** [DetrModelOutput](/docs/transformers/main/ko/model_doc/detr#transformers.models.detr.modeling_detr.DetrModelOutput) 또는 `tuple(torch.Tensor)`

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

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

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

- **last_hidden_state** (`torch.Tensor`, shape `(batch_size, sequence_length, hidden_size)`) -- 모델의 decoder 마지막 레이어 출력의 hidden-state 시퀀스입니다.

  `past_key_values`가 사용되면, `(batch_size, 1, hidden_size)` 형태의 시퀀스의 마지막 hidden-state만 출력됩니다.
- **past_key_values** (`EncoderDecoderCache`, *선택 사항*, `use_cache=True`가 전달되거나 `config.use_cache=True`인 경우 반환됨) -- [EncoderDecoderCache](/docs/transformers/main/ko/internal/generation_utils#transformers.EncoderDecoderCache) 인스턴스입니다. 자세한 내용은 [kv 캐시 가이드](https://huggingface.co/docs/transformers/en/kv_cache)를 참조하세요.

  순차적 디코딩을 가속화하는 데 사용할 수 있는 사전 계산된 hidden-states(셀프-어텐션 블록과 크로스-어텐션 블록의 key 및 values)를 포함합니다(입력 `past_key_values` 참조).
- **decoder_hidden_states** (`tuple(torch.Tensor)`, *선택*, `output_hidden_states=True`가 전달되거나 `config.output_hidden_states=True`인 경우 반환) -- shape가 `(batch_size, sequence_length, hidden_size)`인 `torch.Tensor`의 튜플 (모델에 임베딩 레이어가 있는 경우 임베딩 출력 1개 + 각 레이어의 출력 1개).

  각 레이어 출력의 decoder hidden-states와 선택적인 초기 embedding 출력
- **decoder_attentions** (`tuple(torch.Tensor)`, *선택 사항*, `output_attentions=True`가 전달되었거나 `config.output_attentions=True`인 경우 반환) -- 각 레이어마다 하나씩 포함된 `torch.Tensor` 튜플이며, shape는 `(batch_size, num_heads, sequence_length, sequence_length)`입니다.

  self-attention 헤드에서 가중 평균을 계산하는 데 사용되는, attention softmax 이후의 decoder의 attention 가중치입니다.
- **cross_attentions** (`tuple(torch.Tensor)`, *선택*, `output_attentions=True`가 전달되거나 `config.output_attentions=True`인 경우 반환) -- 각 레이어마다 하나씩 포함된 `torch.Tensor`의 튜플로, shape는 `(batch_size, num_heads, sequence_length, sequence_length)`입니다.

  decoder의 cross-attention 레이어에서 attention softmax를 적용한 후, cross-attention 헤드에서 가중 평균을 계산하는 데 사용되는 attention 가중치입니다.
- **encoder_last_hidden_state** (`torch.Tensor`, shape `(batch_size, sequence_length, hidden_size)`, *선택 사항*) -- 모델 인코더의 마지막 레이어 출력의 hidden-state 시퀀스입니다.
- **encoder_hidden_states** (`tuple(torch.Tensor)`, *선택*, `output_hidden_states=True`가 전달되거나 `config.output_hidden_states=True`일 때 반환) -- shape가 `(batch_size, sequence_length, hidden_size)`인 `torch.Tensor`의 튜플 (모델에 임베딩 레이어가 있는 경우 임베딩 출력 1개 + 각 레이어의 출력 1개).

  각 레이어 출력의 인코더 hidden-states와 선택적인 초기 임베딩 출력.
- **encoder_attentions** (`tuple(torch.Tensor)`, *선택 사항*, `output_attentions=True`가 전달되거나 `config.output_attentions=True`인 경우 반환) -- 각 레이어에 하나씩 포함된 `torch.Tensor` 튜플로, shape는 `(batch_size, num_heads, sequence_length, sequence_length)`입니다.

  인코더의 어텐션 가중치입니다. 어텐션 softmax 이후에 self-attention 헤드에서 가중 평균을 계산하는 데 사용됩니다.
- **intermediate_hidden_states** (shape가 `(config.decoder_layers, batch_size, sequence_length, hidden_size)`인 `torch.Tensor`, *선택*, `config.auxiliary_loss=True`일 때 반환) -- 중간 decoder 활성화 값, 즉 각 decoder layer의 출력으로, 각각 layernorm을 거친 것입니다.

예:

```python
>>> from transformers import AutoImageProcessor, DetrModel
>>> from PIL import Image
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> with httpx.stream("GET", url) as response:
...     image = Image.open(BytesIO(response.read()))

>>> image_processor = AutoImageProcessor.from_pretrained("facebook/detr-resnet-50")
>>> model = DetrModel.from_pretrained("facebook/detr-resnet-50")

>>> # prepare image for the model
>>> inputs = image_processor(images=image, return_tensors="pt")

>>> # forward pass
>>> outputs = model(**inputs)

>>> # the last hidden states are the final query embeddings of the Transformer decoder
>>> # these are of shape (batch_size, num_queries, hidden_size)
>>> last_hidden_states = outputs.last_hidden_state
>>> list(last_hidden_states.shape)
[1, 100, 256]
```

## DetrForObjectDetection[[transformers.DetrForObjectDetection]]

#### transformers.DetrForObjectDetection[[transformers.DetrForObjectDetection]]

```python
transformers.DetrForObjectDetection(config: DetrConfig)
```

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/detr/modeling_detr.py#L1309)

**매개변수:**

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

COCO detection과 같은 작업을 위해 객체 탐지 헤드를 최상단에 배치한 DETR 모델(백본과 인코더-디코더 Transformer로 구성).

이 모델은 [PreTrainedModel](/docs/transformers/main/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.DetrForObjectDetection.forward]]

```python
forward(pixel_values: Tensor, pixel_mask: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.Tensor] = None, encoder_outputs: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, decoder_inputs_embeds: typing.Optional[torch.Tensor] = None, labels: list[dict] | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/detr/modeling_detr.py#L1327)

**매개변수:**

pixel_values (`torch.Tensor`, shape `(batch_size, num_channels, image_size, image_size)`) : 입력 이미지에 해당하는 텐서입니다. 픽셀 값은 `image_processor_class`를 사용하여 얻을 수 있습니다. 자세한 내용은 `image_processor_class.__call__`를 참조하세요 (`processor_class`는 이미지 처리에 `image_processor_class`를 사용합니다).

pixel_mask (`torch.LongTensor`, shape `(batch_size, height, width)`, *선택 사항*) : 패딩 픽셀 값에 대한 attention을 수행하지 않도록 하는 마스크. `[0, 1]`에서 선택된 마스크 값: - 실제 픽셀(즉, **마스크되지 않은** 픽셀)은 1, - 패딩 픽셀(즉, **마스크된** 픽셀)은 0. [attention 마스크란?](../glossary#attention-mask)

decoder_attention_mask (`torch.Tensor`, shape `(batch_size, num_queries)`, *선택 사항*) : decoder에서 특정 object query에 attention을 수행하지 않도록 하는 마스크. 마스크 값은 `[0, 1]`에서 선택: - **마스크되지 않은** query는 1, - **마스크된** query는 0.

encoder_outputs (`torch.Tensor`, *선택 사항*) : (`last_hidden_state`, *선택 사항*: `hidden_states`, *선택 사항*: `attentions`) `last_hidden_state`의 shape은 `(batch_size, sequence_length, hidden_size)`, *선택 사항*)이며, 인코더의 마지막 레이어 출력에서 생성된 hidden-states의 시퀀스입니다. 디코더의 cross-attention에 사용됩니다.

inputs_embeds (`torch.Tensor`, shape `(batch_size, sequence_length, hidden_size)`, *선택 사항*) : backbone + projection layer의 출력인 flattened feature map을 전달하는 대신, 이미지의 flattened representation을 직접 전달할 수 있습니다. vision backbone을 우회하는 데 유용합니다.

decoder_inputs_embeds (`torch.Tensor`, shape `(batch_size, num_queries, hidden_size)`, *선택 사항*) : queries를 제로 텐서로 초기화하는 대신, 임베디드 표현을 직접 전달할 수 있습니다. custom query initialization이 필요한 작업에 유용합니다.

labels (`list[Dict]` of len `(batch_size,)`, *optional*) : 이분 매칭 손실을 계산하기 위한 라벨. 딕셔너리의 목록으로, 각 딕셔너리는 최소한 다음 2개의 키를 포함해야 합니다: 'class_labels'와 'boxes' (배치 내 이미지의 클래스 라벨과 바운딩 박스). 클래스 라벨 자체는 len이 `(number of bounding boxes in the image,)`인 `torch.LongTensor`여야 하고, boxes는 shape이 `(number of bounding boxes in the image, 4)`인 `torch.Tensor`여야 합니다.

**반환값:** [DetrObjectDetectionOutput](/docs/transformers/main/ko/model_doc/detr#transformers.models.detr.modeling_detr.DetrObjectDetectionOutput) 또는 `tuple(torch.Tensor)`

[DetrObjectDetectionOutput](/docs/transformers/main/ko/model_doc/detr#transformers.models.detr.modeling_detr.DetrObjectDetectionOutput) 또는 `torch.Tensor`의 튜플(`return_dict=False`이 전달되었거나 `config.return_dict=False`인 경우)로, 설정(`None`)과 입력에 따라 다양한 요소를 포함합니다.

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

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

- **loss** (`torch.Tensor`, 형상 `(1,)`, *선택 사항*, `labels`가 제공될 때 반환)) -- 클래스 예측에 대한 음의 로그 가능도(교차 엔트로피)와 바운딩 박스 손실의 선형 결합으로 계산된 총 손실입니다. 후자는 L1 손실과 일반화된 스케일 불변 IoU 손실의 선형 결합으로 정의됩니다.
- **loss_dict** (`Dict`, *선택 사항*) -- 개별 손실 값을 포함하는 사전입니다. 로깅에 유용합니다.
- **logits** (`torch.Tensor`, shape `(batch_size, num_queries, num_classes + 1)`) -- 모든 query에 대한 분류 logits(no-object 포함).
- **pred_boxes** (`torch.Tensor`, shape `(batch_size, num_queries, 4)`) -- 모든 쿼리에 대한 정규화된 박스 좌표로, (center_x, center_y, width, height) 형식으로 표현됩니다. 이 값들은 [0, 1] 범위로 정규화되며, 배치의 각 개별 이미지의 크기에 상대적입니다(가능한 패딩은 무시합니다). 정규화되지 않은 바운딩 박스를 가져오려면 [post_process_object_detection()](/docs/transformers/main/ko/model_doc/detr#transformers.DetrImageProcessor.post_process_object_detection)을 사용할 수 있습니다.
- **auxiliary_outputs** (`list[Dict]`, *선택*) -- 선택 사항이며, 보조 손실이 활성화된 경우(즉, `config.auxiliary_loss`가 `True`로 설정된 경우)와 라벨이 제공된 경우에만 반환됩니다. 각 디코더 레이어에 대해 위의 두 키(`logits`와 `pred_boxes`)를 포함하는 사전의 목록입니다.
- **last_hidden_state** (`torch.Tensor`, shape `(batch_size, sequence_length, hidden_size)`, *선택 사항*) -- 모델의 decoder 마지막 레이어 출력의 hidden-state 시퀀스입니다.
- **decoder_hidden_states** (`tuple[torch.Tensor]`, *선택*, `output_hidden_states=True`가 전달되거나 `config.output_hidden_states=True`인 경우 반환) -- shape가 `(batch_size, sequence_length, hidden_size)`인 `torch.Tensor`의 튜플 (모델에 임베딩 레이어가 있는 경우 임베딩 출력 1개 + 각 레이어의 출력 1개).

  각 레이어의 출력에서 디코더의 Hidden-states와 초기 임베딩 출력을 더한 값.
- **decoder_attentions** (`tuple[torch.Tensor]`, *선택 사항*, `output_attentions=True`가 전달되거나 `config.output_attentions=True`인 경우 반환) -- 각 레이어에 하나씩, shape가 `(batch_size, num_heads, sequence_length, sequence_length)`인 `torch.Tensor` 튜플.

  self-attention 헤드에서 가중 평균을 계산하는 데 사용되는, attention softmax 이후의 decoder의 attention 가중치입니다.
- **cross_attentions** (`tuple[torch.Tensor]`, *선택*, `output_attentions=True`가 전달되거나 `config.output_attentions=True`일 때 반환) -- 각 레이어마다 하나씩 포함된 `torch.Tensor`의 튜플로, shape는 `(batch_size, num_heads, sequence_length, sequence_length)`입니다.

  decoder의 cross-attention 레이어에서 attention softmax를 적용한 후, cross-attention 헤드에서 가중 평균을 계산하는 데 사용되는 attention 가중치입니다.
- **encoder_last_hidden_state** (`torch.Tensor`, shape `(batch_size, sequence_length, hidden_size)`, *선택 사항*) -- 모델 인코더의 마지막 레이어 출력의 hidden-state 시퀀스입니다.
- **encoder_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와 초기 임베딩 출력을 더한 값.
- **encoder_attentions** (`tuple[torch.Tensor]`, *선택*, `output_attentions=True`가 전달되었거나 `config.output_attentions=True`인 경우 반환) -- 각 레이어에 하나씩 포함된 `torch.Tensor` 튜플이며, shape은 `(batch_size, num_heads, sequence_length, sequence_length)`입니다.

  인코더의 어텐션 가중치입니다. 어텐션 softmax 이후에 self-attention 헤드에서 가중 평균을 계산하는 데 사용됩니다.

예:

```python
>>> from transformers import AutoImageProcessor, DetrForObjectDetection
>>> import torch
>>> from PIL import Image
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> with httpx.stream("GET", url) as response:
...     image = Image.open(BytesIO(response.read()))

>>> image_processor = AutoImageProcessor.from_pretrained("facebook/detr-resnet-50")
>>> model = DetrForObjectDetection.from_pretrained("facebook/detr-resnet-50")

>>> inputs = image_processor(images=image, return_tensors="pt")
>>> outputs = model(**inputs)

>>> # convert outputs (bounding boxes and class logits) to Pascal VOC format (xmin, ymin, xmax, ymax)
>>> target_sizes = torch.tensor([image.size[::-1]])
>>> results = image_processor.post_process_object_detection(outputs, threshold=0.9, target_sizes=target_sizes)[
...     0
... ]

>>> for score, label, box in zip(results["scores"], results["labels"], results["boxes"]):
...     box = [round(i, 2) for i in box.tolist()]
...     print(
...         f"Detected {model.config.id2label[label.item()]} with confidence "
...         f"{round(score.item(), 3)} at location {box}"
...     )
Detected remote with confidence 0.998 at location [40.16, 70.81, 175.55, 117.98]
Detected remote with confidence 0.996 at location [333.24, 72.55, 368.33, 187.66]
Detected couch with confidence 0.995 at location [-0.02, 1.15, 639.73, 473.76]
Detected cat with confidence 0.999 at location [13.24, 52.05, 314.02, 470.93]
Detected cat with confidence 0.999 at location [345.4, 23.85, 640.37, 368.72]
```

## DetrForSegmentation[[transformers.DetrForSegmentation]]

#### transformers.DetrForSegmentation[[transformers.DetrForSegmentation]]

```python
transformers.DetrForSegmentation(config: DetrConfig)
```

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/detr/modeling_detr.py#L1441)

**매개변수:**

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

COCO panoptic와 같은 작업을 위해, 백본과 인코더-디코더 Transformer로 구성된 DETR Model 위에 분할 헤드를 결합한 모델

이 모델은 [PreTrainedModel](/docs/transformers/main/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.DetrForSegmentation.forward]]

```python
forward(pixel_values: Tensor, pixel_mask: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.Tensor] = None, encoder_outputs: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, decoder_inputs_embeds: typing.Optional[torch.Tensor] = None, labels: list[dict] | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[소스](https://github.com/huggingface/transformers/blob/main/src/transformers/models/detr/modeling_detr.py#L1463)

**매개변수:**

pixel_values (`torch.Tensor`, shape `(batch_size, num_channels, image_size, image_size)`) : 입력 이미지에 해당하는 텐서입니다. 픽셀 값은 `image_processor_class`를 사용하여 얻을 수 있습니다. 자세한 내용은 `image_processor_class.__call__`를 참조하세요 (`processor_class`는 이미지 처리에 `image_processor_class`를 사용합니다).

pixel_mask (`torch.LongTensor`, shape `(batch_size, height, width)`, *선택 사항*) : 패딩 픽셀 값에 대한 attention을 수행하지 않도록 하는 마스크. `[0, 1]`에서 선택된 마스크 값: - 실제 픽셀(즉, **마스크되지 않은** 픽셀)은 1, - 패딩 픽셀(즉, **마스크된** 픽셀)은 0. [attention 마스크란?](../glossary#attention-mask)

decoder_attention_mask (`torch.Tensor`, shape `(batch_size, num_queries)`, *선택 사항*) : decoder에서 특정 object query에 attention을 수행하지 않도록 하는 마스크. 마스크 값은 `[0, 1]`에서 선택: - **마스크되지 않은** query는 1, - **마스크된** query는 0.

encoder_outputs (`torch.Tensor`, *선택 사항*) : (`last_hidden_state`, *선택 사항*: `hidden_states`, *선택 사항*: `attentions`) `last_hidden_state`의 shape은 `(batch_size, sequence_length, hidden_size)`, *선택 사항*)이며, 인코더의 마지막 레이어 출력에서 생성된 hidden-states의 시퀀스입니다. 디코더의 cross-attention에 사용됩니다.

inputs_embeds (`torch.Tensor`, shape `(batch_size, sequence_length, hidden_size)`, *선택*) : 하위 호환성을 위해 유지되었지만, segmentation에는 사용할 수 없습니다. segmentation은 backbone에서 제공하는 다중 스케일 특징이 필요하며, inputs_embeds를 사용하여 backbone을 우회할 경우 이러한 특징을 사용할 수 없기 때문입니다.

decoder_inputs_embeds (`torch.Tensor`, shape `(batch_size, num_queries, hidden_size)`, *선택 사항*) : queries를 제로 텐서로 초기화하는 대신, 임베디드 표현을 직접 전달할 수 있습니다. custom query initialization이 필요한 작업에 유용합니다.

labels (`list[Dict]` of len `(batch_size,)`, *optional*) : bipartite matching loss, DICE/F-1 loss, Focal loss를 계산하는 데 사용되는 라벨입니다. 각 딕셔너리가 최소한 다음 3개의 키('class_labels', 'boxes', 'masks')를 포함하는 딕셔너리 목록입니다(각각 배치 내 이미지의 클래스 라벨, 바운딩 박스, 세그멘테이션 마스크를 나타냅니다). 클래스 라벨 자체는 len `(number of bounding boxes in the image,)`인 `torch.LongTensor`여야 하며, boxes는 shape `(number of bounding boxes in the image, 4)`인 `torch.Tensor`여야 하고, masks는 shape `(number of bounding boxes in the image, height, width)`인 `torch.Tensor`여야 합니다.

**반환값:** [DetrSegmentationOutput](/docs/transformers/main/ko/model_doc/detr#transformers.models.detr.modeling_detr.DetrSegmentationOutput) 또는 `tuple(torch.Tensor)`

[DetrSegmentationOutput](/docs/transformers/main/ko/model_doc/detr#transformers.models.detr.modeling_detr.DetrSegmentationOutput) 또는 `torch.Tensor`의 튜플(`return_dict=False`이 전달되었거나 `config.return_dict=False`인 경우)로, 설정(`None`)과 입력에 따라 다양한 요소를 포함합니다.

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

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

- **loss** (`torch.Tensor`, 형상 `(1,)`, *선택 사항*, `labels`가 제공될 때 반환)) -- 클래스 예측에 대한 음의 로그 가능도(교차 엔트로피)와 바운딩 박스 손실의 선형 결합으로 계산된 총 손실입니다. 후자는 L1 손실과 일반화된 스케일 불변 IoU 손실의 선형 결합으로 정의됩니다.
- **loss_dict** (`Dict`, *선택 사항*) -- 개별 손실 값을 포함하는 사전입니다. 로깅에 유용합니다.
- **logits** (`torch.Tensor`, shape `(batch_size, num_queries, num_classes + 1)`) -- 모든 query에 대한 분류 logits(no-object 포함).
- **pred_boxes** (`torch.Tensor`, shape `(batch_size, num_queries, 4)`) -- 모든 쿼리에 대한 정규화된 박스 좌표로, (center_x, center_y, width, height) 형식으로 표현됩니다. 이 값들은 [0, 1] 범위로 정규화되며, 배치의 각 개별 이미지의 크기에 상대적입니다(가능한 패딩은 무시합니다). 정규화되지 않은 바운딩 박스를 가져오려면 [post_process_object_detection()](/docs/transformers/main/ko/model_doc/detr#transformers.DetrImageProcessor.post_process_object_detection)를 사용할 수 있습니다.
- **pred_masks** (`torch.Tensor`, shape `(batch_size, num_queries, height/4, width/4)`) -- 모든 쿼리에 대한 분할 마스크 로짓입니다. [post_process_semantic_segmentation()](/docs/transformers/main/ko/model_doc/detr#transformers.DetrImageProcessor.post_process_semantic_segmentation) 또는 [post_process_instance_segmentation()](/docs/transformers/main/ko/model_doc/detr#transformers.DetrImageProcessor.post_process_instance_segmentation), [post_process_panoptic_segmentation()](/docs/transformers/main/ko/model_doc/detr#transformers.DetrImageProcessor.post_process_panoptic_segmentation)을(를) 각각 참조하여 의미론적, 인스턴스, 팬옵틱 분할 마스크를 평가할 수 있습니다.
- **auxiliary_outputs** (`list[Dict]`, *선택*) -- 선택 사항이며, 보조 손실이 활성화된 경우(즉, `config.auxiliary_loss`가 `True`로 설정된 경우)와 라벨이 제공된 경우에만 반환됩니다. 각 디코더 레이어에 대해 위의 두 키(`logits`와 `pred_boxes`)를 포함하는 사전의 목록입니다.
- **last_hidden_state** (`torch.Tensor`, shape `(batch_size, sequence_length, hidden_size)`, *선택 사항*) -- 모델의 decoder 마지막 레이어 출력의 hidden-state 시퀀스입니다.
- **decoder_hidden_states** (`tuple[torch.Tensor]`, *선택*, `output_hidden_states=True`가 전달되거나 `config.output_hidden_states=True`인 경우 반환) -- shape가 `(batch_size, sequence_length, hidden_size)`인 `torch.Tensor`의 튜플 (모델에 임베딩 레이어가 있는 경우 임베딩 출력 1개 + 각 레이어의 출력 1개).

  각 레이어의 출력에서 디코더의 Hidden-states와 초기 임베딩 출력을 더한 값.
- **decoder_attentions** (`tuple[torch.Tensor]`, *선택 사항*, `output_attentions=True`가 전달되거나 `config.output_attentions=True`인 경우 반환) -- 각 레이어에 하나씩, shape가 `(batch_size, num_heads, sequence_length, sequence_length)`인 `torch.Tensor` 튜플.

  self-attention 헤드에서 가중 평균을 계산하는 데 사용되는, attention softmax 이후의 decoder의 attention 가중치입니다.
- **cross_attentions** (`tuple[torch.Tensor]`, *선택*, `output_attentions=True`가 전달되거나 `config.output_attentions=True`일 때 반환) -- 각 레이어마다 하나씩 포함된 `torch.Tensor`의 튜플로, shape는 `(batch_size, num_heads, sequence_length, sequence_length)`입니다.

  decoder의 cross-attention 레이어에서 attention softmax를 적용한 후, cross-attention 헤드에서 가중 평균을 계산하는 데 사용되는 attention 가중치입니다.
- **encoder_last_hidden_state** (`torch.Tensor`, shape `(batch_size, sequence_length, hidden_size)`, *선택 사항*) -- 모델 인코더의 마지막 레이어 출력의 hidden-state 시퀀스입니다.
- **encoder_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와 초기 임베딩 출력을 더한 값.
- **encoder_attentions** (`tuple[torch.Tensor]`, *선택*, `output_attentions=True`가 전달되었거나 `config.output_attentions=True`인 경우 반환) -- 각 레이어에 하나씩 포함된 `torch.Tensor` 튜플이며, shape은 `(batch_size, num_heads, sequence_length, sequence_length)`입니다.

  인코더의 어텐션 가중치입니다. 어텐션 softmax 이후에 self-attention 헤드에서 가중 평균을 계산하는 데 사용됩니다.

예:

```python
>>> import io
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO
>>> from PIL import Image
>>> import torch
>>> import numpy

>>> from transformers import AutoImageProcessor, DetrForSegmentation
>>> from transformers.image_transforms import rgb_to_id

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> with httpx.stream("GET", url) as response:
...     image = Image.open(BytesIO(response.read()))

>>> image_processor = AutoImageProcessor.from_pretrained("facebook/detr-resnet-50-panoptic")
>>> model = DetrForSegmentation.from_pretrained("facebook/detr-resnet-50-panoptic")

>>> # prepare image for the model
>>> inputs = image_processor(images=image, return_tensors="pt")

>>> # forward pass
>>> outputs = model(**inputs)

>>> # Use the `post_process_panoptic_segmentation` method of the `image_processor` to retrieve post-processed panoptic segmentation maps
>>> # Segmentation results are returned as a list of dictionaries
>>> result = image_processor.post_process_panoptic_segmentation(outputs, target_sizes=[(300, 500)])

>>> # A tensor of shape (height, width) where each value denotes a segment id, filled with -1 if no segment is found
>>> panoptic_seg = result[0]["segmentation"]
>>> panoptic_seg.shape
torch.Size([300, 500])
>>> # Get prediction score and segment_id to class_id mapping of each segment
>>> panoptic_segments_info = result[0]["segments_info"]
>>> len(panoptic_segments_info)
5
```