# Bark

## Resumen

[Bark](https://huggingface.co/suno/bark) es un modelo de texto a voz basado en transformers propuesto por Suno AI en [suno-ai/bark](https://github.com/suno-ai/bark).

Bark está compuesto por 4 modelos principales:

- [BarkSemanticModel](/docs/transformers/v5.23.0/es/model_doc/bark#transformers.BarkSemanticModel) (también conocido como el modelo de «texto»): un modelo transformer causal auto-regresivo que toma como entrada texto tokenizado y predice tokens semánticos de texto que capturan el significado del texto.
- [BarkCoarseModel](/docs/transformers/v5.23.0/es/model_doc/bark#transformers.BarkCoarseModel) (también conocido como el modelo de «acústica gruesa»): un transformer autoregresivo causal que toma como entrada los resultados del modelo [BarkSemanticModel](/docs/transformers/v5.23.0/es/model_doc/bark#transformers.BarkSemanticModel). Su objetivo es predecir los dos primeros libros de códigos de audio necesarios para EnCodec.
- [BarkFineModel](/docs/transformers/v5.23.0/es/model_doc/bark#transformers.BarkFineModel) (el modelo de «acústica fina»), esta vez un transformador autoencoder no causal, que predice iterativamente los últimos codebooks a partir de la suma de los embeddings de los codebooks anteriores.
- Tras haber predicho todos los canales del libro de códigos desde el [EncodecModel](/docs/transformers/v5.23.0/es/model_doc/encodec#transformers.EncodecModel), Bark lo utiliza para decodificar el array de audio de salida.

Cabe señalar que cada uno de los tres primeros módulos puede admitir embeddings de hablante condicional para condicionar el sonido de salida según una voz específica predefinida.

Este modelo fue aportado por [Yoach Lacombe (ylacombe)](https://huggingface.co/ylacombe) y [Sanchit Gandhi (sanchit-gandhi)](https://github.com/sanchit-gandhi). El código original se puede encontrar [aquí](https://github.com/suno-ai/bark).

### Optimización de Bark

Bark se puede optimizar con solo unas pocas líneas de código adicionales, lo que **reduce significativamente su huella de memoria** y **acelera la inferencia**.

#### Uso de precisión a mitad

Puede acelerar la inferencia y reducir la huella de memoria en un 50 % simplemente cargando el modelo en media precisión.

```python
from transformers import BarkModel

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

#### Uso de CPU offload

Como se mencionó anteriormente, Bark está compuesto por 4 submodelos, que se invocan de forma secuencial durante la generación de audio. En otras palabras, mientras un submodelo está en uso, los demás submodelos permanecen inactivos.

Si estás usando una GPU CUDA o una XPU de Intel, una solución sencilla para beneficiarte de una reducción del 80 % en la huella de memoria es descargar los submodelos del dispositivo a la CPU cuando están inactivos. Esta operación se denomina *CPU offloading*. Puedes usarla con una sola línea de código, de la siguiente manera:

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

Tenga en cuenta que 🤗 Accelerate debe estar instalado antes de usar esta función. [Así es como se instala.](https://huggingface.co/docs/accelerate/basic_tutorials/install)

#### Uso de Flash Attention 2

Flash Attention 2 es una versión aún más rápida y optimizada de la optimización anterior.

##### Instalación

Primero, comprueba si tu hardware es compatible con Flash Attention 2. La lista más reciente de hardware compatible se encuentra en la [documentación oficial](https://github.com/Dao-AILab/flash-attention#installation-and-features). A continuación, [instala](https://github.com/Dao-AILab/flash-attention#installation-and-features) la última versión de Flash Attention 2:

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

##### Uso

Para cargar un modelo usando Flash Attention 2, podemos pasar la bandera `attn_implementation="flash_attention_2"` a [from_pretrained()](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel.from_pretrained). También cargaremos el modelo en media precisión (por ejemplo, `torch.float16`), ya que esto produce una degradación casi nula en la calidad del audio, pero reduce significativamente el uso de memoria y acelera la inferencia:

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

##### Comparación de rendimiento

El siguiente diagrama muestra la latencia de la implementación nativa de atención (sin optimización) frente a Flash Attention 2. En todos los casos, generamos 400 tokens semánticos en una GPU A100 de 40 GB con PyTorch 2.1:

Para poner esto en perspectiva, en una NVIDIA A100 y al generar 400 tokens semánticos con un tamaño de lote de 16, se puede obtener un [throughput](https://huggingface.co/blog/optimizing-bark#throughput) 17 veces mayor y aun así ser 2 segundos más rápido que generar las oraciones una por una con la implementación nativa del modelo. En otras palabras, todas las muestras se generarán 17 veces más rápido.

#### Combinar técnicas de optimización

Puede combinar técnicas de optimización y usar CPU offload, precisión a mitad y Flash Attention 2 todas a la vez.

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

Obtenga más información sobre técnicas de optimización de inferencia [aquí](https://huggingface.co/docs/transformers/perf_infer_gpu_one).

### Consejos de uso

Suno ofrece una biblioteca de presets de voz en varios idiomas [aquí](https://suno-ai.notion.site/8b8e8749ed514b0cbf3f699013548683?v=bc67cff786b04b50b3ceb756fd05f68c). Estos presets también se suben al hub [aquí](https://huggingface.co/suno/bark-small/tree/main/speaker_embeddings) o [aquí](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()
```

Bark puede generar voz **multilingüe** altamente realista, así como otros audios, incluyendo música, ruido de fondo y efectos de sonido 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()
```

El modelo también puede producir **comunicaciones no verbales** como reír, suspirar y llorar.

```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 guardar el audio, simplemente toma la tasa de muestreo de la configuración del modelo y usa alguna utilidad de 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)
```

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

**Parámetros:**

semantic_config ([BarkSemanticConfig](/docs/transformers/v5.23.0/es/model_doc/bark#transformers.BarkSemanticConfig), *opcional*) : Configuración del submodelo semántico subyacente.

coarse_acoustics_config ([BarkCoarseConfig](/docs/transformers/v5.23.0/es/model_doc/bark#transformers.BarkCoarseConfig), *opcional*) : Configuración del submodelo de acústica gruesa subyacente.

fine_acoustics_config ([BarkFineConfig](/docs/transformers/v5.23.0/es/model_doc/bark#transformers.BarkFineConfig), *opcional*) : Configuración del submodelo de acústica fina subyacente.

codec_config ([AutoConfig](/docs/transformers/v5.23.0/es/model_doc/auto#transformers.AutoConfig), *opcional*) : Configuración del submodelo de códec subyacente.

initializer_range (`float`, *opcional*, valor predeterminado `0.02`) : La desviación estándar de truncated_normal_initializer para inicializar todas las matrices de pesos.

Esta es la clase de configuración para almacenar la configuración de un BarkModel. Se utiliza para instanciar un modelo Bark según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de [suno/bark](https://huggingface.co/suno/bark)

Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) y se pueden utilizar para controlar las salidas del modelo. Consulte la documentación de [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información.

Ejemplo:

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

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

**Parámetros:**

tokenizer (`BertTokenizer`) : El tokenizador es una entrada obligatoria.

speaker_embeddings (`dict[dict[str]]`, *opcional*) : Diccionario anidado opcional de embeddings de hablante. El primer nivel contiene los nombres de los presets de voz (p. ej. `"en_speaker_4"`). El segundo nivel contiene los embeddings `"semantic_prompt"`, `"coarse_prompt"` y `"fine_prompt"`. Los valores corresponden a la ruta del `np.ndarray` correspondiente. Consulte [aquí](https://suno-ai.notion.site/8b8e8749ed514b0cbf3f699013548683?v=bc67cff786b04b50b3ceb756fd05f68c) para obtener una lista de `voice_preset_names`.

Construye un BarkProcessor que envuelve un tokenizer en un único procesador.

[BarkProcessor](/docs/transformers/v5.23.0/es/model_doc/bark#transformers.BarkProcessor) ofrece todas las funcionalidades de [BertTokenizer](/docs/transformers/v5.23.0/es/model_doc/lxmert#transformers.BertTokenizer). Consulte [~BertTokenizer](/docs/transformers/v5.23.0/es/model_doc/lxmert#transformers.BertTokenizer) para obtener más información.

#### __llamada__[[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)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/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]`) : El preset de voz, es decir, los embeddings del hablante. Puede ser un nombre de voice_preset válido, por ejemplo `"en_speaker_1"`, o directamente un diccionario de embeddings `np.ndarray` para cada submodelo de `Bark`. También puede ser un nombre de archivo válido de un preset de voz local `.npz` que contenga las claves `"semantic_prompt"`, `"coarse_prompt"` y `"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` objects.

max_length (`int`, por defecto `256`) : Controla la longitud máxima que utilizará uno de los parámetros de truncamiento/relleno. Si se deja sin establecer o se establece en `None`, se utilizará la longitud máxima predefinida del modelo si uno de los parámetros de truncamiento/relleno requiere una longitud máxima. Si el modelo no tiene una longitud máxima de entrada específica (como XLNet), el truncamiento/relleno a una longitud máxima se desactivará.

add_special_tokens (`bool`, por defecto `False`) : Indica si se deben o no añadir tokens especiales al codificar las secuencias. Esto utilizará la función subyacente `PretrainedTokenizerBase.build_inputs_with_special_tokens`, que define qué tokens se añaden automáticamente a los ids de entrada. Esto es útil si deseas añadir automáticamente tokens `bos` o `eos`.

return_attention_mask (`bool`, por defecto `True`) : Indica si se debe devolver la máscara de atención. Si se deja en el valor por defecto, se devolverá la máscara de atención según el valor por defecto del tokenizador específico, definido por el atributo `return_outputs`.  [¿Qué son las máscaras de atención?](../glossary#attention-mask)

return_token_type_ids (`bool`, por defecto `False`) : Indica si se deben devolver los IDs de tipo de token. Si se deja en el valor por defecto, se devolverán los IDs de tipo de token según el valor por defecto del tokenizador específico, definido por el atributo `return_outputs`.  [¿Qué son los IDs de tipo de token?](../glossary#token-type-ids)

**Devuelve:** [BatchEncoding](/docs/transformers/v5.23.0/es/main_classes/tokenizer#transformers.BatchEncoding)

Un objeto [BatchEncoding](/docs/transformers/v5.23.0/es/main_classes/tokenizer#transformers.BatchEncoding) que contiene la salida del `tokenizer`. Si se proporciona un preset de voz, el objeto devuelto incluirá una clave `"history_prompt"` que contiene un [BatchFeature](/docs/transformers/v5.23.0/es/main_classes/feature_extractor#transformers.BatchFeature), es decir, el preset de voz con el tipo de tensores adecuado.

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

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

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

**Parámetros:**

pretrained_model_name_or_path (`str` o `os.PathLike`) : Puede ser:  - una cadena, el *model id* de un [BarkProcessor](/docs/transformers/v5.23.0/es/model_doc/bark#transformers.BarkProcessor) preentrenado alojado en un repositorio de modelos en huggingface.co. - una ruta a un *directorio* que contiene un procesador guardado con el método [save_pretrained()](/docs/transformers/v5.23.0/es/model_doc/bark#transformers.BarkProcessor.save_pretrained), por ejemplo, `./my_model_directory/`.

speaker_embeddings_dict_path (`str`, *opcional*, valor predeterminado `"speaker_embeddings_path.json"`) : El nombre del archivo `.json` que contiene el diccionario speaker_embeddings ubicado en `pretrained_model_name_or_path`. Si es `None`, no se carga speaker_embeddings.

- ****kwargs** : Argumentos de palabra clave adicionales que se pasan a `~tokenization_utils_base.PreTrainedTokenizer.from_pretrained`.

Instanciar un procesador de Bark asociado a un modelo preentrenado.

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

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

**Parámetros:**

save_directory (`str` o `os.PathLike`) : Directorio donde se guardarán los archivos del tokenizador y las incrustaciones de hablante (se creará el directorio si no existe).

speaker_embeddings_dict_path (`str`, *opcional*, valor predeterminado `"speaker_embeddings_path.json"`) : El nombre del archivo `.json` que contendrá el diccionario de rutas anidadas de speaker_embeddings, si existe, y que se ubicará en `pretrained_model_name_or_path/speaker_embeddings_directory`.

speaker_embeddings_directory (`str`, *opcional*, valor predeterminado `"speaker_embeddings/"`) : El nombre de la carpeta en la que se guardarán los arrays de speaker_embeddings.

push_to_hub (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe subir el modelo al Hugging Face model hub después de guardarlo. Puede especificar el repositorio al que desea subirlo con `repo_id` (por defecto, se usará el nombre de `save_directory` en su espacio de nombres).

kwargs : Argumentos de palabra clave adicionales que se pasan al método [push_to_hub()](/docs/transformers/v5.23.0/es/main_classes/model#transformers.utils.PushToHubMixin.push_to_hub).

Guarda los atributos de este procesador (tokenizer...) en el directorio especificado para que pueda recargarse mediante el método [from_pretrained()](/docs/transformers/v5.23.0/es/model_doc/bark#transformers.BarkProcessor.from_pretrained).

## BarkModel[[transformers.BarkModel]]

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

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/bark/modeling_bark.py#L1250)

**Parámetros:**

config ([BarkConfig](/docs/transformers/v5.23.0/es/model_doc/bark#transformers.BarkConfig)) : Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método [from_pretrained()](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

El modelo completo de Bark, un modelo de texto a voz compuesto por 4 submodelos:
- [BarkSemanticModel](/docs/transformers/v5.23.0/es/model_doc/bark#transformers.BarkSemanticModel) (también conocido como el modelo de 'texto'): un modelo transformer causal auto-regresivo que
recibe como entrada texto tokenizado y predice tokens de texto semánticos que capturan el significado del texto.
- [BarkCoarseModel](/docs/transformers/v5.23.0/es/model_doc/bark#transformers.BarkCoarseModel) (también conocido como el modelo de «acústica gruesa»), también un transformer autoregresivo causal,
que toma como entrada los resultados del último modelo. Su objetivo es regredir los dos primeros libros de códigos de audio necesarios para `encodec`.
- [BarkFineModel](/docs/transformers/v5.23.0/es/model_doc/bark#transformers.BarkFineModel) (el modelo de «acústica fina»), esta vez un transformador autoencoder no causal, que de forma iterativa
predice los últimos codebooks en función de la suma de las embeddings de los codebooks anteriores.
- Tras haber predicho todos los canales del libro de códigos desde el [EncodecModel](/docs/transformers/v5.23.0/es/model_doc/encodec#transformers.EncodecModel), Bark lo utiliza para decodificar el audio de salida
array.

Cabe señalar que cada uno de los tres primeros módulos puede admitir embeddings de hablante condicional para condicionar el sonido de salida según una voz específica predefinida.

Este modelo hereda de [PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel). Consulte la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/bark/modeling_bark.py#L1354)

**Parámetros:**

input_ids (`Optional[torch.Tensor]` de forma (batch_size, seq_len), *opcional*) : ids de entrada. Se truncarán hasta 256 tokens. Ten en cuenta que los audios de salida tendrán la misma duración que la generación más larga del lote.

history_prompt (`Optional[dict[str,torch.Tensor]]`, *opcional*) : Prompt de orador de `Bark` opcional. Tenga en cuenta que, por ahora, este modelo solo acepta un prompt de orador por lote.

kwargs (*opcional*) : Diccionario restante de argumentos de palabra clave. Los argumentos de palabra clave son de dos tipos: - Sin prefijo, se introducirán como `**kwargs` para el método `generate` de cada submodelo. - Con un prefijo *semantic_*, *coarse_*, *fine_*, se introducirán para el método `generate` del semántico, el grueso y el fino, respectivamente. Tienen prioridad sobre las palabras clave sin prefijo. Esto significa que, por ejemplo, puede especificar una estrategia de generación para todos los submodelos excepto uno.

return_output_lengths (`bool`, *opcional*) : Indica si se deben devolver o no las longitudes de la forma de onda. Útil al procesar por lotes.

**Devuelve:** `By default`

- **audio_waveform** (`torch.Tensor` de forma (batch_size, seq_len)): Forma de onda de audio generada.
Cuando `return_output_lengths=True`: devuelve una tupla compuesta por:
- **audio_waveform** (`torch.Tensor` de forma (batch_size, seq_len)): Forma de onda de audio generada.
- **output_lengths** (`torch.Tensor` de forma (batch_size)): La longitud de cada forma de onda en el lote

Genera audio a partir de un prompt de entrada y un prompt de orador de `Bark` adicional y opcional.

Ejemplo:

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/bark/modeling_bark.py#L1292)

**Parámetros:**

accelerator_id (`int`, *opcional*, valor predeterminado 0) : identificador del acelerador en el que se cargarán y descargarán los submodelos.

Descarga todos los submodelos a la CPU usando accelerate, reduciendo el uso de memoria con un bajo impacto en el rendimiento. Este método mueve un submodelo completo a la aceleradora a la vez cuando se utiliza, y el submodelo permanece en la aceleradora hasta que se ejecuta el siguiente submodelo.

## BarkSemanticModel[[transformers.BarkSemanticModel]]

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

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/bark/modeling_bark.py#L516)

**Parámetros:**

config (`BarkSubModelConfig`) : Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método [from_pretrained()](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

Modelo semántico (o de texto) de Bark. Comparte la misma arquitectura que el modelo grueso. Es un modelo autoregresivo similar a GPT-2 con una cabeza de modelado de lenguaje en la parte superior.

Este modelo hereda de [PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel). Consulte la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/bark/modeling_bark.py#L386)

**Parámetros:**

input_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada. Los índices se pueden obtener mediante [AutoTokenizer](/docs/transformers/v5.23.0/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para obtener más detalles. [¿Qué son los IDs de entrada?](../glossary#input-ids)

past_key_values (`~cache_utils.Cache`, *opcional*) : Estados ocultos precalculados (claves y valores en los bloques de autoatención y en los bloques de atención cruzada) que se pueden utilizar para acelerar la decodificación secuencial. Esto suele consistir en los `past_key_values` devueltos por el modelo en una etapa anterior de la decodificación, cuando `use_cache=True` o `config.use_cache=True`.  Solo se permite una instancia de [Cache](/docs/transformers/v5.23.0/es/internal/generation_utils#transformers.Cache) como entrada, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache). Si no se pasan `past_key_values`, se inicializará [DynamicCache](/docs/transformers/v5.23.0/es/internal/generation_utils#transformers.DynamicCache) de forma predeterminada.  El modelo devolverá el mismo formato de caché que se haya proporcionado como entrada.  Si se utilizan `past_key_values`, se espera que el usuario introduzca solo los `input_ids` no procesados (aquellos que no tienen sus estados de clave y valor previos dados a este modelo) con forma `(batch_size, unprocessed_length)` en lugar de todos los `input_ids` con forma `(batch_size, sequence_length)`.

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de la máscara seleccionados en `[0, 1]`:  - 1 para tokens que **no están enmascarados**, - 0 para tokens que **están enmascarados**.  [¿Qué son las máscaras de atención?](../glossary#attention-mask)

position_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de las posiciones de los tokens de cada secuencia de entrada en las incrustaciones de posición. Seleccionados en el rango `[0, config.n_positions - 1]`.  [¿Qué son los IDs de posición?](../glossary#position-ids)

labels (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Etiquetas para calcular la pérdida de modelado de lenguaje enmascarado. Los índices deben estar en `[0, ..., config.vocab_size]` o ser -100 (consulte la docstring de `input_ids`). Los tokens con índices fijados en `-100` se ignoran (se enmascaran); la pérdida solo se calcula para los tokens con etiquetas en `[0, ..., config.vocab_size]`.

inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, en lugar de pasar `input_ids`, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices de `input_ids` en los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo.

use_cache (`bool`, *opcional*) : Si se establece en `True`, se devuelven los estados de valores clave `past_key_values` y pueden usarse para acelerar la decodificación (ver `past_key_values`).

output_attentions (`bool`, *opcional*) : Indica si se deben devolver los tensores de atención de todas las capas de atención. Consulte `attentions` en los tensores devueltos para obtener más detalles.

output_hidden_states (`bool`, *opcional*) : Indica si se deben devolver los estados ocultos de todas las capas. Consulte `hidden_states` en los tensores devueltos para obtener más detalles.

return_dict (`bool`, *opcional*) : Indica si se debe devolver un [ModelOutput](/docs/transformers/v5.23.0/es/main_classes/output#transformers.utils.ModelOutput) en lugar de una tupla simple.

**Devuelve:** [CausalLMOutputWithPast](/docs/transformers/v5.23.0/es/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithPast) o `tuple(torch.Tensor)`

Un [CausalLMOutputWithPast](/docs/transformers/v5.23.0/es/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithPast) o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([BarkConfig](/docs/transformers/v5.23.0/es/model_doc/bark#transformers.BarkConfig)) y las entradas.

El método forward de [BarkCausalModel](/docs/transformers/v5.23.0/es/model_doc/bark#transformers.BarkCausalModel) sobrescribe el método especial `__call__`.

Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de `Module` después, en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de preprocesamiento y posprocesamiento, mientras que la segunda los ignora silenciosamente.

- **loss** (`torch.Tensor` de forma `(1,)`, *opcional*, se devuelve cuando se proporciona `labels`) -- Pérdida de modelado de lenguaje (para la predicción del siguiente token).
- **logits** (`torch.Tensor` de forma `(batch_size, sequence_length, config.vocab_size)`) -- Puntuaciones de predicción de la cabeza de modelado de lenguaje (puntuaciones para cada token del vocabulario antes de SoftMax).
- **past_key_values** (`Cache`, *opcional*, se devuelve cuando se pasa `use_cache=True` o cuando `config.use_cache=True`) -- Es una instancia de [Cache](/docs/transformers/v5.23.0/es/internal/generation_utils#transformers.Cache). Para más detalles, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache).

  Contiene estados ocultos precalculados (claves y valores en los bloques de autoatención) que pueden utilizarse (véase la entrada `past_key_values`) para acelerar la decodificación secuencial.
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de los embeddings, si el modelo tiene una capa de embedding, + una para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

## BarkCoarseModel[[transformers.BarkCoarseModel]]

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

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/bark/modeling_bark.py#L632)

**Parámetros:**

config (`BarkSubModelConfig`) : Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método [from_pretrained()](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

Modelo de acústica gruesa de Bark. Comparte la misma arquitectura que el modelo semántico (o de texto). Es un modelo autoregresivo similar a GPT-2 con una cabeza de modelado de lenguaje en la parte superior.

Este modelo hereda de [PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel). Consulte la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/bark/modeling_bark.py#L386)

**Parámetros:**

input_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada. Los índices se pueden obtener mediante [AutoTokenizer](/docs/transformers/v5.23.0/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para obtener más detalles. [¿Qué son los IDs de entrada?](../glossary#input-ids)

past_key_values (`~cache_utils.Cache`, *opcional*) : Estados ocultos precalculados (claves y valores en los bloques de autoatención y en los bloques de atención cruzada) que se pueden utilizar para acelerar la decodificación secuencial. Esto suele consistir en los `past_key_values` devueltos por el modelo en una etapa anterior de la decodificación, cuando `use_cache=True` o `config.use_cache=True`.  Solo se permite una instancia de [Cache](/docs/transformers/v5.23.0/es/internal/generation_utils#transformers.Cache) como entrada, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache). Si no se pasan `past_key_values`, se inicializará [DynamicCache](/docs/transformers/v5.23.0/es/internal/generation_utils#transformers.DynamicCache) de forma predeterminada.  El modelo devolverá el mismo formato de caché que se haya proporcionado como entrada.  Si se utilizan `past_key_values`, se espera que el usuario introduzca solo los `input_ids` no procesados (aquellos que no tienen sus estados de clave y valor previos dados a este modelo) con forma `(batch_size, unprocessed_length)` en lugar de todos los `input_ids` con forma `(batch_size, sequence_length)`.

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de la máscara seleccionados en `[0, 1]`:  - 1 para tokens que **no están enmascarados**, - 0 para tokens que **están enmascarados**.  [¿Qué son las máscaras de atención?](../glossary#attention-mask)

position_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de las posiciones de los tokens de cada secuencia de entrada en las incrustaciones de posición. Seleccionados en el rango `[0, config.n_positions - 1]`.  [¿Qué son los IDs de posición?](../glossary#position-ids)

labels (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Etiquetas para calcular la pérdida de modelado de lenguaje enmascarado. Los índices deben estar en `[0, ..., config.vocab_size]` o ser -100 (consulte la docstring de `input_ids`). Los tokens con índices fijados en `-100` se ignoran (se enmascaran); la pérdida solo se calcula para los tokens con etiquetas en `[0, ..., config.vocab_size]`.

inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, en lugar de pasar `input_ids`, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices de `input_ids` en los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo.

use_cache (`bool`, *opcional*) : Si se establece en `True`, se devuelven los estados de valores clave `past_key_values` y pueden usarse para acelerar la decodificación (ver `past_key_values`).

output_attentions (`bool`, *opcional*) : Indica si se deben devolver los tensores de atención de todas las capas de atención. Consulte `attentions` en los tensores devueltos para obtener más detalles.

output_hidden_states (`bool`, *opcional*) : Indica si se deben devolver los estados ocultos de todas las capas. Consulte `hidden_states` en los tensores devueltos para obtener más detalles.

return_dict (`bool`, *opcional*) : Indica si se debe devolver un [ModelOutput](/docs/transformers/v5.23.0/es/main_classes/output#transformers.utils.ModelOutput) en lugar de una tupla simple.

**Devuelve:** [CausalLMOutputWithPast](/docs/transformers/v5.23.0/es/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithPast) o `tuple(torch.Tensor)`

Un [CausalLMOutputWithPast](/docs/transformers/v5.23.0/es/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithPast) o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([BarkConfig](/docs/transformers/v5.23.0/es/model_doc/bark#transformers.BarkConfig)) y las entradas.

El método forward de [BarkCausalModel](/docs/transformers/v5.23.0/es/model_doc/bark#transformers.BarkCausalModel) sobrescribe el método especial `__call__`.

Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de `Module` después, en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de preprocesamiento y posprocesamiento, mientras que la segunda los ignora silenciosamente.

- **loss** (`torch.Tensor` de forma `(1,)`, *opcional*, se devuelve cuando se proporciona `labels`) -- Pérdida de modelado de lenguaje (para la predicción del siguiente token).
- **logits** (`torch.Tensor` de forma `(batch_size, sequence_length, config.vocab_size)`) -- Puntuaciones de predicción de la cabeza de modelado de lenguaje (puntuaciones para cada token del vocabulario antes de SoftMax).
- **past_key_values** (`Cache`, *opcional*, se devuelve cuando se pasa `use_cache=True` o cuando `config.use_cache=True`) -- Es una instancia de [Cache](/docs/transformers/v5.23.0/es/internal/generation_utils#transformers.Cache). Para más detalles, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache).

  Contiene estados ocultos precalculados (claves y valores en los bloques de autoatención) que pueden utilizarse (véase la entrada `past_key_values`) para acelerar la decodificación secuencial.
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de los embeddings, si el modelo tiene una capa de embedding, + una para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

## BarkFineModel[[transformers.BarkFineModel]]

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

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/bark/modeling_bark.py#L856)

**Parámetros:**

config ([BarkFineConfig](/docs/transformers/v5.23.0/es/model_doc/bark#transformers.BarkFineConfig)) : Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método [from_pretrained()](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

Modelo de acústica fina de Bark. Es un modelo no causal similar a GPT con `config.n_codes_total` capas de incrustación y cabezas de modelado de lenguaje, una para cada libro de códigos.

Este modelo hereda de [PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel). Consulte la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/bark/modeling_bark.py#L983)

**Parámetros:**

codebook_idx (`int`) : Índice del codebook que se predecirá.

input_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada. Los índices se pueden obtener mediante [AutoTokenizer](/docs/transformers/v5.23.0/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para obtener más detalles. [¿Qué son los IDs de entrada?](../glossary#input-ids)

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de la máscara seleccionados en `[0, 1]`:  - 1 para tokens que **no están enmascarados**, - 0 para tokens que **están enmascarados**.  [¿Qué son las máscaras de atención?](../glossary#attention-mask)

position_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de las posiciones de los tokens de cada secuencia de entrada en las incrustaciones de posición. Seleccionados en el rango `[0, config.n_positions - 1]`.  [¿Qué son los IDs de posición?](../glossary#position-ids)

labels (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : AÚN NO IMPLEMENTADO.

inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, en lugar de pasar `input_ids`, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices de `input_ids` en los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo.

output_attentions (`bool`, *opcional*) : Indica si se deben devolver los tensores de atención de todas las capas de atención. Consulte `attentions` en los tensores devueltos para obtener más detalles.

output_hidden_states (`bool`, *opcional*) : Indica si se deben devolver los estados ocultos de todas las capas. Consulte `hidden_states` en los tensores devueltos para obtener más detalles.

return_dict (`bool`, *opcional*) : Indica si se debe devolver un [ModelOutput](/docs/transformers/v5.23.0/es/main_classes/output#transformers.utils.ModelOutput) en lugar de una tupla simple.

**Devuelve:** [MaskedLMOutput](/docs/transformers/v5.23.0/es/main_classes/output#transformers.modeling_outputs.MaskedLMOutput) o `tuple(torch.Tensor)`

Un [MaskedLMOutput](/docs/transformers/v5.23.0/es/main_classes/output#transformers.modeling_outputs.MaskedLMOutput) o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([BarkConfig](/docs/transformers/v5.23.0/es/model_doc/bark#transformers.BarkConfig)) y las entradas.

El método forward de [BarkFineModel](/docs/transformers/v5.23.0/es/model_doc/bark#transformers.BarkFineModel) reemplaza el método especial `__call__`.

Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de `Module` después, en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de preprocesamiento y posprocesamiento, mientras que la segunda los ignora silenciosamente.

- **loss** (`torch.Tensor` de forma `(1,)`, *opcional*, se devuelve cuando se proporciona `labels`) -- Pérdida de modelado de lenguaje enmascarado (MLM).
- **logits** (`torch.Tensor` de forma `(batch_size, sequence_length, config.vocab_size)`) -- Puntuaciones de predicción de la cabeza de modelado de lenguaje (puntuaciones para cada token del vocabulario antes de SoftMax).
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de los embeddings, si el modelo tiene una capa de embedding, + una para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

## BarkCausalModel[[transformers.BarkCausalModel]]

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

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/bark/modeling_bark.py#L351)

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/bark/modeling_bark.py#L386)

**Parámetros:**

input_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada. Los índices se pueden obtener mediante [AutoTokenizer](/docs/transformers/v5.23.0/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para obtener más detalles. [¿Qué son los IDs de entrada?](../glossary#input-ids)

past_key_values (`~cache_utils.Cache`, *opcional*) : Estados ocultos precalculados (claves y valores en los bloques de autoatención y en los bloques de atención cruzada) que se pueden utilizar para acelerar la decodificación secuencial. Esto suele consistir en los `past_key_values` devueltos por el modelo en una etapa anterior de la decodificación, cuando `use_cache=True` o `config.use_cache=True`.  Solo se permite una instancia de [Cache](/docs/transformers/v5.23.0/es/internal/generation_utils#transformers.Cache) como entrada, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache). Si no se pasan `past_key_values`, se inicializará [DynamicCache](/docs/transformers/v5.23.0/es/internal/generation_utils#transformers.DynamicCache) de forma predeterminada.  El modelo devolverá el mismo formato de caché que se haya proporcionado como entrada.  Si se utilizan `past_key_values`, se espera que el usuario introduzca solo los `input_ids` no procesados (aquellos que no tienen sus estados de clave y valor previos dados a este modelo) con forma `(batch_size, unprocessed_length)` en lugar de todos los `input_ids` con forma `(batch_size, sequence_length)`.

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de la máscara seleccionados en `[0, 1]`:  - 1 para tokens que **no están enmascarados**, - 0 para tokens que **están enmascarados**.  [¿Qué son las máscaras de atención?](../glossary#attention-mask)

position_ids (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de las posiciones de los tokens de cada secuencia de entrada en las incrustaciones de posición. Seleccionados en el rango `[0, config.n_positions - 1]`.  [¿Qué son los IDs de posición?](../glossary#position-ids)

labels (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Etiquetas para calcular la pérdida de modelado de lenguaje enmascarado. Los índices deben estar en `[0, ..., config.vocab_size]` o ser -100 (consulte la docstring de `input_ids`). Los tokens con índices fijados en `-100` se ignoran (se enmascaran); la pérdida solo se calcula para los tokens con etiquetas en `[0, ..., config.vocab_size]`.

inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, en lugar de pasar `input_ids`, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices de `input_ids` en los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo.

use_cache (`bool`, *opcional*) : Si se establece en `True`, se devuelven los estados de valores clave `past_key_values` y pueden usarse para acelerar la decodificación (ver `past_key_values`).

output_attentions (`bool`, *opcional*) : Indica si se deben devolver los tensores de atención de todas las capas de atención. Consulte `attentions` en los tensores devueltos para obtener más detalles.

output_hidden_states (`bool`, *opcional*) : Indica si se deben devolver los estados ocultos de todas las capas. Consulte `hidden_states` en los tensores devueltos para obtener más detalles.

return_dict (`bool`, *opcional*) : Indica si se debe devolver un [ModelOutput](/docs/transformers/v5.23.0/es/main_classes/output#transformers.utils.ModelOutput) en lugar de una tupla simple.

**Devuelve:** [CausalLMOutputWithPast](/docs/transformers/v5.23.0/es/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithPast) o `tuple(torch.Tensor)`

Un [CausalLMOutputWithPast](/docs/transformers/v5.23.0/es/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithPast) o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([BarkConfig](/docs/transformers/v5.23.0/es/model_doc/bark#transformers.BarkConfig)) y las entradas.

El método forward de [BarkCausalModel](/docs/transformers/v5.23.0/es/model_doc/bark#transformers.BarkCausalModel) sobrescribe el método especial `__call__`.

Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de `Module` después, en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de preprocesamiento y posprocesamiento, mientras que la segunda los ignora silenciosamente.

- **loss** (`torch.Tensor` de forma `(1,)`, *opcional*, se devuelve cuando se proporciona `labels`) -- Pérdida de modelado de lenguaje (para la predicción del siguiente token).
- **logits** (`torch.Tensor` de forma `(batch_size, sequence_length, config.vocab_size)`) -- Puntuaciones de predicción de la cabeza de modelado de lenguaje (puntuaciones para cada token del vocabulario antes de SoftMax).
- **past_key_values** (`Cache`, *opcional*, se devuelve cuando se pasa `use_cache=True` o cuando `config.use_cache=True`) -- Es una instancia de [Cache](/docs/transformers/v5.23.0/es/internal/generation_utils#transformers.Cache). Para más detalles, consulte nuestra [guía de caché kv](https://huggingface.co/docs/transformers/en/kv_cache).

  Contiene estados ocultos precalculados (claves y valores en los bloques de autoatención) que pueden utilizarse (véase la entrada `past_key_values`) para acelerar la decodificación secuencial.
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de los embeddings, si el modelo tiene una capa de embedding, + una para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`.

  Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
- **attentions** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

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

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

**Parámetros:**

block_size (`int`, *opcional*, valor predeterminado 1024) : La longitud máxima de secuencia con la que podría utilizarse este modelo. Por lo general, se establece en un valor grande por si acaso (p. ej., 512, 1024 o 2048).

input_vocab_size (`int`, *opcional*, valor predeterminado 10_048) : Tamaño del vocabulario de un submodelo de Bark. Define el número de tokens diferentes que pueden representarse mediante los `inputs_ids` que se pasan al llamar a `{model}`. El valor predeterminado es 10_048, pero debe elegirse con cuidado en función del submodelo seleccionado.

output_vocab_size (`int`, *opcional*, valor predeterminado 10_048) : Tamaño del vocabulario de salida de un submodelo de Bark. Define el número de tokens diferentes que pueden representarse con `output_ids` al pasar un `{model}` hacia adelante. El valor predeterminado es 10_048, pero debe elegirse con cuidado en función del submodelo seleccionado.

num_layers (`int`, *opcional*, valor predeterminado `12`) : Número de capas ocultas en el decodificador del Transformer.

num_heads (`int`, *opcional*, valor predeterminado `12`) : Número de cabezas de atención para cada capa de atención en el decodificador Transformer.

hidden_size (`int`, *opcional*, valor predeterminado `768`) : Dimensión de las representaciones ocultas.

dropout (`Union[float, int]`, *opcional*, valor predeterminado `0.0`) : La proporción para todas las capas de dropout.

bias (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe usar sesgo en las capas lineales y en las capas de normalización por capa

initializer_range (`float`, *opcional*, valor predeterminado `0.02`) : La desviación estándar de truncated_normal_initializer para inicializar todas las matrices de pesos.

use_cache (`bool`, *opcional*, valor predeterminado `True`) : Indica si el modelo debe devolver las últimas atenciones de claves/valores (no se utiliza en todos los modelos). Solo es relevante si `config.is_decoder=True` o cuando el modelo es un modelo generativo solo de decodificador.

Esta es la clase de configuración para almacenar la configuración de un BarkModel. Se utiliza para instanciar un modelo Bark según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de [suno/bark](https://huggingface.co/suno/bark)

Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) y se pueden utilizar para controlar las salidas del modelo. Consulte la documentación de [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información.

Ejemplo:

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

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

**Parámetros:**

block_size (`int`, *opcional*, valor predeterminado 1024) : La longitud máxima de secuencia con la que podría utilizarse este modelo. Por lo general, se establece en un valor grande por si acaso (p. ej., 512, 1024 o 2048).

input_vocab_size (`int`, *opcional*, valor predeterminado 10_048) : Tamaño del vocabulario de un submodelo de Bark. Define el número de tokens diferentes que pueden representarse mediante los `inputs_ids` que se pasan al llamar a `{model}`. El valor predeterminado es 10_048, pero debe elegirse con cuidado en función del submodelo seleccionado.

output_vocab_size (`int`, *opcional*, valor predeterminado 10_048) : Tamaño del vocabulario de salida de un submodelo de Bark. Define el número de tokens diferentes que pueden representarse con `output_ids` al pasar un `{model}` hacia adelante. El valor predeterminado es 10_048, pero debe elegirse con cuidado en función del submodelo seleccionado.

num_layers (`int`, *opcional*, valor predeterminado `12`) : Número de capas ocultas en el decodificador del Transformer.

num_heads (`int`, *opcional*, valor predeterminado `12`) : Número de cabezas de atención para cada capa de atención en el decodificador Transformer.

hidden_size (`int`, *opcional*, valor predeterminado `768`) : Dimensión de las representaciones ocultas.

dropout (`Union[float, int]`, *opcional*, valor predeterminado `0.0`) : La proporción para todas las capas de dropout.

bias (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe usar sesgo en las capas lineales y en las capas de normalización por capa

initializer_range (`float`, *opcional*, valor predeterminado `0.02`) : La desviación estándar de truncated_normal_initializer para inicializar todas las matrices de pesos.

use_cache (`bool`, *opcional*, valor predeterminado `True`) : Indica si el modelo debe devolver las últimas atenciones de claves/valores (no se utiliza en todos los modelos). Solo es relevante si `config.is_decoder=True` o cuando el modelo es un modelo generativo solo de decodificador.

tie_word_embeddings (`bool`, *opcional*, valor predeterminado `True`) : Indica si se deben vincular las incrustaciones de pesos según el mapeo `tied_weights_keys` del modelo.

n_codes_total (`int`, *opcional*, valor predeterminado: 8) : El número total de libros de códigos de audio predichos. Se utiliza en el submodelo de acústica fina.

n_codes_given (`int`, *opcional*, valor predeterminado: 1) : El número de libros de códigos de audio predichos en el submodelo de acústica gruesa. Se utiliza en los submodelos de acústica.

Esta es la clase de configuración para almacenar la configuración de un BarkModel. Se utiliza para instanciar un modelo Bark según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de [suno/bark](https://huggingface.co/suno/bark)

Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) y se pueden utilizar para controlar las salidas del modelo. Consulte la documentación de [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información.

Ejemplo:

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

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

**Parámetros:**

block_size (`int`, *opcional*, valor predeterminado 1024) : La longitud máxima de secuencia con la que podría utilizarse este modelo. Por lo general, se establece en un valor grande por si acaso (p. ej., 512, 1024 o 2048).

input_vocab_size (`int`, *opcional*, valor predeterminado 10_048) : Tamaño del vocabulario de un submodelo de Bark. Define el número de tokens diferentes que pueden representarse mediante los `inputs_ids` que se pasan al llamar a `{model}`. El valor predeterminado es 10_048, pero debe elegirse con cuidado en función del submodelo seleccionado.

output_vocab_size (`int`, *opcional*, valor predeterminado 10_048) : Tamaño del vocabulario de salida de un submodelo de Bark. Define el número de tokens diferentes que pueden representarse con `output_ids` al pasar un `{model}` hacia adelante. El valor predeterminado es 10_048, pero debe elegirse con cuidado en función del submodelo seleccionado.

num_layers (`int`, *opcional*, valor predeterminado `12`) : Número de capas ocultas en el decodificador del Transformer.

num_heads (`int`, *opcional*, valor predeterminado `12`) : Número de cabezas de atención para cada capa de atención en el decodificador Transformer.

hidden_size (`int`, *opcional*, valor predeterminado `768`) : Dimensión de las representaciones ocultas.

dropout (`Union[float, int]`, *opcional*, valor predeterminado `0.0`) : La proporción para todas las capas de dropout.

bias (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe usar sesgo en las capas lineales y en las capas de normalización por capa

initializer_range (`float`, *opcional*, valor predeterminado `0.02`) : La desviación estándar de truncated_normal_initializer para inicializar todas las matrices de pesos.

use_cache (`bool`, *opcional*, valor predeterminado `True`) : Indica si el modelo debe devolver las últimas atenciones de claves/valores (no se utiliza en todos los modelos). Solo es relevante si `config.is_decoder=True` o cuando el modelo es un modelo generativo solo de decodificador.

Esta es la clase de configuración para almacenar la configuración de un BarkModel. Se utiliza para instanciar un modelo Bark según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de [suno/bark](https://huggingface.co/suno/bark)

Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) y se pueden utilizar para controlar las salidas del modelo. Consulte la documentación de [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información.

Ejemplo:

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

