# X-Codec2

## Обзор

Модель X-Codec2 была предложена в работе [Llasa: Scaling Train-Time and Inference-Time Compute for Llama-based Speech Synthesis](https://huggingface.co/papers/2502.04128).

X-Codec2 — это нейронный аудиокодек, разработанный для улучшения синтеза речи и общего генерирования аудио в конвейерах больших языковых моделей (LLM). Он расширяет возможности исходного X-Codec, совершенствуя методы интеграции и токенизации семантической и акустической информации, что обеспечивает эффективное и высококачественное представление аудио.

О его архитектуре:
- **Единая семанто-акустическая токенизация**: X-Codec2 объединяет выходные данные семантического энкодера (например, Wav2Vec2-BERT) и акустического энкодера в единственное вложение, захватывая как высокоуровневый смысл (например, текстовое содержание, эмоции), так и низкоуровневые детали аудио (например, тембр).
- **Одноступенчатое скалярное квантование признаков (FSQ)**: В отличие от многослойного остаточного VQ, используемого в большинстве подходов (например, [DAC](./dac), [EnCodec](./encodec), [X-Codec](./xcodec), [Mimi](./mimi)), X-Codec2 использует один слой скалярного квантования признаков (FSQ) для обеспечения стабильности и совместимости с каузальными авто-регрессивными LLM.
- **Дизайн, удобный для трансформеров**: одномерная структура токенов X-Codec2 естественным образом согласуется с авторегрессионным моделированием в LLM, таких как LLaMA, что повышает эффективность обучения и совместимость с последующими задачами.

Точка контрольного состояния модели доступна по адресу [HKUSTAudio/xcodec2-hf](https://huggingface.co/HKUSTAudio/xcodec2-hf).

Эта модель была предоставлена [Eric Bezzam](https://huggingface.co/bezzam) и [Steven Zheng](https://huggingface.co/Steveeeeeeen). Исходный код моделирования можно найти [здесь](https://huggingface.co/HKUSTAudio/xcodec2/blob/main/modeling_xcodec2.py), а код обучения — [здесь](https://github.com/zhenye234/X-Codec-2.0).

## Пример использования 

Вот краткий пример того, как закодировать и декодировать аудио с помощью этой модели:

```python 
from datasets import Audio, load_dataset
from transformers import AutoFeatureExtractor, AutoModel

model_id = "HKUSTAudio/xcodec2-hf"
model = AutoModel.from_pretrained(model_id, device_map="auto")
feature_extractor = AutoFeatureExtractor.from_pretrained(model_id)

dataset = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
dataset = dataset.cast_column("audio", Audio(sampling_rate=feature_extractor.sampling_rate))
audio = dataset[0]["audio"]["array"]
inputs = feature_extractor(audio=audio, sampling_rate=feature_extractor.sampling_rate, return_tensors="pt").to(
    model.device, model.dtype
)
print("Input waveform shape:", inputs["input_values"].shape)
# Input waveform shape: torch.Size([1, 1, 93760])

# encoder and decoder
audio_codes = model.encode(**inputs).audio_codes
print("Audio codes shape:", audio_codes.shape)
# Audio codes shape: torch.Size([1, 1, 293])
audio_values = model.decode(audio_codes).audio_values
print("Audio values shape:", audio_values.shape)
# Audio values shape: torch.Size([1, 1, 93760])

# Equivalently, you can do encoding and decoding in one step
model_output = model(**inputs)
audio_codes = model_output.audio_codes
audio_values = model_output.audio_values
```

### Пакетная обработка

Эта реализация также поддерживает пакетный ввод, в отличие от исходного [релиза](https://huggingface.co/HKUSTAudio/xcodec2)!

```python
from datasets import Audio, load_dataset
from transformers import AutoFeatureExtractor, AutoModel

batch_size = 2
model_id = "HKUSTAudio/xcodec2-hf"
model = AutoModel.from_pretrained(model_id, device_map="auto")
feature_extractor = AutoFeatureExtractor.from_pretrained(model_id)

dataset = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
dataset = dataset.cast_column("audio", Audio(sampling_rate=feature_extractor.sampling_rate))
audios = [dataset[i]["audio"]["array"] for i in range(batch_size)]
inputs = feature_extractor(audio=audios, sampling_rate=feature_extractor.sampling_rate, return_tensors="pt").to(
    model.device, model.dtype
)
print("Input waveform shape:", inputs["input_values"].shape)
# Input waveform shape: torch.Size([2, 1, 93760])

# encoder and decoder
encoder_output = model.encode(**inputs)
audio_codes = encoder_output.audio_codes
print("Audio codes shape:", audio_codes.shape)
# Audio codes shape: torch.Size([2, 1, 293])
audio_values = model.decode(audio_codes).audio_values
print("Audio values shape:", audio_values.shape)
# Audio values shape: torch.Size([2, 1, 93760])

# Equivalently, you can do encoding and decoding in one step
model_output = model(**inputs)
audio_codes = model_output.audio_codes
audio_values = model_output.audio_values
```

### Ускорение с помощью `torch.compile`

Вы можете ускорить инференс с помощью [`torch.compile`](https://pytorch.org/docs/stable/generated/torch.compile.html). Первые несколько вызовов будут медленнее из-за накладных расходов на компиляцию, но последующие вызовы будут выполняться быстрее.

На A100 мы наблюдали ускорение примерно в 1,35 раза при размере батча 4 ([скрипт](https://gist.github.com/ebezzam/3b79481b5d48d8e35c4ecc582aee0cb3#file-benchmark_torch_compile-py)).

```python
import torch
from datasets import Audio, load_dataset
from transformers import AutoFeatureExtractor, AutoModel

batch_size = 4
model_id = "HKUSTAudio/xcodec2-hf"
model = AutoModel.from_pretrained(model_id, device_map="auto")
feature_extractor = AutoFeatureExtractor.from_pretrained(model_id)

dataset = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
dataset = dataset.cast_column("audio", Audio(sampling_rate=feature_extractor.sampling_rate))
audios = [dataset[i]["audio"]["array"] for i in range(batch_size)]
inputs = feature_extractor(
    audio=audios, sampling_rate=feature_extractor.sampling_rate, padding=True, return_tensors="pt"
).to(model.device, model.dtype)

compiled_model = torch.compile(model, fullgraph=True)

# Warmup (includes compilation on first call)
for _ in range(10):
    with torch.inference_mode():
        _ = compiled_model(**inputs)

with torch.inference_mode():
    output = compiled_model(**inputs)
print("Audio values shape:", output.audio_values.shape)
```

## Xcodec2Config[[transformers.Xcodec2Config]]

#### transformers.Xcodec2Config[[transformers.Xcodec2Config]]

```python
transformers.Xcodec2Config(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, hidden_size: int = 1024, intermediate_size: int = 4096, num_hidden_layers: int = 12, num_attention_heads: int = 16, num_key_value_heads: int = 16, hidden_act: str = 'silu', max_position_embeddings: int = 4096, initializer_range: float = 0.02, rms_norm_eps: float = 1e-06, pad_token_id: int | None = None, tie_word_embeddings: bool = False, rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = None, attention_bias: bool = False, attention_dropout: int | float | None = 0.0, head_dim: int = 64, encoder_hidden_size: int = 48, downsampling_ratios: list[int] | tuple[int, ...] = (2, 2, 4, 4, 5), semantic_model_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, sampling_rate: int = 16000, activation_dropout: float = 0.1, quantization_dim: int = 2048, quantization_levels: list[int] | tuple[int, ...] = (4, 4, 4, 4, 4, 4, 4, 4))
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/xcodec2/configuration_xcodec2.py#L33)

**Параметры:**

hidden_size (`int`, *необязательный*, по умолчанию `1024`) : Размерность скрытых представлений.

intermediate_size (`int`, *необязательный*, по умолчанию `4096`) : Размерность представлений MLP.

num_hidden_layers (`int`, *необязательный*, по умолчанию `12`) : Количество скрытых слоев в декодере Transformer.

num_attention_heads (`int`, *необязательный*, по умолчанию `16`) : Количество головок внимания для каждого слоя внимания в декодере Transformer.

num_key_value_heads (`int`, *optional*, по умолчанию `16`) : Это количество ключевых и value-голов, которое следует использовать для реализации Grouped Query Attention. Если `num_key_value_heads=num_attention_heads`, модель будет использовать Multi Head Attention (MHA), если `num_key_value_heads=1` — Multi Query Attention (MQA), в противном случае используется GQA. При конвертации multi-head checkpoint в GQA checkpoint каждая группа ключевых и value-голов должна быть построена путем усреднения (meanpooling) всех исходных голов в этой группе. Подробнее см. в [этой статье](https://huggingface.co/papers/2305.13245). Если значение не указано, по умолчанию используется `num_attention_heads`.

hidden_act (`str`, *необязательный*, по умолчанию `silu`) : Нелинейная функция активации (функция или строка) в декодере. Например, `"gelu"`, `"relu"`, `"silu"` и т. д.

max_position_embeddings (`int`, *необязательный*, по умолчанию `4096`) : Максимальная длина последовательности, с которой может использоваться данная модель.

initializer_range (`float`, *необязательный*, по умолчанию `0.02`) : Стандартное отклонение truncated_normal_initializer для инициализации всех матриц весов.

rms_norm_eps (`float`, *необязательный*, по умолчанию `1e-06`) : Значение epsilon, используемое слоями нормализации rms.

pad_token_id (`int`, *необязательный*) : Идентификатор токена, используемый для выравнивания в словаре.

tie_word_embeddings (`bool`, *необязательный*, по умолчанию `False`) : Связывать ли веса эмбеддингов согласно отображению `tied_weights_keys` модели.

rope_parameters (`Union[~modeling_rope_utils.RopeParameters, dict]`, *optional*) : Словарь, содержащий параметры конфигурации для вложений RoPE. Словарь должен содержать значение для `rope_theta` и, при необходимости, параметры, используемые для масштабирования, если вы хотите использовать RoPE с более длинными `max_position_embeddings`.

attention_bias (`bool`, *необязательный*, по умолчанию `False`) : Использовать ли смещение (bias) в слоях проекции запроса, ключа, значения и вывода при само-внимании.

attention_dropout (`Union[int, float]`, *необязательный*, по умолчанию `0.0`) : Доля dropout для вероятностей внимания.

head_dim (`int`, *необязательный*, по умолчанию `64`) : Размер измерения головы внимания. Если None, по умолчанию будет hidden_size // num_attention_heads

encoder_hidden_size (`int`, *optional*, по умолчанию `48`) : Размерность скрытых представлений.

downsampling_ratios (`list[int]`, *необязательный*, по умолчанию `[2, 2, 4, 4, 5]`) : Коэффициенты уменьшения разрешения в кодировщике.

semantic_model_config (`Union[Dict, Wav2Vec2BertConfig]`, *необязательный*) : экземпляр объекта конфигурации для семантической модели (Wav2Vec2BertConfig).

sampling_rate (`int`, *optional*, по умолчанию `16000`) : Частота дискретизации, с которой аудиофайлы должны быть оцифрованы, выраженная в герцах (Гц).

activation_dropout (`float`, *необязательный*, по умолчанию `0.1`) : Коэффициент dropout для активаций внутри полносвязного слоя.

quantization_dim (`int`, *optional*, по умолчанию 2048) : Размерность для кодовой книги векторного квантования.

quantization_levels (`list[int]`, *необязательный*, по умолчанию `[4, 4, 4, 4, 4, 4, 4, 4]`) : Уровни для кодовой книги векторного квантования.

Это класс конфигурации для хранения настроек модели Xcodec2Model. Он используется для создания модели Xcodec2 в соответствии с указанными аргументами, определяя архитектуру модели. Создание конфигурации с параметрами по умолчанию даст конфигурацию, аналогичную конфигурации [HKUSTAudio/xcodec2-hf](https://huggingface.co/HKUSTAudio/xcodec2-hf)

Объекты конфигурации наследуются от [PreTrainedConfig](/docs/transformers/main/ru/main_classes/configuration#transformers.PreTrainedConfig) и могут использоваться для управления выводами модели. Подробнее см. в документации [PreTrainedConfig](/docs/transformers/main/ru/main_classes/configuration#transformers.PreTrainedConfig).

Пример:

```python
>>> from transformers import Xcodec2Config, Xcodec2Model

>>> # Initializing configuration
>>> configuration = Xcodec2Config()

>>> # Initializing a model (with random weights) from the configuration
>>> model = Xcodec2Model(configuration)

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

## Xcodec2FeatureExtractor[[transformers.Xcodec2FeatureExtractor]]

#### transformers.Xcodec2FeatureExtractor[[transformers.Xcodec2FeatureExtractor]]

```python
transformers.Xcodec2FeatureExtractor(feature_size = 80, sampling_rate = 16000, padding_value = 1.0, hop_length = 320, **kwargs)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/xcodec2/feature_extraction_xcodec2.py#L37)

**Параметры:**

feature_size (`int`, *optional*, по умолчанию 80) : Размерность признаков извлекаемых фич.

sampling_rate (`int`, *optional*, по умолчанию 16000) : Частота дискретизации, с которой аудиофайлы должны быть оцифрованы, выраженная в герцах (Гц).

padding_value (`float`, *optional*, по умолчанию 1.0) : Значение, используемое для заполнения векторов отступов (padding) в мел-спектрограмме.

hop_length (`int`, *optional*, по умолчанию 320) : Количество аудиовыборок, кодируемых в каждом кадре. Эквивалентно произведению коэффициентов понижающей дискретизации. Необходимо для выравнивания входных данных акустического энкодера.

Создаёт экстрактор признаков Xcodec2, который вычисляет признаки банка мел-фильтров для семантического энкодера и дополненный аудио для акустического энкодера.

Этот экстрактор признаков наследуется от [SequenceFeatureExtractor](/docs/transformers/main/ru/main_classes/feature_extractor#transformers.SequenceFeatureExtractor), который содержит большинство основных методов. За дополнительной информацией о них следует обращаться к этому суперклассу.

#### __call__[[transformers.Xcodec2FeatureExtractor.__call__]]

```python
__call__(audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor']], padding: bool | str | transformers.utils.generic.PaddingStrategy = True, max_length: int | None = None, truncation: bool = False, return_tensors: str | transformers.utils.generic.TensorType | None = None, sampling_rate: int | None = None, device: str = 'cpu', **kwargs)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/xcodec2/feature_extraction_xcodec2.py#L85)

**Параметры:**

audio (`np.ndarray`, `torch.Tensor`, `list[np.ndarray]`, `list[torch.Tensor]`) : массив Numpy или тензор torch с формой (num_channels, sequence_length). Для батча входных данных также можно передать список таких массивов или тензоров.

padding (`bool`, `str` или [PaddingStrategy](/docs/transformers/main/ru/internal/file_utils#transformers.utils.PaddingStrategy), *необязательный*, по умолчанию `True`) : Выбор стратегии выравнивания возвращаемых последовательностей (с учётом стороны выравнивания и индекса padding модели) из следующих вариантов:  - `True` или `'longest'`: Выравнивание до самой длинной последовательности в батче (или без выравнивания, если предоставлена только одна последовательность). - `'max_length'`: Выравнивание до максимальной длины, указанной в аргументе `max_length`, или до максимально допустимой входной длины для модели, если этот аргумент не указан. - `False` или `'do_not_pad'` (по умолчанию): Без выравнивания (т. е. на выходе может быть батч с последовательностями разной длины).

max_length (`int`, *optional*) : Максимальная длина возвращаемого списка и, при необходимости, длина отступов (см. выше).

truncation (`bool`) : Включает усечение, чтобы обрезать входные последовательности длиннее *max_length* до *max_length*.

return_tensors (`str` или [TensorType](/docs/transformers/main/ru/internal/file_utils#transformers.TensorType), *необязательный*) : Если задано, возвращает тензоры вместо списка целых чисел Python. Допустимые значения:  - `'tf'`: Возвращает объекты `tf.constant` TensorFlow. - `'pt'`: Возвращает объекты `torch.Tensor` PyTorch. - `'np'`: Возвращает объекты `np.ndarray` Numpy.

sampling_rate (`int`, *optional*) : Частота дискретизации, с которой была оцифрована входная `audio`. Настоятельно рекомендуется передавать `sampling_rate` при вызове forward, чтобы избежать скрытых ошибок.

device (`str`, *необязательный*, по умолчанию `"cpu"`) : Устройство для тензоров PyTorch при извлечении признаков банка мел-фильтров.

kwargs (*необязательный*) : Оставшийся словарь аргументов по имени, который будет передан в токенизатор или извлекатель признаков.

## Xcodec2Model[[transformers.Xcodec2Model]]

#### transformers.Xcodec2Model[[transformers.Xcodec2Model]]

```python
transformers.Xcodec2Model(config: Xcodec2Config)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/xcodec2/modeling_xcodec2.py#L939)

**Параметры:**

config ([Xcodec2Config](/docs/transformers/main/ru/model_doc/xcodec2#transformers.Xcodec2Config)) : Класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели.

Модель нейронного аудиокодека Xcodec2.

Эта модель наследуется от [PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel). Общие методы, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка головок и т. д.), описаны в документации родительского класса.

Эта модель также является подклассом [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением.

#### decode[[transformers.Xcodec2Model.decode]]

```python
decode(audio_codes: typing.Optional[torch.Tensor] = None, latents: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/xcodec2/modeling_xcodec2.py#L1012)

**Параметры:**

audio_codes (`torch.LongTensor`  с формой `(batch_size, 1, codes_length)`) : Индексы дискретных кодов, вычисленные с помощью `model.encode`.

latents (`torch.Tensor` формы `(batch_size, dimension, time_steps)`, *необязательный*) : Квантованное непрерывное представление входных данных.

**Возвращает:** `Xcodec2DecoderOutput` или `tuple(torch.Tensor)`

`Xcodec2DecoderOutput` или кортеж из `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации (`None`) и входных данных.

- **audio_values** (`torch.Tensor` формы `(batch_size, 1, segment_length)`, *необязательный*) -- Значения декодированной аудиоволны во временной области, полученные путём преобразования дискретных кодов обратно в непрерывные аудиосигналы. Это представляет собой реконструированный звук, который можно воспроизвести.

#### encode[[transformers.Xcodec2Model.encode]]

```python
encode(input_values: Tensor, input_features: Tensor, padding_mask: typing.Optional[torch.Tensor] = None, input_features_mask: typing.Optional[torch.Tensor] = None, output_latents: bool = False, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/xcodec2/modeling_xcodec2.py#L958)

**Параметры:**

input_values (`torch.Tensor` формы `(batch_size, 1, sequence_length)`) : Входная аудиоволна.

input_features (`torch.Tensor` формы `(batch_size, mel_bins, time_steps)`) : Входная аудио-мел-спектрограмма для семантического кодирования.

padding_mask (`torch.Tensor` формы `(batch_size, 1, sequence_length)`) : Маска отступов, используемая для дополнения `input_values`.

input_features_mask (`torch.Tensor` формы `(batch_size, time_steps)`, *необязательный*) : Маска внимания для входных спектрограмм семантического кодировщика. `1` для валидных кадров, `0` для отступов.

output_latents (`bool`, *необязательный*, по умолчанию `False`) : Нужно ли возвращать непрерывное латентное представление из квантизатора.

**Возвращает:** `Xcodec2EncoderOutput` или `tuple(torch.Tensor)`

`Xcodec2EncoderOutput` или кортеж `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации (`None`) и входных данных.

- **audio_codes** (`torch.LongTensor` формы `(batch_size, 1, codes_length)`, *необязательный*) -- Вложения дискретных кодов, вычисленные с помощью `model.encode`. Они представляют собой сжатую, квантованную форму входного аудиосигнала, которую можно использовать для хранения, передачи или генерации.
- **latents** (`torch.Tensor` формы `(batch_size, dimension, time_steps)`) -- Квантованное непрерывное представление эмбеддинга входных данных.
- **audio_codes_mask** (`torch.int32` формы `(batch_size, 1, codes_length)`, *необязательный*) -- Уменьшенная по размеру `padding_mask` для указания валидных аудиокодов в `audio_codes`.

#### forward[[transformers.Xcodec2Model.forward]]

```python
forward(input_values: Tensor, input_features: Tensor, padding_mask: typing.Optional[torch.Tensor] = None, input_features_mask: typing.Optional[torch.Tensor] = None, output_latents: bool = False, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/models/xcodec2/modeling_xcodec2.py#L1037)

**Параметры:**

input_values (`torch.Tensor` формы `(batch_size, 1, sequence_length)`) : Входная аудиоволна.

input_features (`torch.Tensor` формы `(batch_size, mel_bins, time_steps)`) : Входная аудио-мел-спектрограмма для семантического кодирования.

padding_mask (`torch.Tensor` формы `(batch_size, 1, sequence_length)`) : Маска отступов, используемая для дополнения `input_values`.

input_features_mask (`torch.Tensor` формы `(batch_size, time_steps)`, *необязательный*) : Маска внимания для входных спектрограмм семантического кодировщика. `1` для валидных кадров, `0` для отступов.

output_latents (`bool`, *необязательный*, по умолчанию `False`) : Нужно ли возвращать непрерывное латентное представление из квантизатора.

**Возвращает:** `Xcodec2Output` или `tuple(torch.Tensor)`

`Xcodec2Output` или кортеж `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации (`None`) и входных данных.

Метод forward модели [Xcodec2Model](/docs/transformers/main/ru/model_doc/xcodec2#transformers.Xcodec2Model) переопределяет специальный метод `__call__`.

Хотя рецепт для прямого прохода должен быть определён внутри этой функции, после этого следует вызывать экземпляр `Module`, а не эту функцию, поскольку первый выполняет шаги предварительной и постобработки, тогда как второй молча их игнорирует.

- **audio_values** (`torch.Tensor` формы `(batch_size, 1, sequence_length)`, *необязательный*) -- Значения декодированной аудиоволны во временной области, полученные с помощью декодерной части Xcodec2. Эти значения представляют собой восстановленный аудиосигнал.
- **audio_codes** (`torch.LongTensor` формы `(batch_size, 1, codes_length)`, *необязательный*) -- Вложения дискретных кодов, вычисленные с помощью `model.encode`. Это квантованные представления входного аудио, используемые для дальнейшей обработки или генерации.
- **latents** (`torch.Tensor` формы `(batch_size, dimension, time_steps)`) -- Квантованное непрерывное представление эмбеддинга входных данных.
- **audio_codes_mask** (`torch.int32` формы `(batch_size, 1, codes_length)`, *необязательный*) -- Уменьшенная по размеру `padding_mask` для указания валидных аудиокодов в `audio_codes`.

Примеры:

```python
>>> from datasets import load_dataset
>>> from transformers import AutoFeatureExtractor, Xcodec2Model

>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> audio = dataset["train"]["audio"][0]["array"]

>>> model_id = "HKUSTAudio/xcodec2-hf"
>>> model = Xcodec2Model.from_pretrained(model_id)
>>> feature_extractor = AutoFeatureExtractor.from_pretrained(model_id)

>>> inputs = feature_extractor(audio=audio, sampling_rate=feature_extractor.sampling_rate, return_tensors="pt")

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