# Nemotron 3.5 Transcribe

## Resumen

Nemotron 3.5 Transcribe es un modelo de lenguaje de audio para transcripción multilingüe, transcripción con atribución de hablantes, traducción de voz y respuesta a preguntas sobre audio. Un codificador de reconocimiento de voz y el modelo [Nemotron 3 Diarization](./nemotron3_diarization) leen el mismo espectrograma; sus salidas se proyectan en un modelo de lenguaje [Nemotron-H](./nemotron_h). Una cabeza de marcas de tiempo de palabras en las salidas del codificador proporciona tiempos a nivel de palabra.

## Uso

### Transcripción

```python
from transformers import AutoModelForMultimodalLM, AutoProcessor

model_id = "nvidia/NVIDIA-Nemotron-3.5-Transcribe-30B-A4B"
samples = "https://huggingface.co/datasets/hf-internal-testing/dummy-audio-samples/resolve/main/"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForMultimodalLM.from_pretrained(model_id, device_map="auto")

inputs = processor.apply_transcription_request(samples + "en-Alice_woman.wav").to(model.device)
outputs = model.generate(**inputs, max_new_tokens=256)
print(processor.decode(outputs[:, inputs.input_ids.shape[1] :], skip_special_tokens=True))
```

### Transcripción por lotes

```python
from transformers import AutoModelForMultimodalLM, AutoProcessor

model_id = "nvidia/NVIDIA-Nemotron-3.5-Transcribe-30B-A4B"
samples = "https://huggingface.co/datasets/hf-internal-testing/dummy-audio-samples/resolve/main/"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForMultimodalLM.from_pretrained(model_id, device_map="auto")

audio = [samples + "en-Alice_woman.wav", samples + "diarization_example.mp3"]
speaker_attributed_prompt = (
    "Transcribe this audio with punctuation and capitalization. Include all spoken words and verbal fillers. Write "
    "numbers in their standard written form. Put speaker tags <spk:0> <spk:1> <spk:2> <spk:3> on the transcription."
)
prompt = [None, speaker_attributed_prompt]

inputs = processor.apply_transcription_request(audio, prompt=prompt).to(model.device)
outputs = model.generate(**inputs, max_new_tokens=1024)
texts = processor.decode(outputs[:, inputs.input_ids.shape[1] :], skip_special_tokens=False)
print([text.replace(processor.tokenizer.pad_token, "") for text in texts])
```

### Transcripción atribuida al orador

```python
from transformers import AutoModelForMultimodalLM, AutoProcessor

model_id = "nvidia/NVIDIA-Nemotron-3.5-Transcribe-30B-A4B"
samples = "https://huggingface.co/datasets/hf-internal-testing/dummy-audio-samples/resolve/main/"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForMultimodalLM.from_pretrained(model_id, device_map="auto")

prompt = (
    "Transcribe this audio with punctuation and capitalization. Include all spoken words and verbal fillers. Write "
    "numbers in their standard written form. Put speaker tags <spk:0> <spk:1> <spk:2> <spk:3> on the transcription."
)
conversation = [
    {
        "role": "user",
        "content": [
            {"type": "text", "text": prompt},
            {"type": "audio", "path": samples + "diarization_example.mp3"},
        ],
    }
]

inputs = processor.apply_chat_template(
    conversation,
    tokenize=True,
    add_generation_prompt=True,
    return_dict=True,
    enable_thinking=False,
).to(model.device)
outputs = model.generate(**inputs, max_new_tokens=1024)
text = processor.decode(outputs[0, inputs.input_ids.shape[1] :], skip_special_tokens=False)
print(text)
```

[extract_speaker_dict()](/docs/transformers/main/es/model_doc/nemotron3_5_transcribe#transformers.Nemotron3_5TranscribeProcessor.extract_speaker_dict) divide la salida en un diccionario por turno de cada hablante:

```python
for turn in processor.extract_speaker_dict(text):
    print(turn)
```

```text
{'Speaker': 0, 'Content': "To celebrate the release of Nematron three Dierization, we invited ... from NVIDIA."}
{'Speaker': 1, 'Content': "Hi everybody, thanks for having me. I'm Jane, a pocket voice from QTie."}
{'Speaker': 2, 'Content': "Nice to meet you Chris and Jane. I'm Serena, the Queen three Voice."}
...
```

### Marcas de tiempo de palabras

Requiere `torchaudio` y `scipy`.

```python
from transformers import AutoModelForMultimodalLM, AutoProcessor

model_id = "nvidia/NVIDIA-Nemotron-3.5-Transcribe-30B-A4B"
samples = "https://huggingface.co/datasets/hf-internal-testing/dummy-audio-samples/resolve/main/"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForMultimodalLM.from_pretrained(model_id, device_map="auto")

prompt = (
    "Transcribe this audio with punctuation and capitalization. Include all spoken words and verbal fillers. Write "
    "numbers in their standard written form. Put speaker tags <spk:0> <spk:1> <spk:2> <spk:3> on the transcription."
)

inputs = processor.apply_transcription_request(samples + "diarization_example.mp3", prompt=prompt).to(model.device)
outputs = model.generate(**inputs, max_new_tokens=1024, return_word_timestamp_logits=True)
texts = processor.decode(outputs.sequences[:, inputs.input_ids.shape[1] :], skip_special_tokens=False)
timestamps = processor.align_word_timestamps(
    texts,
    outputs.word_timestamp_logits,
    inputs.input_features_mask,
    outputs.speaker_logits,
)
print(timestamps[0]["chunks"][:3])
```

Para alinear un transcripción que no fue generado:

```python
input_features_mask = inputs.input_features_mask
audio_outputs = model.get_audio_features(inputs.input_features, input_features_mask)
word_timestamp_logits = model.get_word_timestamp_logits(audio_outputs.asr_last_hidden_state, input_features_mask)
timestamps = processor.align_word_timestamps(
    ["<spk:0> To celebrate the ..."],
    word_timestamp_logits,
    input_features_mask,
    audio_outputs.speaker_logits,
)
```

## Nemotron3_5TranscribeConfig[[transformers.Nemotron3_5TranscribeConfig]]

#### transformers.Nemotron3_5TranscribeConfig[[transformers.Nemotron3_5TranscribeConfig]]

```python
transformers.Nemotron3_5TranscribeConfig(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, text_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, audio_token_id: int = 131072, word_timestamp_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron3_5_transcribe/configuration_nemotron3_5_transcribe.py#L223)

**Parámetros:**

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

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

audio_token_id (`int`, *opcional*, valor predeterminado 131072) : El índice de token de audio utilizado como marcador de posición para las incrustaciones de audio. El punto de control original lo añade después del vocabulario del modelo de lenguaje, sin fila de incrustación: se incrusta como token 0 y luego se reemplaza por el audio.

word_timestamp_config (`Union[dict, Nemotron3_5TranscribeWordTimestampConfig]`, *opcional*) : Configuración del codificador y la cabeza de marcas de tiempo de palabras, que predice las piezas del tokenizador de alineación a partir de los estados del codificador de reconocimiento de voz.

Esta es la clase de configuración para almacenar la configuración de un Nemotron3 5 TranscribeModel. Se utiliza para instanciar un modelo Nemotron3 5 Transcribe 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 [nvidia/NVIDIA-Nemotron-3.5-Transcribe-30B-A4B](https://huggingface.co/nvidia/NVIDIA-Nemotron-3.5-Transcribe-30B-A4B)

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.

Ejemplo:

```python
>>> from transformers import Nemotron3_5TranscribeForConditionalGeneration, Nemotron3_5TranscribeConfig

>>> # Initializing a Nemotron3_5Transcribe configuration
>>> configuration = Nemotron3_5TranscribeConfig()

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

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

## Nemotron3_5TranscribeAsrAudioConfig[[transformers.Nemotron3_5TranscribeAsrAudioConfig]]

#### transformers.Nemotron3_5TranscribeAsrAudioConfig[[transformers.Nemotron3_5TranscribeAsrAudioConfig]]

```python
transformers.Nemotron3_5TranscribeAsrAudioConfig(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 = 1280, intermediate_size: int = 5120, num_hidden_layers: int = 32, num_attention_heads: int = 10, num_key_value_heads: int | None = None, hidden_act: str = 'gelu', max_position_embeddings: int = 5000, initializer_range: float = 0.02, rope_parameters: dict | None = None, attention_dropout: float | int = 0.0, num_mel_bins: int = 128, subsampling_factor: int = 8)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron3_5_transcribe/configuration_nemotron3_5_transcribe.py#L31)

**Parámetros:**

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

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

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

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

num_key_value_heads (`int`, *opcional*) : Este es el número de cabezas de key_value que deben usarse para implementar Grouped Query Attention. Si `num_key_value_heads=num_attention_heads`, el modelo usará Multi Head Attention (MHA); si `num_key_value_heads=1`, el modelo usará Multi Query Attention (MQA); en caso contrario, se usará GQA. Al convertir un checkpoint multi-head a un checkpoint GQA, cada cabeza de key y value del grupo debe construirse mediante meanpooling de todas las cabezas originales dentro de ese grupo. Para más detalles, consulta [este artículo](https://huggingface.co/papers/2305.13245). Si no se especifica, el valor predeterminado será `num_attention_heads`.

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

max_position_embeddings (`int`, *opcional*, valor predeterminado `5000`) : La longitud máxima de secuencia con la que se podría utilizar este modelo.

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

rope_parameters (`dict`, *opcional*) : Diccionario que contiene los parámetros de configuración para las incrustaciones RoPE. El diccionario debe contener un valor para `rope_theta` y, opcionalmente, parámetros utilizados para el escalado en caso de que desee usar RoPE con `max_position_embeddings` más largos.

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

num_mel_bins (`int`, *opcional*, valor predeterminado `128`) : Número de características mel utilizadas por cada entrada de fotograma. Debe corresponder al valor utilizado en la clase `AutoFeatureExtractor`.

subsampling_factor (`int`, *opcional*, valor predeterminado 8) : Número de fotogramas consecutivos del espectrograma apilados en un fotograma del codificador.

Esta es la clase de configuración para almacenar la configuración de un Nemotron3 5 TranscribeModel. Se utiliza para instanciar un modelo Nemotron3 5 Transcribe 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 [nvidia/NVIDIA-Nemotron-3.5-Transcribe-30B-A4B](https://huggingface.co/nvidia/NVIDIA-Nemotron-3.5-Transcribe-30B-A4B)

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.

Ejemplo:

```python
>>> from transformers import Nemotron3_5TranscribeAsrAudioModel, Nemotron3_5TranscribeAsrAudioConfig

>>> # Initializing a Nemotron3_5TranscribeAsrAudioModel configuration
>>> configuration = Nemotron3_5TranscribeAsrAudioConfig()

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

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

## Nemotron3_5TranscribeAudioConfig[[transformers.Nemotron3_5TranscribeAudioConfig]]

#### transformers.Nemotron3_5TranscribeAudioConfig[[transformers.Nemotron3_5TranscribeAudioConfig]]

```python
transformers.Nemotron3_5TranscribeAudioConfig(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, asr_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, diarization_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, speaker_activity_threshold: float = 0.5)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron3_5_transcribe/configuration_nemotron3_5_transcribe.py#L152)

**Parámetros:**

asr_config (`Union[dict, Nemotron3_5TranscribeAsrAudioConfig]`, *opcional*) : Configuración del codificador de reconocimiento de voz.

diarization_config (`Union[dict, Nemotron3DiarizationConfig]`, *opcional*) : Configuración del modelo de diarización de hablantes, cuyas actividades de los hablantes se añaden a las salidas del codificador de reconocimiento de voz.

speaker_activity_threshold (`float`, *opcional*, valor predeterminado 0.5) : Un hablante está activo en un marco del codificador cuando su probabilidad supera este umbral.

Esta es la clase de configuración para almacenar la configuración de un Nemotron3 5 TranscribeModel. Se utiliza para instanciar un modelo Nemotron3 5 Transcribe 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 [nvidia/NVIDIA-Nemotron-3.5-Transcribe-30B-A4B](https://huggingface.co/nvidia/NVIDIA-Nemotron-3.5-Transcribe-30B-A4B)

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.

Ejemplo:

```python
>>> from transformers import Nemotron3_5TranscribeAudioModel, Nemotron3_5TranscribeAudioConfig

>>> # Initializing a Nemotron3_5TranscribeAudioModel configuration
>>> configuration = Nemotron3_5TranscribeAudioConfig()

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

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

## Nemotron3_5TranscribeWordTimestampConfig[[transformers.Nemotron3_5TranscribeWordTimestampConfig]]

#### transformers.Nemotron3_5TranscribeWordTimestampConfig[[transformers.Nemotron3_5TranscribeWordTimestampConfig]]

```python
transformers.Nemotron3_5TranscribeWordTimestampConfig(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 = 1280, intermediate_size: int = 640, num_hidden_layers: int = 2, num_attention_heads: int = 16, num_key_value_heads: int | None = None, hidden_act: str = 'gelu', max_position_embeddings: int = 5000, initializer_range: float = 0.02, rope_parameters: dict | None = None, attention_dropout: float | int = 0.0, vocab_size: int = 23863, blank_token_id: int = 23862, residual_scale: float = 0.1, upsampling_factor: int = 2)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron3_5_transcribe/configuration_nemotron3_5_transcribe.py#L88)

**Parámetros:**

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

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

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

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

num_key_value_heads (`int`, *opcional*) : Este es el número de cabezas de key_value que deben usarse para implementar Grouped Query Attention. Si `num_key_value_heads=num_attention_heads`, el modelo usará Multi Head Attention (MHA); si `num_key_value_heads=1`, el modelo usará Multi Query Attention (MQA); en caso contrario, se usará GQA. Al convertir un checkpoint multi-head a un checkpoint GQA, cada cabeza de key y value del grupo debe construirse mediante meanpooling de todas las cabezas originales dentro de ese grupo. Para más detalles, consulta [este artículo](https://huggingface.co/papers/2305.13245). Si no se especifica, el valor predeterminado será `num_attention_heads`.

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

max_position_embeddings (`int`, *opcional*, valor predeterminado `5000`) : La longitud máxima de secuencia con la que se podría utilizar este modelo.

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

rope_parameters (`dict`, *opcional*) : Diccionario que contiene los parámetros de configuración para las incrustaciones RoPE. El diccionario debe contener un valor para `rope_theta` y, opcionalmente, parámetros utilizados para el escalado en caso de que desee usar RoPE con `max_position_embeddings` más largos.

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

vocab_size (`int`, *opcional*, valor predeterminado 23863) : Número de clases de la cabeza de marcas de tiempo de palabras: las piezas de su tokenizador de alineación, más el espacio en blanco.

blank_token_id (`int`, *opcional*, valor predeterminado 23862) : Índice de la clase en blanco, después de las piezas del tokenizador de alineación.

residual_scale (`float`, *opcional*, valor predeterminado 0.1) : Escala de la salida del transformador que se suma a los estados del codificador de reconocimiento de voz antes del clasificador.

upsampling_factor (`int`, *opcional*, valor predeterminado 2) : Número de fotogramas de cabecera por fotograma del codificador, generados mediante una convolución transpuesta antes del transformer: 2 produce fotogramas de 40 ms a partir de los fotogramas de 80 ms del codificador.

Esta es la clase de configuración para almacenar la configuración de un Nemotron3 5 TranscribeModel. Se utiliza para instanciar un modelo Nemotron3 5 Transcribe 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 [nvidia/NVIDIA-Nemotron-3.5-Transcribe-30B-A4B](https://huggingface.co/nvidia/NVIDIA-Nemotron-3.5-Transcribe-30B-A4B)

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.

Ejemplo:

```python
>>> from transformers import Nemotron3_5TranscribeConfig, Nemotron3_5TranscribeWordTimestampConfig

>>> # Initializing a Nemotron3_5TranscribeWordTimestamp configuration
>>> configuration = Nemotron3_5TranscribeWordTimestampConfig()

>>> # Using it as the word timestamp head of the model
>>> model_configuration = Nemotron3_5TranscribeConfig(word_timestamp_config=configuration)
```

## Nemotron3_5TranscribeProcessor[[transformers.Nemotron3_5TranscribeProcessor]]

#### transformers.Nemotron3_5TranscribeProcessor[[transformers.Nemotron3_5TranscribeProcessor]]

```python
transformers.Nemotron3_5TranscribeProcessor(feature_extractor, tokenizer, alignment_tokenizer, chat_template = None, audio_token = '<|audio|>', default_transcription_prompt = 'Audio transcription. Language: as spoken. Wording: verbatim, including fillers and repetitions. Formatting: punctuation and capitalization. Output: transcript only.', subsampling_factor = 8)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron3_5_transcribe/processing_nemotron3_5_transcribe.py#L235)

**Parámetros:**

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

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

alignment_tokenizer (`PreTrainedTokenizerFast`) : El vocabulario de la cabeza de marcas de tiempo de palabras: 23.862 piezas BPE de SentencePiece, donde la clase 23.862 de la cabeza es el espacio en blanco de CTC. Solo se utiliza en [align_word_timestamps()](/docs/transformers/main/es/model_doc/nemotron3_5_transcribe#transformers.Nemotron3_5TranscribeProcessor.align_word_timestamps) y se guarda en la subcarpeta `alignment_tokenizer/`. Añade un espacio al inicio para reproducir los ids de SentencePiece originales de cualquier texto, incluido un texto que comience con una etiqueta: `alignment_tokenizer.encode(" " + text, add_special_tokens=False)`.

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

audio_token (`str`, *opcional*, valor predeterminado `"<|audio|>"`) : Token especial utilizado para representar las entradas de audio en la plantilla de chat.

default_transcription_prompt (`str`, *opcional*) : Prompt predeterminado utilizado por [apply_transcription_request()](/docs/transformers/main/es/model_doc/nemotron3_5_transcribe#transformers.Nemotron3_5TranscribeProcessor.apply_transcription_request).

subsampling_factor (`int`, *opcional*, valor predeterminado 8) : Número de fotogramas del espectrograma por token de audio, que refleja `Nemotron3_5TranscribeAsrAudioConfig.subsampling_factor`. El espectrograma se rellena hasta un múltiplo de este valor.

Construye un Nemotron3_5TranscribeProcessor que envuelve un extractor de características, un tokenizador y un tokenizador de alineación en un único procesador.

[Nemotron3_5TranscribeProcessor](/docs/transformers/main/es/model_doc/nemotron3_5_transcribe#transformers.Nemotron3_5TranscribeProcessor) ofrece todas las funcionalidades de `feature_extractor_class`, `tokenizer_class` y `{alignment_tokenizer_class}`. Consulte `~feature_extractor_class`, `~tokenizer_class` y `~{alignment_tokenizer_class}` para obtener más información.

#### __llamada__[[transformers.Nemotron3_5TranscribeProcessor.__call__]]

```python
__call__(text: str | 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.nemotron3_5_transcribe.processing_nemotron3_5_transcribe.Nemotron3_5TranscribeProcessorKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron3_5_transcribe/processing_nemotron3_5_transcribe.py#L268)

**Parámetros:**

text (`Union[str, list[str]]`) : La secuencia o el lote de secuencias que se van a codificar. Cada secuencia puede ser una cadena de caracteres o una lista de cadenas (cadena pretokenizada). Si se pasa una entrada pretokenizada, establezca `is_split_into_words=True` para evitar ambigüedad con las entradas en lote.

audio (`Union[numpy.ndarray, torch.Tensor, collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence[torch.Tensor]]`, *opcional*) : El audio o lote de audios que se va a preparar. Cada audio puede ser un array de NumPy o un tensor de PyTorch. En el caso de un array de NumPy/tensor de PyTorch, cada audio debe tener la forma (C, T), donde C es el número de canales y T es la longitud de muestreo del audio.

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

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 diccionario con texto tokenizado (`input_ids`, `attention_mask`) y características de audio (`input_features`, `input_features_mask`).

#### apply_transcription_request[[transformers.Nemotron3_5TranscribeProcessor.apply_transcription_request]]

```python
apply_transcription_request(audio: typing.Union[str, list[str], numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor']], prompt: str | list[str] | None = None, **kwargs: *<class 'transformers.models.nemotron3_5_transcribe.processing_nemotron3_5_transcribe.Nemotron3_5TranscribeProcessorKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron3_5_transcribe/processing_nemotron3_5_transcribe.py#L340)

**Parámetros:**

audio (`str`, `list[str]`, `np.ndarray`, `torch.Tensor`, `list[np.ndarray]`, `list[torch.Tensor]`) : Audio a transcribir. Las cadenas se interpretan como rutas locales o URL y se cargan automáticamente mediante el cargador de plantillas de chat; los arreglos de NumPy y los tensores de PyTorch se reenvían directamente.

prompt (`str` o `list[str]`, *opcional*) : Prompt(s) personalizado(s) para incluir en el turno del usuario. Una lista debe tener la misma longitud que el lote. Cuando es `None`, cada muestra utiliza `default_transcription_prompt`.

- ****kwargs** : Argumentos de palabra clave adicionales que se reenvían a [apply_chat_template()](/docs/transformers/main/es/main_classes/processors#transformers.ProcessorMixin.apply_chat_template) (por ejemplo, `text_kwargs`, `audio_kwargs`, ...). El razonamiento está deshabilitado a menos que se pase `enable_thinking=True` (la plantilla de chat lo habilita de forma predeterminada).

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

Salidas del procesador listas para pasarse a `Nemotron3_5TranscribeForConditionalGeneration.generate()`.

Prepara las entradas para el reconocimiento automático de voz sin escribir manualmente el prompt de transcripción predeterminado.

#### apply_chat_template[[transformers.Nemotron3_5TranscribeProcessor.apply_chat_template]]

```python
apply_chat_template(conversation: list[dict[str, str]] | list[list[dict[str, str]]], chat_template: str | None = None, tools: list[dict] | None = None, documents: list[dict[str, str]] | None = None, add_generation_prompt: bool = False, continue_final_message: bool | str = False, return_assistant_tokens_mask: bool = False, tokenize: bool = False, return_tensors: str | transformers.utils.generic.TensorType | None = 'auto', return_dict: bool = False, load_audio_from_video: bool = False, processor_kwargs: dict | None = None, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/processing_utils.py#L2250)

**Parámetros:**

conversation (`Union[list[Dict, [str, str]], list[list[dict[str, str]]]]`) : La conversación a formatear.

chat_template (`Optional[str]`, *opcional*) : La plantilla Jinja que se usará para formatear la conversación. Si no se proporciona, se utiliza la plantilla de chat del tokenizador.

De manera similar al método `apply_chat_template` de los tokenizadores, este método aplica una plantilla Jinja a las conversaciones de entrada para convertirlas en una única cadena tokenizable.

Se espera que la entrada tenga el siguiente formato, donde el contenido de cada mensaje es una lista que consiste en texto y, opcionalmente, entradas de imagen o video. También se puede proporcionar una imagen, un video, una URL o una ruta local, que se utilizará para formar `pixel_values` cuando `return_dict=True`. Si no se proporciona, se obtendrá solo el texto formateado y, opcionalmente, el texto tokenizado.

conversation = [ { "role": "user", "content": [ {"type": "image", "url": "https://www.ilankelman.org/stopsigns/australia.jpg"}, {"type": "text", "text": "Please describe this image in detail."}, ], }, ]

#### extract_speaker_dict[[transformers.Nemotron3_5TranscribeProcessor.extract_speaker_dict]]

```python
extract_speaker_dict(text: str | list[str])
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron3_5_transcribe/processing_nemotron3_5_transcribe.py#L414)

**Parámetros:**

text (`str` o `list[str]`) : Texto único o lote de textos, decodificado con `skip_special_tokens=False`: las etiquetas de hablante `<spk:N>` son tokens especiales. Se descarta todo a partir del token de fin de texto.

**Devuelve:** `list[dict]` para un solo texto, `list[list[dict]]` para un lote

un diccionario por turno de hablante, con el índice `"Speaker"` `N` de su etiqueta `<spk:N>` y su `"Content"`. Un texto sin etiquetas es un único turno con `"Speaker": None`, al igual que el texto antes de la primera etiqueta, si la hay.

Divide un transcripción atribuida a hablantes en turnos de hablante, en el formato de `VibeVoiceAsrProcessor.extract_speaker_dict()` sin las marcas de tiempo, que este modelo no predice.

Ejemplo:

```python
>>> processor.extract_speaker_dict("<spk:0> Hi, how are you? <spk:1> Fine, thanks.<|im_end|>")
[{'Speaker': 0, 'Content': 'Hi, how are you?'}, {'Speaker': 1, 'Content': 'Fine, thanks.'}]
```

#### align_word_timestamps[[transformers.Nemotron3_5TranscribeProcessor.align_word_timestamps]]

```python
align_word_timestamps(transcriptions: str | list[str], word_timestamp_logits: torch.Tensor, input_features_mask: torch.Tensor, speaker_logits: torch.Tensor | None = None, language: str | list[str | None] | None = None, speaker_activity_threshold: float = 0.5, max_word_duration: float = 1.0, max_word_frames: int = 12)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron3_5_transcribe/processing_nemotron3_5_transcribe.py#L455)

**Parámetros:**

transcriptions (`str` o `list[str]`) : Texto generado de cada grabación, decodificado con `skip_special_tokens=False` para conservar las etiquetas `<spk:N>`.

word_timestamp_logits (`torch.Tensor` de forma `(batch_size, num_frames * upsampling_factor, vocab_size)`) : Logits de la cabeza de marcas de tiempo de palabras (`word_timestamp_logits` de `generate(..., return_word_timestamp_logits=True)` o `model.get_word_timestamp_logits(...)`), donde la última clase es el espacio en blanco de CTC. Su número de fotogramas por fotograma del codificador, el `upsampling_factor` de la cabeza, se lee a partir de su forma.

input_features_mask (`torch.Tensor` de forma `(batch_size, feature_sequence_length)`) : Máscara de los fotogramas de espectrograma válidos de cada grabación, tal como la devuelve el procesador: su número define la duración de la grabación y, por tanto, el paso de tiempo de los fotogramas de la cabeza.

speaker_logits (`torch.Tensor` de forma `(batch_size, num_frames * subsampling_factor, num_speakers)`, *opcional*) : Logits del modelo de diarización (`speaker_logits` de `generate(..., return_word_timestamp_logits=True)` o de `get_audio_features`). Sin ellos, cada transcripción se alinea como un único hablante y no se devuelve ninguna diarización.

language (`str` o `list[str | None]`, *opcional*) : Idioma de las transcripciones, uno para todas o uno por transcripción, detectado a partir del guion cuando es `None`: `"zh"` y `"ja"` se alinean carácter a carácter, `"th"` no está admitido.

speaker_activity_threshold (`float`, *opcional*, valor predeterminado 0.5) : Probabilidad a partir de la cual un orador de la diarización se considera activo.

max_word_duration (`float`, *opcional*, valor predeterminado 1.0) : Duración máxima de una palabra alineada, en segundos.

max_word_frames (`int`, *opcional*, valor predeterminado 12) : Desplazamiento máximo y duración de una palabra alineada a un segmento de diarización, en fotogramas del codificador de como máximo 80 ms.

**Devuelve:** `dict` o `list[dict]`

para la grabación (o para cada grabación de una lista de transcripciones), como los marcas de tiempo de las palabras del pipeline de reconocimiento de voz, `"chunks"` (`{"text", "timestamp", "speaker"}` por palabra, `timestamp` = `(start, end)` en segundos, ordenado por tiempo; `speaker` es el `N` de la etiqueta de la palabra, `None` antes de la primera etiqueta y 0 en una transcripción sin etiquetas), `"diarization"` (`{"speaker", "timestamp"}` segmentos de actividad de cada orador de diarización), `"speaker_tag_to_diarization_speaker"` (`None` para una etiqueta sin coincidencia) y `"failed_speakers"` (las etiquetas cuyas palabras no se pudieron alinear, ausentes de `"chunks"`).

Multiplica cada palabra de las transcripciones generadas y la asigna a un orador: las palabras de cada etiqueta `<spk:N>` se alinean de forma forzada (`torchaudio.functional.forced_align`) en los fotogramas de la cabecera de marcas de tiempo de palabras donde el orador de la diarización correspondiente a la etiqueta está activo, y luego se ajustan a los segmentos de diarización de ese orador. Port del `MultiSpeakerSOTWordTimestampAligner` de NeMo, con una búsqueda exacta donde este último aproxima grabaciones largas.

Ejemplo:

```python
>>> inputs = processor.apply_transcription_request(audio, prompt=speaker_attributed_prompt).to(model.device)
>>> outputs = model.generate(**inputs, return_word_timestamp_logits=True, max_new_tokens=500)
>>> transcriptions = processor.decode(
...     outputs.sequences[:, inputs.input_ids.shape[1] :], skip_special_tokens=False
... )
>>> timestamps = processor.align_word_timestamps(
...     transcriptions, outputs.word_timestamp_logits, inputs.input_features_mask, outputs.speaker_logits
... )
>>> timestamps[0]["chunks"][0]  # {'text': ..., 'timestamp': (..., ...), 'speaker': 0}
```

## Nemotron3_5TranscribeAsrAudioModel[[transformers.Nemotron3_5TranscribeAsrAudioModel]]

#### transformers.Nemotron3_5TranscribeAsrAudioModel[[transformers.Nemotron3_5TranscribeAsrAudioModel]]

```python
transformers.Nemotron3_5TranscribeAsrAudioModel(config: Nemotron3_5TranscribeAsrAudioConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron3_5_transcribe/modeling_nemotron3_5_transcribe.py#L379)

**Parámetros:**

config ([Nemotron3_5TranscribeAsrAudioConfig](/docs/transformers/main/es/model_doc/nemotron3_5_transcribe#transformers.Nemotron3_5TranscribeAsrAudioConfig)) : 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 codificador de reconocimiento de voz Nemotron 3.5 Transcribe: el codificador de audio Nemotron 3 Diarization con las consultas y claves de cada cabeza de atención normalizadas, y embeddings de posición rotatorios en parte de cada cabeza.

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.Nemotron3_5TranscribeAsrAudioModel.forward]]

```python
forward(input_features: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron3_5_transcribe/modeling_nemotron3_5_transcribe.py#L400)

**Parámetros:**

input_features (`torch.Tensor` de forma `(batch_size, sequence_length, feature_dim)`, *opcional*) : Los tensores correspondientes a las características de audio de entrada. Las características de audio se pueden obtener usando `feature_extractor_class`. Consulte `feature_extractor_class.__call__` para más detalles (`processor_class` utiliza `feature_extractor_class` para procesar audios).

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)

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.

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)

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

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

El método forward del [Nemotron3_5TranscribeAsrAudioModel](/docs/transformers/main/es/model_doc/nemotron3_5_transcribe#transformers.Nemotron3_5TranscribeAsrAudioModel) 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.
- **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.

## Nemotron3_5TranscribeAudioModel[[transformers.Nemotron3_5TranscribeAudioModel]]

#### transformers.Nemotron3_5TranscribeAudioModel[[transformers.Nemotron3_5TranscribeAudioModel]]

```python
transformers.Nemotron3_5TranscribeAudioModel(config: Nemotron3_5TranscribeAudioConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron3_5_transcribe/modeling_nemotron3_5_transcribe.py#L547)

**Parámetros:**

config ([Nemotron3_5TranscribeAudioConfig](/docs/transformers/main/es/model_doc/nemotron3_5_transcribe#transformers.Nemotron3_5TranscribeAudioConfig)) : 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 de transcripción de audio Nemotron 3.5: un codificador de reconocimiento de voz y un modelo de diarización de hablantes se ejecutan en paralelo sobre el mismo espectrograma, y las actividades de los hablantes se añaden a las salidas del codificador de reconocimiento de voz.

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.Nemotron3_5TranscribeAudioModel.forward]]

```python
forward(input_features: Tensor, input_features_mask: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron3_5_transcribe/modeling_nemotron3_5_transcribe.py#L561)

**Parámetros:**

input_features (`torch.Tensor` de forma `(batch_size, feature_sequence_length, num_mel_bins)`) : Espectrograma log mel, relleno hasta un múltiplo de `config.subsampling_factor` fotogramas. Al igual que en el original, el audio más largo que `config.diarization_config.chunk_length` fotogramas del codificador se codifica en fragmentos con contexto.

input_features_mask (`torch.Tensor` de forma `(batch_size, feature_sequence_length)`, *opcional*) : Máscara de los fotogramas de espectrograma válidos. El relleno debe estar a la derecha.

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

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

El método forward del [Nemotron3_5TranscribeAudioModel](/docs/transformers/main/es/model_doc/nemotron3_5_transcribe#transformers.Nemotron3_5TranscribeAudioModel) 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.
- **pooler_output** (`torch.Tensor` de forma `(num_audio_tokens, text_config.hidden_size)`, *opcional*) -- Incrustaciones de audio proyectadas de los marcos válidos del codificador de cada grabación, en orden de lote: las incrustaciones que reemplazan a los tokens de audio del prompt. Devuelto por `get_audio_features`.
- **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.
- **asr_last_hidden_state** (`torch.Tensor` de forma `(batch_size, num_frames, audio_config.hidden_size)`) -- Salida del codificador de reconocimiento de voz, antes de su normalización y de las incorporaciones de hablante: la entrada de [get_word_timestamp_logits()](/docs/transformers/main/es/model_doc/nemotron3_5_transcribe#transformers.Nemotron3_5TranscribeForConditionalGeneration.get_word_timestamp_logits).
- **speaker_logits** (`torch.Tensor` de forma `(batch_size, feature_sequence_length, audio_config.num_speakers)`) -- Logits del modelo de diarización, un fotograma por fotograma del espectrograma.

## Nemotron3_5TranscribeWordTimestampModel[[transformers.Nemotron3_5TranscribeWordTimestampModel]]

#### transformers.Nemotron3_5TranscribeWordTimestampModel[[transformers.Nemotron3_5TranscribeWordTimestampModel]]

```python
transformers.Nemotron3_5TranscribeWordTimestampModel(config: Nemotron3_5TranscribeWordTimestampConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron3_5_transcribe/modeling_nemotron3_5_transcribe.py#L444)

**Parámetros:**

config ([Nemotron3_5TranscribeWordTimestampConfig](/docs/transformers/main/es/model_doc/nemotron3_5_transcribe#transformers.Nemotron3_5TranscribeWordTimestampConfig)) : 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 transformador de la cabeza de marcas de tiempo de palabras de Nemotron 3.5 Transcribe. La clase `Nemotron3_5TranscribeForConditionalGeneration.word_timestamp_head` clasifica su salida.

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.Nemotron3_5TranscribeWordTimestampModel.forward]]

```python
forward(inputs_embeds: Tensor, attention_mask: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron3_5_transcribe/modeling_nemotron3_5_transcribe.py#L470)

**Parámetros:**

inputs_embeds (`torch.Tensor` de forma `(batch_size, num_frames, hidden_size)`) : Estados del codificador de reconocimiento de voz, antes de la `asr_norm` del modelo de audio y las incrustaciones del hablante.

attention_mask (`torch.Tensor` de forma `(batch_size, num_frames)`, *opcional*) : Máscara de los fotogramas de codificador válidos.

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

Devuelve `num_frames * upsampling_factor` fotogramas.

## Nemotron3_5TranscribeModel[[transformers.Nemotron3_5TranscribeModel]]

#### transformers.Nemotron3_5TranscribeModel[[transformers.Nemotron3_5TranscribeModel]]

```python
transformers.Nemotron3_5TranscribeModel(config: Nemotron3_5TranscribeConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron3_5_transcribe/modeling_nemotron3_5_transcribe.py#L641)

**Parámetros:**

config ([Nemotron3_5TranscribeConfig](/docs/transformers/main/es/model_doc/nemotron3_5_transcribe#transformers.Nemotron3_5TranscribeConfig)) : 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 Nemotron 3.5 Transcribe (codificador de reconocimiento de voz y modelo de diarización de hablantes en paralelo, proyector lineal y modelo de lenguaje Nemotron-H), 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.Nemotron3_5TranscribeModel.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, input_features: typing.Optional[torch.Tensor] = None, input_features_mask: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron3_5_transcribe/modeling_nemotron3_5_transcribe.py#L708)

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

input_features (`torch.Tensor` de forma `(batch_size, sequence_length, feature_dim)`, *opcional*) : Los tensores correspondientes a las características de audio de entrada. Las características de audio se pueden obtener usando `feature_extractor_class`. Consulte `feature_extractor_class.__call__` para más detalles (`processor_class` utiliza `feature_extractor_class` para procesar audios).

input_features_mask (`torch.Tensor` de forma `(batch_size, feature_sequence_length)`) : Máscara para evitar realizar atención en los índices de características de relleno.

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

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/main/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/main/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)`.

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

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

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

El método forward de [Nemotron3_5TranscribeModel](/docs/transformers/main/es/model_doc/nemotron3_5_transcribe#transformers.Nemotron3_5TranscribeModel) 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.
- **audio_hidden_states** (`torch.Tensor`, *opcional*) -- Estados ocultos de audio proyectados.

#### get_audio_features[[transformers.Nemotron3_5TranscribeModel.get_audio_features]]

```python
get_audio_features(input_features: Tensor, input_features_mask: Tensor, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron3_5_transcribe/modeling_nemotron3_5_transcribe.py#L654)

**Parámetros:**

input_features (`torch.Tensor`) : Valores de flotantes de las características mel extraídas de la forma de onda de voz cruda.

input_features_mask (`torch.Tensor` de forma `(batch_size, feature_sequence_length)`) : Máscara para evitar realizar atención en los índices de características rellenos.

**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 ([Nemotron3_5TranscribeConfig](/docs/transformers/main/es/model_doc/nemotron3_5_transcribe#transformers.Nemotron3_5TranscribeConfig)) y las entradas.

Este método se utiliza para obtener los embeddings de audio a partir de las características de entrada (un espectrograma log mel), es decir, para inferir el codificador de audio y el proyector multimodal.

- **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_word_timestamp_hidden_states[[transformers.Nemotron3_5TranscribeModel.get_word_timestamp_hidden_states]]

```python
get_word_timestamp_hidden_states(asr_last_hidden_state: Tensor, input_features_mask: Tensor)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron3_5_transcribe/modeling_nemotron3_5_transcribe.py#L767)

**Parámetros:**

asr_last_hidden_state (`torch.Tensor` de forma `(batch_size, num_frames, audio_config.hidden_size)`) : Salida del codificador de reconocimiento de voz antes de su normalización y de las incorporaciones de hablante, tal como se devuelve en [get_audio_features()](/docs/transformers/main/es/model_doc/nemotron3_5_transcribe#transformers.Nemotron3_5TranscribeModel.get_audio_features) para `input_features_mask`.

input_features_mask (`torch.Tensor` de forma `(batch_size, feature_sequence_length)`) : Máscara de los fotogramas de espectrograma válidos. El relleno debe estar a la derecha.

**Devuelve:**

`torch.Tensor` de forma `(batch_size, num_frames * word_timestamp_config.upsampling_factor, audio_config.hidden_size)`: `upsampling_factor` fotogramas por fotograma del codificador, en el dtype del codificador de marcas de tiempo de palabras.

Ejecuta el codificador de marcas de tiempo de palabras sobre los estados del codificador de reconocimiento de voz, en los fragmentos del codificador: los estados que clasifica la cabeza de marcas de tiempo de palabras.

## Nemotron3_5TranscribeForConditionalGeneration[[transformers.Nemotron3_5TranscribeForConditionalGeneration]]

#### transformers.Nemotron3_5TranscribeForConditionalGeneration[[transformers.Nemotron3_5TranscribeForConditionalGeneration]]

```python
transformers.Nemotron3_5TranscribeForConditionalGeneration(config: Nemotron3_5TranscribeConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron3_5_transcribe/modeling_nemotron3_5_transcribe.py#L808)

**Parámetros:**

config ([Nemotron3_5TranscribeConfig](/docs/transformers/main/es/model_doc/nemotron3_5_transcribe#transformers.Nemotron3_5TranscribeConfig)) : 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 Nemotron 3.5 Transcribe (codificador de reconocimiento de voz y modelo de diarización de hablantes en paralelo, proyector lineal y modelo de lenguaje Nemotron-H) con 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.Nemotron3_5TranscribeForConditionalGeneration.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, input_features: typing.Optional[torch.Tensor] = None, input_features_mask: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, logits_to_keep: typing.Union[int, torch.Tensor] = 0, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron3_5_transcribe/modeling_nemotron3_5_transcribe.py#L828)

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

input_features (`torch.Tensor` de forma `(batch_size, sequence_length, feature_dim)`, *opcional*) : Los tensores correspondientes a las características de audio de entrada. Las características de audio se pueden obtener usando `feature_extractor_class`. Consulte `feature_extractor_class.__call__` para más detalles (`processor_class` utiliza `feature_extractor_class` para procesar audios).

input_features_mask (`torch.Tensor` de forma `(batch_size, feature_sequence_length)`) : Máscara para evitar realizar atención en los índices de características de relleno.

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

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/main/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/main/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)`.

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.

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

logits_to_keep (`Union[int, torch.Tensor]`, *opcional*, valor predeterminado `0`) : Si es un `int`, se calculan los logits para los últimos `logits_to_keep` tokens. Si es `0`, se calculan los logits para todos los `input_ids` (caso especial). Solo se necesitan los logits del último token para la generación, y calcularlos únicamente 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).

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

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

El método forward de [Nemotron3_5TranscribeForConditionalGeneration](/docs/transformers/main/es/model_doc/nemotron3_5_transcribe#transformers.Nemotron3_5TranscribeForConditionalGeneration) 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.
- **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).
- **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 las incrustaciones, si el modelo tiene una capa de incrustaciones, + 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.
- **audio_hidden_states** (`torch.Tensor`, *opcional*) -- Estados ocultos del codificador de audio después de la proyección.

Ejemplo:

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

>>> model_id = "nvidia/audio-flamingo-3-hf"
>>> processor = AutoProcessor.from_pretrained(model_id)
>>> model = Nemotron3_5TranscribeForConditionalGeneration.from_pretrained(model_id, device_map="auto")
```

#### get_audio_features[[transformers.Nemotron3_5TranscribeForConditionalGeneration.get_audio_features]]

```python
get_audio_features(input_features, input_features_mask, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron3_5_transcribe/modeling_nemotron3_5_transcribe.py#L820)

**Parámetros:**

input_features (`` of shape `(batch_size, sequence_length, feature_dim)`) : The tensors corresponding to the input audio features. Audio features can be obtained using `feature_extractor_class`. See `feature_extractor_class.__call__` for details (`processor_class` uses `feature_extractor_class` for processing audios).

input_features_mask (`torch.Tensor` de forma `(batch_size, feature_sequence_length)`) : Máscara de los fotogramas de espectrograma válidos. El relleno debe estar a la derecha.

Ejemplo:

```python
```

#### get_word_timestamp_logits[[transformers.Nemotron3_5TranscribeForConditionalGeneration.get_word_timestamp_logits]]

```python
get_word_timestamp_logits(asr_last_hidden_state: Tensor, input_features_mask: Tensor)
```

[Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/nemotron3_5_transcribe/modeling_nemotron3_5_transcribe.py#L890)

**Parámetros:**

asr_last_hidden_state (`torch.Tensor` de forma `(batch_size, num_frames, audio_config.hidden_size)`) : Salida del codificador de reconocimiento de voz antes de su normalización y de las incorporaciones de hablante, tal como se devuelve en [get_audio_features()](/docs/transformers/main/es/model_doc/nemotron3_5_transcribe#transformers.Nemotron3_5TranscribeForConditionalGeneration.get_audio_features) para `input_features_mask`.

input_features_mask (`torch.Tensor` de forma `(batch_size, feature_sequence_length)`) : Máscara de los fotogramas de espectrograma válidos. El relleno debe estar a la derecha.

**Devuelve:**

`torch.Tensor` de forma `(batch_size, num_frames * word_timestamp_config.upsampling_factor, word_timestamp_config.vocab_size)`: logits brutos sobre las piezas del tokenizador de alineación y el espacio en blanco, `upsampling_factor` fotogramas por fotograma del codificador (el procesador aplica log-softmax).

Logits de la cabeza de marca de tiempo de la palabra en los estados del codificador de reconocimiento de voz, que [align_word_timestamps()](/docs/transformers/main/es/model_doc/nemotron3_5_transcribe#transformers.Nemotron3_5TranscribeProcessor.align_word_timestamps) convierte en tiempos de palabra.

Ejemplo:

```python
```