# Görüntü Kodlayıcı Çözücü Modelleri

## Genel Bakış

[VisionEncoderDecoderModel](/docs/transformers/main/tr/model_doc/vision-encoder-decoder#transformers.VisionEncoderDecoderModel), herhangi bir önceden eğitilmiş Transformer tabanlı görme modelini kodlayıcı (*ör.* [ViT](vit), [BEiT](beit), [DeiT](deit), [Swin](swin)) ve herhangi bir önceden eğitilmiş dil modelini çözücü (*ör.* [RoBERTa](roberta), [GPT2](gpt2), [BERT](bert), [DistilBERT](distilbert)) olarak kullanarak görüntüden metne modelini başlatmak için kullanılabilir.

Görselden metin dizisine modellerin önceden eğitilmiş denetim noktalarıyla başlatılmasının etkinliği, Minghao Li, Tengchao Lv, Lei Cui, Yijuan Lu, Dinei Florencio, Cha Zhang, Zhoujun Li, Furu Wei tarafından yazılan [TrOCR: Transformer-based Optical Character Recognition with Pre-trained Models](https://huggingface.co/papers/2109.10282) (örneğin) makalesinde gösterilmiştir.

Böyle bir [VisionEncoderDecoderModel](/docs/transformers/main/tr/model_doc/vision-encoder-decoder#transformers.VisionEncoderDecoderModel) eğitildikten/ince ayarlandıktan sonra, diğer modeller gibi kaydedilebilir/yüklenebilir (daha fazla bilgi için aşağıdaki örnekleri inceleyin).

Örnek bir uygulama, görüntü açıklama (image captioning) işlemidir; bu işlemde kodlayıcı (encoder) görüntüyü kodlamak için kullanılır ve ardından otoregresif bir dil modeli açıklamayı üretir. Bir diğer örnek ise optik karakter tanımadır. [VisionEncoderDecoderModel](/docs/transformers/main/tr/model_doc/vision-encoder-decoder#transformers.VisionEncoderDecoderModel) sınıfının bir örneği olan [TrOCR](trocr) modeline bakınız.

## Model yapılandırmalarından `VisionEncoderDecoderModel` için rastgele başlatma

[VisionEncoderDecoderModel](/docs/transformers/main/tr/model_doc/vision-encoder-decoder#transformers.VisionEncoderDecoderModel), bir encoder ve bir decoder yapılandırmasından rastgele başlatılabilir. Aşağıdaki örnekte, encoder için varsayılan [ViTModel](/docs/transformers/main/tr/model_doc/vit#transformers.ViTModel) yapılandırmasını ve decoder için varsayılan `BertForCausalLM` yapılandırmasını kullanarak bunun nasıl yapılacağını gösteriyoruz.

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

## Önceden eğitilmiş bir kodlayıcı ve önceden eğitilmiş bir çözücüden `VisionEncoderDecoderModel` başlatma

[VisionEncoderDecoderModel](/docs/transformers/main/tr/model_doc/vision-encoder-decoder#transformers.VisionEncoderDecoderModel), önceden eğitilmiş bir kodlayıcı kontrol noktası ve önceden eğitilmiş bir çözücü kontrol noktasından başlatılabilir. Dikkat edin, herhangi bir önceden eğitilmiş Transformer tabanlı görme modeli, *örneğin* [Swin](swin), kodlayıcı olarak kullanılabilir ve hem önceden eğitilmiş otomatik kodlama modelleri, *örneğin* BERT, hem önceden eğitilmiş nedensel dil modelleri, *örneğin* GPT2, hem de diziden-diziye modellerin önceden eğitilmiş çözücü kısmı, *örneğin* BART'ın çözücüsü, çözücü olarak kullanılabilir. Çözücü olarak hangi mimariyi seçtiğinize bağlı olarak, çapraz dikkat katmanları rastgele başlatılabilir. [VisionEncoderDecoderModel](/docs/transformers/main/tr/model_doc/vision-encoder-decoder#transformers.VisionEncoderDecoderModel)'in önceden eğitilmiş bir kodlayıcı ve çözücü kontrol noktasından başlatılması, [*Warm-starting-encoder-decoder blog yazısında* gösterildiği gibi](https://huggingface.co/blog/warm-starting-encoder-decoder), modelin bir aşağı akış görevinde ince ayar gerektirir. Bunu yapmak için `VisionEncoderDecoderModel` sınıfı, [VisionEncoderDecoderModel.from_encoder_decoder_pretrained()](/docs/transformers/main/tr/model_doc/vision-encoder-decoder#transformers.VisionEncoderDecoderModel.from_encoder_decoder_pretrained) yöntemini sağlar.

```python
from transformers import VisionEncoderDecoderModel

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

## Mevcut bir `VisionEncoderDecoderModel` kontrol noktasını yükleme ve çıkarım yapma

`VisionEncoderDecoderModel` sınıfının ince ayarlanmış denetim noktalarını yüklemek için, [VisionEncoderDecoderModel](/docs/transformers/main/tr/model_doc/vision-encoder-decoder#transformers.VisionEncoderDecoderModel), Transformers'taki diğer tüm model mimarileri gibi `from_pretrained(...)` yöntemini sağlar.

Çıkarım yapmak için, metni otoregresif olarak üretmeye olanak tanıyan `generate` metodu kullanılır. Bu metot, açgözlü, demet arama ve çok terimli örneklem gibi çeşitli çözümleme biçimlerini destekler.

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

## Eğitim

Model oluşturulduktan sonra, (görsel, metin) çiftlerinden oluşan bir veri setinde BART, T5 veya herhangi bir diğer kodlayıcı-çözücü modeli gibi ince ayarlanabilir. Görebileceğiniz gibi, modelin bir kayıp (loss) hesaplaması için yalnızca 2 girdi gereklidir: `pixel_values` (bunlar görsellerdir) ve `labels` (bunlar, kodlanmış hedef dizinin `input_ids` değerleridir).

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

Bu model [nielsr](https://github.com/nielsrogge) tarafından katkıda bulunmuştur.

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

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

**Parametreler:**

is_encoder_decoder (`bool`, *isteğe bağlı*, varsayılan `True`) : Modelin bir kodlayıcı/çözücü olarak kullanılıp kullanılmadığı.

encoder (`Union[~configuration_utils.PreTrainedConfig, dict]`, *isteğe bağlı*) : Encoder iskeletinin config nesnesi veya sözlüğü.

decoder (`Union[~configuration_utils.PreTrainedConfig, dict]`, *isteğe bağlı*) : Decoder iskeletinin config nesnesi veya sözlüğü.

Bu, bir Vision Encoder DecoderModel'in yapılandırmasını depolamak için kullanılan yapılandırma sınıfıdır. Belirtilen argümanlara göre bir Vision Encoder Decoder modelini örneklemek ve model mimarisini tanımlamak için kullanılır. Varsayılanlarla bir yapılandırma örneği oluşturmak, [None](https://huggingface.co/None) ile benzer bir yapılandırmaya yol açar.

Yapılandırma nesneleri [PreTrainedConfig](/docs/transformers/main/tr/main_classes/configuration#transformers.PreTrainedConfig) sınıfından türetilir ve model çıktılarını kontrol etmek için kullanılabilir. Daha fazla bilgi için [PreTrainedConfig](/docs/transformers/main/tr/main_classes/configuration#transformers.PreTrainedConfig) belgesini okuyun.

Örnekler:

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

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

**Dönüş:** [VisionEncoderDecoderConfig](/docs/transformers/main/tr/model_doc/vision-encoder-decoder#transformers.VisionEncoderDecoderConfig)

Bir yapılandırma nesnesi örneği

Önceden eğitilmiş bir kodlayıcı modeli yapılandırması ve kodlayıcı modeli yapılandırmasından bir [VisionEncoderDecoderConfig](/docs/transformers/main/tr/model_doc/vision-encoder-decoder#transformers.VisionEncoderDecoderConfig) (veya türetilmiş bir sınıf) örnekleyin.

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

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

**Parametreler:**

config ([PreTrainedConfig](/docs/transformers/main/tr/main_classes/configuration#transformers.PreTrainedConfig), *opsiyonel*) : Modelin tüm parametrelerini içeren model yapılandırma sınıfı. Bir yapılandırma dosyasıyla başlatmak, modelle ilişkili ağırlıkları yüklemez, yalnızca yapılandırmayı yükler. Model ağırlıklarını yüklemek için [from_pretrained()](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel.from_pretrained) yöntemine göz atın.

encoder (`PreTrainedModel`, *isteğe bağlı*) : Kullanılacak kodlayıcı modeli.

decoder (`PreTrainedModel`, *isteğe bağlı*) : Kullanılacak decoder modeli.

Üzerinde herhangi bir özel başlık olmadan ham gizli durumları (hidden-states) üreten çıplak Vision Encoder Decoder Model.

Bu model [PreTrainedModel](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel) sınıfından devralır. Kütüphanenin tüm modelleri için uyguladığı genel yöntemler (indirme veya kaydetme, giriş gömme boyutlarını yeniden ayarlama, başları budama vb.) için üst sınıf belgelendirmesine bakın.

Bu model aynı zamanda bir PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) alt sınıfıdır. Bunu standart bir PyTorch Module olarak kullanın ve genel kullanım ve davranışla ilgili tüm konular için PyTorch dokümantasyonuna başvurun.

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

```python
forward(pixel_values: typing.Optional[torch.Tensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.BoolTensor] = None, encoder_outputs: tuple[torch.Tensor] | None = None, past_key_values: transformers.cache_utils.Cache | None = None, decoder_inputs_embeds: typing.Optional[torch.Tensor] = 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)
```

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

**Parametreler:**

pixel_values (`torch.Tensor`, şekli `(batch_size, num_channels, image_size, image_size)`, *isteğe bağlı*) : Girdi görüntülerine karşılık gelen tensörler. Piksel değerleri `image_processor_class` kullanılarak elde edilebilir. Ayrıntılar için `image_processor_class.__call__` bölümüne bakın (`processor_class`, görüntüleri işlemek için `image_processor_class` kullanır).

decoder_input_ids (`torch.LongTensor`, şekli `(batch_size, target_sequence_length)`, *isteğe bağlı*) : Sözlükte çözücü giriş dizisi belirteçlerinin dizinleri. Dizinler [PreTrainedTokenizer](/docs/transformers/main/tr/main_classes/tokenizer#transformers.PythonBackend) kullanılarak elde edilebilir. Ayrıntılar için [PreTrainedTokenizer.encode()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) ve [PreTrainedTokenizer.__call__()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) bkz. [Giriş kimlikleri nelerdir?](../glossary#input-ids) `past_key_values` kullanılıyorsa, isteğe bağlı olarak yalnızca son `decoder_input_ids` girdi olarak verilmelidir (bkz. `past_key_values`). Eğitim için `decoder_input_ids`, model tarafından `labels` sağa kaydırılarak, -100 değeri `pad_token_id` ile değiştirilerek ve başlarına `decoder_start_token_id` eklenerek otomatik olarak oluşturulur.

decoder_attention_mask (`torch.BoolTensor`, şekli `(batch_size, target_sequence_length)`, *isteğe bağlı*) : Varsayılan davranış: `decoder_input_ids` içindeki dolgu (pad) jetonlarını yok sayan bir tensör oluşturur. Varsayılan olarak nedensel maske (causal mask) de kullanılır.

encoder_outputs (`tuple[torch.Tensor]`, *isteğe bağlı*) : (`last_hidden_state`, *isteğe bağlı*: `hidden_states`, *isteğe bağlı*: `attentions`) içeren bir demet. `last_hidden_state`, `(batch_size, sequence_length, hidden_size)` biçiminde, *isteğe bağlı*) kodlayıcının son katmanının çıktısındaki gizli durumlar dizisidir. Kodlayıcının çapraz dikkat (cross-attention) mekanizmasında kullanılır.

past_key_values (`~cache_utils.Cache`, *isteğe bağlı*) : Sıralı çözümlemeyi hızlandırmak için kullanılabilen, önceden hesaplanmış gizli durumlar (self-attention bloklarındaki ve cross-attention bloklarındaki anahtar ve değerler). Bu genellikle, `use_cache=True` veya `config.use_cache=True` olduğunda, çözümlemenin önceki bir aşamasında modelin döndürdüğü `past_key_values` değerlerinden oluşur. Girdi olarak yalnızca [Cache](/docs/transformers/main/tr/internal/generation_utils#transformers.Cache) örneği kabul edilir, bkz. [kv cache kılavuzu](https://huggingface.co/docs/transformers/en/kv_cache). `past_key_values` geçirilmezse, varsayılan olarak [DynamicCache](/docs/transformers/main/tr/internal/generation_utils#transformers.DynamicCache) başlatılır. Model, girdi olarak verilen aynı önbellek biçimini çıktı olarak verecektir. `past_key_values` kullanılıyorsa, kullanıcının, bu modele geçmiş anahtar-değer durumları verilmemiş olan, yalnızca işlenmemiş `input_ids` değerlerini (şekli `(batch_size, unprocessed_length)` olan) girmesi beklenir; bunun yerine, şekli `(batch_size, sequence_length)` olan tüm `input_ids` değerleri girilmez.

decoder_inputs_embeds (`torch.Tensor`, şekli `(batch_size, target_sequence_length, hidden_size)`, *isteğe bağlı*) : `decoder_input_ids` parametresini iletmek yerine, gömülü bir temsil doğrudan iletmeyi tercih edebilirsiniz. Bu, `decoder_input_ids` indekslerini ilgili vektörlere dönüştürme biçimi üzerinde modelin dahili gömme arama matrisine kıyasla daha fazla kontrol sahibi olmak istiyorsanız faydalıdır.

labels (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Dekoder için maskeli dil modelleme kaybını hesaplamak için etiketler. Endeksler `[-100, 0, ..., config.vocab_size]` aralığında olmalıdır (bkz. `input_ids` docstring). Endeksleri `-100` olarak ayarlanan tokenlar yok sayılır (maskelenir), kayıp yalnızca etiketleri `[0, ..., config.vocab_size]` aralığında olan tokenlar için hesaplanır.

use_cache (`bool`, *isteğe bağlı*) : `True` olarak ayarlanırsa, `past_key_values` anahtar değer durumları döndürülür ve çözümlemeyi hızlandırmak için kullanılabilir (bkz. `past_key_values`).

output_attentions (`bool`, *isteğe bağlı*) : Tüm dikkat katmanlarının dikkat tensörlerinin döndürülüp döndürülmediğini belirtir. Daha fazla ayrıntı için döndürülen tensörler altındaki `attentions` bölümüne bakın.

output_hidden_states (`bool`, *isteğe bağlı*) : Tüm katmanların gizli durumlarının (hidden states) döndürülüp döndürülmeyeceğini belirtir. Daha fazla ayrıntı için döndürülen tensörler altındaki `hidden_states` bölümüne bakın.

return_dict (`bool`, *isteğe bağlı*) : Düz bir tuple yerine [ModelOutput](/docs/transformers/main/tr/main_classes/output#transformers.utils.ModelOutput) döndürülecek mi?

**Dönüş:** [Seq2SeqLMOutput](/docs/transformers/main/tr/main_classes/output#transformers.modeling_outputs.Seq2SeqLMOutput) veya `tuple(torch.Tensor)`

[Seq2SeqLMOutput](/docs/transformers/main/tr/main_classes/output#transformers.modeling_outputs.Seq2SeqLMOutput) veya bir `torch.Tensor` demeti (eğer `return_dict=False` geçirildiyse veya `config.return_dict=False` ise), yapılandırma ([VisionEncoderDecoderConfig](/docs/transformers/main/tr/model_doc/vision-encoder-decoder#transformers.VisionEncoderDecoderConfig)) ve girdilere bağlı olarak çeşitli öğelerden oluşur.

[VisionEncoderDecoderModel](/docs/transformers/main/tr/model_doc/vision-encoder-decoder#transformers.VisionEncoderDecoderModel) forward metodu, `__call__` özel metodunu geçersiz kılar.

İleri geçiş tarifi bu fonksiyon içinde tanımlanmalı olsa da, sonrasında bunun yerine `Module` örneğini çağırmak gerekir; çünkü ilki ön ve son işleme adımlarını çalıştırmaktan sorumluyken ikincisi bunları sessizce yok sayar.

- **loss** (`torch.Tensor`, şekli `(1,)`, *isteğe bağlı*, `labels` sağlandığında döndürülür) -- Dil modelleme kaybı.
- **logits** (`torch.Tensor`, şekli `(batch_size, sequence_length, config.vocab_size)`) -- Dil modelleme başlığının tahmin puanları (SoftMax öncesi her sözlük jetonu için puanlar).
- **past_key_values** (`EncoderDecoderCache`, *isteğe bağlı*, `use_cache=True` geçirildiğinde veya `config.use_cache=True` olduğunda döndürülür) -- Bir [EncoderDecoderCache](/docs/transformers/main/tr/internal/generation_utils#transformers.EncoderDecoderCache) örneğidir. Daha fazla ayrıntı için [kv önbellek kılavuzumuza](https://huggingface.co/docs/transformers/en/kv_cache) bakın.

  Sıralı çözümlemeyi hızlandırmak için (bkz. `past_key_values` girdisi) kullanılabilen, önceden hesaplanmış gizli durumları (self-attention bloklarındaki ve cross-attention bloklarındaki anahtar ve değerler) içerir.
- **decoder_hidden_states** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_hidden_states=True` geçirildiğinde veya `config.output_hidden_states=True` olduğunda döndürülür) -- `torch.Tensor` (modelin bir gömme katmanı varsa gömme katmanının çıktısı için bir tane + her katmanın çıktısı için bir tane) içeren bir tuple, şekli `(batch_size, sequence_length, hidden_size)`.

  Her katmanın çıktısında ve başlangıç gömme çıktılarında dekodlayıcının gizli durumları.
- **decoder_attentions** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_attentions=True` geçirildiğinde veya `config.output_attentions=True` olduğunda döndürülür) -- `torch.Tensor` (her katman için bir tane) içeren bir tuple, şekli `(batch_size, num_heads, sequence_length, sequence_length)`.

  Dikkat yumuşatma (attention softmax) sonrasında, öz-dikkat (self-attention) kafalarında ağırlıklı ortalamanın hesaplanmasında kullanılan çözücü (decoder) dikkat ağırlıkları.
- **cross_attentions** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_attentions=True` geçirildiğinde veya `config.output_attentions=True` olduğunda döndürülür) -- `(batch_size, num_heads, sequence_length, sequence_length)` biçiminde, her katman için bir adet içeren `torch.Tensor` demeti.

  Dekoderin çapraz dikkat katmanının dikkat ağırlıkları, dikkat softmax'ından sonra, çapraz dikkat başlıklarında ağırlıklı ortalamanın hesaplanmasında kullanılır.
- **encoder_last_hidden_state** (`torch.Tensor`, şekli `(batch_size, sequence_length, hidden_size)`, *isteğe bağlı*) -- Modelin kodlayıcısının son katmanının çıktısındaki gizli durumlar dizisi.
- **encoder_hidden_states** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_hidden_states=True` geçirildiğinde veya `config.output_hidden_states=True` olduğunda döndürülür) -- `torch.Tensor` (modelin bir gömme katmanı varsa gömme katmanının çıktısı için bir tane + her katmanın çıktısı için birer tane) içeren, `(batch_size, sequence_length, hidden_size)` biçiminde bir demet.

  Her katmanın çıktısında ve başlangıç gömme çıktılarında kodlayıcının gizli durumları.
- **encoder_attentions** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_attentions=True` geçirildiğinde veya `config.output_attentions=True` olduğunda döndürülür) -- `torch.Tensor` (her katman için bir tane) içeren bir tuple, şekli `(batch_size, num_heads, sequence_length, sequence_length)`.

  Dikkat yumuşatma (attention softmax) sonrasında, öz-dikkat (self-attention) kafalarında ağırlıklı ortalamanın hesaplanmasında kullanılan kodlayıcının dikkat ağırlıkları.

Örnekler:

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

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

**Parametreler:**

encoder_pretrained_model_name_or_path (`str`, *isteğe bağlı*) : Görüntü kodlayıcısını başlatmak için gerekli bilgiler. Şunlardan biri olabilir:  - huggingface.co'daki bir model deposunda barındırılan önceden eğitilmiş bir modelin *model kimliği* olan bir dize. Bir örnek `google/vit-base-patch16-224-in21k`'tır. - [save_pretrained()](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel.save_pretrained) kullanılarak kaydedilmiş model ağırlıklarını içeren bir *dizin* yolu, örn. `./my_model_directory/`.

decoder_pretrained_model_name_or_path (`str`, *isteğe bağlı*, varsayılan `None`) : Metin çözücü başlatmak için gerekli bilgiler. Şunlardan biri olabilir:  - huggingface.co'daki bir model deposunda barındırılan önceden eğitilmiş bir modelin *model kimliği* olan bir dize. - [save_pretrained()](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel.save_pretrained) kullanılarak kaydedilmiş model ağırlıklarını içeren bir *dizin* yolu, örneğin `./my_model_directory/`.

model_args (kalan konumsal argümanlar, *isteğe bağlı*) : Tüm kalan konumsal argümanlar, alttaki modelin `__init__` yöntemine aktarılır.

kwargs (kalan anahtar kelime argümanları sözlüğü, *isteğe bağlı*) : Yapılandırma nesnesini (yüklenmesinin ardından) güncellemek ve modeli başlatmak için kullanılabilir (ör. `output_attentions=True`). - Kodlayıcı yapılandırmasını güncellemek için her yapılandırma parametresine *encoder_* öneki kullanın. - Çözücü yapılandırmasını güncellemek için her yapılandırma parametresine *decoder_* öneki kullanın. - Ana model yapılandırmasını güncellemek için her yapılandırma parametresine önek kullanmayın.  `config` sağlanıp sağlanmadığına veya otomatik olarak yüklenip yüklenmediğine göre farklı davranır.

Kütüphanenin bir veya iki temel sınıfından, önceden eğitilmiş model kontrol noktalarından bir kodlayıcı ve bir çözücü örneği oluşturun.

Model, varsayılan olarak `model.eval()` kullanılarak değerlendirme moduna ayarlanır (Dropout modülleri devre dışı bırakılır). Modeli eğitmek için önce `model.train()` ile eğitim moduna geri almanız gerekir.

Örnek:

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