Tamanhos dos modelos Whisper explicados: Tiny vs Base vs Small vs Medium vs Large
Todos os modelos Whisper, comparados. Parâmetros, velocidade, precisão e qual deles você realmente deveria usar.
OpenWhispr
Engenharia
Índice
O Whisper da OpenAI vem em 9 variantes de modelo distribuídas em 5 categorias de tamanho: tiny (39M de parâmetros), base (74M), small (244M), medium (769M) e large (1,55B). Cada tamanho tem uma versão multilíngue e uma versão somente em inglês (exceto large e turbo, que são apenas multilíngues). Há também um modelo turbo (809M) — uma versão destilada do large-v3 que é quase tão preciso, mas drasticamente mais rápido. Modelos maiores são mais precisos, porém mais lentos e exigem mais memória.
No formato quantizado (GGML) do whisper.cpp usado pela maioria dos apps de transcrição local, os arquivos de modelo variam de 75 MB (tiny) a 2,9 GB (large). O uso de memória em tempo de execução vai de cerca de 273 MB para o tiny a 3,9 GB para o large. O modelo certo depende do seu hardware, do seu idioma e de quanta precisão você precisa.
Última atualização: 17 de fevereiro de 2026. As afirmações sobre parâmetros, memória e benchmarks foram verificadas em pelo menos duas fontes primárias.
Resumo da verificação de fatos (fontes duplas)
- Famílias oficiais de modelos e contagens de parâmetros: tiny/base/small/medium/large mais o turbo estão documentados pela OpenAI. README do Whisper da OpenAI · Cartão do modelo Whisper
- Contexto de disco e memória em tempo de execução GGML/GGUF: as pegadas de implantação local vêm da documentação de conversão/execução do whisper.cpp. whisper.cpp · Notas de memória do whisper.cpp
- Ressalva sobre benchmarks: a WER varia bastante por conjunto de dados e idioma; os números do LibriSpeech não são uma nota de qualidade universal. Artigo do Whisper · Cartão do modelo large-v2
- Posicionamento do modelo turbo: o turbo é uma variante focada em velocidade com trade-offs de precisão documentados nas notas de versão/cartões de modelo. Cartão do modelo turbo · Discussão de lançamento do turbo
- Contexto de uso no OpenWhispr: o OpenWhispr disponibiliza vários tamanhos do Whisper para que os usuários ajustem velocidade/precisão localmente. OpenWhispr · Backend whisper.cpp
Whisper Tamanhos de modelo: velocidade versus precisão
O tamanho da bolha reflete a contagem relativa de parâmetros
Taxa de erro de palavras: Whisper vs concorrentes de código aberto
LibriSpeech test-clean (leitura de fala em inglês) - quanto menor, melhor
Fontes: cartões modelo Hugging Face, cartões modelo NVIDIA, Open ASR Leaderboard (Feb 2026). Apenas fala de leitura limpa em inglês – a precisão do mundo real varia de acordo com a qualidade do áudio, sotaque e domínio. APIs comerciais omitidos porque não publicam benchmarks LibriSpeech.
A comparação completa de modelos
Esta tabela cobre todos os modelos Whisper oficiais. A "velocidade relativa" é em relação ao large (referência 1x). Os números de VRAM são para inferência PyTorch em GPU. As colunas GGML mostram os tamanhos de arquivo e o uso de RAM do whisper.cpp, que é o que a maioria dos apps de desktop usa.
| Modelo | Parâmetros | Somente inglês | VRAM (GPU) | Disco GGML | RAM (whisper.cpp) | Velocidade | WER em inglês | WER multilíngue |
|---|---|---|---|---|---|---|---|---|
| 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% |
Observações: Os números de WER (taxa de erro por palavra) são médias aproximadas do artigo do Whisper, dos cartões de modelo do HuggingFace (conjuntos de teste do LibriSpeech para inglês) e dos benchmarks publicados pela OpenAI. A WER exata varia significativamente conforme o conjunto de dados, o idioma, a qualidade do áudio e a metodologia de avaliação. Quanto menor, melhor. A velocidade é em relação ao large (1x = mais lento).
Tiny (39M de parâmetros)
O modelo tiny é a variante menor e mais rápida do Whisper. Com apenas 39 milhões de parâmetros e um arquivo GGML de 75 MB, ele roda confortavelmente em praticamente qualquer hardware — incluindo Raspberry Pi, notebooks antigos e dispositivos móveis de baixo custo. Ele transcreve a cerca de 10x a velocidade em tempo real em relação ao modelo large, tornando-se a melhor escolha quando a latência importa mais do que a precisão perfeita.
- GGML: 75 MiB em disco
- RAM: ~273 MB em execução
- VRAM: ~1 GB (modo GPU)
- ~10x mais rápido que o large
- Quase instantâneo no Apple Silicon
- Tempo real na maioria das CPUs
- WER em inglês: ~7,6%
- WER multilíngue: ~12%
- Tem dificuldade com sotaques/ruído
Na variante tiny.en (somente inglês), a WER no test-clean do LibriSpeech fica em torno de 5,6%, subindo para ~14,9% no test-other (áudio com ruído/sotaque). O modelo tiny multilíngue tem desempenho ligeiramente pior em inglês, mas suporta todos os 99 idiomas do Whisper.
O tiny é ideal para anotações rápidas, ditado de baixo risco, protótipos de legendagem ao vivo e dispositivos embarcados ou de borda onde a capacidade de processamento é limitada. É o modelo inicial padrão de muitas ferramentas baseadas em whisper.cpp, porque baixa em segundos e roda instantaneamente.
Base (74M de parâmetros)
O modelo base dobra a contagem de parâmetros do tiny (74M vs 39M) mantendo-se bem leve. Com 142 MiB (GGML) e ~388 MB de RAM em execução, ele ainda cabe confortavelmente em praticamente qualquer dispositivo moderno. A melhora de precisão em relação ao tiny é perceptível — especialmente em áudio com ruído e fala com sotaque.
- GGML: 142 MiB em disco
- RAM: ~388 MB em execução
- VRAM: ~1 GB (modo GPU)
- ~7x mais rápido que o large
- Ainda muito rápido na CPU
- Menos de um segundo no Apple Silicon
- WER em inglês: ~5,0%
- WER multilíngue: ~10%
- Melhor que o tiny em áudio com ruído
A variante base.en atinge cerca de 4,3% de WER no test-clean do LibriSpeech e ~12,8% no test-other. Isso é uma melhora significativa em relação ao tiny.en (5,6% e 14,9%, respectivamente), em especial em áudios desafiadores.
O base é uma boa escolha para dispositivos de baixa potência em que o tiny não é preciso o suficiente. Também é popular em pipelines de transcrição em tempo real onde você quer um equilíbrio entre velocidade e qualidade sem ultrapassar 500 MB de RAM.
Small (244M de parâmetros)
O small é onde o Whisper começa a parecer genuinamente preciso. Com 244M de parâmetros, ele representa um salto de 3,3x em relação ao base e entrega uma melhora significativa de precisão — especialmente para idiomas que não o inglês e gravações com ruído. O arquivo GGML tem 466 MiB, e o uso de RAM em execução fica em torno de 852 MB. Ele roda a cerca de 4x a velocidade do large.
- GGML: 466 MiB em disco
- RAM: ~852 MB em execução
- VRAM: ~2 GB (modo GPU)
- ~4x mais rápido que o large
- Rápido em notebooks modernos
- Tempo real no Apple Silicon
- WER em inglês: ~3,4%
- WER multilíngue: ~7%
- Lida bem com sotaques
A variante small.en chega a cerca de 3,0% de WER no test-clean do LibriSpeech — um resultado notável para um modelo que cabe em menos de 500 MB. Para muitos casos de uso somente em inglês, o small.en oferece uma precisão próxima à do medium por uma fração do custo de recursos.
O small costuma ser recomendado como modelo padrão para a maioria dos usuários. Ele roda bem em qualquer notebook moderno (incluindo o MacBook Air M1 com 8 GB de RAM), entrega boa precisão em vários idiomas e transcreve rápido o suficiente para fluxos de ditado em tempo real.
Nossa recomendação: Se você não tem certeza de qual modelo começar, comece pelo small. Ele oferece o melhor equilíbrio entre velocidade, precisão e uso de recursos para a maioria dos hardwares e casos de uso.
Medium (769M de parâmetros)
O medium é onde os retornos decrescentes começam a aparecer — mas os ganhos de precisão em relação ao small ainda são relevantes, especialmente para transcrição multilíngue, vocabulário técnico e condições de áudio desafiadoras. Com 769M de parâmetros, ele exige 1,5 GiB de espaço em disco (GGML) e cerca de 2,1 GB de RAM em execução.
- GGML: 1,5 GiB em disco
- RAM: ~2,1 GB em execução
- VRAM: ~5 GB (modo GPU)
- ~2x mais rápido que o large
- Tranquilo em máquinas de 8 GB+
- Precisa de hardware decente
- WER em inglês: ~2,9%
- WER multilíngue: ~5%
- Forte em conteúdo técnico
O modelo medium.en atinge cerca de 3,0% de WER no test-clean do LibriSpeech e aproximadamente 7,5% no test-other. No entanto, em benchmarks mais amplos — principalmente os com sotaques diversos, ruído de fundo e vocabulário específico de domínio — o medium supera consistentemente o small.
O medium é uma escolha forte para fluxos de transcrição profissionais em que a precisão importa, mas você não tem o hardware (ou a paciência) para o large. Ele roda bem em máquinas com 8 GB ou mais de RAM e se beneficia bastante da aceleração por GPU.
Large (1.550M de parâmetros)
O modelo large é a variante mais precisa do Whisper, com 1,55 bilhão de parâmetros. Existem três versões: large-v1 (o lançamento original), large-v2 (treinado por 2,5x mais épocas, com regularização adicional) e large-v3 (treinado com mais dados e 128 faixas de frequência Mel em vez de 80). O large-v3 é a versão recomendada atualmente para máxima precisão.
- GGML: 2,9 GiB em disco
- RAM: ~3,9 GB em execução
- VRAM: ~10 GB (modo GPU)
- 1x (referência — mais lento)
- GPU fortemente recomendada
- CPU: pode ser mais lento que tempo real
- WER em inglês: ~2,4% (v3)
- WER multilíngue: ~3,5% (v3)
- Melhor em todos os idiomas
large-v2 vs large-v3
large-v2
- Treinado por 2,5x mais épocas que o large-v1
- Regularização adicional para melhor generalização
- WER no test-clean do LibriSpeech: ~3,0%
- Mais estável em alguns tipos de áudio
large-v3
- 128 faixas Mel (vs 80) — resolução de frequência mais fina
- Treinado com 1M de horas rotuladas + 4M de horas pseudo-rotuladas
- Redução de erro de 10-20% sobre o large-v2 entre idiomas
- Adicionado suporte ao idioma cantonês
Qual modelo large usar: Para projetos novos, use o large-v3. Ele é estritamente melhor que o large-v2 na média entre idiomas. No entanto, alguns usuários relataram que o large-v2 produz menos alucinações (gerar texto que não está presente no áudio) em casos extremos específicos com trechos de áudio muito baixos ou em silêncio. Se você encontrar problemas de alucinação com o large-v3, tente o large-v2 como alternativa.
Turbo (809M de parâmetros)
O modelo turbo é uma versão destilada do large-v3 que reduz drasticamente o tempo de inferência mantendo a maior parte da precisão. A OpenAI conseguiu isso podando o decodificador de 32 camadas para apenas 4 camadas — cortando a contagem de parâmetros de 1.550M para 809M. O codificador (que faz o trabalho pesado) permanece idêntico ao do large-v3.
- GGML: ~1,6 GiB em disco
- RAM: ~2,3 GB em execução
- VRAM: ~6 GB (modo GPU)
- ~8x mais rápido que o large
- Precisão perto do large, velocidade perto do tiny
- Ótimo na GPU com torch.compile
- WER em inglês: ~2,5%
- WER multilíngue: ~3,7%
- Pequena perda de qualidade vs large-v3
O turbo é a melhor escolha quando você quer precisão próxima à do large-v3, mas não pode arcar com a latência do modelo large completo. Na GPU, com otimizações como o torch.compile, o turbo pode atingir uma melhoria de velocidade de até 4,5x em relação à inferência padrão, tornando-o extremamente rápido.
Limitação importante: O modelo turbo não foi treinado para tarefas de tradução. Se você precisa traduzir fala de um idioma para o inglês, use o medium ou o large-v3.
Modelos somente em inglês vs multilíngues
Para os tamanhos tiny, base, small e medium, o Whisper oferece duas variantes: um modelo multilíngue e um modelo somente em inglês ( .en ). Os modelos large e turbo são apenas multilíngues — não há versões somente em inglês.
Quando usar .en (somente inglês)
- Você só transcreve áudio em inglês
- Melhor precisão em inglês nos tamanhos tiny/base
- Um pouco mais rápido — sem o custo de detecção de idioma
- Mesmo tamanho de arquivo que o equivalente multilíngue
Quando usar o multilíngue
- Você transcreve áudio que não é em inglês
- Seu áudio contém idiomas misturados
- Você precisa de tradução de fala (para o inglês)
- Obrigatório se usar large ou turbo (não existe variante .en)
A diferença de desempenho entre os modelos .en e multilíngues é mais significativa nos tamanhos menores. Para o tiny e o base, as variantes .en são nitidamente melhores em inglês. Quando você chega ao small e ao medium, a diferença diminui consideravelmente. No nível large, há apenas um modelo multilíngue — e ele se sai excelente em inglês de qualquer forma.
Regra geral: Se você usa exclusivamente o inglês e está escolhendo o tiny ou o base, prefira a variante .en. Para o small ou maiores, a versão multilíngue funciona muito bem para o inglês e ainda dá flexibilidade para outros idiomas.
Requisitos de hardware: o que roda onde
O hardware de que você precisa depende muito do tamanho do modelo e de você estar usando o whisper.cpp (CPU/Metal/CUDA) ou a implementação em PyTorch (focada em GPU). Veja o que esperar nas classes de hardware mais comuns.
MacBook Air M1 (8 GB de RAM)
- tiny/base: Instantâneo. Mais rápido que tempo real.
- small: Rápido. Tempo real ou melhor com Metal.
- medium: Utilizável. Pode ser um pouco mais lento que tempo real na CPU. O Metal ajuda bastante.
- large: Possível, mas apertado de RAM. Espere algo mais lento que tempo real.
- turbo: Boa opção. Quase tempo real com a aceleração do Metal.
MacBook Pro M2/M3 (16-36 GB de RAM)
- tiny/base/small: Instantâneo. Tudo bem dentro dos limites do hardware.
- medium: Rápido. Tranquilo com o Metal.
- large: Bom. Tempo real ou perto disso com o Metal.
- turbo: Excelente. Transcrição em tempo real rápida.
Notebook Windows/Linux intermediário (8 GB de RAM, GPU integrada)
- tiny/base: Rápido. Apenas na CPU já é suficiente.
- small: Bom. Tranquilo na maioria das CPUs modernas.
- medium: Viável. Pode ficar 2-3x mais lento que tempo real na CPU.
- large: Desafiador. Apenas na CPU vai ser lento.
- turbo: Viável. Se beneficia do Vulkan, se disponível.
Desktop com GPU NVIDIA (RTX 3060+, 8 GB+ de VRAM)
- Todos os modelos: Rápido. A GPU dá conta de tudo com folga.
- large: Precisa de 10 GB de VRAM (RTX 3060 12 GB ou melhor).
- turbo: Opção mais rápida com CUDA. Significativamente mais rápido que o large.
- Use o backend CUDA no whisper.cpp para melhor desempenho.
Backends de aceleração do whisper.cpp
O whisper.cpp — o port em C/C++ que a maioria dos apps de desktop usa — suporta vários backends de aceleração de hardware que podem melhorar drasticamente o desempenho:
Metal (Apple Silicon)
Inferência completa na GPU em Macs M1/M2/M3/M4. Roda o modelo inteiro na GPU sem cópias de memória. Este é o backend mais rápido para usuários de macOS e é o que o OpenWhispr usa no Mac.
Core ML (Apple)
Usa o neural engine da Apple para a inferência. Pode ser mais rápido que o Metal em alguns tamanhos de modelo em chips mais novos, além de ser mais eficiente em energia. Requer converter os modelos para o formato Core ML primeiro.
CUDA (NVIDIA)
Aceleração por GPU para placas NVIDIA. O backend mais rápido para usuários com GPUs NVIDIA dedicadas. Requer o CUDA toolkit. Melhor escolha para os modelos large e turbo no desktop.
Vulkan (GPU multifabricante)
Funciona com GPUs Intel, AMD e NVIDIA. Boa alternativa para sistemas não NVIDIA. Disponível no Linux e no Windows. O desempenho varia conforme o fabricante da GPU e o driver.
Velocidade de transcrição aproximada
Fator de tempo real (RTF) para um clipe de áudio de 60 segundos. RTF < 1,0 significa mais rápido que tempo real. Estas são estimativas aproximadas — o desempenho real depende do conteúdo do áudio, da quantização do modelo e da carga do sistema.
| Modelo | 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 |
Como ler a tabela: 0,1x significa que transcrever 60 segundos de áudio leva cerca de 6 segundos. 1,0x = tempo real. Valores acima de 1,0x significam mais lento que tempo real. Todos os números usam o whisper.cpp com as configurações padrão e o backend Metal (Mac) ou CUDA (NVIDIA), quando aplicável.
Qual modelo você deveria usar?
Aqui estão recomendações concretas baseadas em cenários comuns. Na dúvida, comece pelo small e suba ou desça conforme sua experiência.
"Quero o mais rápido possível"
Use tiny ou tiny.en . Transcreve em milissegundos em hardware moderno. A precisão é grosseira, mas utilizável para anotações rápidas e ditado de baixo risco.
tiny / tiny.en"Quero boa precisão em um notebook"
Use small . Melhor equilíbrio entre velocidade e precisão para notebooks modernos. Se sua máquina tem 16 GB+ de RAM, o medium também é uma excelente escolha.
small ou medium"Quero a melhor precisão"
Use large-v3 . É o modelo Whisper mais preciso no geral. Se a velocidade também importa, o turbo entrega 95% da precisão a 8x a velocidade.
large-v3 ou turbo"Eu só uso inglês"
Use a variante .en do tamanho que você escolher para a melhor precisão em inglês. Para o tiny e o base, os modelos .en são nitidamente melhores. Para o small e acima, a diferença é mínima.
small.en ou medium.en"Eu uso vários idiomas"
Use a variante multilíngue. small ou medium para desempenho equilibrado. large-v3 para a melhor precisão multilíngue.
small, medium ou large-v3"Tenho hardware bem limitado"
Use tiny ou base . Ambos rodam com 1 GB de RAM e funcionam até em Raspberry Pi e outros computadores de placa única. O base oferece um aumento de precisão relevante sobre o tiny com custo adicional mínimo.
tiny ou baseComo o OpenWhispr lida com a seleção de modelos
OpenWhispr é um app de ditado de desktop open source que usa o whisper.cpp por baixo dos panos. Ele permite que você baixe e alterne entre qualquer modelo Whisper diretamente nas configurações — sem precisar de linha de comando. Os modelos são baixados uma vez e armazenados localmente. Você pode trocar de modelo a qualquer momento para equilibrar velocidade e precisão de acordo com o seu hardware.
Baixe qualquer modelo
Escolha do tiny ao large-v3 nas configurações. O OpenWhispr baixa a versão GGML automaticamente.
Troque na hora
Mude de modelo a qualquer momento. Sem precisar reiniciar. Teste tamanhos diferentes para descobrir o que funciona melhor no seu hardware.
Otimizado para o hardware
Usa Metal no Apple Silicon, CUDA na NVIDIA e inferência de CPU otimizada nos demais casos. Tudo local, tudo privado.
Nossa sugestão: Comece pelo small . Se parecer lento, desça para o base ou o tiny. Se quiser mais precisão e seu hardware aguentar, suba para o medium ou o large-v3. O OpenWhispr facilita a experimentação.
Fontes
- Radford et al. "Robust Speech Recognition via Large-Scale Weak Supervision" (2022) — O artigo original do Whisper, com resultados completos de benchmark.
- Repositório do Whisper da OpenAI no GitHub — Tabela oficial de modelos, contagens de parâmetros, requisitos de VRAM e números de velocidade relativa.
- Cartão do modelo Whisper da OpenAI — Composição oficial dos dados de treinamento e ressalvas de avaliação.
- Repositório do whisper.cpp no GitHub — Tamanhos de modelo GGML, uso de RAM e detalhes de aceleração de hardware.
- Cartão do modelo Whisper large-v2 (HuggingFace) — Contexto do benchmark LibriSpeech usado em muitas comparações de WER.
- Cartão do modelo Whisper large-v3 (HuggingFace) — Detalhes de treinamento, mudanças de arquitetura em relação ao large-v2 e melhorias multilíngues.
- Cartão do modelo Whisper large-v3-turbo (HuggingFace) — Detalhes da arquitetura do turbo, especificidades da poda do decodificador e trade-offs de desempenho.
- Anúncio do Whisper Turbo da OpenAI (Discussão #2363 no GitHub) — Notas oficiais de lançamento do turbo e comparações de desempenho entre idiomas.
- OpenWhispr — Contexto prático de implantação local para a escolha de tamanhos de modelo.
Experimente diferentes modelos Whisper no OpenWhispr
Ditado open source e local-first. Baixe qualquer modelo Whisper, alterne entre tamanhos com um clique e encontre o equilíbrio perfeito para o seu hardware.
Sem necessidade de conta · Funciona offline · Open source para sempre