# VibeVoice

## Resumen

[VibeVoice](https://huggingface.co/papers/2508.19205) es un marco novedoso para sintetizar audio de alta fidelidad y de larga duración con múltiples hablantes, empleando un enfoque de difusión de próximo token dentro de una estructura de modelo de lenguaje de gran escala (LLM). Está diseñado para capturar la auténtica "vibe" conversacional y es especialmente adecuado para generar contenido de audio como podcasts y audiolibros con múltiples participantes.

Hay dos puntos de control de modelos disponibles en:
- [vibevoice/VibeVoice-1.5B-hf](https://huggingface.co/vibevoice/VibeVoice-1.5B-hf)
- [vibevoice/VibeVoice-7B-hf](https://huggingface.co/vibevoice/VibeVoice-7B-hf)

Este modelo fue aportado por [Eric Bezzam](https://huggingface.co/bezzam).

## Arquitectura

    

El marco de trabajo VibeVoice integra tres componentes clave:
1. **Tokenizadores de voz continuos:** Tokenizadores [acústicos](./vibevoice_acoustic_tokenizer) y semánticos especializados, donde el tokenizador acústico utiliza un $\sigma$-VAE para lograr una compresión ultrabaja (7,5 tokens/seg, 3200x) para la escalabilidad y la fidelidad, y el tokenizador semántico utiliza una tarea proxy de ASR para la extracción de características centrada en el contenido.
2. **Modelo de lenguaje de gran escala (LLM):** Utiliza Qwen2.5 (en versiones de 1.5B y 7B) como su modelo de secuencia principal.
3. **Cabeza de difusión a nivel de token:** condicionada al estado oculto del LLM y responsable de predecir las características continuas del VAE de forma en streaming.

El checkpoint original de VibeVoice-1.5B está disponible bajo la organización [Microsoft](https://huggingface.co/microsoft/VibeVoice-1.5B) en Hugging Face.

## Características principales

- **Síntesis de formato largo**: Puede sintetizar hasta 90 minutos de conversación hablada con múltiples hablantes.
- **Diálogo de varios hablantes**: Capaz de sintetizar audio con un máximo de 4 hablantes.
- **Calidad de vanguardia**: Supera a las líneas base en métricas tanto subjetivas como objetivas.
- **Alta compresión**: Lograda mediante un tokenizador acústico novedoso que opera a una tasa de fotogramas ultrabaja de 7,5 Hz.
- **LLM escalable**: Escalar el LLM central de 1.5B a 7B mejora significativamente la calidad perceptual.

## Uso

### Configuración 

Se necesita un programador de ruido, ya que la generación de audio se basa en un proceso de difusión. El enfoque más sencillo (y el utilizado por los desarrolladores del modelo) es emplear un programador de ruido de la biblioteca `diffusers`. De forma predeterminada, el modelo creará internamente un programador de ruido con `diffusers`.
```
pip install diffusers
pip install soundfile   # for saving audio
```

### Carga del modelo

```python
from transformers import AutoProcessor, AutoModelForTextToWaveform

model_id = "vibevoice/VibeVoice-1.5B-hf"  # "vibevoice/VibeVoice-7B-hf"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForTextToWaveform.from_pretrained(model_id)
```

### Texto a voz (TTS)

```python
import os
from transformers import AutoProcessor, AutoModelForTextToWaveform

model_id = "vibevoice/VibeVoice-1.5B-hf"   # "vibevoice/VibeVoice-7B-hf"
text = "Hello, nice to meet you. How are you?"

# Load model
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForTextToWaveform.from_pretrained(model_id, device_map="auto")

# Prepare input
conversation = [{"role": "0", "content": [{"type": "text", "text": text}]}]
inputs = processor.apply_chat_template(
    conversation, return_dict=True, tokenize=True, add_generation_prompt=True,
).to(model.device, model.dtype)

# Generate!
audio = model.generate(**inputs)

# Save to file
file_name = f"{os.path.basename(model_id)}_tts.wav"
processor.save_audio(audio, file_name)
print(f"Saved output to {file_name}")
```

### Clonación de voz TTS

Se puede clonar una voz proporcionando un audio de referencia junto con el texto dentro del diccionario de la plantilla de chat.

```python
import os
from transformers import AutoProcessor, AutoModelForTextToWaveform, set_seed

model_id = "vibevoice/VibeVoice-1.5B-hf"   # "vibevoice/VibeVoice-7B-hf"
text = "Hello, nice to meet you. How are you?"
set_seed(42)  # for deterministic results

# Load model
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForTextToWaveform.from_pretrained(model_id, device_map="auto")
sampling_rate = processor.feature_extractor.sampling_rate

# Prepare input
conversation = [
    {
        "role": "0",
        "content": [
            {"type": "text", "text": text},
            {
                "type": "audio",
                "url": "https://huggingface.co/datasets/bezzam/vibevoice_samples/resolve/main/voices/en-Alice_woman.wav",
            },
        ],
    }
]
inputs = processor.apply_chat_template(
    conversation, return_dict=True, tokenize=True, add_generation_prompt=True,
).to(model.device, model.dtype)

# Generate!
audio = model.generate(**inputs)

# Save to file
fn = f"{os.path.basename(model_id)}_tts_clone.wav"
processor.save_audio(audio, fn)
print(f"Saved output to {fn}")
```

### Generar un podcast a partir de un guion

A continuación se muestra un ejemplo para generar una conversación entre dos hablantes, cuyas voces se clonan proporcionando un audio de referencia para cada ID de rol único en la plantilla de chat.

El ejemplo anterior también utilizó la opción `monitor_progress` para seguir el progreso de la generación.

```python
import os
import time
from transformers import AutoProcessor, AutoModelForTextToWaveform

model_id = "vibevoice/VibeVoice-1.5B-hf"   # "vibevoice/VibeVoice-7B-hf"
max_new_tokens = 400  # `None` to ensure full generation

# create conversation with an audio for the first time a speaker appears to clone that particular voice
conversation = [
    {
        "role": "0",
        "content": [
            {
                "type": "text", "text": "Hello everyone, and welcome to the VibeVoice podcast. I'm your host, Linda, and today we're getting into one of the biggest debates in all of sports: who's the greatest basketball player of all time? I'm so excited to have Thomas here to talk about it with me.",
            },
            {
                "type": "audio", "url": "https://huggingface.co/datasets/bezzam/vibevoice_samples/resolve/main/voices/en-Alice_woman.wav",
            },
        ],
    },
    {
        "role": "1",
        "content": [
            {
                "type": "text", "text": "Thanks so much for having me, Linda. You're absolutely right—this question always brings out some seriously strong feelings.",
            },
            {
                "type": "audio", "url": "https://huggingface.co/datasets/bezzam/vibevoice_samples/resolve/main/voices/en-Frank_man.wav",
            },
        ],
    },
    {
        "role": "0",
        "content": [
            {
                "type": "text", "text": "Okay, so let's get right into it. For me, it has to be Michael Jordan. Six trips to the Finals, six championships. That kind of perfection is just incredible.",
            },
        ],
    },
    {
        "role": "1",
        "content": [
            {
                "type": "text", "text": "Oh man, the first thing that always pops into my head is that shot against the Cleveland Cavaliers back in '89. Jordan just rises, hangs in the air forever, and just sinks it",
            },
        ],
    },
]

# Load model
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForTextToWaveform.from_pretrained(model_id, device_map="auto")

# prepare inputs
inputs = processor.apply_chat_template(
    conversation, return_dict=True, tokenize=True, add_generation_prompt=True,
).to(model.device, model.dtype)

# Generate audio with a progress bar to track generation
model.generation_config.max_new_tokens = max_new_tokens
start_time = time.time()
audio = model.generate(**inputs, monitor_progress=True)
generation_time = time.time() - start_time
print(f"Generation time: {generation_time:.2f} seconds")

# Save audio
fn = f"{os.path.basename(model_id)}_script.wav"
processor.save_audio(audio, fn)
print(f"Saved output to {fn}")
```

### Inferencia por lotes

Para el procesamiento por lotes, se puede pasar una lista de conversaciones a `processor.apply_chat_template`:

```python
import os
import time
from transformers import AutoProcessor, AutoModelForTextToWaveform

model_id = "vibevoice/VibeVoice-1.5B-hf"   # "vibevoice/VibeVoice-7B-hf"
max_new_tokens = 400  # `None` to ensure full generation

conversation = [
    [
        {
            "role": "0",
            "content": [
                {
                    "type": "text", "text": "Hello everyone, and welcome to the VibeVoice podcast. I'm your host, Linda, and today we're getting into one of the biggest debates in all of sports: who's the greatest basketball player of all time? I'm so excited to have Thomas here to talk about it with me.",
                },
                {
                    "type": "audio",
                    "url": "https://huggingface.co/datasets/bezzam/vibevoice_samples/resolve/main/voices/en-Alice_woman.wav",
                },
            ],
        },
        {
            "role": "1",
            "content": [
                {
                    "type": "text", "text": "Thanks so much for having me, Linda.",
                },
                {
                    "type": "audio", "url": "https://huggingface.co/datasets/bezzam/vibevoice_samples/resolve/main/voices/en-Frank_man.wav",
                },
            ],
        },
    ],
    [
        {
            "role": "0",
            "content": [
                {
                    "type": "text", "text": "Hello and welcome to Planet in Peril. I'm your host, Alice. We're here today to discuss a really sobering new report that looks back at the last ten years of climate change. I'm joined by our expert panel. Welcome Carter, Frank, and Maya.",
                },
                {
                    "type": "audio", "url": "https://huggingface.co/datasets/bezzam/vibevoice_samples/resolve/main/voices/en-Alice_woman.wav",
                },
            ],
        },
        {
            "role": "1",
            "content": [
                {"type": "text", "text": "Hi Alice, it's great to be here. I'm Carter."},
                {
                    "type": "audio", "url": "https://huggingface.co/datasets/bezzam/vibevoice_samples/resolve/main/voices/en-Carter_man.wav",
                },
            ],
        },
        {
            "role": "2",
            "content": [
                {"type": "text", "text": "Hello, uh, I'm Frank. Good to be on."},
                {
                    "type": "audio", "url": "https://huggingface.co/datasets/bezzam/vibevoice_samples/resolve/main/voices/en-Frank_man.wav",
                },
            ],
        },
        {
            "role": "3",
            "content": [
                {"type": "text", "text": "And I'm Maya. Thanks for having me."},
                {
                    "type": "audio", "url": "https://huggingface.co/datasets/bezzam/vibevoice_samples/resolve/main/voices/en-Maya_woman.wav",
                },
            ],
        },
    ],
]

# Load model
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForTextToWaveform.from_pretrained(model_id, device_map="auto")

# prepare inputs
inputs = processor.apply_chat_template(
    conversation, return_dict=True, tokenize=True, add_generation_prompt=True,
).to(model.device, model.dtype)

# Generate audio with a progress bar to track generation
model.generation_config.max_new_tokens = max_new_tokens
start_time = time.time()
audio = model.generate(**inputs, monitor_progress=True)
generation_time = time.time() - start_time
print(f"Generation time: {generation_time:.2f} seconds")

# Save audio
output_dir = f"{os.path.basename(model_id)}_batch"
processor.save_audio(audio, output_dir)
print(f"Saved output to {output_dir}")
```

### Uso de Pipeline

VibeVoice también se puede cargar como un pipeline. A continuación, mostramos cómo se pueden ajustar los parámetros de difusión.

```python
import os
import soundfile as sf
from transformers import pipeline

model_id = "vibevoice/VibeVoice-1.5B-hf"   # "vibevoice/VibeVoice-7B-hf"
text = "Hello, nice to meet you. How are you?"
pipe = pipeline("text-to-speech", model=model_id)

# Generate!
conversation = [
    {
        "role": "0",
        "content": [
            {"type": "text", "text": text},
            {
                "type": "audio", "url": "https://huggingface.co/datasets/bezzam/vibevoice_samples/resolve/main/voices/en-Alice_woman.wav",
            },
        ],
    }
]
# optional kwargs for generation
generate_kwargs = {"guidance_scale": 1.3, "num_diffusion_steps": 10}
output = pipe(conversation, generate_kwargs=generate_kwargs)

# Save to file
fn = f"{os.path.basename(model_id)}_pipeline.wav"
sf.write(fn, output["audio"], output["sampling_rate"])
print(f"Saved output to {fn}")
```

### Entrenamiento

VibeVoice se puede entrenar con la pérdida emitida por el modelo.

```python
from transformers import AutoProcessor, AutoModelForTextToWaveform

model_id = "vibevoice/VibeVoice-1.5B-hf"   # "vibevoice/VibeVoice-7B-hf"

# Load model and processor
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForTextToWaveform.from_pretrained(
    model_id,
    diffusion_loss_weight=0.75,  # by default, equal weighting (0.5) of language modeling loss (CE) and diffusion loss is applied
    device_map="auto"
)
model.train()

# Prepare batch of 2
conversation = [
    [
        {
            "role": "0",
            "content": [
                {
                    "type": "text", "text": "VibeVoice is this novel framework designed for generating expressive, long-form, multi-speaker, conversational audio.",
                },
                {
                    "type": "audio", "url": "https://huggingface.co/datasets/bezzam/vibevoice_samples/resolve/main/realtime_model/vibevoice_tts_german.wav",
                },
            ],
        }
    ],
    # NOTE: multiple speakers not supported yet
    [
        {
            "role": "0",
            "content": [
                {
                    "type": "text", "text": "Hello everyone and welcome to the VibeVoice podcast. I'm your host, Alex, and today we're getting into one of the biggest debates in all of sports: who's the greatest basketball player of all time? I'm so excited to have Sam here to talk about it with me. Thanks so much for having me, Alex. And you're absolutely right. This question always brings out some seriously strong feelings. Okay, so let's get right into it. For me, it has to be Michael Jordan. Six trips to the finals, six championships. That kind of perfection is just incredible. Oh man, the first thing that always pops into my head is that shot against the Cleveland Cavaliers back in '89. Jordan just rises, hangs in the air forever, and just sinks it.",
                },
                {
                    "type": "audio",
                    "url": "https://huggingface.co/datasets/bezzam/vibevoice_samples/resolve/main/example_output/VibeVoice-1.5B_output.wav",
                },
            ],
        }
    ],
]

# Process with apply_chat_template and output_labels=True for training
inputs = processor.apply_chat_template(
    conversation,
    tokenize=True,
    return_dict=True,
    processor_kwargs={"output_labels": True},
).to(model.device, model.dtype)

# Forward pass
outputs = model(**inputs, ddpm_batch_multiplier=2, num_diffusion_steps=2)
print(f"Total loss: {outputs.loss.item():.4f}")

# Backward pass
outputs.loss.backward()
```

### Torch compile

El modelo se puede compilar con `torch.compile` para una inferencia más rápida. Se necesitan algunas ejecuciones de calentamiento antes de que el modelo compilado alcance su velocidad máxima.

En una A100 con un tamaño de lote de 4, observamos una aceleración de aproximadamente 1,5x entre la inferencia compilada y la no compilada, consulte [este script](https://gist.github.com/ebezzam/c45b9fdee65f3029e17d566e30c59399).

```python
import os
import time
import torch
from transformers import AutoModelForTextToWaveform, AutoProcessor, CompileConfig

model_id = "vibevoice/VibeVoice-1.5B-hf"   # "vibevoice/VibeVoice-7B-hf"
num_warmup = 5
max_new_tokens = 128

torch.set_float32_matmul_precision("high")

# Load processor + model
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForTextToWaveform.from_pretrained(model_id, dtype=torch.bfloat16, device_map="auto").eval()

# Prepare inputs
conversation = [
    [
        {
            "role": "0",
            "content": [
                {"type": "text", "text": "VibeVoice is a novel framework for generating expressive audio."},
                {
                    "type": "audio", "url": "https://huggingface.co/datasets/bezzam/vibevoice_samples/resolve/main/realtime_model/vibevoice_tts_german.wav",
                },
            ],
        }
    ],
] * 4  # batch size 4
inputs = processor.apply_chat_template(
    conversation, tokenize=True, return_dict=True, add_generation_prompt=True,
).to(model.device, model.dtype)

compile_config = CompileConfig(mode="default", dynamic=False)

generate_kwargs = dict(
    **inputs,
    max_new_tokens=max_new_tokens,
    cache_implementation="static",
    compile_config=compile_config,
)

# Warmup
print("Warming up...")
warmup_start = time.time()
with torch.inference_mode():
    for _ in range(num_warmup):
        torch.compiler.cudagraph_mark_step_begin()
        _ = model.generate(**generate_kwargs)
torch.cuda.synchronize()
print(f"Warmup complete in {time.time() - warmup_start:.2f}s. Ready!")

# Apply model
with torch.inference_mode():
    torch.compiler.cudagraph_mark_step_begin()
    audio = model.generate(**generate_kwargs)
output_folder = f"{os.path.basename(model_id)}_compiled_output"
processor.save_audio(audio, output_folder)
print(f"Saved output to {output_folder}")
```

## VibeVoiceConfig[[transformers.VibeVoiceConfig]]

#### transformers.VibeVoiceConfig[[transformers.VibeVoiceConfig]]

```python
transformers.VibeVoiceConfig(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, audio_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, semantic_model_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, text_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, diffusion_head_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, pad_token_id: int = 151643, eos_token_id: int = 151643, audio_bos_token_id: int = 151652, audio_eos_token_id: int = 151653, audio_token_id: int = 151654, diffusion_loss_weight: float = 0.5)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vibevoice/configuration_vibevoice.py#L49)

**Parámetros:**

audio_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *opcional*) : El objeto de configuración o el diccionario del backbone de audio.

semantic_model_config (`Union[AutoConfig, dict]`, *opcional*) : El objeto de configuración o el diccionario del codificador del tokenizador semántico. Este tokenizador extrae características semánticas del audio.

text_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *opcional*) : El objeto de configuración o el diccionario del backbone de texto.

diffusion_head_config (`Union[VibeVoiceDiffusionHeadConfig, dict]`, *opcional*) : El objeto de configuración o diccionario de la cabeza de difusión utilizada para sintetizar latentes acústicos.

pad_token_id (`int`, *opcional*, valor predeterminado `151643`) : Id del token utilizado para el relleno en el vocabulario.

eos_token_id (`int`, *opcional*, valor predeterminado `151643`) : Id del token utilizado para el fin de la secuencia en el vocabulario.

audio_bos_token_id (`int`, *opcional*, valor predeterminado 151652) : El ID de token que indica el inicio de los tokens de audio.

audio_eos_token_id (`int`, *opcional*, valor predeterminado 151653) : El ID de token que indica el final de los tokens de audio.

audio_token_id (`int`, *opcional*, valor predeterminado `151654`) : El índice del token de audio utilizado como marcador de posición para el audio de entrada.

diffusion_loss_weight (`float`, *opcional*, valor predeterminado 0.5) : El peso de la pérdida de difusión en el cálculo de la pérdida total. La pérdida de entropía cruzada para la cabeza de modelado de lenguaje se pondera con `(1 - diffusion_loss_weight)`.

Esta es la clase de configuración para almacenar la configuración de un VibeVoiceForConditionalGeneration. Se utiliza para instanciar un modelo Vibevoice 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 [vibevoice/VibeVoice-1.5B-hf](https://huggingface.co/vibevoice/VibeVoice-1.5B-hf)

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

```python
>>> from transformers import VibeVoiceForConditionalGeneration, VibeVoiceConfig

>>> # Initializing a VibeVoice configuration
>>> configuration = VibeVoiceConfig()

>>> # Initializing a 1.5B model with random weights
>>> model = VibeVoiceForConditionalGeneration(configuration)

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

## VibeVoiceDiffusionHeadConfig[[transformers.VibeVoiceDiffusionHeadConfig]]

#### transformers.VibeVoiceDiffusionHeadConfig[[transformers.VibeVoiceDiffusionHeadConfig]]

```python
transformers.VibeVoiceDiffusionHeadConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, hidden_size: int = 1536, latent_size: int = 64, num_hidden_layers: int = 4, intermediate_size: int = 4608, rms_norm_eps: float = 1e-05, hidden_act: str = 'silu', frequency_embedding_size: int = 256, diffusion_max_period: int = 10000, mlp_bias: bool = False)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vibevoice/configuration_vibevoice.py#L24)

**Parámetros:**

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

latent_size (`int`, *opcional*, valor predeterminado 64) : Dimensionalidad de los latentes acústicos que el head desruidiza.

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

intermediate_size (`int`, *opcional*, valor predeterminado `4608`) : Dimensión de las representaciones del MLP.

rms_norm_eps (`float`, *opcional*, valor predeterminado `1e-05`) : El epsilon utilizado por las capas de normalización rms.

hidden_act (`str`, *opcional*, valor predeterminado `silu`) : La función de activación no lineal (función o cadena) en el decodificador. Por ejemplo, `"gelu"`, `"relu"`, `"silu"`, etc.

frequency_embedding_size (`int`, *opcional*, valor predeterminado 256) : El tamaño de la incrustación de frecuencia sinusoidal para la codificación del paso de tiempo en la cabeza de difusión.

diffusion_max_period (`int`, *opcional*, valor predeterminado 10000) : El período máximo para el incrustado de frecuencia sinusoidal en la cabeza de difusión.

mlp_bias (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe usar un sesgo en las capas up_proj, down_proj y gate_proj de las capas MLP.

Esta es la clase de configuración para almacenar la configuración de un VibeVoiceForConditionalGeneration. Se utiliza para instanciar un modelo Vibevoice 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 [vibevoice/VibeVoice-1.5B-hf](https://huggingface.co/vibevoice/VibeVoice-1.5B-hf)

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

## VibeVoiceProcessor[[transformers.VibeVoiceProcessor]]

#### transformers.VibeVoiceProcessor[[transformers.VibeVoiceProcessor]]

```python
transformers.VibeVoiceProcessor(feature_extractor, tokenizer, chat_template = None, audio_bos_token = '<|vision_start|>', audio_eos_token = '<|vision_end|>', audio_token = '<|vision_pad|>')
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vibevoice/processing_vibevoice.py#L46)

**Parámetros:**

feature_extractor (`VibeVoiceAcousticTokenizerFeatureExtractor`) : El extractor de características es una entrada obligatoria.

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

chat_template (`str`) : Una plantilla de Jinja para convertir listas de mensajes de un chat en una cadena tokenizable.

audio_bos_token (`str`, *opcional*, valor predeterminado `"<|vision_start|>"`) : El token utilizado para indicar el inicio de la generación de audio.

audio_eos_token (`str`, *opcional*, valor predeterminado `"<|vision_end|>"`) : El token utilizado para indicar el final de la generación de audio.

audio_token (`str`, *opcional*, valor predeterminado `"<|vision_pad|>"`) : El token utilizado para indicar que se debe continuar generando audio.

Construye un VibeVoiceProcessor que envuelve un extractor de características y un tokenizador en un único procesador.

[VibeVoiceProcessor](/docs/transformers/main/es/model_doc/vibevoice#transformers.VibeVoiceProcessor) ofrece todas las funcionalidades de [VibeVoiceAcousticTokenizerFeatureExtractor](/docs/transformers/main/es/model_doc/vibevoice_acoustic_tokenizer#transformers.VibeVoiceAcousticTokenizerFeatureExtractor) y [Qwen2TokenizerFast](/docs/transformers/main/es/model_doc/qwen2#transformers.Qwen2Tokenizer). Consulte [~VibeVoiceAcousticTokenizerFeatureExtractor](/docs/transformers/main/es/model_doc/vibevoice_acoustic_tokenizer#transformers.VibeVoiceAcousticTokenizerFeatureExtractor) y [~Qwen2TokenizerFast](/docs/transformers/main/es/model_doc/qwen2#transformers.Qwen2Tokenizer) para obtener más información.

#### __llamada__[[transformers.VibeVoiceProcessor.__call__]]

```python
__call__(text: str | list[str] | list[list[str]], audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor'], NoneType] = None, output_labels: bool | None = False, **kwargs: *<class 'transformers.models.vibevoice.processing_vibevoice.VibeVoiceProcessorKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vibevoice/processing_vibevoice.py#L98)

**Parámetros:**

text (`str`, `List[str]`) : El texto de entrada a procesar, normalmente preparado con apply_chat_template y marcadores de posición para tokens de audio.

audio (`List[Union[str, np.ndarray]]`, *opcional*) : Muestras de audio para clonación de voz del orador. Debe coincidir con el número de marcadores de posición de tokens de audio en el texto.

output_labels (`bool`, *opcional*, predeterminado=False) : Si se deben devolver etiquetas para el entrenamiento.

- ****kwargs** : Argumentos de palabra clave adicionales que se pasan al tokenizador y al extractor de características.

return_tensors (`str` o [TensorType](/docs/transformers/main/es/internal/file_utils#transformers.TensorType), *opcional*) : Si se establece, devolverá tensores de un marco de trabajo específico. Los valores aceptables son:  - `'pt'`: Devuelve objetos `torch.Tensor` de PyTorch. - `'np'`: Devuelve objetos `np.ndarray` de NumPy.

- ****kwargs** ([ProcessingKwargs](/docs/transformers/main/es/main_classes/processors#transformers.ProcessingKwargs), *opcional*) : Opciones de procesamiento adicionales para cada modalidad (texto, imágenes, vídeos, audio). Los parámetros específicos del modelo se enumeran arriba; consulte la clase TypedDict para obtener la lista completa de argumentos admitidos.

**Devuelve:** [BatchFeature](/docs/transformers/main/es/main_classes/feature_extractor#transformers.BatchFeature)

Un [BatchFeature](/docs/transformers/main/es/main_classes/feature_extractor#transformers.BatchFeature) con los siguientes campos:
- **input_ids** -- Lista de ids de tokens que se enviarán al modelo.
- **attention_mask** -- Lista de índices que especifica qué tokens deben ser atendidos por el modelo (cuando `return_attention_mask=True`).
- **input_values** -- Lista de valores de audio que se enviarán al modelo. Se devuelve cuando `audio` no es `None`.
- **padding_mask** -- Lista de índices que especifica qué fotogramas de audio deben ser atendidos por el modelo. Se devuelve cuando `audio` no es `None`.
- **labels** -- Etiquetas para el entrenamiento del modelo de lenguaje. Los tokens de relleno y de difusión de audio se enmascaran con -100 (los embeddings de los tokens de difusión de audio se reemplazan por características de audio, por lo que su identidad de token no es un objetivo significativo). Los tokens bos/eos de audio y los tokens eos de texto se conservan como objetivos para que el LM aprenda cuándo iniciar y detener la generación de audio. Se devuelve cuando `output_labels=True`.
- **acoustic_loss_mask** -- Máscara booleana para las posiciones donde se calcula la pérdida de difusión. True en las posiciones de tokens de difusión de audio. Se devuelve cuando `output_labels=True`.

## VibeVoiceForConditionalGeneration[[transformers.VibeVoiceForConditionalGeneration]]

#### transformers.VibeVoiceForConditionalGeneration[[transformers.VibeVoiceForConditionalGeneration]]

```python
transformers.VibeVoiceForConditionalGeneration(config: VibeVoiceConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vibevoice/modeling_vibevoice.py#L367)

**Parámetros:**

config ([VibeVoiceConfig](/docs/transformers/main/es/model_doc/vibevoice#transformers.VibeVoiceConfig)) : 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/main/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

El modelo VibeVoice, que consta de un modelo de lenguaje, tokenizadores de audio, conectores y una cabeza de difusión.

Este modelo hereda de [PreTrainedModel](/docs/transformers/main/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.VibeVoiceForConditionalGeneration.forward]]

```python
forward(input_ids: LongTensor = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, logits_to_keep: int | slice = 0, input_values: typing.Optional[torch.Tensor] = None, padding_mask: typing.Optional[torch.BoolTensor] = None, acoustic_loss_mask: typing.Optional[torch.BoolTensor] = None, noise_scheduler: object | None = None, ddpm_batch_multiplier: int = 4, num_diffusion_steps: int = 10, sample: bool = True, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vibevoice/modeling_vibevoice.py#L422)

**Parámetros:**

input_ids (`torch.LongTensor` 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/main/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para obtener más detalles. [¿Qué son los IDs de entrada?](../glossary#input-ids)

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.

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

logits_to_keep (`Union[int, slice]`, *opcional*, valor predeterminado `0`) : Si es un `int`, calcula los logits para los últimos `logits_to_keep` tokens. Si es `0`, calcula los logits para todos los `input_ids` (caso especial). Solo se necesitan los logits del último token para la generación, y calcularlos solo para ese token puede ahorrar memoria, lo cual se vuelve bastante significativo para secuencias largas o un tamaño de vocabulario grande. Si es un `torch.Tensor`, debe ser de 1D y corresponder a los índices a conservar en la dimensión de longitud de secuencia. Esto es útil al usar el formato de tensor empaquetado (una sola dimensión para el lote y la longitud de secuencia).

input_values (`torch.Tensor`, *opcional*) : Forma de onda de audio preprocesada para clonación de voz.

padding_mask (`torch.BoolTensor`, *opcional*) : Máscaras que indican los cuadros de entrada válidos.

acoustic_loss_mask (`torch.BoolTensor`, *opcional*) : Máscara para calcular la pérdida de difusión solo en tokens acústicos específicos.

noise_scheduler (`object`, *opcional*) : Necesario para el entrenamiento a fin de calcular las dianas de ruido para la pérdida de difusión. De forma predeterminada, utiliza la configuración del programador de ruido especificada en `generation_config` del modelo.

ddpm_batch_multiplier (`int`, *opcional*, valor predeterminado 4) : Para el entrenamiento, número de muestras de ruido a generar por token de audio para el cálculo de la pérdida de difusión, lo que puede ayudar a estabilizar el entrenamiento.

num_diffusion_steps (`int`, *opcional*, valor predeterminado 10) : Para el entrenamiento, el número de pasos de difusión a utilizar. Si no se proporciona, el valor predeterminado es 10.

sample (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe añadir ruido gaussiano a los latentes acústicos, tal como en el modelo original (σ-VAE: la escala del ruido se extrae por elemento del lote de N(0, `vae_std`)). Si es False, la salida del codificador se utiliza tal cual, por lo que la salida es determinista.

**Devuelve:** `VibeVoiceCausalLMOutputWithPast` o `tuple(torch.Tensor)`

Un `VibeVoiceCausalLMOutputWithPast` 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 ([VibeVoiceConfig](/docs/transformers/main/es/model_doc/vibevoice#transformers.VibeVoiceConfig)) y las entradas.

El método forward de [VibeVoiceForConditionalGeneration](/docs/transformers/main/es/model_doc/vibevoice#transformers.VibeVoiceForConditionalGeneration) 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.

- **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Secuencia de estados ocultos en la salida de la última capa del modelo.

  Si se utiliza `past_key_values`, solo se genera el último hidden-state de las secuencias con forma `(batch_size, 1, hidden_size)`.
- **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/main/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 y, opcionalmente, si `config.is_encoder_decoder=True`, en los bloques de atención cruzada) 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.
- **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).
- **audio_features** (`torch.Tensor` de forma `(batch_size, sequence_length, feature_size)`, *opcional*) -- Características de audio extraídas que pueden usarse para condicionar el modelo de lenguaje.

Ejemplo:

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

>>> model = VibeVoiceForConditionalGeneration.from_pretrained("vibevoice/VibeVoice-1.5B-hf")

>>> processor = AutoProcessor.from_pretrained("vibevoice/VibeVoice-1.5B-hf")
>>> inputs = processor(text="Hello, my dog is cute", return_tensors="pt")

>>> # generate speech
>>> speech = model(inputs["input_ids"])
```

#### generate[[transformers.VibeVoiceForConditionalGeneration.generate]]

```python
generate(inputs: typing.Optional[torch.Tensor] = None, generation_config: transformers.generation.configuration_utils.GenerationConfig | None = None, logits_processor: transformers.generation.logits_process.LogitsProcessorList | None = None, stopping_criteria: transformers.generation.stopping_criteria.StoppingCriteriaList | None = None, prefix_allowed_tokens_fn: collections.abc.Callable[[int, torch.Tensor], list[int]] | None = None, synced_gpus: bool | None = None, assistant_model: typing.Optional[ForwardRef('PreTrainedModel')] = None, streamer: typing.Optional[ForwardRef('BaseStreamer')] = None, negative_prompt_ids: typing.Optional[torch.Tensor] = None, negative_prompt_attention_mask: typing.Optional[torch.Tensor] = None, custom_generate: str | collections.abc.Callable | None = None, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/generation/utils.py#L2581)

**Parámetros:**

inputs (`torch.Tensor` de forma variable según la modalidad, *opcional*) : La secuencia utilizada como indicación para la generación o como entradas del modelo para el codificador. Si es `None`, el método la inicializa con `bos_token_id` y un tamaño de lote de 1. Para modelos solo de decodificador, `inputs` debe estar en el formato de `input_ids`. Para modelos codificador-decodificador, *inputs* puede representar cualquiera de `input_ids`, `input_values`, `input_features` o `pixel_values`.

generation_config ([GenerationConfig](/docs/transformers/main/es/main_classes/text_generation#transformers.GenerationConfig), *opcional*) : La configuración de generación que se utilizará como parametrización base para la llamada de generación. Los `**kwargs` pasados a generate que coincidan con los atributos de `generation_config` los sobrescribirán. Si no se proporciona `generation_config`, se utilizará la predeterminada, que tiene la siguiente prioridad de carga: 1) desde el archivo de modelo `generation_config.json`, si existe; 2) desde la configuración del modelo. Tenga en cuenta que los parámetros no especificados heredarán los valores predeterminados de [GenerationConfig](/docs/transformers/main/es/main_classes/text_generation#transformers.GenerationConfig), cuya documentación debe consultarse para parametrizar la generación.

logits_processor (`LogitsProcessorList`, *opcional*) : Procesadores de logits personalizados que complementan los procesadores de logits predeterminados creados a partir de los argumentos y la configuración de generación. Si se pasa un procesador de logits que ya ha sido creado con los argumentos o una configuración de generación, se lanza un error. Esta función está destinada a usuarios avanzados.

stopping_criteria (`StoppingCriteriaList`, *opcional*) : Criterios de parada personalizados que complementan los criterios de parada predeterminados construidos a partir de los argumentos y una configuración de generación. Si se pasa un criterio de parada que ya ha sido creado con los argumentos o una configuración de generación, se lanza un error. Si su criterio de parada depende de la entrada `scores`, asegúrese de pasar `return_dict_in_generate=True, output_scores=True` a `generate`. Esta función está destinada a usuarios avanzados.

prefix_allowed_tokens_fn (`Callable[[int, torch.Tensor], list[int]]`, *opcional*) : Si se proporciona, esta función restringe la búsqueda por haz a los tokens permitidos en cada paso. Si no se proporciona, no se aplica ninguna restricción. Esta función toma 2 argumentos: el ID del lote `batch_id` y `input_ids`. Debe devolver una lista con los tokens permitidos para el siguiente paso de generación, condicionada al ID del lote `batch_id` y a los tokens generados previamente `inputs_ids`. Este argumento es útil para la generación restringida condicionada al prefijo, tal como se describe en [Autoregressive Entity Retrieval](https://huggingface.co/papers/2010.00904).

synced_gpus (`bool`, *opcional*) : Indica si se debe continuar ejecutando el bucle while hasta max_length. A menos que se sobrescriba, esta bandera se establecerá en `True` si se utiliza `FullyShardedDataParallel` o DeepSpeed ZeRO Stage 3 con varias GPUs, para evitar bloqueos si una GPU termina de generar antes que las demás. De lo contrario, el valor predeterminado es `False`.

assistant_model (`PreTrainedModel`, *opcional*) : Un modelo asistente que se puede utilizar para acelerar la generación. El modelo asistente debe tener exactamente el mismo tokenizador. La aceleración se logra cuando la predicción de tokens candidatos con el modelo asistente es mucho más rápida que ejecutar la generación con el modelo desde el que se llama a generate. Por lo tanto, el modelo asistente debe ser mucho más pequeño.

streamer (`BaseStreamer`, *opcional*) : Objeto Streamer que se utilizará para transmitir las secuencias generadas. Los tokens generados se pasan a través de `streamer.put(token_ids)` y el streamer se encarga de cualquier procesamiento adicional.

negative_prompt_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : El prompt negativo necesario para algunos procesadores, como CFG. El tamaño del lote debe coincidir con el tamaño del lote de entrada. Esta es una función experimental, sujeta a cambios que pueden romper la API en versiones futuras.

negative_prompt_attention_mask (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Attention_mask para `negative_prompt_ids`.

custom_generate (`str` o `Callable`, *opcional*) : Una de las siguientes opciones: - `str` (nombre de un repositorio de Hugging Face Hub): ejecuta la función personalizada `generate` definida en `custom_generate/generate.py` de ese repositorio en lugar del método estándar `generate`. El repositorio reemplaza por completo la lógica de generación, y el tipo de retorno puede diferir. - `str` (ruta de un repositorio local): igual que lo anterior, pero desde una ruta local. Los directorios locales también requieren `trust_remote_code=True` porque se ejecuta el `custom_generate/generate.py` local. - `Callable`: `generate` realizará los pasos habituales de preparación de la entrada y luego llamará al callable proporcionado para ejecutar el bucle de decodificación. Para obtener más información, consulte [la documentación](../../generation_strategies#custom-generation-methods).

kwargs (`dict[str, Any]`, *opcional*) : Parametrización ad hoc de `generation_config` y/o kwargs específicos del modelo adicionales que se reenviarán a la función `forward` del modelo. Si el modelo es un modelo encoder-decoder, los kwargs específicos del encoder no deben tener prefijo y los kwargs específicos del decoder deben tener el prefijo *decoder_*.

**Devuelve:** [ModelOutput](/docs/transformers/main/es/main_classes/output#transformers.utils.ModelOutput) o `torch.LongTensor`

Un [ModelOutput](/docs/transformers/main/es/main_classes/output#transformers.utils.ModelOutput) (si `return_dict_in_generate=True` o cuando `config.return_dict_in_generate=True`) o un `torch.LongTensor`.

Si el modelo *no* es un modelo encoder-decoder (`model.config.is_encoder_decoder=False`), los tipos [ModelOutput](/docs/transformers/main/es/main_classes/output#transformers.utils.ModelOutput) posibles son:

- [GenerateDecoderOnlyOutput](/docs/transformers/main/es/internal/generation_utils#transformers.generation.GenerateDecoderOnlyOutput),
- [GenerateBeamDecoderOnlyOutput](/docs/transformers/main/es/internal/generation_utils#transformers.generation.GenerateBeamDecoderOnlyOutput)

Si el modelo es un modelo encoder-decoder (`model.config.is_encoder_decoder=True`), los tipos [ModelOutput](/docs/transformers/main/es/main_classes/output#transformers.utils.ModelOutput) posibles son:

- [GenerateEncoderDecoderOutput](/docs/transformers/main/es/internal/generation_utils#transformers.generation.GenerateEncoderDecoderOutput),
- [GenerateBeamEncoderDecoderOutput](/docs/transformers/main/es/internal/generation_utils#transformers.generation.GenerateBeamEncoderDecoderOutput)

Genera secuencias de ids de tokens para modelos con una cabeza de modelado de lenguaje.

La mayoría de los parámetros de control de generación se configuran en `generation_config`, que, si no se pasa, se establecerá en la configuración de generación predeterminada del modelo. Puede invalidar cualquier `generation_config` pasando los parámetros correspondientes a generate(), por ejemplo, `.generate(inputs, num_beams=4, do_sample=True)`.

Para obtener una visión general de las estrategias de generación y ejemplos de código, consulta la [siguiente guía](../generation_strategies).

## VibeVoiceModel[[transformers.VibeVoiceModel]]

#### transformers.VibeVoiceModel[[transformers.VibeVoiceModel]]

```python
transformers.VibeVoiceModel(config: VibeVoiceConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vibevoice/modeling_vibevoice.py#L241)

**Parámetros:**

config ([VibeVoiceConfig](/docs/transformers/main/es/model_doc/vibevoice#transformers.VibeVoiceConfig)) : 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/main/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

El modelo VibeVoice, que consta de tokenizadores de audio y un backbone de LLM, sin una cabeza de modelado de lenguaje.

Este modelo hereda de [PreTrainedModel](/docs/transformers/main/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.VibeVoiceModel.forward]]

```python
forward(input_ids: LongTensor = None, inputs_embeds: typing.Optional[torch.Tensor] = None, input_values: typing.Optional[torch.Tensor] = None, padding_mask: typing.Optional[torch.BoolTensor] = None, sample: bool = True, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vibevoice/modeling_vibevoice.py#L324)

**Parámetros:**

input_ids (`torch.LongTensor` 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/main/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para obtener más detalles. [¿Qué son los IDs de entrada?](../glossary#input-ids)

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.

input_values (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Valores en coma flotante de la forma de onda de voz cruda de entrada. Los valores se pueden obtener cargando un archivo de audio `.flac` o `.wav` en un array de tipo `list[float]`, un `numpy.ndarray` o un `torch.Tensor`, *por ejemplo* mediante la biblioteca torchcodec (`pip install torchcodec`) o la biblioteca soundfile (`pip install soundfile`). Para preparar el array como `input_values`, se debe utilizar [AutoProcessor](/docs/transformers/main/es/model_doc/auto#transformers.AutoProcessor) para el relleno y la conversión a un tensor de tipo `torch.Tensor`. Consulte [VibeVoiceProcessor.__call__()](/docs/transformers/main/es/model_doc/vibevoice#transformers.VibeVoiceProcessor.__call__) para más detalles.

padding_mask (`torch.Tensor` de forma `(batch_size, padded_audio_length)`) : Máscara de relleno para eliminar las partes rellenas del audio.

sample (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe añadir ruido gaussiano a los latentes acústicos, tal como en el modelo original (σ-VAE: la escala del ruido se extrae por elemento del lote de N(0, `vae_std`)). Si es False, la salida del codificador se utiliza tal cual, por lo que la salida es determinista.

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

Un [BaseModelOutputWithPast](/docs/transformers/main/es/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) 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 ([VibeVoiceConfig](/docs/transformers/main/es/model_doc/vibevoice#transformers.VibeVoiceConfig)) y las entradas.

El método forward de [VibeVoiceModel](/docs/transformers/main/es/model_doc/vibevoice#transformers.VibeVoiceModel) 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.

- **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Secuencia de estados ocultos en la salida de la última capa del modelo.

  Si se utiliza `past_key_values`, solo se genera el último hidden-state de las secuencias con forma `(batch_size, 1, hidden_size)`.
- **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/main/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 y, opcionalmente, si `config.is_encoder_decoder=True`, en los bloques de atención cruzada) 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.

#### get_audio_features[[transformers.VibeVoiceModel.get_audio_features]]

```python
get_audio_features(input_values: Tensor, padding_mask: Tensor, sample: bool = True, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vibevoice/modeling_vibevoice.py#L258)

**Parámetros:**

input_values (`torch.Tensor`) : Valores de flotante de la forma de onda de audio (normalizada).

padding_mask (`torch.Tensor` de forma `(batch_size, padded_audio_length)`) : Máscara de relleno para eliminar las partes rellenas del audio.

sample (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe añadir ruido gaussiano a los latentes acústicos, tal como en el modelo original (σ-VAE: la escala del ruido se extrae por elemento del lote de N(0, `vae_std`)). Si es False, la salida del codificador se utiliza tal cual, por lo que la salida es determinista.

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

Un [BaseModelOutputWithPooling](/docs/transformers/main/es/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) 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 ([VibeVoiceConfig](/docs/transformers/main/es/model_doc/vibevoice#transformers.VibeVoiceConfig)) y las entradas.

Este método se utiliza para obtener los embeddings de audio (que reemplazan los tokens de audio de marcador de posición en la secuencia de entrada) y las características acústicas (utilizadas como objetivo de difusión) a partir de la forma de onda de audio de entrada.

- **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Secuencia de estados ocultos en la salida de la última capa del modelo.
- **pooler_output** (`torch.Tensor` de forma `(batch_size, hidden_size)`) -- Estado oculto de la última capa del primer token de la secuencia (token de clasificación) después de un procesamiento adicional a través de las capas utilizadas para la tarea de preentrenamiento auxiliar. Por ejemplo, para la familia de modelos BERT, esto devuelve el token de clasificación después de procesarlo a través de una capa lineal y una función de activación tanh. Los pesos de la capa lineal se entrenan a partir del objetivo de predicción de la siguiente oración (clasificación) durante el preentrenamiento.
- **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.

#### get_placeholder_mask[[transformers.VibeVoiceModel.get_placeholder_mask]]

```python
get_placeholder_mask(input_ids: LongTensor, inputs_embeds: Tensor, audio_features: Tensor)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/vibevoice/modeling_vibevoice.py#L300)

Obtiene la máscara de marcador de posición multimodal a partir de `input_ids` o `inputs_embeds` y comprueba que la cantidad de tokens de marcador de posición sea igual a la longitud de las características multimodales. Si las longitudes son diferentes, se genera un error.