Dans cet article, nous allons explorer comment automatiser les entretiens IT en utilisant Ollama pour la génération de texte, et des solutions open-source pour la reconnaissance et la synthèse vocale, le tout en Python.

Prérequis

• Python 3.x
• Ollama
• Vosk (pour la reconnaissance vocale)
• eSpeak NG (pour la synthèse vocale)
• PyAudio
• Requests

Installation

1. Installez Ollama en suivant les instructions sur le site officiel.

2. Installez les dépendances Python :

pip install vosk py-espeak-ng pyaudio requests

3. Téléchargez un modèle acoustique Vosk pour votre langue depuis le site officiel de Vosk.

4. Installez eSpeak NG sur votre système (la méthode dépend de votre distribution Linux).

Structure du projet

Créez les fichiers suivants :

• interviewer.py
• speech_to_text.py
• text_to_speech.py
• ollama_client.py

Implémentation

speech_to_text.py

from vosk import Model, KaldiRecognizer
import wave

def recognize_speech(audio_file):
    model = Model("chemin/vers/votre/modele")
    rec = KaldiRecognizer(model, 16000)

    with wave.open(audio_file, "rb") as wf:
        while True:
            data = wf.readframes(4000)
            if len(data) == 0:
                break
            if rec.AcceptWaveform(data):
                result = rec.Result()
                return result["text"]

    return rec.FinalResult()["text"]

text_to_speech.py

from espeakng import ESpeakNG

def synthesize_speech(text, output_file):
    esng = ESpeakNG()
    esng.voice = 'fr'  # Choisissez la voix appropriée
    esng.save_to_file(text, output_file)
    print(f"Contenu audio écrit dans le fichier {output_file}")

ollama_client.py

import requests

def generate_response(prompt):
    url = "http://localhost:11434/api/generate"
    data = {
        "model": "mistral",
        "prompt": prompt
    }
    response = requests.post(url, json=data)
    return response.json()["response"]

interviewer.py

import pyaudio
import wave
from speech_to_text import recognize_speech
from text_to_speech import synthesize_speech
from ollama_client import generate_response

def record_audio(filename, duration=5):
    CHUNK = 1024
    FORMAT = pyaudio.paInt16
    CHANNELS = 1
    RATE = 16000

    p = pyaudio.PyAudio()

    stream = p.open(format=FORMAT,
                    channels=CHANNELS,
                    rate=RATE,
                    input=True,
                    frames_per_buffer=CHUNK)

    print("Enregistrement...")

    frames = []

    for i in range(0, int(RATE / CHUNK * duration)):
        data = stream.read(CHUNK)
        frames.append(data)

    print("Enregistrement terminé.")

    stream.stop_stream()
    stream.close()
    p.terminate()

    wf = wave.open(filename, 'wb')
    wf.setnchannels(CHANNELS)
    wf.setsampwidth(p.get_sample_size(FORMAT))
    wf.setframerate(RATE)
    wf.writeframes(b''.join(frames))
    wf.close()

def main():
    context = "Tu es un recruteur IT qui conduit un entretien pour un poste de développeur Python senior."
    
    while True:
        # Enregistrement de la question de l'utilisateur
        record_audio("question.wav")
        
        # Reconnaissance vocale
        question = recognize_speech("question.wav")
        print(f"Question: {question}")
        
        # Génération de la réponse avec Ollama
        prompt = f"{context}\nQuestion: {question}\nRéponse:"
        response = generate_response(prompt)
        print(f"Réponse: {response}")
        
        # Synthèse vocale de la réponse
        synthesize_speech(response, "reponse.wav")
        
        # Lecture de la réponse (à implémenter selon vos besoins)
        
        # Demander à l'utilisateur s'il souhaite continuer
        continuer = input("Voulez-vous poser une autre question ? (o/n) ")
        if continuer.lower() != 'o':
            break

if __name__ == "__main__":
    main()

Utilisation

1. Assurez-vous qu’Ollama est en cours d’exécution.
2. Exécutez python interviewer.py.
3. Posez vos questions à voix haute lorsque l’enregistrement commence.
4. Écoutez les réponses générées.

Conclusion

Ce projet démontre comment automatiser les entretiens IT en utilisant Ollama pour la génération de texte, Vosk pour la reconnaissance vocale, et eSpeak NG pour la synthèse vocale, le tout en Python. Cette approche offre une solution entièrement open-source et exécutable en local, garantissant la confidentialité des données et la possibilité de fonctionner hors-ligne.

En utilisant ces technologies libres, vous pouvez personnaliser et étendre le système selon vos besoins spécifiques. N’hésitez pas à expérimenter avec différents modèles Vosk ou voix eSpeak NG pour améliorer la qualité de la reconnaissance et de la synthèse vocale.