# Pop2Piano

## Resumen

El modelo Pop2Piano fue propuesto en [Pop2Piano : Pop Audio-based Piano Cover Generation](https://huggingface.co/papers/2211.00895) por Jongho Choi y Kyogu Lee.

Los arreglos de piano de música pop son muy populares, pero generarlos a partir de la música no es una tarea trivial. Requiere un gran dominio del piano, así como un conocimiento de las distintas características y melodías de una canción. Con Pop2Piano puedes generar directamente un arreglo a partir de la forma de onda de audio de una canción. Es el primer modelo que genera directamente un arreglo de piano a partir de audio pop, sin necesidad de módulos de extracción de melodía y acordes.

Pop2Piano es un modelo Transformer de codificador-decodificador basado en [T5](https://huggingface.co/papers/1910.10683). La entrada de audio se transforma en su forma de onda y se pasa al codificador, que la convierte en una representación latente. El decodificador utiliza estas representaciones latentes para generar ids de tokens de manera autoregresiva. Cada id de token corresponde a uno de cuatro tipos de tokens diferentes: tiempo, velocidad, nota y 'especial'. Los ids de tokens se decodifican luego en su archivo MIDI equivalente.

El resumen del artículo es el siguiente:

*Las versiones de piano de música pop son disfrutadas por muchas personas. Sin embargo, la tarea de generar automáticamente versiones de piano de música pop sigue estando poco estudiada. Esto se debe en parte a la falta de pares de datos sincronizados {Pop, Piano Cover}, lo que dificultó la aplicación de los últimos métodos basados en aprendizaje profundo intensivo en datos. Para aprovechar el poder del enfoque basado en datos, creamos una gran cantidad de datos emparejados y sincronizados {Pop, Piano Cover} utilizando un pipeline automatizado. En este artículo, presentamos Pop2Piano, una red Transformer que genera versiones de piano a partir de las formas de onda de la música pop. Según nuestro conocimiento, este es el primer modelo que genera una versión de piano directamente desde audio pop sin utilizar módulos de extracción de melodía y acordes. Mostramos que Pop2Piano, entrenado con nuestro conjunto de datos, es capaz de producir versiones de piano plausibles.*

Este modelo fue aportado por [Susnato Dhar](https://huggingface.co/susnato). El código original se puede encontrar [aquí](https://github.com/sweetcocoa/pop2piano).

## Consejos de uso

* Para usar Pop2Piano, deberá instalar la biblioteca 🤗 Transformers, así como los siguientes módulos de terceros:

```bash
pip install pretty-midi==0.2.9 essentia==2.1b6.dev1034 librosa scipy
```

Tenga en cuenta que es posible que deba reiniciar su entorno de ejecución después de la instalación.

* Pop2Piano es un modelo basado en Encoder-Decoder, similar a T5.
* Pop2Piano se puede utilizar para generar archivos midi-audio para una secuencia de audio dada.
* Elegir diferentes compositores en `Pop2PianoForConditionalGeneration.generate()` puede llevar a una variedad de resultados diferentes.
* Establecer la tasa de muestreo en 44,1 kHz al cargar el archivo de audio puede ofrecer un buen rendimiento.
* Aunque Pop2Piano se entrenó principalmente con música pop coreana, también funciona bastante bien con otras canciones de pop o hip hop occidental.

## Ejemplos

- Ejemplo usando un Dataset de HuggingFace:

```python
from datasets import load_dataset

from transformers import Pop2PianoForConditionalGeneration, Pop2PianoProcessor

model = Pop2PianoForConditionalGeneration.from_pretrained("sweetcocoa/pop2piano", device_map="auto")
processor = Pop2PianoProcessor.from_pretrained("sweetcocoa/pop2piano")
ds = load_dataset("sweetcocoa/pop2piano_ci", split="test")

inputs = processor(
    audio=ds["audio"][0]["array"], sampling_rate=ds["audio"][0]["sampling_rate"], return_tensors="pt"
)
model_output = model.generate(input_features=inputs["input_features"], composer="composer1")
tokenizer_output = processor.batch_decode(
    token_ids=model_output, feature_extractor_output=inputs
)["pretty_midi_objects"][0]
tokenizer_output.write("./Outputs/midi_output.mid")
```

- Ejemplo usando su propio archivo de audio:

```python
import librosa

from transformers import Pop2PianoForConditionalGeneration, Pop2PianoProcessor

audio, sr = librosa.load("<your_audio_file_here>", sr=44100)  # feel free to change the sr to a suitable value.
model = Pop2PianoForConditionalGeneration.from_pretrained("sweetcocoa/pop2piano", device_map="auto")
processor = Pop2PianoProcessor.from_pretrained("sweetcocoa/pop2piano")

inputs = processor(audio=audio, sampling_rate=sr, return_tensors="pt").to(model.device)
model_output = model.generate(input_features=inputs["input_features"], composer="composer1")
tokenizer_output = processor.batch_decode(
    token_ids=model_output, feature_extractor_output=inputs
)["pretty_midi_objects"][0]
tokenizer_output.write("./Outputs/midi_output.mid")
```

- Ejemplo de procesamiento de varios archivos de audio en lote:

```python
import librosa

from transformers import Pop2PianoForConditionalGeneration, Pop2PianoProcessor

# feel free to change the sr to a suitable value.
audio1, sr1 = librosa.load("<your_first_audio_file_here>", sr=44100)
audio2, sr2 = librosa.load("<your_second_audio_file_here>", sr=44100)
model = Pop2PianoForConditionalGeneration.from_pretrained("sweetcocoa/pop2piano", device_map="auto")
processor = Pop2PianoProcessor.from_pretrained("sweetcocoa/pop2piano")

inputs = processor(audio=[audio1, audio2], sampling_rate=[sr1, sr2], return_attention_mask=True, return_tensors="pt").to(model.device)
# Since we now generating in batch(2 audios) we must pass the attention_mask
model_output = model.generate(
    input_features=inputs["input_features"],
    attention_mask=inputs["attention_mask"],
    composer="composer1",
)
tokenizer_output = processor.batch_decode(
    token_ids=model_output, feature_extractor_output=inputs
)["pretty_midi_objects"]

# Since we now have 2 generated MIDI files
tokenizer_output[0].write("./Outputs/midi_output1.mid")
tokenizer_output[1].write("./Outputs/midi_output2.mid")
```

- Ejemplo de procesamiento de varios archivos de audio en lote (usando `Pop2PianoFeatureExtractor` y `Pop2PianoTokenizer`):

```python
import librosa

from transformers import Pop2PianoFeatureExtractor, Pop2PianoForConditionalGeneration, Pop2PianoTokenizer

# feel free to change the sr to a suitable value.
audio1, sr1 = librosa.load("<your_first_audio_file_here>", sr=44100)
audio2, sr2 = librosa.load("<your_second_audio_file_here>", sr=44100)
model = Pop2PianoForConditionalGeneration.from_pretrained("sweetcocoa/pop2piano", device_map="auto")
feature_extractor = Pop2PianoFeatureExtractor.from_pretrained("sweetcocoa/pop2piano")
tokenizer = Pop2PianoTokenizer.from_pretrained("sweetcocoa/pop2piano")

inputs = feature_extractor(
    audio=[audio1, audio2],
    sampling_rate=[sr1, sr2],
    return_attention_mask=True,
    return_tensors="pt",
)
# Since we now generating in batch(2 audios) we must pass the attention_mask
model_output = model.generate(
    input_features=inputs["input_features"],
    attention_mask=inputs["attention_mask"],
    composer="composer1",
)
tokenizer_output = tokenizer.batch_decode(
    token_ids=model_output, feature_extractor_output=inputs
)["pretty_midi_objects"]

# Since we now have 2 generated MIDI files
tokenizer_output[0].write("./Outputs/midi_output1.mid")
tokenizer_output[1].write("./Outputs/midi_output2.mid")
```

## Pop2PianoConfig[[transformers.Pop2PianoConfig]]

#### transformers.Pop2PianoConfig[[transformers.Pop2PianoConfig]]

```python
transformers.Pop2PianoConfig(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, 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, is_encoder_decoder: bool = True, vocab_size: int = 2400, composer_vocab_size: int = 21, d_model: int = 512, d_kv: int = 64, d_ff: int = 2048, num_layers: int = 6, num_decoder_layers: int | None = None, num_heads: int = 8, relative_attention_num_buckets: int = 32, relative_attention_max_distance: int = 128, dropout_rate: float | int = 0.1, layer_norm_epsilon: float = 1e-06, initializer_factor: float = 1.0, feed_forward_proj: str = 'gated-gelu', use_cache: bool = True, pad_token_id: int | None = 0, eos_token_id: int | list[int] | None = 1, dense_act_fn: str = 'relu', is_decoder: bool = False, tie_word_embeddings: bool = True)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/pop2piano/configuration_pop2piano.py#L24)

**Parámetros:**

is_encoder_decoder (`bool`, *opcional*, valor predeterminado `True`) : Indica si el modelo se utiliza como codificador/decodificador o no.

vocab_size (`int`, *opcional*, valor predeterminado `2400`) : Tamaño del vocabulario del modelo. Define el número de tokens diferentes que pueden representarse mediante `input_ids`.

composer_vocab_size (`int`, *opcional*, valor predeterminado 21) : Indica el número de compositores.

d_model (`int`, *opcional*, valor predeterminado `512`) : Tamaño de las capas del codificador y de la capa pooler.

d_kv (`int`, *opcional*, valor predeterminado `64`) : Tamaño de las proyecciones de clave, consulta y valor por cabeza de atención. El `inner_dim` de la capa de proyección se definirá como `num_heads * d_kv`.

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

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

num_decoder_layers (`int`, *opcional*) : Número de capas ocultas en el decodificador del Transformer. Si no se establece, se usará el mismo valor que `num_layers`.

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

relative_attention_num_buckets (`int`, *opcional*, valor predeterminado: 32) : El número de cubos a utilizar en cada capa de atención.

relative_attention_max_distance (`int`, *opcional*, valor predeterminado 128) : La distancia máxima de las secuencias más largas para la separación de cubos.

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

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

initializer_factor (`float`, *opcional*, valor predeterminado `1.0`) : Un factor para inicializar todas las matrices de pesos (debe mantenerse en 1, se usa internamente para pruebas de inicialización).

feed_forward_proj (`string`, *opcional*, por defecto `"gated-gelu"`) : Tipo de capa de avance hacia adelante que se utilizará. Debe ser `"relu"` o `"gated-gelu"`.

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

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

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

dense_act_fn (`string`, *opcional*, valor predeterminado `"relu"`) : Tipo de función de activación que se utilizará en `Pop2PianoDenseActDense` y en `Pop2PianoDenseGatedActDense`.

is_decoder (`bool`, *opcional*, valor predeterminado `False`) : Indica si el modelo se utiliza como decodificador. Si es `False`, el modelo se utiliza como codificador.

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

Esta es la clase de configuración para almacenar la configuración de un Pop2PianoModel. Se utiliza para instanciar un modelo Pop2Piano 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 [sweetcocoa/pop2piano](https://huggingface.co/sweetcocoa/pop2piano)

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

## Pop2PianoFeatureExtractor[[transformers.Pop2PianoFeatureExtractor]]

#### transformers.Pop2PianoFeatureExtractor[[transformers.Pop2PianoFeatureExtractor]]

```python
transformers.Pop2PianoFeatureExtractor(sampling_rate: int = 22050, padding_value: int = 0, window_size: int = 4096, hop_length: int = 1024, min_frequency: float = 10.0, feature_size: int = 512, num_bars: int = 2, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/pop2piano/feature_extraction_pop2piano.py#L49)

**Parámetros:**

sampling_rate (`int`, *opcional*, valor predeterminado 22050) : Tasa de muestreo objetivo de la señal de audio. Es la tasa de muestreo que se envía al modelo.

padding_value (`int`, *opcional*, valor predeterminado 0) : Valor de relleno utilizado para rellenar el audio. Debe corresponder a silencios.

window_size (`int`, *opcional*, valor predeterminado 4096) : Longitud de la ventana en muestras a la que se aplica la transformada de Fourier.

hop_length (`int`, *opcional*, valor predeterminado 1024) : Tamaño del paso entre cada ventana de la forma de onda, en muestras.

min_frequency (`float`, *opcional*, valor predeterminado 10.0) : Frecuencia mínima que se utilizará en el espectrograma log-mel.

feature_size (`int`, *opcional*, valor predeterminado 512) : La dimensión de las características de las características extraídas.

num_bars (`int`, *opcional*, valor predeterminado 2) : Determina el intervalo entre cada secuencia.

Construye un extractor de características Pop2Piano.

Este extractor de características hereda de [SequenceFeatureExtractor](/docs/transformers/v5.23.0/es/main_classes/feature_extractor#transformers.SequenceFeatureExtractor), que contiene la mayoría de los métodos principales. Los usuarios deben consultar esta superclase para obtener más información sobre dichos métodos.

Esta clase extrae el ritmo y preprocesa el audio antes de pasarlo al modelo. Primero, el audio se pasa al algoritmo `RhythmExtractor2013`, que extrae los beat_times, las posiciones de los beats y estima su confianza, así como el tempo en bpm. A continuación, beat_times se interpola para obtener beatsteps. Después, se calcula extrapolated_beatsteps a partir de ello para usarlo en el tokenizer. Por otro lado, el audio se re-muestrea a self.sampling_rate y se preprocesa, y luego se calcula el espectrograma log mel a partir de él para usarlo en nuestro modelo transformer.

#### __llamada__[[transformers.Pop2PianoFeatureExtractor.__call__]]

```python
__call__(audio: numpy.ndarray | list[float] | list[numpy.ndarray] | list[list[float]], sampling_rate: int | list[int], steps_per_beat: int = 2, resample: bool | None = True, return_attention_mask: bool | None = False, return_tensors: str | transformers.utils.generic.TensorType | None = None, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/pop2piano/feature_extraction_pop2piano.py#L341)

**Parámetros:**

audio (`np.ndarray`, `List`) : El audio o lote de audios a procesar. Cada audio puede ser un array de numpy, una lista de valores flotantes, una lista de arrays de numpy o una lista de listas de valores flotantes.

sampling_rate (`int`) : La tasa de muestreo a la que se muestreó la entrada `audio`. Se recomienda encarecidamente pasar `sampling_rate` en la llamada forward para evitar errores silenciosos.

steps_per_beat (`int`, *opcional*, valor predeterminado 2) : Se utiliza para interpolar `beat_times`.

resample (`bool`, *opcional*, valor predeterminado `True`) : Determina si se debe re-muestrear el audio a `sampling_rate` antes de procesarlo. Debe ser True durante la inferencia.

return_attention_mask (`bool` *opcional*, valor predeterminado `False`) : Indica si se proporcionará o no attention_mask para input_features, beatsteps y extrapolated_beatstep como salida. Se establece automáticamente en True para entradas por lotes.

return_tensors (`str` o [TensorType](/docs/transformers/v5.23.0/es/internal/file_utils#transformers.TensorType), *opcional*) : Si se establece, devolverá tensores en lugar de listas de enteros de Python. Los valores aceptables son: - `'pt'`: Devuelve objetos `torch.Tensor` de PyTorch. - `'np'`: Devuelve objetos `np.ndarray` de Numpy. Si no se especifica nada, devolverá una lista de matrices `np.ndarray`.

Método principal para extraer características y preparar los datos para el modelo.

## Pop2PianoForConditionalGeneration[[transformers.Pop2PianoForConditionalGeneration]]

#### transformers.Pop2PianoForConditionalGeneration[[transformers.Pop2PianoForConditionalGeneration]]

```python
transformers.Pop2PianoForConditionalGeneration(config: Pop2PianoConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/pop2piano/modeling_pop2piano.py#L763)

**Parámetros:**

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

Modelo Pop2Piano con una cabeza de `language modeling` en la parte superior.

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

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

#### forward[[transformers.Pop2PianoForConditionalGeneration.forward]]

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/pop2piano/modeling_pop2piano.py#L851)

**Parámetros:**

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices de los tokens de la secuencia de entrada en el vocabulario. Pop2Piano es un modelo con incrustaciones de posición relativa, por lo que debe poder rellenar las entradas tanto a la derecha como a la izquierda. Los índices se pueden obtener usando [AutoTokenizer](/docs/transformers/v5.23.0/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para más detalles. [¿Qué son los input IDs?](../glossary#input-ids) Para saber más sobre cómo preparar `input_ids` para el preentrenamiento, eche un vistazo a [Pop2Piano Training](./Pop2Piano#training).

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)

decoder_input_ids (`torch.LongTensor` de forma `(batch_size, target_sequence_length)`, *opcional*) : Índices de los tokens de la secuencia de entrada del decodificador en el vocabulario. Los índices se pueden obtener usando [AutoTokenizer](/docs/transformers/v5.23.0/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para más detalles. [¿Qué son los IDs de entrada del decodificador?](../glossary#decoder-input-ids) Pop2Piano utiliza `pad_token_id` como token inicial para la generación de `decoder_input_ids`. Si se utiliza `past_key_values`, opcionalmente solo se deben introducir los últimos `decoder_input_ids` (consulte `past_key_values`). Para saber más sobre cómo preparar

decoder_attention_mask (`torch.BoolTensor` de forma `(batch_size, target_sequence_length)`, *opcional*) : Comportamiento predeterminado: genera un tensor que ignora los tokens de relleno en `decoder_input_ids`. También se usará una máscara causal de forma predeterminada.

encoder_outputs (`tuple[tuple[torch.Tensor]]`, *opcional*) : La tupla consiste en (`last_hidden_state`, *opcional*: `hidden_states`, *opcional*: `attentions`) `last_hidden_state` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) es una secuencia de estados ocultos en la salida de la última capa del codificador. Se utiliza en la atención cruzada del decodificador.

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

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_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 utilizando [Pop2PianoFeatureExtractor](/docs/transformers/v5.23.0/es/model_doc/pop2piano#transformers.Pop2PianoFeatureExtractor). Consulte [Pop2PianoFeatureExtractor.__call__()](/docs/transformers/v5.23.0/es/model_doc/pop2piano#transformers.Pop2PianoFeatureExtractor.__call__) para más detalles ([Pop2PianoProcessor](/docs/transformers/v5.23.0/es/model_doc/pop2piano#transformers.Pop2PianoProcessor) utiliza [Pop2PianoFeatureExtractor](/docs/transformers/v5.23.0/es/model_doc/pop2piano#transformers.Pop2PianoFeatureExtractor) para procesar audios).

decoder_inputs_embeds (`torch.Tensor` de forma `(batch_size, target_sequence_length, hidden_size)`, *opcional*) : Opcionalmente, en lugar de pasar `decoder_input_ids`, puedes elegir pasar directamente una representación incrustada. Si se usa `past_key_values`, opcionalmente solo se deben introducir los últimos `decoder_inputs_embeds` (ver `past_key_values`). Esto es útil si deseas tener más control sobre cómo convertir los índices de `decoder_input_ids` en los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo. Si `decoder_input_ids` y `decoder_inputs_embeds` no están configurados, `decoder_inputs_embeds` toma el valor de `inputs_embeds`.

labels (`torch.LongTensor` de forma `(batch_size,)`, *opcional*) : Etiquetas para calcular la pérdida de clasificación/regresión de secuencia. Los índices deben estar en `[-100, 0, ..., config.vocab_size - 1]`. Todas las etiquetas establecidas en `-100` se ignoran (se enmascaran); la pérdida solo se calcula para las etiquetas en `[0, ..., config.vocab_size]`

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:** [Seq2SeqLMOutput](/docs/transformers/v5.23.0/es/main_classes/output#transformers.modeling_outputs.Seq2SeqLMOutput) o `tuple(torch.Tensor)`

Un [Seq2SeqLMOutput](/docs/transformers/v5.23.0/es/main_classes/output#transformers.modeling_outputs.Seq2SeqLMOutput) 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 ([Pop2PianoConfig](/docs/transformers/v5.23.0/es/model_doc/pop2piano#transformers.Pop2PianoConfig)) y las entradas.

El método forward de [Pop2PianoForConditionalGeneration](/docs/transformers/v5.23.0/es/model_doc/pop2piano#transformers.Pop2PianoForConditionalGeneration) 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.
- **logits** (`torch.Tensor` de forma `(batch_size, sequence_length, config.vocab_size)`) -- Puntuaciones de predicción de la cabeza de modelado de lenguaje (puntuaciones para cada token del vocabulario antes de SoftMax).
- **past_key_values** (`EncoderDecoderCache`, *opcional*, se devuelve cuando se pasa `use_cache=True` o cuando `config.use_cache=True`) -- Es una instancia de [EncoderDecoderCache](/docs/transformers/v5.23.0/es/internal/generation_utils#transformers.EncoderDecoderCache). 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 en los bloques de atención cruzada) que se pueden utilizar (véase la entrada `past_key_values`) para acelerar la decodificación secuencial.
- **decoder_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 decodificador en la salida de cada capa más las salidas de la incrustación inicial.
- **decoder_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 del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
- **cross_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 de la capa de atención cruzada del decodificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de atención cruzada.
- **encoder_last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) -- Secuencia de estados ocultos en la salida de la última capa del codificador del modelo.
- **encoder_hidden_states** (`tuple(torch.Tensor)`, *opcional*, devuelto 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 codificador en la salida de cada capa más las salidas de la incrustación inicial.
- **encoder_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 del codificador, después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

Ejemplo:

```python
>>> from transformers import AutoProcessor, Pop2PianoForConditionalGeneration
>>> from datasets import load_dataset
>>> import torch

>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
>>> dataset = dataset.sort("id")
>>> sampling_rate = dataset.features["audio"].sampling_rate

>>> processor = AutoProcessor.from_pretrained("sweetcocoa/pop2piano")
>>> model = Pop2PianoForConditionalGeneration.from_pretrained("sweetcocoa/pop2piano")

>>> # audio file is decoded on the fly
>>> inputs = processor(dataset[0]["audio"]["array"], sampling_rate=sampling_rate, return_tensors="pt")
>>> with torch.no_grad():
...     logits = model(**inputs).logits
>>> predicted_ids = torch.argmax(logits, dim=-1)

>>> # transcribe speech
>>> transcription = processor.batch_decode(predicted_ids)
>>> transcription[0]
...

>>> inputs["labels"] = processor(text=dataset[0]["text"], return_tensors="pt").input_ids

>>> # compute loss
>>> loss = model(**inputs).loss
>>> round(loss.item(), 2)
...
```

#### generate[[transformers.Pop2PianoForConditionalGeneration.generate]]

```python
generate(input_features, attention_mask = None, composer = 'composer1', generation_config = None, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/pop2piano/modeling_pop2piano.py#L953)

**Parámetros:**

input_features (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Esta es la versión con características de audio generada por `Pop2PianoFeatureExtractor`.

attention_mask : Para la generación por lotes, `input_features` se rellenan para que tengan la misma forma en todos los ejemplos. `attention_mask` ayuda a determinar qué áreas se rellenaron y cuáles no. - 1 para los tokens que **no están rellenados**, - 0 para los tokens que **están rellenados**.

composer (`str`, *opcional*, valor predeterminado `"composer1"`) : Este valor se pasa a `Pop2PianoConcatEmbeddingToMel` para generar diferentes embeddings para cada `"composer"`. Asegúrese de que el valor de composer esté presente en `composer_to_feature_token` dentro de `generation_config`. Para un ejemplo, consulte https://huggingface.co/sweetcocoa/pop2piano/blob/main/generation_config.json .

generation_config (`~generation.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/v5.23.0/es/main_classes/text_generation#transformers.GenerationConfig), cuya documentación debe consultarse para parametrizar la generación.

kwargs : Parametrización ad hoc de `generate_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/v5.23.0/es/main_classes/output#transformers.utils.ModelOutput) o `torch.LongTensor`

Un [ModelOutput](/docs/transformers/v5.23.0/es/main_classes/output#transformers.utils.ModelOutput) (si `return_dict_in_generate=True` o cuando `config.return_dict_in_generate=True`) o un `torch.Tensor`. Dado que Pop2Piano es un modelo codificador-decodificador (`model.config.is_encoder_decoder=True`), los tipos de [ModelOutput](/docs/transformers/v5.23.0/es/main_classes/output#transformers.utils.ModelOutput) posibles son:
- [GenerateEncoderDecoderOutput](/docs/transformers/v5.23.0/es/internal/generation_utils#transformers.generation.GenerateEncoderDecoderOutput),
- [GenerateBeamEncoderDecoderOutput](/docs/transformers/v5.23.0/es/internal/generation_utils#transformers.generation.GenerateBeamEncoderDecoderOutput)

Genera ids de tokens para las salidas midi.

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. Puedes sobrescribir cualquier `generation_config` pasando los parámetros correspondientes a generate(), por ejemplo, `.generate(inputs, num_beams=4, do_sample=True)`. Para una visión general de las estrategias de generación y ejemplos de código, consulta la [siguiente guía](./generation_strategies).

## Pop2PianoTokenizer[[transformers.Pop2PianoTokenizer]]

#### transformers.Pop2PianoTokenizer[[transformers.Pop2PianoTokenizer]]

```python
transformers.Pop2PianoTokenizer(vocab, default_velocity = 77, num_bars = 2, unk_token = '-1', eos_token = '1', pad_token = '0', bos_token = '2', **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/pop2piano/tokenization_pop2piano.py#L62)

**Parámetros:**

vocab (`str`) : Ruta al archivo de vocabulario que contiene el vocabulario.

default_velocity (`int`, *opcional*, valor predeterminado: 77) : Determina la velocidad predeterminada que se utilizará al crear notas MIDI.

num_bars (`int`, *opcional*, valor predeterminado 2) : Determina cutoff_time_idx para cada token.

unk_token (`str` o `tokenizers.AddedToken`, *opcional*, valor predeterminado `"-1"`) : El token desconocido. Un token que no está en el vocabulario no se puede convertir en un ID y se establece como este token en su lugar.

eos_token (`str` o `tokenizers.AddedToken`, *opcional*, valor predeterminado 1) : El token de fin de secuencia.

pad_token (`str` o `tokenizers.AddedToken`, *opcional*, valor predeterminado 0) : Un token especial utilizado para que los arreglos de tokens tengan el mismo tamaño con fines de lotes. Luego será ignorado por los mecanismos de atención o el cálculo de la pérdida.

bos_token (`str` o `tokenizers.AddedToken`, *opcional*, valor predeterminado 2) : El token de inicio de secuencia que se utilizó durante el preentrenamiento. Puede usarse como token de clasificador de secuencias.

Construye un tokenizador Pop2Piano. Este tokenizador no requiere entrenamiento.

Este tokenizador hereda de [PreTrainedTokenizer](/docs/transformers/v5.23.0/es/main_classes/tokenizer#transformers.PythonBackend), que contiene la mayoría de los métodos principales. Los usuarios deben consultar esta superclase para obtener más información sobre dichos métodos.

#### __llamada__[[transformers.Pop2PianoTokenizer.__call__]]

```python
__call__(notes: numpy.ndarray | list[pretty_midi.Note] | list[list[pretty_midi.Note]], padding: bool | str | transformers.utils.generic.PaddingStrategy = False, truncation: bool | str | transformers.tokenization_utils_base.TruncationStrategy | None = None, max_length: int | None = None, pad_to_multiple_of: int | None = None, return_attention_mask: bool | None = None, return_tensors: str | transformers.utils.generic.TensorType | None = None, verbose: bool = True, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/pop2piano/tokenization_pop2piano.py#L473)

**Parámetros:**

notes (`numpy.ndarray` de forma `[batch_size, max_sequence_length, 4]` o `list` de objetos `pretty_midi.Note`) : Esto representa las notas MIDI. Si `notes` es un `numpy.ndarray`: - Cada secuencia debe tener 4 valores, que son `onset idx`, `offset idx`, `pitch` y `velocity`. Si `notes` es una `list` que contiene objetos `pretty_midi.Note`: - Cada secuencia debe tener 4 atributos, que son `start`, `end`, `pitch` y `velocity`.

padding (`bool`, `str` o [PaddingStrategy](/docs/transformers/v5.23.0/es/internal/file_utils#transformers.utils.PaddingStrategy), *opcional*, valor predeterminado `False`) : Activa y controla el relleno. Acepta los siguientes valores:  - `True` o `'longest'`: Rellena hasta la secuencia más larga del lote (o no aplica relleno si solo se proporciona una secuencia). - `'max_length'`: Rellena hasta una longitud máxima especificada con el argumento `max_length` o hasta la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento. - `False` o `'do_not_pad'` (predeterminado): Sin relleno (es decir, puede generar un lote con secuencias de longitudes diferentes).

truncation (`bool`, `str` o [TruncationStrategy](/docs/transformers/v5.23.0/es/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy), *opcional*, valor predeterminado `False`) : Activa y controla la truncación. Acepta los siguientes valores:  - `True` o `'longest_first'`: Trunca hasta una longitud máxima especificada con el argumento `max_length` o hasta la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento. Esto truncará token por token, eliminando un token de la secuencia más larga de la pareja si se proporciona una pareja de secuencias (o un lote de parejas). - `'only_first'`: Trunca hasta una longitud máxima especificada con el argumento `max_length` o hasta la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento. Esto solo truncará la primera secuencia de una pareja si se proporciona una pareja de secuencias (o un lote de parejas). - `'only_second'`: Trunca hasta una longitud máxima especificada con el argumento `max_length` o hasta la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento. Esto solo truncará la segunda secuencia de una pareja si se proporciona una pareja de secuencias (o un lote de parejas). - `False` o `'do_not_truncate'` (predeterminado): Sin truncación (es decir, puede generar un lote con longitudes de secuencia mayores que el tamaño máximo de entrada admisible del modelo).

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

pad_to_multiple_of (`int`, *opcional*) : Si se establece, rellenará la secuencia hasta un múltiplo del valor proporcionado. Esto resulta especialmente útil para habilitar el uso de Tensor Cores en hardware de NVIDIA con capacidad de cálculo `>= 7.5` (Volta).

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

return_tensors (`str` o [TensorType](/docs/transformers/v5.23.0/es/internal/file_utils#transformers.TensorType), *opcional*) : Si se establece, devolverá tensores en lugar de listas de enteros de Python. Los valores aceptables son:  - `'pt'`: Devuelve objetos `torch.Tensor` de PyTorch. - `'np'`: Devuelve objetos `np.ndarray` de Numpy.

verbose (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe imprimir más información y advertencias.

**Devuelve:**

`BatchEncoding` que contiene los token_ids.

Este es el método `__call__` de `Pop2PianoTokenizer`. Convierte las notas midi en los ids de tokens generados por el transformer.

## Pop2PianoProcessor[[transformers.Pop2PianoProcessor]]

#### transformers.Pop2PianoProcessor[[transformers.Pop2PianoProcessor]]

```python
transformers.Pop2PianoProcessor(feature_extractor, tokenizer)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/pop2piano/processing_pop2piano.py#L29)

**Parámetros:**

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

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

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

[Pop2PianoProcessor](/docs/transformers/v5.23.0/es/model_doc/pop2piano#transformers.Pop2PianoProcessor) ofrece todas las funcionalidades de [Pop2PianoFeatureExtractor](/docs/transformers/v5.23.0/es/model_doc/pop2piano#transformers.Pop2PianoFeatureExtractor) y `tokenizer_class`. Consulte [~Pop2PianoFeatureExtractor](/docs/transformers/v5.23.0/es/model_doc/pop2piano#transformers.Pop2PianoFeatureExtractor) y `~tokenizer_class` para obtener más información.

#### __llamada__[[transformers.Pop2PianoProcessor.__call__]]

```python
__call__(audio: numpy.ndarray | list[float] | list[numpy.ndarray] = None, sampling_rate: int | list[int] | None = None, steps_per_beat: int = 2, resample: bool | None = True, notes: list | transformers.utils.generic.TensorType = None, padding: bool | str | transformers.utils.generic.PaddingStrategy = False, truncation: bool | str | transformers.tokenization_utils_base.TruncationStrategy = None, max_length: int | None = None, pad_to_multiple_of: int | None = None, verbose: bool = True, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/pop2piano/processing_pop2piano.py#L33)

**Parámetros:**

audio (`Union[numpy.ndarray, list[float], list[numpy.ndarray]]`, *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 muestra del audio.

sampling_rate (`int` o `list[int]`, *opcional*) : La tasa de muestreo del audio de entrada en Hz. Debe coincidir con la tasa de muestreo utilizada por el extractor de características. Si no se proporciona, se utilizará la tasa de muestreo predeterminada de la configuración del procesador.

steps_per_beat (`int`, *opcional*, valor predeterminado `2`) : El número de pasos de tiempo por pulso musical. Este parámetro controla la resolución temporal de la representación musical. Un valor más alto proporciona una granularidad temporal más fina, pero aumenta la longitud de la secuencia. Se utiliza al procesar audio para extraer características musicales.

resample (`bool`, *opcional*, valor predeterminado `True`) : Filtro de remuestreo que se utilizará si se redimensiona la imagen. Puede ser uno de los valores de la enumeración `PILImageResampling`. Solo tiene efecto si `do_resize` está establecido en `True`.

notes (`list` o `TensorType`, *opcional*) : Notas musicales preextraídas en formato MIDI. Cuando se proporciona, el procesador omite la extracción de características de audio y procesa directamente las notas a través del tokenizador. Cada nota debe representarse como una lista o tensor que contenga información de tono, velocidad y temporización.

padding (bool, str o [PaddingStrategy](/docs/transformers/v5.23.0/es/internal/file_utils#transformers.utils.PaddingStrategy), *opcional*, valor predeterminado `False`) : Activa y controla el relleno. Acepta los siguientes valores:  - `True` o `'longest'`: Rellena hasta la secuencia más larga del lote (o no aplica relleno si solo se proporciona una secuencia). - `'max_length'`: Rellena hasta una longitud máxima especificada con el argumento `max_length` o hasta la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento. - `False` o `'do_not_pad'` (predeterminado): Sin relleno (es decir, puede generar un lote con secuencias de longitudes diferentes).

truncation (bool, str o [TruncationStrategy](/docs/transformers/v5.23.0/es/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy), *opcional*) : Activa y controla la truncación. Acepta los siguientes valores:  - `True` o `'longest_first'`: Trunca hasta una longitud máxima especificada con el argumento `max_length` o hasta la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento. Esto truncará token a token, eliminando un token de la secuencia más larga de la pareja si se proporciona una pareja de secuencias (o un lote de parejas). - `'only_first'`: Trunca hasta una longitud máxima especificada con el argumento `max_length` o hasta la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento. Esto solo truncará la primera secuencia de una pareja si se proporciona una pareja de secuencias (o un lote de parejas). - `'only_second'`: Trunca hasta una longitud máxima especificada con el argumento `max_length` o hasta la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento. Esto solo truncará la segunda secuencia de una pareja si se proporciona una pareja de secuencias (o un lote de parejas). - `False` o `'do_not_truncate'` (predeterminado): Sin truncación (es decir, puede generar un lote con longitudes de secuencia mayores que el tamaño de entrada máximo admisible del modelo).

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

pad_to_multiple_of (`int`, *opcional*) : Si se establece, rellenará la secuencia hasta un múltiplo del valor proporcionado. Requiere que `padding` esté activado. Esto es especialmente útil para habilitar el uso de Tensor Cores en hardware de NVIDIA con capacidad de cálculo `>= 7.5` (Volta).

verbose (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe imprimir más información y advertencias.

return_tensors (`str` o [TensorType](/docs/transformers/v5.23.0/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.

**Devuelve:**

`Union[~feature_extraction_utils.BatchFeature, ~tokenization_utils_base.BatchEncoding]`

