Transcription avec Whisper

Motifs prêts pour la production pour la transcription audio/vidéo avec OpenAI Whisper.

Configuration requise

Options d'installation

Option 1 : OpenAI Whisper (Python)

# macOS/Linux/Windows
pip install openai-whisper

# Vérification
whisper --help

Option 2 : whisper.cpp (C++ - plus rapide)

# macOS
brew install whisper-cpp

# Linux - compilation depuis les sources
git clone https://github.com/ggerganov/whisper.cpp
cd whisper.cpp && make

# Windows - utiliser les binaires pré-construits ou compiler avec cmake

Option 3 : Insanely Fast Whisper (accéléré GPU)

pip install insanely-fast-whisper

Sélection du modèle

Modèle	Taille	VRAM	Précision	Vitesse	Cas d'utilisation
tiny	39M	~1 Go	Faible	La plus rapide	Aperçus rapides
base	74M	~1 Go	Moyenne	Rapide	Transcriptions provisoires
small	244M	~2 Go	Bonne	Moyenne	Usage général
medium	769M	~5 Go	Meilleure	Lente	Transcriptions de qualité
large-v3	1550M	~10 Go	Meilleure	La plus lente	Production finale

Recommandation : Commencez avec small pour un bon équilibre vitesse/qualité. Utilisez large-v3 pour la livraison finale.

Transcription de base

Avec OpenAI Whisper

# Transcription de base (détection automatique de la langue)
whisper audio.mp3 --model small

# Spécification de la langue et du format de sortie
whisper audio.mp3 --model medium --language fr --output_format srt

# Plusieurs formats de sortie
whisper audio.mp3 --model small --output_format all

# Avec horodatages et timing au niveau du mot
whisper audio.mp3 --model small --word_timestamps True

Avec whisper.cpp

# Téléchargement du modèle d'abord
./models/download-ggml-model.sh base.en

# Transcription
./main -m models/ggml-base.en.bin -f audio.wav -osrt

# Avec horodatages
./main -m models/ggml-base.en.bin -f audio.wav -ocsv

Formats de sortie

SRT (SubRip Subtitle)

1
00:00:01,000 --> 00:00:04,500
Bonjour et bienvenue dans cette vidéo.

2
00:00:05,000 --> 00:00:08,200
Aujourd'hui, nous allons discuter du montage vidéo.

VTT (WebVTT)

WEBVTT

00:00:01.000 --> 00:00:04.500
Bonjour et bienvenue dans cette vidéo.

00:00:05.000 --> 00:00:08.200
Aujourd'hui, nous allons discuter du montage vidéo.

JSON (avec timing au niveau du mot)

{
  "text": "Bonjour et bienvenue dans cette vidéo.",
  "segments": [
    {
      "id": 0,
      "start": 1.0,
      "end": 4.5,
      "text": " Bonjour et bienvenue dans cette vidéo.",
      "words": [
        {"word": "Bonjour", "start": 1.0, "end": 1.3},
        {"word": "et", "start": 1.4, "end": 1.5},
        {"word": "bienvenue", "start": 1.6, "end": 2.0},
        {"word": "dans", "start": 2.1, "end": 2.2},
        {"word": "cette", "start": 2.3, "end": 2.5},
        {"word": "vidéo", "start": 2.6, "end": 3.0}
      ]
    }
  ]
}

Extraction audio pour la transcription

Avant de transcrire une vidéo, extrayez l'audio dans un format optimal :

# Extraction audio en WAV (16 kHz, mono - optimal pour Whisper)
ffmpeg -i video.mp4 -ar 16000 -ac 1 -c:a pcm_s16le audio.wav

# Extraction en WAV haute qualité pour archivage
ffmpeg -i video.mp4 -vn -c:a pcm_s16le audio.wav

# Extraction en MP3 compressé (plus petit, fonctionne toujours)
ffmpeg -i video.mp4 -vn -c:a libmp3lame -q:a 2 audio.mp3

Synchronisation temporelle

Conversion JSON Whisper en timing FCP

import json

def whisper_to_fcp_timing(whisper_json_path, fps=24):
    """Convertit la sortie JSON Whisper en timing compatible FCP."""
    with open(whisper_json_path) as f:
        data = json.load(f)

    segments = []
    for seg in data.get("segments", []):
        segments.append({
            "start_time": seg["start"],
            "end_time": seg["end"],
            "start_frame": int(seg["start"] * fps),
            "end_frame": int(seg["end"] * fps),
            "text": seg["text"].strip(),
            "words": seg.get("words", [])
        })

    return segments

Timing image par image

# Obtenir le nombre exact d'images et la durée
ffprobe -v error -count_frames -select_streams v:0 \
  -show_entries stream=nb_read_frames,duration,r_frame_rate \
  -of json video.mp4

Diarisation des locuteurs

Pour du contenu avec plusieurs locuteurs, utilisez pyannote.audio :

pip install pyannote.audio

from pyannote.audio import Pipeline

pipeline = Pipeline.from_pretrained("pyannote/[email protected]")
diarization = pipeline("audio.wav")

for turn, _, speaker in diarization.itertracks(yield_label=True):
    print(f"{turn.start:.1f}s - {turn.end:.1f}s : {speaker}")

Traitement par lots

#!/bin/bash
# Transcrire toutes les vidéos d'un répertoire

MODEL="small"
OUTPUT_DIR="transcripts"
mkdir -p "$OUTPUT_DIR"

for video in *.mp4 *.mov *.avi; do
  [[ -f "$video" ]] || continue

  base="${video%.*}"

  # Extraction audio
  ffmpeg -i "$video" -ar 16000 -ac 1 -c:a pcm_s16le "/tmp/${base}.wav" -y

  # Transcription
  whisper "/tmp/${base}.wav" --model "$MODEL" \
    --output_format all \
    --output_dir "$OUTPUT_DIR"

  # Nettoyage de l'audio temporaire
  rm "/tmp/${base}.wav"

  echo "Transcrit : $video"
done

Optimisation de la qualité

Améliorer la précision

Réduction du bruit avant la transcription :

ffmpeg -i noisy_audio.wav -af "highpass=f=200,lowpass=f=3000,afftdn=nf=-25" clean_audio.wav

Utiliser une indication de langue :

whisper audio.mp3 --language fr --model medium

Fournir une invite initiale pour le contexte :

whisper audio.mp3 --initial_prompt "Discussion technique sur le logiciel de montage vidéo."

Conseils de performance

Accélération GPU (si disponible) :

whisper audio.mp3 --model large-v3 --device cuda

Traiter par morceaux pour les longues vidéos :

# Diviser l'audio en segments de 10 minutes
# Transcrire chaque segment
# Fusionner les résultats avec ajustement du décalage temporel

Gestion des erreurs

# Valider le fichier audio avant la transcription
validate_audio() {
  local file="$1"
  if ffprobe -v error -select_streams a:0 -show_entries stream=codec_type -of csv=p=0 "$file" 2>/dev/null | grep -q "audio"; then
    return 0
  else
    echo "Erreur : Aucun flux audio trouvé dans $file"
    return 1
  fi
}

# Vérifier l'installation de Whisper
check_whisper() {
  if command -v whisper &> /dev/null; then
    echo "Whisper disponible"
    return 0
  else
    echo "Erreur : Whisper non installé. Exécutez : pip install openai-whisper"
    return 1
  fi
}

Compétences associées

ffmpeg-core - Extraction audio et prétraitement
final-cut-pro - Importation de transcriptions en tant que titres/marqueurs

MadAppGang/claude-code

Qu'est-ce que claude-code ?

Demander à votre IA préférée

Documentation