Deepgram & Groq : Test du “Fastest LLM Inference” et du “Fastest Text to Speech Inference”

Tutoriel publié le 21/08/2024. Les outils et leurs interfaces peuvent avoir évolué. Cet exemple pédagogique ne constitue pas une réalisation client ni une garantie de résultat.

Technologies Utilisées

Comment ça marche ?

import requests
import speech_recognition as sr
from groq import Groq
import pygame
import datetime

def takeCommandCMic():
    r = sr.Recognizer()
    with sr.Microphone() as source:
        print("Listening...")
        r.pause_threshold = 1
        audio = r.listen(source)
    try:
        print("Recognizing...")
        query = r.recognize_google(audio, language='en-US')
        print(query)
        return query
    except Exception as e:
        print(e)
        return "Could not understand. Please try again."

def play_audio(audio_file):
    pygame.mixer.init()
    pygame.mixer.music.load(audio_file)
    pygame.mixer.music.play()
    while pygame.mixer.music.get_busy():
        pygame.time.Clock().tick(5)

GROQ_API_KEY = " "
DEEPGRAM_API_KEY = " "

client = Groq(api_key=GROQ_API_KEY)

def create_groq_response(user_input):
    chat_completion = client.chat.completions.create(
        messages=[{"role": "user", "content": user_input}],
        model="mixtral-8x7b-32768",
    )
    if chat_completion.choices:
        return chat_completion.choices[0].message.content
    else:
        return "Sorry, I couldn't retrieve a response."

def send_to_deepgram(text):
    url = "https://api.deepgram.com/v1/speak?model=aura-asteria-en"
    headers = {
        "Authorization": f"Token {DEEPGRAM_API_KEY}",
        "Content-Type": "application/json"
    }
    payload = {"text": text}
    response = requests.post(url, headers=headers, json=payload)
    if response.status_code == 200:
        timestamp = datetime.datetime.now().strftime("%Y%m%d%H%M%S")
        filename = f"output_response_{timestamp}.mp3"
        with open(filename, "wb") as f:
            f.write(response.content)
        print("Audio response saved successfully.")
        return filename
    else:
        print(f"Error: {response.status_code} - {response.text}")
        return None

while True:
    user_input = takeCommandCMic()
    if user_input.lower() in ["exit", "quit", "stop"]:
        print("Exiting...")
        break
    groq_response = create_groq_response(user_input)
    audio_file = send_to_deepgram(groq_response)
    if audio_file:
        play_audio(audio_file)

Résumé du code :

Composants principaux :

1. Imports :
   • requests : Pour envoyer des requêtes HTTP.
   • speech_recognition (as sr) : Pour la transcription de la parole en texte.
   • groq : Pour interagir avec l'API du chatbot Groq.
   • pygame : Pour la lecture audio.
   • datetime : Pour générer des horodatages.

Fonctions :

1. takeCommandCMic :
   • Utilise un microphone pour écouter les entrées vocales et les reconnaître grâce à l'API de reconnaissance vocale de Google.
   • Renvoie le texte reconnu ou un message d'erreur si la reconnaissance échoue.
2. play_audio :
   • Lit un fichier audio en utilisant le module pygame.
3. create_groq_response :
   • Génère une réponse du chatbot Groq en envoyant les entrées de l'utilisateur à l'API Groq.
   • Renvoie le texte de la réponse ou un message d'erreur.
4. send_to_deepgram :
   • Convertit le texte en parole en utilisant l'API Deepgram et enregistre le résultat en tant que fichier .mp3.
   • Renvoie le chemin du fichier audio enregistré ou None en cas d'erreur.

Clés d'API :

• GROQ_API_KEY et DEEPGRAM_API_KEY : Clés d'API temporaires à remplacer par des valeurs réelles pour Groq et Deepgram.

Boucle d'interaction principale :

• Écoute l'entrée vocale de l'utilisateur en utilisant takeCommandCMic.
• Si le texte reconnu correspond à "exit", "quit" ou "stop", la boucle se termine.
• Sinon, il génère une réponse du chatbot Groq et envoie la réponse à Deepgram pour la synthèse vocale.
• Enfin, l'audio synthétisé est lu en utilisant play_audio.

Flux du script :

1. Entrée vocale de l'utilisateur (takeCommandCMic)
2. Réponse du chatbot Groq (create_groq_response)
3. Conversion texte-parole (send_to_deepgram)
4. Lecture audio (play_audio)

Améliorations :

1. Gérer la récupération des clés d'API de manière sécurisée en utilisant des variables d'environnement.
2. Ajouter une gestion des erreurs pour les clés d'API vides ou invalides.
3. Inclure des messages plus conviviaux pour les erreurs d'API.

Conclusion :