Communitygithub.com

ovachiever/droid-tings

Modèle de reconnaissance vocale multilingue d'OpenAI. Prend 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 de podcasts, le traitement audio multilingue et la reconnaissance vocale robuste.

Qu'est-ce que droid-tings ?

Whisper est un modèle de reconnaissance vocale (ASR) multilingue développé par OpenAI, formé sur 680 000 heures de données audio supervisées. Il prend en charge 99 langues et peut transcrire, traduire vers l'anglais ou identifier automatiquement la langue parlée. Le modèle se décline en six tailles — de `tiny` (39M paramètres) à `large` (1550M paramètres) et `turbo` (809M) — offrant un compromis entre vitesse et précision. Whisper s'utilise aussi bien en Python (via le package `openai-whisper`) qu'en ligne de commande (`whisper audio.mp3`), et il est compatible avec les accélérations GPU et CPU. Ses applications incluent la transcription de podcasts, la génération de sous-titres, l'automatisation de notes de réunion et le traitement audio multilingue. Pour un usage en temps réel ou des performances accrues, l'alternative `faster-whisper` est recommandée. Whisper est distribué sous licence MIT et bénéficie de plus de 72 900 étoiles GitHub.

Compatible avec~Claude Code✓Codex CLI~Cursor
npx skills add https://github.com/ovachiever/droid-tings/tree/HEAD/skills/whisper

Demander à votre IA préférée

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

Documentation

Whisper - Reconnaissance vocale robuste

Modèle de reconnaissance vocale multilingue d'OpenAI.

Quand utiliser Whisper

Utilisez 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 plutôt des alternatives :

  • AssemblyAI : API gérée, diarisation des locuteurs
  • Deepgram : ASR en streaming temps réel
  • Google Speech-to-Text : Basé sur le 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✓✓~32×~1 Go
base74M✓✓~16×~1 Go
small244M✓✓~6×~2 Go
medium769M✓✓~2×~5 Go
large1550M✗✓1×~10 Go
turbo809M✗✓~8×~6 Go

Recommandation : Utilisez turbo pour le meilleur rapport 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="fr")

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

Sélection de la tâche

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

# Traduction vers l'anglais
result = model.transcribe("espagnol.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 du mot
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 French

# Traduction
whisper espagnol.mp3 --task translate

Traitement par lots

import os

fichiers_audio = ["fichier1.mp3", "fichier2.mp3", "fichier3.mp3"]

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

    # Sauvegarder dans un fichier
    fichier_sortie = fichier_audio.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 si disponible
model = whisper.load_model("turbo")

# Forcer le CPU
model = whisper.load_model("turbo", device="cpu")

# Forcer le GPU
model = whisper.load_model("turbo", device="cuda")

# 10-20× 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 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 rapport 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× plus rapide
  5. Traitez par lots - Plus efficace
  6. Convertissez en WAV - Meilleure compatibilité
  7. Divisez les longs audios - Morceaux de <30 min
  8. Vérifiez la prise en charge des langues - La qualité varie selon la langue
  9. Utilisez faster-whisper - 4× plus rapide que openai-whisper
  10. Surveillez la VRAM - Adaptez la taille du modèle au matériel

Performances

ModèleFacteur temps réel (CPU)Facteur 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 temps réel : 0.1 = 10× plus rapide que le temps réel

Support linguistique

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 sur les longs formats - Se dégrade sur les audios >30 min
  3. Identification des locuteurs - Pas de diarisation
  4. Accents - Qualité variable
  5. Bruit de fond - Peut affecter la précision
  6. Latence temps réel - Ne convient pas au sous-titrage en direct

Ressources

Individual skills in this repo

This repo contains 3 individual skills — each has its own dedicated page.

Skills associés