Exigences audio de Whisper : guide complet des formats pris en charge et des spécifications

---

Formats audio pris en charge

Formats audio

Format	Extension	Notes
WAV	.wav	✅ Préféré, sans perte
MP3	.mp3	✅ Très répandu
FLAC	.flac	✅ Sans perte, bonne compression
M4A	.m4a	✅ Format Apple, codec AAC
AAC	.aac	✅ Compression haute qualité
OGG	.ogg	✅ Format open source
OPUS	.opus	✅ Faible latence, adapté au web
WMA	.wma	⚠️ Moins courant
AMR	.amr	⚠️ Faible qualité, enregistrements téléphoniques

Formats vidéo (extraction audio)

Format	Extension	Notes
MP4	.mp4	✅ Format vidéo le plus courant
AVI	.avi	✅ Ancien format, toujours pris en charge
MKV	.mkv	✅ Conteneur
MOV	.mov	✅ Format QuickTime
WebM	.webm	✅ Vidéo web
FLV	.flv	⚠️ Ancien format Flash

---

Exigences de fréquence d’échantillonnage

Fréquence optimale : 16 kHz

Fréquences prises en charge

Fréquence d’entrée	Traitement Whisper	Recommandation
8 kHz	Rééchantillonnage à 16 kHz	✅ Appels téléphoniques, acceptable
16 kHz	Utilisation directe	✅ Optimal, pas de rééchantillonnage
22,05 kHz	Rééchantillonnage à 16 kHz	✅ Bonne qualité
44,1 kHz	Rééchantillonnage à 16 kHz	✅ Qualité CD, correct
48 kHz	Rééchantillonnage à 16 kHz	✅ Audio pro, correct
96 kHz	Rééchantillonnage à 16 kHz	⚠️ Inutile, fichiers plus lourds

Bonne pratique

# Convert audio to 16 kHz before processing (optional optimization)
import ffmpeg

def convert_to_16khz(input_file, output_file):
    stream = ffmpeg.input(input_file)
    stream = ffmpeg.output(
        stream,
        output_file,
        acodec='pcm_s16le',
        ac=1,  # Mono
        ar=16000  # 16 kHz
    )
    ffmpeg.run(stream, overwrite_output=True)

---

Exigences de profondeur en bits

Profondeurs prises en charge

Profondeur	Statut	Notes
8 bits	✅ Pris en charge	Faible qualité, non recommandé
16 bits	✅ Recommandé	Standard, suffisant
24 bits	✅ Pris en charge	Professionnel, fichiers plus lourds
32 bits float	✅ Pris en charge	Qualité studio, excessif

---

Configuration des canaux : mono vs stéréo

Mono (recommandé)

• Fichiers plus petits
• Traitement plus rapide
• Pas de mixage de canaux nécessaire
• Optimal pour un seul locuteur

• Enregistrements à un locuteur
• Appels téléphoniques
• Podcasts avec un seul animateur
• La plupart des tâches de transcription

Stéréo (pris en charge)

• Locuteurs séparés sur des canaux distincts (rare)
• L’enregistrement d’origine est stéréo (conversion automatique)

import ffmpeg

# Convert stereo to mono
stream = ffmpeg.input('stereo_audio.wav')
stream = ffmpeg.output(
    stream,
    'mono_audio.wav',
    ac=1  # Mono channel
)
ffmpeg.run(stream, overwrite_output=True)

---

Limites de taille de fichier

Limites pratiques

Taille	Temps de traitement	Recommandation
< 10 Mo	Secondes	✅ Idéal
10–100 Mo	Minutes	✅ Bon
100–500 Mo	10–30 minutes	⚠️ Envisager le découpage
> 500 Mo	30+ minutes	⚠️ Découpage obligatoire

Mémoire

• Modèle base : ~1–2 Go VRAM
• Modèle small : ~2–3 Go VRAM
• Modèle medium : ~5–6 Go VRAM
• Modèle large : ~10–12 Go VRAM

---

Limites de durée

Durée recommandée

Durée	Statut	Notes
< 30 minutes	✅ Optimal	Traitement direct
30–60 minutes	✅ Bon	Découpage possible
1–2 heures	⚠️ Découpage recommandé	Souvent meilleure précision
> 2 heures	⚠️ Découpage obligatoire	Nécessaire pour la stabilité

Pourquoi découper les longs enregistrements ?

1. Limites mémoire : Évite les erreurs de mémoire insuffisante
2. Meilleure précision : Les segments courts conservent mieux le contexte
3. Traitement plus rapide : Traitement parallèle possible
4. Récupération d’erreurs : Si un segment échoue, les autres peuvent réussir

# Split long audio into 30-60 second chunks with 5-10 second overlap
def chunk_audio(audio_path, chunk_length=60, overlap=5):
    # Implementation: split audio into segments
    # Process each chunk separately
    # Merge results with timestamps
    pass

---

Exigences de qualité audio

Niveaux minimums

Facteur	Minimum	Optimal
Rapport signal/bruit	> 10 dB	> 20 dB
Débit (MP3)	≥ 64 kbps	≥ 128 kbps
Niveau sonore	Audible	Normalisé à -3 dB
Bruit de fond	Minimal	Aucun
Écho/réverbération	Minimal	Aucun

Liste de contrôle qualité

• ✅ Parole claire : Les locuteurs sont audibles et compréhensibles
• ✅ Peu de bruit : L’arrière-plan ne noie pas la voix
• ✅ Volume stable : Pas de variations brutales
• ✅ Pas d’écrêtage : Pas de distorsion ni saturation
• ✅ Bon micro : Matériel d’enregistrement de qualité

---

Exigences de codec

Codecs recommandés

Codec	Format	Qualité	Recommandation
PCM	WAV	Sans perte	✅ Meilleur pour la précision
FLAC	FLAC	Sans perte	✅ Excellent, compressé
AAC	M4A, MP4	Haute	✅ Très bon
MP3	MP3	Avec perte	✅ Bon à ≥128 kbps
OGG Vorbis	OGG	Avec perte	✅ Bonne qualité
OPUS	OPUS	Avec perte	✅ Bon, faible latence

Bonnes pratiques codec

• Utilisez PCM (WAV) ou FLAC (sans perte)

• Utilisez AAC ou MP3 à ≥128 kbps (excellents résultats)

• MP3 très bas débit (< 64 kbps)
• Formats trop compressés
• Codecs téléphoniques (AMR, G.711) sauf nécessité

---

Recommandations de prétraitement audio

Avant transcription

1. Normaliser le volume

import numpy as np
from scipy.io import wavfile

def normalize_audio(audio_path, output_path, target_dB=-3.0):
    sr, audio = wavfile.read(audio_path)
    audio = audio.astype(np.float32)
    
    # Normalize to target dB
    max_val = np.max(np.abs(audio))
    target_linear = 10 ** (target_dB / 20)
    audio = audio * (target_linear / max_val)
    
    # Clip to prevent overflow
    audio = np.clip(audio, -1.0, 1.0)
    
    wavfile.write(output_path, sr, (audio * 32767).astype(np.int16))

2. Supprimer le silence

# Remove leading/trailing silence
# Helps with processing time and accuracy

3. Réduction de bruit (optionnel)

# Use noise reduction libraries
# librosa, noisereduce, or specialized tools
# Only if background noise is significant

4. Rééchantillonner à 16 kHz (optionnel)

import ffmpeg

stream = ffmpeg.input('input.wav')
stream = ffmpeg.output(
    stream,
    'output_16k.wav',
    ar=16000  # Resample to 16 kHz
)
ffmpeg.run(stream, overwrite_output=True)

---

Problèmes audio courants et solutions

Problème 1 : Fréquence d’échantillonnage très basse (8 kHz)

• Utilisez le modèle medium ou large de Whisper (meilleur à basse fréquence)
• Suréchantillonnez à 16 kHz (ne restaure pas la qualité mais aide le traitement)

Problème 2 : Stéréo avec locuteurs différents

# Extract each channel separately
import torchaudio

audio, sr = torchaudio.load('stereo.wav')
speaker1 = audio[0]  # Left channel
speaker2 = audio[1]  # Right channel

# Transcribe each separately
result1 = model.transcribe(speaker1)
result2 = model.transcribe(speaker2)

Problème 3 : MP3 à débit variable (VBR)

• Convertissez en débit constant (CBR) ou WAV
• Whisper gère le VBR, mais le CBR est plus prévisible

Problème 4 : Fichiers audio corrompus

# Re-encode the file
import ffmpeg

stream = ffmpeg.input('corrupted.mp3')
stream = ffmpeg.output(
    stream,
    'fixed.wav',
    acodec='pcm_s16le'
)
ffmpeg.run(stream, overwrite_output=True)

Problème 5 : Fichiers audio très longs

• Découpez en segments de 30–60 secondes
• Traitez en séquence ou en parallèle
• Fusionnez les résultats avec horodatage

---

Recommandations par contexte

Appels téléphoniques

Paramètre	Valeur	Raison
Fréquence	8–16 kHz	Qualité téléphone
Format	WAV ou MP3	Standard
Débit	≥ 64 kbps	Qualité codec
Canaux	Mono	Standard appels

Réunions (Zoom, Teams)

Paramètre	Valeur	Raison
Fréquence	16–48 kHz	Haute qualité
Format	MP4 (extraire l’audio)	Vidéo
Débit	≥ 128 kbps	Bonne qualité
Canaux	Mono ou stéréo	Selon configuration

Podcasts

Paramètre	Valeur	Raison
Fréquence	44,1–48 kHz	Qualité pro
Format	MP3, WAV ou M4A	Courants
Débit	≥ 128 kbps	Bonne qualité
Canaux	Mono	Standard podcasts

Interviews

Paramètre	Valeur	Raison
Fréquence	16–48 kHz	Haute qualité
Format	WAV ou FLAC	Précision maximale
Débit	Sans perte ou ≥ 192 kbps	Professionnel
Canaux	Mono	Standard

---

Synthèse : exigences audio Whisper

Exigences minimales

• ✅ Format : Tout format pris en charge par FFmpeg
• ✅ Fréquence : Toute (8 kHz minimum recommandé)
• ✅ Profondeur : 8 bits ou plus
• ✅ Canaux : Mono ou stéréo (mono préféré)
• ✅ Taille : Pas de limite stricte (découper si > 100 Mo)
• ✅ Durée : Pas de limite stricte (découper si > 1 heure)

Exigences optimales

• ✅ Format : WAV, FLAC ou MP3 (≥128 kbps)
• ✅ Fréquence : 16 kHz (optimal, pas de rééchantillonnage)
• ✅ Profondeur : PCM 16 bits
• ✅ Canaux : Mono
• ✅ Qualité : Parole claire, peu de bruit
• ✅ Prétraitement : Volume normalisé, pas d’écrêtage

---

Référence rapide : liste de préparation audio

• Format : WAV, MP3, FLAC, M4A ou autre format pris en charge
• Fréquence : 16 kHz (optimal) ou tout taux pris en charge
• Profondeur : 16 bits (recommandé)
• Canaux : Mono (préféré) ou stéréo
• Taille : < 100 Mo (ou prévoir le découpage)
• Durée : < 1 heure (ou prévoir le découpage)
• Qualité : Parole claire, peu de bruit de fond
• Volume : Normalisé, pas d’écrêtage
• Codec : Sans perte (WAV/FLAC) ou avec perte haute qualité (MP3 ≥128 kbps)

---

Tester votre audio

Test rapide

import whisper

# Load model
model = whisper.load_model("base")

# Test transcription
result = model.transcribe("your_audio.wav")

# Check if successful
if result["text"]:
    print("✅ Audio format is compatible")
    print(f"Detected language: {result['language']}")
else:
    print("⚠️ Transcription failed - check audio format")

Messages d’erreur courants

Erreur	Cause	Solution
« File not found »	Chemin incorrect	Vérifier le chemin
« Unsupported format »	Format non pris en charge	Convertir en WAV/MP3
« Out of memory »	Fichier trop volumineux	Découper l’audio
« Empty audio »	Fichier corrompu	Réencoder le fichier

---

Synthèse des bonnes pratiques

1. 16 kHz quand c’est possible (optimal pour Whisper)
2. Préférer le mono au stéréo (Whisper traite en mono en interne)
3. Formats sans perte (WAV/FLAC) pour une précision maximale
4. Découper les longs fichiers (> 1 h) pour précision et stabilité
5. Normaliser l’audio pour des niveaux cohérents
6. Réduire le bruit de fond pour de meilleurs résultats
7. Choisir la taille de modèle adaptée (les grands modèles gèrent mieux un mauvais audio)
8. Tester d’abord avec le modèle base avant les modèles plus grands

---

Conclusion

• Format : WAV, FLAC ou MP3 (≥128 kbps)
• Fréquence : 16 kHz (optimal)
• Profondeur : PCM 16 bits
• Canaux : Mono
• Qualité : Parole claire avec peu de bruit

---