Este modelo de fala de 178 MB não deveria ser tão bom (Parakeet Redux)

Autoria: Better Stack · Assistir no YouTube

Vídeo de autoria do canal indicado, não da IANIA; todos os direitos pertencem ao criador. Transcrição, resumo e tradução gerados automaticamente; o conteúdo no idioma original é preservado na versão em idioma original.

Idioma original: inglês

Vídeo original: This 178MB Speech Model Shouldn’t Be This Good (Parakeet Redux) · Canal: Better Stack · 07:50 · Assistir no YouTube

Tópicos: Inferência e otimização de modelos, Modelos locais e open source, Modelos multimodais, Open source e ecossistemas de software, Privacidade e proteção de dados

Resumo

Parakeet Redux reduz o modelo Parakeet 0.6B V3 de 1,2 GB para 178 MB ao quantizar os pesos do encoder para três valores, mantendo desempenho próximo ao original em inglês e melhorando algumas métricas multilíngues. O modelo pode ser útil em computadores modestos e permite transcrição local, com recursos como detecção automática de idioma e timestamps por palavra. Porém, seu runtime Photon não é open source, e o desempenho piora em áudio com ruído. A escolha depende do hardware, das condições do áudio e da importância de usar um runtime com licença aberta.

Pontos-chave

Parakeet Redux reduz o tamanho do modelo para cerca de 178 MB ao limitar os pesos do encoder a -1, 0 e +1.
A taxa de erro por palavra em inglês muda de 6,26 para 6,55, enquanto algumas métricas multilíngues e de falas longas melhoram.
O modelo oferece detecção automática de idioma, suporte a 25 idiomas europeus e timestamps por segmento ou por palavra.
Em CPU, os testes citados indicam que Redux é cerca de três vezes mais rápido que Parakeet CPP; em GPU de Mac, os resultados são praticamente equivalentes.
O número de 113 vezes o tempo real foi medido em um servidor AMD EPYC com AVX-512, não em um computador típico.
A transmissão de áudio ao vivo substitui o resultado anterior a cada atualização, então acrescentar todas as atualizações pode duplicar frases.
A transcrição local pode oferecer privacidade e funcionar offline, mesmo quando o custo de APIs em nuvem é baixo.
Os pesos são disponibilizados sob Creative Commons, mas o runtime Photon não é open source e há termos de licença pouco claros.
Em áudio com ruído, a taxa de erro piora; o vídeo recomenda considerar o Parakeet original nesse cenário.

Capítulos

Início	Capítulo	Resumo
00:00	Como o modelo foi reduzido	O vídeo apresenta a quantização ternária do Parakeet 0.6B V3 e os resultados de precisão e tamanho do Parakeet Redux.
02:07	Demonstração e comparação de desempenho	A demonstração mostra transcrição com timestamps e detecção de idioma, seguida de comparações de velocidade, suporte a idiomas e recursos.
04:44	Instalação, privacidade e licenciamento	O vídeo explica a instalação e discute os motivos para transcrever localmente, além das dúvidas sobre a licença do runtime Photon.
06:48	Limitações e conclusão	A conclusão destaca a piora em áudio com ruído e recomenda avaliar o modelo conforme o hardware, a qualidade do áudio e a licença do runtime.

Citações

O modelo passou de 1,2 GB para 178 MB e, de algum modo, em inglês quase não piorou. — 00:00

A taxa de erro por palavra em inglês vai de 6,26 para 6,55. É pior, mas por pouco. — 01:04

O verdadeiro motivo de gostarmos desse tipo de coisa é a privacidade. — 05:46

Pesos abertos não significam automaticamente uma stack aberta. — 07:19

Conceitos e entidades

Parakeet Redux (modelo): Modelo de transcrição de fala que reduz o tamanho do Parakeet 0.6B V3 com pesos ternários.
Parakeet 0.6B V3 (modelo): Modelo de fala da Nvidia usado como base para o Parakeet Redux.
Moon Dream (empresa): Empresa responsável pelo Parakeet Redux e pelo runtime Photon.
Photon (ferramenta): Runtime usado para executar o modelo, descrito no vídeo como não open source.
Kestrel Kernels (ferramenta): Pacote instalado como dependência do Photon, cujos termos de licença são questionados no vídeo.
Parakeet CPP (ferramenta): Runtime aberto citado na comparação de velocidade com Parakeet Redux.
Parakeet Mix (modelo): Modelo usado como outro ponto de comparação, com licença Apache mencionada no vídeo.
Whisper large V3 Turbo (modelo): Modelo de transcrição comparado ao Parakeet Redux em tamanho e idiomas suportados.
whisper.cpp (ferramenta): Runtime associado ao Whisper large V3 Turbo na comparação de tamanho apresentada.
Deepgram Nova 3 (modelo): Serviço de transcrição em nuvem cujo custo por minuto é usado como exemplo.
OpenAI mini transcribe (modelo): Modelo de transcrição da OpenAI citado na comparação de custos de APIs em nuvem.
Hugging Face Open ASR leaderboard (ferramenta): Ranking de reconhecimento automático de fala mencionado no vídeo ao comentar a posição dos modelos.

Tradução completa (pt-BR)

00:00 Este modelo de fala para texto passou de 1,2 GB para 178 MB e, de algum jeito, no inglês quase não piorou, porque o maior porém aqui não é o modelo em si, mas aquilo que você precisa usar para executá-lo. Este é o Parakeet Redux, da Moon Dream. Ele começa com o Parakeet 0.6B V3, da Nvidia, que já era um dos melhores modelos de fala open source disponíveis. Depois, a Moon Dream fez algo bem extremo. Pegou cada peso do encoder e o forçou a assumir apenas um de três valores: -1, 0,

00:32 e +1. Hora de colocá-lo à prova. >> [música] >> Pense em cada peso como um pequeno controle de volume preciso. Normalmente, dá para ajustar esse controle para uma enorme variedade de posições. O ternário basicamente arranca o controle e o substitui por uma chave de três posições: -1, 0 e +1. Você descarta muita precisão, mas, em troca, o modelo encolhe para cerca de um sétimo do tamanho. E normalmente você

01:04 esperaria que a precisão também desabasse, mas aqui isso não acontece de verdade. No inglês, a taxa de erro de palavras passa de 6,26 para 6,55. É pior, mas por muito pouco. E fica ainda mais estranho: além disso tudo, a pontuação multilíngue na verdade melhora, de 11,62 para 10,56. Em conversas longas, também melhora, de 2,71 para 2,51. São melhorias. Ele oferece suporte a 25 idiomas europeus e consegue detectar o idioma por conta própria. Então

01:35 o modelo fica drasticamente menor sem desmoronar por completo, e isso é importante por muito mais do que apenas economizar espaço em disco. Com 178 MB, ele é pequeno o bastante para caber no download de um aplicativo e pode rodar em um laptop antigo. E, como pode rodar na CPU, você pode deixar a GPU livre para outra coisa, como um LLM local. Deixe-me mostrar como isso funciona na prática. Se você gosta de ferramentas de programação que aceleram seu workflow, não deixe de se inscrever. Temos vídeos novos o tempo todo. Certo, basta um pip install e algumas linhas de Python. E, no disco, aqui está o

02:07 Parakeet Redux: 178 megabytes. Ao lado, o Whisper large V3 Turbo para Whisper CPP: 1,6 gigabytes. Essa é a primeira grande diferença. Mas o tamanho não importa se o modelo não for realmente útil, então vamos executá-lo. Certo, aqui está um episódio de podcast, e estou pedindo marcações de tempo em cada palavra, para que a saída possa ir direto para as legendas. Agora, aqui está um trecho em alemão. Não informei o idioma; ele simplesmente o identificou sozinho. Até aqui, parece fácil demais, o que nos leva

02:39 aos números de velocidade. No teste do Model Cards em um MacBook Air M2, rodando na CPU, o Redux processa 38 vezes mais rápido que o tempo real. O Parakeet CPP, o runtime aberto popular, chega a 12. Então, segundo os próprios números da Moon Dream, isso representa uma vantagem de cerca de três vezes. Bem impressionante, certo? Mas, ao mudar para a GPU do Mac, essa vantagem praticamente desaparece. O Redux chega a 43. As alternativas ficam em torno de 38, 39. É praticamente um empate, certo? Uma diferença de poucos

03:10 pontos. Se você viu o número de destaque de 113 vezes mais rápido que o tempo real, há outro detalhe importante. Não foi em um Mac, mas em um servidor AMD Epyc com AVX-512. Então, sim, 113 vezes mais rápido que o tempo real é verdade; só que provavelmente não é a máquina que você está usando. E é por isso que a comparação importa muito mais do que esse número sugere. Comparado ao Parakeet original, o Redux é cerca de sete vezes menor. Ele também inclui um detector de voz integrado que divide o áudio em

03:41 trechos com menos de 30 segundos. Comparado ao Parakeet Mix, que tem licença Apache, o desempenho na GPU é próximo: 43 contra 37. Com o Whisper, a troca de vantagens muda de novo. O Whisper oferece suporte a cerca de 99 idiomas — vamos dizer 100. O Redux oferece suporte a 25, todos europeus. Mas o Redux pode transmitir diretamente de um microfone ao vivo, e a transcrição pode se reescrever conforme ouve mais. O restante da API também é bem legal. Você pode escolher sem marcações de tempo, marcações de tempo por segmento ou

04:12 marcações de tempo por palavra. Ele aceita WAV, MP3, FLAC, M4A e bytes brutos. E, se você quiser apenas parte de uma gravação longa, pode informar um horário de início e de fim em vez de cortar o arquivo por conta própria. Para áudio ao vivo, há um modo assíncrono que recebe trechos diretamente do microfone. Você recebe uma primeira prévia após alguns segundos, e ela é atualizada a cada dois. Mas também há uma pequena armadilha. Cada atualização do streaming substitui a anterior. Então, se você simplesmente acrescentar cada resultado, vai imprimir a mesma

04:44 frase várias vezes. A configuração é bem simples. Você precisa do Python 3.1 ou mais recente. O pip install instala o PyTorch e também os pacotes nativos próprios da Moon Dream. Depois, na primeira execução, ele baixa o modelo inteiro, com 178 megabytes. E, até agora, online, a maior parte da atenção se concentrou na publicação de lançamento da Ax Moon Dream. Bombou. Certo. Ou recebeu avaliações razoáveis. Alguém da equipe do ranking Open ASR da Hugging Face disse que esses modelos estão na fronteira de Pareto. No

05:15 Hacker News e em outras plataformas, quase ninguém está falando disso ainda. Mas isso responde a outra pergunta: por que executar conversão de fala em texto localmente, afinal? E é aqui que acho que às vezes entendemos a transcrição local ao contrário. Nem sempre se trata de economizar dinheiro. As APIs na nuvem já podem ser bem baratas. O Nova 3, da Deep Gram, custa cerca de 0,4 centavo por minuto. É quase nada. O modelo mini transcribe da Open AI custa cerca de 0,3 centavo. Uma hora de áudio custa só alguns centavos. Então, se você está migrando para o processamento local apenas para economizar nas tarifas da API, esse não é nem o

05:46 motivo mais forte. O verdadeiro motivo de gostarmos desse tipo de coisa é a privacidade. Funciona offline. Não depende de uma conexão de rede. E esse é o ponto principal aqui. Os pesos são abertos. Eles estão sob Creative Commons, mas o mecanismo que os executa, Photon, não é open source. Quando você instala com pip, também instala um pacote chamado Kestrel Kernels. E o texto da licença diz, abro aspas: “Se você não celebrou tal acordo, não tem licença para usar o software.” É grátis para baixar. Só não consegui descobrir

06:18 o que significava esse acordo todo. E, de repente, esse modelo já não parece tão legal. O Photon é grátis hoje, mas era pago até junho. E a Moon Dream também vende uma opção na nuvem, com o plano para equipes custando cerca de 350 dólares por mês. Então, o que temos são pesos abertos rodando em um mecanismo fechado, de uma empresa cujos termos já mudaram uma vez. Como devemos lidar com isso? Não sei. Tenha cuidado. O segundo porém é o ruído. No benchmark de áudio com ruído, a taxa de erro de palavras salta de 6,72 para cerca de nove. Isso é cerca de um

06:48 terço pior. O próprio model card diz que o Redux troca palavras por outras de som parecido com mais frequência. Então, onde isso nos deixa? Se você usa uma máquina sem GPU, um laptop antigo ou está desenvolvendo um aplicativo em que cada megabyte importa, certo, isso é legal. Experimente, teste. Segundo os próprios números da Moon Dream, ele é cerca de três vezes mais rápido que o Parakeet CPP na CPU. E tem aproximadamente um sétimo do tamanho do modelo original. Instale, execute no seu próprio hardware e experimente. Mas, se você usa um Mac da série M e já está usando a GPU,

07:19 os runtimes abertos oferecem praticamente a mesma velocidade, com uma licença que você consegue ler. Se estiver lidando com áudio ruidoso, fique com o Parakeet original. Os modelos de 1,58 bit acabaram de passar de artigo de pesquisa para pip install. Isso é enorme. Um modelo que antes tinha 1,2 gigabytes agora pode ter cerca de 178 megabytes e ainda manter a maior parte da precisão. Essa parte é genuinamente impressionante. Mas o Parakeet Redux também expõe um novo problema. Pesos abertos não garantem automaticamente uma stack aberta, e acho que é aí que vai acontecer a próxima

07:50 disputa na IA local. Não em torno de quem lança os pesos do modelo, mas de quem controla o runtime que fica por baixo deles. Se você gostou de dicas e truques de programação como este, não deixe de se inscrever no canal Better Stack. Até o próximo vídeo.

Transcrição original

[00:00] This speech to text model went from 1.2 GB to 178 MB and somehow on English it barely got worse because the biggest catch here isn’t actually the model, it’s the thing you have to run it with. This is Parakeet Redux from Moon Dream. It starts with Nvidia’s Parakeet 0.6B V3, already one of the best open speech models out there. Then Moon Dream did something pretty extreme. They took every weight in the encoder and forced it into one of just three values, -1, 0,

[00:32] and +1. Time to put it to the test. >> [music] >> Think of every weight like a tiny precise volume dial. Normally you can just set that dial to a huge number of different positions. Ternary basically rips the dial out and replaces it with a three-position switch, -1, 0, and +1. You throw away a ton of precision, but in return the model collapses to about a seventh of its size. And normally you’d

[01:04] expect accuracy to collapse with it, but here it doesn’t really do that. Now on English word error rate goes from 6.26 to 6.55. That’s worse, but barely. Then it gets even weirder on top of all this, the multilingual score actually improves from 11.62 to 10.56. Long talks improve too from 2.71 to 2.51. These are improvements. It supports 25 European languages and it can detect the language on its own. So

[01:35] the model gets dramatically smaller without completely falling apart, and that is huge for more than just saving disk space. Now at 178 MB, this is a small enough to fit inside an app download and it can run on an old laptop. And because it can run on your CPU, you can leave the GPU free for something else like local LLM. Let me show you what that actually looks like. If you enjoy coding tools that speed up your workflow, be sure to subscribe. We have videos coming out all the time. All right, it’s one pip install and just a few lines of Python. And on disk, here’s

[02:07] Parakeet Redux, 178 megabytes. Next to it, Whisper large V3 Turbo for Whisper CPP, 1.6 gigabytes. That’s the first big difference. But size doesn’t matter if the thing isn’t actually useful, so let’s run it. All right, now here’s a podcast episode and I’m asking for word-level timestamps, so this output can go straight into subtitles. Now, here’s a German clip. I didn’t tell it the language, it just figured it out on its own. So far, this looks almost too easy, which brings us

[02:39] to the speed numbers. On the Model Cards M2 MacBook Air test, running on the CPU, Redux does 38 times real time. Parakeet CPP, the popular open runtime, does 12. So, on Moon Dreams’ own numbers, that’s about a three times win. Pretty impressive, okay, but switch to a Mac’s GPU and that lead basically disappear. Redux does 43. The alternatives do around 38, 39. That’s basically a tie, okay, a few

[03:10] numbers off. If you’ve seen the headline number of 113 times real time, there’s another detail you need. That wasn’t on a Mac, that was on an AMD epic server with AVX-512. So, yes, 113 times real time is real, it’s just probably not the machine that you’re using. And that’s why the comparison matters a lot more than what that says. Against original Parakeet, Redux is about seven times smaller. It also includes a built-in voice detector that chops audio into

[03:41] chunks under 30 seconds. Against Parakeet Mix, which is Apache-licensed, GPU performance is close to 43 versus 37. Against Whisper, the tradeoff changes yet again. Whisper supports around 99 languages, let’s call it 100. Reduct supports 25 and they’re all European-based. But, Reduct can stream directly from live microphone and the task can rewrite itself as it hears more. The rest of the API is actually pretty nice, too. You can choose no timestamps, segment timestamps, or

[04:12] word-level timestamps. It accepts wave, MP3, FLAC, M4A, and raw bytes. And if you only want part of a long recording, you can give it a start and end time instead of cutting the file yourself. For live audio, there’s an async mode that takes chunks directly from your mic. You get a first preview after about a few seconds, then it refreshes every two. But, there’s also a little trap here. Each streaming update replaces the last one. So, if you just append every result, you’re going to print the same

[04:44] sentence multiple times. The setup is all pretty simple. You need Python 3. 1 or newer. The pip install pulls in PyTorch plus Moon Dream’s own native packages. Then, the first run downloads the whole model itself, 178 megabytes. And online, most of the attention so far has just been on Ax Moon Dream’s launch post. Blew up. Okay, sure. Or got decent reviews. Someone from Hugging Face’s Open ASR leaderboard team said these models sit on the Pareto front. On

[05:15] Hacker News and other platforms, no one’s really talking about this yet. But, this answers another question. Why run speech to text locally in the first place? And this is where I think sometimes we get local transcription backwards. It’s not always about saving money. Cloud APIs can already be pretty cheap. Deep Gram’s Nova 3 is about 4/10 of a cent per minute. That’s nothing. Open AI’s mini transcribe model is around 3/10. An hour of audio costs just pennies. So, if you’re moving local just to save API fees, that’s not even the

[05:46] strongest reason. The real reason that we like this kind of stuff is privacy. It’s working offline. It’s not depending on a network connection. And that’s really what’s key here. The weights are open. They are Creative Commons, but the engine that runs them, Photon, is not open source. When you pip install it, you’re also pulling in a package called Kestrel Kernels. And the license text says, quote, “If you have not entered into such an agreement, you have no license to use the software.” It’s free to download. I just couldn’t find out

[06:18] what that whole agreement meant. And suddenly this model isn’t as cool as it used to be. Photon is free today, but it was paid until June. And Moon Dream also sells a cloud tier with the team plan around 350 bucks a month. So what you have is open weights running inside a closed engine from a company whose terms have already changed once. So how do we approach that? I don’t know. Be careful here. The second catch is noise. On the noise audio benchmark, air rate jumps from 6.72 to about nine. That’s about a

[06:48] third worse. The model card itself says Redux swaps in a similar sounding words more often. So where does this leave us? If you’re on a CPU-only machine, an older laptop, or you’re building an app where every megabyte matters, sure, okay, this is cool. Play around with it, test it. On Moon Dream’s own numbers, it’s around three times faster than Parakeet CPP on CPU. And it’s roughly a seventh of the size of the original model. Install it, run it on your own hardware, play around with it. But if you’re an M-series Mac and you’re

[07:19] already using the GPU, the open runtimes get you basically the same speed with a license you can actually read. If you’re dealing with noisy audio, just stick with the original Parakeet. 1.58-bit models just went from research paper to pip install. That is huge. A model that used to be 1.2 gigabytes can now sit around 178 megabytes and still keep most of its accuracy. That part is genuinely impressive. But Parakeet Redux also exposes a new problem. Open weights don’t automatically give you an open stack, and I think that’s where the next

[07:50] fight in local AI is going to happen. Not around who releases the model weights, around who controls the runtime underneath them. If you enjoyed coding tips and tricks like this, be sure to subscribe to the Better Stack channel. We’ll see you in another video.