# DETR

[DETR](https://huggingface.co/papers/2005.12872)は、畳み込みバックボーンにエンコーダー・デコーダー型 Transformer を接続した構成で、オブジェクト検出をエンドツーエンドで学習できます。Faster-R-CNN や Mask-R-CNN のようなモデルは、リージョン提案、非最大値抑制、アンカー生成などの複雑な要素を含んでいますが、DETR はこれらを大幅に簡素化します。さらに、デコーダーの出力上にマスクヘッドを付加するだけで、パノプティックセグメンテーションにも自然に拡張できます。

すべてのオリジナルの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/v5.23.0/ja/main_classes/model#transformers.PreTrainedModel.from_pretrained) に設定すると、対応するレイヤーが Hub からの最適化されたカーネルに置き換えられます。詳細は [カーネルの読み込み](../kernel_doc/loading_kernels) を参照してください。

以下の例では、[Pipeline](/docs/transformers/v5.23.0/ja/main_classes/pipelines#transformers.Pipeline)または[AutoModel](/docs/transformers/v5.23.0/ja/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/v5.23.0/ja/model_doc/detr#transformers.DetrForObjectDetection) の動作を要約すると、以下のようになります。

まず、画像は事前学習済みの畳み込みバックボーン（論文では著者がResNet-50/ResNet-101を使用）に送られます。ここでは、バッチ次元も追加すると仮定します。つまり、画像が3つのカラーチャネル（RGB）を持つと仮定すると、バックボーンへの入力は`(batch_size, 3, height, width)`の形状のテンソルになります。CNNバックボーンは、通常`(batch_size, 2048, height/32, width/32)`の形状の、より低い解像度の新しい特徴マップを出力します。これは、`nn.Conv2D`層を使用して、DETRのTransformerの隠れ次元（デフォルトでは`256`）に一致するように射影されます。したがって、現在`(batch_size, 256, height/32, width/32).`の形状のテンソルを持っています。次に、特徴マップをフラット化して転置し、`(batch_size, seq_len, d_model)` = `(batch_size, width/32*height/32, 256)`の形状のテンソルを取得します。したがって、NLPモデルとの違いとして、シーケンス長は通常より長くなりますが、`d_model`は小さくなります（NLPでは通常768以上です）。

次に、エンコーダーに送信され、同じ形状の`encoder_hidden_states`が出力されます（これらは画像の特徴量とみなすことができます）。次に、いわゆる**オブジェクトクエリ**がデコーダーに送信されます。これは形状`(batch_size, num_queries, d_model)`のテンソルで、`num_queries`は通常100に設定され、ゼロで初期化されます。これらの入力埋め込みは、著者がオブジェクトクエリと呼んでいる学習された位置エンコーディングであり、エンコーダーと同様に、各アテンション層の入力に追加されます。各オブジェクトクエリは、画像内の特定のオブジェクトを探します。デコーダーは、複数の自己アテンション層とエンコーダー-デコーダーアテンション層を通じてこれらの埋め込みを更新し、同じ形状の`decoder_hidden_states`を出力します：`(batch_size, num_queries, d_model)`。次に、オブジェクト検出のために2つのヘッドが上に追加されます。1つは、各オブジェクトクエリをオブジェクトのいずれかまたは「オブジェクトなし」に分類するための線形層、もう1つは、各クエリに対するバウンディングボックスを予測するためのMLPです。

モデルは**二部マッチング損失**を用いて学習されます。具体的には、N = 100 のオブジェクトクエリそれぞれについて、予測されたクラスとバウンディングボックスを、同じ長さ N にパディングされた正解アノテーションと比較します（画像に4つのオブジェクトしか含まれない場合、残り96件のアノテーションはクラスが「オブジェクトなし」、バウンディングボックスが「バウンディングボックスなし」となります）。[ハンガリアンマッチングアルゴリズム](https://en.wikipedia.org/wiki/Hungarian_algorithm)を用いて、N 個のクエリと N 個のアノテーションの間の最適な 1 対 1 の対応付けを見つけます。その後、クラスについては標準的なクロスエントロピー、バウンディングボックスについては L1 と[汎化 IoU 損失](https://giou.stanford.edu/)の線形結合を用いて、モデルのパラメータを最適化します。

DETRは、パノプティックセグメンテーション（セマンティックセグメンテーションとインスタンスセグメンテーションを統合する手法）を実行するように自然に拡張できます。[DetrForSegmentation](/docs/transformers/v5.23.0/ja/model_doc/detr#transformers.DetrForSegmentation)は、[DetrForObjectDetection](/docs/transformers/v5.23.0/ja/model_doc/detr#transformers.DetrForObjectDetection)の上にセグメンテーションマスクヘッドを追加します。マスクヘッドは、単一のプロセスで共同学習するか、2段階のプロセスで学習できます。2段階のプロセスでは、まず「things」（インスタンス）と「stuff」（木々、道路、空などの背景物）の両方の周りにバウンディングボックスを検出するように[DetrForObjectDetection](/docs/transformers/v5.23.0/ja/model_doc/detr#transformers.DetrForObjectDetection)モデルを訓練し、その後、すべての重みを凍結してマスクヘッドのみを25エポック訓練します。実験的に、これらの2つのアプローチは類似した結果をもたらします。ハンガリーマッチングはボックス間の距離を使用して計算されるため、ボックスの予測が訓練を可能にするために必要であることに注意してください。

## 注記

- DETR は、いわゆる**オブジェクトクエリ**を使用して画像内のオブジェクトを検出します。クエリの数は、1枚の画像で検出できるオブジェクトの最大数を決定し、デフォルトでは 100 に設定されています（[DetrConfig](/docs/transformers/v5.23.0/ja/model_doc/detr#transformers.DetrConfig)のパラメータ`num_queries`を参照）。なお、ある程度の余裕を持たせることが望ましいです（COCO では、著者が 100 を使用しましたが、COCO 画像におけるオブジェクトの最大数は約 70 です）。
- DETRのデコーダーは、クエリ埋め込みを並列に更新します。これは、GPT-2のような言語モデルとは異なり、それらは並列ではなく自己回帰デコーディングを使用します。したがって、因果的アテンションマスクは使用されません。
- DETR は、クエリとキーへ射影する前に、各自己注意層と相互注意層の隠れ状態に位置埋め込みを加えます。画像の位置埋め込みについては、固定の正弦波型または学習された絶対位置埋め込みのいずれかを選択できます。デフォルトでは、[DetrConfig](/docs/transformers/v5.23.0/ja/model_doc/detr#transformers.DetrConfig) のパラメータ `position_embedding_type` は `"sine"` に設定されています。
- 学習中、DETR の著者らは、特に各クラスの正しい数のオブジェクトをモデルが出力するのを助けるために、デコーダーで補助損失を使用することが有効であることを発見しました。[DetrConfig](/docs/transformers/v5.23.0/ja/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/v5.23.0/ja/model_doc/detr#transformers.DetrForObjectDetection) と [DetrForSegmentation](/docs/transformers/v5.23.0/ja/model_doc/detr#transformers.DetrForSegmentation) は、[timm library](https://github.com/rwightman/pytorch-image-models) で利用可能な任意の畳み込みバックボーンで初期化できます。例えば、MobileNet バックボーンで初期化するには、[DetrConfig](/docs/transformers/v5.23.0/ja/model_doc/detr#transformers.DetrConfig) の `backbone` 属性を `"tf_mobilenetv3_small_075"` に設定し、その設定でモデルを初期化します。
- DETRは、最短辺が一定のピクセル数以上、かつ最長辺が1333ピクセル以下になるように入力画像をリサイズします。学習時にはスケール拡張が使用され、最短辺は480ピクセル以上800ピクセル以下の範囲でランダムに設定されます。推論時には、最短辺は800ピクセルに設定されます。[DetrImageProcessor](/docs/transformers/v5.23.0/ja/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モデルをインスタンス化するには、以下の3つの方法があります（お好みの方法をお選びください）：

- オプション1: 事前学習済み重みを使用して、モデル全体をDETRとしてインスタンス化

```python
from transformers import DetrForObjectDetection

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

- オプション2: Transformerにはランダム初期化された重みを、バックボーンには事前学習済み重みを設定してDETRをインスタンス化

```python
from transformers import DetrConfig, DetrForObjectDetection

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

- オプション3: バックボーンとTransformerの重みをランダム初期化してDETRをインスタンス化

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

まとめとして、以下の表を参照してください。

| タスク | オブジェクト検出 | インスタンスセグメンテーション | パンセグメンテーション |
|------|------------------|-----------------------|-----------------------|
| **説明** | 画像内のオブジェクトの周囲にバウンディングボックスとクラスラベルを予測します | 画像内のオブジェクト（つまりインスタンス）の周囲のマスクを予測する | 画像内の両方のオブジェクト（つまりインスタンス）および「stuff」（つまり木や道路などの背景の物体）の周囲のマスクを予測します |
| **モデル** | [DetrForObjectDetection](/docs/transformers/v5.23.0/ja/model_doc/detr#transformers.DetrForObjectDetection) | [DetrForSegmentation](/docs/transformers/v5.23.0/ja/model_doc/detr#transformers.DetrForSegmentation) | [DetrForSegmentation](/docs/transformers/v5.23.0/ja/model_doc/detr#transformers.DetrForSegmentation) |
| **データセットの例** | COCO検出 | COCO検出、COCOパンノミック | COCO パノプティック                           |
| **に渡すアノテーションの形式**  [DetrImageProcessor](/docs/transformers/v5.23.0/ja/model_doc/detr#transformers.DetrImageProcessor) | {'image_id': `int`, 'annotations': `list[Dict]`} 各 Dict は COCO オブジェクトアノテーションです  | {'image_id': `int`, 'annotations': `list[Dict]`}（COCO 検出の場合）または {'file_name': `str`, 'image_id': `int`, 'segments_info': `list[Dict]`}（COCO パノプティックの場合） | {'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/v5.23.0/ja/model_doc/detr#transformers.DetrImageProcessor) を使用して `pixel_values`、`pixel_mask` および任意の `labels` を作成します。これらはモデルの学習（またはファインチューニング）に使用できます。
- 評価を行うには、まず[DetrImageProcessor](/docs/transformers/v5.23.0/ja/model_doc/detr#transformers.DetrImageProcessor)のポストプロセッシングメソッドのいずれかを使用して、モデルの出力を変換する必要があります。変換後の出力は、`CocoEvaluator`または`PanopticEvaluator`に渡すことができ、これらを用いて平均平均精度（mAP）やPanoptic Quality（PQ）などのメトリクスを計算できます。後者のオブジェクトは[元のリポジトリ](https://github.com/facebookresearch/detr)に実装されています。評価に関する詳細は、[サンプルノートブック](https://github.com/NielsRogge/Transformers-Tutorials/tree/master/DETR)を参照してください。

## リソース

- カスタムデータセットで[DetrForObjectDetection](/docs/transformers/v5.23.0/ja/model_doc/detr#transformers.DetrForObjectDetection)および[DetrForSegmentation](/docs/transformers/v5.23.0/ja/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/v5.23.0/src/transformers/models/detr/configuration_detr.py#L25)

**パラメータ:**

is_encoder_decoder (`bool`、*任意*、デフォルトは`True`) : モデルがエンコーダー/デコーダーとして使用されるかどうかを示します。

backbone_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`、*optional*) : バックボーンモデルの設定です。

num_channels (`int`、*任意*、デフォルトは`3`) : 入力チャネル数。

num_queries (`int`、*optional*、デフォルトは 100) : オブジェクトクエリ数、すなわち検出スロットの数です。これは、[ConditionalDetrModel](/docs/transformers/v5.23.0/ja/model_doc/conditional_detr#transformers.ConditionalDetrModel) が 1 枚の画像内で検出できるオブジェクトの最大数を示します。COCO の場合は、100 クエリを推奨します。

encoder_layers (`int`、*任意*、デフォルトは`6`) : Transformerエンコーダーの隠れ層の数。設定されていない場合は、`num_layers`と同じ値が使用されます。

encoder_ffn_dim (`int`、*optional*、デフォルトは`2048`) : エンコーダー内の「intermediate」（feed-forward とも呼ばれる）層の次元数。

encoder_attention_heads (`int`、*optional*、デフォルトは`8`) : Transformer エンコーダーの各アテンション層におけるアテンションヘッドの数。

decoder_layers (`int`、*任意*、デフォルトは`6`) : Transformer デコーダーの隠れ層の数。設定されていない場合は、`num_layers` と同じ値が使用されます。

decoder_ffn_dim (`int`、*任意*、デフォルトは `2048`) : デコーダー内の「intermediate」（feed-forward と呼ばれることが多い）層の次元数。

decoder_attention_heads (`int`、*任意*、デフォルトは `8`) : Transformer デコーダーの各アテンション層におけるアテンションヘッドの数。

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`) : 注意確率のドロップアウト率。

activation_dropout (`Union[float, int]`、*任意*、デフォルトは`0.0`) : 全結合層内の活性化に対する dropout 率。

init_std (`float`、*任意*、デフォルトは`0.02`) : すべての重み行列を初期化するためのtruncated_normal_initializerの標準偏差です。

init_xavier_std (`float`、*任意*、デフォルトは `1.0`) : クロスアテンションの重みの 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`, *optional*, デフォルトは `1`) : ハンガリアンマッチングのコストにおける分類誤差の相対的な重み。

bbox_cost (`int`、*任意*、デフォルトは`5`) : ハンガリアンマッチングのコストにおける、L1バウンディングボックス誤差の相対的な重み。

giou_cost (`int`, *optional*, デフォルトは `2`) : ハンガリアンマッチングのコストにおける汎化 IoU ロスの相対的な重み。

mask_loss_coefficient (`int`, *optional*, デフォルトは `1`) : パノプティックセグメンテーション損失における focal loss の相対的な重み。

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) と同様の設定が得られます。

設定オブジェクトは [PreTrainedConfig](/docs/transformers/v5.23.0/ja/main_classes/configuration#transformers.PreTrainedConfig) を継承し、モデルの出力を制御するために使用できます。詳細については、[PreTrainedConfig](/docs/transformers/v5.23.0/ja/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/v5.23.0/src/transformers/models/detr/image_processing_detr.py#L426)

**パラメータ:**

do_convert_rgb (`bool`, *kwargs*, *optional*) : 画像を 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*, *optional*, デフォルトは `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`のいずれかになります。`do_resize`が`True`に設定されている場合のみ、効果が現れます。

do_rescale (`bool`, *kwargs*, *optional*, デフォルトは `True`) : 画像をリスケールするかどうか。

rescale_factor (`float`, *kwargs*, *optional*, デフォルトは `0.00392156862745098`) : `do_rescale` が `True` に設定されている場合、画像をリスケールするための係数。

do_normalize (`bool`, *kwargs*, *optional*, デフォルトは `True`) : 画像を正規化するかどうかを指定します。

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *optional*, デフォルトは `[0.485, 0.456, 0.406]`) : 正規化に使用する画像の平均値です。`do_normalize` が `True` に設定されている場合のみ有効です。

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *optional*, デフォルトは `[0.229, 0.224, 0.225]`) : 正規化に使用する画像の標準偏差。`do_normalize` が `True` に設定されている場合のみ有効です。

do_pad (`bool`, *kwargs*, *optional*, デフォルトは `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*, *optional*) : 画像を中央クロップするかどうか。

data_format (`Union[str, ~image_utils.ChannelDimension]`、*kwargs*、*optional*) : 対応するのは `ChannelDimension.FIRST` のみです。slow processors との互換性のために追加されました。

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*, *optional*) : 画像をサイズごとにグループ化してバッチ処理するのではなく、個別に処理するためにグループ化を無効にするかどうかを指定します。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*, *optional*, デフォルトは `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/v5.23.0/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*, *optional*) : 画像を RGB に変換するかどうか。

do_resize (`bool`, *kwargs*, *optional*) : 画像をリサイズするかどうか。

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : モデルへの最大入力次元を記述します。

default_to_square (`bool`, *kwargs*, *optional*) : 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` の列挙型のいずれかです。`do_resize` が `True` に設定されている場合のみ有効です。

do_rescale (`bool`, *kwargs*, *任意*) : 画像をリスケールするかどうか。

rescale_factor (`float`, *kwargs*, *optional*) : `do_rescale` が `True` に設定されている場合、画像をリサイズするためのリスケール係数。

do_normalize (`bool`, *kwargs*, *optional*) : 画像を正規化するかどうかを指定します。

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *optional*) : 正規化に使用する画像の平均値。`do_normalize` が `True` に設定されている場合のみ有効です。

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *optional*) : 正規化に使用する画像の標準偏差。`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*, *optional*) : 画像を中央クロップするかどうか。

data_format (`Union[str, ~image_utils.ChannelDimension]`、*kwargs*、*optional*) : 対応するのは `ChannelDimension.FIRST` のみです。slow processors との互換性のために追加されました。

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*, *optional*) : 画像をサイズごとにグループ化してバッチ処理するのではなく、個別に処理するためにグループ化を無効にするかどうかを指定します。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*, *optional*, デフォルトは `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 内の整数リストを変換するために、ここで 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/v5.23.0/src/transformers/models/detr/image_processing_detr.py#L823)

**パラメータ:**

outputs (`DetrObjectDetectionOutput`) : モデルの生出力。

threshold (`float`, *任意*) : オブジェクト検出の予測を保持するためのスコアしきい値。

target_sizes (`torch.Tensor` または `list[tuple[int, int]]`、*任意*) : 形状が `(batch_size, 2)` の Tensor、またはバッチ内の各画像のターゲットサイズ `(height, width)` を含むタプルのリスト (`tuple[int, int]`)。未設定の場合、予測結果はリサイズされません。

**戻り値:** `list[Dict]`

モデルが予測した、バッチ内の各画像のスコア、ラベル、ボックスをそれぞれ含む辞書のリスト。

[DetrForObjectDetection](/docs/transformers/v5.23.0/ja/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/v5.23.0/src/transformers/models/detr/image_processing_detr.py#L876)

**パラメータ:**

outputs ([DetrForSegmentation](/docs/transformers/v5.23.0/ja/model_doc/detr#transformers.DetrForSegmentation)) : モデルの生出力。

target_sizes (`list[tuple[int, int]]`, *任意*) : バッチ内の各画像のターゲットサイズ（高さ、幅）を含むタプルのリスト（`tuple[int, int]`）。未設定の場合、予測結果はリサイズされません。

return_segmentation_scores (`bool`、*任意*、デフォルトは`False`) : セグメンテーションマップとともにセグメンテーションスコアを返すかどうか。`True`の場合、返されるリストの各要素は、`segmentation`（クラス ID、形状`(height, width)`）と`segmentation_scores`（形状`(num_classes, height, width)`）というフィールドを持つ`SemanticSegmentationPostProcessorOutput`です。

**戻り値:** `list[torch.Tensor]` または `list[SemanticSegmentationPostProcessorOutput]`

`return_segmentation_scores=False` (デフォルト)の場合、長さが`batch_size`のリストが返され、各要素はクラス ID を持つ形状`(height, width)`のセグメンテーションマップです。`return_segmentation_scores=True`の場合、`SemanticSegmentationPostProcessorOutput`のリストが返され、フィールド`segmentation` (クラス ID、形状`(height, width)`)と`segmentation_scores` (形状`(num_classes, height, width)`)を持ちます。どちらの場合も、`(height, width)`はターゲットサイズに対応します(`target_sizes`が指定されている場合)。

[DetrForSegmentation](/docs/transformers/v5.23.0/ja/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/v5.23.0/src/transformers/models/detr/image_processing_detr.py#L947)

**パラメータ:**

outputs ([DetrForSegmentation](/docs/transformers/v5.23.0/ja/model_doc/detr#transformers.DetrForSegmentation)) : モデルの生出力。

threshold (`float`、*任意*、デフォルト値は 0.5) : 予測されたインスタンスマスクを保持するための確率スコアの閾値。

mask_threshold (`float`、*optional*、デフォルト値は 0.5) : 予測されたマスクをバイナリ値に変換する際に使用する閾値。

overlap_mask_area_threshold (`float`、*optional*、デフォルトは 0.8) : 各バイナリインスタンスマスク内の、小さな非連結部分のマージまたは破棄に用いるオーバーラップマスク領域の閾値。

target_sizes (`list[Tuple]`、*任意*) : 長さが (batch_size) のリストです。各リストの要素 (`tuple[int, int]]`) は、各予測の要求される最終サイズ (高さ、幅) に対応します。設定されていない場合、予測はリサイズされません。

return_coco_annotation (`bool`, *任意*) : デフォルト値は `False` です。`True` に設定すると、セグメンテーションマップは COCO のランレングスエンコーディング (RLE) 形式で返されます。

**戻り値:** `list[Dict]`

画像ごとに1つずつの辞書のリストで、各辞書には2つのキーが含まれます:
- **segmentation** -- 各ピクセルが`segment_id`を表す、形状`(height, width)`のテンソル。return_coco_annotationが`True`に設定されている場合は、セグメンテーションマップの`list[List]`形式のランレングス符号化（RLE）になります。`threshold`を超えるマスクが見つからない場合は`None`に設定されます。
- **segments_info** -- 各セグメントに関する追加情報を含む辞書。
  - **id** -- `segment_id`を表す整数。
  - **label_id** -- `segment_id`に対応するラベル/セマンティッククラスIDを表す整数。
  - **score** -- `segment_id`を持つセグメントの予測スコア。

[DetrForSegmentation](/docs/transformers/v5.23.0/ja/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/v5.23.0/src/transformers/models/detr/image_processing_detr.py#L1030)

**パラメータ:**

outputs ([DetrForSegmentation](/docs/transformers/v5.23.0/ja/model_doc/detr#transformers.DetrForSegmentation)) : [DetrForSegmentation](/docs/transformers/v5.23.0/ja/model_doc/detr#transformers.DetrForSegmentation)の出力です。

threshold (`float`、*任意*、デフォルト値は 0.5) : 予測されたインスタンスマスクを保持するための確率スコアの閾値。

mask_threshold (`float`、*optional*、デフォルト値は 0.5) : 予測されたマスクをバイナリ値に変換する際に使用する閾値。

overlap_mask_area_threshold (`float`、*optional*、デフォルトは 0.8) : 各バイナリインスタンスマスク内の、小さな非連結部分のマージまたは破棄に用いるオーバーラップマスク領域の閾値。

label_ids_to_fuse (`Set[int]`, *任意*) : この状態では、ラベルのすべてのインスタンスが融合されます。例えば、画像には空が1つしか存在しませんが、人物は複数存在し得るため、空のラベル ID はそのセットに含まれますが、人物のラベル ID は含まれません。

target_sizes (`list[Tuple]`、*任意*) : 長さ (batch_size) のリストです。各リストの要素 (`tuple[int, int]]`) は、バッチ内の各予測の要求される最終サイズ (高さ、幅) に対応します。設定されていない場合、予測はリサイズされません。

**戻り値:** `list[Dict]`

画像ごとに1つずつの辞書のリストで、各辞書には2つのキーが含まれます:
- **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/v5.23.0/ja/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/v5.23.0/src/transformers/models/detr/image_processing_pil_detr.py#L432)

**パラメータ:**

do_convert_rgb (`bool`, *kwargs*, *optional*) : 画像を 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*, *optional*, デフォルトは `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`のいずれかになります。`do_resize`が`True`に設定されている場合のみ、効果が現れます。

do_rescale (`bool`, *kwargs*, *optional*, デフォルトは `True`) : 画像をリスケールするかどうか。

rescale_factor (`float`, *kwargs*, *optional*, デフォルトは `0.00392156862745098`) : `do_rescale` が `True` に設定されている場合、画像をリスケールするための係数。

do_normalize (`bool`, *kwargs*, *optional*, デフォルトは `True`) : 画像を正規化するかどうかを指定します。

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *optional*, デフォルトは `[0.485, 0.456, 0.406]`) : 正規化に使用する画像の平均値です。`do_normalize` が `True` に設定されている場合のみ有効です。

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *optional*, デフォルトは `[0.229, 0.224, 0.225]`) : 正規化に使用する画像の標準偏差。`do_normalize` が `True` に設定されている場合のみ有効です。

do_pad (`bool`, *kwargs*, *optional*, デフォルトは `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*, *optional*) : 画像を中央クロップするかどうか。

data_format (`Union[str, ~image_utils.ChannelDimension]`、*kwargs*、*optional*) : 対応するのは `ChannelDimension.FIRST` のみです。slow processors との互換性のために追加されました。

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*, *optional*) : 画像をサイズごとにグループ化してバッチ処理するのではなく、個別に処理するためにグループ化を無効にするかどうかを指定します。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*, *optional*, デフォルトは `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/v5.23.0/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*, *optional*) : 画像を RGB に変換するかどうか。

do_resize (`bool`, *kwargs*, *optional*) : 画像をリサイズするかどうか。

size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : モデルへの最大入力次元を記述します。

default_to_square (`bool`, *kwargs*, *optional*) : 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` の列挙型のいずれかです。`do_resize` が `True` に設定されている場合のみ有効です。

do_rescale (`bool`, *kwargs*, *任意*) : 画像をリスケールするかどうか。

rescale_factor (`float`, *kwargs*, *optional*) : `do_rescale` が `True` に設定されている場合、画像をリサイズするためのリスケール係数。

do_normalize (`bool`, *kwargs*, *optional*) : 画像を正規化するかどうかを指定します。

image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *optional*) : 正規化に使用する画像の平均値。`do_normalize` が `True` に設定されている場合のみ有効です。

image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *optional*) : 正規化に使用する画像の標準偏差。`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*, *optional*) : 画像を中央クロップするかどうか。

data_format (`Union[str, ~image_utils.ChannelDimension]`、*kwargs*、*optional*) : 対応するのは `ChannelDimension.FIRST` のみです。slow processors との互換性のために追加されました。

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*, *optional*) : 画像をサイズごとにグループ化してバッチ処理するのではなく、個別に処理するためにグループ化を無効にするかどうかを指定します。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*, *optional*, デフォルトは `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 内の整数リストを変換するために、ここで 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/v5.23.0/src/transformers/models/detr/image_processing_pil_detr.py#L845)

**パラメータ:**

outputs (`DetrObjectDetectionOutput`) : モデルの生出力。

threshold (`float`, *任意*) : オブジェクト検出の予測を保持するためのスコアしきい値。

target_sizes (`torch.Tensor` または `list[tuple[int, int]]`、*任意*) : 形状が `(batch_size, 2)` の Tensor、またはバッチ内の各画像のターゲットサイズ `(height, width)` を含むタプルのリスト (`tuple[int, int]`)。未設定の場合、予測結果はリサイズされません。

**戻り値:** `list[Dict]`

モデルが予測した、バッチ内の各画像のスコア、ラベル、ボックスをそれぞれ含む辞書のリスト。

[DetrForObjectDetection](/docs/transformers/v5.23.0/ja/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/v5.23.0/src/transformers/models/detr/image_processing_pil_detr.py#L899)

**パラメータ:**

outputs ([DetrForSegmentation](/docs/transformers/v5.23.0/ja/model_doc/detr#transformers.DetrForSegmentation)) : モデルの生出力。

target_sizes (`list[tuple[int, int]]`, *任意*) : バッチ内の各画像のターゲットサイズ（高さ、幅）を含むタプルのリスト（`tuple[int, int]`）。未設定の場合、予測結果はリサイズされません。

return_segmentation_scores (`bool`、*任意*、デフォルトは`False`) : セグメンテーションマップとともにセグメンテーションスコアを返すかどうか。`True`の場合、返されるリストの各要素は、`segmentation`（クラス ID、形状`(height, width)`）と`segmentation_scores`（形状`(num_classes, height, width)`）というフィールドを持つ`SemanticSegmentationPostProcessorOutput`です。

**戻り値:** `list[torch.Tensor]` または `list[SemanticSegmentationPostProcessorOutput]`

`return_segmentation_scores=False` (デフォルト)の場合、長さが`batch_size`のリストが返され、各要素はクラス ID を持つ形状`(height, width)`のセグメンテーションマップです。`return_segmentation_scores=True`の場合、`SemanticSegmentationPostProcessorOutput`のリストが返され、フィールド`segmentation` (クラス ID、形状`(height, width)`)と`segmentation_scores` (形状`(num_classes, height, width)`)を持ちます。どちらの場合も、`(height, width)`はターゲットサイズに対応します(`target_sizes`が指定されている場合)。

[DetrForSegmentation](/docs/transformers/v5.23.0/ja/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/v5.23.0/src/transformers/models/detr/image_processing_pil_detr.py#L971)

**パラメータ:**

outputs ([DetrForSegmentation](/docs/transformers/v5.23.0/ja/model_doc/detr#transformers.DetrForSegmentation)) : モデルの生出力。

threshold (`float`、*任意*、デフォルト値は 0.5) : 予測されたインスタンスマスクを保持するための確率スコアの閾値。

mask_threshold (`float`、*optional*、デフォルト値は 0.5) : 予測されたマスクをバイナリ値に変換する際に使用する閾値。

overlap_mask_area_threshold (`float`、*optional*、デフォルトは 0.8) : 各バイナリインスタンスマスク内の、小さな非連結部分のマージまたは破棄に用いるオーバーラップマスク領域の閾値。

target_sizes (`list[Tuple]`、*任意*) : 長さが (batch_size) のリストです。各リストの要素 (`tuple[int, int]]`) は、各予測の要求される最終サイズ (高さ、幅) に対応します。設定されていない場合、予測はリサイズされません。

return_coco_annotation (`bool`, *任意*) : デフォルト値は `False` です。`True` に設定すると、セグメンテーションマップは COCO のランレングスエンコーディング (RLE) 形式で返されます。

**戻り値:** `list[Dict]`

画像ごとに1つずつの辞書のリストで、各辞書には2つのキーが含まれます:
- **segmentation** -- 各ピクセルが`segment_id`を表す、形状`(height, width)`のテンソル。return_coco_annotationが`True`に設定されている場合は、セグメンテーションマップの`list[List]`形式のランレングス符号化（RLE）になります。`threshold`を超えるマスクが見つからない場合は`None`に設定されます。
- **segments_info** -- 各セグメントに関する追加情報を含む辞書。
  - **id** -- `segment_id`を表す整数。
  - **label_id** -- `segment_id`に対応するラベル/セマンティッククラスIDを表す整数。
  - **score** -- `segment_id`を持つセグメントの予測スコア。

[DetrForSegmentation](/docs/transformers/v5.23.0/ja/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/v5.23.0/src/transformers/models/detr/image_processing_pil_detr.py#L1055)

**パラメータ:**

outputs ([DetrForSegmentation](/docs/transformers/v5.23.0/ja/model_doc/detr#transformers.DetrForSegmentation)) : [DetrForSegmentation](/docs/transformers/v5.23.0/ja/model_doc/detr#transformers.DetrForSegmentation)の出力です。

threshold (`float`、*任意*、デフォルト値は 0.5) : 予測されたインスタンスマスクを保持するための確率スコアの閾値。

mask_threshold (`float`、*optional*、デフォルト値は 0.5) : 予測されたマスクをバイナリ値に変換する際に使用する閾値。

overlap_mask_area_threshold (`float`、*optional*、デフォルトは 0.8) : 各バイナリインスタンスマスク内の、小さな非連結部分のマージまたは破棄に用いるオーバーラップマスク領域の閾値。

label_ids_to_fuse (`Set[int]`, *任意*) : この状態では、ラベルのすべてのインスタンスが融合されます。例えば、画像には空が1つしか存在しませんが、人物は複数存在し得るため、空のラベル ID はそのセットに含まれますが、人物のラベル ID は含まれません。

target_sizes (`list[Tuple]`、*任意*) : 長さ (batch_size) のリストです。各リストの要素 (`tuple[int, int]]`) は、バッチ内の各予測の要求される最終サイズ (高さ、幅) に対応します。設定されていない場合、予測はリサイズされません。

**戻り値:** `list[Dict]`

画像ごとに1つずつの辞書のリストで、各辞書には2つのキーが含まれます:
- **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/v5.23.0/ja/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/v5.23.0/src/transformers/models/detr/modeling_detr.py#L76)

**パラメータ:**

last_hidden_state (`torch.Tensor`、shape `(batch_size, sequence_length, hidden_size)`) : モデルのデコーダーの最終層の出力における、hidden-states のシーケンスです。 `past_key_values` が使用されている場合、シーケンスの最後の hidden-state のみ、shape `(batch_size, 1, hidden_size)` で出力されます。

past_key_values (`EncoderDecoderCache`、*任意*、`use_cache=True` が渡された場合または `config.use_cache=True` の場合に返されます) : [EncoderDecoderCache](/docs/transformers/v5.23.0/ja/internal/generation_utils#transformers.EncoderDecoderCache) のインスタンスです。詳細については、[kv cache ガイド](https://huggingface.co/docs/transformers/en/kv_cache)を参照してください。 逐次デコーディングを高速化するために使用できる（`past_key_values` 入力参照）、事前計算された hidden-states（self-attention ブロックおよび cross-attention ブロックの key と value）が含まれます。

decoder_hidden_states (`tuple(torch.Tensor)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) : `torch.Tensor` のタプル (モデルに埋め込み層がある場合は埋め込みの出力用 1 つ + 各層の出力用 1 つ) で、形状は `(batch_size, sequence_length, hidden_size)` です。各層の出力におけるデコーダーの隠れ状態と、任意の初期埋め込み出力です。

decoder_attentions (`tuple(torch.Tensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.Tensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。アテンションの softmax 後のデコーダーのアテンション重みで、自己アテンションヘッドにおける加重平均の計算に使用されます。

cross_attentions (`tuple(torch.Tensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.Tensor` のタプル（レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。クロスアテンションヘッド内で加重平均を計算するために使用される、アテンションの softmax 後のデコーダーのクロスアテンション層のアテンション重みです。

encoder_last_hidden_state (`torch.Tensor`、形状 `(batch_size, sequence_length, hidden_size)`、*任意*) : モデルのエンコーダの最終層の出力における隠れ状態のシーケンス。

encoder_hidden_states (`tuple(torch.Tensor)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) : `torch.Tensor` のタプル (モデルに埋め込み層がある場合は埋め込みの出力用 1 つ + 各層の出力用 1 つ) で、形状は `(batch_size, sequence_length, hidden_size)` です。エンコーダーの各層の出力時の隠れ状態と、任意の初期埋め込み出力です。

encoder_attentions (`tuple(torch.Tensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.Tensor` のタプル（レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。エンコーダーのアテンション重みで、アテンションの softmax 適用後のもので、セルフアテンションヘッドにおける加重平均の計算に使用されます。

intermediate_hidden_states (`torch.Tensor`、形状 `(config.decoder_layers, batch_size, sequence_length, hidden_size)`、*任意*、`config.auxiliary_loss=True` の場合に返されます) : 中間デコーダ活性化、すなわち各デコーダ層の出力であり、それぞれがレイヤノーマルを適用済みです。

DETRエンコーダー・デコーダーモデルの出力の基底クラスです。このクラスは、Seq2SeqModelOutputに1つの属性、すなわち任意の中間デコーダー活性化のスタック（各デコーダー層の出力であり、それぞれがレイヤノーマルを通過したもの）を追加します。これは、補助的なデコーディング損失を用いてモデルを訓練する場合に有用です。

#### 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/v5.23.0/src/transformers/models/detr/modeling_detr.py#L92)

**パラメータ:**

loss (`torch.Tensor`、shape `(1,)`、*optional*、`labels` が提供された場合に返されます)) : クラス予測の負の対数尤度（クロスエントロピー）とバウンディングボックス損失の線形結合としての総損失。後者は、L1損失と汎用スケール不変IoU損失の線形結合として定義されます。

loss_dict (`Dict`, *任意*) : 個別の損失を含む辞書です。ログ出力に便利です。

logits (`torch.Tensor`、形状 `(batch_size, num_queries, num_classes + 1)`) : すべてのクエリに対する分類ロジスト（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/v5.23.0/ja/model_doc/detr#transformers.DetrImageProcessor.post_process_object_detection) を使用できます。

auxiliary_outputs (`list[Dict]`、*任意*) : 補助損失が有効化されている場合（つまり `config.auxiliary_loss` が `True` に設定されている場合）かつラベルが提供されている場合にのみ返されます。各デコーダ層について、上記の2つのキー（`logits` と `pred_boxes`）を含む辞書のリストです。

last_hidden_state (`torch.Tensor`、形状 `(batch_size, sequence_length, hidden_size)`、*任意*) : モデルのデコーダーの最終層の出力における隠れ状態のシーケンス。

decoder_hidden_states (`tuple[torch.Tensor]`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) : `torch.Tensor` のタプル (モデルに埋め込み層がある場合はその出力用 1 つ、各層の出力用 1 つずつ) で、形状は `(batch_size, sequence_length, hidden_size)` です。各層の出力におけるデコーダーの隠れ状態と、初期の埋め込み出力です。

decoder_attentions (`tuple[torch.Tensor]`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.Tensor` のタプル（レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。アテンションの softmax 後のデコーダーのアテンション重みで、セルフアテンションヘッドにおける加重平均の計算に使用されます。

cross_attentions (`tuple[torch.Tensor]`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.Tensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。クロスアテンションヘッド内で加重平均を計算するために使用される、アテンションの softmax 後のデコーダーのクロスアテンションレイヤーのアテンション重みです。

encoder_last_hidden_state (`torch.Tensor`、形状 `(batch_size, sequence_length, hidden_size)`、*任意*) : モデルのエンコーダの最終層の出力における隠れ状態のシーケンス。

encoder_hidden_states (`tuple[torch.Tensor]`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) : `torch.Tensor` のタプル (モデルに埋め込み層がある場合はその出力用 1 つ、各層の出力用 1 つずつ) で、形状は `(batch_size, sequence_length, hidden_size)` です。エンコーダーの各層の出力における隠れ状態と、初期の埋め込み出力です。

encoder_attentions (`tuple[torch.Tensor]`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.Tensor` のタプル（レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。エンコーダーのアテンション重みで、アテンションの softmax 適用後のもので、セルフアテンションヘッドにおける加重平均の計算に使用されます。

[DetrForObjectDetection](/docs/transformers/v5.23.0/ja/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/v5.23.0/src/transformers/models/detr/modeling_detr.py#L135)

**パラメータ:**

loss (`torch.Tensor`、shape `(1,)`、*optional*、`labels` が提供された場合に返されます)) : クラス予測の負の対数尤度（クロスエントロピー）とバウンディングボックス損失の線形結合としての総損失。後者は、L1損失と汎用スケール不変IoU損失の線形結合として定義されます。

loss_dict (`Dict`, *任意*) : 個別の損失を含む辞書です。ログ出力に便利です。

logits (`torch.Tensor`、形状 `(batch_size, num_queries, num_classes + 1)`) : すべてのクエリに対する分類ロジスト（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/v5.23.0/ja/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/v5.23.0/ja/model_doc/detr#transformers.DetrImageProcessor.post_process_semantic_segmentation)、[post_process_instance_segmentation()](/docs/transformers/v5.23.0/ja/model_doc/detr#transformers.DetrImageProcessor.post_process_instance_segmentation)、[post_process_panoptic_segmentation()](/docs/transformers/v5.23.0/ja/model_doc/detr#transformers.DetrImageProcessor.post_process_panoptic_segmentation)を参照してください。

auxiliary_outputs (`list[Dict]`、*任意*) : 補助損失が有効化されている場合（つまり `config.auxiliary_loss` が `True` に設定されている場合）かつラベルが提供されている場合にのみ返されます。各デコーダ層について、上記の2つのキー（`logits` と `pred_boxes`）を含む辞書のリストです。

last_hidden_state (`torch.Tensor`、形状 `(batch_size, sequence_length, hidden_size)`、*任意*) : モデルのデコーダーの最終層の出力における隠れ状態のシーケンス。

decoder_hidden_states (`tuple[torch.Tensor]`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) : `torch.Tensor` のタプル (モデルに埋め込み層がある場合はその出力用 1 つ、各層の出力用 1 つずつ) で、形状は `(batch_size, sequence_length, hidden_size)` です。各層の出力におけるデコーダーの隠れ状態と、初期の埋め込み出力です。

decoder_attentions (`tuple[torch.Tensor]`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.Tensor` のタプル（レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。アテンションの softmax 後のデコーダーのアテンション重みで、セルフアテンションヘッドにおける加重平均の計算に使用されます。

cross_attentions (`tuple[torch.Tensor]`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.Tensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。クロスアテンションヘッド内で加重平均を計算するために使用される、アテンションの softmax 後のデコーダーのクロスアテンションレイヤーのアテンション重みです。

encoder_last_hidden_state (`torch.Tensor`、形状 `(batch_size, sequence_length, hidden_size)`、*任意*) : モデルのエンコーダの最終層の出力における隠れ状態のシーケンス。

encoder_hidden_states (`tuple[torch.Tensor]`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) : `torch.Tensor` のタプル (モデルに埋め込み層がある場合はその出力用 1 つ、各層の出力用 1 つずつ) で、形状は `(batch_size, sequence_length, hidden_size)` です。エンコーダーの各層の出力における隠れ状態と、初期の埋め込み出力です。

encoder_attentions (`tuple[torch.Tensor]`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) : `torch.Tensor` のタプル（レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。エンコーダーのアテンション重みで、アテンションの softmax 適用後のもので、セルフアテンションヘッドにおける加重平均の計算に使用されます。

[DetrForSegmentation](/docs/transformers/v5.23.0/ja/model_doc/detr#transformers.DetrForSegmentation)の出力型。

## DetrModel[[transformers.DetrModel]]

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

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

[ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/detr/modeling_detr.py#L1115)

**パラメータ:**

config ([DetrConfig](/docs/transformers/v5.23.0/ja/model_doc/detr#transformers.DetrConfig)) : モデルのパラメータをすべて含むモデル設定クラスです。設定ファイルで初期化しても、モデルに関連する重みは読み込まれず、設定のみが読み込まれます。モデルの重みをロードするには、[from_pretrained()](/docs/transformers/v5.23.0/ja/main_classes/model#transformers.PreTrainedModel.from_pretrained) メソッドを確認してください。

DETRモデルの本体（バックボーンとエンコーダー・デコーダーのTransformerで構成）で、特定のヘッドを上に載せず、生の隠れ状態を出力します。

このモデルは [PreTrainedModel](/docs/transformers/v5.23.0/ja/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/v5.23.0/src/transformers/models/detr/modeling_detr.py#L1144)

**パラメータ:**

pixel_values (`torch.Tensor`、shape `(batch_size, num_channels, image_size, image_size)`、*optional*) : 入力画像に対応するテンソルです。ピクセル値は `image_processor_class` を使用して取得できます。詳細は `image_processor_class.__call__` を参照してください（`processor_class` は画像の処理に `image_processor_class` を使用します）。

pixel_mask (`torch.LongTensor`、形状 `(batch_size, height, width)`、*任意*) : パディングピクセル値に対するアテンションの実行を回避するためのマスク。`[0, 1]` から選択されるマスク値:  - 実在するピクセル（つまり **マスクされていない**）は 1、 - パディングのピクセル（つまり **マスクされている**）は 0。  [アテンションマスクとは何ですか？](../glossary#attention-mask)

decoder_attention_mask (`torch.Tensor`、形状 `(batch_size, num_queries)`、*任意*) : デコーダー内で特定のオブジェクトクエリに対するアテンションの実行を回避するためのマスク。`[0, 1]` から選択されるマスクの値:  - **マスクされていない** クエリは 1、 - **マスクされている** クエリは 0。

encoder_outputs (`torch.Tensor`, *任意*) : (`last_hidden_state`, *任意*: `hidden_states`, *任意*: `attentions`) のタプル。`last_hidden_state` は形状 `(batch_size, sequence_length, hidden_size)` を持ち、エンコーダーの最終層の出力における隠れ状態のシーケンスです。*任意*デコーダーのクロスアテンションで使用されます。

inputs_embeds (`torch.Tensor`、形状 `(batch_size, sequence_length, hidden_size)`、*任意*) : フラット化された特徴マップ（バックボーンと投影層の出力）を渡す代わりに、画像のフラット化された表現を直接渡すこともできます。ビジョンバックボーンをバイパスする場合に便利です。

decoder_inputs_embeds (`torch.Tensor`、shape `(batch_size, num_queries, hidden_size)`、*optional*) : クエリをゼロのテンソルで初期化する代わりに、埋め込み表現を直接渡すこともできます。カスタムなクエリ初期化を必要とするタスクに有用です。

**戻り値:** [DetrModelOutput](/docs/transformers/v5.23.0/ja/model_doc/detr#transformers.models.detr.modeling_detr.DetrModelOutput) または `tuple(torch.Tensor)`

設定（`None`）や入力に応じて、さまざまな要素で構成される、[DetrModelOutput](/docs/transformers/v5.23.0/ja/model_doc/detr#transformers.models.detr.modeling_detr.DetrModelOutput) または `torch.Tensor` のタプル（`return_dict=False` が渡された場合、または `config.return_dict=False` の場合）。

[DetrModel](/docs/transformers/v5.23.0/ja/model_doc/detr#transformers.DetrModel)のforwardメソッドは、`__call__`特殊メソッドをオーバーライドします。

この関数内でフォワードパスの手順を定義する必要がありますが、その後、この関数ではなく`Module`インスタンスを呼び出すべきです。前者は前処理と後処理の実行を適切に処理するのに対し、後者はそれらを無視してしまいます。

- **last_hidden_state** (`torch.Tensor`、形状 `(batch_size, sequence_length, hidden_size)`) -- モデルのデコーダーの最終層の出力における、隠れ状態のシーケンスです。

  `past_key_values`が使用されている場合、出力されるのは、形状`(batch_size, 1, hidden_size)`のシーケンスの最後の隠れ状態のみです。
- **past_key_values** (`EncoderDecoderCache`、*任意*、`use_cache=True` が渡された場合または `config.use_cache=True` の場合に返されます) -- [EncoderDecoderCache](/docs/transformers/v5.23.0/ja/internal/generation_utils#transformers.EncoderDecoderCache) のインスタンスです。詳細については、[kv cache ガイド](https://huggingface.co/docs/transformers/en/kv_cache)を参照してください。

  逐次デコーディングを高速化するために使用できる（`past_key_values` 入力参照）、事前計算済みの隠れ状態（自己アテンションブロックおよびクロスアテンションブロックのキーとバリュー）が含まれます。
- **decoder_hidden_states** (`tuple(torch.Tensor)`、*optional*、`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)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.Tensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)`。

  自己アテンションヘッドにおける加重平均を計算するために使用される、アテンションのsoftmax後のデコーダーのアテンション重み。
- **cross_attentions** (`tuple(torch.Tensor)`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.Tensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)`。

  クロスアテンション層のアテンション重みは、アテンションのsoftmax適用後に計算され、クロスアテンションヘッドにおける加重平均の計算に使用されます。
- **encoder_last_hidden_state** (`torch.Tensor`、形状 `(batch_size, sequence_length, hidden_size)`、*任意*) -- モデルのエンコーダーの最終層の出力における隠れ状態のシーケンス。
- **encoder_hidden_states** (`tuple(torch.Tensor)`、*optional*、`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` の場合に返されます) -- 各レイヤーごとに 1 つの `torch.Tensor` からなるタプルで、形状は `(batch_size, num_heads, sequence_length, sequence_length)` です。

  アテンションのsoftmaxを適用した後のエンコーダーのアテンション重み。自己アテンションヘッドにおける加重平均の計算に使用されます。
- **intermediate_hidden_states** (`torch.Tensor`、形状 `(config.decoder_layers, batch_size, sequence_length, hidden_size)`、*任意*、`config.auxiliary_loss=True` の場合に返されます) -- 中間デコーダ活性化、すなわち各デコーダ層の出力であり、それぞれが 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/v5.23.0/src/transformers/models/detr/modeling_detr.py#L1309)

**パラメータ:**

config ([DetrConfig](/docs/transformers/v5.23.0/ja/model_doc/detr#transformers.DetrConfig)) : モデルのパラメータをすべて含むモデル設定クラスです。設定ファイルで初期化しても、モデルに関連する重みは読み込まれず、設定のみが読み込まれます。モデルの重みをロードするには、[from_pretrained()](/docs/transformers/v5.23.0/ja/main_classes/model#transformers.PreTrainedModel.from_pretrained) メソッドを確認してください。

DETRモデル（バックボーンとエンコーダー・デコーダーのTransformerで構成）の上部にオブジェクト検出ヘッドを備えたモデル。COCO検出などのタスクに使用します。

このモデルは [PreTrainedModel](/docs/transformers/v5.23.0/ja/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/v5.23.0/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`、形状 `(batch_size, height, width)`、*任意*) : パディングピクセル値に対するアテンションの実行を回避するためのマスク。`[0, 1]` から選択されるマスク値:  - 実在するピクセル（つまり **マスクされていない**）は 1、 - パディングのピクセル（つまり **マスクされている**）は 0。  [アテンションマスクとは何ですか？](../glossary#attention-mask)

decoder_attention_mask (`torch.Tensor`、形状 `(batch_size, num_queries)`、*任意*) : デコーダー内で特定のオブジェクトクエリに対するアテンションの実行を回避するためのマスク。`[0, 1]` から選択されるマスクの値:  - **マスクされていない** クエリは 1、 - **マスクされている** クエリは 0。

encoder_outputs (`torch.Tensor`, *任意*) : (`last_hidden_state`, *任意*: `hidden_states`, *任意*: `attentions`) のタプル。`last_hidden_state` は形状 `(batch_size, sequence_length, hidden_size)` を持ち、エンコーダーの最終層の出力における隠れ状態のシーケンスです。*任意*デコーダーのクロスアテンションで使用されます。

inputs_embeds (`torch.Tensor`、形状 `(batch_size, sequence_length, hidden_size)`、*任意*) : フラット化された特徴マップ（バックボーンと投影層の出力）を渡す代わりに、画像のフラット化された表現を直接渡すこともできます。ビジョンバックボーンをバイパスする場合に便利です。

decoder_inputs_embeds (`torch.Tensor`、shape `(batch_size, num_queries, hidden_size)`、*optional*) : クエリをゼロのテンソルで初期化する代わりに、埋め込み表現を直接渡すこともできます。カスタムなクエリ初期化を必要とするタスクに有用です。

labels (`list[Dict]`、長さ `(batch_size,)`、*任意*) : 二部マッチング損失を計算するためのラベル。辞書のリストで、各辞書には少なくとも以下の 2 つのキーが含まれます: 'class_labels' と 'boxes' (それぞれバッチ内の画像のクラスラベルとバウンディングボックス)。クラスラベル自体は長さ `(number of bounding boxes in the image,)` の `torch.LongTensor` であり、ボックスは形状 `(number of bounding boxes in the image, 4)` の `torch.Tensor` である必要があります。

**戻り値:** [DetrObjectDetectionOutput](/docs/transformers/v5.23.0/ja/model_doc/detr#transformers.models.detr.modeling_detr.DetrObjectDetectionOutput) または `tuple(torch.Tensor)`

設定（`None`）や入力に応じて、さまざまな要素で構成される、[DetrObjectDetectionOutput](/docs/transformers/v5.23.0/ja/model_doc/detr#transformers.models.detr.modeling_detr.DetrObjectDetectionOutput) または `torch.Tensor` のタプル（`return_dict=False` が渡された場合、または `config.return_dict=False` の場合）。

[DetrForObjectDetection](/docs/transformers/v5.23.0/ja/model_doc/detr#transformers.DetrForObjectDetection)のforwardメソッドは、`__call__`特殊メソッドをオーバーライドします。

この関数内でフォワードパスの手順を定義する必要がありますが、その後、この関数ではなく`Module`インスタンスを呼び出すべきです。前者は前処理と後処理の実行を適切に処理するのに対し、後者はそれらを無視してしまいます。

- **loss** (`torch.Tensor`、形状 `(1,)`、*任意*、`labels` が提供された場合に返されます) -- クラス予測の負の対数尤度（クロスエントロピー）とバウンディングボックス損失の線形結合としての総損失。後者は、L1損失と汎用スケール不変IoU損失の線形結合として定義されます。
- **loss_dict** (`Dict`, *任意*) -- 個別の損失を含む辞書です。ログ出力に便利です。
- **logits** (`torch.Tensor`、形状 `(batch_size, num_queries, num_classes + 1)`) -- すべてのクエリに対する分類 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/v5.23.0/ja/model_doc/detr#transformers.DetrImageProcessor.post_process_object_detection) を使用できます。
- **auxiliary_outputs** (`list[Dict]`, *optional*) -- 任意。補助損失が有効化されている場合（つまり `config.auxiliary_loss` が `True` に設定されている場合）かつラベルが提供されている場合にのみ返されます。各デコーダ層について、上記の 2 つのキー（`logits` と `pred_boxes`）を含む辞書のリストです。
- **last_hidden_state** (`torch.Tensor`、形状 `(batch_size, sequence_length, hidden_size)`、*任意*) -- モデルのデコーダーの最終層の出力における、隠れ状態のシーケンス。
- **decoder_hidden_states** (`tuple[torch.Tensor]`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) -- `torch.Tensor` のタプル（埋め込み層を持つモデルの場合、埋め込みの出力用 1 つ + 各層の出力用 1 つ）で、形状は `(batch_size, sequence_length, hidden_size)` です。

  各層の出力および初期埋め込み出力における、デコーダーの隠れ状態。
- **decoder_attentions** (`tuple[torch.Tensor]`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.Tensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)`。

  自己アテンションヘッドにおける加重平均を計算するために使用される、アテンションのsoftmax後のデコーダーのアテンション重み。
- **cross_attentions** (`tuple[torch.Tensor]`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.Tensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)`。

  クロスアテンション層のアテンション重みは、アテンションのsoftmax適用後に計算され、クロスアテンションヘッドにおける加重平均の計算に使用されます。
- **encoder_last_hidden_state** (`torch.Tensor`、形状 `(batch_size, sequence_length, hidden_size)`、*任意*) -- モデルのエンコーダーの最終層の出力における隠れ状態のシーケンス。
- **encoder_hidden_states** (`tuple[torch.Tensor]`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) -- `torch.Tensor` のタプル（埋め込み層を持つモデルの場合、埋め込みの出力用 1 つ + 各層の出力用 1 つずつ）で、形状は `(batch_size, sequence_length, hidden_size)` です。

  各層の出力および初期埋め込み出力におけるエンコーダーの隠れ状態。
- **encoder_attentions** (`tuple[torch.Tensor]`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.Tensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)`。

  アテンションのsoftmaxを適用した後のエンコーダーのアテンション重み。自己アテンションヘッドにおける加重平均の計算に使用されます。

例:

```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/v5.23.0/src/transformers/models/detr/modeling_detr.py#L1441)

**パラメータ:**

config ([DetrConfig](/docs/transformers/v5.23.0/ja/model_doc/detr#transformers.DetrConfig)) : モデルのパラメータをすべて含むモデル設定クラスです。設定ファイルで初期化しても、モデルに関連する重みは読み込まれず、設定のみが読み込まれます。モデルの重みをロードするには、[from_pretrained()](/docs/transformers/v5.23.0/ja/main_classes/model#transformers.PreTrainedModel.from_pretrained) メソッドを確認してください。

DETRモデル（バックボーンとエンコーダー・デコーダーのTransformerで構成）の上部にセグメンテーションヘッドを備え、COCOパノプティックなどのタスクに対応します。

このモデルは [PreTrainedModel](/docs/transformers/v5.23.0/ja/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/v5.23.0/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`、形状 `(batch_size, height, width)`、*任意*) : パディングピクセル値に対するアテンションの実行を回避するためのマスク。`[0, 1]` から選択されるマスク値:  - 実在するピクセル（つまり **マスクされていない**）は 1、 - パディングのピクセル（つまり **マスクされている**）は 0。  [アテンションマスクとは何ですか？](../glossary#attention-mask)

decoder_attention_mask (`torch.Tensor`、形状 `(batch_size, num_queries)`、*任意*) : デコーダー内で特定のオブジェクトクエリに対するアテンションの実行を回避するためのマスク。`[0, 1]` から選択されるマスクの値:  - **マスクされていない** クエリは 1、 - **マスクされている** クエリは 0。

encoder_outputs (`torch.Tensor`, *任意*) : (`last_hidden_state`, *任意*: `hidden_states`, *任意*: `attentions`) のタプル。`last_hidden_state` は形状 `(batch_size, sequence_length, hidden_size)` を持ち、エンコーダーの最終層の出力における隠れ状態のシーケンスです。*任意*デコーダーのクロスアテンションで使用されます。

inputs_embeds (`torch.Tensor`、形状 `(batch_size, sequence_length, hidden_size)`、*任意*) : 後方互換性のために保持されていますが、セグメンテーションには使用できません。セグメンテーションにはバックボーンからのマルチスケール特徴量が必要ですが、inputs_embeds を使用してバックボーンをバイパスすると、それらは利用できないためです。

decoder_inputs_embeds (`torch.Tensor`、shape `(batch_size, num_queries, hidden_size)`、*optional*) : クエリをゼロのテンソルで初期化する代わりに、埋め込み表現を直接渡すこともできます。カスタムなクエリ初期化を必要とするタスクに有用です。

labels (`list[Dict]`、長さ `(batch_size,)`、*任意*) : 二部マッチング損失、DICE/F-1 損失、Focal 損失の計算に使用するラベル。辞書のリストで、各辞書には少なくとも以下の 3 つのキーが含まれます: 'class_labels'、'boxes'、'masks' (それぞれバッチ内の画像のクラスラベル、バウンディングボックス、セグメンテーションマスク)。クラスラベル自体は長さ `(number of bounding boxes in the image,)` の `torch.LongTensor`、ボックスは形状 `(number of bounding boxes in the image, 4)` の `torch.Tensor`、マスクは形状 `(number of bounding boxes in the image, height, width)` の `torch.Tensor` である必要があります。

**戻り値:** [DetrSegmentationOutput](/docs/transformers/v5.23.0/ja/model_doc/detr#transformers.models.detr.modeling_detr.DetrSegmentationOutput) または `tuple(torch.Tensor)`

設定（`None`）や入力に応じて、さまざまな要素で構成される、[DetrSegmentationOutput](/docs/transformers/v5.23.0/ja/model_doc/detr#transformers.models.detr.modeling_detr.DetrSegmentationOutput) または `torch.Tensor` のタプル（`return_dict=False` が渡された場合、または `config.return_dict=False` の場合）。

[DetrForSegmentation](/docs/transformers/v5.23.0/ja/model_doc/detr#transformers.DetrForSegmentation)のforwardメソッドは、`__call__`特殊メソッドをオーバーライドします。

この関数内でフォワードパスの手順を定義する必要がありますが、その後、この関数ではなく`Module`インスタンスを呼び出すべきです。前者は前処理と後処理の実行を適切に処理するのに対し、後者はそれらを無視してしまいます。

- **loss** (`torch.Tensor`、形状 `(1,)`、*任意*、`labels` が提供された場合に返されます) -- クラス予測の負の対数尤度（クロスエントロピー）とバウンディングボックス損失の線形結合としての総損失。後者は、L1損失と汎用スケール不変IoU損失の線形結合として定義されます。
- **loss_dict** (`Dict`, *任意*) -- 個別の損失を含む辞書です。ログ出力に便利です。
- **logits** (`torch.Tensor`、形状 `(batch_size, num_queries, num_classes + 1)`) -- すべてのクエリに対する分類 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/v5.23.0/ja/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/v5.23.0/ja/model_doc/detr#transformers.DetrImageProcessor.post_process_semantic_segmentation)、[post_process_instance_segmentation()](/docs/transformers/v5.23.0/ja/model_doc/detr#transformers.DetrImageProcessor.post_process_instance_segmentation)、[post_process_panoptic_segmentation()](/docs/transformers/v5.23.0/ja/model_doc/detr#transformers.DetrImageProcessor.post_process_panoptic_segmentation) を参照してください。
- **auxiliary_outputs** (`list[Dict]`, *optional*) -- 任意。補助損失が有効化されている場合（つまり `config.auxiliary_loss` が `True` に設定されている場合）かつラベルが提供されている場合にのみ返されます。各デコーダ層について、上記の 2 つのキー（`logits` と `pred_boxes`）を含む辞書のリストです。
- **last_hidden_state** (`torch.Tensor`、形状 `(batch_size, sequence_length, hidden_size)`、*任意*) -- モデルのデコーダーの最終層の出力における、隠れ状態のシーケンス。
- **decoder_hidden_states** (`tuple[torch.Tensor]`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) -- `torch.Tensor` のタプル（埋め込み層を持つモデルの場合、埋め込みの出力用 1 つ + 各層の出力用 1 つ）で、形状は `(batch_size, sequence_length, hidden_size)` です。

  各層の出力および初期埋め込み出力における、デコーダーの隠れ状態。
- **decoder_attentions** (`tuple[torch.Tensor]`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.Tensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)`。

  自己アテンションヘッドにおける加重平均を計算するために使用される、アテンションのsoftmax後のデコーダーのアテンション重み。
- **cross_attentions** (`tuple[torch.Tensor]`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.Tensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)`。

  クロスアテンション層のアテンション重みは、アテンションのsoftmax適用後に計算され、クロスアテンションヘッドにおける加重平均の計算に使用されます。
- **encoder_last_hidden_state** (`torch.Tensor`、形状 `(batch_size, sequence_length, hidden_size)`、*任意*) -- モデルのエンコーダーの最終層の出力における隠れ状態のシーケンス。
- **encoder_hidden_states** (`tuple[torch.Tensor]`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返されます) -- `torch.Tensor` のタプル（埋め込み層を持つモデルの場合、埋め込みの出力用 1 つ + 各層の出力用 1 つずつ）で、形状は `(batch_size, sequence_length, hidden_size)` です。

  各層の出力および初期埋め込み出力におけるエンコーダーの隠れ状態。
- **encoder_attentions** (`tuple[torch.Tensor]`、*optional*、`output_attentions=True` が渡された場合または `config.output_attentions=True` の場合に返されます) -- `torch.Tensor` のタプル（各レイヤーごとに1つ）、形状は `(batch_size, num_heads, sequence_length, sequence_length)`。

  アテンションのsoftmaxを適用した後のエンコーダーのアテンション重み。自己アテンションヘッドにおける加重平均の計算に使用されます。

例:

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

