# Wav2Vec2-Conformer

## Genel Bakış

Wav2Vec2-Conformer, Changhan Wang, Yun Tang, Xutai Ma, Anne Wu, Sravya Popuri, Dmytro Okhonko ve Juan Pino tarafından geliştirilen [fairseq S2T: Fast Speech-to-Text Modeling with fairseq](https://huggingface.co/papers/2010.05171)'in güncellenmiş sürümüne eklendi.

Modelin resmi sonuçları, makalenin Tablo 3 ve Tablo 4'ünde bulunabilir.

Wav2Vec2-Conformer ağırlıkları, Meta AI ekibi tarafından [Fairseq kütüphanesi](https://github.com/pytorch/fairseq/blob/main/examples/wav2vec/README.md#pre-trained-models) içinde yayımlandı.

Bu model [patrickvonplaten](https://huggingface.co/patrickvonplaten) tarafından katkıda bulunmuştur. Orijinal kod [burada](https://github.com/pytorch/fairseq/tree/main/examples/wav2vec) bulunabilir.

Not: Meta (FAIR), [Wav2Vec2-BERT 2.0](./wav2vec2-bert)'ın yeni bir sürümünü yayınladı - 4,5 milyon saatlik ses verisi üzerinde ön eğitildi. Özellikle ince ayar görevleri için kullanmanızı, örneğin [bu kılavuza](https://huggingface.co/blog/fine-tune-w2v2-bert) uygun olarak, özellikle öneriyoruz.

## Kullanım ipuçları

- Wav2Vec2-Conformer, Wav2Vec2 ile aynı mimariyi izler ancak [Conformer: Convolution-augmented Transformer for Speech Recognition](https://huggingface.co/papers/2005.08100) makalesinde tanıtılan *Conformer* bloğuyla *Attention* bloğunu değiştirir.
- Aynı katman sayısı için Wav2Vec2-Conformer, Wav2Vec2'den daha fazla parametre gerektirir ancak aynı zamanda
daha düşük kelime hata oranı.
- Wav2Vec2-Conformer, Wav2Vec2 ile aynı tokenizer ve feature extractor kullanır.
- Wav2Vec2-Conformer, doğru `config.position_embeddings_type` değerini ayarlayarak göreceli konum gömme kullanmayabilir, Transformer-XL benzeri konum gömme kullanabilir veya döner konum gömme kullanabilir.

## Kaynaklar

- [Ses sınıflandırma görevi kılavuzu](../tasks/audio_classification)
- [Otomatik konuşma tanıma görevi kılavuzu](../tasks/asr)

## Wav2Vec2ConformerConfig[[transformers.Wav2Vec2ConformerConfig]]

#### transformers.Wav2Vec2ConformerConfig[[transformers.Wav2Vec2ConformerConfig]]

```python
transformers.Wav2Vec2ConformerConfig(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, is_encoder_decoder: bool = False, 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, vocab_size: int | None = None, hidden_size: int = 768, num_hidden_layers: int = 12, num_attention_heads: int = 12, intermediate_size: int = 3072, hidden_act: str = 'gelu', hidden_dropout: float | int = 0.1, activation_dropout: float | int = 0.1, attention_dropout: float | int = 0.1, feat_proj_dropout: float | int = 0.0, feat_quantizer_dropout: float | int = 0.0, final_dropout: float | int = 0.1, layerdrop: float | int = 0.1, initializer_range: float = 0.02, layer_norm_eps: float = 1e-05, feat_extract_norm: str = 'group', feat_extract_activation: str = 'gelu', conv_dim: list[int] | tuple[int, ...] = (512, 512, 512, 512, 512, 512, 512), conv_stride: list[int] | tuple[int, ...] = (5, 2, 2, 2, 2, 2, 2), conv_kernel: list[int] | tuple[int, ...] = (10, 3, 3, 3, 3, 2, 2), conv_bias: bool = False, num_conv_pos_embeddings: int = 128, num_conv_pos_embedding_groups: int = 16, apply_spec_augment: bool = True, mask_time_prob: float | int = 0.05, mask_time_length: int = 10, mask_time_min_masks: int = 2, mask_feature_prob: float | int = 0.0, mask_feature_length: int = 10, mask_feature_min_masks: int = 0, num_codevectors_per_group: int = 320, num_codevector_groups: int = 2, contrastive_logits_temperature: float = 0.1, num_negatives: int = 100, codevector_dim: int = 256, proj_codevector_dim: int = 256, diversity_loss_weight: float = 0.1, ctc_loss_reduction: str = 'sum', ctc_zero_infinity: bool = False, use_weighted_layer_sum: bool = False, classifier_proj_size: int = 256, tdnn_dim: list[int] | tuple[int, ...] = (512, 512, 512, 512, 1500), tdnn_kernel: list[int] | tuple[int, ...] = (5, 3, 3, 1, 1), tdnn_dilation: list[int] | tuple[int, ...] = (1, 2, 3, 1, 1), xvector_output_dim: int = 512, pad_token_id: int | None = 0, bos_token_id: int | None = 1, eos_token_id: int | list[int] | None = 2, add_adapter: bool = False, adapter_kernel_size: int = 3, adapter_stride: int = 2, num_adapter_layers: int = 3, output_hidden_size: int | None = None, position_embeddings_type: str | None = 'relative', rotary_embedding_base: int = 10000, max_source_positions: int = 5000, conv_depthwise_kernel_size: int = 31, conformer_conv_dropout: float | int = 0.1)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_conformer/configuration_wav2vec2_conformer.py#L27)

**Parametreler:**

vocab_size (`int`, *isteğe bağlı*) : Modelin sözlük boyutu. `input_ids` tarafından temsil edilebilecek farklı token sayısını tanımlar.

hidden_size (`int`, *isteğe bağlı*, varsayılan `768`) : Gizli temsillerin boyutu.

num_hidden_layers (`int`, *isteğe bağlı*, varsayılan `12`) : Transformer decoder'ındaki gizli katman sayısı.

num_attention_heads (`int`, *isteğe bağlı*, varsayılan `12`) : Transformer decoder'ındaki her dikkat katmanı için dikkat başı sayısı.

intermediate_size (`int`, *isteğe bağlı*, varsayılan `3072`) : MLP temsil boyutu.

hidden_act (`str`, *isteğe bağlı*, varsayılan `gelu`) : Çözücüdeki doğrusal olmayan aktivasyon fonksiyonu (fonksiyon veya dize). Örneğin, `"gelu"`, `"relu"`, `"silu"` vb.

hidden_dropout (`Union[float, int]`, *isteğe bağlı*, varsayılan `0.1`) : Gömme, kodlayıcı ve havuzlayıcıdaki tüm tam bağlı katmanlar için dropout olasılığı.

activation_dropout (`Union[float, int]`, *isteğe bağlı*, varsayılan `0.1`) : Tamamen bağlı katmandaki aktivasyonlar için dropout oranı.

attention_dropout (`Union[float, int]`, *isteğe bağlı*, varsayılan `0.1`) : Dikkat olasılıkları için dropout oranı.

feat_proj_dropout (`float`, *opsiyonel*, varsayılan 0.0) : Özellik kodlayıcısının çıktısı için dropout olasılığı.

feat_quantizer_dropout (`float`, *opsiyonel*, varsayılan 0.0) : Kuantizatör tarafından kullanılan özellik kodlayıcısının çıktısı için dropout olasılığı.

final_dropout (`float`, *isteğe bağlı*, varsayılan 0.1) : [Wav2Vec2ConformerForCTC](/docs/transformers/main/tr/model_doc/wav2vec2-conformer#transformers.Wav2Vec2ConformerForCTC)'nin son projeksiyon katmanı için dropout olasılığı.

layerdrop (`Union[float, int]`, *isteğe bağlı*, varsayılan `0.1`) : LayerDrop olasılığı. Daha fazla ayrıntı için [LayerDrop makalesine](see https://huggingface.co/papers/1909.11556) bakın.

initializer_range (`float`, *opsiyonel*, varsayılan `0.02`) : Tüm ağırlık matrislerini başlatmak için kullanılan truncated_normal_initializer'ın standart sapması.

layer_norm_eps (`float`, *opsiyonel*, varsayılan `1e-05`) : Katman normalizasyonu katmanları tarafından kullanılan epsilon.

feat_extract_norm (`str`, *isteğe bağlı*, varsayılan `"group"`) : Özellik kodlayıcıdaki 1B konvolüsyonel katmanlara uygulanacak norm. Sadece ilk 1B konvolüsyonel katman için grup normalizasyonu olan `"group"` veya tüm 1B konvolüsyonel katmanlar için katman normalizasyonu olan `"layer"` değerlerinden biri.

feat_extract_activation (`str, `optional`, defaults to `"gelu"`) : The non-linear activation function (function or string) in the 1D convolutional layers of the feature extractor. If string, `"gelu"`, `"relu"`, `"selu"` and `"gelu_new"` are supported.

conv_dim (`tuple[int]` veya `list[int]`, *isteğe bağlı*, varsayılan `(512, 512, 512, 512, 512, 512, 512)`) : Özellik kodlayıcıdaki her 1D konvolüsyon katmanının giriş ve çıkış kanal sayısını tanımlayan tamsayılardan oluşan bir demet. *conv_dim*'in uzunluğu, 1D konvolüsyon katmanlarının sayısını belirler.

conv_stride (`tuple[int]` veya `list[int]`, *isteğe bağlı*, varsayılan `(5, 2, 2, 2, 2, 2, 2)`) : Özellik kodlayıcıdaki her 1D konvolüsyon katmanının adımını (stride) tanımlayan tamsayılardan oluşan bir demet. *conv_stride*'un uzunluğu, konvolüsyon katmanlarının sayısını belirler ve *conv_dim*'in uzunluğuyla eşleşmelidir.

conv_kernel (`tuple[int]` veya `list[int]`, *isteğe bağlı*, varsayılan `(10, 3, 3, 3, 3, 3, 3)`) : Özellik kodlayıcıdaki her 1D konvolüsyonel katmanın çekirdek boyutunu tanımlayan tamsayılar dizisi. *conv_kernel*'ın uzunluğu, konvolüsyonel katmanların sayısını belirler ve *conv_dim*'ın uzunluğuyla eşleşmelidir.

conv_bias (`bool`, *isteğe bağlı*, varsayılan `False`) : 1B konvolüsyonel katmanların bir sapma (bias) içerip içermediğini belirtir.

num_conv_pos_embeddings (`int`, *isteğe bağlı*, varsayılan 128) : Konvolüsyonel konumsal gömme sayısı. 1D konvolüsyonel konumsal gömme katmanının çekirdek boyutunu tanımlar.

num_conv_pos_embedding_groups (`int`, *isteğe bağlı*, varsayılan 16) : 1D konvolüsyonel konumsal gömme katmanının grup sayısı.

apply_spec_augment (`bool`, *isteğe bağlı*, varsayılan `True`) : Özellik kodlayıcısının çıktılarında *SpecAugment* veri artırma uygulamasının yapılıp yapılmayacağını belirtir. Referans için [SpecAugment: A Simple Data Augmentation Method for Automatic Speech Recognition](https://huggingface.co/papers/1904.08779) makalesine bakınız.

mask_time_prob (`float`, *opsiyonel*, varsayılan 0.05) : Zaman ekseni boyunca tüm özellik vektörlerinin, maskelenecek yüzdesi (0 ile 1 arasında). Maskeleme işlemi, eksen üzerinde ''mask_time_prob*len(time_axis)/mask_time_length'' adet bağımsız maske üretir. Maskelenecek vektör aralığının başlangıcı olarak seçilecek her özellik vektörünün olasılığından yola çıkarak akıl yürütülüyorsa, *mask_time_prob* değeri `prob_vector_start*mask_time_length` olmalıdır. Dikkat edin, örtüşme, maskelenen vektörlerin gerçek yüzdesini azaltabilir. Bu, yalnızca `apply_spec_augment is True` ise geçerlidir.

mask_time_length (`int`, *isteğe bağlı*, varsayılan 10) : Zaman ekseni boyunca vektör aralığının uzunluğu.

mask_time_min_masks (`int`, *opsiyonel*, varsayılan 2), : `mask_feature_prob` değerinden bağımsız olarak, zaman ekseninde üretilen, her zaman adımında, `mask_feature_length` uzunluğundaki maskelerin minimum sayısı. Yalnızca ''mask_time_prob*len(time_axis)/mask_time_length < mask_time_min_masks'' durumu geçerliyse ilgili.

mask_feature_prob (`float`, *opsiyonel*, varsayılan 0.0) : Özellik ekseni boyunca, maskeleme işlemine tabi tutulacak tüm özellik vektörlerinin yüzdesi (0 ile 1 arasında). Maskeleme işlemi, eksen üzerinde ''mask_feature_prob*len(feature_axis)/mask_time_length'' adet bağımsız maske üretir. Her bir özellik vektörünün, maskeleme işlemine tabi tutulacak vektör aralığının başlangıcı olarak seçilme olasılığından yola çıkarak akıl yürütülüyorsa, *mask_feature_prob* değeri `prob_vector_start*mask_feature_length` olmalıdır. Dikkat edin, örtüşme, maskeleme işlemine tabi tutulan vektörlerin gerçek yüzdesini azaltabilir. Bu, yalnızca `apply_spec_augment is True` ise geçerlidir.

mask_feature_prob (`Union[float, int]`, *isteğe bağlı*, varsayılan `0.0`) : Özellik ekseni boyunca, maskelenmesi istenen tüm özellik vektörlerinin yüzdesi (0 ile 1 arasında). Maskeleme işlemi, eksen üzerinde `mask_feature_prob*len(feature_axis)/mask_time_length` bağımsız maske üretir. Maskelenecek vektör aralığının başlangıcı olarak seçilecek her özellik vektörünün olasılığından yola çıkarak akıl yürütülürse, *mask_feature_prob* değeri `prob_vector_start*mask_feature_length` olmalıdır. Dikkat edin, örtüşme, maskelenen vektörlerin gerçek yüzdesini azaltabilir. Bu, yalnızca `apply_spec_augment` değeri `True` ise geçerlidir.

mask_feature_length (`int`, *isteğe bağlı*, varsayılan 10) : Özellik ekseni boyunca vektör aralığının uzunluğu.

mask_feature_min_masks (`int`, *opsiyonel*, varsayılan 0), : `mask_feature_prob` değerinden bağımsız olarak, her zaman adımında, özellik ekseni boyunca üretilen, uzunluğu `mask_feature_length` olan maskelerin minimum sayısı. Yalnızca ''mask_feature_prob*len(feature_axis)/mask_feature_length < mask_feature_min_masks'' durumu geçerliyse ilgili.

num_codevectors_per_group (`int`, *isteğe bağlı*, varsayılan 320) : Her kuantizasyon kod kitabındaki (gruptaki) giriş sayısı.

num_codevectors_per_group (`int`, *isteğe bağlı*, varsayılan 320) : Her kuantizasyon kod kitabındaki (gruptaki) giriş sayısı.

num_codevector_groups (`int`, *isteğe bağlı*, varsayılan 2) : Ürün kod vektörü kuantizasyonu için kod vektörü gruplarının sayısı.

contrastive_logits_temperature (`float`, *isteğe bağlı*, varsayılan 0.1) : Karşıtlık kaybındaki *kappa* sıcaklığı.

num_negatives (`int`, *isteğe bağlı*, varsayılan 100) : Karşıtlık kaybı için negatif örnek sayısı.

codevector_dim (`int`, *isteğe bağlı*, varsayılan 256) : Kuantize edilmiş özellik vektörlerinin boyutluluğu.

proj_codevector_dim (`int`, *isteğe bağlı*, varsayılan 256) : Hem kuantize hem de dönüştürücü özelliklerinin son projeksiyonunun boyutluluğu.

diversity_loss_weight (`int`, *opsiyonel*, varsayılan 0.1) : Kod kitabı çeşitlilik kaybı bileşeninin ağırlığı.

ctc_loss_reduction (`str`, *isteğe bağlı*, varsayılan `sum`) : `torch.nn.CTCLoss` çıktısına uygulanacak indirgemeyi belirtir. Yalnızca eğitim sırasında geçerlidir.

ctc_zero_infinity (`bool`, *isteğe bağlı*, varsayılan `False`) : `torch.nn.CTCLoss`'ün sonsuz kayıplarını ve ilişkili gradyanlarını sıfırlayıp sıfırlamayacağını belirtir. Sonsuz kayıplar, girdilerin hedeflerle hizalanmak için çok kısa olması durumunda ortaya çıkar. Yalnızca [Wav2Vec2ConformerForCTC](/docs/transformers/main/tr/model_doc/wav2vec2-conformer#transformers.Wav2Vec2ConformerForCTC) örneğinin eğitimi sırasında geçerlidir.

use_weighted_layer_sum (`bool`, *isteğe bağlı*, varsayılan `False`) : Öğrenmiş ağırlıklara sahip katman çıktıları ağırlıklı ortalamasının kullanılıp kullanılmayacağını belirtir. Yalnızca [Wav2Vec2ConformerForSequenceClassification](/docs/transformers/main/tr/model_doc/wav2vec2-conformer#transformers.Wav2Vec2ConformerForSequenceClassification) örneği kullanıldığında geçerlidir.

classifier_proj_size (`int`, *opsiyonel*, varsayılan 256) : Sınıflandırma için token ortalama havuzlamadan önceki projeksiyonun boyutluluğu.

tdnn_dim (`tuple[int]` veya `list[int]`, *isteğe bağlı*, varsayılan `(512, 512, 512, 512, 1500)`) : *XVector* modelinin *TDNN* modülündeki her bir 1D konvolüsyon katmanının çıktı kanal sayısını tanımlayan tamsayılardan oluşan bir demet. *tdnn_dim*'in uzunluğu, *TDNN* katmanlarının sayısını belirler.

tdnn_kernel (`tuple[int]` veya `list[int]`, *isteğe bağlı*, varsayılan `(5, 3, 3, 1, 1)`) : *XVector* modelinin *TDNN* modülündeki her bir 1D konvolüsyon katmanının çekirdek boyutunu tanımlayan tamsayılar dizisi. *tdnn_kernel*'ın uzunluğu, *tdnn_dim*'in uzunluğuyla eşleşmelidir.

tdnn_dilation (`tuple[int]` veya `list[int]`, *isteğe bağlı*, varsayılan `(1, 2, 3, 1, 1)`) : *XVector* modelinin *TDNN* modülündeki her bir 1D konvolüsyon katmanının dilasyon çarpanını tanımlayan tamsayılar dizisi. *tdnn_dilation*'ın uzunluğu, *tdnn_dim*'in uzunluğuyla eşleşmelidir.

xvector_output_dim (`int`, *isteğe bağlı*, varsayılan 512) : *XVector* gömme vektörlerinin boyutluluğu.

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

bos_token_id (`int`, *isteğe bağlı*, varsayılan `1`) : Sözlükte akış başlangıcı için kullanılan token kimliği.

eos_token_id (`Union[int, list[int]]`, *isteğe bağlı*, varsayılan `2`) : Sözlükte akış sonu için kullanılan token kimliği.

add_adapter (`bool`, *isteğe bağlı*, varsayılan `False`) : Wav2Vec2Conformer Encoder'ın üzerine konvolüsyonel bir ağ yığılmalı mı? SpeechEncoderDecoder modelleri için Wav2Vec2Conformer'ı ısıtmalı başlatmak için çok faydalı olabilir.

adapter_kernel_size (`int`, *opsiyonel*, varsayılan 3) : Adaptör ağındaki konvolüsyon katmanlarının çekirdek boyutu. Yalnızca `add_adapter is True` ise geçerlidir.

adapter_stride (`int`, *opsiyonel*, varsayılan 2) : Adaptör ağındaki konvolüsyon katmanlarının adım boyutu. Yalnızca `add_adapter is True` ise geçerlidir.

num_adapter_layers (`int`, *opsiyonel*, varsayılan 3) : Adaptör ağında kullanılması gereken konvolüsyonel katman sayısı. Yalnızca `add_adapter is True` ise geçerlidir.

output_hidden_size (`int`, *opsiyonel*) : Kodlayıcı çıktı katmanının boyutluluğu. Tanımlanmamışsa, bu varsayılan olarak *hidden-size* değerini alır. Yalnızca `add_adapter is True` ise geçerlidir.

position_embeddings_type (`str`, *isteğe bağlı*, varsayılan `"relative"`) : Göreli veya döner konum gömmelemeleri için sırasıyla `relative` veya `rotary` olarak belirtilebilir. `None` olarak bırakılırsa göreli konum gömmelemesi uygulanmaz.

rotary_embedding_base (`int`, *isteğe bağlı*, varsayılan 10000) : `"rotary"` konum gömlemeleri kullanılıyorsa, gömme tabanının boyutunu tanımlar.

max_source_positions (`int`, *isteğe bağlı*, varsayılan 5000) : `"relative"` konum gömme kullanılıyorsa, maksimum kaynak giriş konumlarını tanımlar.

conv_depthwise_kernel_size (`int`, *opsiyonel*, varsayılan 31) : Conformer bloklarındaki konvolüsyonel derinlikli 1D katmanının çekirdek boyutu.

conformer_conv_dropout (`float`, *opsiyonel*, varsayılan 0.1) : Conformer bloklarındaki tüm konvolüsyon katmanları için dropout olasılığı.

Bu, bir Wav2Vec2 ConformerModel yapılandırmasını depolamak için kullanılan yapılandırma sınıfıdır. Belirtilen argümanlara göre bir Wav2Vec2 Conformer modelini örneklemek ve model mimarisini tanımlamak için kullanılır. Varsayılanlarla bir yapılandırma örneği oluşturmak, [facebook/wav2vec2-conformer-rel-pos-large](https://huggingface.co/facebook/wav2vec2-conformer-rel-pos-large) modelinin yapılandırmasına benzer bir yapılandırma üretir.

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.

Örnek:

```python
>>> from transformers import Wav2Vec2ConformerConfig, Wav2Vec2ConformerModel

>>> # Initializing a Wav2Vec2Conformer facebook/wav2vec2-conformer-rel-pos-large style configuration
>>> configuration = Wav2Vec2ConformerConfig()

>>> # Initializing a model (with random weights) from the facebook/wav2vec2-conformer-rel-pos-large style configuration
>>> model = Wav2Vec2ConformerModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config
```

## Wav2Vec2Conformer'e özgü çıktılar[[transformers.models.wav2vec2_conformer.modeling_wav2vec2_conformer.Wav2Vec2ConformerForPreTrainingOutput]]

#### transformers.models.wav2vec2_conformer.modeling_wav2vec2_conformer.Wav2Vec2ConformerForPreTrainingOutput[[transformers.models.wav2vec2_conformer.modeling_wav2vec2_conformer.Wav2Vec2ConformerForPreTrainingOutput]]

```python
transformers.models.wav2vec2_conformer.modeling_wav2vec2_conformer.Wav2Vec2ConformerForPreTrainingOutput(loss: typing.Optional[torch.Tensor] = None, projected_states: typing.Optional[torch.Tensor] = None, projected_quantized_states: typing.Optional[torch.Tensor] = None, codevector_perplexity: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor] | None = None, attentions: tuple[torch.Tensor] | None = None, contrastive_loss: typing.Optional[torch.Tensor] = None, diversity_loss: typing.Optional[torch.Tensor] = None)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_conformer/modeling_wav2vec2_conformer.py#L46)

**Parametreler:**

loss (`*optional*`, `sample_negative_indices` geçirildiğinde döndürülür, `(1,)` biçiminde `torch.Tensor`) : [resmi makalede](https://huggingface.co/papers/2006.11477) belirtildiği üzere, kontrastif kayıp (L_m) ile çeşitlilik kaybının (L_d) toplamı olarak toplam kayıp.

projected_states (`torch.Tensor`, şekli `(batch_size, sequence_length, config.proj_codevector_dim)`) : Maskelenmiş projeksiyonlu kuantize durumları tahmin etmek için kullanılabilen, *config.proj_codevector_dim* boyutuna projekte edilmiş model gizli durumları.

projected_quantized_states (`torch.Tensor`, şekli `(batch_size, sequence_length, config.proj_codevector_dim)`) : Karşıtlı kayıp için pozitif hedef vektörleri temsil eden, *config.proj_codevector_dim*'ye yansıtılmış kuantize edilmiş çıkarılmış özellik vektörleri.

codevector_perplexity (`torch.Tensor`, şekli `(1,)`) : Kod kitabı çeşitliliğini ölçmek için kullanılan codevector dağılımının perplexity değeri.

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 bir demet, şekli `(batch_size, sequence_length, hidden_size)`. Modelin her katmanının çıktısındaki gizli durumlar ve isteğe bağlı başlangıç gömme çıktıları.

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 softmax'ı sonrası dikkat ağırlıkları, öz-dikkat başlıklarında ağırlıklı ortalamanın hesaplanmasında kullanılır.

contrastive_loss (`*optional*`, `sample_negative_indices` geçirildiğinde döndürülür, `torch.Tensor`, şekli `(1,)`) : [resmi makalede](https://huggingface.co/papers/2006.11477) belirtildiği gibi kontrastif kayıp (L_m).

diversity_loss (`*optional*`, `sample_negative_indices` geçirildiğinde döndürülür, şekli `(1,)` olan `torch.Tensor`) : [resmi makalede](https://huggingface.co/papers/2006.11477) belirtildiği gibi çeşitlilik kaybı (L_d).

[Wav2Vec2ConformerForPreTraining](/docs/transformers/main/tr/model_doc/wav2vec2-conformer#transformers.Wav2Vec2ConformerForPreTraining) için çıktı türü, potansiyel gizli durumlar ve dikkat mekanizmalarıyla birlikte.

## Wav2Vec2ConformerModel[[transformers.Wav2Vec2ConformerModel]]

#### transformers.Wav2Vec2ConformerModel[[transformers.Wav2Vec2ConformerModel]]

```python
transformers.Wav2Vec2ConformerModel(config: Wav2Vec2ConformerConfig)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_conformer/modeling_wav2vec2_conformer.py#L1078)

**Parametreler:**

config ([Wav2Vec2ConformerConfig](/docs/transformers/main/tr/model_doc/wav2vec2-conformer#transformers.Wav2Vec2ConformerConfig)) : 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 bakın.

Üzerinde herhangi bir özel başlık olmadan ham gizli durumları (hidden-states) üreten çıplak Wav2Vec2 Conformer Modeli.

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.Wav2Vec2ConformerModel.forward]]

```python
forward(input_values: typing.Optional[torch.Tensor], attention_mask: typing.Optional[torch.Tensor] = None, mask_time_indices: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_conformer/modeling_wav2vec2_conformer.py#L1149)

**Parametreler:**

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]` 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. Diziyi `input_values` için hazırlamak için, `torch.Tensor` tipinde bir tensöre dolgu ve dönüştürme amacıyla [AutoProcessor](/docs/transformers/main/tr/model_doc/auto#transformers.AutoProcessor) kullanılmalıdır. Ayrıntılar için [Wav2Vec2Processor.__call__()](/docs/transformers/main/tr/model_doc/wav2vec2#transformers.Wav2Vec2Processor.__call__) bölümüne bakın.

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)

mask_time_indices (`torch.BoolTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Karşıtlı kayıp için çıkarılan özellikleri maskelemek üzere kullanılacak indeksler. Eğitim modundayken, model *config.proj_codevector_dim* uzayında maskelenmiş çıkarılan özellikleri tahmin etmeyi öğrenir.

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

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

[Wav2Vec2ConformerModel](/docs/transformers/main/tr/model_doc/wav2vec2-conformer#transformers.Wav2Vec2ConformerModel) 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.

- **last_hidden_state** (`torch.Tensor`, şekli `(batch_size, sequence_length, hidden_size)`) -- Modelin son katmanının çıktısındaki gizli durumlar dizisi.
- **extract_features** (`torch.Tensor`, şekli `(batch_size, sequence_length, conv_dim[-1])`) -- Modelin son konvolüsyon katmanından çıkarılan özellik vektörlerinin dizisi.
- **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` (gömme çıktısı için bir tane + her katman çıktısı için bir tane) içeren, `(batch_size, sequence_length, hidden_size)` biçiminde bir demet.

  Her katmanın çıktısında modelin gizli durumları ve başlangıç gömme çıktıları.
- **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 softmax'ı sonrası dikkat ağırlıkları, öz-dikkat kafalarında ağırlıklı ortalamanın hesaplanmasında kullanılır.

## Wav2Vec2ConformerForCTC[[transformers.Wav2Vec2ConformerForCTC]]

#### transformers.Wav2Vec2ConformerForCTC[[transformers.Wav2Vec2ConformerForCTC]]

```python
transformers.Wav2Vec2ConformerForCTC(config: Wav2Vec2ConformerConfig, target_lang: str | None = None)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_conformer/modeling_wav2vec2_conformer.py#L1403)

**Parametreler:**

config ([Wav2Vec2ConformerConfig](/docs/transformers/main/tr/model_doc/wav2vec2-conformer#transformers.Wav2Vec2ConformerConfig)) : 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 bakın.

target_lang (`str`, *isteğe bağlı*) : Adaptör ağırlıklarının dil kimliği. Adaptör ağırlıkları adapter..safetensors veya adapter..bin biçiminde saklanır. Sadece adaptörlerle bir [UniSpeechSatForCTC](/docs/transformers/main/tr/model_doc/unispeech-sat#transformers.UniSpeechSatForCTC) örneği kullanıldığında geçerlidir. Varsayılan olarak 'eng' kullanılır.

Üzerinde Bağlantıcı Zaman Sınıflandırması (CTC) için `language modeling` başlığı bulunan Wav2Vec2Conformer Modeli.

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.Wav2Vec2ConformerForCTC.forward]]

```python
forward(input_values: typing.Optional[torch.Tensor], attention_mask: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_conformer/modeling_wav2vec2_conformer.py#L1440)

**Parametreler:**

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]` 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. Diziyi `input_values` için hazırlamak için, `torch.Tensor` tipinde bir tensöre dolgu ve dönüştürme amacıyla [AutoProcessor](/docs/transformers/main/tr/model_doc/auto#transformers.AutoProcessor) kullanılmalıdır. Ayrıntılar için [Wav2Vec2Processor.__call__()](/docs/transformers/main/tr/model_doc/wav2vec2#transformers.Wav2Vec2Processor.__call__) bölümüne bakın.

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)

labels (`torch.LongTensor`, şekli `(batch_size, target_length)`, *isteğe bağlı*) : Bağlantılı zaman sınıflandırması için etiketler. Not: `target_length`, çıktı logitlerinin dizi uzunluğundan küçük veya eşit olmalıdır. Endeksler `[-100, 0, ..., config.vocab_size - 1]` aralığından seçilir. `-100` olarak ayarlanan tüm etiketler yok sayılır (maske uygulanır), kayıp yalnızca `[0, ..., config.vocab_size - 1]` aralığındaki etiketler için hesaplanır.

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

[CausalLMOutput](/docs/transformers/main/tr/main_classes/output#transformers.modeling_outputs.CausalLMOutput) veya bir `torch.Tensor` demeti (`return_dict=False` geçirildiğinde veya `config.return_dict=False` olduğunda), yapılandırmaya ([Wav2Vec2ConformerConfig](/docs/transformers/main/tr/model_doc/wav2vec2-conformer#transformers.Wav2Vec2ConformerConfig)) ve girdilere bağlı olarak çeşitli öğelerden oluşur.

[Wav2Vec2ConformerForCTC](/docs/transformers/main/tr/model_doc/wav2vec2-conformer#transformers.Wav2Vec2ConformerForCTC) 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ı (sonraki token tahmini için).
- **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).
- **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` (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, `(batch_size, sequence_length, hidden_size)` biçiminde bir demet.

  Her katmanın çıktısında modelin gizli durumları ve isteğe bağlı başlangıç gömme çıktıları.
- **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 softmax'ı sonrası dikkat ağırlıkları, öz-dikkat kafalarında ağırlıklı ortalamanın hesaplanmasında kullanılır.

Örnek:

```python
>>> from transformers import AutoProcessor, Wav2Vec2ConformerForCTC
>>> from datasets import load_dataset
>>> import torch

>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
>>> dataset = dataset.sort("id")
>>> sampling_rate = dataset.features["audio"].sampling_rate

>>> processor = AutoProcessor.from_pretrained("facebook/wav2vec2-conformer-rel-pos-large")
>>> model = Wav2Vec2ConformerForCTC.from_pretrained("facebook/wav2vec2-conformer-rel-pos-large")

>>> # audio file is decoded on the fly
>>> inputs = processor(dataset[0]["audio"]["array"], sampling_rate=sampling_rate, return_tensors="pt")
>>> with torch.no_grad():
...     logits = model(**inputs).logits
>>> predicted_ids = torch.argmax(logits, dim=-1)

>>> # transcribe speech
>>> transcription = processor.batch_decode(predicted_ids)
>>> transcription[0]
...

>>> inputs["labels"] = processor(text=dataset[0]["text"], return_tensors="pt").input_ids

>>> # compute loss
>>> loss = model(**inputs).loss
>>> round(loss.item(), 2)
...
```

## Wav2Vec2ConformerForSequenceClassification[[transformers.Wav2Vec2ConformerForSequenceClassification]]

#### transformers.Wav2Vec2ConformerForSequenceClassification[[transformers.Wav2Vec2ConformerForSequenceClassification]]

```python
transformers.Wav2Vec2ConformerForSequenceClassification(config: Wav2Vec2ConformerConfig)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_conformer/modeling_wav2vec2_conformer.py#L1498)

**Parametreler:**

config ([Wav2Vec2ConformerConfig](/docs/transformers/main/tr/model_doc/wav2vec2-conformer#transformers.Wav2Vec2ConformerConfig)) : 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 bakın.

Üstünde bir dizi sınıflandırma başlığı (toplanmış çıktı üzerinde doğrusal bir katman) bulunan, SUPERB Keyword Spotting gibi görevler için kullanılan Wav2Vec2Conformer Modeli.

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.Wav2Vec2ConformerForSequenceClassification.forward]]

```python
forward(input_values: typing.Optional[torch.Tensor], attention_mask: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_conformer/modeling_wav2vec2_conformer.py#L1531)

**Parametreler:**

input_values (`torch.Tensor`, şekli `(batch_size, sequence_length)`) : Girdi ham ses dalgasının 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. Diziyi `input_values` için hazırlamak için, [AutoProcessor](/docs/transformers/main/tr/model_doc/auto#transformers.AutoProcessor) dolguyu (padding) ve `torch.Tensor` tipinde bir tensöre dönüştürmeyi uygulamak üzere kullanılmalıdır. Ayrıntılar için `Wav2Vec2ConformerProcessor.__call__` bölümüne bakın.

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)

labels (`torch.LongTensor`, şekli `(batch_size,)`, *isteğe bağlı*) : Sınıflandırma/geri dönüş kaybını hesaplamak için etiketler. Endeksler `[0, ..., config.num_labels - 1]` aralığında olmalıdır. `config.num_labels == 1` ise bir geri dönüş kaybı (Ortalama Kare kaybı) hesaplanır, `config.num_labels > 1` ise bir sınıflandırma kaybı (Çapraz Entropi) hesaplanır.

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

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

[Wav2Vec2ConformerForSequenceClassification](/docs/transformers/main/tr/model_doc/wav2vec2-conformer#transformers.Wav2Vec2ConformerForSequenceClassification) 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) -- Sınıflandırma (config.num_labels==1 ise regresyon) kaybı.
- **logits** (`torch.Tensor`, şekli `(batch_size, config.num_labels)`) -- Sınıflandırma (veya config.num_labels==1 ise regresyon) puanları (SoftMax öncesi).
- **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` (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, `(batch_size, sequence_length, hidden_size)` biçiminde bir demet.

  Her katmanın çıktısında modelin gizli durumları ve isteğe bağlı başlangıç gömme çıktıları.
- **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 softmax'ı sonrası dikkat ağırlıkları, öz-dikkat kafalarında ağırlıklı ortalamanın hesaplanmasında kullanılır.

Tek etiketli sınıflandırma örneği:

```python
>>> import torch
>>> from transformers import AutoTokenizer, Wav2Vec2ConformerForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("facebook/wav2vec2-conformer-rel-pos-large")
>>> model = Wav2Vec2ConformerForSequenceClassification.from_pretrained("facebook/wav2vec2-conformer-rel-pos-large")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_class_id = logits.argmax().item()
>>> model.config.id2label[predicted_class_id]
...

>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = Wav2Vec2ConformerForSequenceClassification.from_pretrained("facebook/wav2vec2-conformer-rel-pos-large", num_labels=num_labels)

>>> labels = torch.tensor([1])
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
...
```

Çok etiketli sınıflandırma örneği:

```python
>>> import torch
>>> from transformers import AutoTokenizer, Wav2Vec2ConformerForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("facebook/wav2vec2-conformer-rel-pos-large")
>>> model = Wav2Vec2ConformerForSequenceClassification.from_pretrained("facebook/wav2vec2-conformer-rel-pos-large", problem_type="multi_label_classification")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_class_ids = torch.arange(0, logits.shape[-1])[torch.sigmoid(logits).squeeze(dim=0) > 0.5]

>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = Wav2Vec2ConformerForSequenceClassification.from_pretrained(
...     "facebook/wav2vec2-conformer-rel-pos-large", num_labels=num_labels, problem_type="multi_label_classification"
... )

>>> labels = torch.sum(
...     torch.nn.functional.one_hot(predicted_class_ids[None, :].clone(), num_classes=num_labels), dim=1
... ).to(torch.float)
>>> loss = model(**inputs, labels=labels).loss
```

## Wav2Vec2ConformerForAudioFrameClassification[[transformers.Wav2Vec2ConformerForAudioFrameClassification]]

#### transformers.Wav2Vec2ConformerForAudioFrameClassification[[transformers.Wav2Vec2ConformerForAudioFrameClassification]]

```python
transformers.Wav2Vec2ConformerForAudioFrameClassification(config: Wav2Vec2ConformerConfig)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_conformer/modeling_wav2vec2_conformer.py#L1591)

**Parametreler:**

config ([Wav2Vec2ConformerConfig](/docs/transformers/main/tr/model_doc/wav2vec2-conformer#transformers.Wav2Vec2ConformerConfig)) : 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 bakın.

Konuşmacı Ayırt Etme gibi görevler için üstünde bir çerçeve sınıflandırma başlığı bulunan Wav2Vec2 Conformer Modeli.

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.Wav2Vec2ConformerForAudioFrameClassification.forward]]

```python
forward(input_values: typing.Optional[torch.Tensor], attention_mask: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_conformer/modeling_wav2vec2_conformer.py#L1623)

**Parametreler:**

input_values (`torch.Tensor`, şekli `(batch_size, sequence_length)`) : Girdi ham ses dalgasının 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. Diziyi `input_values` için hazırlamak için, [AutoProcessor](/docs/transformers/main/tr/model_doc/auto#transformers.AutoProcessor) dolguyu (padding) ve `torch.Tensor` tipinde bir tensöre dönüştürmeyi uygulamak üzere kullanılmalıdır. Ayrıntılar için `Wav2Vec2ConformerProcessor.__call__` bölümüne bakın.

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)

labels (`torch.LongTensor`, şekli `(batch_size,)`, *isteğe bağlı*) : Sınıflandırma/geri dönüş kaybını hesaplamak için etiketler. Endeksler `[0, ..., config.num_labels - 1]` aralığında olmalıdır. `config.num_labels == 1` ise bir geri dönüş kaybı (Ortalama Kare kaybı) hesaplanır, `config.num_labels > 1` ise bir sınıflandırma kaybı (Çapraz Entropi) hesaplanır.

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

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

[Wav2Vec2ConformerForAudioFrameClassification](/docs/transformers/main/tr/model_doc/wav2vec2-conformer#transformers.Wav2Vec2ConformerForAudioFrameClassification) 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) -- Sınıflandırma kaybı.
- **logits** (`torch.Tensor`, şekli `(batch_size, sequence_length, config.num_labels)`) -- Sınıflandırma puanları (SoftMax öncesi).
- **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` (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, `(batch_size, sequence_length, hidden_size)` biçiminde bir demet.

  Her katmanın çıktısında modelin gizli durumları ve isteğe bağlı başlangıç gömme çıktıları.
- **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 softmax'ı sonrası dikkat ağırlıkları, öz-dikkat kafalarında ağırlıklı ortalamanın hesaplanmasında kullanılır.

Örnek:

```python
>>> from transformers import AutoFeatureExtractor, Wav2Vec2ConformerForAudioFrameClassification
>>> from datasets import load_dataset
>>> import torch

>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
>>> dataset = dataset.sort("id")
>>> sampling_rate = dataset.features["audio"].sampling_rate

>>> feature_extractor = AutoFeatureExtractor.from_pretrained("facebook/wav2vec2-conformer-rel-pos-large")
>>> model = Wav2Vec2ConformerForAudioFrameClassification.from_pretrained("facebook/wav2vec2-conformer-rel-pos-large")

>>> # audio file is decoded on the fly
>>> inputs = feature_extractor(dataset[0]["audio"]["array"], return_tensors="pt", sampling_rate=sampling_rate)
>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> probabilities = torch.sigmoid(logits[0])
>>> # labels is a one-hot array of shape (num_frames, num_speakers)
>>> labels = (probabilities > 0.5).long()
>>> labels[0].tolist()
...
```

## Wav2Vec2ConformerForXVector[[transformers.Wav2Vec2ConformerForXVector]]

#### transformers.Wav2Vec2ConformerForXVector[[transformers.Wav2Vec2ConformerForXVector]]

```python
transformers.Wav2Vec2ConformerForXVector(config: Wav2Vec2ConformerConfig)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_conformer/modeling_wav2vec2_conformer.py#L1737)

**Parametreler:**

config ([Wav2Vec2ConformerConfig](/docs/transformers/main/tr/model_doc/wav2vec2-conformer#transformers.Wav2Vec2ConformerConfig)) : 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 bakın.

Konuşmacı Doğrulama gibi görevler için üstünde XVector özellik çıkarma başlığı bulunan Wav2Vec2Conformer Modeli.

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.Wav2Vec2ConformerForXVector.forward]]

```python
forward(input_values: typing.Optional[torch.Tensor], attention_mask: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_conformer/modeling_wav2vec2_conformer.py#L1787)

**Parametreler:**

input_values (`torch.Tensor`, şekli `(batch_size, sequence_length)`) : Girdi ham ses dalgasının 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. Diziyi `input_values` için hazırlamak için, [AutoProcessor](/docs/transformers/main/tr/model_doc/auto#transformers.AutoProcessor) dolguyu (padding) ve `torch.Tensor` tipinde bir tensöre dönüştürmeyi uygulamak üzere kullanılmalıdır. Ayrıntılar için `Wav2Vec2ConformerProcessor.__call__` bölümüne bakın.

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)

labels (`torch.LongTensor`, şekli `(batch_size,)`, *isteğe bağlı*) : Sınıflandırma/geri dönüş kaybını hesaplamak için etiketler. Endeksler `[0, ..., config.num_labels - 1]` aralığında olmalıdır. `config.num_labels == 1` ise bir geri dönüş kaybı (Ortalama Kare kaybı) hesaplanır, `config.num_labels > 1` ise bir sınıflandırma kaybı (Çapraz Entropi) hesaplanır.

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

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

[Wav2Vec2ConformerForXVector](/docs/transformers/main/tr/model_doc/wav2vec2-conformer#transformers.Wav2Vec2ConformerForXVector) 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) -- Sınıflandırma kaybı.
- **logits** (`torch.Tensor`, şekli `(batch_size, config.xvector_output_dim)`) -- AMSoftmax öncesi sınıflandırma gizli durumları.
- **embeddings** (`torch.Tensor`, şekli `(batch_size, config.xvector_output_dim)`) -- Vektör benzerliğine dayalı geri getirme için kullanılan cümle gömme değerleri.
- **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` (gömme çıktısı için bir tane + her katman çıktısı için bir tane) içeren, `(batch_size, sequence_length, hidden_size)` biçiminde bir demet.

  Her katmanın çıktısında modelin gizli durumları ve başlangıç gömme çıktıları.
- **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 softmax'ı sonrası dikkat ağırlıkları, öz-dikkat kafalarında ağırlıklı ortalamanın hesaplanmasında kullanılır.

Örnek:

```python
>>> from transformers import AutoFeatureExtractor, Wav2Vec2ConformerForXVector
>>> from datasets import load_dataset
>>> import torch

>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
>>> dataset = dataset.sort("id")
>>> sampling_rate = dataset.features["audio"].sampling_rate

>>> feature_extractor = AutoFeatureExtractor.from_pretrained("facebook/wav2vec2-conformer-rel-pos-large")
>>> model = Wav2Vec2ConformerForXVector.from_pretrained("facebook/wav2vec2-conformer-rel-pos-large")

>>> # audio file is decoded on the fly
>>> inputs = feature_extractor(
...     [d["array"] for d in dataset[:2]["audio"]], sampling_rate=sampling_rate, return_tensors="pt", padding=True
... )
>>> with torch.no_grad():
...     embeddings = model(**inputs).embeddings

>>> embeddings = torch.nn.functional.normalize(embeddings, dim=-1).cpu()

>>> # the resulting embeddings can be used for cosine similarity-based retrieval
>>> cosine_sim = torch.nn.CosineSimilarity(dim=-1)
>>> similarity = cosine_sim(embeddings[0], embeddings[1])
>>> threshold = 0.7  # the optimal threshold is dataset-dependent
>>> if similarity < threshold:
...     print("Speakers are not the same!")
>>> round(similarity.item(), 2)
...
```

## Wav2Vec2ConformerForPreTraining[[transformers.Wav2Vec2ConformerForPreTraining]]

#### transformers.Wav2Vec2ConformerForPreTraining[[transformers.Wav2Vec2ConformerForPreTraining]]

```python
transformers.Wav2Vec2ConformerForPreTraining(config: Wav2Vec2ConformerConfig)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_conformer/modeling_wav2vec2_conformer.py#L1200)

**Parametreler:**

config ([Wav2Vec2ConformerConfig](/docs/transformers/main/tr/model_doc/wav2vec2-conformer#transformers.Wav2Vec2ConformerConfig)) : 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 bakın.

Üzerinde bir kuantizatör ve `VQ` başlığı bulunan Wav2Vec2Conformer Modeli.

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.Wav2Vec2ConformerForPreTraining.forward]]

```python
forward(input_values: typing.Optional[torch.Tensor], attention_mask: typing.Optional[torch.Tensor] = None, mask_time_indices: typing.Optional[torch.BoolTensor] = None, sampled_negative_indices: typing.Optional[torch.BoolTensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/wav2vec2_conformer/modeling_wav2vec2_conformer.py#L1248)

**Parametreler:**

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]` 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. Diziyi `input_values` için hazırlamak için, `torch.Tensor` tipinde bir tensöre dolgu ve dönüştürme amacıyla [AutoProcessor](/docs/transformers/main/tr/model_doc/auto#transformers.AutoProcessor) kullanılmalıdır. Ayrıntılar için [Wav2Vec2Processor.__call__()](/docs/transformers/main/tr/model_doc/wav2vec2#transformers.Wav2Vec2Processor.__call__) bölümüne bakın.

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)

mask_time_indices (`torch.BoolTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Karşıtlı kayıp için çıkarılan özellikleri maskelemek üzere kullanılacak indeksler. Eğitim modundayken, model *config.proj_codevector_dim* uzayında maskelenmiş çıkarılan özellikleri tahmin etmeyi öğrenir.

sampled_negative_indices (`torch.BoolTensor`, şekli `(batch_size, sequence_length, num_negatives)`, *isteğe bağlı*) : Karşıtlı kayıp (contrastive loss) içinde negatif örneklenmiş vektörler olarak kullanılan kuantize edilmiş hedef vektörlerini gösteren indeksler. Ön eğitim için gerekli girdi.

**Dönüş:** [Wav2Vec2ConformerForPreTrainingOutput](/docs/transformers/main/tr/model_doc/wav2vec2-conformer#transformers.models.wav2vec2_conformer.modeling_wav2vec2_conformer.Wav2Vec2ConformerForPreTrainingOutput) veya `tuple(torch.Tensor)`

[Wav2Vec2ConformerForPreTrainingOutput](/docs/transformers/main/tr/model_doc/wav2vec2-conformer#transformers.models.wav2vec2_conformer.modeling_wav2vec2_conformer.Wav2Vec2ConformerForPreTrainingOutput) veya bir `torch.Tensor` demeti (eğer `return_dict=False` geçirildiyse veya `config.return_dict=False` ise), yapılandırma ([Wav2Vec2ConformerConfig](/docs/transformers/main/tr/model_doc/wav2vec2-conformer#transformers.Wav2Vec2ConformerConfig)) ve girdilere bağlı olarak çeşitli öğelerden oluşur.

[Wav2Vec2ConformerForPreTraining](/docs/transformers/main/tr/model_doc/wav2vec2-conformer#transformers.Wav2Vec2ConformerForPreTraining) 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** (`*optional*`, `sample_negative_indices` geçirildiğinde döndürülür, `(1,)` biçiminde `torch.Tensor`) -- [resmi makalede](https://huggingface.co/papers/2006.11477) belirtildiği üzere, kontrastif kaybın (L_m) ve çeşitlilik kaybının (L_d) toplamı olarak toplam kayıp.
- **projected_states** (`torch.Tensor`, şekli `(batch_size, sequence_length, config.proj_codevector_dim)`) -- Maskelenmiş projeksiyonlu kuantize durumları tahmin etmek için kullanılabilen, *config.proj_codevector_dim* boyutuna projekte edilmiş model gizli durumları.
- **projected_quantized_states** (`torch.Tensor`, şekli `(batch_size, sequence_length, config.proj_codevector_dim)`) -- Karşıtlı kayıp için pozitif hedef vektörleri temsil eden, çıkarılan öznitelik vektörlerinin *config.proj_codevector_dim* boyutuna yansıtılmış kuantize hali.
- **codevector_perplexity** (`torch.Tensor`, şekli `(1,)`) -- Kod kitabı çeşitliliğini ölçmek için kullanılan codevector dağılımının perplexity değeri.
- **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` (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 ve `(batch_size, sequence_length, hidden_size)` biçiminde bir demet.

  Her katmanın çıktısında modelin gizli durumları ve isteğe bağlı başlangıç gömme çıktıları.
- **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.

  Dikkat softmax'ı sonrası dikkat ağırlıkları, öz-dikkat kafalarında ağırlıklı ortalamanın hesaplanmasında kullanılır.
- **contrastive_loss** (`*optional*`, `sample_negative_indices` geçirildiğinde döndürülür, `(1,)` biçiminde `torch.Tensor`) -- [resmi makalede](https://huggingface.co/papers/2006.11477) belirtildiği gibi kontrastif kayıp (L_m).
- **diversity_loss** (`*optional*`, `sample_negative_indices` geçirildiğinde döndürülür, `(1,)` biçiminde `torch.Tensor`) -- [resmi makalede](https://huggingface.co/papers/2006.11477) belirtildiği gibi çeşitlilik kaybı (L_d).

Örnek:

```python
>>> import torch
>>> from transformers import AutoFeatureExtractor, Wav2Vec2ConformerForPreTraining
>>> from transformers.models.wav2vec2_conformer.modeling_wav2vec2_conformer import _compute_mask_indices, _sample_negative_indices
>>> from datasets import load_dataset

>>> feature_extractor = AutoFeatureExtractor.from_pretrained("facebook/wav2vec2_conformer-base")
>>> model = Wav2Vec2ConformerForPreTraining.from_pretrained("facebook/wav2vec2_conformer-base")

>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> input_values = feature_extractor(ds[0]["audio"]["array"], return_tensors="pt").input_values  # Batch size 1

>>> # compute masked indices
>>> batch_size, raw_sequence_length = input_values.shape
>>> sequence_length = model._get_feat_extract_output_lengths(raw_sequence_length).item()
>>> mask_time_indices = _compute_mask_indices(
...     shape=(batch_size, sequence_length), mask_prob=0.2, mask_length=2
... )
>>> sampled_negative_indices = _sample_negative_indices(
...     features_shape=(batch_size, sequence_length),
...     num_negatives=model.config.num_negatives,
...     mask_time_indices=mask_time_indices,
... )
>>> mask_time_indices = torch.tensor(data=mask_time_indices, device=input_values.device, dtype=torch.long)
>>> sampled_negative_indices = torch.tensor(
...     data=sampled_negative_indices, device=input_values.device, dtype=torch.long
... )

>>> with torch.no_grad():
...     outputs = model(input_values, mask_time_indices=mask_time_indices)

>>> # compute cosine similarity between predicted (=projected_states) and target (=projected_quantized_states)
>>> cosine_sim = torch.cosine_similarity(outputs.projected_states, outputs.projected_quantized_states, dim=-1)

>>> # show that cosine similarity is much higher than random
>>> cosine_sim[mask_time_indices.to(torch.bool)].mean() > 0.5
tensor(True)

>>> # for contrastive loss training model should be put into train mode
>>> model = model.train()
>>> loss = model(
...     input_values, mask_time_indices=mask_time_indices, sampled_negative_indices=sampled_negative_indices
... ).loss
```