Hugging Face's logo

Transformers documentation

Pop2Piano

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.1).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Ce modèle a été publié dans HF papers le 2022-11-02 et ajouté à Hugging Face Transformers le 2023-08-21.

Pop2Piano

Aperçu

Le modèle Pop2Piano a été proposé dans Pop2Piano : Pop Audio-based Piano Cover Generation par Jongho Choi et Kyogu Lee.

Les reprises au piano de la musique pop sont très appréciées, mais les générer à partir de la musique n’est pas une tâche triviale. Cela 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. L’audio d’entrée est transformé en forme d’onde et transmis à l’encodeur, qui le convertit 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 différents : temps, vélocité, note et « spécial ». Les identifiants de jetons sont ensuite décodés en leur fichier MIDI équivalent.

L'abstract de l'article est le suivant :

Les arrangements de musique pop au piano sont appréciés de nombreuses personnes. Cependant, la tâche de génération automatique d’arrangements de piano pour la musique pop reste peu étudiée. Cela est dû en partie 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 créé 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 de piano à partir des formes d’onde de la musique pop. À notre connaissance, il s’agit du premier modèle capable de générer un arrangement de piano directement à partir d’audio pop, sans utiliser de 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 de piano plausibles.

Ce modèle a été contribué par Susnato Dhar. Le code d'origine peut être trouvé ici.

Conseils d'utilisation

  • Pour utiliser Pop2Piano, vous devrez installer la bibliothèque 🤗 Transformers ainsi que les modules tiers suivants :
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 :
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 :
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 :
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) :
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

classe transformers.Pop2PianoConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0id2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Noneis_encoder_decoder: bool = Truevocab_size: int = 2400composer_vocab_size: int = 21d_model: int = 512d_kv: int = 64d_ff: int = 2048num_layers: int = 6num_decoder_layers: int | None = Nonenum_heads: int = 8relative_attention_num_buckets: int = 32relative_attention_max_distance: int = 128dropout_rate: float | int = 0.1layer_norm_epsilon: float = 1e-06initializer_factor: float = 1.0feed_forward_proj: str = 'gated-gelu'use_cache: bool = Truepad_token_id: int | None = 0eos_token_id: int | list[int] | None = 1dense_act_fn: str = 'relu'is_decoder: bool = Falsetie_word_embeddings: bool = True )

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, 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, par défaut 512) — Taille des couches encodeur et de la couche pooler.
  • d_kv (int, facultatif, par défaut 64) — Taille des projections 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, par défaut 2048) — Dimension des représentations du MLP.
  • num_layers (int, facultatif, 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 plus longues pour la séparation par lots.
  • dropout_rate (Union[float, int], facultatif, par défaut 0.1) — Le taux appliqué à toutes les couches de dropout.
  • layer_norm_epsilon (float, facultatif, valeur par défaut 1e-06) — L'épsilon utilisé par les couches de normalisation de 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 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). N’est pertinent que si config.is_decoder=True ou si le modèle est un modèle génératif uniquement décodeur.
  • pad_token_id (int, facultatif, par défaut 0) — Identifiant du jeton utilisé pour le bourrage dans le vocabulaire.
  • eos_token_id (Union[int, list[int]], facultatif, par défaut 1) — Identifiant du jeton utilisé pour la fin de flux dans le vocabulaire.
  • dense_act_fn (string, facultatif, par défaut "relu") — Type de fonction d'activation à utiliser dans Pop2PianoDenseActDense et dans Pop2PianoDenseGatedActDense.
  • is_decoder (bool, facultatif, par défaut False) — Indique si le modèle est utilisé comme décodeur ou non. Si False, le modèle est utilisé comme encodeur.
  • tie_word_embeddings (bool, facultatif, 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, définissant ainsi l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de sweetcocoa/pop2piano

Les objets de configuration héritent de PreTrainedConfig et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de PreTrainedConfig pour plus d’informations.

Pop2PianoFeatureExtractor

classe transformers.Pop2PianoFeatureExtractor

< >

( sampling_rate: int = 22050padding_value: int = 0window_size: int = 4096hop_length: int = 1024min_frequency: float = 10.0feature_size: int = 512num_bars: int = 2**kwargs )

Paramètres

  • sampling_rate (int, facultatif, valeur par défaut 22050) — Taux d’échantillonnage cible du signal audio. C’est le taux d’échantillonnage que nous transmettons 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, par défaut 4096) — Longueur de la fenêtre en échantillons à laquelle la transformée de Fourier est appliquée.
  • hop_length (int, facultatif, par défaut 1024) — Taille du pas entre chaque fenêtre de la forme d'onde, en échantillons.
  • min_frequency (float, facultatif, valeur par défaut 10.0) — Fréquence minimale utilisée dans le spectrogramme log-mel.
  • feature_size (int, facultatif, 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 fonctionnalités hérite de SequenceFeatureExtractor, qui contient la plupart des méthodes principales. Les utilisateurs doivent se référer à cette superclasse pour plus d'informations sur ces méthodes.

Cette classe extrait le rythme et prétraite l'audio avant qu'il ne soit transmis 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, puis beat_times est interpolé pour obtenir les beatsteps. Ensuite, nous calculons extrapolated_beatsteps à partir de ceux-ci pour être utilisés 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.

__call__

< >

( audio: numpy.ndarray | list[float] | list[numpy.ndarray] | list[list[float]]sampling_rate: int | list[int]steps_per_beat: int = 2resample: bool | None = Truereturn_attention_mask: bool | None = Falsereturn_tensors: str | transformers.utils.generic.TensorType | None = None**kwargs )

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) — La fréquence d’échantillonnage à laquelle 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 interpoler beat_times.
  • resample (bool, facultatif, par défaut True) — Détermine s'il faut rééchantillonner l'audio à sampling_rate ou non avant le traitement. Doit être True lors de l'inférence.
  • return_attention_mask (bool optional, defaults to False) — Denotes if attention_mask for input_features, beatsteps and extrapolated_beatstep will be given as output or not. Automatically set to True for batched inputs.
  • return_tensors (str ou TensorType, facultatif) — Si défini, renvoie des tenseurs au lieu d'une liste d'entiers Python. Les valeurs acceptées sont :
    • 'pt' : Renvoie des objets torch.Tensor de PyTorch.
    • 'np' : renvoie des objets Numpy np.ndarray. Si rien n’est spécifié, renvoie une liste de tableaux np.ndarray.

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

Pop2PianoForConditionalGeneration

classe transformers.Pop2PianoForConditionalGeneration

< >

( config: Pop2PianoConfig )

Paramètres

  • config (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() 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. 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, la taille des têtes, etc.)

Ce modèle est également une sous-classe de 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

< >

( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonedecoder_input_ids: typing.Optional[torch.LongTensor] = Nonedecoder_attention_mask: typing.Optional[torch.BoolTensor] = Noneencoder_outputs: tuple[tuple[torch.Tensor]] | None = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneinput_features: typing.Optional[torch.Tensor] = Nonedecoder_inputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Seq2SeqLMOutput or tuple(torch.Tensor)

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 effectuer le bourrage des entrées à la fois à droite et à gauche. Les indices peuvent être obtenus à l’aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails. Que sont les identifiants d’entrée ? Pour en savoir plus sur la préparation de input_ids pour le pré-entraînement, consultez 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 masqués.

    Qu'est-ce que les masques d'attention ?

  • 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. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails. Quels sont les IDs d’entrée du décodeur ? Pop2Piano utilise le 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 le dernier 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 d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Cela consiste généralement en la past_key_values retournée 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 est autorisée en entrée, consultez notre guide du cache kv. Si aucun past_key_values n'est transmis, DynamicCache sera initialisé par défaut.

    Le modèle produira le même format de cache qui est 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 n’ont pas été 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 que 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. Voir Pop2PianoFeatureExtractor.call() pour plus de détails (Pop2PianoProcessor utilise 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é, facultativement, seules les dernières decoder_inputs_embeds doivent être entrées (voir past_key_values). Cela est utile si vous souhaitez un meilleur contrôle sur la conversion des decoder_input_ids indices en vecteurs associés que 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 à -100 sont ignorées (masquées), la perte n'est calculée que pour les étiquettes dans [0, ..., config.vocab_size]
  • use_cache (bool, facultatif) — Si défini sur True, les états clé-valeur past_key_values sont renvoyés et peuvent être utilisés pour accélérer le décodage (voir past_key_values).

Retourne

Seq2SeqLMOutput ou tuple(torch.Tensor)

Un 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) et des entrées.

La méthode forward de 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. Pour plus de détails, consultez notre guide sur le cache kv.

    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 :

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

< >

( input_featuresattention_mask = Nonecomposer = 'composer1'generation_config = None**kwargs ) → ModelOutput or torch.LongTensor

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 permet de 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 remplis.
  • 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 dans 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 transmis à 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, dont la documentation doit être consultée pour paramétrer la génération.
  • kwargs — Paramétrage ad hoc de generate_config et/ou kwargs supplémentaires spécifiques au modèle qui seront transmis à la fonction forward du modèle. Si le modèle est un modèle encoder-décodeur, les kwargs spécifiques à l’encodeur ne doivent pas être préfixés et les kwargs spécifiques au décodeur doivent être préfixés par decoder_.

Retourne

ModelOutput ou torch.LongTensor

Un 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 possibles sont :

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, sera défini 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.

Pop2PianoTokenizer

classe transformers.Pop2PianoTokenizer

< >

( vocabdefault_velocity = 77num_bars = 2unk_token = '-1'eos_token = '1'pad_token = '0'bos_token = '2'**kwargs )

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 des 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, 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, par défaut 1) — Le 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 à des fins de lot. 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) — Le 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, qui contient la plupart des méthodes principales. Les utilisateurs doivent se référer à cette superclasse pour plus d'informations sur ces méthodes.

__call__

< >

( notes: numpy.ndarray | list[pretty_midi.Note] | list[list[pretty_midi.Note]]padding: bool | str | transformers.utils.generic.PaddingStrategy = Falsetruncation: bool | str | transformers.tokenization_utils_base.TruncationStrategy | None = Nonemax_length: int | None = Nonepad_to_multiple_of: int | None = Nonereturn_attention_mask: bool | None = Nonereturn_tensors: str | transformers.utils.generic.TensorType | None = Noneverbose: bool = True**kwargs )

Paramètres

  • notes (numpy.ndarray de forme [batch_size, max_sequence_length, 4] ou list de pretty_midi.Note objets) — 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, facultatif, défaut : False) — Active et contrôle le padding. Accepte les valeurs suivantes :
    • True ou 'longest' : Ajuster à la séquence la plus longue du lot (ou aucun ajustement si une seule séquence est fournie).
    • 'max_length' : Remplir jusqu'à une longueur maximale spécifiée par 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 padding (c’est-à-dire, peut produire un lot avec des séquences de longueurs différentes).
  • truncation (bool, str ou TruncationStrategy, facultatif, défaut : False) — Active et contrôle la troncature. Accepte les valeurs suivantes :
    • True ou 'longest_first' : Tronquer à 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 tronquera jeton par jeton, en retirant un jeton de la séquence la plus longue du couple si un couple de séquences (ou un lot de couples) est fourni.
    • '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 tronquera 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 tronquera 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 par le modèle).
  • max_length (int, facultatif) — Contrôle 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/le remplissage à une longueur maximale sera désactivé.
  • pad_to_multiple_of (int, facultatif) — Si défini, la séquence sera rembourdée 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 ?

  • return_tensors (str ou TensorType, facultatif) — Si défini, renvoie des tenseurs au lieu d'une liste d'entiers Python. Les valeurs acceptées sont :
    • 'pt' : Renvoie des objets torch.Tensor de PyTorch.
    • 'np' : Renvoie des objets Numpy np.ndarray.
  • verbose (bool, facultatif, par défaut True) — Indique s'il faut afficher plus d'informations et d'avertissements.

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

classe transformers.Pop2PianoProcessor

< >

( feature_extractortokenizer )

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 offre toutes les fonctionnalités de Pop2PianoFeatureExtractor et de tokenizer_class. Consultez ~Pop2PianoFeatureExtractor et ~tokenizer_class pour plus d’informations.

__call__

< >

( audio: numpy.ndarray | list[float] | list[numpy.ndarray] = Nonesampling_rate: int | list[int] | None = Nonesteps_per_beat: int = 2resample: bool | None = Truenotes: list | transformers.utils.generic.TensorType = Nonepadding: bool | str | transformers.utils.generic.PaddingStrategy = Falsetruncation: bool | str | transformers.tokenization_utils_base.TruncationStrategy = Nonemax_length: int | None = Nonepad_to_multiple_of: int | None = Noneverbose: bool = True**kwargs )

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. En cas de tableau NumPy/tenseur PyTorch, chaque audio doit avoir la forme (C, T), où C est le nombre de canaux et T est la longueur d’échantillonnage de l’audio.
  • sampling_rate (int ou list[int], facultatif) — La 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 temporelles 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, par défaut True) — Filtre de rééchantillonnage à utiliser lors du redimensionnement de l’image. Il peut s’agir de l’une des valeurs de l’enum 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, facultatif, défaut False) — Active et contrôle le padding. Accepte les valeurs suivantes :
    • True ou 'longest' : Ajuster à la séquence la plus longue du lot (ou aucun ajustement si une seule séquence est fournie).
    • 'max_length' : Remplir jusqu'à une longueur maximale spécifiée par 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 padding (c’est-à-dire, peut produire un lot avec des séquences de longueurs différentes).
  • truncation (bool, str ou TruncationStrategy, facultatif) — Active et contrôle la troncature. Accepte les valeurs suivantes :
    • True ou 'longest_first' : Tronquer à 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 tronquera jeton par jeton, en retirant un jeton de la séquence la plus longue du couple si un couple de séquences (ou un lot de couples) est fourni.
    • '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 tronquera 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 tronquera 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 par le modèle).
  • max_length (int, facultatif) — Contrôle la longueur maximale à utiliser par l'un des paramètres de troncature/remplissage.

    Si non défini ou 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/le remplissage à une longueur maximale sera désactivé.

  • pad_to_multiple_of (int, facultatif) — Si défini, la séquence est rembourré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 le 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, facultatif) — Si défini, renvoie des tenseurs d'un framework particulier. Les valeurs acceptées sont :
    • 'pt' : Renvoie des objets torch.Tensor de PyTorch.
    • 'np' : Renvoie des objets NumPy np.ndarray.
Update on GitHub

←Pocket TTS Audio Tokenizer Qwen3 ASR→