# 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）により、Speech Language Models による下流モデリングに最適です。
- Non-Commercial なデータ制限が**ない**よう、CC データで学習されています。
- 1秒あたり50トークン、1トークンあたり16ビットの場合、全体のビットレートは**0.8kbps**になります。
- このコーデックは16kHzの入力を取得し、**アップサンプリングデコーダー**を使用して**24kHz**を出力します。
- 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/main/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`, *任意*, デフォルトは `16`) : Grouped Query Attention を実装するために使用する key_value ヘッドの数です。`num_key_value_heads=num_attention_heads` の場合、モデルは Multi Head Attention (MHA) を使用し、`num_key_value_heads=1` の場合は Multi Query Attention (MQA) を使用し、それ以外の場合は GQA が使用されます。マルチヘッドのチェックポイントを GQA のチェックポイントに変換する際は、各グループの key ヘッドと value ヘッドは、そのグループ内の元のすべてのヘッドを平均プーリングして構築する必要があります。詳細については、[この論文](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`) : rms 正規化レイヤーで使用する epsilon。

pad_token_id (`int`, *任意*) : 語彙内でパディングに使用されるトークンID。

tie_word_embeddings (`bool`, *任意*, デフォルトは `False`) : モデルの `tied_weights_keys` マッピングに従って重み埋め込みを共有するかどうか。

rope_parameters (`Union[~modeling_rope_utils.RopeParameters, dict]`, *optional*) : RoPE 埋め込みの設定パラメータを含む辞書です。この辞書には `rope_theta` の値が含まれていなければならず、より長い `max_position_embeddings` で RoPE を使用する場合、スケーリングに使用されるパラメータが任意で含まれます。

attention_bias (`bool`、*任意*、デフォルトは`False`) : セルフアテンションにおけるクエリ、キー、バリュー、出力の投影層でバイアスを使用するかどうか。

attention_dropout (`Union[int, float]`、*任意*、デフォルトは`0.0`) : 注意確率のドロップアウト率。

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`, *optional*, デフォルトは `0.1`) : 全結合層内の活性化に対する dropout 率です。

quantization_dim (`int`, *optional*, デフォルトは 2048) : ベクトル量子化コードブックの次元。

quantization_levels (`list[int]`、*optional*、デフォルトは`[4, 4, 4, 4, 4, 4, 4, 4]`) : ベクトル量子化コードブックのレベル。

input_sampling_rate (`int`、*optional*、デフォルトは 16000) : エンコーダーの入力音声波形のサンプリングレート (Hz)。

output_sampling_rate (`int`, *optional*, デフォルトは 24000) : デコーダーの出力音声波形のサンプリングレート (Hz)。

これはNeuCodecModelの設定を保存するための設定クラスです。指定された引数に基づいてNeucodecモデルをインスタンス化し、モデルのアーキテクチャを定義するために使用されます。デフォルト値で設定をインスタンス化すると、[neuphonic/neucodec](https://huggingface.co/neuphonic/neucodec)と類似した設定が得られます。

設定オブジェクトは [PreTrainedConfig](/docs/transformers/main/ja/main_classes/configuration#transformers.PreTrainedConfig) を継承し、モデルの出力を制御するために使用できます。詳細については、[PreTrainedConfig](/docs/transformers/main/ja/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/main/src/transformers/models/neucodec/feature_extraction_neucodec.py#L42)

**パラメータ:**

feature_size (`int`、*任意*、デフォルトは 80) : 抽出された特徴量の次元数。

sampling_rate (`int`, *optional*, デフォルトは 16000) : オーディオファイルをデジタル化するためのサンプリングレート (Hz) です。

padding_value (`float`、*optional*、デフォルト値は 1.0) : メルスペクトログラムのパディングベクトルに埋められる値です。

hop_length (`int`、*optional*、デフォルトは 320) : フレームごとにエンコードされるオーディオサンプルの数。ダウンサンプリング比の積に相当します。音響エンコーダーの入力パディングに必要です。

NeuCodecのフィーチャーエクストラクターを構築します。このエクストラクターは、セマンティックエンコーダー用のメルフィルタバンク特徴量と、アコースティックエンコーダー用のパディング済みオーディオを計算します。

このフィーチャーエクストラクターは、主要なメソッドの大部分を含む [SequenceFeatureExtractor](/docs/transformers/main/ja/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/main/src/transformers/models/neucodec/feature_extraction_neucodec.py#L90)

**パラメータ:**

audio (`np.ndarray`、`torch.Tensor`、`list[np.ndarray]`、`list[torch.Tensor]`) : 形状が (num_channels, sequence_length) の Numpy 配列または torch テンソル。入力バッチに対して、これらの配列またはテンソルのリストを指定することもできます。

padding (`bool`、`str`または[PaddingStrategy](/docs/transformers/main/ja/internal/file_utils#transformers.utils.PaddingStrategy)、*省略可能*、デフォルトは`True`) : 返されるシーケンスのパディング戦略を選択します（モデルのパディング側とパディングインデックスに従います）。選択肢は以下の通りです。 - `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/ja/internal/file_utils#transformers.TensorType)、*optional*) : 設定されている場合、Python の整数のリストではなくテンソルを返します。指定可能な値は以下の通りです:  - `'tf'`: TensorFlow の `tf.constant` オブジェクトを返します。 - `'pt'`: PyTorch の `torch.Tensor` オブジェクトを返します。 - `'np'`: Numpy の `np.ndarray` オブジェクトを返します。

sampling_rate (`int`, *optional*) : `audio`入力がサンプリングされた際のサンプルレートです。サイレントエラーを防ぐため、フォワード呼び出し時に`sampling_rate`を渡すことを強く推奨します。

device (`str`、*任意*、デフォルトは`"cpu"`) : メルフィルタバンク特徴量抽出時のPyTorchテンソルに使用するデバイス。

kwargs (*任意*) : トークナイザーまたは特徴抽出器に渡される残りのキーワード引数の辞書。

## NeuCodecModel[[transformers.NeuCodecModel]]

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

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

[ソース](https://github.com/huggingface/transformers/blob/main/src/transformers/models/neucodec/modeling_neucodec.py#L944)

**パラメータ:**

config ([NeuCodecConfig](/docs/transformers/main/ja/model_doc/neucodec#transformers.NeuCodecConfig)) : モデルのパラメータをすべて含むモデル設定クラスです。設定ファイルで初期化しても、モデルに関連する重みは読み込まれず、設定のみが読み込まれます。モデルの重みをロードするには、[from_pretrained()](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel.from_pretrained) メソッドを確認してください。

NeuCodec ニューラルオーディオコーデックモデル。

このモデルは [PreTrainedModel](/docs/transformers/main/ja/main_classes/model#transformers.PreTrainedModel) を継承しています。ライブラリがすべてのモデルに対して実装している汎用的なメソッド（ダウンロードや保存、入力埋め込みのリサイズ、ヘッドのプルーニングなど）については、スーパークラスのドキュメントを参照してください。

このモデルは、PyTorchの[torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module)のサブクラスでもあります。通常のPyTorch Moduleとして使用し、一般的な使用方法や動作に関する詳細については、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/main/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/main/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`、shape `(batch_size, 1, codes_length)`、*任意*) -- `audio_codes` 内の有効なオーディオコードを示すために、`padding_mask` をダウンサンプリングしたものです。

#### 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/main/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/main/ja/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`、shape `(batch_size, 1, codes_length)`、*任意*) -- `audio_codes` 内の有効なオーディオコードを示すために、`padding_mask` をダウンサンプリングしたものです。

例:

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