Déployez MusicGen en un rien de temps avec les points de terminaison d’inférence

Déployez MusicGen rapidement avec des points de terminaison d'inférence.

MusicGen est un modèle puissant de génération de musique qui prend en compte une phrase de texte et une mélodie facultative pour produire de la musique. Cet article de blog vous guidera pour générer de la musique avec MusicGen en utilisant les points d’inférence.

Les points d’inférence nous permettent d’écrire des fonctions d’inférence personnalisées appelées gestionnaires personnalisés. Ils sont particulièrement utiles lorsque le modèle n’est pas pris en charge directement par l’abstraction de haut niveau “transformers.pipeline”.

Les pipelines “transformers” offrent des abstractions puissantes pour exécuter des inférences avec des modèles basés sur “transformers”. Les points d’inférence utilisent l’API du pipeline pour déployer facilement des modèles en seulement quelques clics. Cependant, les points d’inférence peuvent également être utilisés pour déployer des modèles qui n’ont pas de pipeline, voire des modèles non-transformers! Cela est réalisé en utilisant une fonction d’inférence personnalisée que nous appelons un gestionnaire personnalisé.

Illustrons ce processus en utilisant MusicGen comme exemple. Pour mettre en œuvre une fonction de gestionnaire personnalisée pour MusicGen et la déployer, nous devrons :

• Six Croyances Qui Font Que Votre Travail En Science des Données Est Truffé de Biais
• OpenAI dévoile 6 fonctionnalités passionnantes de ChatGPT pour révolutionner l’expérience utilisateur
• Classification multilabel Une introduction avec Scikit-Learn de Python

1. Dupliquer le référentiel MusicGen que nous souhaitons servir,
2. Écrire un gestionnaire personnalisé dans “handler.py” et toutes les dépendances dans “requirements.txt” et les ajouter au référentiel dupliqué,
3. Créer un point d’inférence pour ce référentiel.

Ou simplement utiliser le résultat final et déployer notre référentiel de modèle MusicGen personnalisé, où nous avons simplement suivi les étapes ci-dessus 🙂

Allons-y !

Tout d’abord, nous dupliquerons le référentiel facebook/musicgen-large sur notre propre profil à l’aide du duplicateur de référentiel.

Ensuite, nous ajouterons “handler.py” et “requirements.txt” au référentiel dupliqué. Tout d’abord, examinons comment exécuter une inférence avec MusicGen.

from transformers import AutoProcessor, MusicgenForConditionalGeneration

processor = AutoProcessor.from_pretrained("facebook/musicgen-large")
model = MusicgenForConditionalGeneration.from_pretrained("facebook/musicgen-large")

inputs = processor(
    text=["Piste de pop des années 80 avec des batteries basses et des synthétiseurs"],
    padding=True,
    return_tensors="pt",
)
audio_values = model.generate(**inputs, do_sample=True, guidance_scale=3, max_new_tokens=256)

Écoutons ce que cela donne :

Votre navigateur ne prend pas en charge l’élément audio.

En option, vous pouvez également conditionner la sortie avec un extrait audio, c’est-à-dire générer un extrait complémentaire qui combine l’audio généré par le texte avec un audio d’entrée.

from transformers import AutoProcessor, MusicgenForConditionalGeneration
from datasets import load_dataset

processor = AutoProcessor.from_pretrained("facebook/musicgen-large")
model = MusicgenForConditionalGeneration.from_pretrained("facebook/musicgen-large")

dataset = load_dataset("sanchit-gandhi/gtzan", split="train", streaming=True)
sample = next(iter(dataset))["audio"]

# prendre la première moitié de l'échantillon audio
sample["array"] = sample["array"][: len(sample["array"]) // 2]

inputs = processor(
    audio=sample["array"],
    sampling_rate=sample["sampling_rate"],
    text=["Piste de blues des années 80 avec un saxophone groovy"],
    padding=True,
    return_tensors="pt",
)
audio_values = model.generate(**inputs, do_sample=True, guidance_scale=3, max_new_tokens=256)

Écoutons :

Votre navigateur ne prend pas en charge l’élément audio.

Dans les deux cas, la méthode “model.generate” produit l’audio et suit les mêmes principes que la génération de texte. Vous pouvez en lire plus à ce sujet dans notre article de blog sur comment générer.

D’accord ! Avec l’utilisation de base décrite ci-dessus, déployons MusicGen pour le plaisir et le profit !

Tout d’abord, nous définirons un gestionnaire personnalisé dans “handler.py”. Nous pouvons utiliser le modèle de points d’inférence et remplacer les méthodes “__init__” et “__call__” par notre code d’inférence personnalisé. “__init__” initialisera le modèle et le processeur, et “__call__” prendra les données et renverra la musique générée. Vous pouvez trouver la classe “EndpointHandler” modifiée ci-dessous. 👇

from typing import Dict, List, Any
from transformers import AutoProcessor, MusicgenForConditionalGeneration
import torch

class EndpointHandler:
    def __init__(self, path=""):
        # charger le modèle et le processeur depuis le chemin
        self.processor = AutoProcessor.from_pretrained(path)
        self.model = MusicgenForConditionalGeneration.from_pretrained(path, torch_dtype=torch.float16).to("cuda")

    def __call__(self, data: Dict[str, Any]) -> Dict[str, str]:
        """
        Args:
            data (:dict:):
                Les données avec la phrase de texte et les paramètres de génération.
        """
        # traiter l'entrée
        inputs = data.pop("inputs", data)
        parameters = data.pop("parameters", None)

        # prétraiter
        inputs = self.processor(
            text=[inputs],
            padding=True,
            return_tensors="pt",).to("cuda")

        # passer les entrées avec tous les kwargs dans les données
        if parameters is not None:
            with torch.autocast("cuda"):
                outputs = self.model.generate(**inputs, **parameters)
        else:
            with torch.autocast("cuda"):
                outputs = self.model.generate(**inputs,)

        # post-traiter la prédiction
        prediction = outputs[0].cpu().numpy().tolist()

        return [{"generated_audio": prediction}]

Pour simplifier les choses, dans cet exemple, nous générons uniquement de l’audio à partir de texte, sans le conditionner avec une mélodie. Ensuite, nous allons créer un fichier requirements.txt contenant toutes les dépendances nécessaires pour exécuter notre code d’inférence:

transformers==4.31.0
accelerate>=0.20.3

Uploader ces deux fichiers sur notre dépôt sera suffisant pour servir le modèle.

Nous pouvons maintenant créer le point de terminaison d’inférence. Rendez-vous sur la page des points de terminaison d’inférence et cliquez sur Déployer votre premier modèle. Dans le champ “Répertoire du modèle”, entrez l’identifiant de votre dépôt dupliqué. Ensuite, choisissez le matériel que vous souhaitez et créez le point de terminaison. Toute instance avec un minimum de 16 Go de RAM devrait fonctionner pour musicgen-large.

Après la création du point de terminaison, il sera automatiquement lancé et prêt à recevoir des requêtes.

Nous pouvons interroger le point de terminaison avec le code ci-dessous.

curl URL_DU_POINT_DE_TERMINAISON \
-X POST \
-d '{"inputs":"chanson folk joyeuse, gaie et animée"}' \
-H "Authorization: {VOTRE_JETON_ICI}" \
-H "Content-Type: application/json"

Nous pouvons voir la séquence d’ondes ci-dessous en tant que sortie.

[{"generated_audio":[[-0.024490159,-0.03154691,-0.0079551935,-0.003828604, ...]]}]

Voici à quoi cela ressemble:

Votre navigateur ne supporte pas l’élément audio.

Vous pouvez également interroger le point de terminaison avec la classe InferenceClient de la bibliothèque Python huggingface-hub.

from huggingface_hub import InferenceClient

client = InferenceClient(model = URL_DU_POINT_DE_TERMINAISON)
response = client.post(json={"inputs":"une chanson rock alternative"})
# la réponse ressemble à ceci b'[{"generated_text":[[-0.182352,-0.17802449, ...]]}]

output = eval(response)[0]["generated_audio"]

Vous pouvez convertir la séquence générée en audio de la manière qui vous convient. Vous pouvez utiliser scipy en Python pour l’écrire dans un fichier .wav.

import scipy
import numpy as np

# output est [[-0.182352,-0.17802449, ...]]
scipy.io.wavfile.write("musicgen_out.wav", rate=32000, data=np.array(output[0]))

Et voilà!

Jouez avec la démo ci-dessous pour essayer le point de terminaison.

Conclusion

Dans cet article de blog, nous avons montré comment déployer MusicGen en utilisant des points de terminaison d’inférence avec un gestionnaire d’inférence personnalisé. La même technique peut être utilisée pour tout autre modèle dans le Hub qui n’a pas de pipeline associé. Il vous suffit de remplacer la classe Endpoint Handler dans handler.py et d’ajouter requirements.txt pour refléter les dépendances de votre projet.

Lire la suite

• Documentation des points de terminaison d’inférence couvrant le gestionnaire personnalisé

We will continue to update IPGirl; if you have any questions or suggestions, please contact us!