Communitygithub.com

Whisper – Reconnaissance vocale robuste

Modèle de reconnaissance vocale multilingue d'OpenAI prenant en charge 99 langues, la transcription, la traduction vers l'anglais et l'identification de la langue. Six tailles de modèle de tiny (39M paramètres) à large (1550M paramètres). Idéal pour la transcription audio, les podcasts et le traitement vocal multilingue.

Qu'est-ce que Whisper – Reconnaissance vocale robuste ?

Whisper est un modèle de reconnaissance vocale généraliste développé par OpenAI, conçu pour transcrire et traduire de l'audio en texte en anglais. Il prend en charge 99 langues avec une identification automatique de la langue et permet la transcription native ou la traduction vers l'anglais. Le modèle existe en six tailles (tiny, base, small, medium, large, turbo) allant de 39 millions à 1,55 milliard de paramètres, ce qui permet d'adapter le compromis vitesse/précision aux ressources matérielles disponibles. Whisper est particulièrement robuste pour les environnements bruyants et les accents variés, grâce à un entraînement sur 680 000 heures de données audio. Il peut être utilisé en ligne de commande ou via l'API Python, supporte l'accélération GPU, la génération de sous-titres, et s'intègre avec des outils comme LangChain et ffmpeg. Une alternative plus rapide (`faster-whisper`) est disponible pour la transcription en temps réel. Ses limites incluent les hallucinations, la baisse de qualité sur les longs audios, et l'absence de diarisation des locuteurs.

Compatible avec~Claude Code✓Codex CLI~Cursor
npx skills add https://github.com/graniet/kheish/tree/HEAD/skills/mlops/models/whisper

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Compatibilité Kheish

Cette compétence est locale au dépôt et reste inactive jusqu'à activation explicite.

Lorsque les instructions originales font référence à des noms d'outils hérités, utilisez ces correspondances Kheish :

  • terminal => bash
  • web_extract => web_fetch, plus web_search si une découverte est nécessaire
  • search_files => grep_search et glob_search
  • Les outils browser_* nécessitent un outil compatible navigateur ou MCP ; si aucun n'est disponible, utilisez la surface la plus proche disponible et mentionnez-le explicitement

Lorsque les instructions mentionnent des fichiers d'aide locaux, résolvez-les à partir de ${KHEISH_SKILL_DIR}.

Whisper - Reconnaissance vocale robuste

Modèle de reconnaissance vocale multilingue d'OpenAI.

Quand utiliser Whisper

Utilisez-le quand :

  • Transcription parole-texte (99 langues)
  • Transcription de podcasts/vidéos
  • Automatisation de notes de réunion
  • Traduction vers l'anglais
  • Transcription audio bruitée
  • Traitement audio multilingue

Métriques :

  • 72 900+ étoiles GitHub
  • 99 langues prises en charge
  • Entraîné sur 680 000 heures d'audio
  • Licence MIT

Utilisez des alternatives à la place :

  • AssemblyAI : API gérée, diarisation des locuteurs
  • Deepgram : ASR en flux temps réel
  • Google Speech-to-Text : Cloud

Démarrage rapide

Installation

# Nécessite Python 3.8-3.11
pip install -U openai-whisper

# Nécessite ffmpeg
# macOS : brew install ffmpeg
# Ubuntu : sudo apt install ffmpeg
# Windows : choco install ffmpeg

Transcription de base

import whisper

# Charger le modèle
model = whisper.load_model("base")

# Transcrire
result = model.transcribe("audio.mp3")

# Afficher le texte
print(result["text"])

# Accéder aux segments
for segment in result["segments"]:
    print(f"[{segment['start']:.2f}s - {segment['end']:.2f}s] {segment['text']}")

Tailles de modèle

# Modèles disponibles
models = ["tiny", "base", "small", "medium", "large", "turbo"]

# Charger un modèle spécifique
model = whisper.load_model("turbo")  # Plus rapide, bonne qualité
ModèleParamètresAnglais uniquementMultilingueVitesseVRAM
tiny39M✓✓~32x~1 Go
base74M✓✓~16x~1 Go
small244M✓✓~6x~2 Go
medium769M✓✓~2x~5 Go
large1550M✗✓1x~10 Go
turbo809M✗✓~8x~6 Go

Recommandation : Utilisez turbo pour le meilleur compromis vitesse/qualité, base pour le prototypage

Options de transcription

Spécification de la langue

# Détection automatique de la langue
result = model.transcribe("audio.mp3")

# Spécifier la langue (plus rapide)
result = model.transcribe("audio.mp3", language="en")

# Prises en charge : en, es, fr, de, it, pt, ru, ja, ko, zh, et 89 de plus

Sélection de la tâche

# Transcription (par défaut)
result = model.transcribe("audio.mp3", task="transcribe")

# Traduction vers l'anglais
result = model.transcribe("spanish.mp3", task="translate")
# Entrée : audio espagnol → Sortie : texte anglais

Prompt initial

# Améliorer la précision avec du contexte
result = model.transcribe(
    "audio.mp3",
    initial_prompt="Ceci est un podcast technique sur l'apprentissage automatique et l'IA."
)

# Aide pour :
# - Termes techniques
# - Noms propres
# - Vocabulaire spécifique au domaine

Horodatages

# Horodatages au niveau des mots
result = model.transcribe("audio.mp3", word_timestamps=True)

for segment in result["segments"]:
    for word in segment["words"]:
        print(f"{word['word']} ({word['start']:.2f}s - {word['end']:.2f}s)")

Repli de température

# Réessayer avec différentes températures si la confiance est faible
result = model.transcribe(
    "audio.mp3",
    temperature=(0.0, 0.2, 0.4, 0.6, 0.8, 1.0)
)

Utilisation en ligne de commande

# Transcription de base
whisper audio.mp3

# Spécifier le modèle
whisper audio.mp3 --model turbo

# Formats de sortie
whisper audio.mp3 --output_format txt     # Texte brut
whisper audio.mp3 --output_format srt     # Sous-titres
whisper audio.mp3 --output_format vtt     # WebVTT
whisper audio.mp3 --output_format json    # JSON avec horodatages

# Langue
whisper audio.mp3 --language Spanish

# Traduction
whisper spanish.mp3 --task translate

Traitement par lots

import os

fichiers_audio = ["file1.mp3", "file2.mp3", "file3.mp3"]

for fichier in fichiers_audio:
    print(f"Transcription de {fichier}...")
    result = model.transcribe(fichier)

    # Sauvegarder dans un fichier
    fichier_sortie = fichier.replace(".mp3", ".txt")
    with open(fichier_sortie, "w") as f:
        f.write(result["text"])

Transcription en temps réel

# Pour l'audio en flux, utilisez faster-whisper
# pip install faster-whisper

from faster_whisper import WhisperModel

model = WhisperModel("base", device="cuda", compute_type="float16")

# Transcrire avec flux
segments, info = model.transcribe("audio.mp3", beam_size=5)

for segment in segments:
    print(f"[{segment.start:.2f}s -> {segment.end:.2f}s] {segment.text}")

Accélération GPU

import whisper

# Utilise automatiquement le GPU s'il est disponible
model = whisper.load_model("turbo")

# Forcer l'utilisation du CPU
model = whisper.load_model("turbo", device="cpu")

# Forcer l'utilisation du GPU
model = whisper.load_model("turbo", device="cuda")

# 10 à 20 fois plus rapide sur GPU

Intégration avec d'autres outils

Génération de sous-titres

# Générer des sous-titres SRT
whisper video.mp4 --output_format srt --language English

# Sortie : video.srt

Avec LangChain

from langchain.document_loaders import WhisperTranscriptionLoader

loader = WhisperTranscriptionLoader(file_path="audio.mp3")
docs = loader.load()

# Utiliser la transcription dans un RAG
from langchain_chroma import Chroma
from langchain_openai import OpenAIEmbeddings

vectorstore = Chroma.from_documents(docs, OpenAIEmbeddings())

Extraire l'audio d'une vidéo

# Utiliser ffmpeg pour extraire l'audio
ffmpeg -i video.mp4 -vn -acodec pcm_s16le audio.wav

# Puis transcrire
whisper audio.wav

Bonnes pratiques

  1. Utilisez le modèle turbo - Meilleur compromis vitesse/qualité pour l'anglais
  2. Spécifiez la langue - Plus rapide que la détection automatique
  3. Ajoutez un prompt initial - Améliore les termes techniques
  4. Utilisez le GPU - 10 à 20 fois plus rapide
  5. Traitez par lots - Plus efficace
  6. Convertissez en WAV - Meilleure compatibilité
  7. Divisez les longs audios - <30 min par morceau
  8. Vérifiez la prise en charge des langues - La qualité varie selon la langue
  9. Utilisez faster-whisper - 4 fois plus rapide que openai-whisper
  10. Surveillez la VRAM - Adaptez la taille du modèle au matériel

Performances

ModèleFacteur de temps réel (CPU)Facteur de temps réel (GPU)
tiny~0.32~0.01
base~0.16~0.01
turbo~0.08~0.01
large~1.0~0.05

Facteur de temps réel : 0.1 = 10 fois plus rapide que le temps réel

Prise en charge des langues

Langues les mieux prises en charge :

  • Anglais (en)
  • Espagnol (es)
  • Français (fr)
  • Allemand (de)
  • Italien (it)
  • Portugais (pt)
  • Russe (ru)
  • Japonais (ja)
  • Coréen (ko)
  • Chinois (zh)

Liste complète : 99 langues au total

Limitations

  1. Hallucinations - Peut répéter ou inventer du texte
  2. Précision des longs audios - Se dégrade sur des audios de plus de 30 minutes
  3. Identification des locuteurs - Pas de diarisation
  4. Accents - La qualité varie
  5. Bruit de fond - Peut affecter la précision
  6. Latence temps réel - Non adapté au sous-titrage en direct

Ressources

Skills associés