# CLVP

## Genel Bakış

CLVP (Contrastive Language-Voice Pretrained Transformer) modeli, James Betker tarafından [Better speech synthesis through scaling](https://huggingface.co/papers/2305.07243) makalesinde önerilmiştir.

Makalenin özeti aşağıdaki gibidir:

*Son yıllarda, görüntü üretimi alanı, otoregresif transformer'ların ve DDPM'lerin uygulanmasıyla devrim niteliğinde bir dönüşüm geçirdi. Bu yaklaşımlar, görüntü üretim sürecini adım adım olasılıksal süreçler olarak modelleyerek ve görüntü dağılımını öğrenmek için büyük miktarda hesaplama gücü ve veriden yararlanıyor. Performansı iyileştirmeye yönelik bu metodoloji yalnızca görüntülerle sınırlı kalmak zorunda değil. Bu makale, görüntü üretim alanındaki ilerlemelerin konuşma sentezine uygulanmasının bir yolunu tanımlıyor. Sonuç, TorToise - ifade zengini, çok sesli bir metinden konuşmaya sistemidir.*

Bu model [Susnato Dhar](https://huggingface.co/susnato) tarafından katkıda bulunmuştur. Orijinal kod [burada](https://github.com/neonbjb/tortoise-tts) bulunabilir.

## Kullanım ipuçları

1. CLVP, Tortoise TTS modelinin ayrılmaz bir parçasıdır.
2. CLVP, üretilen farklı konuşma adaylarını sağlanan metinle karşılaştırmak için kullanılabilir ve en iyi konuşma jetonları difüzyon modeline iletilir.
3. Tortoise kullanımı için `ClvpModelForConditionalGeneration.generate()` metodunun kullanılması şiddetle önerilir.
4. CLVP modelinin, 16 kHz örnekleme hızı bekleyen diğer ses modellerinin aksine, sesin 22.05 kHz'de örneklenmesini beklediğini unutmayın.

## Kısa Açıklama

- [ClvpTokenizer](/docs/transformers/main/tr/model_doc/clvp#transformers.ClvpTokenizer) metin girdisini belirteçlere ayırır ve [ClvpFeatureExtractor](/docs/transformers/main/tr/model_doc/clvp#transformers.ClvpFeatureExtractor) istenen ses dosyasından log mel-spektrogramını çıkarır.
- `ClvpConditioningEncoder`, bu metin tokenlarını ve ses temsillerini alır ve metne ve sese koşullu gömütlere dönüştürür.
- [ClvpForCausalLM](/docs/transformers/main/tr/model_doc/clvp#transformers.ClvpForCausalLM), bu gömmelemeleri kullanarak birden fazla konuşma adayı üretir.
- Her konuşma adayı, onları vektör temsiline dönüştüren konuşma kodlayıcısından ([ClvpEncoder](/docs/transformers/main/tr/model_doc/clvp#transformers.ClvpEncoder)) geçirilir ve metin kodlayıcısı ([ClvpEncoder](/docs/transformers/main/tr/model_doc/clvp#transformers.ClvpEncoder)) metin jetonlarını aynı gizli uzaya dönüştürür.
- Son olarak, her ses vektörünü metin vektörüyle karşılaştırarak metin vektörüne en benzer ses vektörünü buluruz.
- `ClvpModelForConditionalGeneration.generate()`, yukarıda açıklanan tüm mantığı tek bir yöntemde birleştirir.

Örnek:

```python
import datasets

from transformers import ClvpModelForConditionalGeneration, ClvpProcessor

# Define the Text and Load the Audio (We are taking an audio example from HuggingFace Hub using `datasets` library).
text = "This is an example text."

ds = datasets.load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
ds = ds.cast_column("audio", datasets.Audio(sampling_rate=22050))
sample = ds[0]["audio"]

# Define processor and model.
processor = ClvpProcessor.from_pretrained("susnato/clvp_dev")
model = ClvpModelForConditionalGeneration.from_pretrained("susnato/clvp_dev", device_map="auto")

# Generate processor output and model output.
processor_output = processor(raw_speech=sample["array"], sampling_rate=sample["sampling_rate"], text=text, return_tensors="pt").to(model.device)
generated_output = model.generate(**processor_output)
```

## ClvpConfig[[transformers.ClvpConfig]]

#### transformers.ClvpConfig[[transformers.ClvpConfig]]

```python
transformers.ClvpConfig(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, text_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, speech_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, decoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, projection_dim: int = 768, logit_scale_init_value: float = 2.6592, initializer_factor: float = 1.0)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/configuration_clvp.py#L185)

**Parametreler:**

text_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *isteğe bağlı*) : Metin omurgasının yapılandırma nesnesi veya sözlüğü.

speech_config (`dict`, *isteğe bağlı*) : CLVP konuşma kodlayıcısını başlatmak için kullanılan yapılandırma seçeneklerinin sözlüğü.

decoder_config (`dict`, *isteğe bağlı*) : [ClvpDecoderConfig](/docs/transformers/main/tr/model_doc/clvp#transformers.ClvpDecoderConfig) sınıfını başlatmak için kullanılan yapılandırma seçeneklerinin sözlüğü.

projection_dim (`int`, *isteğe bağlı*, varsayılan `768`) : Metin ve görme projeksiyon katmanlarının boyutluluğu.

logit_scale_init_value (`float`, *isteğe bağlı*, varsayılan `2.6592`) : *logit_scale* parametresinin başlangıç değeri.

initializer_factor (`float`, *opsiyonel*, varsayılan `1.0`) : Tüm ağırlık matrislerini başlatmak için kullanılan bir çarpan (1 olarak tutulmalıdır, başlatma testleri için dahili olarak kullanılır).

Bu, bir ClvpModelForConditionalGeneration yapılandırmasını depolamak için kullanılan yapılandırma sınıfıdır. Belirtilen argümanlara göre bir Clvp modelini örneklemek ve model mimarisini tanımlamak için kullanılır. Varsayılanlarla bir yapılandırma örneklendiğinde, [susnato/clvp_dev](https://huggingface.co/susnato/clvp_dev) ile benzer bir yapılandırma elde edilir.

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 ClvpConfig, ClvpModelForConditionalGeneration

>>> # Initializing a ClvpConfig with susnato/clvp_dev style configuration
>>> configuration = ClvpConfig()

>>> # Initializing a ClvpModelForConditionalGeneration (with random weights) from the susnato/clvp_dev style configuration
>>> model = ClvpModelForConditionalGeneration(configuration)

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

>>> # We can also initialize a CLVPConfig from a CLVPTextConfig, CLVPSpeechConfig and a CLVPAutoRegressiveConfig
>>> from transformers import ClvpEncoderConfig, ClvpDecoderConfig

>>> # Initializing a CLVP text, CLVP speech and CLVP decoder configuration
>>> config_text = ClvpEncoderConfig()
>>> config_speech = ClvpEncoderConfig()
>>> decoder_config = ClvpDecoderConfig()

>>> config = ClvpConfig(config_text, config_speech, decoder_config)
```

## ClvpEncoderConfig[[transformers.ClvpEncoderConfig]]

#### transformers.ClvpEncoderConfig[[transformers.ClvpEncoderConfig]]

```python
transformers.ClvpEncoderConfig(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 = 256, hidden_size: int = 768, intermediate_size: int = 1536, projection_dim: int = 768, num_hidden_layers: int = 20, num_attention_heads: int = 12, hidden_act: str = 'gelu', layer_norm_eps: float = 1e-05, attention_dropout: float | int = 0.1, dropout: float | int = 0.1, use_rotary_embedding: bool = True, use_attention_bias: bool = False, summary_type: str = 'mean', initializer_factor: float = 1.0, bos_token_id: int | None = 255, eos_token_id: int | list[int] | None = 0, pad_token_id: int | None = None)
```

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

**Parametreler:**

vocab_size (`int`, *isteğe bağlı*, varsayılan `256`) : 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.

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

projection_dim (`int`, *isteğe bağlı*, varsayılan `768`) : Metin ve görme projeksiyon katmanlarının boyutluluğu.

num_hidden_layers (`int`, *isteğe bağlı*, varsayılan `20`) : 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ı.

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.

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

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

dropout (`Union[float, int]`, *isteğe bağlı*, varsayılan `0.1`) : Tüm dropout katmanları için oran.

use_rotary_embedding (`bool`, *isteğe bağlı*, varsayılan `True`) : rotary_embedding kullanılacak mı?

use_attention_bias (`bool`, *isteğe bağlı*, varsayılan `False`) : Kendi dikkat (self attention) sırasında Query, Key ve Value katmanlarında bias kullanılıp kullanılmayacağı.

summary_type (`str`, *isteğe bağlı*, varsayılan `"mean"`) : last_hidden_state'ten pooler_output almak için kullanılacak strateji. `"last"`, `"first"`, `"mean"` ve `"cls_index"` desteklenmektedir.

initializer_factor (`float`, *opsiyonel*, varsayılan `1.0`) : Tüm ağırlık matrislerini başlatmak için kullanılan bir çarpan (1 olarak tutulmalıdır, başlatma testleri için dahili olarak kullanılır).

bos_token_id (`int`, *isteğe bağlı*, varsayılan `255`) : 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 `0`) : Sözlükte akış sonu için kullanılan token kimliği.

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

Bu, bir ClvpModelForConditionalGeneration yapılandırmasını depolamak için kullanılan yapılandırma sınıfıdır. Belirtilen argümanlara göre bir Clvp modelini örneklemek ve model mimarisini tanımlamak için kullanılır. Varsayılanlarla bir yapılandırma örneklendiğinde, [susnato/clvp_dev](https://huggingface.co/susnato/clvp_dev) ile benzer bir yapılandırma elde edilir.

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 ClvpEncoderConfig, ClvpEncoder

>>> # Initializing a ClvpEncoderConfig with susnato/clvp_dev style configuration
>>> encoder_configuration = ClvpEncoderConfig()

>>> # Initializing a ClvpEncoder (with random weights) from the susnato/clvp_dev style configuration
>>> model = ClvpEncoder(encoder_configuration)

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

## ClvpDecoderConfig[[transformers.ClvpDecoderConfig]]

#### transformers.ClvpDecoderConfig[[transformers.ClvpDecoderConfig]]

```python
transformers.ClvpDecoderConfig(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 = 8194, max_position_embeddings: int = 608, max_text_tokens: int = 404, hidden_size: int = 1024, num_hidden_layers: int = 30, num_attention_heads: int = 16, n_inner: int | None = None, num_mel_attn_blocks: int = 6, activation_function: str = 'gelu_new', resid_pdrop: float | int = 0.1, embd_pdrop: float | int = 0.1, attention_dropout: float | int = 0.1, layer_norm_epsilon: float = 1e-05, initializer_range: float = 0.02, summary_type: str = 'cls_index', summary_use_proj: bool = True, summary_activation: str | None = None, summary_proj_to_labels: bool = True, summary_first_dropout: float | int = 0.1, use_cache: bool = True, bos_token_id: int | None = 8192, eos_token_id: int | list[int] | None = 8193, pad_token_id: int | None = None, feature_size: int = 80, use_attention_bias: bool = True, initializer_factor: float = 1.0, decoder_fixing_codes: list[int] | tuple[int, ...] = (83, 45, 45, 248), add_cross_attention: bool = False)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/configuration_clvp.py#L103)

**Parametreler:**

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

max_position_embeddings (`int`, *isteğe bağlı*, varsayılan `608`) : Bu modelin kullanılabileceği en büyük dizi uzunluğu.

max_text_tokens (`int`, *opsiyonel*, varsayılan 404) : Bu modelin kullanılabileceği metin token'larının maksimum dizilim uzunluğu. `GPT2Config` içindeki `n_positions` ile benzerdir.

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

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

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

n_inner (`int`, *isteğe bağlı*) : İç beslemeli ileri (feed-forward) katmanlarının boyutluluğu. `None`, bunu `hidden_size`'in 4 katı olarak ayarlar.

num_mel_attn_blocks (`int`, *isteğe bağlı*, varsayılan 6) : `ClvpConditioningEncoder` içindeki öz-dikkat katmanlarının sayısını belirtir.

activation_function (`str`, *isteğe bağlı*, varsayılan `gelu_new`) : Dekoderdeki doğrusal olmayan aktivasyon fonksiyonu (fonksiyon veya dize). Örneğin, `"gelu"`, `"relu"`, `"silu"` vb.

resid_pdrop (`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ığı.

embd_pdrop (`Union[float, int]`, *isteğe bağlı*, varsayılan `0.1`) : Gömme (embedding) katmanı 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ı.

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

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

summary_type (`string`, *opsiyonel*, varsayılan `"cls_index"`) : Sıralama özeti yapılırken kullanılan argüman. Aşağıdaki seçeneklerden biri olmalıdır: - `"last"`: Son token gizli durumunu alır (XLNet gibi). - `"first"`: İlk token gizli durumunu alır (BERT gibi). - `"mean"`: Tüm token gizli durumlarının ortalamasını alır. - `"cls_index"`: Sınıflandırma token konumu için bir Tensor sağlar (GPT/GPT-2 gibi). - `"attn"`: Şu an uygulanmadı, çok başlı dikkat kullanılır.

summary_use_proj (`bool`, *isteğe bağlı*, varsayılan `True`) : Vektör çıkarımından sonra bir projeksiyon eklenip eklenmeyeceğini belirtir.

summary_activation (`str`, *isteğe bağlı*) : Çıktıya tanh aktivasyonu uygulamak için `"tanh"` değerini geçirin; başka herhangi bir değer aktivasyon uygulanmamasına neden olur.

summary_proj_to_labels (`bool`, *isteğe bağlı*, varsayılan `True`) : Projeksiyon çıktıları `config.num_labels` veya `config.hidden_size` sınıfına sahip olmalı mı?

summary_first_dropout (`float`, *opsiyonel*, varsayılan 0.1) : Projeksiyon ve aktivasyon sonrasında kullanılacak dropout oranı.

use_cache (`bool`, *isteğe bağlı*, varsayılan `True`) : Modelin son anahtar/değer dikkatlerini döndürüp döndürmeyeceğini belirtir (tüm modellerde kullanılmaz). Yalnızca `config.is_decoder=True` olduğunda veya model yalnızca çözücü tabanlı üretken bir model olduğunda geçerlidir.

bos_token_id (`int`, *isteğe bağlı*, varsayılan `8192`) : 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 `8193`) : Sözlükte akış sonu için kullanılan token kimliği.

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

feature_size (`int`, *isteğe bağlı*, varsayılan 80) : Çıkarılan mel özelliklerinin boyutu. Bu değer `ClvpConditioningEncoder` içinde kullanılır.

use_attention_bias (`bool`, *isteğe bağlı*, varsayılan `True`) : Kendi dikkat (self attention) sırasında Query, Key ve Value katmanlarında bias kullanılıp kullanılmayacağı.

initializer_factor (`float`, *opsiyonel*, varsayılan `1.0`) : Tüm ağırlık matrislerini başlatmak için kullanılan bir çarpan (1 olarak tutulmalıdır, başlatma testleri için dahili olarak kullanılır).

decoder_fixing_codes (`list`, *isteğe bağlı*, varsayılan `[83, 45, 45, 248]`) : Bu değerler, `fix_speech_decoder_output` yönteminde, decoder tarafından üretilen çıktıları düzeltmek için kullanılır.

add_cross_attention (`bool`, *isteğe bağlı*, varsayılan `False`) : Modelde çapraz dikkat katmanlarının eklenip eklenmeyeceğini belirtir.

Bu, bir ClvpModelForConditionalGeneration yapılandırmasını depolamak için kullanılan yapılandırma sınıfıdır. Belirtilen argümanlara göre bir Clvp modelini örneklemek ve model mimarisini tanımlamak için kullanılır. Varsayılanlarla bir yapılandırma örneklendiğinde, [susnato/clvp_dev](https://huggingface.co/susnato/clvp_dev) ile benzer bir yapılandırma elde edilir.

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 ClvpDecoderConfig, ClvpDecoder

>>> # Initializing a ClvpDecoderConfig with susnato/clvp_dev style configuration
>>> decoder_configuration = ClvpDecoderConfig()

>>> # Initializing a ClvpDecoder (with random weights) from the susnato/clvp_dev style configuration
>>> model = ClvpDecoder(decoder_configuration)

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

## ClvpTokenizer[[transformers.ClvpTokenizer]]

#### transformers.ClvpTokenizer[[transformers.ClvpTokenizer]]

```python
transformers.ClvpTokenizer(vocab_file, merges_file, errors = 'replace', unk_token = '[UNK]', bos_token = '<|endoftext|>', eos_token = '[STOP]', pad_token = '[STOP]', add_prefix_space = False, **kwargs)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/tokenization_clvp.py#L73)

**Parametreler:**

vocab_file (`str`) : Sözlük dosyasının yolu.

merges_file (`str`) : Birleştirme dosyasının yolu.

errors (`str`, *isteğe bağlı*, varsayılan `"replace"`) : Baytların UTF-8'e çözümlenirken izlenecek paradigma. Daha fazla bilgi için [bytes.decode](https://docs.python.org/3/library/stdtypes.html#bytes.decode)'e bakın.

unk_token (`str`, *isteğe bağlı*, varsayılan `"[UNK]"`) : Bilinmeyen jeton. Sözlükte yer almayan bir jeton, bir kimliğe dönüştürülemez ve bunun yerine bu jeton olarak ayarlanır.

bos_token (`str`, *isteğe bağlı*, varsayılan `"<|endoftext|>"`) : Sıranın başlangıç belirteci.

eos_token (`str`, *isteğe bağlı*, varsayılan `"[STOP]"`) : Sıra sonu belirteci.

pad_token (`str`, *isteğe bağlı*, varsayılan `"[STOP]"`) : Sıranın dolgu belirteci (pad token).

add_prefix_space (`bool`, *isteğe bağlı*, varsayılan `False`) : Girdiye başlangıçta bir boşluk eklenip eklenmeyeceğini belirtir. Bu, baştaki kelimenin diğer kelimelerle aynı şekilde ele alınmasını sağlar. (CLVP tokenizer, kelimelerin başlangıcını önceki boşlukla tespit eder).

CLVP belirteç oluşturucu (tokenizer) oluşturun. Bayt düzeyinde Byte-Pair-Encoding tabanlıdır.

Bu tokenizer, boşlukları tokenların parçaları gibi işlemek üzere eğitilmiştir (biraz da sentencepiece gibi) bu yüzden bir kelime

cümle başında (boşluksuz) mı yoksa değil mi olduğuna göre farklı kodlanabilir:

```python
>>> from transformers import ClvpTokenizer

>>> tokenizer = ClvpTokenizer.from_pretrained("susnato/clvp_dev")
>>> tokenizer("Hello world")["input_ids"]
[62, 84, 28, 2, 179, 79]

>>> tokenizer(" Hello world")["input_ids"]
[2, 62, 84, 28, 2, 179, 79]
```

Bu davranışın etrafından dolaşmak için bu tokenizer'ı örneklerken veya bazı metinler üzerinde çağırdığınızda `add_prefix_space=True` parametresini iletebilirsiniz; ancak model bu şekilde ön eğitilmediğinden, performans düşüşüne yol açabilir.

`is_split_into_words=True` ile kullanıldığında, bu tokenizer her kelimenin (ilk kelime dahil) başına bir boşluk ekler.

Bu tokenizer, ana yöntemlerin çoğunu içeren [PreTrainedTokenizer](/docs/transformers/main/tr/main_classes/tokenizer#transformers.PythonBackend) sınıfından devralır. Kullanıcıların bu yöntemler hakkında daha fazla bilgi için bu üst sınıfa başvurması gerekir.

#### save_vocabulary[[transformers.ClvpTokenizer.save_vocabulary]]

```python
save_vocabulary(save_directory: str, filename_prefix: str | None = None)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_python.py#L1362)

**Parametreler:**

save_directory (`str`) : Sözlüğün kaydedileceği dizin.

filename_prefix (`str`, *isteğe bağlı*) : Kaydedilen dosyaların adlarına eklenecek isteğe bağlı bir önek.

**Dönüş:** `tuple[str, ...]`

Kaydedilen dosyaların yolları, dosya kaydedilmediyse boş tuple.

Ortak sözlük kaydetme kalıpları için varsayılan uygulama. self.encoder/self.vocab'ı JSON olarak kaydeder, isteğe bağlı olarak self.bpe_ranks'ı birleştirmeler (merges) olarak ekler. Sözlük yoksa boş tuple döndürür.

Tokenizörünüz özel kaydetme mantığı gerektiriyorsa (ör. SentencePiece modelleri, birden çok sözlük dosyası veya özel dosya biçimleri) bu yöntemi geçersiz kılın.

## ClvpFeatureExtractor[[transformers.ClvpFeatureExtractor]]

#### transformers.ClvpFeatureExtractor[[transformers.ClvpFeatureExtractor]]

```python
transformers.ClvpFeatureExtractor(feature_size = 80, sampling_rate = 22050, default_audio_length = 6, hop_length = 256, chunk_length = 30, n_fft = 1024, padding_value = 0.0, mel_norms = None, return_attention_mask = False, **kwargs)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/feature_extraction_clvp.py#L30)

**Parametreler:**

feature_size (`int`, *isteğe bağlı*, varsayılan 80) : Çıkarılan özelliklerin boyutu.

sampling_rate (`int`, *isteğe bağlı*, varsayılan 22050) : Ses dosyalarının dijitalleştirileceği örnekleme hızı, hertz (Hz) cinsinden ifade edilir.

default_audio_length (`int`, *isteğe bağlı*, varsayılan 6) : Ham sesin varsayılan uzunluğu, saniye cinsinden. `max_length` `__call__` sırasında ayarlanmazsa, otomatik olarak default_audio_length * `self.sampling_rate` olarak ayarlanır.

hop_length (`int`, *opsiyonel*, varsayılan 256) : Mel Frekans katsayılarını elde etmek için kullanılan STFT'nin üst üste binen pencerelerinin uzunluğu.

chunk_length (`int`, *opsiyonel*, varsayılan 30) : Daha uzun veya kısa ses dizilerini kırpıp doldurmak için kullanılan `sampling_rate` örneklik maksimum parça sayısı.

n_fft (`int`, *isteğe bağlı*, varsayılan 1024) : Fourier dönüşümünün boyutu.

padding_value (`float`, *opsiyonel*, varsayılan 0.0) : Sesin doldurulmasında kullanılan dolgu değeri. Sessizliklere karşılık gelmelidir.

mel_norms (`list`, uzunluğu `feature_size`, *isteğe bağlı*) : `mel_norms` sağlanırsa, log-mel spektrogramları her mel filtresi boyunca normalize etmek için kullanılır.

return_attention_mask (`bool`, *isteğe bağlı*, varsayılan `False`) : Dikkat maskesinin (attention mask) döndürülüp döndürülmeyeceğini belirtir. Varsayılan değer bırakılırsa, dikkat maskesi döndürülür.  [Dikkat maskeleri nelerdir?](../glossary#attention-mask)

Bir CLVP özellik çıkarıcı oluşturur.

Bu özellik çıkarıcı, ana yöntemlerin çoğunu içeren [SequenceFeatureExtractor](/docs/transformers/main/tr/main_classes/feature_extractor#transformers.SequenceFeatureExtractor) sınıfından devralır. Kullanıcıların bu yöntemler hakkında daha fazla bilgi için bu üst sınıfa başvurması gerekir.

Bu sınıf, ham konuşma verisinden log-mel-spektrogram özelliklerini, pytorch'un `torch.stft` karşılığıyla eşleşmesi gereken özel bir numpy `Short Time Fourier Transform` uygulaması kullanarak çıkarır.

#### __call__[[transformers.ClvpFeatureExtractor.__call__]]

```python
__call__(raw_speech: numpy.ndarray | list[float] | list[numpy.ndarray] | list[list[float]], sampling_rate: int | None = None, truncation: bool = True, pad_to_multiple_of: int | None = None, return_tensors: str | transformers.utils.generic.TensorType | None = None, return_attention_mask: bool | None = True, padding: str | None = 'max_length', max_length: int | None = None, **kwargs)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/feature_extraction_clvp.py#L128)

**Parametreler:**

raw_speech (`np.ndarray`, `list[float]`, `list[np.ndarray]`, `list[list[float]]`) : Dolgusu yapılacak dizi veya dizi partisi. Her dizi, bir numpy dizisi, bir float değerleri listesi, bir numpy dizileri listesi veya float değerleri listeleri listesi olabilir. Tek kanallı ses olmalıdır, stereo değil; yani her zaman adımı için tek bir float.

sampling_rate (`int`, *isteğe bağlı*) : `raw_speech` girdisinin örneklenmiş olduğu örneklem hızı. Sessiz hataları önlemek ve otomatik konuşma tanıma hattına izin vermek için forward çağrısında `sampling_rate` parametresinin geçirilmesi şiddetle önerilir.

truncation (`bool`, *isteğe bağlı*, varsayılan `True`) : *max_length*'den uzun giriş dizilerini *max_length*'e kısaltmak için kesme işlemini etkinleştirir.

pad_to_multiple_of (`int`, *opsiyonel*) : Ayarlanırsa, diziyi verilen değerin katına kadar doldurur. Bu, hesaplama yeteneği `>= 7.5` (Volta) olan NVIDIA donanımlarında Tensor Cores kullanımını etkinleştirmek veya 128'in katı olan dizi uzunluklarından faydalanan TPU'larda özellikle faydalıdır.

return_attention_mask (`bool`, *isteğe bağlı*, varsayılan `True`) : Dikkat maskesinin (attention mask) döndürülüp döndürülmeyeceğini belirtir. Varsayılan değer bırakılırsa, dikkat maskesi döndürülür.  [Dikkat maskeleri nelerdir?](../glossary#attention-mask)

return_tensors (`str` veya [TensorType](/docs/transformers/main/tr/internal/file_utils#transformers.TensorType), *opsiyonel*) : Ayarlanırsa, Python tamsayı listesi yerine tensörler döndürülür. Kabul edilen değerler:  - `'pt'`: PyTorch `torch.Tensor` nesnelerini döndürür. - `'np'`: Numpy `np.ndarray` nesnelerini döndürür.

padding_value (`float`, *isteğe bağlı*, varsayılan 0.0) : Dolgu değerleri / vektörleri doldurmak için kullanılan değer.

max_length (`int`, *isteğe bağlı*) : Girdilerin maksimum giriş uzunluğu.

`ClvpFeatureExtractor`, örnek bir ses veya `raw_speech` içinden sesin perde ve tonu, konuşma hızı ve hatta dişil veya kekemelik gibi konuşma kusurları gibi çeşitli sesle ilgili özellikleri çıkarmak için kullanılır.

Önce ses, `self.default_audio_length` saniye uzunluğunda bir dalga formuna dönüşecek şekilde dolgu yapılır veya kısaltılır; ardından log-mel spektrogramı bu dalga formundan çıkarılır.

## ClvpProcessor[[transformers.ClvpProcessor]]

#### transformers.ClvpProcessor[[transformers.ClvpProcessor]]

```python
transformers.ClvpProcessor(feature_extractor, tokenizer)
```

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

**Parametreler:**

feature_extractor (`ClvpFeatureExtractor`) : Özellik çıkarıcı zorunlu bir girdidir.

tokenizer (`ClvpTokenizer`) : Tokenizer zorunlu bir girdidir.

Bir özellik çıkarıcıyı ve bir belirteçleyiciyi tek bir işlemciye saran bir ClvpProcessor oluşturur.

[ClvpProcessor](/docs/transformers/main/tr/model_doc/clvp#transformers.ClvpProcessor), [ClvpFeatureExtractor](/docs/transformers/main/tr/model_doc/clvp#transformers.ClvpFeatureExtractor) ve [ClvpTokenizer](/docs/transformers/main/tr/model_doc/clvp#transformers.ClvpTokenizer) sınıflarının tüm işlevlerini sunar. Daha fazla bilgi için [~ClvpFeatureExtractor](/docs/transformers/main/tr/model_doc/clvp#transformers.ClvpFeatureExtractor) ve [~ClvpTokenizer](/docs/transformers/main/tr/model_doc/clvp#transformers.ClvpTokenizer) belgelerini inceleyin.

#### __call__[[transformers.ClvpProcessor.__call__]]

```python
__call__(*args, text = None, audio = None, **kwargs)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/processing_clvp.py#L31)

**Parametreler:**

text (``) : The sequence or batch of sequences to be encoded. Each sequence can be a string or a list of strings (pretokenized string). If you pass a pretokenized input, set `is_split_into_words=True` to avoid ambiguity with batched inputs.

audio (``) : Hazırlanacak ses veya sesler partisi. Her ses, bir NumPy dizisi veya PyTorch tensörü olabilir. NumPy dizisi/PyTorch tensörü durumunda, her sesin şekli (C, T) olmalıdır; burada C kanal sayısı, T ise sesin örnek uzunluğudur.

return_tensors (`str` veya [TensorType](/docs/transformers/main/tr/internal/file_utils#transformers.TensorType), *opsiyonel*) : Ayarlanırsa, belirli bir çerçeveye ait tensörleri döndürür. Kabul edilen değerler:  - `'pt'`: PyTorch `torch.Tensor` nesnelerini döndürür. - `'np'`: NumPy `np.ndarray` nesnelerini döndürür.

#### decode[[transformers.ClvpProcessor.decode]]

```python
decode(*args, **kwargs)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/processing_utils.py#L1957)

Bu yöntem, tüm argümanlarını PreTrainedTokenizer'ın [decode()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.decode) yöntemine iletir. Daha fazla bilgi için bu yöntemin docstring'ine başvurun.

#### batch_decode[[transformers.ClvpProcessor.batch_decode]]

```python
batch_decode(*args, **kwargs)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/processing_utils.py#L1948)

Bu yöntem, tüm argümanlarını PreTrainedTokenizer'ın [batch_decode()](/docs/transformers/main/tr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.batch_decode) yöntemine iletir. Daha fazla bilgi için bu yöntemin docstring'ine başvurun.

## ClvpModelForConditionalGeneration[[transformers.ClvpModelForConditionalGeneration]]

#### transformers.ClvpModelForConditionalGeneration[[transformers.ClvpModelForConditionalGeneration]]

```python
transformers.ClvpModelForConditionalGeneration(config: ClvpConfig)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/modeling_clvp.py#L1247)

**Parametreler:**

config ([ClvpConfig](/docs/transformers/main/tr/model_doc/clvp#transformers.ClvpConfig)) : 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.

Bir metin kodlayıcı, konuşma kodlayıcı ve konuşma çözücü modeline sahip bileşik CLVP 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.ClvpModelForConditionalGeneration.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, input_features: typing.Optional[torch.Tensor] = None, conditioning_encoder_inputs_embeds: typing.Optional[torch.Tensor] = None, text_encoder_inputs_embeds: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.LongTensor] = None, return_loss: bool | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/modeling_clvp.py#L1452)

**Parametreler:**

input_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Sözlükteki girdi dizisi belirteçlerinin (token) indeksleri. Varsayılan olarak dolgu (padding) yoksayılır. İndeksler [AutoTokenizer](/docs/transformers/main/tr/model_doc/auto#transformers.AutoTokenizer) 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__) yöntemlerine bakın. [Girdi kimlikları (input IDs) nedir?](../glossary#input-ids)

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 [ClvpFeatureExtractor](/docs/transformers/main/tr/model_doc/clvp#transformers.ClvpFeatureExtractor) kullanılarak elde edilebilir. Ayrıntılar için [ClvpFeatureExtractor.__call__()](/docs/transformers/main/tr/model_doc/clvp#transformers.ClvpFeatureExtractor.__call__) bölümüne bakın ([ClvpProcessor](/docs/transformers/main/tr/model_doc/clvp#transformers.ClvpProcessor), sesleri işlemek için [ClvpFeatureExtractor](/docs/transformers/main/tr/model_doc/clvp#transformers.ClvpFeatureExtractor) kullanır).

conditioning_encoder_inputs_embeds (`torch.Tensor`, *isteğe bağlı*) : `ClvpConditioningEncoder` için inputs_embeds. `input_ids` yerine kullanılabilir.

text_encoder_inputs_embeds (`torch.Tensor`, *isteğe bağlı*) : `input_ids` yerine metin kodlayıcı modeline geçirilen inputs_embeds.

attention_mask (`torch.LongTensor`, ş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)

return_loss (`bool`, *isteğe bağlı*) : Karşıtlık kaybının (contrastive loss) döndürülüp döndürülmeyeceği.

**Dönüş:** `ClvpOutput` veya `tuple(torch.Tensor)`

Yapılandırmaya ([ClvpConfig](/docs/transformers/main/tr/model_doc/clvp#transformers.ClvpConfig)) ve girdilere bağlı olarak çeşitli öğelerden oluşan, `ClvpOutput` veya bir `torch.Tensor` demeti (`return_dict=False` geçirildiğinde veya `config.return_dict=False` olduğunda).

[ClvpModelForConditionalGeneration](/docs/transformers/main/tr/model_doc/clvp#transformers.ClvpModelForConditionalGeneration) 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,)`, *opsiyonel*, `return_loss` `True` olduğunda döndürülür) -- Ses-metin benzerliği için kontrastif kayıp.
- **speech_ids** (`torch.LongTensor`, *isteğe bağlı*) -- `ClvpForCausalLM` modeli tarafından üretilen speech_ids (veya speech adayları).
- **logits_per_speech** (`torch.Tensor`, şekli `(speech_batch_size, text_batch_size)`) -- `speech_embeds` ile `text_embeds` arasındaki ölçekli nokta çarpımı puanları. Bu, konuşma-metin benzerlik puanlarını temsil eder.
- **logits_per_text** (`torch.Tensor`, şekli `(text_batch_size, speech_batch_size)`) -- `text_embeds` ile `speech_embeds` arasındaki ölçekli nokta çarpımı puanları. Bu, metin-konuşma benzerlik puanlarını temsil eder.
- **text_embeds** (`torch.Tensor`, şekli `(batch_size, output_dim`) -- Metin kodlayıcı modelinin havuzlanmış çıktısına projeksiyon katmanının uygulanmasıyla elde edilen metin gömme değerleri.
- **speech_embeds** (`torch.Tensor`, şekli `(batch_size, output_dim`) -- Ses kodlayıcı modelinin havuzlanmış çıktısına projeksiyon katmanının uygulanmasıyla elde edilen ses gömme değerleri.
- **text_model_output** (`~modeling_outputs.BaseModelOutputWithPooling`, *isteğe bağlı*) -- Metin kodlayıcı Model'inin `last_hidden_state`'inin havuzlanmış çıktısı.
- **speech_model_output** (`~modeling_outputs.BaseModelOutputWithPooling`, *isteğe bağlı*) -- Ses kodlayıcı Model'inin `last_hidden_state`'inin havuzlanmış çıktısı.
- **decoder_hidden_states** (`torch.Tensor`, *isteğe bağlı*) -- Dekoder modelinin gizli durumları.
- **text_encoder_hidden_states** (`torch.Tensor`, *isteğe bağlı*) -- Metin kodlayıcı modelinin gizli durumları.
- **speech_encoder_hidden_states** (`torch.Tensor`, *isteğe bağlı*) -- Ses kodlayıcı modelinin gizli durumları.

Örnekler:

```python
>>> import datasets
>>> from transformers import ClvpProcessor, ClvpModelForConditionalGeneration

>>> # Define the Text and Load the Audio (We are taking an audio example from HuggingFace Hub using `datasets` library)
>>> text = "This is an example text."

>>> ds = datasets.load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> ds = ds.cast_column("audio", datasets.Audio(sampling_rate=22050))
>>> audio = ds.sort("id")["audio"][0]
>>> audio_sample, sr = audio["array"], audio["sampling_rate"]

>>> # Define processor and model
>>> processor = ClvpProcessor.from_pretrained("susnato/clvp_dev")
>>> model = ClvpModelForConditionalGeneration.from_pretrained("susnato/clvp_dev")

>>> # processor outputs and model outputs
>>> processor_output = processor(raw_speech=audio_sample, sampling_rate=sr, text=text, return_tensors="pt")
>>> outputs = model(
...     input_ids=processor_output["input_ids"],
...     input_features=processor_output["input_features"],
...     return_dict=True,
... )
```

#### generate[[transformers.ClvpModelForConditionalGeneration.generate]]

```python
generate(input_ids: typing.Optional[torch.LongTensor] = None, input_features: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.LongTensor] = None, generation_config: transformers.generation.configuration_utils.GenerationConfig | None = None, pad_to_max_mel_tokens: int | None = None, output_hidden_states: bool | None = None, **kwargs)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/modeling_clvp.py#L1561)

**Parametreler:**

input_ids (`torch.Tensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Girdi metin Token'ları. [ClvpTokenizer](/docs/transformers/main/tr/model_doc/clvp#transformers.ClvpTokenizer) tarafından işlenir.

attention_mask (`torch.Tensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Dolgu metin token dizinlerinde dikkat işleminin uygulanmasını önlemek için maske. `[0, 1]` aralığında seçilen maske değerleri:  - **maske uygulanmamış** tokenlar için 1, - **maske uygulanmış** tokenlar için 0.  [Dikkat maskeleri nelerdir?](../glossary#attention-mask)

generation_config (`~generation.GenerationConfig`, *isteğe bağlı*) : Üretim çağrısı için temel parametrelendirme olarak kullanılacak üretim yapılandırması. `generation_config` öznitelikleriyle eşleşen ve generate'e aktarılan `**kwargs` bunları geçersiz kılar. `generation_config` sağlanmazsa, varsayılan değer kullanılır; bunun yükleme önceliği şu şekildedir: 1) varsa `generation_config.json` model dosyasından; 2) model yapılandırmasından. Belirtilmeyen parametrelerin [GenerationConfig](/docs/transformers/main/tr/main_classes/text_generation#transformers.GenerationConfig)'in varsayılan değerlerini devralacağını ve üretim parametrelendirmesi için belgelenmiş değerlerin kontrol edilmesi gerektiğini lütfen unutmayın.

pad_to_max_mel_tokens (`int`, *isteğe bağlı*) : Üretilen speech_ids değerini belirtilen değere kadar doldurur. Bu, resmi depodaki aynı mantığı uygulamak ve logits'lerin aynı olduğundan emin olmak içindir, bağlantı: https://github.com/neonbjb/tortoise-tts/blob/80f89987a5abda5e2b082618cd74f9c7411141dc/tortoise/api.py#L430 . Bu, üretim kalitesini etkilemez, bu nedenle daha az verimli olduğu için kullanmayı düşünmeyin.

output_hidden_states (`bool`, *isteğe bağlı*) : Dekoder modeli, metin kodlayıcı ve konuşma kodlayıcı modellerinin gizli durumlarının (hidden states) döndürülüp döndürülmeyeceğini belirtir.

**Dönüş:** `ClvpOutput` veya tuple

`ClvpOutput` (eğer `return_dict_in_generate=True` ise veya `config.return_dict_in_generate=True` olduğunda) ya da bir tuple.

`ClvpModelForConditionalGeneration` için Generate yöntemi, bu yöntem `ClvpForCausalLM`'nin `generate` yöntemini çağırır ve ardından üretilen `speech_ids`'leri kullanarak `ClvpEncoder` ile `text_embeds` ve `speech_embeds`'leri işler.

#### get_text_features[[transformers.ClvpModelForConditionalGeneration.get_text_features]]

```python
get_text_features(input_ids: typing.Optional[torch.LongTensor] = None, text_encoder_inputs_embeds: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.LongTensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/modeling_clvp.py#L1315)

**Parametreler:**

input_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Sözlükteki girdi dizisi belirteçlerinin (token) indeksleri. Varsayılan olarak dolgu (padding) yoksayılır. İndeksler [AutoTokenizer](/docs/transformers/main/tr/model_doc/auto#transformers.AutoTokenizer) 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__) yöntemlerine bakın. [Girdi kimlikları (input IDs) nedir?](../glossary#input-ids)

text_encoder_inputs_embeds (`torch.Tensor`, *isteğe bağlı*) : `input_ids` yerine metin kodlayıcı modeline geçirilen inputs_embeds.

attention_mask (`torch.LongTensor`, ş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)

**Dönüş:** `ClvpEncoderOutput` veya `tuple(torch.Tensor)`

A `ClvpEncoderOutput` veya bir `torch.Tensor` tuple'ı (eğer `return_dict=False` geçirildiyse veya `config.return_dict=False` ise), yapılandırmaya ([ClvpConfig](/docs/transformers/main/tr/model_doc/clvp#transformers.ClvpConfig)) ve girdilere bağlı olarak çeşitli öğelerden oluşur.

Bu yöntem, bir metinden text_embeds çıkarmak için kullanılabilir. Metin gömleleri, CLVP metin kodlayıcı modelinin havuzlanmış çıktısına projeksiyon katmanının uygulanmasıyla elde edilir.

- **embeds** (`torch.Tensor`, şekli `(batch_size, output_dim)`, *opsiyonel*, model `with_projection=True` ile başlatıldığında döndürülür) -- pooler_output'a projeksiyon katmanının uygulanmasıyla elde edilen gömme değerleri.
- **last_hidden_state** (`torch.Tensor`, şekli `(batch_size, sequence_length, hidden_size)`) -- Modelin son katmanının gizli durumu.
- **pooler_output** (`torch.Tensor`, şekli `(batch_size, hidden_size)`) -- `last_hidden_state`'in havuzlanmış çıktısı.
- **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.

Örnekler:

```python
>>> from transformers import ClvpProcessor, ClvpModelForConditionalGeneration

>>> # Define the Text
>>> text = "This is an example text."

>>> # Define processor and model
>>> processor = ClvpProcessor.from_pretrained("susnato/clvp_dev")
>>> model = ClvpModelForConditionalGeneration.from_pretrained("susnato/clvp_dev")

>>> # Generate processor output and text embeds
>>> processor_output = processor(text=text, return_tensors="pt")
>>> text_embeds = model.get_text_features(input_ids=processor_output["input_ids"])
```

#### get_speech_features[[transformers.ClvpModelForConditionalGeneration.get_speech_features]]

```python
get_speech_features(speech_ids: typing.Optional[torch.LongTensor] = None, input_ids: typing.Optional[torch.LongTensor] = None, input_features: typing.Optional[torch.Tensor] = None, conditioning_encoder_inputs_embeds: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, generation_config: transformers.generation.configuration_utils.GenerationConfig | None = None, **kwargs)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/modeling_clvp.py#L1357)

**Parametreler:**

speech_ids (`torch.LongTensor`, şekli `(batch_size, num_speech_ids)`, *isteğe bağlı*) : Konuşma Jetonları. Sağlarsanız, dolgu (padding) varsayılan olarak yok sayılır. speech_ids sağlanırsa input_ids ve input_features otomatik olarak yok sayılır.

input_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Girdi metin Token'ları. [ClvpTokenizer](/docs/transformers/main/tr/model_doc/clvp#transformers.ClvpTokenizer) tarafından işlenir. speech_ids sağlanmazsa, input_ids ve input_features kullanılır.

conditioning_encoder_inputs_embeds (`torch.Tensor`, *isteğe bağlı*) : `ClvpConditioningEncoder` için inputs_embeds. `input_ids` yerine kullanılabilir.

attention_mask (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Dolgu konuşma jetonu indekslerinde dikkat işleminin uygulanmasını önlemek için maske. `[0, 1]` aralığında seçilen maske değerleri:  - **maske uygulanmamış** jetonlar için 1, - **maske uygulanmış** jetonlar için 0.  [Dikkat maskeleri nelerdir?](../glossary#attention-mask)

generation_config (`GenerationConfig`, *isteğe bağlı*) : speech_ids sağlanmadığında speech_ids üretiminin kontrolü için generation config.

**Dönüş:** `torch.Tensor`, şekli `(batch_size, output_dim)`

CLVP Speech Model'in havuzlanmış çıktısına projeksiyon katmanının uygulanmasıyla elde edilen konuşma gömme değerleri.

Bu yöntem, speech_embeds çıkarımı için kullanılabilir. Ses gömlemleri, speech_ids üzerine ses modelinin uygulanmasıyla elde edilir. speech_ids mevcut değilse ancak hem input_ids hem de input_features verilirse, önce speech_ids'leri üretmek için decoder modeli kullanılır ve ardından ses modeli uygulanır.

Örnekler:

```python
>>> import datasets
>>> from transformers import ClvpProcessor, ClvpModelForConditionalGeneration

>>> # Define the Text and Load the Audio (We are taking an audio example from HuggingFace Hub using `datasets` library)
>>> text = "This is an example text."
>>> ds = datasets.load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> ds = ds.cast_column("audio", datasets.Audio(sampling_rate=22050))
>>> audio = ds.sort("id")["audio"][0]
>>> audio_sample, sr = audio["array"], audio["sampling_rate"]

>>> # Define processor and model
>>> processor = ClvpProcessor.from_pretrained("susnato/clvp_dev")
>>> model = ClvpModelForConditionalGeneration.from_pretrained("susnato/clvp_dev")

>>> # Generate processor output and model output
>>> processor_output = processor(raw_speech=audio_sample, sampling_rate=sr, text=text, return_tensors="pt")
>>> speech_embeds = model.get_speech_features(
...     input_ids=processor_output["input_ids"], input_features=processor_output["input_features"]
... )
```

## ClvpForCausalLM[[transformers.ClvpForCausalLM]]

#### transformers.ClvpForCausalLM[[transformers.ClvpForCausalLM]]

```python
transformers.ClvpForCausalLM(config: ClvpDecoderConfig)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/modeling_clvp.py#L1069)

**Parametreler:**

config ([ClvpDecoderConfig](/docs/transformers/main/tr/model_doc/clvp#transformers.ClvpDecoderConfig)) : 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.

Üstünde bir dil modelleme başlığı bulunan CLVP çözücü 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.ClvpForCausalLM.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/modeling_clvp.py#L1185)

**Parametreler:**

input_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Sözlükteki girdi dizisi belirteçlerinin (token) indeksleri. Varsayılan olarak dolgu (padding) yoksayılır. İndeksler [AutoTokenizer](/docs/transformers/main/tr/model_doc/auto#transformers.AutoTokenizer) 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__) yöntemlerine bakın. [Girdi kimlikları (input IDs) nedir?](../glossary#input-ids)

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.

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)

token_type_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Girdilerin ilk ve ikinci bölümlerini belirtmek için segment token dizinleri. Dizinler `[0, 1]` aralığından seçilir:  - 0, *sentence A* token'ına karşılık gelir, - 1, *sentence B* token'ına karşılık gelir.  [Token type ID'leri nelerdir?](../glossary#token-type-ids)

position_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Girdi dizisi token'larının konum gömme (position embeddings) içindeki konum indeksleri. `[0, config.n_positions - 1]` aralığında seçilir.  [Konum kimlikleri (position IDs) nedir?](../glossary#position-ids)

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

labels (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Dil modelleme için etiketler. Not: Etiketler model içinde **kaydırılır**, yani `labels = input_ids` olarak ayarlayabilirsiniz. İndisler `[-100, 0, ..., config.vocab_size]` 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]` aralığındaki etiketler için hesaplanır.

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

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

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

[ClvpForCausalLM](/docs/transformers/main/tr/model_doc/clvp#transformers.ClvpForCausalLM) 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.
- **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.

  Dikkat softmax'ı sonrası çapraz dikkat ağırlıkları, çapraz dikkat başlıklarında ağırlıklı ortalamanın hesaplanmasında kullanılır.
- **past_key_values** (`Cache`, *isteğe bağlı*, `use_cache=True` geçirildiğinde veya `config.use_cache=True` olduğunda döndürülür) -- Bir [Cache](/docs/transformers/main/tr/internal/generation_utils#transformers.Cache) örneğidir. Daha fazla ayrıntı için [kv cache 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ı (dikkat bloklarındaki anahtar ve değerler) içerir.

## ClvpModel[[transformers.ClvpModel]]

#### transformers.ClvpModel[[transformers.ClvpModel]]

```python
transformers.ClvpModel(config: ClvpDecoderConfig)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/modeling_clvp.py#L1013)

**Parametreler:**

config ([ClvpDecoderConfig](/docs/transformers/main/tr/model_doc/clvp#transformers.ClvpDecoderConfig)) : 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.

Üzerinde herhangi bir özel head olmadan ham hidden-state'ler üreten çıplak Clvp 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.ClvpModel.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/modeling_clvp.py#L1030)

**Parametreler:**

input_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Sözlükteki girdi dizisi belirteçlerinin (token) indeksleri. Varsayılan olarak dolgu (padding) yoksayılır. İndeksler [AutoTokenizer](/docs/transformers/main/tr/model_doc/auto#transformers.AutoTokenizer) 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__) yöntemlerine bakın. [Girdi kimlikları (input IDs) nedir?](../glossary#input-ids)

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

token_type_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Girdilerin ilk ve ikinci bölümlerini belirtmek için segment token dizinleri. Dizinler `[0, 1]` aralığından seçilir:  - 0, *sentence A* token'ına karşılık gelir, - 1, *sentence B* token'ına karşılık gelir.  [Token type ID'leri nelerdir?](../glossary#token-type-ids)

position_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Girdi dizisi token'larının konum gömme (position embeddings) içindeki konum indeksleri. `[0, config.n_positions - 1]` aralığında seçilir.  [Konum kimlikleri (position IDs) nedir?](../glossary#position-ids)

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.

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

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

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

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

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

  `past_key_values` kullanılırsa, yalnızca `(batch_size, 1, hidden_size)` biçimindeki dizilerin son gizli durumu (hidden-state) çıktı olarak verilir.
- **past_key_values** (`Cache`, *isteğe bağlı*, `use_cache=True` geçirildiğinde veya `config.use_cache=True` olduğunda döndürülür) -- Bir [Cache](/docs/transformers/main/tr/internal/generation_utils#transformers.Cache) örneğidir. Daha fazla ayrıntı için [kv cache 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 anahtar ve değerler ve isteğe bağlı olarak `config.is_encoder_decoder=True` ise cross-attention bloklarındaki anahtar ve değerler) içerir.
- **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.
- **cross_attentions** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_attentions=True` ve `config.add_cross_attention=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.

## ClvpEncoder[[transformers.ClvpEncoder]]

#### transformers.ClvpEncoder[[transformers.ClvpEncoder]]

```python
transformers.ClvpEncoder(config: ClvpEncoderConfig)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/modeling_clvp.py#L815)

**Parametreler:**

config : ClvpConfig

`config.num_hidden_layers` öz-dikkat katmanından oluşan Transformer kodlayıcı. Her katman bir `ClvpEncoderLayer`'dir.

#### forward[[transformers.ClvpEncoder.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/modeling_clvp.py#L849)

**Parametreler:**

input_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Sözlükteki girdi dizisi belirteçlerinin (token) indeksleri. Varsayılan olarak dolgu (padding) yoksayılır. İndeksler [AutoTokenizer](/docs/transformers/main/tr/model_doc/auto#transformers.AutoTokenizer) 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__) yöntemlerine bakın. [Girdi kimlikları (input IDs) nedir?](../glossary#input-ids)

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

attention_mask (`torch.LongTensor`, ş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)

position_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Girdi dizisi token'larının konum gömme (position embeddings) içindeki konum indeksleri. `[0, config.n_positions - 1]` aralığında seçilir.  [Konum kimlikleri (position IDs) nedir?](../glossary#position-ids)

**Dönüş:** `ClvpEncoderOutput` veya `tuple(torch.Tensor)`

A `ClvpEncoderOutput` veya bir `torch.Tensor` tuple'ı (eğer `return_dict=False` geçirildiyse veya `config.return_dict=False` ise), yapılandırmaya ([ClvpConfig](/docs/transformers/main/tr/model_doc/clvp#transformers.ClvpConfig)) ve girdilere bağlı olarak çeşitli öğelerden oluşur.

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

- **embeds** (`torch.Tensor`, şekli `(batch_size, output_dim)`, *opsiyonel*, model `with_projection=True` ile başlatıldığında döndürülür) -- pooler_output'a projeksiyon katmanının uygulanmasıyla elde edilen gömme değerleri.
- **last_hidden_state** (`torch.Tensor`, şekli `(batch_size, sequence_length, hidden_size)`) -- Modelin son katmanının gizli durumu.
- **pooler_output** (`torch.Tensor`, şekli `(batch_size, hidden_size)`) -- `last_hidden_state`'in havuzlanmış çıktısı.
- **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.

## ClvpDecoder[[transformers.ClvpDecoder]]

#### transformers.ClvpDecoder[[transformers.ClvpDecoder]]

```python
transformers.ClvpDecoder(config: ClvpDecoderConfig)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/modeling_clvp.py#L905)

*config.num_hidden_layers* katmandan oluşan Transformer decoder. Her katman bir `ClvpDecoderLayer`'dir.

#### forward[[transformers.ClvpDecoder.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/clvp/modeling_clvp.py#L937)

**Parametreler:**

input_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Sözlükteki girdi dizisi belirteçlerinin (token) indeksleri. Varsayılan olarak dolgu (padding) yoksayılır. İndeksler [AutoTokenizer](/docs/transformers/main/tr/model_doc/auto#transformers.AutoTokenizer) 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__) yöntemlerine bakın. [Girdi kimlikları (input IDs) nedir?](../glossary#input-ids)

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

token_type_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Girdilerin ilk ve ikinci bölümlerini belirtmek için segment token dizinleri. Dizinler `[0, 1]` aralığından seçilir:  - 0, *sentence A* token'ına karşılık gelir, - 1, *sentence B* token'ına karşılık gelir.  [Token type ID'leri nelerdir?](../glossary#token-type-ids)

position_ids (`torch.LongTensor`, şekli `(batch_size, sequence_length)`, *isteğe bağlı*) : Girdi dizisi token'larının konum gömme (position embeddings) içindeki konum indeksleri. `[0, config.n_positions - 1]` aralığında seçilir.  [Konum kimlikleri (position IDs) nedir?](../glossary#position-ids)

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.

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

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

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

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

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

  `past_key_values` kullanılırsa, yalnızca `(batch_size, 1, hidden_size)` biçimindeki dizilerin son gizli durumu (hidden-state) çıktı olarak verilir.
- **past_key_values** (`Cache`, *isteğe bağlı*, `use_cache=True` geçirildiğinde veya `config.use_cache=True` olduğunda döndürülür) -- Bir [Cache](/docs/transformers/main/tr/internal/generation_utils#transformers.Cache) örneğidir. Daha fazla ayrıntı için [kv cache 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 anahtar ve değerler ve isteğe bağlı olarak `config.is_encoder_decoder=True` ise cross-attention bloklarındaki anahtar ve değerler) içerir.
- **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.
- **cross_attentions** (`tuple(torch.Tensor)`, *isteğe bağlı*, `output_attentions=True` ve `config.add_cross_attention=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.