# ビジョンエンコーダーデコーダーモデル

## 概要

[VisionEncoderDecoderModel](/docs/transformers/main/ja/model_doc/vision-encoder-decoder#transformers.VisionEncoderDecoderModel) は、事前学習済みの Transformer ベースのビジョンモデル（*例:* [ViT](vit)、[BEiT](beit)、[DeiT](deit)、[Swin](swin)）をエンコーダーとして、事前学習済みの言語モデル（*例:* [RoBERTa](roberta)、[GPT2](gpt2)、[BERT](bert)、[DistilBERT](distilbert)）をデコーダーとして使用して、画像からテキストへの変換モデルを初期化するために使用できます。

事前学習済みチェックポイントで画像からテキストシーケンスへのモデルを初期化する有効性は、Minghao Li、Tengchao Lv、Lei Cui、Yijuan Lu、Dinei Florencio、Cha Zhang、Zhoujun Li、Furu Wei による [TrOCR: Transformer-based Optical Character Recognition with Pre-trained Models](https://huggingface.co/papers/2109.10282) などで示されています。

このような[VisionEncoderDecoderModel](/docs/transformers/main/ja/model_doc/vision-encoder-decoder#transformers.VisionEncoderDecoderModel)が学習/ファインチューニングされた後、他のモデルと同様に保存/読み込みを行うことができます（詳細は以下の例を参照してください）。

アプリケーションの例として、画像キャプション生成があります。このタスクでは、エンコーダーが画像をエンコードし、その後、自己回帰型言語モデルがキャプションを生成します。別の例として、光学文字認識（OCR）があります。[VisionEncoderDecoderModel](/docs/transformers/main/ja/model_doc/vision-encoder-decoder#transformers.VisionEncoderDecoderModel)のインスタンスである[TrOCR](trocr)を参照してください。

## モデル設定から`VisionEncoderDecoderModel`をランダムに初期化

[VisionEncoderDecoderModel](/docs/transformers/main/ja/model_doc/vision-encoder-decoder#transformers.VisionEncoderDecoderModel)は、エンコーダーとデコーダーの設定からランダムに初期化できます。以下の例では、エンコーダーにデフォルトの[ViTModel](/docs/transformers/main/ja/model_doc/vit#transformers.ViTModel)設定、デコーダーにデフォルトの`BertForCausalLM`設定を使用して、これを行う方法を示しています。

```python
from transformers import BertConfig, VisionEncoderDecoderConfig, VisionEncoderDecoderModel, ViTConfig

config_encoder = ViTConfig()
config_decoder = BertConfig()

config = VisionEncoderDecoderConfig.from_encoder_decoder_configs(config_encoder, config_decoder)
model = VisionEncoderDecoderModel(config=config)
```

## 事前学習済みエンコーダーと事前学習済みデコーダーから`VisionEncoderDecoderModel`を初期化

[VisionEncoderDecoderModel](/docs/transformers/main/ja/model_doc/vision-encoder-decoder#transformers.VisionEncoderDecoderModel) は、事前学習済みのエンコーダーのチェックポイントと事前学習済みのデコーダーのチェックポイントから初期化できます。事前学習済みの Transformer ベースのビジョンモデル、*例えば* [Swin](swin) はエンコーダーとして使用でき、事前学習済みのオートエンコーディングモデル、*例えば* BERT、事前学習済みの因果言語モデル、*例えば* GPT2、およびシーケンスツーシーケンスモデルの事前学習済みのデコーダー部分、*例えば* BART のデコーダーは、デコーダーとして使用できます。デコーダーとしてどのアーキテクチャを選択するかによって、クロスアテンション層がランダムに初期化される場合があります。[*Warm-starting-encoder-decoder ブログ記事*](https://huggingface.co/blog/warm-starting-encoder-decoder) に示されているように、[VisionEncoderDecoderModel](/docs/transformers/main/ja/model_doc/vision-encoder-decoder#transformers.VisionEncoderDecoderModel) を事前学習済みのエンコーダーとデコーダーのチェックポイントから初期化するには、下流タスクでのファインチューニングが必要です。これを行うために、`VisionEncoderDecoderModel` クラスは [VisionEncoderDecoderModel.from_encoder_decoder_pretrained()](/docs/transformers/main/ja/model_doc/vision-encoder-decoder#transformers.VisionEncoderDecoderModel.from_encoder_decoder_pretrained) メソッドを提供しています。

```python
from transformers import VisionEncoderDecoderModel

model = VisionEncoderDecoderModel.from_encoder_decoder_pretrained(
    "microsoft/swin-base-patch4-window7-224-in22k", "google-bert/bert-base-uncased"
)
```

## 既存の`VisionEncoderDecoderModel`チェックポイントを読み込み、推論を実行する

`VisionEncoderDecoderModel` クラスのファインチューニング済みチェックポイントを読み込むには、Transformers の他のモデルアーキテクチャと同様に、[VisionEncoderDecoderModel](/docs/transformers/main/ja/model_doc/vision-encoder-decoder#transformers.VisionEncoderDecoderModel) が `from_pretrained(...)` メソッドを提供しています。

推論を実行するには、`generate`メソッドを使用します。このメソッドは、テキストを自己回帰的に生成することを可能にします。このメソッドは、貪欲法、ビームサーチ、多項分布サンプリングなど、さまざまなデコーディング形式をサポートしています。

```python
import requests
from PIL import Image

from transformers import GPT2TokenizerFast, ViTImageProcessor, VisionEncoderDecoderModel

# load a fine-tuned image captioning model and corresponding tokenizer and image processor
model = VisionEncoderDecoderModel.from_pretrained("nlpconnect/vit-gpt2-image-captioning", device_map="auto")
tokenizer = GPT2TokenizerFast.from_pretrained("nlpconnect/vit-gpt2-image-captioning")
image_processor = ViTImageProcessor.from_pretrained("nlpconnect/vit-gpt2-image-captioning")

# let's perform inference on an image
url = "http://images.cocodataset.org/val2017/000000039769.jpg"
image = Image.open(requests.get(url, stream=True).raw)
pixel_values = image_processor(image, return_tensors="pt").to(model.device).pixel_values

# autoregressively generate caption (uses greedy decoding by default)
generated_ids = model.generate(pixel_values)
generated_text = tokenizer.batch_decode(generated_ids, skip_special_tokens=True)[0]
print(generated_text)
a cat laying on a blanket next to a cat laying on a bed
```

## トレーニング

モデルが作成されると、(画像, テキスト) のペアからなるデータセット上で、BART や T5 など他のエンコーダー・デコーダーモデルと同様にファインチューニングを行うことができます。ご覧のとおり、損失を計算するには、モデルには2つの入力のみが必要です: `pixel_values`（画像）と `labels`（エンコードされたターゲットシーケンスの `input_ids`）。

```python
from datasets import load_dataset

from transformers import BertTokenizer, VisionEncoderDecoderModel, ViTImageProcessor

image_processor = ViTImageProcessor.from_pretrained("google/vit-base-patch16-224-in21k")
tokenizer = BertTokenizer.from_pretrained("google-bert/bert-base-uncased")
model = VisionEncoderDecoderModel.from_encoder_decoder_pretrained(
    "google/vit-base-patch16-224-in21k", "google-bert/bert-base-uncased"
)

model.config.decoder_start_token_id = tokenizer.cls_token_id
model.config.pad_token_id = tokenizer.pad_token_id

dataset = load_dataset("huggingface/cats-image")
image = dataset["test"]["image"][0]
pixel_values = image_processor(image, return_tensors="pt").to(model.device).pixel_values

labels = tokenizer(
    "an image of two cats chilling on a couch",
    return_tensors="pt",
).input_ids

# the forward function automatically creates the correct decoder_input_ids
loss = model(pixel_values=pixel_values, labels=labels).loss
```

このモデルは [nielsr](https://github.com/nielsrogge) によって提供されました。

## VisionEncoderDecoderConfig[[transformers.VisionEncoderDecoderConfig]]

#### transformers.VisionEncoderDecoderConfig[[transformers.VisionEncoderDecoderConfig]]

```python
transformers.VisionEncoderDecoderConfig(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, encoder: transformers.configuration_utils.PreTrainedConfig | dict | None = None, decoder: transformers.configuration_utils.PreTrainedConfig | dict | None = None)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vision_encoder_decoder/configuration_vision_encoder_decoder.py#L29)

**パラメータ:**

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

encoder (`Union[~configuration_utils.PreTrainedConfig, dict]`, *省略可*) : エンコーダーのバックボーンの設定オブジェクトまたは辞書。

decoder (`Union[~configuration_utils.PreTrainedConfig, dict]`、*optional*) : デコーダーのバックボーンの設定オブジェクトまたは辞書。

これは、Vision Encoder Decoderモデルの構成を保存するための設定クラスです。指定された引数に基づいてVision Encoder Decoderモデルをインスタンス化し、モデルのアーキテクチャを定義するために使用されます。デフォルト値で設定をインスタンス化すると、[None](https://huggingface.co/None)の構成に類似した構成が得られます。

設定オブジェクトは [PreTrainedConfig](/docs/transformers/main/ja/main_classes/configuration#transformers.PreTrainedConfig) を継承し、モデルの出力を制御するために使用できます。詳細については、[PreTrainedConfig](/docs/transformers/main/ja/main_classes/configuration#transformers.PreTrainedConfig) のドキュメントを参照してください。

例:

```python
>>> from transformers import BertConfig, ViTConfig, VisionEncoderDecoderConfig, VisionEncoderDecoderModel

>>> # Initializing a ViT & BERT style configuration
>>> config_encoder = ViTConfig()
>>> config_decoder = BertConfig()

>>> config = VisionEncoderDecoderConfig(encoder=config_encoder, decoder=config_decoder)

>>> # Initializing a ViTBert model (with random weights) from a ViT & google-bert/bert-base-uncased style configurations
>>> model = VisionEncoderDecoderModel(config=config)

>>> # Accessing the model configuration
>>> config_encoder = model.config.encoder
>>> config_decoder = model.config.decoder
>>> # set decoder config to causal lm
>>> config_decoder.is_decoder = True
>>> config_decoder.add_cross_attention = True

>>> # Saving the model, including its configuration
>>> model.save_pretrained("my-model")

>>> # loading model and config from pretrained folder
>>> encoder_decoder_config = VisionEncoderDecoderConfig.from_pretrained("my-model")
>>> model = VisionEncoderDecoderModel.from_pretrained("my-model", config=encoder_decoder_config)
```

#### from_encoder_decoder_configs[[transformers.VisionEncoderDecoderConfig.from_encoder_decoder_configs]]

```python
from_encoder_decoder_configs(encoder_config: PreTrainedConfig, decoder_config: PreTrainedConfig, **kwargs)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vision_encoder_decoder/configuration_vision_encoder_decoder.py#L72)

**戻り値:** [VisionEncoderDecoderConfig](/docs/transformers/main/ja/model_doc/vision-encoder-decoder#transformers.VisionEncoderDecoderConfig)

設定オブジェクトのインスタンス

事前学習済みエンコーダーモデルの設定とデコーダーモデルの設定から、[VisionEncoderDecoderConfig](/docs/transformers/main/ja/model_doc/vision-encoder-decoder#transformers.VisionEncoderDecoderConfig)（または派生クラス）をインスタンス化します。

## VisionEncoderDecoderModel[[transformers.VisionEncoderDecoderModel]]

#### transformers.VisionEncoderDecoderModel[[transformers.VisionEncoderDecoderModel]]

```python
transformers.VisionEncoderDecoderModel(config: transformers.configuration_utils.PreTrainedConfig | None = None, encoder: transformers.modeling_utils.PreTrainedModel | None = None, decoder: transformers.modeling_utils.PreTrainedModel | None = None)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vision_encoder_decoder/modeling_vision_encoder_decoder.py#L54)

**パラメータ:**

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

encoder (`PreTrainedModel`、*任意*) : 使用するエンコーダーモデル。

decoder (`PreTrainedModel`、*任意*) : 使用するデコーダーモデル。

特定のヘッドを上に付加せず、生のhidden-statesを出力する、素のVision Encoder Decoder Model。

このモデルは [PreTrainedModel](/docs/transformers/main/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.VisionEncoderDecoderModel.forward]]

```python
forward(pixel_values: typing.Optional[torch.FloatTensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.BoolTensor] = None, encoder_outputs: tuple[torch.FloatTensor] | None = None, past_key_values: transformers.cache_utils.Cache | None = None, decoder_inputs_embeds: typing.Optional[torch.FloatTensor] = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vision_encoder_decoder/modeling_vision_encoder_decoder.py#L301)

**パラメータ:**

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

decoder_input_ids (`torch.LongTensor`、shape `(batch_size, target_sequence_length)`、*任意*) : 語彙におけるデコーダー入力シーケンスのトークンインデックス。インデックスは [PreTrainedTokenizer](/docs/transformers/main/ja/main_classes/tokenizer#transformers.PythonBackend) を使用して取得できます。詳細は [PreTrainedTokenizer.encode()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) および [PreTrainedTokenizer.__call__()](/docs/transformers/main/ja/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) を参照してください。[入力 ID とは何か？](../glossary#input-ids) `past_key_values` を使用する場合、最後の `decoder_input_ids` のみを任意で入力すれば十分です（`past_key_values` を参照）。学習時には、モデルが自動的に `decoder_input_ids` を作成します。具体的には、`labels` を右にシフトし、-100 を `pad_token_id` に置き換え、先頭に `decoder_start_token_id` を付加します。

decoder_attention_mask (`torch.BoolTensor`、shape `(batch_size, target_sequence_length)`、*任意*) : デフォルトの動作: `decoder_input_ids`内のpadトークンを無視するテンソルを生成します。デフォルトでは、causal maskも使用されます。

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

past_key_values (`~cache_utils.Cache`, *任意*) : 逐次デコードを高速化するために使用できる、事前計算された hidden-states（self-attention ブロックおよび cross-attention ブロック内の key と value）です。通常、`use_cache=True` または `config.use_cache=True` の場合、モデルがデコードの以前の段階で返した `past_key_values` で構成されます。入力として許可されるのは [Cache](/docs/transformers/main/ja/internal/generation_utils#transformers.Cache) インスタンスのみです。[kv cache ガイド](https://huggingface.co/docs/transformers/en/kv_cache)を参照してください。`past_key_values` が渡されない場合、デフォルトで [DynamicCache](/docs/transformers/main/ja/internal/generation_utils#transformers.DynamicCache) が初期化されます。モデルは、入力として与えられたのと同じキャッシュ形式を出力します。`past_key_values` を使用する場合は、すべての `input_ids`（形状 `(batch_size, sequence_length)`）の代わりに、このモデルに過去の key value 状態が与えられていない未処理の `input_ids`（形状 `(batch_size, unprocessed_length)`）のみを入力する必要があります。

decoder_inputs_embeds (`torch.FloatTensor`、shape `(batch_size, target_sequence_length, hidden_size)`、*任意*) : `decoder_input_ids` を渡す代わりに、埋め込み表現を直接渡すこともできます。これは、モデル内部の埋め込みルックアップ行列よりも、`decoder_input_ids` のインデックスを対応するベクトルに変換する方法をより細かく制御したい場合に有用です。

labels (`torch.LongTensor`、shape `(batch_size, sequence_length)`、*optional*) : デコーダーのマスク言語モデリング損失を計算するためのラベル。インデックスは `[-100, 0, ..., config.vocab_size]` の範囲である必要があります（`input_ids` のドキュメント文字列を参照）。インデックスが `-100` に設定されたトークンは無視（マスク）され、損失は `[0, ..., config.vocab_size]` の範囲のラベルを持つトークンに対してのみ計算されます。

use_cache (`bool`, *任意*) : `True`に設定すると、`past_key_values`のキーバリュー状態が返され、デコーディングの高速化に利用できます（`past_key_values`を参照）。

output_attentions (`bool`, *任意*) : すべてのアテンション層のアテンションテンソルを返すかどうか。詳細は、返されるテンソルの `attentions` を参照してください。

output_hidden_states (`bool`, *任意*) : 全レイヤーの hidden states を返すかどうかを指定します。詳細は、返されるテンソルの `hidden_states` を参照してください。

return_dict (`bool`, *任意*) : プレーンなタプルではなく [ModelOutput](/docs/transformers/main/ja/main_classes/output#transformers.utils.ModelOutput) を返すかどうか。

**戻り値:** [Seq2SeqLMOutput](/docs/transformers/main/ja/main_classes/output#transformers.modeling_outputs.Seq2SeqLMOutput) または `tuple(torch.FloatTensor)`

設定（[VisionEncoderDecoderConfig](/docs/transformers/main/ja/model_doc/vision-encoder-decoder#transformers.VisionEncoderDecoderConfig)）や入力に応じて、さまざまな要素で構成される、[Seq2SeqLMOutput](/docs/transformers/main/ja/main_classes/output#transformers.modeling_outputs.Seq2SeqLMOutput) または `torch.FloatTensor` のタプル（`return_dict=False` が渡された場合、または `config.return_dict=False` の場合）。

[VisionEncoderDecoderModel](/docs/transformers/main/ja/model_doc/vision-encoder-decoder#transformers.VisionEncoderDecoderModel)のforwardメソッドは、`__call__`という特殊メソッドをオーバーライドします。

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

- **loss** (`torch.FloatTensor`、shape `(1,)`、*optional*、`labels` が指定された場合に返されます) -- 言語モデリングの損失。
- **logits** (`torch.FloatTensor`、shape `(batch_size, sequence_length, config.vocab_size)`) -- 言語モデリングヘッドの予測スコア（SoftMax 適用前の各語彙トークンのスコア）。
- **past_key_values** (`EncoderDecoderCache`、*任意*、`use_cache=True` が渡された場合または `config.use_cache=True` の場合に返されます) -- [EncoderDecoderCache](/docs/transformers/main/ja/internal/generation_utils#transformers.EncoderDecoderCache) のインスタンスです。詳細については、[kv cache ガイド](https://huggingface.co/docs/transformers/en/kv_cache)を参照してください。

  逐次デコーディングを高速化するために使用できる（`past_key_values` 入力参照）、事前計算済みの隠れ状態（自己アテンションブロックおよびクロスアテンションブロックのキーとバリュー）が含まれます。
- **decoder_hidden_states** (`tuple(torch.FloatTensor)`、*optional*、`output_hidden_states=True` が渡された場合または `config.output_hidden_states=True` の場合に返される) -- `torch.FloatTensor` のタプル（モデルに埋め込み層がある場合はその出力用 + 各層の出力用）で、形状は `(batch_size, sequence_length, hidden_size)` です。

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

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

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

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

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

例:

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

>>> processor = AutoProcessor.from_pretrained("microsoft/trocr-base-handwritten")
>>> model = VisionEncoderDecoderModel.from_pretrained("microsoft/trocr-base-handwritten")

>>> # load image from the IAM dataset
>>> url = "https://fki.tic.heia-fr.ch/static/img/a01-122-02.jpg"
>>> with httpx.stream("GET", url) as response:
...     image = Image.open(BytesIO(response.read())).convert("RGB")

>>> # training
>>> model.config.decoder_start_token_id = processor.tokenizer.eos_token_id
>>> model.config.pad_token_id = processor.tokenizer.pad_token_id
>>> model.config.vocab_size = model.config.decoder.vocab_size

>>> pixel_values = processor(image, return_tensors="pt").pixel_values
>>> text = "hello world"
>>> labels = processor.tokenizer(text, return_tensors="pt").input_ids
>>> outputs = model(pixel_values=pixel_values, labels=labels)
>>> loss = outputs.loss

>>> # inference (generation)
>>> generated_ids = model.generate(pixel_values)
>>> generated_text = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
```

#### from_encoder_decoder_pretrained[[transformers.VisionEncoderDecoderModel.from_encoder_decoder_pretrained]]

```python
from_encoder_decoder_pretrained(encoder_pretrained_model_name_or_path: str | None = None, decoder_pretrained_model_name_or_path: str | None = None, *model_args, **kwargs)
```

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vision_encoder_decoder/modeling_vision_encoder_decoder.py#L155)

**パラメータ:**

encoder_pretrained_model_name_or_path (`str`, *任意*) : 画像エンコーダーの初期化に必要な情報。以下のいずれかです。 - huggingface.co のモデルリポジトリにホストされている事前学習済みモデルの *モデル ID* を示す文字列。例: `google/vit-base-patch16-224-in21k`。 - [save_pretrained()](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel.save_pretrained) を使用してモデルの重みを保存した *ディレクトリ* へのパス。例: `./my_model_directory/`。

decoder_pretrained_model_name_or_path (`str`, *任意*, デフォルトは `None`) : テキストデコーダーを開始するために必要な情報。以下のいずれかです。 - huggingface.co のモデルリポジトリにホストされている事前学習済みモデルの *モデル ID* を示す文字列。 - [save_pretrained()](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel.save_pretrained) を使用して保存されたモデルの重みを含む *ディレクトリ* へのパス。例: `./my_model_directory/`。

model_args (残りの位置引数、*任意*) : 残りのすべての位置引数は、基盤となるモデルの `__init__` メソッドに渡されます。

kwargs （残りのキーワード引数の辞書、*任意*）: 設定オブジェクト（読み込み後）の更新とモデルの初期化に使用できます（例: `output_attentions=True`）。 - エンコーダーの設定を更新するには、各設定パラメータにプレフィックス *encoder_* を使用します。 - デコーダーの設定を更新するには、各設定パラメータにプレフィックス *decoder_* を使用します。 - 親モデルの設定を更新するには、各設定パラメータにプレフィックスを使用しません。 `config` が提供されるか、自動的に読み込まれるかによって動作が異なります。

Transformers ライブラリの1つまたは2つのベースクラスから、事前学習済みモデルのチェックポイントを使用してエンコーダーとデコーダーをインスタンス化します。

モデルはデフォルトで`model.eval()`によって評価モードに設定されています（Dropoutモジュールは無効化されます）。モデルを学習するには、まず`model.train()`で学習モードに戻す必要があります。

例:

```python
>>> from transformers import VisionEncoderDecoderModel

>>> # initialize a vit-bert from a pretrained ViT and a pretrained BERT model. Note that the cross-attention layers will be randomly initialized
>>> model = VisionEncoderDecoderModel.from_encoder_decoder_pretrained(
...     "google/vit-base-patch16-224-in21k", "google-bert/bert-base-uncased"
... )
>>> # saving model after fine-tuning
>>> model.save_pretrained("./vit-bert")
>>> # load fine-tuned model
>>> model = VisionEncoderDecoderModel.from_pretrained("./vit-bert")
```