AI Endpoints - Transcrire et résumer des fichiers audio

Introduction

Vous cherchez un moyen de résumer efficacement vos réunions, diffusions et podcasts, pour une consultation rapide ou pour les partager avec d'autres ? Ne cherchez plus !

Objectif

Dans ce tutoriel, vous allez créer un assistant Audio Summarizer capable non seulement de transcrire, mais aussi de résumer l'ensemble de vos fichiers audio.

En effet, grâce à AI Endpoints, il n'a jamais été aussi facile de créer un assistant virtuel qui vous aide à suivre vos réunions et à garder trace des informations importantes.

Ce tutoriel explore comment connecter des API d'IA pour créer un assistant virtuel avancé capable de transcrire et de résumer n'importe quel fichier audio à l'aide des technologies d'ASR (Automatic Speech Recognition) et de LLM (Large Language Models) populaires. Nous allons également construire une application pour utiliser notre assistant !

Définitions

• Automatic Speech Recognition (ASR) : technologie qui convertit le langage parlé en texte écrit. L'ASR sera utilisée ici pour transcrire de longs enregistrements audio en texte, qui sera ensuite résumé à l'aide de LLM.
• Large Language Models (LLM) : modèles avancés entraînés pour comprendre le contexte et générer des réponses proches de celles d'un humain. Dans ce cas d'usage, le prompt du LLM sera conçu pour générer un résumé du texte d'entrée à partir de la sortie de l'endpoint d'ASR.

Prérequis

• Un projet Public Cloud dans votre compte OVHcloud
• Un token d'accès pour OVHcloud AI Endpoints. Pour créer un token API, suivez les instructions du guide AI Endpoints - Premiers pas.

En pratique

Configurer l'environnement

Afin d'utiliser facilement les API d'AI Endpoints, créez un fichier .env pour stocker les variables d'environnement :

OVH_AI_ENDPOINTS_URL=https://oai.endpoints.kepler.ai.cloud.ovh.net/v1
OVH_AI_ENDPOINTS_ACCESS_TOKEN=<ai-endpoints-api-token>

Veillez à remplacer la valeur du token (OVH_AI_ENDPOINTS_ACCESS_TOKEN) par la vôtre. Si vous n'en avez pas encore, suivez les instructions du guide AI Endpoints - Premiers pas.

Créez ensuite un fichier requirements.txt avec les bibliothèques suivantes :

openai==1.13.3
gradio==4.36.1
pydub==0.25.1
python-dotenv==1.0.1

Lancez ensuite l'installation de ces dépendances :

pip install -r requirements.txt

Notez que Python 3.11 est utilisé dans ce tutoriel.

Importer les bibliothèques et variables nécessaires

Une fois cela fait, vous pouvez créer un fichier Python nommé audio-summarizer-app.py, dans lequel vous importerez d'abord les bibliothèques Python comme suit :

import gradio as gr
import io
import os
import requests
from pydub import AudioSegment
from dotenv import load_dotenv
from openai import OpenAI
import functools

Après ces lignes, chargez et accédez aux variables d'environnement de votre fichier .env :

# access the environment variables from the .env file
load_dotenv()

ai_endpoint_url = os.getenv("OVH_AI_ENDPOINTS_URL")
ai_endpoint_token = os.getenv("OVH_AI_ENDPOINTS_ACCESS_TOKEN")

Définissez ensuite le client qui communique avec les API et authentifie vos requêtes :

oai_client = OpenAI(
    base_url=ai_endpoint_url,
    api_key=ai_endpoint_token
)

💡 Vous êtes maintenant prêt à commencer à coder votre application web.

Transcrire un fichier audio avec l'ASR

Créez d'abord la fonction d'Automatic Speech Recognition afin de transcrire les fichiers audio en texte :

def asr_transcription(oai_client, audio):
    
    if audio is None:
        return " "

    else:
        # preprocess audio 
        processed_audio = "/tmp/my_audio.wav"
        audio_input = AudioSegment.from_file(audio, "mp3")
        process_audio_to_wav = audio_input.set_channels(1)
        process_audio_to_wav = process_audio_to_wav.set_frame_rate(16000)
        process_audio_to_wav.export(processed_audio, format="wav")
    
        with open(processed_audio, "rb") as audio_file:
            response = oai_client.audio.transcriptions.create(
                model="whisper-large-v3",
                file=audio_file,
                response_format="verbose_json",
                timestamp_granularities=["segment"]
            )

        # return complete transcription
        return response.text

Dans cette fonction :

• Le fichier audio est prétraité comme suit : format .wav, 1 canal, fréquence d'échantillonnage 16000
• L'audio transformé processed_audio est lu
• Un appel API est effectué vers l'endpoint d'ASR nommé whisper-large-v3
• La réponse complète est stockée dans la variable resp et renvoyée par la fonction

🎉 Maintenant que vous disposez de cette fonction, vous êtes prêt à transcrire des fichiers audio.

Il est maintenant temps d'appeler un LLM pour résumer le texte transcrit.

Résumer l'audio avec un LLM

Dans cette seconde étape, créez la fonction chat_completion pour utiliser efficacement gpt-oss-120b (ou tout autre modèle) :

Que faire ?

• Vérifier que la transcription existe
• Utiliser la compatibilité avec l'API OpenAI pour appeler le LLM
• Personnaliser votre prompt afin de préciser la tâche du LLM
• Renvoyer le résumé audio

def chat_completion(oai_client, new_message):

    if new_message==" ":
        return "Please, send an input audio to get its summary!"
    
    else:

        # prompt
        history_openai_format = [{"role": "user", "content": f"Summarize the following text in a few words: {new_message}"}]
        # return summary
        return oai_client.chat.completions.create(
            model="gpt-oss-120b",
            messages=history_openai_format,
            temperature=0,
            max_tokens=1024
        ).choices.pop().message.content

⚡️ Vous y êtes presque ! La dernière étape consiste à construire votre application web, rendant votre solution facile à utiliser en quelques lignes de code.

Construire l'application avec Gradio

Gradio est une bibliothèque Python open source permettant de créer rapidement des interfaces utilisateur pour des modèles de Machine Learning et des démonstrations.

Qu'est-ce que cela signifie en pratique ?

À l'intérieur d'un Gradio Block, vous pouvez :

• Définir un thème pour votre interface
• Ajouter un titre à votre application web avec gr.HTML()
• Envoyer un fichier audio grâce au composant dédié, gr.Audio()
• Obtenir le résultat de la transcription écrite avec gr.Textbox()
• Obtenir un résumé de l'audio grâce au puissant LLM et à un second composant gr.Textbox()
• Ajouter un bouton de réinitialisation avec gr.ClearButton() pour réinitialiser la page de l'application web

asr_transcribe_fn = functools.partial(asr_transcription, oai_client)
chat_completion_fn = functools.partial(chat_completion, oai_client)

# gradio
with gr.Blocks(theme=gr.themes.Default(primary_hue="blue"), fill_height=True) as demo:

    # add title and description
    with gr.Row():
        gr.HTML(
            """
            <div align="center">
                <h1>Welcome on Audio Summarizer web app 💬!</h1>
                <i>Transcribe and summarize your broadcast, meetings, conversations, potcasts and much more...</i>
            </div>
            <br/>
            """
        )
        
    # audio zone for user question
    gr.Markdown("## Upload your audio file 📢")
    with gr.Row():
        inp_audio = gr.Audio(
            label = "Audio file in .wav or .mp3 format:",
            sources = ['upload'],
            type = "filepath",
        )

    # written transcription of user question
    with gr.Row():
        inp_text = gr.Textbox(
            label = "Audio transcription into text:",
        )
        
    # chabot answer
    gr.Markdown("## Chatbot summarization 🤖")
    with gr.Row():
        out_resp = gr.Textbox(
            label = "Get a summary of your audio:",
        )

    with gr.Row():
        
        # clear inputs
        clear = gr.ClearButton([inp_audio, inp_text, out_resp])
  
    # update functions
    inp_audio.change(
        fn = asr_transcribe_fn,
        inputs = inp_audio,
        outputs = inp_text
      )
    inp_text.change(
        fn = chat_completion_fn,
        inputs = inp_text,
        outputs = out_resp
      )

Vous pouvez ensuite la lancer dans le main :

if __name__ == '__main__':
    demo.launch(server_name="0.0.0.0", server_port=8000)

Lancer l'application web Gradio en local

🚀 Voilà ! Votre application web est maintenant prête à être utilisée ! Vous pouvez démarrer cette application Gradio en local en lançant la commande suivante :

python audio-summarizer-app.py

Vous pouvez envoyer vos fichiers audio, obtenir une transcription puis un résumé !

Conclusion

Bravo 🎉 ! Vous avez appris à construire votre propre application Audio Summarizer en quelques lignes de code. Vous avez également constaté à quel point il est facile d'utiliser AI Endpoints pour créer des solutions clés en main innovantes.

➡️ Accédez au code complet ici.

Aller plus loin

Si vous souhaitez aller plus loin et déployer votre application web dans le cloud, en rendant votre interface accessible à tous, reportez-vous aux articles et tutoriels suivants :

• AI Deploy - Tutoriel - Créer et utiliser une image Docker personnalisée
• AI Deploy - Tutoriel - Déployer une app Gradio pour de la reconnaissance de schémas

Si vous avez besoin d'une formation ou d'une assistance technique pour la mise en oeuvre de nos solutions, contactez votre commercial ou cliquez sur ce lien pour obtenir un devis et demander une analyse personnalisée de votre projet à nos experts de l’équipe Professional Services.

Nous voulons vos retours !

N’hésitez pas à nous faire part de vos questions, retours et suggestions concernant AI Endpoints et ses fonctionnalités :

• Dans le canal #ai-endpoints du serveur Discord OVHcloud, où vous pouvez échanger avec la communauté et les équipes OVHcloud.