# Encoder Decoder Modelleri

[`EncoderDecoderModel`](https://huggingface.co/papers/1706.03762), herhangi bir önceden eğitilmiş otoenkoder ve önceden eğitilmiş otoregresif model ile bir diziden-diziye (sequence-to-sequence) modelini başlatır. [BertModel](/docs/transformers/v5.23.0/tr/model_doc/bert#transformers.BertModel)'u hem kodlayıcı hem de çözücü olarak kullanan [Önceden Eğitilmiş Kodlayıcılarla Metin Özetleme](https://huggingface.co/papers/1908.08345) makalesinde gösterildiği gibi, dizi üretme görevleri için etkilidir.

> [!TIP]
> Bu model [thomwolf](https://huggingface.co/thomwolf) tarafından katkıda bulunmuştur.
>
> Farklı dil görevlerine Encoder Decoder'ı nasıl uygulayacağınızla ilgili daha fazla örnek için sağ kenar çubuğundaki Encoder Decoder modellerine tıklayın.

Aşağıdaki örnek, [Pipeline](/docs/transformers/v5.23.0/tr/main_classes/pipelines#transformers.Pipeline), [AutoModel](/docs/transformers/v5.23.0/tr/model_doc/auto#transformers.AutoModel) ve komut satırından metin üretmenin nasıl yapılacağını göstermektedir.

```python
from transformers import AutoModelForCausalLM, AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("patrickvonplaten/bert2bert-cnn_dailymail-fp16")
model = AutoModelForCausalLM.from_pretrained("patrickvonplaten/bert2bert-cnn_dailymail-fp16", device_map="auto",attn_implementation="sdpa")

text = "Plants create energy through a process known as photosynthesis. This involves capturing sunlight and converting carbon dioxide and water into glucose and oxygen."

inputs = tokenizer(text, return_tensors="pt", truncation=True, padding=True).to(model.device)

summary = model.generate(**inputs, max_length=60, num_beams=4, early_stopping=True)
print(tokenizer.decode(summary[0], skip_special_tokens=True))
```

## Notlar

- [EncoderDecoderModel](/docs/transformers/v5.23.0/tr/model_doc/encoder-decoder#transformers.EncoderDecoderModel), herhangi bir önceden eğitilmiş encoder ve decoder kullanılarak başlatılabilir. Ancak decoder mimarisine bağlı olarak, cross-attention katmanları rastgele başlatılabilir.

Bu modeller, bu [blog yazısında](https://huggingface.co/blog/warm-starting-encoder-decoder) tartışıldığı gibi, aşağı akış ince ayarı gerektirir. Kodlayıcı ve çözücü denetim noktalarını birleştirmek için [from_encoder_decoder_pretrained()](/docs/transformers/v5.23.0/tr/model_doc/encoder-decoder#transformers.EncoderDecoderModel.from_encoder_decoder_pretrained) kullanın.

```python
from transformers import BertTokenizer, EncoderDecoderModel

tokenizer = BertTokenizer.from_pretrained("google-bert/bert-base-uncased")
model = EncoderDecoderModel.from_encoder_decoder_pretrained(
    "google-bert/bert-base-uncased",
    "google-bert/bert-base-uncased"
)
```

- Encoder Decoder modelleri, BART, T5 veya herhangi bir başka encoder-decoder modeli gibi ince ayarlanabilir. Kayıp (loss) hesaplamak için yalnızca `input_ids` ve `labels` olmak üzere 2 girdi gereklidir. Daha ayrıntılı bir eğitim örneği için bu [notebook](https://colab.research.google.com/drive/1WIk2bxglElfZewOHboPFNj8H44_VAyKE?usp=sharing#scrollTo=ZwQIEhKOrJpl)'a bakın.

```python
from transformers import BertTokenizer, EncoderDecoderModel

tokenizer = BertTokenizer.from_pretrained("google-bert/bert-base-uncased")
model = EncoderDecoderModel.from_encoder_decoder_pretrained("google-bert/bert-base-uncased", "google-bert/bert-base-uncased")

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

input_ids = tokenizer(
    "The tower is 324 metres (1,063 ft) tall, about the same height as an 81-storey building, and the tallest structure in Paris. Its base is square, measuring 125 metres (410 ft) on each side.During its construction, the Eiffel Tower surpassed the Washington Monument to become the tallest man-made structure in the world, a title it held for 41 years until the Chrysler Building in New York City was  finished in 1930. It was the first structure to reach a height of 300 metres. Due to the addition of a broadcasting aerial at the top of the tower in 1957, it is now taller than the Chrysler Building by 5.2 metres (17 ft).Excluding transmitters, the Eiffel Tower is the second tallest free-standing structure in France after the Millau Viaduct.",
    return_tensors="pt",
).input_ids

labels = tokenizer(
    "the eiffel tower surpassed the washington monument to become the tallest structure in the world. it was the first structure to reach a height of 300 metres in paris in 1930. it is now taller than the chrysler building by 5. 2 metres ( 17 ft ) and is the second tallest free - standing structure in paris.",
    return_tensors="pt",
).input_ids

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

- [EncoderDecoderModel](/docs/transformers/v5.23.0/tr/model_doc/encoder-decoder#transformers.EncoderDecoderModel), aşağıda gösterildiği gibi bir encoder ve bir decoder yapılandırmasından rastgele başlatılabilir.

```python
from transformers import BertConfig, EncoderDecoderConfig, EncoderDecoderModel

config_encoder = BertConfig()
config_decoder = BertConfig()

config = EncoderDecoderConfig.from_encoder_decoder_configs(config_encoder, config_decoder)
model = EncoderDecoderModel(config=config)
```

- Encoder Decoder Model, aşağıda gösterildiği gibi çeviri için de kullanılabilir.

```python
from transformers import AutoTokenizer, EncoderDecoderModel

# Load a pre-trained translation model
model_name = "google/bert2bert_L-24_wmt_en_de"
tokenizer = AutoTokenizer.from_pretrained(model_name, pad_token="<pad>", eos_token="</s>", bos_token="<s>")
model = EncoderDecoderModel.from_pretrained(model_name, device_map="auto")

# Input sentence to translate
input_text = "Plants create energy through a process known as"

# Encode the input text
inputs = tokenizer(input_text, return_tensors="pt", add_special_tokens=False).to(model.device).input_ids

# Generate the translated output
outputs = model.generate(inputs)[0]

# Decode the output tokens to get the translated sentence
translated_text = tokenizer.decode(outputs, skip_special_tokens=True)

print("Translated text:", translated_text)
```

## EncoderDecoderConfig[[transformers.EncoderDecoderConfig]]

#### transformers.EncoderDecoderConfig[[transformers.EncoderDecoderConfig]]

```python
transformers.EncoderDecoderConfig(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 | None = True, encoder: transformers.configuration_utils.PreTrainedConfig | dict | None = None, decoder: transformers.configuration_utils.PreTrainedConfig | dict | None = None, pad_token_id: int | None = None, decoder_start_token_id: int | None = None)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/encoder_decoder/configuration_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üğü.

pad_token_id (`int`, *isteğe bağlı*) : Sözlükte dolgu için kullanılan token kimliği.

decoder_start_token_id (`int`, *isteğe bağlı*) : Bir encoder-decoder modeli `bos` dışında farklı bir token ile çözümlemeye başlıyorsa, o token'ın kimliği.

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

Yapılandırma nesneleri [PreTrainedConfig](/docs/transformers/v5.23.0/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/v5.23.0/tr/main_classes/configuration#transformers.PreTrainedConfig) belgesini okuyun.

Örnekler:

```python
>>> from transformers import BertConfig, EncoderDecoderConfig, EncoderDecoderModel

>>> # Initializing a BERT google-bert/bert-base-uncased style configuration
>>> config_encoder = BertConfig()
>>> config_decoder = BertConfig()

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

>>> # Initializing a Bert2Bert model (with random weights) from the google-bert/bert-base-uncased style configurations
>>> model = EncoderDecoderModel(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 = EncoderDecoderConfig.from_pretrained("my-model")
>>> model = EncoderDecoderModel.from_pretrained("my-model", config=encoder_decoder_config)
```

#### from_encoder_decoder_configs[[transformers.EncoderDecoderConfig.from_encoder_decoder_configs]]

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

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/encoder_decoder/configuration_encoder_decoder.py#L74)

**Dönüş:** [EncoderDecoderConfig](/docs/transformers/v5.23.0/tr/model_doc/encoder-decoder#transformers.EncoderDecoderConfig)

Bir yapılandırma nesnesi örneği

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

## EncoderDecoderModel[[transformers.EncoderDecoderModel]]

#### transformers.EncoderDecoderModel[[transformers.EncoderDecoderModel]]

```python
transformers.EncoderDecoderModel(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/v5.23.0/src/transformers/models/encoder_decoder/modeling_encoder_decoder.py#L65)

**Parametreler:**

config ([PreTrainedConfig](/docs/transformers/v5.23.0/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/v5.23.0/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 head olmadan ham hidden-state çıktısı üreten çıplak Encoder Decoder Model.

Bu model [PreTrainedModel](/docs/transformers/v5.23.0/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.EncoderDecoderModel.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: 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, inputs_embeds: typing.Optional[torch.Tensor] = None, decoder_inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, **kwargs)
```

[Kaynak](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/encoder_decoder/modeling_encoder_decoder.py#L317)

**Parametreler:**

input_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Sözlükteki girdi dizisi belirteçlerinin (token) indeksleri. Varsayılan olarak dolgu (padding) yoksayılır. İndeksler [AutoTokenizer](/docs/transformers/v5.23.0/tr/model_doc/auto#transformers.AutoTokenizer) kullanılarak elde edilebilir. Ayrıntılar için [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) ve [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) yöntemlerine bakın. [Girdi kimlikları (input IDs) nedir?](../glossary#input-ids)

attention_mask (`torch.Tensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Dolgu (padding) token indekslerinde dikkat (attention) işleminin uygulanmamasını sağlayan maske. `[0, 1]` aralığında seçilen maske değerleri:  - **maske uygulanmayan** tokenlar için 1, - **maske uygulanan** tokenlar için 0.  [Dikkat maskeleri nelerdir?](../glossary#attention-mask)

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/v5.23.0/tr/main_classes/tokenizer#transformers.PythonBackend) kullanılarak elde edilebilir. Ayrıntılar için [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) ve [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/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/v5.23.0/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/v5.23.0/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.

inputs_embeds (`torch.Tensor`, şekli `(batch_size, sequence_length, hidden_size)`, *isteğe bağlı*) : `input_ids` parametresini iletmek yerine, gömülü bir temsil doğrudan iletmeyi tercih edebilirsiniz. Bu, `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.

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

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

[Seq2SeqLMOutput](/docs/transformers/v5.23.0/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 ([EncoderDecoderConfig](/docs/transformers/v5.23.0/tr/model_doc/encoder-decoder#transformers.EncoderDecoderConfig)) ve girdilere bağlı olarak çeşitli öğelerden oluşur.

[EncoderDecoderModel](/docs/transformers/v5.23.0/tr/model_doc/encoder-decoder#transformers.EncoderDecoderModel) 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/v5.23.0/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 EncoderDecoderModel, BertTokenizer
>>> import torch

>>> tokenizer = BertTokenizer.from_pretrained("google-bert/bert-base-uncased")
>>> model = EncoderDecoderModel.from_encoder_decoder_pretrained(
...     "google-bert/bert-base-uncased", "google-bert/bert-base-uncased"
... )  # initialize Bert2Bert from pre-trained checkpoints

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

>>> input_ids = tokenizer("This is a really long text", return_tensors="pt").input_ids
>>> labels = tokenizer("This is the corresponding summary", return_tensors="pt").input_ids
>>> outputs = model(input_ids=input_ids, labels=labels)
>>> loss, logits = outputs.loss, outputs.logits

>>> # save and load from pretrained
>>> model.save_pretrained("bert2bert")
>>> model = EncoderDecoderModel.from_pretrained("bert2bert")

>>> # generation
>>> generated = model.generate(input_ids)
```

#### from_encoder_decoder_pretrained[[transformers.EncoderDecoderModel.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/v5.23.0/src/transformers/models/encoder_decoder/modeling_encoder_decoder.py#L182)

**Parametreler:**

encoder_pretrained_model_name_or_path (`str`, *isteğe bağlı*) : Kodlayıcıyı 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/v5.23.0/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/`.

decoder_pretrained_model_name_or_path (`str`, *isteğe bağlı*, varsayılan `None`) : Dekoderi 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/v5.23.0/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 EncoderDecoderModel

>>> # initialize a bert2bert from two pretrained BERT models. Note that the cross-attention layers will be randomly initialized
>>> model = EncoderDecoderModel.from_encoder_decoder_pretrained("google-bert/bert-base-uncased", "google-bert/bert-base-uncased")
>>> # saving model after fine-tuning
>>> model.save_pretrained("./bert2bert")
>>> # load fine-tuned model
>>> model = EncoderDecoderModel.from_pretrained("./bert2bert")
```

