# EnCodec

## Genel Bakış

EnCodec sinir kodlayıcı modeli, Alexandre Défossez, Jade Copet, Gabriel Synnaeve ve Yossi Adi tarafından [High Fidelity Neural Audio Compression](https://huggingface.co/papers/2210.13438) makalesinde önerilmiştir.

Makalenin özeti aşağıdaki gibidir:

*Yapay sinir ağlarını kullanan, son teknoloji, gerçek zamanlı ve yüksek sadakatli bir ses kodlayıcı (audio codec) sunuyoruz. Bu sistem, uçtan uca (end-to-end) olarak eğitilmiş, kuantize edilmiş gizli uzaya (latent space) sahip bir akış (streaming) kodlayıcı-çözücü (encoder-decoder) mimarisinden oluşmaktadır. Eğitim sürecini basitleştirmek ve hızlandırmak için, artefaktları verimli bir şekilde azaltan ve yüksek kaliteli örnekler üreten tek bir çok ölçekli spektrogram (multiscale spectrogram) rakibi (adversary) kullanıyoruz. Eğitimi stabilize etmek için yeni bir kayıp dengeleyici (loss balancer) mekanizması sunuyoruz: bir kaybın ağırlığı, artık toplam gradyanın temsil etmesi gereken kesriyi tanımlar; bu sayede bu hiper-parametrenin seçimi, kaybın tipik ölçeğinden bağımsız hale gelir. Son olarak, gerçek zamanlıdan daha hızlı kalmak koşuluyla, elde edilen temsilin hafif (lightweight) Transformer modelleri kullanılarak %40'a kadar daha fazla sıkıştırılabileceğini inceliyoruz. Önerilen modelin ana tasarım tercihlerinin ayrıntılı bir açıklamasını sunuyoruz; bunlar arasında eğitim hedefi, mimari değişiklikler ve çeşitli algısal kayıp (perceptual loss) fonksiyonlarının incelenmesi yer almaktadır. Konuşma, gürültülü-yankılı konuşma ve müzik dahil olmak üzere çeşitli bant genişlikleri ve ses alanları için kapsamlı bir öznel değerlendirme (MUSHRA testleri) ve bir ablatif çalışma (ablation study) sunuyoruz. Yaklaşımımız, hem 24 kHz monofonik hem de 48 kHz stereofonik ses için değerlendirilen tüm ayarlarda, taban (baseline) yöntemlere göre üstün performans göstermektedir.*

Bu model [Matthijs](https://huggingface.co/Matthijs), [Patrick Von Platen](https://huggingface.co/patrickvonplaten) ve [Arthur Zucker](https://huggingface.co/ArthurZ) tarafından katkıda bulunmuştur. Orijinal kod [burada](https://github.com/facebookresearch/encodec) bulunabilir.

## Kullanım örneği

Bu modelle bir ses dosyasını kodlama ve çözmeye dair hızlı bir örnek:

```python
from datasets import Audio, load_dataset

from transformers import AutoProcessor, EncodecModel

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

model = EncodecModel.from_pretrained("facebook/encodec_24khz", device_map="auto")
processor = AutoProcessor.from_pretrained("facebook/encodec_24khz")
librispeech_dummy = librispeech_dummy.cast_column("audio", Audio(sampling_rate=processor.sampling_rate))
audio_sample = librispeech_dummy[-1]["audio"]["array"]
inputs = processor(raw_audio=audio_sample, sampling_rate=processor.sampling_rate, return_tensors="pt").to(model.device)

encoder_outputs = model.encode(inputs["input_values"], inputs["padding_mask"])
# `encoder_outputs.audio_codes` contains discrete codes
audio_values = model.decode(**encoder_outputs, padding_mask=inputs["padding_mask"])[0]
# or the equivalent with a forward pass
audio_values = model(inputs["input_values"], inputs["padding_mask"]).audio_values
```

## EncodecConfig[[transformers.EncodecConfig]]

#### transformers.EncodecConfig[[transformers.EncodecConfig]]

```python
transformers.EncodecConfig(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, target_bandwidths: list[float] | tuple[float, ...] = (1.5, 3.0, 6.0, 12.0, 24.0), sampling_rate: int = 24000, audio_channels: int = 1, normalize: bool = False, chunk_length_s: int | float | None = None, overlap: float | None = None, hidden_size: int = 128, num_filters: int = 32, num_residual_layers: int = 1, upsampling_ratios: list[int] | tuple[int, ...] = (8, 5, 4, 2), norm_type: str = 'weight_norm', kernel_size: int = 7, last_kernel_size: int = 7, residual_kernel_size: int = 3, dilation_growth_rate: int = 2, use_causal_conv: bool = True, pad_mode: str = 'reflect', compress: int = 2, num_lstm_layers: int = 2, trim_right_ratio: float = 1.0, codebook_size: int = 1024, codebook_dim: int | None = None, use_conv_shortcut: bool = True)
```

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

**Parametreler:**

target_bandwidths (`list[float]`, *isteğe bağlı*, varsayılan `[1.5, 3.0, 6.0, 12.0, 24.0]`) : Modelin ses kodlayabileceği farklı bant genişliklerinin aralığı.

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

audio_channels (`int`, *isteğe bağlı*, varsayılan `1`) : Girdi kanal sayısı.

normalize (`bool`, *isteğe bağlı*, varsayılan `False`) : Ses geçirildiğinde normalize edilecek mi?

chunk_length_s (`float`, *isteğe bağlı*) : Tanımlıysa ses, `chunk_length_s` uzunluğundaki parçalara ön işlenir ve ardından kodlanır.

overlap (`float`, *isteğe bağlı*) : Her parça arasındaki örtüşmeyi tanımlar. `chunk_stride` değerini hesaplamak için aşağıdaki formül kullanılır: `int((1.0 - self.overlap) * self.chunk_length)`.

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

num_filters (`int`, *opsiyonel*, varsayılan 32) : İlk `EncodecConv1d` alt örnekleme katmanındaki konvolüsyon çekirdeklerinin sayısı.

num_residual_layers (`int`, *isteğe bağlı*, varsayılan 1): Kalıntı katman sayısı.

upsampling_ratios (`Sequence[int]` , *isteğe bağlı*, varsayılan `[8, 5, 4, 2]`) : Çekirdek boyutu ve adım oranları. Kodlayıcı, yukarı örnekleme oranları yerine aşağı örnekleme oranlarını kullandığından, burada belirtilen ve kodlayıcı sırasıyla eşleşmesi gereken oranların ters sırasını kullanır.

norm_type (`str`, *isteğe bağlı*, varsayılan `"weight_norm"`) : Normalizasyon yöntemi. `["weight_norm", "time_group_norm"]` içinde olmalıdır

kernel_size (`int`, *isteğe bağlı*, varsayılan 7) : Başlangıç konvolüsyonu için çekirdek boyutu.

last_kernel_size (`int`, *isteğe bağlı*, varsayılan 7) : Son konvolüsyon katmanının çekirdek boyutu.

residual_kernel_size (`int`, *isteğe bağlı*, varsayılan 3) : Kalıntı katmanları için çekirdek boyutu.

dilation_growth_rate (`int`, *isteğe bağlı*, varsayılan 2) : Her katmanda dilasyonun ne kadar artırılacağı.

use_causal_conv (`bool`, *isteğe bağlı*, varsayılan `True`) : Tamamen nedensel konvolüsyonun kullanılıp kullanılmayacağı.

pad_mode (`str`, *isteğe bağlı*, varsayılan `"reflect"`) : Konvolüsyonlar için dolgu modu.

compress (`int`, *isteğe bağlı*, varsayılan 2) : Kalıntı dallarındaki azaltılmış boyut (Demucs v3'ten).

num_lstm_layers (`int`, *isteğe bağlı*, varsayılan 2) : Kodlayıcının sonunda bulunan LSTM katmanlarının sayısı.

trim_right_ratio (`float`, *opsiyonel*, varsayılan 1.0) : `use_causal_conv = True` yapılandırması altında transpoze konvolüsyonun sağ tarafında kırpma için oran. 1.0'a eşitse, tüm kırpmanın sağda yapıldığı anlamına gelir.

codebook_size (`int`, *isteğe bağlı*, varsayılan `1024`) : Modelin kullandığı paralel kod kitaplarının sayısı.

codebook_dim (`int`, *isteğe bağlı*) : Her kod kitabı gömme vektörünün boyutluluğu.

use_conv_shortcut (`bool`, *isteğe bağlı*, varsayılan `True`) : `EncodecResnetBlock` bloğunda 'skip' bağlantısı olarak konvolüsyon katmanı kullanılıp kullanılmayacağını belirtir. False ise, genel bir artımsal bağlantı sağlamak için bir kimlik fonksiyonu kullanılır.

Bu, bir EncodecModel yapılandırmasını depolamak için kullanılan yapılandırma sınıfıdır. Belirtilen argümanlara göre bir Encodec modelini örneklemek ve model mimarisini tanımlamak için kullanılır. Varsayılanlarla bir yapılandırma örneği oluşturmak, [facebook/encodec_24khz](https://huggingface.co/facebook/encodec_24khz) 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 EncodecModel, EncodecConfig

>>> # Initializing a "facebook/encodec_24khz" style configuration
>>> configuration = EncodecConfig()

>>> # Initializing a model (with random weights) from the "facebook/encodec_24khz" style configuration
>>> model = EncodecModel(configuration)

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

## EncodecFeatureExtractor[[transformers.EncodecFeatureExtractor]]

#### transformers.EncodecFeatureExtractor[[transformers.EncodecFeatureExtractor]]

```python
transformers.EncodecFeatureExtractor(feature_size: int = 1, sampling_rate: int = 24000, padding_value: float = 0.0, chunk_length_s: float | None = None, overlap: float | None = None, **kwargs)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/encodec/feature_extraction_encodec.py#L26)

**Parametreler:**

feature_size (`int`, *isteğe bağlı*, varsayılan 1) : Çıkarılan özelliklerin boyutu. Mono için 1, stereo için 2 kullanın.

sampling_rate (`int`, *isteğe bağlı*, varsayılan 24000) : Ses dalgasının dijitalleştirilmesi gereken örneklem hızı, hertz (Hz) cinsinden ifade edilir.

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

chunk_length_s (`float`, *isteğe bağlı*) : Tanımlıysa ses, `chunk_length_s` uzunluğundaki parçalara ön işlenir ve ardından kodlanır.

overlap (`float`, *isteğe bağlı*) : Her parça arasındaki örtüşmeyi tanımlar. `chunk_stride` değerini hesaplamak için aşağıdaki formül kullanılır: `int((1.0 - self.overlap) * self.chunk_length)`.

Bir EnCodec ö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.

Varsayılanlarla bir özellik çıkarıcı örneklenirse, [facebook/encodec_24khz](https://huggingface.co/facebook/encodec_24khz) mimarisine benzer bir yapılandırma elde edilir.

#### __call__[[transformers.EncodecFeatureExtractor.__call__]]

```python
__call__(raw_audio: numpy.ndarray | list[float] | list[numpy.ndarray] | list[list[float]], padding: bool | str | transformers.utils.generic.PaddingStrategy | None = None, truncation: bool | None = False, max_length: int | None = None, return_tensors: str | transformers.utils.generic.TensorType | None = None, sampling_rate: int | None = None)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/encodec/feature_extraction_encodec.py#L81)

**Parametreler:**

raw_audio (`np.ndarray`, `list[float]`, `list[np.ndarray]`, `list[list[float]]`) : İşlenecek dizi veya dizi topluluğu. Her dizi, bir numpy dizisi, bir float değerleri listesi, bir numpy dizileri listesi veya float değerleri listelerinin listesi olabilir. Mono ses için (`feature_size = 1`) numpy dizisinin şekli `(num_samples,)` olmalı, stereo ses için (`feature_size = 2`) ise `(2, num_samples)` olmalıdır.

padding (`bool`, `str` veya [PaddingStrategy](/docs/transformers/main/tr/internal/file_utils#transformers.utils.PaddingStrategy), *opsiyonel*, varsayılan `True`) : Dönen dizilerin dolgusunu (modelin dolgu tarafına ve dolgu indeksine göre) aşağıdakilerden birini seçerek belirleyin: - `True` veya `'longest'`: Batch'teki en uzun diziye kadar dolgu yapın (yalnızca tek bir dizi sağlandıysa dolgu yapılmaz). - `'max_length'`: `max_length` argümanı ile belirtilen maksimum uzunluğa kadar veya bu argüman sağlanmadıysa modelin kabul edebileceği maksimum giriş uzunluğuna kadar dolgu yapın. - `False` veya `'do_not_pad'` (varsayılan): Dolgu yapılmaz (yani, farklı uzunluklarda dizilere sahip bir batch çıktısı verilebilir).

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

max_length (`int`, *isteğe bağlı*) : Dönen listenin maksimum uzunluğu ve isteğe bağlı dolgu uzunluğu (bkz. yukarıda).

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.

sampling_rate (`int`, *isteğe bağlı*) : `audio` girdisinin örneklenmiş olduğu örneklem hızı. Sessiz hataları önlemek için `sampling_rate` değerini forward çağrısında geçmek şiddetle önerilir.

Bir veya birden fazla diziyi model için özelliklendirmek ve hazırlamak için ana yöntem.

## EncodecModel[[transformers.EncodecModel]]

#### transformers.EncodecModel[[transformers.EncodecModel]]

```python
transformers.EncodecModel(config: EncodecConfig)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/encodec/modeling_encodec.py#L485)

**Parametreler:**

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

EnCodec sinirsel ses kodek 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.

#### decode[[transformers.EncodecModel.decode]]

```python
decode(audio_codes: LongTensor, audio_scales: Tensor, padding_mask: typing.Optional[torch.Tensor] = None, return_dict: bool | None = None, last_frame_pad_length: int | None = 0)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/encodec/modeling_encodec.py#L661)

**Parametreler:**

audio_codes (`torch.LongTensor`, şekli `(nb_frames, batch_size, nb_quantizers, frame_len)`, *isteğe bağlı*) : `model.encode` kullanılarak hesaplanan ayrık kod gömme değerleri.

audio_scales (`nb_frames` uzunluğunda, `torch.Tensor` tipinde, `(batch_size, 1)` biçiminde bir liste, *isteğe bağlı*) : Her `audio_codes` girdisi için ölçekleme faktörü.

padding_mask (`torch.Tensor`, şekli `(channels, sequence_length)`) : `input_values` için dolgu yapmakta kullanılan dolgu maskesi.

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

last_frame_pad_length (`int`, *isteğe bağlı*) : Son karede yer alan ve çözümleme sırasında kaldırılan dolgu uzunluğunu temsil eden tamsayı.

Verilen kareleri bir çıkış ses dalgası biçiminde çözer.

Çıktının girdiden biraz daha büyük olabileceğini unutmayın. Bu durumda, sondaki fazladan adımlar kesilebilir.

#### encode[[transformers.EncodecModel.encode]]

```python
encode(input_values: Tensor, padding_mask: typing.Optional[torch.Tensor] = None, bandwidth: float | None = None, return_dict: bool | None = None)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/encodec/modeling_encodec.py#L525)

**Parametreler:**

input_values (`torch.Tensor`, şekli `(batch_size, channels, sequence_length)`) : Girdi ses dalgasının float değerleri.

padding_mask (`torch.Tensor`, şekli `(batch_size, channels, sequence_length)`) : `input_values` için dolgu yapmakta kullanılan dolgu maskesi.

bandwidth (`float`, *isteğe bağlı*) : Hedef bant genişliği. `config.target_bandwidths` içindeki değerlerden biri olmalıdır. `None` ise, mümkün olan en küçük bant genişliği kullanılır. bandwidth, değerinin binde biri olarak temsil edilir; örneğin 6kbps bant genişliği, bandwidth == 6.0 olarak temsil edilir.

**Dönüş:** `EncodecEncoderOutput dict or a tuple containing`

- audio_codes (`torch.LongTensor`, şekli `(nb_frames, batch_size, nb_quantizers, frame_len)`, *isteğe bağlı*),
- audio_scales (`nb_frames` uzunluğunda, `torch.Tensor` tipinde, `(batch_size, 1)` biçiminde bir liste, *isteğe bağlı*),
- last_frame_pad_length (`int`, *isteğe bağlı*).

Girdi ses dalgacığını `(nb_frames, batch_size, nb_quantizers, frame_len)` biçiminde ayrık kodlara dönüştürür.

- `nb_frames=1`, `self.config.chunk_length=None` ise (kodlayıcı tüm ses üzerinde uygulandığı için), bu
24 kHz model için durum. Aksi halde, 48 kHz model için geçerli olan `nb_frames=ceil(input_length/self.config.chunk_stride)` kullanılır.
- `frame_len` is the length of each frame, which is equal to `ceil(input_length/self.config.hop_length)` if
`self.config.chunk_length=None` (örneğin 24 kHz model için). Aksi halde, `self.config.chunk_length` tanımlıysa, `frame_len=self.config.chunk_length/self.config.hop_length` olur; örneğin `frame_len=150` olan 48 kHz model durumu.

#### forward[[transformers.EncodecModel.forward]]

```python
forward(input_values: Tensor, padding_mask: typing.Optional[torch.BoolTensor] = None, bandwidth: float | None = None, audio_codes: typing.Optional[torch.LongTensor] = None, audio_scales: typing.Optional[torch.Tensor] = None, return_dict: bool | None = None, last_frame_pad_length: int | None = 0)
```

[Kaynak](https://github.com/huggingface/transformers/blob/main/src/transformers/models/encodec/modeling_encodec.py#L716)

**Parametreler:**

input_values (`torch.Tensor`, şekli `(batch_size, channels, sequence_length)`, *isteğe bağlı*) : Ham ses girdisi, Float'a dönüştürülür ve `config.chunk_stride` adım uzunluğu ile self.chunk_length uzunluğundaki parçalar kullanılarak kodlanabilmesi için uygun uzunluğa doldurulur.

padding_mask (`torch.BoolTensor`, şekli `(batch_size, channels, sequence_length)`, *isteğe bağlı*) : Dolgu (padding) token indekslerinde ölçekleme faktörlerinin hesaplanmasını önlemek için maske (bu indekslerde conv hesaplamasından kaçınabilir miyiz+). `[0, 1]` aralığında seçilen maske değerleri:  - **maskelenmemiş** tokenlar için 1, - **maskelenmiş** tokenlar için 0.    `padding_mask`, girdi kısaltılmış veya dolgu yapılmamış olmadıkça her zaman iletilmelidir. Bunun nedeni, tensörleri etkili bir şekilde işleyebilmek için girdi sesinin, `step = chunk_length-stride` olacak şekilde `input_length % stride = step` koşulunu sağlayacak biçimde doldurulması gerektiğidir. Bu, tüm parçaların (chunk) aynı şekle sahip olmasını sağlar

bandwidth (`float`, *isteğe bağlı*) : Hedef bant genişliği. `config.target_bandwidths` içindeki değerlerden biri olmalıdır. `None` ise, mümkün olan en küçük bant genişliği kullanılır. bandwidth, değerinin binde biri olarak temsil edilir; örneğin 6kbps bant genişliği `bandwidth == 6.0` olarak temsil edilir.

audio_codes (`torch.LongTensor`, şekli `(nb_frames, batch_size, nb_quantizers, frame_len)`, *isteğe bağlı*) : `model.encode` kullanılarak hesaplanan ayrık kod gömme değerleri.

audio_scales (`list`, uzunluğu `nb_frames`, `torch.Tensor` öğeleri, şekli `(batch_size, 1)`, *opsiyonel*) : Her `audio_codes` girdisi için ölçekleme faktörü.

return_dict (`bool`, *isteğe bağlı*) : Çıktıları bir sözlük olarak döndürüp döndürmeyeceğini belirtir.

last_frame_pad_length (`int`, *isteğe bağlı*) : Varsa, son karedeki dolgu uzunluğu. Kodlanmış karelerin bir tensör olarak çıkarılabilmesini sağlamak için kullanılır. Kodlanmış karelerden dolguların kaldırılmasını sağlamak için bu değer, çözümleme sırasında geçirilmelidir.

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

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

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

- **audio_codes** (`torch.LongTensor`, şekli `(nb_frames, batch_size, nb_quantizers, frame_len)`, *isteğe bağlı*) -- `model.encode` kullanılarak hesaplanan ayrık kod gömme değerleri.
- **audio_values** (`torch.Tensor`, şekli `(batch_size, segment_length)`, *isteğe bağlı*) -- Encodec'in decoder kısmı kullanılarak elde edilen çözümlenmiş ses değerleri.

Örnekler:

```python
>>> from datasets import load_dataset
>>> from transformers import AutoProcessor, EncodecModel

>>> dataset = load_dataset("hf-internal-testing/ashraq-esc50-1-dog-example")
>>> audio_sample = dataset["train"]["audio"][0]["array"]

>>> model_id = "facebook/encodec_24khz"
>>> model = EncodecModel.from_pretrained(model_id)
>>> processor = AutoProcessor.from_pretrained(model_id)

>>> inputs = processor(raw_audio=audio_sample, return_tensors="pt")

>>> outputs = model(**inputs)
>>> audio_codes = outputs.audio_codes
>>> audio_values = outputs.audio_values
```