Utilisation de l'API Whisper et GPT-3 d'OpenAI pour créer et déployer une application de transcription – Partie 1

Alors que le battage médiatique autour des technologies d'IA telles que les chatbots, les grands modèles de langage (LLM) et les copilotes a commencé après la sortie de ChatGPT, de nombreux autres cas d'utilisation sont rapidement apparus.

Je ne parle pas des plus courants comme les assistants à la rédaction, les générateurs d’images ou les chatbots formés sur vos données. Je parle de cas d'utilisation plus spécialisés comme les avatars parlants réalistes, les éditeurs vidéo ou la synthèse vocale.

Dans cet article, nous allons explorer l'un de ces cas d'utilisation : une application de transcription que vous pouvez utiliser avec des podcasts ou des vidéos YouTube . Ce sera d'une grande valeur si vous avez déjà voulu utiliser l'API GPT-3 ou voir une démo OpenAI Whisper en action.

Pour la première partie de ce didacticiel, nous passerons en revue tout ce dont nous avons besoin pour configurer et démarrer le développement de l'application.

Et puis, dans la deuxième partie, nous téléchargerons notre code de travail sur le cloud et ferons fonctionner une interface utilisateur afin que les autres puissent voir les résultats et interagir avec l'application.

Maintenant, attachez votre ceinture, car nous allons nous salir les mains avec du code Python pour construire cela.

La mise en scène

Pour construire cela, nous passerons par 3 actes.

• Dans le premier, nous verrons tout ce dont nous avons besoin pour nous préparer au voyage à venir.

  
  

• Dans la seconde étape, nous construirons un prototype localement et découvrirons quels outils peuvent nous aider dans le processus.

  
  

• Et dans la version finale, nous téléchargerons tout ce que nous avons construit sur le cloud afin que d'autres puissent également l'essayer.

Ça a l'air bien?

Très bien alors, c'est parti !

Acte 1 : La configuration (Whisper et API GPT-3)

Tout d’abord, un aperçu général du processus que nous allons suivre consiste à extraire les informations que nous souhaitons transcrire, puis à les transmettre à Le murmure d'OpenAI .

À partir de là, nous prendrons le résultat et y effectuerons un post-traitement avant de l'afficher dans une application frontale pour que d'autres puissent le voir et pouvoir interagir avec lui.

Ce processus nécessiterait quelques étapes supplémentaires si nous le faisions manuellement. Heureusement, OpenAI mis à disposition Accès API pour Whisper et ChatGPT .

Ici, vous devrez décider quel chemin prendre.

• Construisez-le localement sur votre machine (en supposant que Python 3 soit installé) ou,
• Construisez-le en ligne à l'aide d'un Bloc-notes Google Colab .

Choisissez d'abord votre chemin, puis nous procéderons.

Ensuite, nous aurons besoin d'une clé API d'OpenAI pour accéder au modèle GPT-3.5 Turbo (qui est essentiellement le modèle qui alimente ChatGPT).

Si vous ne savez pas comment en obtenir un, suivez ces étapes :

• Accédez au site Web de la plateforme OpenAI et connectez-vous ou inscrivez-vous (selon votre cas).

• Ensuite, cliquez sur l'icône de votre profil en haut à droite pour afficher les options et sélectionnez « Afficher les clés API ».

• Sur cette page, vous verrez une option indiquant « créer une nouvelle clé secrète » dans la section Clés API.

• Il affichera une fenêtre contextuelle où votre clé secrète est affichée. Enregistrez-le dans un endroit sécurisé car vous ne le reverrez plus jamais.

Une fois que vous aurez cette clé, nous passerons à la pièce suivante du puzzle, Whisper.

Vous pouvez télécharger et installer la dernière version de Whisper sur votre ordinateur en exécutant la commande suivante :

 pip install -U openai-whisper

Alternativement, vous pouvez installer le dernier commit de Git avec ses dépendances à l'aide de cette commande :

 pip install git+https://github.com/openai/whisper.git

Cela vous donne plus de contrôle sur la version que vous installez (et c'est la commande que vous souhaiterez exécuter si vous essayez cela à partir d'un notebook Colab.)

Remarque : Vous devrez avoir installé « ffmpeg » si vous souhaitez exécuter Whisper à partir de la ligne de commande.

Avec Whisper installé, tout ce dont nous avons besoin maintenant, ce sont les fichiers que nous souhaitons transcrire. Nous pouvons lui alimenter plusieurs types de fichiers multimédias comme « mp3 », « mp4 », « mpeg », « wav » et bien d'autres.

La seule limitation ici est la taille des fichiers, cela prendra bien plus de temps avec une vidéo de 10 minutes qu'avec un podcast de 20 minutes.

Maintenant, voici la prochaine bifurcation sur la route.

Vous devrez choisir si vous souhaitez retranscrire de la vidéo ou de l’audio .

Par souci de simplicité dans cet exemple, nous utiliserons des fichiers audio issus de podcasts.

Et ici, la question qui pourrait vous venir à l’esprit est « Où puis-je télécharger des épisodes de podcast ? » ».

Il y a 2 façons que je connais.

La première consiste à utiliser un site comme ListenNotes, à choisir le podcast que vous aimez et à accéder aux épisodes individuels.

Il convient de noter que vous devrez créer un compte pour pouvoir accéder aux épisodes individuels et à leurs fichiers audio correspondants.

À partir de là, vous devrez cliquer sur un bouton avec 3 points pour ouvrir un onglet « plus » et vous verrez ensuite l'option de télécharger l'audio.

Voici à quoi cela ressemblera :

La deuxième option consiste à utiliser Podchaser à la place. Vous suivrez un processus similaire pour trouver un podcast, parcourir la liste des épisodes et en choisir un en particulier.

Une fois que vous arrivez à la page de l'épisode individuel, vous verrez une colonne sur le côté droit qui contient le bouton de lecture et d'autres options en dessous.

Si vous faites défiler vers le bas, vous verrez des informations sur le podcast, des options de partage sur les réseaux sociaux et une petite section avec la possibilité de télécharger le fichier audio.

Voici à quoi cela ressemblerait :

Choisissez l'option que vous préférez et téléchargez quelques épisodes de différentes longueurs afin de pouvoir tester le fonctionnement du processus de transcription.

Ma recommandation est de choisir des épisodes de moins de 30 minutes.

La raison en est que si vous en choisissez un plus long, Whisper peut prendre beaucoup de temps pour le traiter et vous pourriez rencontrer des problèmes de délai d'attente (surtout si vous utilisez l'environnement Colab).

Un épisode de 20 à 30 minutes peut prendre de 4 à 8 minutes pour être transcrit.

Le principal goulot d'étranglement ici est la durée du processus de transcription avant d'obtenir un résultat que nous pouvons utiliser pour des travaux ultérieurs.

Maintenant que nous avons rempli toutes les conditions et que la configuration est terminée.

Il est temps pour nous de passer à la suite du voyage.

Acte 2 : Le développement (Démo OpenAI Whisper)

Nous entrons dans un territoire de programmation plus profond.

Nous utiliserons Whisper via Python car c'est plus pratique. Et nous n'avons rien de spécial à faire pour la transcription, il suffit de transmettre le fichier audio au modèle et d'attendre la transcription, c'est tout.

Passons donc en revue ce processus ligne par ligne.

 import whisper model = whisper.load_model("base")

Ici, nous chargeons la version « de base » du modèle Whisper. Il existe plusieurs versions (ou « tailles ») publiées par OpenAI et elles varient en fonction du nombre de paramètres, des ressources qu'elles consomment et du temps nécessaire pour effectuer la transcription.

Voici un tableau pratique pour référence.

Vous pouvez aller de l'avant et les essayer tous pour la taille (jeu de mots) si vous le souhaitez.

Gardez à l'esprit que si vous utilisez un modèle plus grand, vous aurez besoin de plus de ressources pour l'exécuter (comme un GPU).

Donc, si vous l'exécutez dans Colab, vous pouvez utiliser cette commande à la place.

 model = whisper.load_model('medium', device='cuda')

Vous transmettez le paramètre de l’appareil sur lequel vous souhaitez que cela soit exécuté.

Après avoir choisi la taille du modèle, vous pouvez ensuite transmettre le fichier audio que vous souhaitez retranscrire, comme ceci :

 result = model.transcribe(“path-to-where-the-file-is”)

Ensuite, vous pouvez imprimer le contenu pour vérifier que la transcription a fonctionné. (Mais vous souhaiterez peut-être ne jeter un coup d'œil que sur les 1 000 premiers caractères environ, au lieu d'imprimer le tout.)

 podcast_transcript = result['text'] podcast_transcript[:1000]

Si cela s’est bien passé, vous avez maintenant les résultats du processus de transcription enregistrés dans une variable. Celui que nous utiliserons pour le post-traitement.

C'est assez simple. Mais supposons que nous souhaitions avoir un moyen de savoir ce qui a été discuté dans le podcast au-delà de ce que nous trouverions dans la description de l'épisode.

Nous pouvons créer une fonction qui prend toute la transcription et nous donne un « résumé ». Un résumé que l'on peut également partager avec les personnes occupées qui n'ont pas le temps de tout parcourir et de voir si cela vaut la peine ou non.

Allons-y et faisons-le.

Avez-vous une idée de ce que nous utiliserons pour faire ce résumé ?

Astuce : nous disposons déjà d’une clé API pour cela.

Oui, vous l'avez.

Nous utiliserons le modèle `get-3.5-turbo` pour créer ce résumé en lui fournissant la transcription du podcast.

Nous pourrions faire les appels directement à l'API, mais il est beaucoup plus pratique d'utiliser le package OpenAI pour cela (qui porte bien son nom « openai » 😆).

Nous aurons également besoin de la bibliothèque tokenizer d'OpenAI pour connaître la quantité de tokens que nous enverrons au modèle.

Et nous pouvons installer les deux en exécutant…

 pip install openai pip install tiktoken

Maintenant, nous devons enregistrer la clé API quelque part avant d'appeler GPT-3.

Vous pouvez l'enregistrer en tant que variable d'environnement, puis le préparer à être utilisé dans le code comme celui-ci.

 openai.api_key = os.environ["OPENAI"]

Ou si vous utilisez l'environnement Colab, vous pouvez faire quelque chose comme ceci.

 import openai from getpass import getpass openai.api_key = getpass("Enter your key here: ")

Et puis, lorsque vous exécutez cette commande, elle affichera une cellule de saisie dans laquelle vous pourrez coller la clé.

Maintenant, vous pouvez confirmer que la clé fonctionne en répertoriant les modèles actuellement disponibles avec ce morceau de code.

 models = openai.Model.list() for model in models['data]: print(model['root'])

Avec notre clé fonctionnant correctement, nous pouvons continuer et appeler l'API GPT-3.

Mais il y a quelque chose d’important dont nous devons d’abord tenir compte. Et cela est lié à ce que j'ai mentionné plus tôt à propos des « jetons ».

Puisque l'idée est de transmettre la transcription du podcast au modèle d'IA et d'en récupérer un résumé, nous devons savoir combien de « jetons » il est capable d'accepter.

L'IA ne compte pas les mots ou les caractères mais utilise des jetons. C'est pourquoi le concept de « fenêtre contextuelle » existe.

Si nous dépassons la longueur de la fenêtre contextuelle, notre transcription peut être tronquée et nous obtiendrons un résumé des données incomplètes. (Une autre raison de choisir un épisode de podcast qui n'est pas trop long.)

Heureusement, il existe 2 versions du modèle GPT-3. Le traditionnel et un autre avec une fenêtre contextuelle étendue.

Si vous consultez la documentation OpenAI, vous pouvez voir la différence entre ceux-ci.

Et c'est à cela que sert la bibliothèque `tiktoken`. Cela nous aidera à savoir combien de jetons se trouvent dans la transcription, de cette façon nous saurons quel modèle utiliser pour le résumé.

Nous pouvons faire ce calcul avec le code suivant.

 import tiktoken enc = tiktoken.encoding_for_model(“gpt-3.5-turbo”) print(“Number of tokens in the input ”, len(enc.encode(podcast_transcript)))

Si le nombre de jetons dans le résultat est supérieur à 4 097, nous devrons alors utiliser la version « 16 000 » du modèle.

Après avoir su cela, nous pouvons enfin appeler l'API en utilisant le modèle approprié à la situation.

Tout d’abord, enregistrons l’invite que nous enverrons au modèle dans une variable. Vous pouvez expérimenter avec votre propre invite, mais voici un exemple :

 prompt = """ You are an expert marketer responsible for the growth of several popular podcasts. You are now tasked with summarizing an episode in a way that is concise and covers the main points of the episode for others to understand. The transcript of the episode is provided below. """ request = prompt + podcast_transcript

Maintenant, appelons l'API en utilisant le code suivant.

 chatOutput = openai.ChatCompletion.create(model="gpt-3.5-turbo-16k",    messages=[{"role": "system", "content": "You are a helpful assistant."},                        {"role": "user", "content": request}                        ]    )

Et puis vérifions la réponse de l'API.

 chatOutput.choices[0].messages.content

Voilà! Un résumé de l'épisode du podcast basé sur la transcription que nous avons générée à l'aide de Whisper.

Vous pouvez utiliser ce même processus pour extraire les principaux points forts de l'épisode. Un peu comme un moyen de donner à l’auditeur potentiel un aperçu de la conversation.

La façon de procéder est très similaire. La seule partie qui change est l'invite que le modèle recevra. Au lieu de demander un résumé, vous pouvez lui demander d’extraire les points les plus importants sous forme de liste. Les résultats dépendent de votre créativité avec les invites.

Maintenant que nous savons que cela fonctionne, nous pouvons mettre tout le code dans une fonction pour l'exécuter localement.

Alors, allons-y et créons cette fonction.

 def transcribe_podcast(file_path):    print("Starting podcast transcription")    # Load the Whisper model    import os    import Whisper    print("Loading the Whisper model")    model = whisper.load_model("medium")    print(model.device)    # Do the transcription    print("Starting the transcription")    result = model.transcribe(file_path)       # Return the transcribed text     print("Transcription completed, returning results...")    return result

Vous pouvez appeler cette fonction, lui envoyer le chemin d'un fichier audio et obtenir une transcription en retour.

Voici un exemple de la façon dont vous procéderiez.

 output = transcribe_podcast('path_to_audio_file')

Et puis jetez un œil au contenu de la transcription.

 output[text][:1000]

Très bien, jusqu'ici tout va bien.

Maintenant que cela fonctionne localement, ce serait formidable de le télécharger sur le cloud afin de pouvoir le montrer aux autres et impressionner vos amis et votre famille avec vos compétences en codage l33t h4xx0r. 😆

Mais non, vraiment, c'est un bon choix de le déployer sur un service en ligne afin que d'autres puissent l'essayer.

Et nous allons le faire dans la partie 2. Créer une fonction cloud capable d'accepter les demandes et créer une interface rapide pour visualiser les résultats de cette fonction (comme le résumé et les faits saillants des épisodes de podcast).

À suivre…

Nous en resterons là pour le moment.

Jusqu'à présent, l'application fonctionne localement et vous pouvez la tester avec différentes durées d'épisodes et voir le temps moyen nécessaire à Whisper pour effectuer la transcription.

Merci d'avoir lu jusqu'ici.

Et j'espère vous revoir pour la deuxième partie.

N'oubliez pas de vous abonner à moi sur Hackernoon pour ne pas rater les articles à venir.