# Konuşma Kodlayıcı Çözücü Modelleri

[SpeechEncoderDecoderModel](/docs/transformers/main/tr/model_doc/speech-encoder-decoder#transformers.SpeechEncoderDecoderModel), herhangi bir önceden eğitilmiş konuşma oto-kodlama modelini kodlayıcı olarak (*ör.* [Wav2Vec2](wav2vec2), [Hubert](hubert)) ve herhangi bir önceden eğitilmiş otoregresif modeli çözücü olarak kullanarak bir konuşmadan metne modelini başlatmak için kullanılabilir.

Konuşma dizisinden metin dizisine modellemelerin, konuşma tanıma ve konuşma çevirisi için önceden eğitilmiş denetim noktalarıyla başlatılmasının etkinliği, Changhan Wang, Anne Wu, Juan Pino, Alexei Baevski, Michael Auli ve Alexis Conneau tarafından [Large-Scale Self- and Semi-Supervised Learning for Speech Translation](https://huggingface.co/papers/2104.06678) makalesinde *örneğin* gösterilmiştir.

[SpeechEncoderDecoderModel](/docs/transformers/main/tr/model_doc/speech-encoder-decoder#transformers.SpeechEncoderDecoderModel) sınıfının çıkarım (inference) için nasıl kullanılacağına bir örnek, Speech2Text2 decoder'ı ile görülebilir.

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

[SpeechEncoderDecoderModel](/docs/transformers/main/tr/model_doc/speech-encoder-decoder#transformers.SpeechEncoderDecoderModel), bir encoder ve bir decoder yapılandırmasından rastgele başlatılabilir. Aşağıdaki örnekte, encoder için varsayılan [Wav2Vec2Model](/docs/transformers/main/tr/model_doc/wav2vec2#transformers.Wav2Vec2Model) 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, SpeechEncoderDecoderConfig, SpeechEncoderDecoderModel, Wav2Vec2Config

config_encoder = Wav2Vec2Config()
config_decoder = BertConfig()

config = SpeechEncoderDecoderConfig.from_encoder_decoder_configs(config_encoder, config_decoder)
model = SpeechEncoderDecoderModel(config=config)
```

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

[SpeechEncoderDecoderModel](/docs/transformers/main/tr/model_doc/speech-encoder-decoder#transformers.SpeechEncoderDecoderModel), ö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ı konuşma modeli, *örneğin* [Wav2Vec2](wav2vec2), [Hubert](hubert) kodlayıcı olarak kullanılabilir ve hem önceden eğitilmiş otomatik kodlama modelleri, *örneğin* BERT, hem de önceden eğitilmiş nedensel dil modelleri, *örneğin* GPT2, ayrıca 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. [SpeechEncoderDecoderModel](/docs/transformers/main/tr/model_doc/speech-encoder-decoder#transformers.SpeechEncoderDecoderModel)'in önceden eğitilmiş bir kodlayıcı ve çözücü kontrol noktasından başlatılması, [*Warm-starting-encoder-decoder blog yazısında*](https://huggingface.co/blog/warm-starting-encoder-decoder) gösterildiği gibi, modelin bir aşağı akış görevinde ince ayar gerektirir. Bunu yapmak için `SpeechEncoderDecoderModel` sınıfı, [SpeechEncoderDecoderModel.from_encoder_decoder_pretrained()](/docs/transformers/main/tr/model_doc/speech-encoder-decoder#transformers.SpeechEncoderDecoderModel.from_encoder_decoder_pretrained) yöntemini sağlar.

```python
from transformers import SpeechEncoderDecoderModel

model = SpeechEncoderDecoderModel.from_encoder_decoder_pretrained(
    "facebook/hubert-large-ll60k", "google-bert/bert-base-uncased"
)
```

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

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

Çıkarım yapmak için, metni otoregresif olarak üretmenizi sağlayan `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
from transformers import Wav2Vec2Processor, SpeechEncoderDecoderModel
from datasets import load_dataset
import torch

# load a fine-tuned speech translation model and corresponding processor
model = SpeechEncoderDecoderModel.from_pretrained("facebook/wav2vec2-xls-r-300m-en-to-15", device_map="auto")
processor = Wav2Vec2Processor.from_pretrained("facebook/wav2vec2-xls-r-300m-en-to-15")

# let's perform inference on a piece of English speech (which we'll translate to German)
ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
input_values = processor(ds[0]["audio"]["array"], return_tensors="pt").to(model.device).input_values

# autoregressively generate transcription (uses greedy decoding by default)
generated_ids = model.generate(input_values)
generated_text = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
print(generated_text)
Mr. Quilter ist der Apostel der Mittelschicht und wir freuen uns, sein Evangelium willkommen heißen zu können.
```

## Eğitim

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

```python
from datasets import load_dataset

from transformers import AutoFeatureExtractor, AutoTokenizer, SpeechEncoderDecoderModel

encoder_id = "facebook/wav2vec2-base-960h"  # acoustic model encoder
decoder_id = "google-bert/bert-base-uncased"  # text decoder

feature_extractor = AutoFeatureExtractor.from_pretrained(encoder_id)
tokenizer = AutoTokenizer.from_pretrained(decoder_id)
# Combine pre-trained encoder and pre-trained decoder to form a Seq2Seq model
model = SpeechEncoderDecoderModel.from_encoder_decoder_pretrained(encoder_id, decoder_id)

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

# load an audio input and pre-process (normalise mean/std to 0/1)
ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
input_values = feature_extractor(ds[0]["audio"]["array"], return_tensors="pt").to(model.device).input_values

# load its corresponding transcription and tokenize to generate labels
labels = tokenizer(ds[0]["text"], return_tensors="pt").to(model.device).input_ids

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

## SpeechEncoderDecoderConfig[[transformers.SpeechEncoderDecoderConfig]]

#### transformers.SpeechEncoderDecoderConfig[[transformers.SpeechEncoderDecoderConfig]]

```python
transformers.SpeechEncoderDecoderConfig(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)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/speech_encoder_decoder/configuration_speech_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 Ses Kodlayıcı ÇözücüModelinin yapılandırmasını depolamak için kullanılan yapılandırma sınıfıdır. Belirtilen argümanlara göre bir Ses Kodlayıcı Çözücü 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/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, Wav2Vec2Config, SpeechEncoderDecoderConfig, SpeechEncoderDecoderModel

>>> # Initializing a Wav2Vec2 & BERT style configuration
>>> config_encoder = Wav2Vec2Config()
>>> config_decoder = BertConfig()

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

>>> # Initializing a Wav2Vec2Bert model from a Wav2Vec2 & google-bert/bert-base-uncased style configurations
>>> model = SpeechEncoderDecoderModel(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 = SpeechEncoderDecoderConfig.from_pretrained("my-model")
>>> model = SpeechEncoderDecoderModel.from_pretrained("my-model", config=encoder_decoder_config)
```

#### from_encoder_decoder_configs[[transformers.SpeechEncoderDecoderConfig.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/speech_encoder_decoder/configuration_speech_encoder_decoder.py#L72)

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

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 [SpeechEncoderDecoderConfig](/docs/transformers/main/tr/model_doc/speech-encoder-decoder#transformers.SpeechEncoderDecoderConfig) (veya türetilmiş bir sınıf) örnekleyin.

## SpeechEncoderDecoderModel[[transformers.SpeechEncoderDecoderModel]]

#### transformers.SpeechEncoderDecoderModel[[transformers.SpeechEncoderDecoderModel]]

```python
transformers.SpeechEncoderDecoderModel(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/speech_encoder_decoder/modeling_speech_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 head olmadan ham hidden-state'ler üreten çıplak Speech 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.SpeechEncoderDecoderModel.forward]]

```python
forward(inputs: typing.Optional[torch.Tensor] = 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, 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, input_values: typing.Optional[torch.Tensor] = None, input_features: typing.Optional[torch.Tensor] = None, return_dict: bool | None = None, **kwargs)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/speech_encoder_decoder/modeling_speech_encoder_decoder.py#L308)

**Parametreler:**

inputs (`torch.Tensor`, şekli `(batch_size, sequence_length)` veya `(batch_size, sequence_length, feature_dim)`, *isteğe bağlı*) : Girdi ham ses dalgası formunun veya ses özelliklerinin float değerleri. Değerler, bir `.flac` veya `.wav` ses dosyasını `list[float]` tipinde bir diziye, `numpy.ndarray` veya `torch.Tensor` içine yükleyerek elde edilebilir, *örneğin* torchcodec kütüphanesi (`pip install torchcodec`) veya soundfile kütüphanesi (`pip install soundfile`) aracılığıyla. `inputs` dizisini hazırlamak için, `torch.Tensor` tipinde bir tensöre dolgu ve dönüştürme amacıyla [Wav2Vec2Processor](/docs/transformers/main/tr/model_doc/wav2vec2#transformers.Wav2Vec2Processor) veya [Speech2TextProcessor](/docs/transformers/main/tr/model_doc/speech_to_text#transformers.Speech2TextProcessor) kullanılmalıdır.

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/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.

input_values (`torch.Tensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Girdi ham ses dalgasının float değerleri. Değerler, bir *.flac* veya *.wav* ses dosyasını *list[float]* türünde bir diziye veya *numpy.ndarray*'ye yükleyerek elde edilebilir, *örneğin* torchcodec kütüphanesi (`pip install torchcodec`) veya soundfile kütüphanesi (`pip install soundfile`) aracılığıyla. Diziyi *input_values* için hazırlamak için, [Wav2Vec2Processor](/docs/transformers/main/tr/model_doc/wav2vec2#transformers.Wav2Vec2Processor) dolgu ve *torch.Tensor* türünde bir tensöre dönüştürme için kullanılmalıdır. Ayrıntılar için [Wav2Vec2Processor.__call__()](/docs/transformers/main/tr/model_doc/wav2vec2#transformers.Wav2Vec2Processor.__call__)'a bakın.

input_features (`torch.Tensor`, şekli `(batch_size, sequence_length, feature_dim)`, *isteğe bağlı*) : Girdi ses özelliklerine karşılık gelen tensörler. Ses özellikleri `feature_extractor_class` kullanılarak elde edilebilir. Ayrıntılar için `feature_extractor_class.__call__` bölümüne bakın (`processor_class`, sesleri işlemek için `feature_extractor_class` kullanır).

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

[SpeechEncoderDecoderModel](/docs/transformers/main/tr/model_doc/speech-encoder-decoder#transformers.SpeechEncoderDecoderModel) 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 SpeechEncoderDecoderModel, AutoProcessor
>>> from datasets import load_dataset
>>> import torch

>>> processor = AutoProcessor.from_pretrained("facebook/wav2vec2-xls-r-300m-en-to-15")
>>> model = SpeechEncoderDecoderModel.from_pretrained("facebook/wav2vec2-xls-r-300m-en-to-15")

>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")

>>> input_values = processor(ds[0]["audio"]["array"], return_tensors="pt").input_values
>>> # Inference: Translate English speech to German
>>> generated = model.generate(input_values)
>>> decoded = processor.batch_decode(generated, skip_special_tokens=True)[0]
>>> decoded
'Mr. Quilter ist der Apostel der Mittelschicht und wir freuen uns, sein Evangelium willkommen heißen zu können.'

>>> # Training: Train model on English transcription
>>> labels = processor(text=ds[0]["text"], return_tensors="pt").input_ids

>>> loss = model(input_values, labels=labels).loss
>>> loss.backward()
```

#### from_encoder_decoder_pretrained[[transformers.SpeechEncoderDecoderModel.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/speech_encoder_decoder/modeling_speech_encoder_decoder.py#L163)

**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/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/`.

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/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 SpeechEncoderDecoderModel

>>> # initialize a wav2vec2bert from a pretrained Wav2Vec2 and a pretrained BERT model. Note that the cross-attention layers will be randomly initialized
>>> model = SpeechEncoderDecoderModel.from_encoder_decoder_pretrained(
...     "facebook/wav2vec2-base-960h", "google-bert/bert-base-uncased"
... )
>>> # saving model after fine-tuning
>>> model.save_pretrained("./wav2vec2bert")
>>> # load fine-tuned model
>>> model = SpeechEncoderDecoderModel.from_pretrained("./wav2vec2bert")
```