Les tailles de modèles Whisper expliquées : Tiny vs Base vs Small vs Medium vs Large
Tous les modèles Whisper, comparés. Paramètres, vitesse, précision, et celui que vous devriez réellement utiliser.
OpenWhispr
Ingénierie
Table des matières
Whisper d'OpenAI se décline en 9 variantes de modèles réparties en 5 catégories de taille : tiny (39 millions de paramètres), base (74M), small (244M), medium (769M) et large (1,55 Md). Chaque taille existe en version multilingue et en version anglais uniquement (à l'exception de large et turbo, qui sont uniquement multilingues). Il existe également un modèle turbo (809M) — une version distillée de large-v3 presque aussi précise mais nettement plus rapide. Les modèles plus volumineux sont plus précis mais plus lents et nécessitent davantage de mémoire.
Pour le format quantifié whisper.cpp (GGML) utilisé par la plupart des applications de transcription locale, les fichiers de modèles vont de 75 Mo (tiny) à 2,9 Go (large). L'utilisation mémoire à l'exécution varie d'environ 273 Mo pour tiny à 3,9 Go pour large. Le bon modèle dépend de votre matériel, de votre langue et du niveau de précision dont vous avez besoin.
Dernière mise à jour : 17 février 2026. Les chiffres relatifs aux paramètres, à la mémoire et aux benchmarks sont recoupés avec au moins deux sources primaires.
Aperçu des vérifications (double source)
- Familles de modèles officielles et nombre de paramètres : tiny/base/small/medium/large ainsi que turbo sont documentés par OpenAI. README Whisper d'OpenAI · Fiche du modèle Whisper
- Contexte de l'espace disque GGML/GGUF et de la mémoire à l'exécution : les empreintes de déploiement local proviennent de la documentation de conversion/exécution de whisper.cpp. whisper.cpp · Notes sur la mémoire de whisper.cpp
- Mise en garde sur les benchmarks : le WER varie fortement selon le jeu de données et la langue ; les chiffres LibriSpeech ne constituent pas un score de qualité universel. Article Whisper · Fiche du modèle large-v2
- Positionnement du modèle turbo : turbo est une variante axée sur la vitesse, avec des compromis sur la précision documentés dans les notes de version et les fiches de modèles. Fiche du modèle turbo · Discussion sur la sortie de turbo
- Contexte d'utilisation d'OpenWhispr : OpenWhispr donne accès à plusieurs tailles de Whisper afin que les utilisateurs puissent ajuster le rapport vitesse/précision en local. OpenWhispr · Backend whisper.cpp
Whisper Tailles des modèles : vitesse vs précision
La taille des bulles reflète le nombre relatif de paramètres
Taux d'erreur sur les mots : Whisper par rapport aux concurrents open source
LibriSpeech test-clean (discours lu en anglais) – plus bas est mieux
Sources : cartes modèles Hugging Face, cartes modèles NVIDIA, Open ASR Leaderboard (Feb 2026). Lecture vocale en anglais uniquement : la précision réelle varie en fonction de la qualité audio, de l'accent et du domaine. Les API commerciaux sont omis car ils ne publient pas de références LibriSpeech.
La comparaison complète des modèles
Ce tableau couvre tous les modèles Whisper officiels. La « vitesse relative » est exprimée par rapport à large (référence 1x). Les chiffres de VRAM concernent l'inférence PyTorch sur GPU. Les colonnes GGML indiquent la taille des fichiers et l'utilisation de la RAM pour whisper.cpp, ce qu'utilisent la plupart des applications de bureau.
| Modèle | Paramètres | Anglais uniquement | VRAM (GPU) | Disque GGML | RAM (whisper.cpp) | Vitesse | WER anglais | WER multilingue |
|---|---|---|---|---|---|---|---|---|
| tiny | 39 M | tiny.en | ~1 GB | 75 MiB | ~273 MB | ~10x | ~7.6% | ~12% |
| base | 74 M | base.en | ~1 GB | 142 MiB | ~388 MB | ~7x | ~5.0% | ~10% |
| small | 244 M | small.en | ~2 GB | 466 MiB | ~852 MB | ~4x | ~3.4% | ~7% |
| medium | 769 M | medium.en | ~5 GB | 1.5 GiB | ~2.1 GB | ~2x | ~2.9% | ~5% |
| large-v2 | 1,550 M | N/D | ~10 GB | 2.9 GiB | ~3.9 GB | 1x | ~2.7% | ~4% |
| large-v3 | 1,550 M | N/D | ~10 GB | 2.9 GiB | ~3.9 GB | 1x | ~2.4% | ~3.5% |
| turbo | 809 M | N/D | ~6 GB | 1.6 GiB | ~2.3 GB | ~8x | ~2.5% | ~3.7% |
Notes : Les chiffres de WER (taux d'erreur sur les mots) sont des moyennes approximatives issues de l'article Whisper, des fiches de modèles HuggingFace (jeux de test LibriSpeech pour l'anglais) et des benchmarks publiés par OpenAI. Le WER exact varie considérablement selon le jeu de données, la langue, la qualité audio et la méthodologie d'évaluation. Plus bas est meilleur. La vitesse est exprimée par rapport à large (1x = le plus lent).
Tiny (39M de paramètres)
Le modèle tiny est la plus petite et la plus rapide des variantes de Whisper. Avec seulement 39 millions de paramètres et une taille de fichier GGML de 75 Mo, il tourne confortablement sur presque n'importe quel matériel — y compris le Raspberry Pi, les ordinateurs portables anciens et les appareils mobiles d'entrée de gamme. Il transcrit à environ 10x la vitesse réelle par rapport au modèle large, ce qui en fait le meilleur choix lorsque la latence compte plus qu'une précision parfaite.
- GGML : 75 Mio sur disque
- RAM : ~273 Mo à l'exécution
- VRAM : ~1 Go (mode GPU)
- ~10x plus rapide que large
- Quasi instantané sur Apple Silicon
- Temps réel sur la plupart des processeurs
- WER anglais : ~7,6 %
- WER multilingue : ~12 %
- En difficulté avec les accents et le bruit
Sur la variante tiny.en (anglais uniquement), le WER sur LibriSpeech test-clean est d'environ 5,6 %, montant à ~14,9 % sur test-other (audio bruité ou avec accent). Le modèle tiny multilingue est légèrement moins performant en anglais mais prend en charge les 99 langues de Whisper.
Tiny est idéal pour les notes rapides, la dictée à faible enjeu, les prototypes de sous-titrage en direct, ainsi que les appareils embarqués ou en périphérie où la puissance de calcul est limitée. C'est le modèle de départ par défaut de nombreux outils basés sur whisper.cpp, car il se télécharge en quelques secondes et s'exécute instantanément.
Base (74M de paramètres)
Le modèle base double le nombre de paramètres de tiny (74M contre 39M) tout en restant très léger. Avec 142 Mio (GGML) et ~388 Mo de RAM à l'exécution, il tient encore confortablement sur pratiquement n'importe quel appareil moderne. Le gain de précision par rapport à tiny est notable — en particulier sur l'audio bruité et la parole accentuée.
- GGML : 142 Mio sur disque
- RAM : ~388 Mo à l'exécution
- VRAM : ~1 Go (mode GPU)
- ~7x plus rapide que large
- Toujours très rapide sur CPU
- Moins d'une seconde sur Apple Silicon
- WER anglais : ~5,0 %
- WER multilingue : ~10 %
- Meilleur que tiny sur l'audio bruité
La variante base.en atteint environ 4,3 % de WER sur LibriSpeech test-clean et ~12,8 % sur test-other. Il s'agit d'une amélioration significative par rapport à tiny.en (respectivement 5,6 % et 14,9 %), en particulier sur les audios difficiles.
Base est un bon choix pour les appareils peu puissants où tiny n'est pas tout à fait assez précis. Il est aussi prisé pour les pipelines de transcription en temps réel où l'on recherche un équilibre entre vitesse et qualité sans dépasser 500 Mo de RAM.
Small (244M de paramètres)
Small est le moment où Whisper commence à se montrer véritablement précis. Avec 244M de paramètres, il représente un bond de 3,3x par rapport à base et offre une amélioration notable de la précision — en particulier pour les langues autres que l'anglais et les enregistrements bruités. Le fichier GGML pèse 466 Mio, et l'utilisation de la RAM à l'exécution est d'environ 852 Mo. Il s'exécute à environ 4x la vitesse de large.
- GGML : 466 Mio sur disque
- RAM : ~852 Mo à l'exécution
- VRAM : ~2 Go (mode GPU)
- ~4x plus rapide que large
- Rapide sur les ordinateurs portables modernes
- Temps réel sur Apple Silicon
- WER anglais : ~3,4 %
- WER multilingue : ~7 %
- Gère bien les accents
La variante small.en atteint environ 3,0 % de WER sur LibriSpeech test-clean — un résultat remarquable pour un modèle tenant dans moins de 500 Mo. Pour de nombreux usages en anglais uniquement, small.en offre une précision proche de medium pour une fraction du coût en ressources.
Small est souvent recommandé comme modèle par défaut pour la plupart des utilisateurs. Il fonctionne bien sur n'importe quel ordinateur portable moderne (y compris le MacBook Air M1 avec 8 Go de RAM), offre une bonne précision dans toutes les langues et transcrit assez vite pour les flux de dictée en temps réel.
Notre recommandation : Si vous ne savez pas par quel modèle commencer, commencez par small. C'est le meilleur équilibre entre vitesse, précision et utilisation des ressources pour la majorité des matériels et des cas d'usage.
Medium (769M de paramètres)
Medium est le moment où les rendements décroissants commencent à se faire sentir — mais les gains de précision par rapport à small restent significatifs, en particulier pour la transcription multilingue, le vocabulaire technique et les conditions audio difficiles. Avec 769M de paramètres, il nécessite 1,5 Gio d'espace disque (GGML) et environ 2,1 Go de RAM à l'exécution.
- GGML : 1,5 Gio sur disque
- RAM : ~2,1 Go à l'exécution
- VRAM : ~5 Go (mode GPU)
- ~2x plus rapide que large
- Confortable sur les machines de 8 Go et plus
- Nécessite un matériel correct
- WER anglais : ~2,9 %
- WER multilingue : ~5 %
- Solide sur le contenu technique
Le modèle medium.en atteint environ 3,0 % de WER sur LibriSpeech test-clean et environ 7,5 % sur test-other. Cependant, sur des benchmarks plus larges — notamment ceux comportant des accents variés, du bruit de fond et un vocabulaire propre à un domaine — medium surpasse systématiquement small.
Medium est un excellent choix pour les flux de transcription professionnels où la précision est importante mais où vous n'avez pas le matériel (ou la patience) pour large. Il fonctionne bien sur les machines disposant de 8 Go de RAM ou plus et profite fortement de l'accélération GPU.
Large (1 550M de paramètres)
Le modèle large est la variante la plus précise de Whisper, avec 1,55 milliard de paramètres. Il existe trois versions : large-v1 (la version d'origine), large-v2 (entraîné sur 2,5x plus d'époques avec une régularisation supplémentaire) et large-v3 (entraîné sur davantage de données avec 128 bandes de fréquence Mel au lieu de 80). Large-v3 est la version actuellement recommandée pour une précision maximale.
- GGML : 2,9 Gio sur disque
- RAM : ~3,9 Go à l'exécution
- VRAM : ~10 Go (mode GPU)
- 1x (référence — le plus lent)
- GPU fortement recommandé
- CPU : peut être plus lent que le temps réel
- WER anglais : ~2,4 % (v3)
- WER multilingue : ~3,5 % (v3)
- Le meilleur dans toutes les langues
large-v2 vs large-v3
large-v2
- Entraîné sur 2,5x plus d'époques que large-v1
- Régularisation supplémentaire pour une meilleure généralisation
- WER LibriSpeech test-clean : ~3,0 %
- Plus stable sur certains types d'audio
large-v3
- 128 bandes Mel (contre 80) — résolution fréquentielle plus fine
- Entraîné sur 1M d'heures étiquetées + 4M d'heures pseudo-étiquetées
- Réduction des erreurs de 10 à 20 % par rapport à large-v2, toutes langues confondues
- Prise en charge ajoutée de la langue cantonaise
Quel modèle large utiliser : Pour les nouveaux projets, utilisez large-v3. Il est strictement meilleur que large-v2 en moyenne, toutes langues confondues. Cependant, certains utilisateurs ont signalé que large-v2 produit moins d'hallucinations (génération de texte absent de l'audio) dans certains cas particuliers, avec des segments audio très silencieux ou muets. Si vous rencontrez des problèmes d'hallucination avec large-v3, essayez large-v2 comme solution de repli.
Turbo (809M de paramètres)
Le modèle turbo est une version distillée de large-v3 qui réduit drastiquement le temps d'inférence tout en conservant l'essentiel de la précision. OpenAI y est parvenu en élaguant le décodeur, passant de 32 à seulement 4 couches — réduisant le nombre de paramètres de 1 550M à 809M. L'encodeur (qui fait le gros du travail) reste identique à celui de large-v3.
- GGML : ~1,6 Gio sur disque
- RAM : ~2,3 Go à l'exécution
- VRAM : ~6 Go (mode GPU)
- ~8x plus rapide que large
- Précision proche de large, vitesse proche de tiny
- Excellent sur GPU avec torch.compile
- WER anglais : ~2,5 %
- WER multilingue : ~3,7 %
- Légère perte de qualité face à large-v3
Turbo est le meilleur choix lorsque vous recherchez une précision proche de large-v3 mais que vous ne pouvez pas vous permettre la latence du modèle large complet. Sur GPU avec des optimisations comme torch.compile, turbo peut atteindre une amélioration de vitesse allant jusqu'à 4,5x par rapport à l'inférence standard, ce qui le rend extrêmement rapide.
Limitation importante : Le modèle turbo n'a pas été entraîné pour les tâches de traduction. Si vous devez traduire de la parole d'une langue vers l'anglais, utilisez plutôt medium ou large-v3.
Modèles anglais uniquement vs multilingues
Pour les tailles tiny, base, small et medium, Whisper propose deux variantes : un modèle multilingue et un modèle anglais uniquement ( .en ). Les modèles large et turbo sont uniquement multilingues — il n'existe pas de versions anglais uniquement.
Quand utiliser .en (anglais uniquement)
- Vous transcrivez uniquement de l'audio en anglais
- Meilleure précision en anglais pour les tailles tiny/base
- Légèrement plus rapide — pas de surcoût lié à la détection de langue
- Même taille de fichier que l'équivalent multilingue
Quand utiliser le multilingue
- Vous transcrivez de l'audio dans d'autres langues que l'anglais
- Votre audio mélange plusieurs langues
- Vous avez besoin de la traduction de la parole (vers l'anglais)
- Obligatoire avec large ou turbo (aucune variante .en n'existe)
L'écart de performance entre les modèles .en et multilingues est le plus marqué sur les petites tailles. Pour tiny et base, les variantes .en sont nettement meilleures en anglais. Une fois arrivé à small et medium, la différence se réduit considérablement. Au niveau large, il n'existe qu'un modèle multilingue — et il se comporte excellemment en anglais malgré tout.
Règle générale : Si vous utilisez exclusivement l'anglais et que vous choisissez tiny ou base, optez pour la variante .en. Pour small ou plus grand, la version multilingue fonctionne très bien en anglais et vous offre une flexibilité pour les autres langues.
Configuration matérielle requise : qui fait tourner quoi
Le matériel dont vous avez besoin dépend fortement de la taille du modèle et du fait que vous utilisiez whisper.cpp (CPU/Metal/CUDA) ou l'implémentation PyTorch (axée GPU). Voici à quoi s'attendre sur les classes de matériel courantes.
MacBook Air M1 (8 Go de RAM)
- tiny/base : Instantané. Plus rapide que le temps réel.
- small : Rapide. Temps réel ou mieux avec Metal.
- medium : Utilisable. Peut être légèrement plus lent que le temps réel sur CPU. Metal aide considérablement.
- large : Possible mais juste en RAM. Attendez-vous à plus lent que le temps réel.
- turbo : Bon compromis. Quasi temps réel avec l'accélération Metal.
MacBook Pro M2/M3 (16 à 36 Go de RAM)
- tiny/base/small : Instantané. Tous bien dans les limites du matériel.
- medium : Rapide. Confortable avec Metal.
- large : Bon. Temps réel ou presque avec Metal.
- turbo : Excellent. Transcription rapide en temps réel.
Ordinateur portable Windows/Linux milieu de gamme (8 Go de RAM, GPU intégré)
- tiny/base : Rapide. CPU seul suffit amplement.
- small : Bon. Confortable sur la plupart des processeurs modernes.
- medium : Faisable. Peut être 2 à 3x plus lent que le temps réel sur CPU.
- large : Difficile. CPU seul sera lent.
- turbo : Faisable. Profite de Vulkan s'il est disponible.
PC de bureau avec GPU NVIDIA (RTX 3060+, 8 Go+ de VRAM)
- Tous les modèles : Rapide. Le GPU gère tout confortablement.
- large : Nécessite 10 Go de VRAM (RTX 3060 12 Go ou mieux).
- turbo : L'option la plus rapide avec CUDA. Nettement plus rapide que large.
- Utilisez le backend CUDA de whisper.cpp pour de meilleures performances.
Backends d'accélération de whisper.cpp
whisper.cpp — le portage C/C++ qu'utilisent la plupart des applications de bureau — prend en charge plusieurs backends d'accélération matérielle qui peuvent considérablement améliorer les performances :
Metal (Apple Silicon)
Inférence GPU complète sur les Mac M1/M2/M3/M4. Exécute l'intégralité du modèle sur le GPU sans aucune copie mémoire. C'est le backend le plus rapide pour les utilisateurs macOS et celui qu'OpenWhispr utilise sur Mac.
Core ML (Apple)
Utilise le moteur neuronal d'Apple pour l'inférence. Peut être plus rapide que Metal pour certaines tailles de modèles sur les puces récentes, et plus économe en énergie. Nécessite de convertir au préalable les modèles au format Core ML.
CUDA (NVIDIA)
Accélération GPU pour les cartes NVIDIA. Le backend le plus rapide pour les utilisateurs disposant d'un GPU NVIDIA dédié. Nécessite la boîte à outils CUDA. Meilleur choix pour les modèles large et turbo sur PC de bureau.
Vulkan (GPU multi-fabricants)
Fonctionne avec les GPU Intel, AMD et NVIDIA. Bonne solution de repli pour les systèmes non NVIDIA. Disponible sous Linux et Windows. Les performances varient selon le fabricant du GPU et le pilote.
Vitesse de transcription approximative
Facteur temps réel (RTF) pour un extrait audio de 60 secondes. Un RTF < 1,0 signifie plus rapide que le temps réel. Ce sont des estimations approximatives — les performances réelles dépendent du contenu audio, de la quantification du modèle et de la charge système.
| Modèle | MacBook Air M1 | MacBook M3 Pro | Intel i7 (CPU) | RTX 3060 (CUDA) |
|---|---|---|---|---|
| tiny | ~0.05x | ~0.03x | ~0.1x | ~0.02x |
| base | ~0.08x | ~0.05x | ~0.15x | ~0.04x |
| small | ~0.2x | ~0.12x | ~0.4x | ~0.08x |
| medium | ~0.6x | ~0.3x | ~1.2x | ~0.15x |
| large-v3 | ~1.5x | ~0.7x | ~3.0x | ~0.3x |
| turbo | ~0.3x | ~0.15x | ~0.6x | ~0.08x |
Comment lire le tableau : 0,1x signifie que transcrire 60 secondes d'audio prend environ 6 secondes. 1,0x = temps réel. Les valeurs supérieures à 1,0x signifient plus lent que le temps réel. Tous les chiffres utilisent whisper.cpp avec les paramètres par défaut et le backend Metal (Mac) ou CUDA (NVIDIA) le cas échéant.
Quel modèle devriez-vous utiliser ?
Voici des recommandations concrètes basées sur des scénarios courants. En cas de doute, commencez par small puis montez ou descendez selon votre expérience.
« Je veux le plus rapide possible »
Utilisez tiny ou tiny.en . Transcrit en quelques millisecondes sur du matériel moderne. La précision est approximative mais utilisable pour des notes rapides et de la dictée à faible enjeu.
tiny / tiny.en« Je veux une bonne précision sur un ordinateur portable »
Utilisez small . Le meilleur équilibre entre vitesse et précision pour les ordinateurs portables modernes. Si votre machine dispose de 16 Go de RAM ou plus, medium est également un excellent choix.
small ou medium« Je veux la meilleure précision »
Utilisez large-v3 . C'est le modèle Whisper le plus précis dans l'ensemble. Si la vitesse compte aussi, turbo vous offre 95 % de la précision à 8x la vitesse.
large-v3 ou turbo« Je n'utilise que l'anglais »
Utilisez la .en variante de la taille choisie pour la meilleure précision en anglais. Pour tiny et base, les modèles .en sont nettement meilleurs. Pour small et au-delà, la différence est minime.
small.en ou medium.en« J'utilise plusieurs langues »
Utilisez la variante multilingue. small ou medium pour des performances équilibrées. large-v3 pour la meilleure précision multilingue.
small, medium ou large-v3« J'ai un matériel très limité »
Utilisez tiny ou base . Les deux fonctionnent avec 1 Go de RAM et tournent même sur Raspberry Pi et autres ordinateurs monocartes. Base offre un gain de précision notable par rapport à tiny pour un coût supplémentaire minime.
tiny ou baseComment OpenWhispr gère la sélection des modèles
OpenWhispr est une application de dictée de bureau open source qui utilise whisper.cpp en interne. Elle vous permet de télécharger et de basculer entre n'importe quel modèle Whisper directement depuis les paramètres — sans ligne de commande. Les modèles sont téléchargés une seule fois et stockés localement. Vous pouvez changer de modèle à tout moment pour équilibrer vitesse et précision selon votre matériel.
Téléchargez n'importe quel modèle
Choisissez de tiny à large-v3 dans les paramètres. OpenWhispr télécharge automatiquement la version GGML.
Basculez instantanément
Changez de modèle à tout moment. Aucun redémarrage nécessaire. Testez différentes tailles pour trouver ce qui fonctionne le mieux sur votre matériel.
Optimisé pour votre matériel
Utilise Metal sur Apple Silicon, CUDA sur NVIDIA et une inférence CPU optimisée ailleurs. Tout en local, tout en privé.
Notre suggestion : Commencez par small . Si vous le trouvez lent, descendez vers base ou tiny. Si vous voulez une meilleure précision et que votre matériel le permet, montez vers medium ou large-v3. OpenWhispr facilite l'expérimentation.
Sources
- Radford et al. « Robust Speech Recognition via Large-Scale Weak Supervision » (2022) — L'article original sur Whisper, avec l'ensemble des résultats de benchmarks.
- Dépôt GitHub Whisper d'OpenAI — Tableau officiel des modèles, nombre de paramètres, besoins en VRAM et chiffres de vitesse relative.
- Fiche du modèle Whisper d'OpenAI — Composition officielle des données d'entraînement et mises en garde sur l'évaluation.
- Dépôt GitHub whisper.cpp — Tailles des modèles GGML, utilisation de la RAM et détails sur l'accélération matérielle.
- Fiche du modèle Whisper large-v2 (HuggingFace) — Contexte du benchmark LibriSpeech utilisé dans de nombreuses comparaisons de WER.
- Fiche du modèle Whisper large-v3 (HuggingFace) — Détails d'entraînement, changements d'architecture par rapport à large-v2 et améliorations multilingues.
- Fiche du modèle Whisper large-v3-turbo (HuggingFace) — Détails de l'architecture turbo, spécificités de l'élagage du décodeur et compromis de performance.
- Annonce de Whisper Turbo par OpenAI (discussion GitHub #2363) — Notes de version officielles de turbo et comparaisons de performance entre langues.
- OpenWhispr — Contexte pratique de déploiement local pour choisir la taille des modèles.
Essayez différents modèles Whisper dans OpenWhispr
Dictée open source, axée sur le local. Téléchargez n'importe quel modèle Whisper, basculez entre les tailles en un clic et trouvez l'équilibre parfait pour votre matériel.
Aucun compte requis · Fonctionne hors ligne · Open source pour toujours