# Pop2Piano

## Aperçu

Le modèle Pop2Piano a été proposé dans [Pop2Piano : Pop Audio-based Piano Cover Generation](https://huggingface.co/papers/2211.00895) par Jongho Choi et Kyogu Lee.

Les reprises au piano de la musique pop sont très appréciées, mais leur génération à partir d’une musique n’est pas une tâche triviale. Elle exige une grande maîtrise du jeu au piano ainsi qu’une connaissance des différentes caractéristiques et mélodies d’une chanson. Avec Pop2Piano, vous pouvez générer directement une reprise à partir de la forme d’onde audio d’une chanson. C’est le premier modèle à générer directement une reprise au piano à partir d’audio pop, sans modules d’extraction de mélodie et d’accords.

Pop2Piano est un modèle Transformer encodeur-décodeur basé sur [T5](https://huggingface.co/papers/1910.10683). L’audio d’entrée est converti en forme d’onde puis transmis à l’encodeur, qui le transforme en une représentation latente. Le décodeur utilise ces représentations latentes pour générer des identifiants de jetons de manière autorégressive. Chaque identifiant de jeton correspond à l’un des quatre types de jetons : temps, vélocité, note et « spécial ». Les identifiants de jetons sont ensuite décodés en fichier MIDI équivalent.

L'abstract de l'article est le suivant :

*Les arrangements pour piano de la musique pop sont appréciés de nombreuses personnes. Toutefois, la tâche de génération automatique d’arrangements pour piano de la musique pop reste peu étudiée. Cela est en partie dû au manque de paires de données synchronisées {Pop, Piano Cover}, ce qui a rendu difficile l’application des méthodes récentes basées sur l’apprentissage profond et intensives en données. Pour exploiter la puissance de l’approche pilotée par les données, nous avons constitué un grand volume de données appariées et synchronisées {Pop, Piano Cover} à l’aide d’un pipeline automatisé. Dans cet article, nous présentons Pop2Piano, un réseau Transformer qui génère des arrangements pour piano à partir des formes d’onde de la musique pop. À notre connaissance, il s’agit du premier modèle à générer un arrangement pour piano directement à partir d’audio pop, sans recourir à des modules d’extraction de mélodie et d’accords. Nous montrons que Pop2Piano, entraîné sur notre jeu de données, est capable de produire des arrangements pour piano plausibles.*

Ce modèle a été contribué par [Susnato Dhar](https://huggingface.co/susnato). Le code d'origine est disponible [ici](https://github.com/sweetcocoa/pop2piano).

## Conseils d'utilisation

* Pour utiliser Pop2Piano, vous devrez installer la bibliothèque 🤗 Transformers ainsi que les modules tiers suivants :

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

Veuillez noter que vous devrez peut-être redémarrer votre environnement d'exécution après l'installation.

* Pop2Piano est un modèle basé sur une architecture Encoder-Decoder, comme T5.
* Pop2Piano peut être utilisé pour générer des fichiers midi-audio pour une séquence audio donnée.
* Le choix de différents compositeurs dans `Pop2PianoForConditionalGeneration.generate()` peut entraîner une variété de résultats différents.
* Définir le taux d'échantillonnage à 44,1 kHz lors du chargement du fichier audio peut donner de bonnes performances.
* Bien que Pop2Piano ait été principalement entraîné sur de la musique Pop coréenne, il fonctionne également très bien sur d'autres chansons Pop ou Hip Hop occidentales.

## Exemples

- Exemple utilisant un jeu de données 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")
```

- Exemple utilisant votre propre fichier 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")
```

- Exemple de traitement de plusieurs fichiers audio par lot :

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

- Exemple de traitement de plusieurs fichiers audio par lot (en utilisant `Pop2PianoFeatureExtractor` et `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)
```

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

**Paramètres :**

is_encoder_decoder (`bool`, *facultatif*, valeur par défaut `True`) : Indique si le modèle est utilisé comme encodeur/décodeur ou non.

vocab_size (`int`, *facultatif*, valeur par défaut `2400`) : Taille du vocabulaire du modèle. Définit le nombre de jetons différents qui peuvent être représentés par `input_ids`.

composer_vocab_size (`int`, *facultatif*, valeur par défaut : 21) : Indique le nombre de compositeurs.

d_model (`int`, *facultatif*, valeur par défaut `512`) : Taille des couches d'encodeur et de la couche pooler.

d_kv (`int`, *facultatif*, valeur par défaut `64`) : Taille des projections de clé, requête et valeur par tête d'attention. Le `inner_dim` de la couche de projection sera défini comme `num_heads * d_kv`.

d_ff (`int`, *facultatif*, valeur par défaut `2048`) : Dimension des représentations MLP.

num_layers (`int`, *facultatif*, valeur par défaut `6`) : Nombre de couches cachées dans le décodeur Transformer.

num_decoder_layers (`int`, *facultatif*) : Nombre de couches cachées dans le décodeur Transformer. Utilise la même valeur que `num_layers` si non défini.

num_heads (`int`, *facultatif*, valeur par défaut `8`) : Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer.

relative_attention_num_buckets (`int`, *facultatif*, valeur par défaut : 32) : Le nombre de buckets à utiliser pour chaque couche d'attention.

relative_attention_max_distance (`int`, *facultatif*, valeur par défaut 128) : La distance maximale des séquences les plus longues pour la séparation des buckets.

dropout_rate (`Union[float, int]`, *facultatif*, valeur par défaut `0.1`) : Le ratio pour toutes les couches de dropout.

layer_norm_epsilon (`float`, *facultatif*, par défaut `1e-06`) : L'épsilon utilisé par les couches de normalisation par couche.

initializer_factor (`float`, *facultatif*, par défaut `1.0`) : Un facteur pour l'initialisation de toutes les matrices de poids (doit être maintenu à 1, utilisé en interne pour les tests d'initialisation).

feed_forward_proj (`string`, *facultatif*, par défaut `"gated-gelu"`) : Type de couche de feed forward à utiliser. Doit être l'un des `"relu"` ou `"gated-gelu"`.

use_cache (`bool`, *facultatif*, valeur par défaut `True`) : Indique si le modèle doit retourner les dernières attentions clés/valeurs (non utilisé par tous les modèles). Pertinent uniquement si `config.is_decoder=True` ou si le modèle est un modèle génératif de type décodeur uniquement.

pad_token_id (`int`, *facultatif*, valeur par défaut `0`) : Identifiant du jeton utilisé pour le bourrage dans le vocabulaire.

eos_token_id (`Union[int, list[int]]`, *facultatif*, valeur par défaut `1`) : Identifiant de jeton utilisé pour la fin de flux dans le vocabulaire.

dense_act_fn (`string`, *facultatif*, valeur par défaut `"relu"`) : Type de fonction d'activation à utiliser dans `Pop2PianoDenseActDense` et dans `Pop2PianoDenseGatedActDense`.

is_decoder (`bool`, *facultatif*, valeur par défaut `False`) : Indique si le modèle est utilisé comme décodeur. Si `False`, le modèle est utilisé comme encodeur.

tie_word_embeddings (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut lier les embeddings de poids selon la correspondance `tied_weights_keys` du modèle.

Ceci est la classe de configuration destinée à stocker la configuration d'un Pop2PianoModel. Elle est utilisée pour instancier un modèle Pop2Piano en fonction des arguments spécifiés, en définissant l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de [sweetcocoa/pop2piano](https://huggingface.co/sweetcocoa/pop2piano)

Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/v5.23.0/fr/main_classes/configuration#transformers.PreTrainedConfig) et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de [PreTrainedConfig](/docs/transformers/v5.23.0/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations.

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

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

**Paramètres :**

sampling_rate (`int`, *facultatif*, valeur par défaut 22050) : Fréquence d'échantillonnage cible du signal audio. Il s'agit de la fréquence d'échantillonnage transmise au modèle.

padding_value (`int`, *facultatif*, valeur par défaut 0) : Valeur de bourrage utilisée pour bourrer l'audio. Doit correspondre à des silences.

window_size (`int`, *facultatif*, valeur par défaut 4096) : Longueur de la fenêtre en échantillons à laquelle la transformée de Fourier est appliquée.

hop_length (`int`, *facultatif*, valeur par défaut 1024) : Taille du pas entre chaque fenêtre de la forme d'onde, en échantillons.

min_frequency (`float`, *facultatif*, par défaut 10.0) : Fréquence minimale utilisée dans le spectrogramme log-mel.

feature_size (`int`, *facultatif*, valeur par défaut : 512) : La dimension des caractéristiques des fonctionnalités extraites.

num_bars (`int`, *facultatif*, valeur par défaut : 2) : Détermine l'intervalle entre chaque séquence.

Construit un extracteur de fonctionnalités Pop2Piano.

Cet extracteur de caractéristiques hérite de [SequenceFeatureExtractor](/docs/transformers/v5.23.0/fr/main_classes/feature_extractor#transformers.SequenceFeatureExtractor), qui contient la plupart des méthodes principales. Les utilisateurs doivent se reporter à cette superclasse pour plus d'informations sur ces méthodes.

Cette classe extrait le rythme et prétraite l’audio avant de le transmettre au modèle. D’abord, l’audio est passé à l’algorithme `RhythmExtractor2013`, qui extrait les beat_times, les positions des battements et estime leur confiance ainsi que le tempo en bpm. Ensuite, beat_times est interpolé pour obtenir les beatsteps. Par la suite, nous calculons extrapolated_beatsteps à partir de celui-ci, afin qu’il soit utilisé dans le tokenizer. D’autre part, l’audio est rééchantillonné à self.sampling_rate et prétraité, puis le spectrogramme log mel est calculé à partir de celui-ci pour être utilisé dans notre modèle transformer.

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

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

**Paramètres :**

audio (`np.ndarray`, `List`) : L'audio ou le lot d'audios à traiter. Chaque audio peut être un tableau numpy, une liste de valeurs flottantes, une liste de tableaux numpy ou une liste de listes de valeurs flottantes.

sampling_rate (`int`) : Le taux d'échantillonnage auquel l'entrée `audio` a été échantillonnée. Il est fortement recommandé de passer `sampling_rate` lors de l'appel forward afin d'éviter les erreurs silencieuses.

steps_per_beat (`int`, *facultatif*, valeur par défaut : 2) : Utilisé pour l'interpolation de `beat_times`.

resample (`bool`, *facultatif*, valeur par défaut `True`) : Détermine s'il faut rééchantillonner l'audio en `sampling_rate` avant le traitement. Doit être True pendant l'inférence.

return_attention_mask (`bool` *facultatif*, par défaut `False`) : Indique si attention_mask pour input_features, beatsteps et extrapolated_beatstep sera fourni en sortie ou non. Défini automatiquement sur True pour les entrées par lot.

return_tensors (`str` ou [TensorType](/docs/transformers/v5.23.0/fr/internal/file_utils#transformers.TensorType), *facultatif*) : Si défini, renverra des tenseurs au lieu d'une liste d'entiers Python. Les valeurs acceptables sont : - `'pt'` : Renvoie des objets `torch.Tensor` de PyTorch. - `'np'` : Renvoie des objets `np.ndarray` de Numpy. Si rien n'est spécifié, renverra une liste de tableaux `np.ndarray`.

Méthode principale pour la vectorisation et la préparation pour le modèle.

## Pop2PianoForConditionalGeneration[[transformers.Pop2PianoForConditionalGeneration]]

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

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

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

**Paramètres :**

config ([Pop2PianoConfig](/docs/transformers/v5.23.0/fr/model_doc/pop2piano#transformers.Pop2PianoConfig)) : Classe de configuration du modèle contenant tous les paramètres du modèle. L'initialisation à partir d'un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle.

Modèle Pop2Piano avec une tête de `language modeling` au sommet.

Ce modèle hérite de [PreTrainedModel](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.).

Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux.

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

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

**Paramètres :**

input_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`) : Indices des jetons de la séquence d'entrée dans le vocabulaire. Pop2Piano est un modèle avec des embeddings de position relative, vous devriez donc pouvoir rembourrer les entrées à la fois à droite et à gauche. Les indices peuvent être obtenus à l'aide de [AutoTokenizer](/docs/transformers/v5.23.0/fr/model_doc/auto#transformers.AutoTokenizer). Consultez [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) pour plus de détails. [Que sont les input IDs ?](../glossary#input-ids) Pour en savoir plus sur la préparation de `input_ids` pour le pré-entraînement, consultez [Pop2Piano Training](./Pop2Piano#training).

attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask)

decoder_input_ids (`torch.LongTensor` de forme `(batch_size, target_sequence_length)`, *facultatif*) : Indices des jetons de la séquence d’entrée du décodeur dans le vocabulaire. Les indices peuvent être obtenus à l’aide de [AutoTokenizer](/docs/transformers/v5.23.0/fr/model_doc/auto#transformers.AutoTokenizer). Consultez [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) pour plus de détails. [Que sont les IDs d’entrée du décodeur ?](../glossary#decoder-input-ids) Pop2Piano utilise `pad_token_id` comme jeton de départ pour la génération de `decoder_input_ids`. Si `past_key_values` est utilisé, il est facultatif de n’entrer que les derniers `decoder_input_ids` (voir `past_key_values`). Pour en savoir plus sur la façon de préparer

decoder_attention_mask (`torch.BoolTensor` de forme `(batch_size, target_sequence_length)`, *facultatif*) : Comportement par défaut : générer un tenseur qui ignore les jetons de remplissage dans `decoder_input_ids`. Un masque causal sera également utilisé par défaut.

encoder_outputs (`tuple[tuple[torch.Tensor]]`, *facultatif*) : le tuple est composé de (`last_hidden_state`, *facultatif* : `hidden_states`, *facultatif* : `attentions`) `last_hidden_state` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) est une séquence d'états cachés à la sortie de la dernière couche de l'encodeur. Utilisé dans l'attention croisée du décodeur.

past_key_values (`~cache_utils.Cache`, *facultatif*) : États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et dans les blocs d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Il s'agit généralement des `past_key_values` renvoyés par le modèle à une étape antérieure du décodage, lorsque `use_cache=True` ou `config.use_cache=True`.  Seule une instance de [Cache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.Cache) est autorisée en entrée, voir notre [guide sur le cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Si aucun `past_key_values` n'est transmis, [DynamicCache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.DynamicCache) est initialisé par défaut.  Le modèle renverra le même format de cache que celui fourni en entrée.  Si `past_key_values` sont utilisés, l'utilisateur doit fournir uniquement les `input_ids` non traités (ceux pour lesquels les états de clés et de valeurs passées ne sont pas fournis à ce modèle) de forme `(batch_size, unprocessed_length)` au lieu de tous les `input_ids` de forme `(batch_size, sequence_length)`.

inputs_embeds (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) : Facultativement, au lieu de passer `input_ids`, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices `input_ids` en vecteurs associés, par rapport à la matrice de recherche d'intégration interne du modèle.

input_features (`torch.Tensor` de forme `(batch_size, sequence_length, feature_dim)`, *facultatif*) : Les tenseurs correspondant aux caractéristiques audio d’entrée. Les caractéristiques audio peuvent être obtenues à l’aide de [Pop2PianoFeatureExtractor](/docs/transformers/v5.23.0/fr/model_doc/pop2piano#transformers.Pop2PianoFeatureExtractor). Voir [Pop2PianoFeatureExtractor.__call__()](/docs/transformers/v5.23.0/fr/model_doc/pop2piano#transformers.Pop2PianoFeatureExtractor.__call__) pour plus de détails ([Pop2PianoProcessor](/docs/transformers/v5.23.0/fr/model_doc/pop2piano#transformers.Pop2PianoProcessor) utilise [Pop2PianoFeatureExtractor](/docs/transformers/v5.23.0/fr/model_doc/pop2piano#transformers.Pop2PianoFeatureExtractor) pour le traitement des audios).

decoder_inputs_embeds (`torch.Tensor` de forme `(batch_size, target_sequence_length, hidden_size)`, *facultatif*) : Facultativement, au lieu de passer `decoder_input_ids`, vous pouvez choisir de passer directement une représentation intégrée. Si `past_key_values` est utilisé, il est facultatif de n'entrer que les derniers `decoder_inputs_embeds` (voir `past_key_values`). Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices `decoder_input_ids` en vecteurs associés, par rapport à la matrice de recherche d'intégration interne du modèle. Si `decoder_input_ids` et `decoder_inputs_embeds` sont tous deux non définis, `decoder_inputs_embeds` prend la valeur de `inputs_embeds`.

labels (`torch.LongTensor` de forme `(batch_size,)`, *facultatif*) : Étiquettes pour le calcul de la perte de classification/régression de séquence. Les indices doivent être dans `[-100, 0, ..., config.vocab_size - 1]`. Toutes les étiquettes définies sur `-100` sont ignorées (masquées) ; la perte n'est calculée que pour les étiquettes comprises dans `[0, ..., config.vocab_size]`

use_cache (`bool`, *facultatif*) : Si défini sur `True`, les états clé-valeur de `past_key_values` sont renvoyés et peuvent être utilisés pour accélérer le décodage (voir `past_key_values`).

**Retourne :** [Seq2SeqLMOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.Seq2SeqLMOutput) ou `tuple(torch.Tensor)`

Un [Seq2SeqLMOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.Seq2SeqLMOutput) ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments en fonction de la configuration ([Pop2PianoConfig](/docs/transformers/v5.23.0/fr/model_doc/pop2piano#transformers.Pop2PianoConfig)) et des entrées.

La méthode forward de [Pop2PianoForConditionalGeneration](/docs/transformers/v5.23.0/fr/model_doc/pop2piano#transformers.Pop2PianoForConditionalGeneration) redéfinit la méthode spéciale `__call__`.

Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance `Module` plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.

- **loss** (`torch.Tensor` de forme `(1,)`, *facultatif*, renvoyé lorsque `labels` est fourni) -- Perte de modélisation du langage.
- **logits** (`torch.Tensor` de forme `(batch_size, sequence_length, config.vocab_size)`) -- Scores de prédiction de la tête de modélisation du langage (scores pour chaque jeton du vocabulaire avant SoftMax).
- **past_key_values** (`EncoderDecoderCache`, *facultatif*, renvoyé lorsque `use_cache=True` est passé ou lorsque `config.use_cache=True`) -- Il s'agit d'une instance de [EncoderDecoderCache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.EncoderDecoderCache). Pour plus de détails, consultez notre [guide sur le cache kv](https://huggingface.co/docs/transformers/en/kv_cache).

  Contient des états cachés précalculés (clés et valeurs dans les blocs d'auto-attention et dans les blocs d'attention croisée) qui peuvent être utilisés (voir l'entrée `past_key_values`) pour accélérer le décodage séquentiel.
- **decoder_hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`.

  États cachés du décodeur à la sortie de chaque couche, plus les sorties de l'intégration initiale.
- **decoder_attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`.

  Poids d'attention du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
- **cross_attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`.

  Poids d'attention de la couche d'attention croisée du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'attention croisée.
- **encoder_last_hidden_state** (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) -- Séquence d'états cachés à la sortie de la dernière couche de l'encodeur du modèle.
- **encoder_hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`.

  États cachés de l'encodeur à la sortie de chaque couche, plus les sorties des embeddings initiaux.
- **encoder_attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`.

  Poids d'attention de l'encodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.

Exemple :

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

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

**Paramètres :**

input_features (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) : Il s'agit de la version vectorisée de l'audio générée par `Pop2PianoFeatureExtractor`.

attention_mask : Pour la génération par lots, `input_features` sont rembourrés pour avoir la même forme pour tous les exemples. `attention_mask` aide à déterminer quelles zones ont été rembourrées et lesquelles non. - 1 pour les jetons qui ne sont **pas rembourrés**, - 0 pour les jetons qui sont **rembourrés**.

composer (`str`, *facultatif*, valeur par défaut `"composer1"`) : cette valeur est transmise à `Pop2PianoConcatEmbeddingToMel` pour générer des embeddings différents pour chaque `"composer"`. Veuillez vous assurer que la valeur du compositeur est présente dans `composer_to_feature_token` de `generation_config`. Pour un exemple, veuillez consulter https://huggingface.co/sweetcocoa/pop2piano/blob/main/generation_config.json .

generation_config (`~generation.GenerationConfig`, *facultatif*) : La configuration de génération à utiliser comme paramétrage de base pour l'appel de génération. Les `**kwargs` passés à generate qui correspondent aux attributs de `generation_config` les remplaceront. Si `generation_config` n'est pas fourni, la valeur par défaut sera utilisée, avec la priorité de chargement suivante : 1) depuis le fichier modèle `generation_config.json`, s'il existe ; 2) depuis la configuration du modèle. Veuillez noter que les paramètres non spécifiés hériteront des valeurs par défaut de [GenerationConfig](/docs/transformers/v5.23.0/fr/main_classes/text_generation#transformers.GenerationConfig), dont la documentation doit être consultée pour paramétrer la génération.

kwargs : Paramétrage ad hoc de `generate_config` et/ou d'autres arguments spécifiques au modèle qui seront transmis à la fonction `forward` du modèle. Si le modèle est un modèle encodeur-décodeur, les arguments spécifiques à l'encodeur ne doivent pas être préfixés et les arguments spécifiques au décodeur doivent être préfixés par *decoder_*.

**Retourne :** [ModelOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.utils.ModelOutput) ou `torch.LongTensor`

Un [ModelOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.utils.ModelOutput) (si `return_dict_in_generate=True` ou lorsque `config.return_dict_in_generate=True`) ou un `torch.Tensor`. Étant donné que Pop2Piano est un modèle encodeur-décodeur (`model.config.is_encoder_decoder=True`), les types [ModelOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.utils.ModelOutput) possibles sont :
- [GenerateEncoderDecoderOutput](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.generation.GenerateEncoderDecoderOutput),
- [GenerateBeamEncoderDecoderOutput](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.generation.GenerateBeamEncoderDecoderOutput)

Génère des identifiants de jetons pour les sorties MIDI.

La plupart des paramètres de contrôle de la génération sont définis dans `generation_config`, qui, s'il n'est pas transmis, est réglé sur la configuration de génération par défaut du modèle. Vous pouvez remplacer n'importe quel `generation_config` en transmettant les paramètres correspondants à generate(), par exemple `.generate(inputs, num_beams=4, do_sample=True)`. Pour un aperçu des stratégies de génération et des exemples de code, consultez le [guide suivant](./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)
```

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

**Paramètres :**

vocab (`str`) : Chemin vers le fichier de vocabulaire contenant le vocabulaire.

default_velocity (`int`, *facultatif*, valeur par défaut : 77) : Détermine la vélocité par défaut à utiliser lors de la création de notes MIDI.

num_bars (`int`, *facultatif*, valeur par défaut : 2) : Détermine cutoff_time_idx pour chaque jeton.

unk_token (`str` ou `tokenizers.AddedToken`, *facultatif*, valeur par défaut `"-1"`) : le jeton inconnu. Un jeton qui n'est pas dans le vocabulaire ne peut pas être converti en identifiant et est remplacé par ce jeton.

eos_token (`str` ou `tokenizers.AddedToken`, *facultatif*, valeur par défaut : 1) : Jeton de fin de séquence.

pad_token (`str` ou `tokenizers.AddedToken`, *facultatif*, valeur par défaut 0) : Un jeton spécial utilisé pour uniformiser la taille des tableaux de jetons dans le but de créer des lots. Il sera ensuite ignoré par les mécanismes d'attention ou le calcul de la perte.

bos_token (`str` ou `tokenizers.AddedToken`, *facultatif*, valeur par défaut : 2) : Jeton de début de séquence utilisé lors de la préformation. Peut être utilisé comme jeton de classifieur de séquence.

Construit un tokeniseur Pop2Piano. Ce tokeniseur ne nécessite pas d'entraînement.

Ce tokenizer hérite de [PreTrainedTokenizer](/docs/transformers/v5.23.0/fr/main_classes/tokenizer#transformers.PythonBackend), qui contient la plupart des méthodes principales. Les utilisateurs doivent se reporter à cette superclasse pour plus d’informations sur ces méthodes.

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

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

**Paramètres :**

notes (`numpy.ndarray` de forme `[batch_size, max_sequence_length, 4]` ou `list` d'objets `pretty_midi.Note`) : Représente les notes MIDI. Si `notes` est un `numpy.ndarray` : - Chaque séquence doit avoir 4 valeurs, à savoir `onset idx`, `offset idx`, `pitch` et `velocity`. Si `notes` est une `list` contenant des objets `pretty_midi.Note` : - Chaque séquence doit avoir 4 attributs, à savoir `start`, `end`, `pitch` et `velocity`.

padding (`bool`, `str` ou [PaddingStrategy](/docs/transformers/v5.23.0/fr/internal/file_utils#transformers.utils.PaddingStrategy), *facultatif*, par défaut `False`) : Active et contrôle le bourrage. Accepte les valeurs suivantes :  - `True` ou `'longest'` : Bourrage jusqu'à la séquence la plus longue du lot (ou aucun bourrage si une seule séquence est fournie). - `'max_length'` : Bourrage jusqu'à une longueur maximale spécifiée avec l'argument `max_length` ou jusqu'à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. - `False` ou `'do_not_pad'` (par défaut) : Aucun bourrage (c'est-à-dire, peut produire un lot avec des séquences de longueurs différentes).

truncation (`bool`, `str` ou [TruncationStrategy](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy), *facultatif*, par défaut `False`) : Active et contrôle la troncature. Accepte les valeurs suivantes :  - `True` ou `'longest_first'` : Tronque à une longueur maximale spécifiée par l'argument `max_length` ou à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. Cela tronque jeton par jeton, en supprimant un jeton de la séquence la plus longue de la paire si une paire de séquences (ou un lot de paires) est fournie. - `'only_first'` : Tronque à une longueur maximale spécifiée par l'argument `max_length` ou à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. Cela ne tronque que la première séquence d'une paire si une paire de séquences (ou un lot de paires) est fournie. - `'only_second'` : Tronque à une longueur maximale spécifiée par l'argument `max_length` ou à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. Cela ne tronque que la deuxième séquence d'une paire si une paire de séquences (ou un lot de paires) est fournie. - `False` ou `'do_not_truncate'` (par défaut) : Aucune troncature (c'est-à-dire, peut produire un lot avec des longueurs de séquences supérieures à la taille d'entrée maximale admissible du modèle).

max_length (`int`, *facultatif*) : Permet de contrôler la longueur maximale à utiliser par l'un des paramètres de troncature/remplissage. S'il n'est pas défini ou s'il est défini sur `None`, la longueur maximale prédéfinie du modèle sera utilisée si l'un des paramètres de troncature/remplissage exige une longueur maximale. Si le modèle n'a pas de longueur d'entrée maximale spécifique (comme XLNet), la troncature/remplissage à une longueur maximale sera désactivée.

pad_to_multiple_of (`int`, *facultatif*) : Si défini, la séquence sera rembourdée (padding) jusqu'à un multiple de la valeur fournie. Cela est particulièrement utile pour permettre l'utilisation des Tensor Cores sur le matériel NVIDIA avec une capacité de calcul `>= 7.5` (Volta).

return_attention_mask (`bool`, *facultatif*) : Indique s'il faut retourner le masque d'attention. Si la valeur par défaut est conservée, le masque d'attention est retourné selon la valeur par défaut du tokenizer spécifique, définie par l'attribut `return_outputs`.  [Qu'est-ce que les masques d'attention ?](../glossary#attention-mask)

return_tensors (`str` ou [TensorType](/docs/transformers/v5.23.0/fr/internal/file_utils#transformers.TensorType), *facultatif*) : Si défini, renverra des tenseurs au lieu d'une liste d'entiers Python. Les valeurs acceptables sont :  - `'pt'` : Renvoie des objets `torch.Tensor` de PyTorch. - `'np'` : Renvoie des objets `np.ndarray` de Numpy.

verbose (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut afficher plus d'informations et d'avertissements.

**Retourne :**

`BatchEncoding` contenant les token_ids.

Ceci est la méthode `__call__` de `Pop2PianoTokenizer`. Elle convertit les notes MIDI en identifiants de jetons générés par le transformer.

## Pop2PianoProcessor[[transformers.Pop2PianoProcessor]]

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

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

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

**Paramètres :**

feature_extractor (`Pop2PianoFeatureExtractor`) : l'extracteur de caractéristiques est une entrée obligatoire.

tokenizer (`tokenizer_class`) : Le tokenizer est une entrée obligatoire.

Construit un Pop2PianoProcessor qui encapsule un extracteur de caractéristiques et un tokenizer en un seul processeur.

[Pop2PianoProcessor](/docs/transformers/v5.23.0/fr/model_doc/pop2piano#transformers.Pop2PianoProcessor) offre toutes les fonctionnalités de [Pop2PianoFeatureExtractor](/docs/transformers/v5.23.0/fr/model_doc/pop2piano#transformers.Pop2PianoFeatureExtractor) et de `tokenizer_class`. Consultez [~Pop2PianoFeatureExtractor](/docs/transformers/v5.23.0/fr/model_doc/pop2piano#transformers.Pop2PianoFeatureExtractor) et `~tokenizer_class` pour plus d’informations.

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

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

**Paramètres :**

audio (`Union[numpy.ndarray, list[float], list[numpy.ndarray]]`, *facultatif*) : L’audio ou le lot d’audios à préparer. Chaque audio peut être un tableau NumPy ou un tenseur PyTorch. Dans le cas d’un tableau NumPy/d’un tenseur PyTorch, chaque audio doit avoir la forme (C, T), où C est le nombre de canaux et T est la longueur en échantillons de l’audio.

sampling_rate (`int` ou `list[int]`, *facultatif*) : Fréquence d'échantillonnage de l'audio d'entrée en Hz. Elle doit correspondre à la fréquence d'échantillonnage utilisée par l'extracteur de caractéristiques. Si elle n'est pas fournie, la fréquence d'échantillonnage par défaut de la configuration du processeur sera utilisée.

steps_per_beat (`int`, *facultatif*, valeur par défaut `2`) : Le nombre d'étapes de temps par temps musical. Ce paramètre contrôle la résolution temporelle de la représentation musicale. Une valeur plus élevée offre une granularité temporelle plus fine, mais augmente la longueur de la séquence. Utilisé lors du traitement audio pour extraire les caractéristiques musicales.

resample (`bool`, *facultatif*, valeur par défaut `True`) : Filtre de rééchantillonnage à utiliser lors du redimensionnement de l'image. Il peut s'agir d'une des valeurs de l'énumération `PILImageResampling`. N'a un effet que si `do_resize` est défini sur `True`.

notes (`list` ou `TensorType`, *facultatif*) : Notes musicales pré-extraites au format MIDI. Si fournies, le processeur ignore l'extraction des caractéristiques audio et traite directement les notes via le tokeniseur. Chaque note doit être représentée par une liste ou un tenseur contenant les informations de hauteur, de vélocité et de chronologie.

padding (bool, str ou [PaddingStrategy](/docs/transformers/v5.23.0/fr/internal/file_utils#transformers.utils.PaddingStrategy), *facultatif*, valeur par défaut `False`) : Active et contrôle le bourrage. Accepte les valeurs suivantes :  - `True` ou `'longest'` : Bourrage jusqu'à la séquence la plus longue du lot (ou aucun bourrage si une seule séquence est fournie). - `'max_length'` : Bourrage jusqu'à une longueur maximale spécifiée avec l'argument `max_length` ou jusqu'à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. - `False` ou `'do_not_pad'` (par défaut) : Aucun bourrage (c'est-à-dire, peut produire un lot avec des séquences de longueurs différentes).

truncation (bool, str ou [TruncationStrategy](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy), *facultatif*) : Active et contrôle la troncature. Accepte les valeurs suivantes :  - `True` ou `'longest_first'` : Tronque à une longueur maximale spécifiée avec l'argument `max_length` ou à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. Cela tronque jeton par jeton, en supprimant un jeton de la séquence la plus longue de la paire si une paire de séquences (ou un lot de paires) est fournie. - `'only_first'` : Tronque à une longueur maximale spécifiée avec l'argument `max_length` ou à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. Cela ne tronque que la première séquence d'une paire si une paire de séquences (ou un lot de paires) est fournie. - `'only_second'` : Tronque à une longueur maximale spécifiée avec l'argument `max_length` ou à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. Cela ne tronque que la deuxième séquence d'une paire si une paire de séquences (ou un lot de paires) est fournie. - `False` ou `'do_not_truncate'` (par défaut) : Aucune troncature (c'est-à-dire, peut produire un lot avec des longueurs de séquences supérieures à la taille d'entrée maximale admissible du modèle).

max_length (`int`, *facultatif*) : Permet de contrôler la longueur maximale à utiliser par l'un des paramètres de troncature/remplissage. S'il n'est pas défini ou s'il est défini sur `None`, la longueur maximale prédéfinie du modèle sera utilisée si l'un des paramètres de troncature/remplissage exige une longueur maximale. Si le modèle n'a pas de longueur d'entrée maximale spécifique (comme XLNet), la troncature/remplissage à une longueur maximale sera désactivée.

pad_to_multiple_of (`int`, *facultatif*) : Si défini, la séquence sera rembourdée jusqu'à un multiple de la valeur fournie. Nécessite l'activation de `padding`. Cela est particulièrement utile pour permettre l'utilisation des Tensor Cores sur du matériel NVIDIA avec une capacité de calcul `>= 7.5` (Volta).

verbose (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut afficher plus d'informations et d'avertissements.

return_tensors (`str` ou [TensorType](/docs/transformers/v5.23.0/fr/internal/file_utils#transformers.TensorType), *facultatif*) : Si défini, renverra des tenseurs d'un framework particulier. Les valeurs acceptables sont :  - `'pt'` : Renvoie des objets `torch.Tensor` de PyTorch. - `'np'` : Renvoie des objets `np.ndarray` de NumPy.

**Retourne :**

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

