# NeuCodec

## Обзор

Модель NeuCodec была предложена в работе [Finite Scalar Quantization Enables Redundant and Transmission-Robust Neural Audio Compression at Low Bit-rates](https://huggingface.co/papers/2509.09550).

NeuCodec — это нейронный аудиокодек, расширяющий возможности XCodec2. Он использует следующие возможности:

- Квантование конечных скаляров (FSQ), приводящее к **одной книге кодов**, что делает его идеальным для дальнейшего моделирования с помощью речевых языковых моделей.
- Обучен на данных CC, поэтому **не содержит ограничений, связанных с некоммерческим использованием**.
- При скорости 50 токенов/с и 16 битах на токен общая скорость передачи составляет **0.8 кбит/с**.
- Кодировщик принимает входной сигнал частотой 16 кГц и выдает сигнал частотой **24 кГц** с помощью **декодера с повышением частоты дискретизации**.
- Схема кодирования FSQ обеспечивает устойчивость к ошибкам на уровне битов, что делает её пригодной для работы в ненадёжных и зашумлённых каналах.

Исходный код моделирования можно найти [здесь](https://github.com/neuphonic/neucodec).

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

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

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

model_id = "neuphonic/neucodec"
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, 292])
audio_values = model.decode(audio_codes).audio_values
print("Audio values shape:", audio_values.shape)

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

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

Эта реализация также поддерживает пакетный ввод!

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

batch_size = 2
model_id = "neuphonic/neucodec"
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, 292])
audio_values = model.decode(audio_codes).audio_values
print("Audio values shape:", audio_values.shape)

# 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). Первые несколько вызовов будут медленнее из-за накладных расходов на компиляцию, но последующие вызовы будут выполняться быстрее.

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

batch_size = 4
model_id = "neuphonic/neucodec"
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)
```

## NeuCodecConfig[[transformers.NeuCodecConfig]]

#### transformers.NeuCodecConfig[[transformers.NeuCodecConfig]]

```python
transformers.NeuCodecConfig(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, activation_dropout: float = 0.1, quantization_dim: int = 2048, quantization_levels: list[int] | tuple[int, ...] = (4, 4, 4, 4, 4, 4, 4, 4), input_sampling_rate: int = 16000, output_sampling_rate: int = 24000)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/neucodec/configuration_neucodec.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).

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

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

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

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

output_sampling_rate (`int`, *optional*, по умолчанию 24000) : Частота дискретизации (в герцах) выходной аудиоволны декодера.

Это класс конфигурации для хранения настроек модели NeuCodecModel. Он используется для создания модели Neucodec в соответствии с указанными аргументами, определяя архитектуру модели. Создание конфигурации с параметрами по умолчанию даст конфигурацию, аналогичную конфигурации [neuphonic/neucodec](https://huggingface.co/neuphonic/neucodec)

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

Пример:

```python
>>> from transformers import NeuCodecConfig, NeuCodecModel

>>> # Initializing configuration
>>> configuration = NeuCodecConfig()

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

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

## NeuCodecFeatureExtractor[[transformers.NeuCodecFeatureExtractor]]

#### transformers.NeuCodecFeatureExtractor[[transformers.NeuCodecFeatureExtractor]]

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/neucodec/feature_extraction_neucodec.py#L42)

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

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

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

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

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

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

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

#### __call__[[transformers.NeuCodecFeatureExtractor.__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/v5.23.0/src/transformers/models/neucodec/feature_extraction_neucodec.py#L90)

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

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

padding (`bool`, `str` или [PaddingStrategy](/docs/transformers/v5.23.0/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/v5.23.0/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 (*необязательный*) : Оставшийся словарь аргументов по имени, который будет передан в токенизатор или извлекатель признаков.

## NeuCodecModel[[transformers.NeuCodecModel]]

#### transformers.NeuCodecModel[[transformers.NeuCodecModel]]

```python
transformers.NeuCodecModel(config: NeuCodecConfig)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/neucodec/modeling_neucodec.py#L944)

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

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

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

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

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

#### decode[[transformers.NeuCodecModel.decode]]

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

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/neucodec/modeling_neucodec.py#L1028)

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

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

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

audio_codes_mask (`torch.Tensor` формы `(batch_size, codes_length)`, *необязательный*) : Маска, отмечающая валидные (не заполняющие) позиции, как возвращаемая `model.encode`. Необходима для корректного пакетного декодирования аудио переменной длины.

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

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

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

#### encode[[transformers.NeuCodecModel.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/v5.23.0/src/transformers/models/neucodec/modeling_neucodec.py#L966)

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

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`) : Нужно ли возвращать непрерывное латентное представление из квантизатора.

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

`NeuCodecEncoderOutput` или кортеж `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.NeuCodecModel.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/v5.23.0/src/transformers/models/neucodec/modeling_neucodec.py#L1064)

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

input_values (`torch.Tensor` формы `(batch_size, 1, sequence_length)`) : Входная аудиоволна, сэмплированная с частотой `config.input_sampling_rate`.

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`) : Нужно ли возвращать непрерывное латентное представление из квантизатора.

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

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

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

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

- **audio_values** (`torch.Tensor` формы `(batch_size, 1, sequence_length)`, *необязательный*) -- Значения декодированной аудиоволны во временной области, полученные с помощью декодерной части NeuCodec. Эти значения представляют собой восстановленный аудиосигнал.
- **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, NeuCodecModel

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

>>> model_id = "neuphonic/neucodec"
>>> model = NeuCodecModel.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  # sampled at 24kHz
```

