Communitygithub.com

math-inc/OpenGauss

Modèle de reconnaissance vocale généraliste 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). Utilisez-le pour la synthèse vocale, la transcription de podcasts ou le traitement audio multilingue. Idéal pour une ASR robuste et multilingue.

Qu'est-ce que OpenGauss ?

Whisper est un modèle de reconnaissance vocale multilingue open source développé par OpenAI. Il prend en charge 99 langues, permettant la transcription et la traduction vers l'anglais. Avec plusieurs tailles de modèle, de tiny (39M paramètres) à large (1550M paramètres), il offre un bon équilibre entre vitesse et précision. Utile pour la transcription de réunions, de podcasts, de vidéos et le traitement audio multilingue. Compatible avec les GPU pour une accélération significative (10 à 20×). Nécessite Python 3.8-3.11 et ffmpeg pour l'installation. La sortie peut être au format texte brut, SRT, VTT ou JSON avec horodatage.

Compatible avec~Claude Code✓Codex CLI~Cursor
npx skills add https://github.com/math-inc/OpenGauss/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

Whisper - Reconnaissance vocale robuste

Modèle de reconnaissance vocale multilingue d'OpenAI.

Quand utiliser Whisper

Utilisez-le quand :

  • Transcription de la parole (99 langues)
  • Transcription de podcasts/vidéos
  • Automatisation des notes de réunion
  • Traduction vers l'anglais
  • Transcription d'audio bruité
  • 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 streaming en 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 seulementMultilingueVitesseVRAM
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="en")

# Supportées : 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("spanish.mp3", task="translate")
# Entrée : audio espagnol → Sortie : texte anglais

Invite initiale

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

# Aide pour :
# - Les termes techniques
# - Les noms propres
# - Le vocabulaire spécifique au domaine

Horodatage

# Horodatage 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 horodatage

# Langue
whisper audio.mp3 --language Spanish

# Traduction
whisper spanish.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 streaming, utilisez faster-whisper
# pip install faster-whisper

from faster_whisper import WhisperModel

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

# Transcrire avec streaming
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 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 une invite initiale - Améliore les termes techniques
  4. Utilisez le GPU - 10 à 20 × plus rapide
  5. Traitement par lots - Plus efficace
  6. Convertissez en WAV - Meilleure compatibilité
  7. Divisez l'audio long - Morceaux de <30 minutes
  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

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 sur les longs formats - Se dégrade sur l'audio >30 min
  3. Identification des locuteurs - Pas de diarisation
  4. Accents - La qualité varie
  5. Bruit de fond - Peut affecter la précision
  6. Latence en temps réel - Pas adapté au sous-titrage en direct

Ressources

Skills associés