Blog

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

OpenWhispr

Engenharia

5 de fevereiro de 2026
Í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)

Whisper Tamanhos de modelo: velocidade versus precisão

O tamanho da bolha reflete a contagem relativa de parâmetros

Mais rápido →Mais preciso →tinybasesmallmediumlargeturboRecomendação: comece pequeno e ajuste com base no hardware.

Taxa de erro de palavras: Whisper vs concorrentes de código aberto

LibriSpeech test-clean (leitura de fala em inglês) - quanto menor, melhor

NVIDIA
Outro código aberto
OpenAI Whisper

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.

ModeloParâmetrosSomente inglêsVRAM (GPU)Disco GGMLRAM (whisper.cpp)VelocidadeWER em inglêsWER multilíngue
tiny39 Mtiny.en~1 GB75 MiB~273 MB~10x~7.6%~12%
base74 Mbase.en~1 GB142 MiB~388 MB~7x~5.0%~10%
small244 Msmall.en~2 GB466 MiB~852 MB~4x~3.4%~7%
medium769 Mmedium.en~5 GB1.5 GiB~2.1 GB~2x~2.9%~5%
large-v21,550 MN/D~10 GB2.9 GiB~3.9 GB1x~2.7%~4%
large-v31,550 MN/D~10 GB2.9 GiB~3.9 GB1x~2.4%~3.5%
turbo809 MN/D~6 GB1.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.

Recursos
  • GGML: 75 MiB em disco
  • RAM: ~273 MB em execução
  • VRAM: ~1 GB (modo GPU)
Velocidade
  • ~10x mais rápido que o large
  • Quase instantâneo no Apple Silicon
  • Tempo real na maioria das CPUs
Precisão
  • 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.

Melhor para: Transcrição o mais rápida possível, hardware com poucos recursos, Raspberry Pi, aplicações em tempo real

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.

Recursos
  • GGML: 142 MiB em disco
  • RAM: ~388 MB em execução
  • VRAM: ~1 GB (modo GPU)
Velocidade
  • ~7x mais rápido que o large
  • Ainda muito rápido na CPU
  • Menos de um segundo no Apple Silicon
Precisão
  • 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.

Melhor para: Dispositivos de baixa potência que precisam de mais precisão que o tiny, streaming em tempo real, hardware econômico

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.

Recursos
  • GGML: 466 MiB em disco
  • RAM: ~852 MB em execução
  • VRAM: ~2 GB (modo GPU)
Velocidade
  • ~4x mais rápido que o large
  • Rápido em notebooks modernos
  • Tempo real no Apple Silicon
Precisão
  • 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.

Melhor para: A maioria dos usuários em notebooks modernos, modelo padrão recomendado, bom suporte multilíngue

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.

Recursos
  • GGML: 1,5 GiB em disco
  • RAM: ~2,1 GB em execução
  • VRAM: ~5 GB (modo GPU)
Velocidade
  • ~2x mais rápido que o large
  • Tranquilo em máquinas de 8 GB+
  • Precisa de hardware decente
Precisão
  • 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.

Melhor para: Uso profissional, transcrição multilíngue, conteúdo técnico, máquinas com 8 GB+ de RAM

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.

Recursos
  • GGML: 2,9 GiB em disco
  • RAM: ~3,9 GB em execução
  • VRAM: ~10 GB (modo GPU)
Velocidade
  • 1x (referência — mais lento)
  • GPU fortemente recomendada
  • CPU: pode ser mais lento que tempo real
Precisão
  • 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.

Melhor para: Máxima precisão, transcrição profissional/médica/jurídica, idiomas com poucos recursos, processamento em lote

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.

Recursos
  • GGML: ~1,6 GiB em disco
  • RAM: ~2,3 GB em execução
  • VRAM: ~6 GB (modo GPU)
Velocidade
  • ~8x mais rápido que o large
  • Precisão perto do large, velocidade perto do tiny
  • Ótimo na GPU com torch.compile
Precisão
  • 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.

Melhor para: Transcrição em tempo real de alta precisão, apps sensíveis à latência, quando o large-v3 é lento demais

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.

ModeloMacBook Air M1MacBook M3 ProIntel 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 base

Como 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

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