# EnCodec

## 개요

EnCodec 신경 코덱 모델은 Alexandre Défossez, Jade Copet, Gabriel Synnaeve, Yossi Adi가 [High Fidelity Neural Audio Compression](https://huggingface.co/papers/2210.13438)에서 제안했습니다.

해당 논문의 초록은 다음과 같습니다:

*신경망을 활용하는 최첨단 실시간 고해상도 오디오 코덱을 소개합니다. 이 코덱은 스트리밍 인코더-디코더 아키텍처와 양자화된 잠재 공간으로 구성되며, 엔드투엔드 방식으로 학습됩니다. 단일 멀티스케일 스펙트로그램 어드버서리를 사용하여 아티팩트를 효율적으로 줄이고 고품질 샘플을 생성함으로써 학습을 단순화하고 가속화합니다. 학습을 안정화하기 위해 새로운 손실 밸런서 메커니즘을 도입했습니다. 이제 손실의 가중치는 전체 그래디언트에서 해당 손실이 차지해야 하는 비율을 정의하므로, 이 하이퍼파라미터의 선택이 손실의 일반적인 규모와 분리됩니다. 마지막으로, 실시간보다 빠른 속도를 유지하면서 얻은 표현을 최대 40%까지 추가로 압축할 수 있도록 경량 Transformer 모델을 활용하는 방법을 연구했습니다. 제안된 모델의 주요 설계 선택 사항, 즉 학습 목표, 아키텍처 변경 사항, 다양한 지각 손실 함수에 대한 연구를 자세히 설명합니다. 음성, 소음이 섞인 잔향 있는 음성, 음악 등 다양한 대역폭과 오디오 도메인에 대해 광범위한 주관적 평가(MUSHRA 테스트)와 아블레이션 연구를 함께 제시합니다. 24 kHz 모노포닉 및 48 kHz 스테레오포닉 오디오를 모두 고려할 때, 평가된 모든 설정에서 제안된 접근 방식이 베이스라인 방법보다 우수합니다.*

이 모델은 [Matthijs](https://huggingface.co/Matthijs), [Patrick Von Platen](https://huggingface.co/patrickvonplaten), [Arthur Zucker](https://huggingface.co/ArthurZ)가 기여했습니다. 원본 코드는 [여기](https://github.com/facebookresearch/encodec)에서 찾을 수 있습니다.

## 사용 예시

이 모델을 사용하여 오디오를 인코딩하고 디코딩하는 간단한 예시입니다:

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

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/encodec/configuration_encodec.py#L27)

**매개변수:**

target_bandwidths (`list[float]`, *선택 사항*, 기본값 `[1.5, 3.0, 6.0, 12.0, 24.0]`) : 모델이 오디오를 인코딩할 수 있는 다양한 대역폭의 범위입니다.

sampling_rate (`int`, *선택 사항*, 기본값 `24000`) : 오디오 파일을 디지털화할 때 사용할 샘플링 레이트를 헤르츠(Hz) 단위로 나타낸 값입니다.

audio_channels (`int`, *선택 사항*, 기본값 `1`) : 입력 채널의 수입니다.

normalize (`bool`, *선택 사항*, 기본값 `False`) : 오디오가 전달될 때 정규화할지 여부.

chunk_length_s (`float`, *선택 사항*) : 정의된 경우 오디오는 `chunk_length_s` 길이의 청크로 사전 처리된 후 인코딩됩니다.

overlap (`float`, *선택 사항*) : 각 청크 사이의 겹침을 정의합니다. 다음 수식을 사용하여 `chunk_stride`를 계산하는 데 사용됩니다: `int((1.0 - self.overlap) * self.chunk_length)`.

hidden_size (`int`, *선택 사항*, 기본값 `128`) : 숨겨진 표현의 차원.

num_filters (`int`, *선택 사항*, 기본값 32) : 첫 번째 `EncodecConv1d` 다운샘플링 레이어의 컨볼루션 커널 수.

num_residual_layers (`int`, *선택 사항*, 기본값 1) : 잔차 레이어의 수.

upsampling_ratios (`Sequence[int]` , *선택 사항*, 기본값 `[8, 5, 4, 2]`) : 커널 크기 및 스트라이드 비율입니다. 인코더는 업샘플링 비율 대신 다운샘플링 비율을 사용하므로, 여기에서 지정된 비율과 일치해야 하는 디코더 순서와 반대 순서로 비율을 사용합니다.

norm_type (`str`, *선택 사항*, 기본값 `"weight_norm"`) : 정규화 방법. `["weight_norm", "time_group_norm"]` 중 하나여야 합니다.

kernel_size (`int`, *선택 사항*, 기본값 7) : 초기 컨볼루션의 커널 크기.

last_kernel_size (`int`, *선택 사항*, 기본값 7) : 마지막 컨볼루션 레이어의 커널 크기.

residual_kernel_size (`int`, *선택 사항*, 기본값 3) : 잔차 레이어의 커널 크기입니다.

dilation_growth_rate (`int`, *선택 사항*, 기본값 2) : 각 레이어에서 dilation을 얼마나 증가시킬지 지정합니다.

use_causal_conv (`bool`, *선택 사항*, 기본값 `True`) : 완전 인과적 컨볼루션을 사용할지 여부.

pad_mode (`str`, *선택 사항*, 기본값 `"reflect"`) : 합성곱에 사용할 패딩 모드입니다.

compress (`int`, *선택 사항*, 기본값 2) : 잔차 브랜치의 축소된 차원 (Demucs v3에서).

num_lstm_layers (`int`, *선택 사항*, 기본값 2) : 인코더 끝부분의 LSTM 레이어 수.

trim_right_ratio (`float`, *선택 사항*, 기본값 1.0) : `use_causal_conv = True` 설정에서 전치 합성곱의 오른쪽을 자를 때 사용할 비율입니다. 1.0과 같으면 모든 자름이 오른쪽에서 수행됨을 의미합니다.

codebook_size (`int`, *선택 사항*, 기본값 `1024`) : 모델이 사용하는 병렬 코드북의 수입니다.

codebook_dim (`int`, *선택 사항*) : 각 코드북 임베딩 벡터의 차원.

use_conv_shortcut (`bool`, *선택 사항*, 기본값 `True`) : `EncodecResnetBlock` 블록에서 'skip' 연결로 합성곱(convolutional) 레이어를 사용할지 여부입니다. False인 경우, 일반 잔차(residual) 연결을 제공하기 위해 항등(identity) 함수가 사용됩니다.

이것은 EncodecModel의 구성을 저장하기 위한 구성 클래스입니다. 지정된 인자에 따라 Encodec 모델을 인스턴스화하여 모델 아키텍처를 정의하는 데 사용됩니다. 기본값으로 구성을 인스턴스화하면 [facebook/encodec_24khz](https://huggingface.co/facebook/encodec_24khz)와 유사한 구성이 생성됩니다.

Configuration 객체는 [PreTrainedConfig](/docs/transformers/v5.23.0/ko/main_classes/configuration#transformers.PreTrainedConfig)를 상속하며, 모델 출력을 제어하는 데 사용할 수 있습니다. 자세한 내용은 [PreTrainedConfig](/docs/transformers/v5.23.0/ko/main_classes/configuration#transformers.PreTrainedConfig)의 문서를 참고하세요.

예:

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

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/encodec/feature_extraction_encodec.py#L26)

**매개변수:**

feature_size (`int`, *선택 사항*, 기본값 1) : 추출된 특징의 차원입니다. 모노는 1, 스테레오는 2를 사용합니다.

sampling_rate (`int`, *선택 사항*, 기본값 24000) : 오디오 웨이브폼을 디지털화할 때 사용할 샘플링 주파수입니다. 헤르츠(Hz) 단위로 표현됩니다.

padding_value (`float`, *선택 사항*, 기본값 0.0) : 패딩 값에 채워지는 값입니다.

chunk_length_s (`float`, *선택 사항*) : 정의된 경우 오디오는 `chunk_length_s` 길이의 청크로 사전 처리된 후 인코딩됩니다.

overlap (`float`, *선택 사항*) : 각 청크 사이의 겹침을 정의합니다. 다음 수식을 사용하여 `chunk_stride`를 계산하는 데 사용됩니다: `int((1.0 - self.overlap) * self.chunk_length)`.

EnCodec feature extractor를 생성합니다.

이 feature extractor는 대부분의 주요 메서드를 포함하는 [SequenceFeatureExtractor](/docs/transformers/v5.23.0/ko/main_classes/feature_extractor#transformers.SequenceFeatureExtractor)를 상속합니다. 해당 메서드에 대한 자세한 내용은 이 상위 클래스를 참고하세요.

기본값으로 feature extractor를 인스턴스화하면 [facebook/encodec_24khz](https://huggingface.co/facebook/encodec_24khz) 아키텍처와 유사한 구성이 생성됩니다.

#### __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)
```

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/encodec/feature_extraction_encodec.py#L81)

**매개변수:**

raw_audio (`np.ndarray`, `list[float]`, `list[np.ndarray]`, `list[list[float]]`) : 처리할 시퀀스 또는 시퀀스 배치입니다. 각 시퀀스는 numpy 배열, float 값의 리스트, numpy 배열의 리스트, float 값의 리스트의 리스트일 수 있습니다. numpy 배열은 모노 오디오(`feature_size = 1`)의 경우 `(num_samples,)` 형태여야 하고, 스테레오 오디오(`feature_size = 2`)의 경우 `(2, num_samples)` 형태여야 합니다.

padding (`bool`, `str` 또는 [PaddingStrategy](/docs/transformers/v5.23.0/ko/internal/file_utils#transformers.utils.PaddingStrategy), *optional*, 기본값 `True`) : 반환되는 시퀀스에 패딩을 적용할 전략을 선택합니다 (모델의 패딩 방향 및 패딩 인덱스에 따라). 선택지: - `True` 또는 `'longest'`: 배치 내 가장 긴 시퀀스 길이로 패딩합니다 (단일 시퀀스만 제공된 경우 패딩하지 않음). - `'max_length'`: `max_length` 인수로 지정된 최대 길이로 패딩하거나, 해당 인수가 제공되지 않은 경우 모델이 허용하는 최대 입력 길이로 패딩합니다. - `False` 또는 `'do_not_pad'` (기본값): 패딩하지 않음 (즉, 서로 다른 길이의 시퀀스로 구성된 배치 출력 가능).

truncation (`bool`, *선택 사항*, 기본값 `False`) : `max_length`보다 긴 입력 시퀀스를 `max_length`로 자르는 절단(truncation)을 활성화합니다.

max_length (`int`, *선택 사항*) : 반환되는 리스트의 최대 길이 및 선택적으로 패딩 길이(위 참조).

return_tensors (`str` 또는 [TensorType](/docs/transformers/v5.23.0/ko/internal/file_utils#transformers.TensorType), *optional*) : 설정된 경우, python 정수 목록 대신 텐서를 반환합니다. 허용되는 값은 다음과 같습니다:  - `'pt'`: PyTorch `torch.Tensor` 객체를 반환합니다. - `'np'`: Numpy `np.ndarray` 객체를 반환합니다.

sampling_rate (`int`, *선택 사항*) : `audio` 입력이 샘플링된 샘플링 레이트입니다. 조용한 오류를 방지하려면 forward 호출 시 `sampling_rate`를 전달하는 것이 강력히 권장됩니다.

하나 이상의 시퀀스를 특징화(featurize)하고 모델에 맞게 준비하는 주요 메서드입니다.

## EncodecModel[[transformers.EncodecModel]]

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

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

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/encodec/modeling_encodec.py#L485)

**매개변수:**

config ([EncodecConfig](/docs/transformers/v5.23.0/ko/model_doc/encodec#transformers.EncodecConfig)) : 모델의 모든 매개변수를 포함하는 모델 구성 클래스입니다. 구성 파일로 초기화하는 것은 모델과 관련된 가중치를 로드하지 않으며, 구성 정보만 로드합니다. 모델 가중치를 로드하려면 [from_pretrained()](/docs/transformers/v5.23.0/ko/main_classes/model#transformers.PreTrainedModel.from_pretrained) 메서드를 확인하세요.

EnCodec 신경 오디오 코덱 모델입니다.

이 모델은 [PreTrainedModel](/docs/transformers/v5.23.0/ko/main_classes/model#transformers.PreTrainedModel)에서 상속됩니다. 라이브러리가 모든 모델에 대해 구현하는 일반적 메서드(다운로드 또는 저장, 입력 임베딩 크기 조정, 헤드 프루닝 등)에 대해서는 상위 클래스 문서를 확인하세요.

이 모델은 또한 PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module)의 하위 클래스입니다. 일반적인 PyTorch Module처럼 사용하며, 일반적인 사용법과 동작에 관한 모든 사항은 PyTorch 문서를 참조하세요.

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

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/encodec/modeling_encodec.py#L661)

**매개변수:**

audio_codes (`torch.LongTensor`, shape `(nb_frames, batch_size, nb_quantizers, frame_len)`, *선택 사항*) : `model.encode`를 사용하여 계산된 이산 코드 임베딩.

audio_scales (`nb_frames` 길이의 `torch.Tensor` 목록, shape `(batch_size, 1)`, *선택 사항*) : 각 `audio_codes` 입력에 대한 스케일링 계수.

padding_mask (`torch.Tensor`, shape `(channels, sequence_length)`) : `input_values`를 패딩하는 데 사용되는 패딩 마스크입니다.

return_dict (`bool`, *선택 사항*) : 일반 튜플 대신 [ModelOutput](/docs/transformers/v5.23.0/ko/main_classes/output#transformers.utils.ModelOutput)를 반환할지 여부.

last_frame_pad_length (`int`, *선택 사항*) : 마지막 프레임의 패딩 길이를 나타내는 정수로, 디코딩 과정에서 제거됩니다.

… 주어진 프레임을 출력 오디오 웨이브폼으로 디코딩합니다.

출력이 입력보다 약간 더 클 수 있습니다. 이 경우, 끝부분의 추가 단계는 잘라낼 수 있습니다.

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

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/encodec/modeling_encodec.py#L525)

**매개변수:**

input_values (`torch.Tensor`, shape `(batch_size, channels, sequence_length)`) : 입력 오디오 웨이브폼의 부동 소수점 값.

padding_mask (`torch.Tensor`, shape `(batch_size, channels, sequence_length)`) : `input_values`를 패딩하는 데 사용되는 패딩 마스크입니다.

bandwidth (`float`, *선택 사항*) : 대상 대역폭입니다. `config.target_bandwidths` 중 하나여야 합니다. `None`인 경우 가능한 가장 작은 대역폭을 사용합니다. bandwidth는 실제 값의 1/1000으로 표현되며, 예를 들어 6kbps 대역폭은 bandwidth == 6.0으로 표현됩니다.

**반환값:** `EncodecEncoderOutput dict or a tuple containing`

- audio_codes (`torch.LongTensor`, shape `(nb_frames, batch_size, nb_quantizers, frame_len)`, *선택 사항*),
- audio_scales `nb_frames` 길이의 `torch.Tensor` 목록, 각 텐서의 모양은 `(batch_size, 1)`이며 *선택 사항*
- last_frame_pad_length (`int`, *선택 사항*).

입력 오디오 웨이브폼을 `(nb_frames, batch_size, nb_quantizers, frame_len)` 형태의 이산 코드로 인코딩합니다.

- `self.config.chunk_length=None`인 경우(인코더가 전체 오디오에 적용되므로) `nb_frames=1`이며, 이는
24kHz 모델의 경우입니다. 그렇지 않으면 `nb_frames=ceil(input_length/self.config.chunk_stride)`이며, 이는 48kHz 모델의 경우입니다.
- `frame_len`은 각 프레임의 길이이며, `ceil(input_length/self.config.hop_length)`와 같습니다. 조건은
`self.config.chunk_length=None` (예: 24kHz 모델). 그렇지 않으면 `self.config.chunk_length`이 정의되어 있다면 `frame_len=self.config.chunk_length/self.config.hop_length`가 됩니다. 예를 들어 `frame_len=150`인 48kHz 모델의 경우입니다.

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

[소스](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/encodec/modeling_encodec.py#L716)

**매개변수:**

input_values (`torch.Tensor`, shape `(batch_size, channels, sequence_length)`, *선택 사항*) : Float로 변환된 원시 오디오 입력으로, 길이 self.chunk_length의 chunk와 `config.chunk_stride`의 stride를 사용하여 인코딩되도록 적절한 길이에 패딩이 적용됩니다.

padding_mask (`torch.BoolTensor`, shape `(batch_size, channels, sequence_length)`, *선택 사항*) : padding 토큰 인덱스에 대해 스케일링 계산을 피하기 위한 마스크입니다(이 토큰들에 대한 conv 계산도 피할 수 있습니다). `[0, 1]` 범위에서 선택된 마스크 값:  - **마스크되지 않은** 토큰은 1, - **마스크된** 토큰은 0.    `padding_mask`는 입력이 잘리거나 padding이 적용되지 않은 경우를 제외하고는 항상 전달해야 합니다. 이는 텐서를 효과적으로 처리하기 위해 `input_length % stride = step` (여기서 `step = chunk_length-stride`)를 만족하도록 입력 오디오에 padding을 적용해야 하기 때문입니다. 이를 통해 모든 chunk가 동일한 shape를 가질 수 있습니다

bandwidth (`float`, *선택 사항*) : 대상 대역폭입니다. `config.target_bandwidths` 중 하나여야 합니다. `None`인 경우 가능한 가장 작은 대역폭을 사용합니다. bandwidth는 실제 값의 1/1000으로 표현되며, 예를 들어 6kbps 대역폭은 `bandwidth == 6.0`으로 표현됩니다.

audio_codes (`torch.LongTensor`, shape `(nb_frames, batch_size, nb_quantizers, frame_len)`, *선택 사항*) : `model.encode`를 사용하여 계산된 이산 코드 임베딩.

audio_scales (`list`, 길이 `nb_frames`, 각 요소는 `torch.Tensor`이며 shape이 `(batch_size, 1)`, *optional*) : 각 `audio_codes` 입력에 대한 스케일링 계수.

return_dict (`bool`, *선택 사항*) : 출력을 딕셔너리로 반환할지 여부.

last_frame_pad_length (`int`, *선택 사항*) : 마지막 프레임에 패딩이 있는 경우 그 길이입니다. 이는 인코딩된 프레임을 텐서로 출력할 수 있도록 보장하는 데 사용됩니다. 인코딩된 프레임에서 패딩이 제거되도록 보장하려면 디코딩 시 이 값을 전달해야 합니다.

**반환값:** `EncodecOutput` 또는 `tuple(torch.Tensor)`

`EncodecOutput` 또는 `torch.Tensor`의 튜플(`return_dict=False`이 전달되었거나 `config.return_dict=False`인 경우)로, 구성([EncodecConfig](/docs/transformers/v5.23.0/ko/model_doc/encodec#transformers.EncodecConfig))과 입력에 따라 다양한 요소를 포함합니다.

[EncodecModel](/docs/transformers/v5.23.0/ko/model_doc/encodec#transformers.EncodecModel)의 forward 메서드는 `__call__` 특수 메서드를 오버라이드합니다.

`Module` 인스턴스는 전처리 및 후처리 단계를 실행하는 것을 처리하지만, 이 함수는 해당 단계를 조용히 무시하므로, 순전파(forward pass) 레시피를 이 함수 내에서 정의해야 하더라도 이후에는 이 함수 대신 `Module` 인스턴스를 호출해야 합니다.

- **audio_codes** (`torch.LongTensor`, shape `(nb_frames, batch_size, nb_quantizers, frame_len)`, *선택 사항*) -- `model.encode`를 사용하여 계산된 이산 코드 임베딩.
- **audio_values** (`torch.Tensor`, shape `(batch_size, segment_length)`, *선택 사항*) -- Encodec의 decoder 부분을 사용하여 얻은 디코딩된 오디오 값.

예:

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

