# Bark

## Visão geral

[Bark](https://huggingface.co/suno/bark) é um modelo de texto para fala baseado em transformers proposto pela Suno AI em [suno-ai/bark](https://github.com/suno-ai/bark).

Bark é composto por 4 modelos principais:

- [BarkSemanticModel](/docs/transformers/main/pt/model_doc/bark#transformers.BarkSemanticModel) (também chamado de modelo de 'texto'): um modelo transformer causal auto-regressivo que recebe como entrada texto tokenizado e prevê tokens semânticos de texto que capturam o significado do texto.
- [BarkCoarseModel](/docs/transformers/main/pt/model_doc/bark#transformers.BarkCoarseModel) (também chamado de modelo de "acústica grosseira"): um transformer autoregressivo causal que recebe como entrada os resultados do modelo [BarkSemanticModel](/docs/transformers/main/pt/model_doc/bark#transformers.BarkSemanticModel). Ele tem como objetivo prever os dois primeiros codebooks de áudio necessários para o EnCodec.
- [BarkFineModel](/docs/transformers/main/pt/model_doc/bark#transformers.BarkFineModel) (o modelo de “acústica fina”), desta vez um transformer autoencoder não causal, que prevê iterativamente os últimos codebooks com base na soma dos embeddings dos codebooks anteriores.
- Depois de prever todos os canais do codebook a partir do [EncodecModel](/docs/transformers/main/pt/model_doc/encodec#transformers.EncodecModel), o Bark o utiliza para decodificar o array de áudio de saída.

Deve-se observar que cada um dos três primeiros módulos pode suportar incorporações condicionais de falante para condicionar o som de saída de acordo com uma voz específica predefinida.

Este modelo foi contribuído por [Yoach Lacombe (ylacombe)](https://huggingface.co/ylacombe) e [Sanchit Gandhi (sanchit-gandhi)](https://github.com/sanchit-gandhi). O código original pode ser encontrado [aqui](https://github.com/suno-ai/bark).

### Otimizando o Bark

O Bark pode ser otimizado com apenas algumas linhas extras de código, o que **reduz significativamente sua pegada de memória** e **acelera a inferência**.

#### Usando meia precisão

Você pode acelerar a inferência e reduzir a pegada de memória em 50% simplesmente carregando o modelo em meia precisão.

```python
from transformers import BarkModel

model = BarkModel.from_pretrained("suno/bark-small", device_map="auto")
```

#### Usando offload de CPU

Conforme mencionado acima, o Bark é composto por 4 submodelos, que são chamados sequencialmente durante a geração de áudio. Em outras palavras, enquanto um submodelo está em uso, os outros submodelos ficam ociosos.

Se você estiver usando uma GPU CUDA ou uma XPU da Intel, uma solução simples para aproveitar uma redução de 80% no uso de memória é descarregar os submodelos do dispositivo para a CPU quando eles estiverem ociosos. Essa operação é chamada de *descarregamento para a CPU*. Você pode usá-la com uma única linha de código, conforme mostrado a seguir:

```python
model.enable_cpu_offload()
```

Observe que o 🤗 Accelerate deve ser instalado antes de usar esse recurso. [Veja como instalá-lo.](https://huggingface.co/docs/accelerate/basic_tutorials/install)

#### Usando Flash Attention 2

Flash Attention 2 é uma versão ainda mais rápida e otimizada da otimização anterior.

##### Instalação

Primeiro, verifique se o seu hardware é compatível com o Flash Attention 2. A lista mais recente de hardware compatível pode ser encontrada na [documentação oficial](https://github.com/Dao-AILab/flash-attention#installation-and-features). Em seguida, [instale](https://github.com/Dao-AILab/flash-attention#installation-and-features) a versão mais recente do Flash Attention 2:

```bash
pip install -U flash-attn --no-build-isolation
```

##### Uso

Para carregar um modelo usando Flash Attention 2, podemos passar a flag `attn_implementation="flash_attention_2"` para [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained). Também carregaremos o modelo em meia precisão (por exemplo, `torch.float16`), pois isso resulta em quase nenhuma degradação na qualidade do áudio, mas com uso de memória significativamente menor e inferência mais rápida:

```python
model = BarkModel.from_pretrained("suno/bark-small", attn_implementation="flash_attention_2", device_map="auto")
```

##### Comparação de desempenho

O diagrama a seguir mostra a latência da implementação nativa de atenção (sem otimização) em comparação com o Flash Attention 2. Em todos os casos, geramos 400 tokens semânticos em uma GPU A100 de 40GB com PyTorch 2.1:

Para contextualizar, em uma NVIDIA A100 e ao gerar 400 tokens semânticos com um batch size de 16, é possível obter 17 vezes o [throughput](https://huggingface.co/blog/optimizing-bark#throughput) e ainda ser 2 segundos mais rápido do que gerar frases uma a uma com a implementação nativa do modelo. Em outras palavras, todas as amostras serão geradas 17 vezes mais rápido.

#### Combinando técnicas de otimização

Você pode combinar técnicas de otimização e usar offload de CPU, meia precisão e Flash Attention 2 todos ao mesmo tempo.

```python
from transformers import BarkModel

# load in fp16 and use Flash Attention 2
model = BarkModel.from_pretrained("suno/bark-small", attn_implementation="flash_attention_2", device_map="auto")

# enable CPU offload
model.enable_cpu_offload()
```

Saiba mais sobre técnicas de otimização de inferência [aqui](https://huggingface.co/docs/transformers/perf_infer_gpu_one).

### Dicas de uso

A Suno oferece uma biblioteca de presets de voz em diversos idiomas [aqui](https://suno-ai.notion.site/8b8e8749ed514b0cbf3f699013548683?v=bc67cff786b04b50b3ceb756fd05f68c). Esses presets também estão disponíveis no hub [aqui](https://huggingface.co/suno/bark-small/tree/main/speaker_embeddings) ou [aqui](https://huggingface.co/suno/bark/tree/main/speaker_embeddings).

```python
from transformers import AutoProcessor, BarkModel

processor = AutoProcessor.from_pretrained("suno/bark")
model = BarkModel.from_pretrained("suno/bark", device_map="auto")

voice_preset = "v2/en_speaker_6"

inputs = processor("Hello, my dog is cute", voice_preset=voice_preset)

audio_array = model.generate(**inputs)
audio_array = audio_array.cpu().numpy().squeeze()
```

O Bark pode gerar fala **multilíngue** altamente realista, bem como outros tipos de áudio, incluindo música, ruído de fundo e efeitos sonoros simples.

```python
# Multilingual speech - simplified Chinese
inputs = processor("惊人的！我会说中文")

# Multilingual speech - French - let's use a voice_preset as well
inputs = processor("Incroyable! Je peux générer du son.", voice_preset="fr_speaker_5")

# Bark can also generate music. You can help it out by adding music notes around your lyrics.
inputs = processor("♪ Hello, my dog is cute ♪")

audio_array = model.generate(**inputs)
audio_array = audio_array.cpu().numpy().squeeze()
```

O modelo também pode produzir **comunicações não verbais**, como risos, suspiros e choro.

```python
# Adding non-speech cues to the input text
inputs = processor("Hello uh [clears throat], my dog is cute [laughter]")

audio_array = model.generate(**inputs)
audio_array = audio_array.cpu().numpy().squeeze()
```

Para salvar o áudio, basta obter a taxa de amostragem da configuração do modelo e usar uma utilidade do scipy:

```python
from scipy.io.wavfile import write as write_wav

# save audio to disk, but first take the sample rate from the model config
sample_rate = model.generation_config.sample_rate
write_wav("bark_generation.wav", sample_rate, audio_array)
```

## BarkConfig[[transformers.BarkConfig]]

#### transformers.BarkConfig[[transformers.BarkConfig]]

```python
transformers.BarkConfig(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, semantic_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, coarse_acoustics_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, fine_acoustics_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, codec_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, initializer_range: float = 0.02)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/bark/configuration_bark.py#L188)

**Parâmetros:**

semantic_config ([BarkSemanticConfig](/docs/transformers/main/pt/model_doc/bark#transformers.BarkSemanticConfig), *opcional*) : Configuração do submodelo semântico subjacente.

coarse_acoustics_config ([BarkCoarseConfig](/docs/transformers/main/pt/model_doc/bark#transformers.BarkCoarseConfig), *opcional*) : Configuração do submodelo de acústica grossa subjacente.

fine_acoustics_config ([BarkFineConfig](/docs/transformers/main/pt/model_doc/bark#transformers.BarkFineConfig), *opcional*) : Configuração do submodelo de acústica fina subjacente.

codec_config ([AutoConfig](/docs/transformers/main/pt/model_doc/auto#transformers.AutoConfig), *opcional*) : Configuração do submodelo de codec subjacente.

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

Esta é a classe de configuração para armazenar a configuração de um BarkModel. Ela é usada para instanciar um modelo Bark 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 [suno/bark](https://huggingface.co/suno/bark)

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 (
...     BarkSemanticConfig,
...     BarkCoarseConfig,
...     BarkFineConfig,
...     BarkModel,
...     BarkConfig,
...     AutoConfig,
... )

>>> # Initializing Bark sub-modules configurations.
>>> semantic_config = BarkSemanticConfig()
>>> coarse_acoustics_config = BarkCoarseConfig()
>>> fine_acoustics_config = BarkFineConfig()
>>> codec_config = AutoConfig.from_pretrained("facebook/encodec_24khz")

>>> # Initializing a Bark module style configuration
>>> configuration = BarkConfig(
...     semantic_config, coarse_acoustics_config, fine_acoustics_config, codec_config
... )

>>> # Initializing a model (with random weights)
>>> model = BarkModel(configuration)

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

## BarkProcessor[[transformers.BarkProcessor]]

#### transformers.BarkProcessor[[transformers.BarkProcessor]]

```python
transformers.BarkProcessor(tokenizer, speaker_embeddings = None)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/bark/processing_bark.py#L35)

**Parâmetros:**

tokenizer (`BertTokenizer`) : O tokenizer é uma entrada obrigatória.

speaker_embeddings (`dict[dict[str]]`, *opcional*) : Dicionário opcional de embeddings de falantes aninhados. O primeiro nível contém os nomes dos presets de voz (por exemplo, `"en_speaker_4"`). O segundo nível contém os embeddings `"semantic_prompt"`, `"coarse_prompt"` e `"fine_prompt"`. Os valores correspondem ao caminho do `np.ndarray` correspondente. Veja [aqui](https://suno-ai.notion.site/8b8e8749ed514b0cbf3f699013548683?v=bc67cff786b04b50b3ceb756fd05f68c) uma lista de `voice_preset_names`.

Constrói um BarkProcessor que encapsula um tokenizer em um único processor.

[BarkProcessor](/docs/transformers/main/pt/model_doc/bark#transformers.BarkProcessor) oferece todas as funcionalidades de [BertTokenizer](/docs/transformers/main/pt/model_doc/lxmert#transformers.BertTokenizer). Consulte o [~BertTokenizer](/docs/transformers/main/pt/model_doc/lxmert#transformers.BertTokenizer) para mais informações.

#### __call__[[transformers.BarkProcessor.__call__]]

```python
__call__(text = None, voice_preset = None, return_tensors = 'pt', max_length = 256, add_special_tokens = False, return_attention_mask = True, return_token_type_ids = False, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/bark/processing_bark.py#L296)

**Parâmetros:**

text (``) : The sequence or batch of sequences to be encoded. Each sequence can be a string or a list of strings (pretokenized string). If you pass a pretokenized input, set `is_split_into_words=True` to avoid ambiguity with batched inputs.

voice_preset (`str`, `dict[np.ndarray]`) : O preset de voz, ou seja, os embeddings do falante. Pode ser um nome de voice_preset válido, por exemplo `"en_speaker_1"`, ou diretamente um dicionário de embeddings `np.ndarray` para cada submodelo do `Bark`. Também pode ser um nome de arquivo válido de um preset de voz local `.npz` único, contendo as chaves `"semantic_prompt"`, `"coarse_prompt"` e `"fine_prompt"`.

return_tensors (``, defaults to `pt`) : If set, will return tensors of a particular framework. Acceptable values are:  - `'pt'`: Return PyTorch `torch.Tensor` objects. - `'np'`: Return NumPy `np.ndarray` objetos.

max_length (`int`, padrão `256`) : Controla o comprimento máximo a ser usado por um dos parâmetros de truncamento/preenchimento. Se não for definido ou for definido como `None`, será usado o comprimento máximo predefinido do modelo, caso um dos parâmetros de truncamento/preenchimento exija um comprimento máximo. Se o modelo não tiver um comprimento máximo de entrada específico (como o XLNet), o truncamento/preenchimento para um comprimento máximo será desativado.

add_special_tokens (`bool`, padrão `False`) : Indica se tokens especiais devem ser adicionados ao codificar as sequências. Isso utiliza a função subjacente `PretrainedTokenizerBase.build_inputs_with_special_tokens`, que define quais tokens são adicionados automaticamente aos ids de entrada. Isso é útil se você deseja adicionar tokens `bos` ou `eos` automaticamente.

return_attention_mask (`bool`, padrão `True`) : Se deve retornar a máscara de atenção. Se mantido no padrão, retornará a máscara de atenção de acordo com o padrão do tokenizer específico, definido pelo atributo `return_outputs`.  [O que são máscaras de atenção?](../glossary#attention-mask)

return_token_type_ids (`bool`, padrão `False`) : Se deve retornar os IDs de tipo de token. Se mantido no padrão, retornará os IDs de tipo de token de acordo com o padrão do tokenizer específico, definido pelo atributo `return_outputs`.  [O que são IDs de tipo de token?](../glossary#token-type-ids)

**Retorna:** [BatchEncoding](/docs/transformers/main/pt/main_classes/tokenizer#transformers.BatchEncoding)

Um objeto [BatchEncoding](/docs/transformers/main/pt/main_classes/tokenizer#transformers.BatchEncoding) contendo a saída do `tokenizer`. Se um preset de voz for fornecido, o objeto retornado incluirá uma chave `"history_prompt"` contendo um [BatchFeature](/docs/transformers/main/pt/main_classes/feature_extractor#transformers.BatchFeature), ou seja, o preset de voz com o tipo de tensor adequado.

#### from_pretrained[[transformers.BarkProcessor.from_pretrained]]

```python
from_pretrained(pretrained_processor_name_or_path, speaker_embeddings_dict_path = 'speaker_embeddings_path.json', **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/bark/processing_bark.py#L55)

**Parâmetros:**

pretrained_model_name_or_path (`str` ou `os.PathLike`) : Pode ser:  - uma string, o *model id* de um [BarkProcessor](/docs/transformers/main/pt/model_doc/bark#transformers.BarkProcessor) pré-treinado hospedado em um repositório de modelos no huggingface.co. - um caminho para um *diretório* contendo um processador salvo usando o método [save_pretrained()](/docs/transformers/main/pt/model_doc/bark#transformers.BarkProcessor.save_pretrained), por exemplo, `./my_model_directory/`.

speaker_embeddings_dict_path (`str`, *opcional*, padrão `"speaker_embeddings_path.json"`) : O nome do arquivo `.json` que contém o dicionário speaker_embeddings localizado em `pretrained_model_name_or_path`. Se `None`, nenhum speaker_embeddings é carregado.

- ****kwargs** : Argumentos de palavra-chave adicionais passados para `~tokenization_utils_base.PreTrainedTokenizer.from_pretrained`.

Instancie um processador Bark associado a um modelo pré-treinado.

#### save_pretrained[[transformers.BarkProcessor.save_pretrained]]

```python
save_pretrained(save_directory, speaker_embeddings_dict_path = 'speaker_embeddings_path.json', speaker_embeddings_directory = 'speaker_embeddings', push_to_hub: bool = False, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/bark/processing_bark.py#L121)

**Parâmetros:**

save_directory (`str` ou `os.PathLike`) : Diretório onde os arquivos do tokenizer e os embeddings de falante serão salvos (o diretório será criado caso não exista).

speaker_embeddings_dict_path (`str`, *opcional*, padrão `"speaker_embeddings_path.json"`) : O nome do arquivo `.json` que conterá o dicionário de caminhos aninhados de speaker_embeddings, caso exista, e que ficará localizado em `pretrained_model_name_or_path/speaker_embeddings_directory`.

speaker_embeddings_directory (`str`, *opcional*, padrão `"speaker_embeddings/"`) : O nome da pasta em que os arrays de speaker_embeddings serão salvos.

push_to_hub (`bool`, *opcional*, padrão `False`) : Indica se o modelo deve ser enviado para o Hugging Face model hub após ser salvo. Você pode especificar o repositório de destino com `repo_id` (por padrão, será usado o nome de `save_directory` no seu namespace).

kwargs : Argumentos de palavra-chave adicionais passados para o método [push_to_hub()](/docs/transformers/main/pt/main_classes/model#transformers.utils.PushToHubMixin.push_to_hub).

Salva os atributos deste processador (tokenizer...) no diretório especificado para que ele possa ser recarregado usando o método [from_pretrained()](/docs/transformers/main/pt/model_doc/bark#transformers.BarkProcessor.from_pretrained).

## BarkModel[[transformers.BarkModel]]

#### transformers.BarkModel[[transformers.BarkModel]]

```python
transformers.BarkModel(config: BarkConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/bark/modeling_bark.py#L1260)

**Parâmetros:**

config ([BarkConfig](/docs/transformers/main/pt/model_doc/bark#transformers.BarkConfig)) : 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 Bark completo, um modelo de texto para fala composto por 4 submodelos:
- [BarkSemanticModel](/docs/transformers/main/pt/model_doc/bark#transformers.BarkSemanticModel) (também referido como o modelo de 'texto'): um modelo transformer auto-regressivo causal que
recebe como entrada texto tokenizado e prevê tokens de texto semântico que capturam o significado do texto.
- [BarkCoarseModel](/docs/transformers/main/pt/model_doc/bark#transformers.BarkCoarseModel) (também referido como o modelo de "acústica grosseira"), também um transformer autoregressivo causal,
que recebe como entrada os resultados do último modelo. Ele visa regressar os dois primeiros codebooks de áudio necessários para o `encodec`.
- [BarkFineModel](/docs/transformers/main/pt/model_doc/bark#transformers.BarkFineModel) (o modelo de "acústica fina"), desta vez um transformer autoencoder não causal, que iterativamente
prevê os últimos codebooks com base na soma dos embeddings dos codebooks anteriores.
- após prever todos os canais do codebook a partir do [EncodecModel](/docs/transformers/main/pt/model_doc/encodec#transformers.EncodecModel), o Bark o utiliza para decodificar o áudio de saída
array.

Deve-se observar que cada um dos três primeiros módulos pode suportar incorporações condicionais de falante para condicionar o som de saída de acordo com uma voz específica predefinida.

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.

#### generate[[transformers.BarkModel.generate]]

```python
generate(input_ids: typing.Optional[torch.Tensor] = None, history_prompt: dict[str, torch.Tensor] | None = None, return_output_lengths: bool | None = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/bark/modeling_bark.py#L1364)

**Parâmetros:**

input_ids (`Optional[torch.Tensor]` de forma (batch_size, seq_len), *opcional*) : IDs de entrada. Serão truncados até 256 tokens. Observe que os áudios de saída terão a duração da geração mais longa do lote.

history_prompt (`Optional[dict[str,torch.Tensor]]`, *opcional*) : Prompt de locutor `Bark` opcional. Observe que, por enquanto, este modelo aceita apenas um prompt de locutor por lote.

kwargs (*opcional*) : Dicionário restante de argumentos de palavra-chave. Os argumentos de palavra-chave são de dois tipos:  - Sem um prefixo, eles serão inseridos como `**kwargs` para o método `generate` de cada submodelo. - Com um prefixo *semantic_*, *coarse_*, *fine_*, eles serão inseridos para o método `generate` do semântico, do grosseiro e do fino, respectivamente. Eles têm prioridade sobre as palavras-chave sem prefixo.  Isso significa que você pode, por exemplo, especificar uma estratégia de geração para todos os submodelos, exceto um.

return_output_lengths (`bool`, *opcional*) : Indica se os comprimentos das formas de onda devem ser retornados. Útil ao processar em lotes.

**Retorna:** `By default`

- **audio_waveform** (`torch.Tensor` de forma (batch_size, seq_len)): Forma de onda de áudio gerada.
Quando `return_output_lengths=True`: Retorna uma tupla composta por:
- **audio_waveform** (`torch.Tensor` de forma (batch_size, seq_len)): Forma de onda de áudio gerada.
- **output_lengths** (`torch.Tensor` de forma (batch_size)): O comprimento de cada forma de onda no lote

Gera áudio a partir de um prompt de entrada e um prompt de falante `Bark` adicional opcional.

Exemplo:

```python
>>> from transformers import AutoProcessor, BarkModel

>>> processor = AutoProcessor.from_pretrained("suno/bark-small")
>>> model = BarkModel.from_pretrained("suno/bark-small")

>>> # To add a voice preset, you can pass `voice_preset` to `BarkProcessor.__call__(...)`
>>> voice_preset = "v2/en_speaker_6"

>>> inputs = processor("Hello, my dog is cute, I need him in my life", voice_preset=voice_preset)

>>> audio_array = model.generate(**inputs, semantic_max_new_tokens=100)
>>> audio_array = audio_array.cpu().numpy().squeeze()
```

#### enable_cpu_offload[[transformers.BarkModel.enable_cpu_offload]]

```python
enable_cpu_offload(accelerator_id: int | None = 0, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/bark/modeling_bark.py#L1302)

**Parâmetros:**

accelerator_id (`int`, *opcional*, padrão 0) : id do acelerador no qual os submodelos serão carregados e descarregados.

Desloca todos os submodelos para a CPU usando o accelerate, reduzindo o uso de memória com baixo impacto no desempenho. Este método move um submodelo inteiro por vez para o acelerador quando ele é usado, e o submodelo permanece no acelerador até que o próximo submodelo seja executado.

## BarkSemanticModel[[transformers.BarkSemanticModel]]

#### transformers.BarkSemanticModel[[transformers.BarkSemanticModel]]

```python
transformers.BarkSemanticModel(config: BarkSubModelConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/bark/modeling_bark.py#L526)

**Parâmetros:**

config (`BarkSubModelConfig`) : 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.

Modelo semântico (ou de texto) do Bark. Ele compartilha a mesma arquitetura do modelo de baixa resolução. Trata-se de um modelo autoregressivo semelhante ao GPT-2, com uma cabeça de modelagem de linguagem no topo.

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.

#### forward[[transformers.BarkSemanticModel.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/bark/modeling_bark.py#L396)

**Parâmetros:**

input_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids)

past_key_values (`~cache_utils.Cache`, *opcional*) : hidden-states pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados para acelerar a decodificação sequencial. Isso geralmente consiste nos `past_key_values` retornados pelo modelo em uma etapa anterior da decodificação, quando `use_cache=True` ou `config.use_cache=True`.  Apenas uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache) é permitida como entrada, consulte nosso [guia de kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Se nenhum `past_key_values` for passado, [DynamicCache](/docs/transformers/main/pt/internal/generation_utils#transformers.DynamicCache) será inicializado por padrão.  O modelo sairá no mesmo formato de cache que foi fornecido como entrada.  Se `past_key_values` forem usados, espera-se que o usuário insira apenas `input_ids` não processados (aqueles que não têm seus estados de chave e valor passados para este modelo) com a forma `(batch_size, unprocessed_length)` em vez de todos os `input_ids` com a forma `(batch_size, sequence_length)`.

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`:  - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**.  [O que são máscaras de atenção?](../glossary#attention-mask)

position_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.n_positions - 1]`.  [O que são IDs de posição?](../glossary#position-ids)

labels (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Rótulos para calcular a perda de modelagem de linguagem mascarada. Os índices devem estar em `[0, ..., config.vocab_size]` ou ser -100 (veja a docstring de `input_ids`). Tokens com índices definidos como `-100` são ignorados (mascarados); a perda é calculada apenas para os tokens com rótulos em `[0, ..., config.vocab_size]`.

inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de `input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo.

use_cache (`bool`, *opcional*) : Se definido como `True`, os estados de chave-valor de `past_key_values` são retornados e podem ser usados para acelerar a decodificação (veja `past_key_values`).

output_attentions (`bool`, *opcional*) : Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulte `attentions` nos tensores retornados para mais detalhes.

output_hidden_states (`bool`, *opcional*) : Indica se os estados ocultos de todas as camadas devem ser retornados. Consulte `hidden_states` em tensores retornados para mais detalhes.

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

**Retorna:** [CausalLMOutputWithPast](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithPast) ou `tuple(torch.Tensor)`

Um [CausalLMOutputWithPast](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithPast) ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`), contendo diversos elementos dependendo da configuração ([BarkConfig](/docs/transformers/main/pt/model_doc/bark#transformers.BarkConfig)) e das entradas.

O método forward do [BarkCausalModel](/docs/transformers/main/pt/model_doc/bark#transformers.BarkCausalModel) 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.

- **loss** (`torch.Tensor` de forma `(1,)`, *opcional*, retornado quando `labels` é fornecido) -- Perda de modelagem de linguagem (para previsão do próximo token).
- **logits** (`torch.Tensor` de forma `(batch_size, sequence_length, config.vocab_size)`) -- Pontuações de previsão da cabeça de modelagem de linguagem (pontuações para cada token do vocabulário antes do SoftMax).
- **past_key_values** (`Cache`, *opcional*, retornado quando `use_cache=True` é passado ou quando `config.use_cache=True`) -- Trata-se de uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache). Para mais detalhes, consulte nosso [guia de cache kv](https://huggingface.co/docs/transformers/en/kv_cache).

  Contém estados ocultos pré-computados (chaves e valores nos blocos de autoatenção) que podem ser usados (veja a entrada `past_key_values`) para acelerar a decodificação sequencial.
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.

## BarkCoarseModel[[transformers.BarkCoarseModel]]

#### transformers.BarkCoarseModel[[transformers.BarkCoarseModel]]

```python
transformers.BarkCoarseModel(config: BarkSubModelConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/bark/modeling_bark.py#L642)

**Parâmetros:**

config (`BarkSubModelConfig`) : 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.

Modelo de acústica bruta do Bark. Ele compartilha a mesma arquitetura que o modelo semântico (ou de texto). Trata-se de um modelo autoregressivo semelhante ao GPT-2, com uma cabeça de modelagem de linguagem no topo.

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.

#### forward[[transformers.BarkCoarseModel.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/bark/modeling_bark.py#L396)

**Parâmetros:**

input_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids)

past_key_values (`~cache_utils.Cache`, *opcional*) : hidden-states pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados para acelerar a decodificação sequencial. Isso geralmente consiste nos `past_key_values` retornados pelo modelo em uma etapa anterior da decodificação, quando `use_cache=True` ou `config.use_cache=True`.  Apenas uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache) é permitida como entrada, consulte nosso [guia de kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Se nenhum `past_key_values` for passado, [DynamicCache](/docs/transformers/main/pt/internal/generation_utils#transformers.DynamicCache) será inicializado por padrão.  O modelo sairá no mesmo formato de cache que foi fornecido como entrada.  Se `past_key_values` forem usados, espera-se que o usuário insira apenas `input_ids` não processados (aqueles que não têm seus estados de chave e valor passados para este modelo) com a forma `(batch_size, unprocessed_length)` em vez de todos os `input_ids` com a forma `(batch_size, sequence_length)`.

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`:  - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**.  [O que são máscaras de atenção?](../glossary#attention-mask)

position_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.n_positions - 1]`.  [O que são IDs de posição?](../glossary#position-ids)

labels (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Rótulos para calcular a perda de modelagem de linguagem mascarada. Os índices devem estar em `[0, ..., config.vocab_size]` ou ser -100 (veja a docstring de `input_ids`). Tokens com índices definidos como `-100` são ignorados (mascarados); a perda é calculada apenas para os tokens com rótulos em `[0, ..., config.vocab_size]`.

inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de `input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo.

use_cache (`bool`, *opcional*) : Se definido como `True`, os estados de chave-valor de `past_key_values` são retornados e podem ser usados para acelerar a decodificação (veja `past_key_values`).

output_attentions (`bool`, *opcional*) : Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulte `attentions` nos tensores retornados para mais detalhes.

output_hidden_states (`bool`, *opcional*) : Indica se os estados ocultos de todas as camadas devem ser retornados. Consulte `hidden_states` em tensores retornados para mais detalhes.

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

**Retorna:** [CausalLMOutputWithPast](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithPast) ou `tuple(torch.Tensor)`

Um [CausalLMOutputWithPast](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithPast) ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`), contendo diversos elementos dependendo da configuração ([BarkConfig](/docs/transformers/main/pt/model_doc/bark#transformers.BarkConfig)) e das entradas.

O método forward do [BarkCausalModel](/docs/transformers/main/pt/model_doc/bark#transformers.BarkCausalModel) 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.

- **loss** (`torch.Tensor` de forma `(1,)`, *opcional*, retornado quando `labels` é fornecido) -- Perda de modelagem de linguagem (para previsão do próximo token).
- **logits** (`torch.Tensor` de forma `(batch_size, sequence_length, config.vocab_size)`) -- Pontuações de previsão da cabeça de modelagem de linguagem (pontuações para cada token do vocabulário antes do SoftMax).
- **past_key_values** (`Cache`, *opcional*, retornado quando `use_cache=True` é passado ou quando `config.use_cache=True`) -- Trata-se de uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache). Para mais detalhes, consulte nosso [guia de cache kv](https://huggingface.co/docs/transformers/en/kv_cache).

  Contém estados ocultos pré-computados (chaves e valores nos blocos de autoatenção) que podem ser usados (veja a entrada `past_key_values`) para acelerar a decodificação sequencial.
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.

## BarkFineModel[[transformers.BarkFineModel]]

#### transformers.BarkFineModel[[transformers.BarkFineModel]]

```python
transformers.BarkFineModel(config: BarkFineConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/bark/modeling_bark.py#L866)

**Parâmetros:**

config ([BarkFineConfig](/docs/transformers/main/pt/model_doc/bark#transformers.BarkFineConfig)) : 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.

Modelo de acústica fina do Bark. Trata-se de um modelo não causal, semelhante a um GPT, com `config.n_codes_total` camadas de incorporação e cabeças de modelagem de linguagem, uma para cada codebook.

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.

#### forward[[transformers.BarkFineModel.forward]]

```python
forward(codebook_idx: int, input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/bark/modeling_bark.py#L993)

**Parâmetros:**

codebook_idx (`int`) : Índice do codebook que será previsto.

input_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids)

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`:  - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**.  [O que são máscaras de atenção?](../glossary#attention-mask)

position_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.n_positions - 1]`.  [O que são IDs de posição?](../glossary#position-ids)

labels (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : AINDA NÃO IMPLEMENTADO.

inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de `input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo.

output_attentions (`bool`, *opcional*) : Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulte `attentions` nos tensores retornados para mais detalhes.

output_hidden_states (`bool`, *opcional*) : Indica se os estados ocultos de todas as camadas devem ser retornados. Consulte `hidden_states` em tensores retornados para mais detalhes.

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

**Retorna:** [MaskedLMOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.MaskedLMOutput) ou `tuple(torch.Tensor)`

Um [MaskedLMOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.MaskedLMOutput) ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`), composto por diversos elementos, dependendo da configuração ([BarkConfig](/docs/transformers/main/pt/model_doc/bark#transformers.BarkConfig)) e das entradas.

O método forward do [BarkFineModel](/docs/transformers/main/pt/model_doc/bark#transformers.BarkFineModel) 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.

- **loss** (`torch.Tensor` de forma `(1,)`, *opcional*, retornado quando `labels` é fornecido) -- Perda de modelagem de linguagem mascarada (MLM).
- **logits** (`torch.Tensor` de forma `(batch_size, sequence_length, config.vocab_size)`) -- Pontuações de previsão da cabeça de modelagem de linguagem (pontuações para cada token do vocabulário antes do SoftMax).
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.

## BarkCausalModel[[transformers.BarkCausalModel]]

#### transformers.BarkCausalModel[[transformers.BarkCausalModel]]

```python
transformers.BarkCausalModel(config: BarkSubModelConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/bark/modeling_bark.py#L361)

#### forward[[transformers.BarkCausalModel.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/bark/modeling_bark.py#L396)

**Parâmetros:**

input_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids)

past_key_values (`~cache_utils.Cache`, *opcional*) : hidden-states pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados para acelerar a decodificação sequencial. Isso geralmente consiste nos `past_key_values` retornados pelo modelo em uma etapa anterior da decodificação, quando `use_cache=True` ou `config.use_cache=True`.  Apenas uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache) é permitida como entrada, consulte nosso [guia de kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Se nenhum `past_key_values` for passado, [DynamicCache](/docs/transformers/main/pt/internal/generation_utils#transformers.DynamicCache) será inicializado por padrão.  O modelo sairá no mesmo formato de cache que foi fornecido como entrada.  Se `past_key_values` forem usados, espera-se que o usuário insira apenas `input_ids` não processados (aqueles que não têm seus estados de chave e valor passados para este modelo) com a forma `(batch_size, unprocessed_length)` em vez de todos os `input_ids` com a forma `(batch_size, sequence_length)`.

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`:  - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**.  [O que são máscaras de atenção?](../glossary#attention-mask)

position_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.n_positions - 1]`.  [O que são IDs de posição?](../glossary#position-ids)

labels (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Rótulos para calcular a perda de modelagem de linguagem mascarada. Os índices devem estar em `[0, ..., config.vocab_size]` ou ser -100 (veja a docstring de `input_ids`). Tokens com índices definidos como `-100` são ignorados (mascarados); a perda é calculada apenas para os tokens com rótulos em `[0, ..., config.vocab_size]`.

inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de `input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo.

use_cache (`bool`, *opcional*) : Se definido como `True`, os estados de chave-valor de `past_key_values` são retornados e podem ser usados para acelerar a decodificação (veja `past_key_values`).

output_attentions (`bool`, *opcional*) : Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulte `attentions` nos tensores retornados para mais detalhes.

output_hidden_states (`bool`, *opcional*) : Indica se os estados ocultos de todas as camadas devem ser retornados. Consulte `hidden_states` em tensores retornados para mais detalhes.

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

**Retorna:** [CausalLMOutputWithPast](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithPast) ou `tuple(torch.Tensor)`

Um [CausalLMOutputWithPast](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithPast) ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`), contendo diversos elementos dependendo da configuração ([BarkConfig](/docs/transformers/main/pt/model_doc/bark#transformers.BarkConfig)) e das entradas.

O método forward do [BarkCausalModel](/docs/transformers/main/pt/model_doc/bark#transformers.BarkCausalModel) 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.

- **loss** (`torch.Tensor` de forma `(1,)`, *opcional*, retornado quando `labels` é fornecido) -- Perda de modelagem de linguagem (para previsão do próximo token).
- **logits** (`torch.Tensor` de forma `(batch_size, sequence_length, config.vocab_size)`) -- Pontuações de previsão da cabeça de modelagem de linguagem (pontuações para cada token do vocabulário antes do SoftMax).
- **past_key_values** (`Cache`, *opcional*, retornado quando `use_cache=True` é passado ou quando `config.use_cache=True`) -- Trata-se de uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache). Para mais detalhes, consulte nosso [guia de cache kv](https://huggingface.co/docs/transformers/en/kv_cache).

  Contém estados ocultos pré-computados (chaves e valores nos blocos de autoatenção) que podem ser usados (veja a entrada `past_key_values`) para acelerar a decodificação sequencial.
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.

## BarkCoarseConfig[[transformers.BarkCoarseConfig]]

#### transformers.BarkCoarseConfig[[transformers.BarkCoarseConfig]]

```python
transformers.BarkCoarseConfig(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, block_size: int = 1024, input_vocab_size: int = 10048, output_vocab_size: int = 10048, num_layers: int = 12, num_heads: int = 12, hidden_size: int = 768, dropout: float | int = 0.0, bias: bool = True, initializer_range: float = 0.02, use_cache: bool = True)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/bark/configuration_bark.py#L105)

**Parâmetros:**

block_size (`int`, *opcional*, padrão 1024) : O comprimento máximo de sequência com o qual este modelo pode ser usado. Normalmente, defina esse valor para algo grande, apenas por precaução (por exemplo, 512, 1024 ou 2048).

input_vocab_size (`int`, *opcional*, padrão 10_048) : Tamanho do vocabulário de um submodelo do Bark. Define o número de tokens diferentes que podem ser representados pelos `inputs_ids` passados ao chamar `{model}`. O padrão é 10_048, mas deve ser definido com cuidado em relação ao submodelo escolhido.

output_vocab_size (`int`, *opcional*, padrão 10_048) : Tamanho do vocabulário de saída de um sub-modelo do Bark. Define o número de tokens diferentes que podem ser representados por: `output_ids` ao passar um `{model}` para frente. O padrão é 10_048, mas deve ser pensado com cuidado em relação ao sub-modelo escolhido.

num_layers (`int`, *opcional*, padrão `12`) : Número de camadas ocultas no decodificador do Transformer.

num_heads (`int`, *opcional*, padrão `12`) : Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer.

hidden_size (`int`, *opcional*, padrão `768`) : Dimensão das representações ocultas.

dropout (`Union[float, int]`, *opcional*, padrão `0.0`) : A proporção para todas as camadas de dropout.

bias (`bool`, *opcional*, padrão `True`) : Se deve ou não usar viés nas camadas lineares e nas camadas de normalização de camada

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

use_cache (`bool`, *opcional*, padrão `True`) : Indica se o modelo deve retornar as últimas atenções de chave/valor (não utilizado por todos os modelos). Relevante apenas se `config.is_decoder=True` ou quando o modelo for um modelo generativo somente de decodificador.

Esta é a classe de configuração para armazenar a configuração de um BarkModel. Ela é usada para instanciar um modelo Bark 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 [suno/bark](https://huggingface.co/suno/bark)

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 BarkCoarseConfig, BarkCoarseModel

>>> # Initializing a Bark sub-module style configuration
>>> configuration = BarkCoarseConfig()

>>> # Initializing a model (with random weights) from the suno/bark style configuration
>>> model = BarkCoarseModel(configuration)

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

## BarkFineConfig[[transformers.BarkFineConfig]]

#### transformers.BarkFineConfig[[transformers.BarkFineConfig]]

```python
transformers.BarkFineConfig(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, block_size: int = 1024, input_vocab_size: int = 10048, output_vocab_size: int = 10048, num_layers: int = 12, num_heads: int = 12, hidden_size: int = 768, dropout: float | int = 0.0, bias: bool = True, initializer_range: float = 0.02, use_cache: bool = True, tie_word_embeddings: bool = True, n_codes_total: int = 8, n_codes_given: int = 1)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/bark/configuration_bark.py#L142)

**Parâmetros:**

block_size (`int`, *opcional*, padrão 1024) : O comprimento máximo de sequência com o qual este modelo pode ser usado. Normalmente, defina esse valor para algo grande, apenas por precaução (por exemplo, 512, 1024 ou 2048).

input_vocab_size (`int`, *opcional*, padrão 10_048) : Tamanho do vocabulário de um submodelo do Bark. Define o número de tokens diferentes que podem ser representados pelos `inputs_ids` passados ao chamar `{model}`. O padrão é 10_048, mas deve ser definido com cuidado em relação ao submodelo escolhido.

output_vocab_size (`int`, *opcional*, padrão 10_048) : Tamanho do vocabulário de saída de um sub-modelo do Bark. Define o número de tokens diferentes que podem ser representados por: `output_ids` ao passar um `{model}` para frente. O padrão é 10_048, mas deve ser pensado com cuidado em relação ao sub-modelo escolhido.

num_layers (`int`, *opcional*, padrão `12`) : Número de camadas ocultas no decodificador do Transformer.

num_heads (`int`, *opcional*, padrão `12`) : Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer.

hidden_size (`int`, *opcional*, padrão `768`) : Dimensão das representações ocultas.

dropout (`Union[float, int]`, *opcional*, padrão `0.0`) : A proporção para todas as camadas de dropout.

bias (`bool`, *opcional*, padrão `True`) : Se deve ou não usar viés nas camadas lineares e nas camadas de normalização de camada

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

use_cache (`bool`, *opcional*, padrão `True`) : Indica se o modelo deve retornar as últimas atenções de chave/valor (não utilizado por todos os modelos). Relevante apenas se `config.is_decoder=True` ou quando o modelo for um modelo generativo somente de decodificador.

tie_word_embeddings (`bool`, *opcional*, padrão `True`) : Se deve vincular as embeddings de pesos de acordo com o mapeamento `tied_weights_keys` do modelo.

n_codes_total (`int`, *opcional*, padrão 8) : O número total de codebooks de áudio previstos. Usado no submodelo de acústica fina.

n_codes_given (`int`, *opcional*, padrão 1) : O número de codebooks de áudio previstos no submodelo de acústica grossa. Usado nos submodelos de acústica.

Esta é a classe de configuração para armazenar a configuração de um BarkModel. Ela é usada para instanciar um modelo Bark 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 [suno/bark](https://huggingface.co/suno/bark)

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 BarkFineConfig, BarkFineModel

>>> # Initializing a Bark sub-module style configuration
>>> configuration = BarkFineConfig()

>>> # Initializing a model (with random weights) from the suno/bark style configuration
>>> model = BarkFineModel(configuration)

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

## BarkSemanticConfig[[transformers.BarkSemanticConfig]]

#### transformers.BarkSemanticConfig[[transformers.BarkSemanticConfig]]

```python
transformers.BarkSemanticConfig(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, block_size: int = 1024, input_vocab_size: int = 10048, output_vocab_size: int = 10048, num_layers: int = 12, num_heads: int = 12, hidden_size: int = 768, dropout: float | int = 0.0, bias: bool = True, initializer_range: float = 0.02, use_cache: bool = True)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/bark/configuration_bark.py#L68)

**Parâmetros:**

block_size (`int`, *opcional*, padrão 1024) : O comprimento máximo de sequência com o qual este modelo pode ser usado. Normalmente, defina esse valor para algo grande, apenas por precaução (por exemplo, 512, 1024 ou 2048).

input_vocab_size (`int`, *opcional*, padrão 10_048) : Tamanho do vocabulário de um submodelo do Bark. Define o número de tokens diferentes que podem ser representados pelos `inputs_ids` passados ao chamar `{model}`. O padrão é 10_048, mas deve ser definido com cuidado em relação ao submodelo escolhido.

output_vocab_size (`int`, *opcional*, padrão 10_048) : Tamanho do vocabulário de saída de um sub-modelo do Bark. Define o número de tokens diferentes que podem ser representados por: `output_ids` ao passar um `{model}` para frente. O padrão é 10_048, mas deve ser pensado com cuidado em relação ao sub-modelo escolhido.

num_layers (`int`, *opcional*, padrão `12`) : Número de camadas ocultas no decodificador do Transformer.

num_heads (`int`, *opcional*, padrão `12`) : Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer.

hidden_size (`int`, *opcional*, padrão `768`) : Dimensão das representações ocultas.

dropout (`Union[float, int]`, *opcional*, padrão `0.0`) : A proporção para todas as camadas de dropout.

bias (`bool`, *opcional*, padrão `True`) : Se deve ou não usar viés nas camadas lineares e nas camadas de normalização de camada

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

use_cache (`bool`, *opcional*, padrão `True`) : Indica se o modelo deve retornar as últimas atenções de chave/valor (não utilizado por todos os modelos). Relevante apenas se `config.is_decoder=True` ou quando o modelo for um modelo generativo somente de decodificador.

Esta é a classe de configuração para armazenar a configuração de um BarkModel. Ela é usada para instanciar um modelo Bark 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 [suno/bark](https://huggingface.co/suno/bark)

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 BarkSemanticConfig, BarkSemanticModel

>>> # Initializing a Bark sub-module style configuration
>>> configuration = BarkSemanticConfig()

>>> # Initializing a model (with random weights) from the suno/bark style configuration
>>> model = BarkSemanticModel(configuration)

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