hearing Transcription audio avec Whisper.cpp

mkdir whisper-tuto
cd whisper-tuto

python -m venv venv
venv\Scripts\activate            # Windows
source venv/bin/activate         # macOS / Linux

# faster-whisper : binding Python de Whisper.cpp optimisé (CTranslate2)
pip install faster-whisper

# ffmpeg est nécessaire pour la conversion audio
# Windows : télécharger sur https://ffmpeg.org/download.html et ajouter au PATH
# macOS   : brew install ffmpeg
# Linux   : sudo apt install ffmpeg

from faster_whisper import WhisperModel
import sys
import os

# ── Charger le modèle ─────────────────────────────────────────────────────────
# Tailles disponibles : tiny, base, small, medium, large-v3
# tiny   → très rapide, moins précis (~75 Mo)
# base   → bon compromis pour le français (~145 Mo)
# small  → meilleur en précision (~485 Mo)
# medium → excellent, lent sur CPU (~1.5 Go)
# large-v3 → le meilleur, GPU recommandé (~3 Go)

MODELE = "base"          # on commence avec "base"
DEVICE = "cpu"           # "cuda" si tu as un GPU NVIDIA
COMPUTE_TYPE = "int8"    # int8 = plus rapide sur CPU, float16 sur GPU

print(f"Chargement du modèle Whisper '{MODELE}'...")
model = WhisperModel(MODELE, device=DEVICE, compute_type=COMPUTE_TYPE)
print("Modèle prêt.\n")


def transcrire_fichier(chemin_audio: str, langue: str = None) -> str:
    """
    Transcrit un fichier audio en texte.
    
    chemin_audio : chemin vers le fichier audio (WAV, MP3, MP4…)
    langue       : code langue ("fr", "en"…) ou None pour détection automatique
    
    Retourne le texte transcrit.
    """
    if not os.path.exists(chemin_audio):
        raise FileNotFoundError(f"Fichier introuvable : {chemin_audio}")

    print(f"Transcription de : {chemin_audio}")

    # segments est un générateur — chaque segment est un morceau transcrit
    # info contient les métadonnées (langue détectée, durée…)
    segments, info = model.transcribe(
        chemin_audio,
        language=langue,            # None = détection automatique
        beam_size=5,                # plus élevé = plus précis mais plus lent
        vad_filter=True,            # VAD = Voice Activity Detection, ignore les silences
        vad_parameters=dict(
            min_silence_duration_ms=500,  # silence > 500ms = nouvelle phrase
        ),
    )

    langue_detectee = info.language
    proba_langue    = info.language_probability
    print(f"Langue détectée : {langue_detectee} (confiance : {proba_langue:.0%})")
    print(f"Durée audio     : {info.duration:.1f} secondes\n")

    # Assembler les segments en texte complet
    texte_complet = ""
    for segment in segments:
        # Chaque segment a : start (secondes), end (secondes), text (texte)
        debut = segment.start
        fin   = segment.end
        texte = segment.text.strip()
        print(f"[{debut:5.1f}s → {fin:5.1f}s]  {texte}")
        texte_complet += texte + " "

    return texte_complet.strip()


# ── Point d'entrée ────────────────────────────────────────────────────────────
if __name__ == "__main__":
    # Utilisation : python transcribe.py mon_audio.mp3
    if len(sys.argv) < 2:
        print("Usage : python transcribe.py ")
        print("Exemple : python transcribe.py interview.mp3")
        sys.exit(1)

    fichier = sys.argv[1]

    try:
        texte = transcrire_fichier(fichier)
        print("\n" + "="*50)
        print("TRANSCRIPTION COMPLÈTE :")
        print("="*50)
        print(texte)

        # Sauvegarder dans un fichier .txt
        nom_sortie = os.path.splitext(fichier)[0] + "_transcription.txt"
        with open(nom_sortie, "w", encoding="utf-8") as f:
            f.write(texte)
        print(f"\nTranscription sauvegardée : {nom_sortie}")

    except FileNotFoundError as e:
        print(f"Erreur : {e}")

# Remplace mon_audio.mp3 par ton fichier
python transcribe.py mon_audio.mp3

# Forcer la langue française (évite les erreurs de détection)
# modifie la ligne : transcrire_fichier(fichier, langue="fr")

pip install sounddevice numpy scipy

import sounddevice as sd
import numpy as np
import scipy.io.wavfile as wav
import tempfile
import os
from faster_whisper import WhisperModel

# Paramètres audio
SAMPLE_RATE    = 16000   # Whisper travaille en 16 kHz
DUREE_ECOUTE   = 5       # secondes d'enregistrement par chunk
MODELE         = "base"

print("Chargement du modèle Whisper...")
model = WhisperModel(MODELE, device="cpu", compute_type="int8")
print("Modèle prêt. Parle dans ton micro — Ctrl+C pour arrêter.\n")

def enregistrer_chunk(duree: int) -> np.ndarray:
    """Enregistre `duree` secondes depuis le micro, retourne un tableau numpy."""
    print(f"🎙 Écoute ({duree}s)...", end=" ", flush=True)
    audio = sd.rec(
        int(duree * SAMPLE_RATE),
        samplerate=SAMPLE_RATE,
        channels=1,
        dtype="float32",
    )
    sd.wait()  # attendre la fin de l'enregistrement
    return audio.flatten()

def transcrire_numpy(audio: np.ndarray) -> str:
    """Transcrit un tableau numpy audio en texte."""
    # Whisper accepte un tableau numpy float32 directement
    segments, _ = model.transcribe(
        audio,
        language="fr",
        beam_size=5,
        vad_filter=True,
    )
    return " ".join(seg.text.strip() for seg in segments)

# Boucle d'écoute en continu
try:
    while True:
        audio = enregistrer_chunk(DUREE_ECOUTE)
        texte = transcrire_numpy(audio)
        if texte:
            print(f"→ {texte}")
        else:
            print("(silence)")
except KeyboardInterrupt:
    print("\nArrêt.")

# tiny    → CPU lent / vieux PC    | ~75 Mo  | rapide mais imprécis en français
# base    → CPU moderne             | ~145 Mo | bon compromis pour débuter
# small   → CPU rapide / GPU       | ~485 Mo | recommandé pour le français
# medium  → GPU 4+ Go              | ~1.5 Go | excellent pour le français
# large-v3 → GPU 8+ Go             | ~3 Go   | meilleur modèle disponible

# Changer le modèle dans le script :
model = WhisperModel("small", device="cpu", compute_type="int8")     # CPU
model = WhisperModel("large-v3", device="cuda", compute_type="float16")  # GPU