# Tokenizer Higgs Audio V2

## Visão geral

- Taxa de quadros baixa: a 25 fps, nosso tokenizer reduz pela metade a taxa de quadros de muitas baselines, mantendo ao mesmo tempo uma alta qualidade de áudio.
- Treinamento unificado a 24 kHz: misturamos clipes de fala, música e eventos sonoros em um único modelo, capturando detalhes semânticos e acústicos, o que facilita enormemente o treinamento de modelos de linguagem de áudio.
- Inferência rápida: Ao evitar etapas de difusão, nosso codificador/decodificador processa lotes rapidamente, tornando-o prático para tarefas em tempo real ou em larga escala.

**Arquitetura do modelo:**

    

## Uso

```python
from datasets import Audio, load_dataset

from transformers import AutoFeatureExtractor, HiggsAudioV2TokenizerModel

# load model and feature extractor
model_id = "eustlb/higgs-audio-v2-tokenizer"
feature_extractor = AutoFeatureExtractor.from_pretrained(model_id)
model = HiggsAudioV2TokenizerModel.from_pretrained(model_id, device_map="auto")

# load audio sample
dummy_dataset = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
dummy_dataset = dummy_dataset.cast_column("audio", Audio(sampling_rate=feature_extractor.sampling_rate))
audio_sample = dummy_dataset[-1]["audio"]["array"]
inputs = feature_extractor(raw_audio=audio_sample, sampling_rate=feature_extractor.sampling_rate, return_tensors="pt").to(model.device)

# encode and decode
encoder_outputs = model.encode(inputs["input_values"])
decoder_outputs = model.decode(encoder_outputs.audio_codes)
audio_values = decoder_outputs.audio_values

# or the equivalent with a forward pass
audio_values = model(inputs["input_values"]).audio_values
```

## HiggsAudioV2TokenizerConfig[[transformers.HiggsAudioV2TokenizerConfig]]

#### transformers.HiggsAudioV2TokenizerConfig[[transformers.HiggsAudioV2TokenizerConfig]]

```python
transformers.HiggsAudioV2TokenizerConfig(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[int | float] | tuple[int | float, ...] = (0.5, 1, 1.5, 2, 4), sample_rate: int = 24000, kernel_size: int = 3, channel_ratios: list[int] | tuple[int, ...] = (1, 1), strides: list[int] | tuple[int, ...] = (1, 1), block_dilations: list[int] | tuple[int, ...] = (1, 1), unit_kernel_size: int = 3, codebook_size: int = 1024, codebook_dim: int = 64, initializer_range: float = 0.02, acoustic_model_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, semantic_model_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, semantic_sample_rate: int = 16000, downsample_factor: int = 320)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/higgs_audio_v2_tokenizer/configuration_higgs_audio_v2_tokenizer.py#L34)

**Parâmetros:**

target_bandwidths (`List[float]`, *opcional*, padrão `[0.5, 1, 1.5, 2]`) : A faixa de diferentes larguras de banda (em kbps) com as quais o modelo pode codificar áudio.

sample_rate (`int`, *opcional*, padrão `24000`) : A taxa de amostragem na qual os arquivos de áudio devem ser digitalizados, expressa em hertz (Hz).

kernel_size (`int`, *opcional*, padrão 3) : Tamanho do kernel para a convolução semântica inicial.

channel_ratios (`List[float]`, *opcional*, padrão `[1, 1]`) : Fatores de expansão para o número de canais de saída em cada bloco semântico.

strides (`List[int]`, *opcional*, padrão `[1, 1]`) : Passos para cada bloco do codificador semântico.

block_dilations (`List[int]`, *opcional*, padrão `[1, 1]`) : Fatores de dilatação para as unidades residuais nos blocos semânticos.

unit_kernel_size (`int`, *opcional*, padrão 3) : Tamanho do kernel dentro de cada ResidualUnit nos blocos semânticos.

codebook_size (`int`, *opcional*, padrão `1024`) : O número de codebooks paralelos usados pelo modelo.

codebook_dim (`int`, *opcional*, padrão `64`) : Dimensionalidade de cada vetor de incorporação do codebook.

initializer_range (`float`, *opcional*, padrão `0.02`) : O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos.

acoustic_model_config (`Union[Dict, AutoConfig]`, *opcional*) : Uma instância da configuração para o modelo acústico (DAC).

semantic_model_config (`Union[Dict, AutoConfig]`, *opcional*) : Uma instância do objeto de configuração para o modelo semântico (HuBERT).

semantic_sample_rate (`int`, *opcional*, padrão 16000) : A taxa de amostragem na qual o modelo semântico espera a entrada de áudio, em hertz (Hz).

downsample_factor (`int`, *opcional*, padrão 320) : Fator de downsampling para os recursos semânticos.

Esta é a classe de configuração para armazenar a configuração de um HiggsAudioV2TokenizerModel. Ela é usada para instanciar um modelo Higgs Audio V2 Tokenizer de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do [bosonai/higgs-audio-v2-tokenizer](https://huggingface.co/bosonai/higgs-audio-v2-tokenizer)

Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações.

Exemplo:

```python
>>> from transformers import HiggsAudioV2TokenizerModel, HiggsAudioV2TokenizerConfig

>>> # Initializing configuration
>>> configuration = HiggsAudioV2TokenizerConfig()

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

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

## HiggsAudioV2TokenizerModel[[transformers.HiggsAudioV2TokenizerModel]]

#### transformers.HiggsAudioV2TokenizerModel[[transformers.HiggsAudioV2TokenizerModel]]

```python
transformers.HiggsAudioV2TokenizerModel(config: HiggsAudioV2TokenizerConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/higgs_audio_v2_tokenizer/modeling_higgs_audio_v2_tokenizer.py#L456)

**Parâmetros:**

config ([HiggsAudioV2TokenizerConfig](/docs/transformers/main/pt/model_doc/higgs_audio_v2_tokenizer#transformers.HiggsAudioV2TokenizerConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo.

O modelo de codec neural de áudio HiggsAudioV2Tokenizer.

Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.).

Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais.

#### decode[[transformers.HiggsAudioV2TokenizerModel.decode]]

```python
decode(audio_codes: Tensor, return_dict: bool | None = None)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/higgs_audio_v2_tokenizer/modeling_higgs_audio_v2_tokenizer.py#L564)

**Parâmetros:**

audio_codes (`torch.LongTensor` de forma `(batch_size, num_quantizers, codes_length)`) : Índices de códigos discretos calculados usando `model.encode`.

return_dict (`bool`, *opcional*) : Se deve ou não retornar um [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput)

**Retorna:**

Valores de áudio decodificados com forma `(batch_size, channels, num_samples)` obtidos usando a parte decodificadora do HiggsAudioV2Tokenizer.

#### encode[[transformers.HiggsAudioV2TokenizerModel.encode]]

```python
encode(input_values: Tensor, bandwidth: float | None = None, return_dict: bool | None = None)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/higgs_audio_v2_tokenizer/modeling_higgs_audio_v2_tokenizer.py#L512)

**Parâmetros:**

input_values (`torch.Tensor` de forma `(batch_size, channels, num_samples)`) : Valores em ponto flutuante da forma de onda de áudio de entrada.

bandwidth (`float`, *opcional*) : A largura de banda alvo em (kbps) suporta apenas valores em `config.target_bandwidths`. O padrão é a maior largura de banda disponível, `4.0` kbps.

return_dict (`bool`, *opcional*) : Indica se deve ou não retornar um [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput).

**Retorna:**

`torch.LongTensor` de forma `(batch_size, num_quantizers, codes_length)` contendo os códigos de áudio discretos codificados.

#### forward[[transformers.HiggsAudioV2TokenizerModel.forward]]

```python
forward(input_values: Tensor, audio_codes: typing.Optional[torch.Tensor] = None, bandwidth: float | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/higgs_audio_v2_tokenizer/modeling_higgs_audio_v2_tokenizer.py#L592)

**Parâmetros:**

input_values (`torch.Tensor` de forma `(batch_size, channels, num_samples)`) : Os valores flutuantes brutos da forma de onda de áudio de entrada.

audio_codes (`torch.LongTensor` de forma `(batch_size, num_quantizers, codes_length)` : Índices de códigos discretos calculados usando `model.encode`.

bandwidth (`float`, *opcional*) : Largura de banda alvo em kbps. Deve ser um dos valores de `config.target_bandwidths`. O padrão é a maior largura de banda disponível.

bandwidth (`float`, *opcional*) : Largura de banda alvo em kbps. Deve ser um dos valores de `config.target_bandwidths`. O padrão é a maior largura de banda disponível.

**Retorna:** `HiggsAudioV2TokenizerOutput` ou tupla `(audio_codes, audio_values)`

- `audio_codes` de forma `(batch_size, num_quantizers, codes_length)`: os códigos discretos quantizados.
- `audio_values` com formato `(batch_size, channels, num_samples)`: a forma de onda de áudio reconstruída a partir dos códigos.

O método forward do [HiggsAudioV2TokenizerModel](/docs/transformers/main/pt/model_doc/higgs_audio_v2_tokenizer#transformers.HiggsAudioV2TokenizerModel) substitui o método especial `__call__`.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

Exemplo:

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

>>> model_id = "hf-audio/higgs_audio_v2_tokenizer-hubert-librispeech"
>>> model = HiggsAudioV2TokenizerModel.from_pretrained(model_id)
>>> 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_sample = dataset[0]['audio']['array']

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

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