Fiz reconhecimento de fala de verdade funcionar em um chip de US$ 10 (Whistle)

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: I Got Real Speech Recognition Running on a $10 Chip (Whistle) · Canal: Better Stack · 12:01 · Assistir no YouTube

Tópicos: Inferência e otimização de modelos, Infraestrutura e hardware de IA, Modelos locais e open source, Modelos multimodais

Resumo

O vídeo mostra Whistle, um modelo de speech-to-text que reconhece sete idiomas, funcionando offline em uma placa ESP32-S3 de baixo custo. Como o arquivo completo do modelo ultrapassa o espaço de armazenamento disponível, o autor remove camadas do decoder e otimiza a execução para caber no chip. O dispositivo transcreve comandos de voz e controla uma LED RGB, com tempos de resposta em torno de 10 segundos. Testes com vozes sintéticas indicam cerca de 78% de acerto em comandos de cores em inglês, com melhorias obtidas por keyword biasing e uma regra de nova tentativa.

Pontos-chave

Whistle é um modelo de speech-to-text de 16,9 MB que reconhece inglês, alemão, francês, espanhol, italiano, neerlandês e polonês.
O ESP32-S3 usado no projeto tem 16 MB de flash, menos espaço do que o arquivo completo do modelo exige.
O autor reduziu o decoder para quatro camadas, preservando todas as camadas do encoder, e conseguiu fazer o modelo caber no dispositivo.
A placa funciona offline e usa um microfone INMP441 e um botão para gravar comandos de voz.
O processamento de uma ordem leva, em média, cerca de 10 segundos após otimizações na matemática matricial, no uso dos dois núcleos e na aritmética de 8 bits.
Frases curtas, como “deixe a luz vermelha”, foram reconhecidas corretamente de 82% a 93% das vezes nos testes, contra 44% para uma palavra de cor isolada.
Nos testes com vozes sintéticas para comandos de cores em inglês, o sistema acertou cerca de 78% das vezes; o autor ressalta que esses valores são apenas uma referência aproximada.
Keyword biasing e uma regra de nova tentativa melhoraram os resultados nos testes específicos de comandos de cores.

Capítulos

Início	Capítulo	Resumo
00:00	Demonstração de reconhecimento de voz offline	O autor demonstra comandos em inglês e francês que controlam uma luz por meio de um microcontrolador.
03:10	Reduzindo o modelo para caber no chip	O autor explica como remove camadas do decoder e ajusta a partição do modelo para caber nos 16 MB de flash.
05:15	Como Whistle processa o áudio	A transcrição explica o mel spectrogram, o encoder, o decoder e a geração do texto.
07:21	Montagem e testes na placa	O autor apresenta o circuito, demonstra comandos de voz e mede o tempo de processamento.
09:24	Otimização e precisão dos comandos	O vídeo descreve as otimizações de desempenho e os resultados dos testes de precisão com vozes sintéticas.
11:29	Resumo do projeto e disponibilidade	O autor resume o funcionamento offline de Whistle no chip e informa que o modelo está disponível no Hugging Face.

Citações

Está funcionando completamente offline, sem Wi-Fi nem Bluetooth conectados. — 00:00

Fiquei com a versão de quatro camadas, que se encaixa muito bem. — 04:12

Prefira uma frase curta, como ‘deixe a luz vermelha’, em vez de dizer apenas ‘vermelho’. — 08:54

Com um pouco de redução e muita otimização, consegui fazê-lo funcionar completamente offline em um chip de US$ 10. — 11:29

Conceitos e entidades

Whistle (modelo): Modelo de speech-to-text da Cactus Compute, com suporte a sete idiomas e tamanho de 16,9 MB.
Cactus Compute (empresa): Empresa que criou Whistle e Needle e disponibiliza o modelo Whistle sob a licença Apache 2.0.
ESP32-S3 (ferramenta): Microcontrolador usado para executar Whistle localmente, com 16 MB de flash e 8 MB de memória.
Needle (modelo): Modelo da Cactus Compute mencionado como antecessor do projeto e como modelo que compartilha o mecanismo de execução de Whistle.
Whisper base (modelo): Modelo da OpenAI usado como comparação de tamanho e desempenho para Whistle.
LibriSpeech (conceito): Conjunto de teste padrão com pessoas lendo audiolivros em voz alta, citado na comparação de desempenho dos modelos.
INMP441 (ferramenta): Microfone digital pequeno instalado na placa para captar os comandos de voz.
mel spectrogram (conceito): Representação do áudio em faixas de frequência e tempo que o modelo usa como entrada.
keyword biasing (conceito): Técnica que favorece palavras fornecidas, como nomes de cores, quando o modelo está em dúvida.
Apache License 2.0 (conceito): Licença sob a qual Whistle é disponibilizado.
Hugging Face (ferramenta): Plataforma indicada no vídeo como local para baixar Whistle.

Tradução completa (pt-BR)

00:00 Certo, pessoal, confiram isto. Este é um microcontrolador ESP32-S3, e este é um microfone minúsculo soldado nele. E este é um botãozinho soldado a uma placa perfurada, que ativa o microfone. E a própria placa está conectada a um carregador portátil, então está funcionando completamente offline, sem Wi-Fi nem Bluetooth conectados. Agora, confiram isto. Pisque a luz em roxo-claro por 5 segundos.

00:31 Olhem só. Que legal é isso? Agora, vamos tentar outro idioma. Acenda a luz em vermelho. Vamos ver o que acontece. Olhem só. Estamos recebendo uma luz vermelha. Que legal é isso? O modelo que faz tudo isso se chama Whistle, e é o novíssimo modelo de fala para texto da Cactus Compute, a mesma empresa que lançou Needle, que já apresentei duas vezes neste canal. Então, neste

01:02 vídeo, vamos conhecer o Whistle, e vou mostrar como consegui colocá-lo em um chip minúsculo que, tecnicamente, é pequeno demais para ele. Depois, vou mostrar algumas coisas bem estranhas que descobri pelo caminho. Vai ser muito divertido, então vamos nessa. Primeiro, um pouco de contexto. No meu vídeo anterior sobre Needle 2, escrevi meu próprio mecanismo de inference para fazer o Needle funcionar exatamente nesta placa, e ele respondia aos meus comandos, que eu precisava digitar à mão. Mas agora o Whistle nos dá a

01:34 oportunidade de instalar localmente um modelo de fala para texto em um microcontrolador. Então, a Cactus lançou o Whistle em 2 de outubro, e o modelo inteiro é apenas um arquivo de 16,9 MB. Ele transcreve inglês, alemão, francês, espanhol, italiano, neerlandês e polonês, e identifica sozinho em qual idioma você está falando. Ele também pode fornecer uma marcação de tempo para cada palavra e transformar um clipe em um embedding sem gerar uma transcrição. Para comparar, o modelo base do Whisper, da OpenAI,

02:05 tem 145 MB, então o Whistle é quase nove vezes menor e, de acordo com os próprios benchmarks da Cactus, ainda supera o Whisper base no LibriSpeech, que é o conjunto de teste padrão com pessoas lendo audiolivros em voz alta. Em um laptop MacBook M4 Pro, ele gera a primeira palavra em cerca de 11 ms, o que é incrivelmente rápido. E o que o torna interessante para nós é que o Whistle funciona com o mesmo mecanismo do Needle, e a Cactus projetou os dois para serem carregados lado a lado. Então,

02:38 na configuração deles, você pode inserir diretamente um clipe de áudio e receber diretamente uma chamada de ferramenta, o que é basicamente um assistente de voz para dispositivos minúsculos. A Cactus distribui versões pré-compiladas do mecanismo para 17 plataformas, incluindo celulares, laptops e um navegador, mas não há uma versão para o chip ESP32 que estou usando aqui. Então, assim como com o Needle 2, se eu quisesse algo nesta placa, teria que compilar tudo por conta própria. Foi assim que fiz. O primeiro problema é simples. A placa tem 16 MB de armazenamento flash, e o Whistle

03:10 tem 16,9 MB. Então, o modelo completo é literalmente maior do que o próprio chip, e isso antes mesmo de contabilizarmos o firmware. Mas é aqui que entra a escada de inteligência, que alguns de vocês devem lembrar que abordei no vídeo sobre Needle 3. O Whistle tem duas metades. Há um encoder, que escuta o áudio, e um decoder, que escreve o texto. O decoder tem oito camadas, e a Cactus o treinou de modo que você possa cortá-lo depois de duas, três, quatro ou mais camadas,

03:40 e cada uma dessas versões reduzidas ainda funciona como um modelo por conta própria. Mas o encoder sempre funciona com todas as oito camadas, então não podemos reduzir essa parte. Escrevi uma ferramenta pequena que pega o arquivo completo do modelo e gera um novo contendo apenas as camadas que você quer manter. Verifiquei que o arquivo reduzido gera exatamente a mesma saída que o modelo completo executado com a mesma quantidade de camadas, e garanti que o próprio mecanismo da Cactus carregasse sem reclamar. E, quando mostrei onde todos os megabytes são realmente usados, o

04:12 maior bloco era, na verdade, a memória de N-gram, aquelas grandes tabelas de consulta de que falei nos outros vídeos sobre Needle, que ocupam cerca de 5,3 megabytes. Isso é quase um terço do arquivo inteiro. Em comparação, uma camada do decoder tem apenas cerca de meio megabyte. Então, escolhi a versão de quatro camadas, que se encaixa muito bem depois que estendi a partição do modelo até o fim do chip flash, e isso me deixa com um total de 98 kilobytes sobrando. Ela também comete visivelmente menos erros do que a

04:44 versão de duas camadas. Então, essas camadas extras definitivamente valem o espaço que ocupam. O único porém é que Needle e Whistle não podem compartilhar a mesma placa, porque, juntos, precisariam de cerca de 24 megabytes. Então, o Whistle funciona sozinho e, em vez do Needle, escrevi um parser pequeno que lê a transcrição e extrai a cor e o modo como as luzes devem piscar. Vamos percorrer rapidamente o que acontece entre eu falar e o texto aparecer, porque isso ajuda a explicar para onde vai todo o tempo de latência. Primeiro, o áudio bruto

05:15 é transformado em algo chamado espectrograma mel. O microfone grava 16.000 amostras por segundo, e o modelo divide isso em intervalos minúsculos de 10 ms. Depois, mede quanta energia há em cada tom. Assim, você acaba com algo que parece um mapa de calor da sua voz ao longo do tempo. Em seguida, uma pequena pilha de camadas convolucionais comprime esse mapa de calor, de modo que cada intervalo passe a cobrir 80 ms de áudio, em vez de 10. Isso é importante porque, a partir daqui, cada parte do modelo funciona

05:47 com quadros de 80 milissegundos. Então, um comando de 2 segundos se transforma em apenas 25 quadros. Em seguida, vem o encoder. Ele tem oito camadas, e o interessante é que cada quadro pode observar todos os outros quadros do clipe ao mesmo tempo. Assim, um som no começo da sua frase pode ser entendido no contexto do que você disse no final. Por fim, o decoder escreve a transcrição uma parte de cada vez, mais ou menos como um modelo de linguagem comum. A primeira coisa que ele escreve é um

06:19 token de idioma, então ele literalmente decide se você está falando inglês ou francês antes de escrever uma única palavra. E, cada vez que escreve uma parte do texto, ele consulta a saída do encoder por meio de algo chamado atenção cruzada, que é basicamente o decoder voltando ao que ouviu antes de decidir qual será a próxima palavra. O decoder também tem aquelas tabelas de consulta de engram do Needle, então parte do conhecimento dele vem de consultas, em vez de cálculos. Agora, vamos ver o hardware. É o mesmo tipo de placa ESP32-S3

06:51 que usei no meu vídeo sobre Needle 2, com 16 MB de flash e 8 MB de memória, funcionando a 240 MHz. Além disso, soldei nela um INMP441, um microfone digital minúsculo que custa alguns dólares. Também soldei uma plaquinha perfurada com um botão de pressão comum, que me permite falar no microfone enquanto o botão está pressionado. No total, foram oito fios que precisei conectar à placa. E a luz que estou

07:21 controlando é o LED RGB que já vem integrado à placa. E, assim como da última vez, vou deixar o link do repo no GitHub na descrição abaixo, caso queiram montar este gadget por conta própria e gravar nele exatamente este projeto. O funcionamento é assim: você segura o botão enquanto fala, e o LED fica branco para você saber que está gravando. Quando solta o botão, ele pulsa com pouca intensidade enquanto processa, e então faz o que você pediu. E, se conectar a placa a um laptop, tenho este aplicativo de terminal que mostra a transcrição, o que o LED está fazendo e

07:52 quanto tempo cada etapa leva. O laptop está apenas mostrando a saída aqui, mas todo o trabalho de fato acontece na placa. Então, estou com a placa conectada aqui e, agora, se eu apertar o botão, deveremos ver algo no aplicativo de TUI. Vamos começar a falar. Pisque a luz azul-clara. Agora, está transcrevendo. Dá para ver “Pisque a luz azul-clara”, assim como dá para ver isso na placa. E

08:23 Você pode ver que levou um total de 8,8 segundos para processar esse comando. Vamos tentar algo em francês. Fais clignoter la lumière violette. (Faça a luz violeta piscar.) E está transcrevendo. E, como você pode ver, temos uma luz violeta aqui, e também no app, e levou 11,7 segundos. Então, como você pode ver, isso varia. Alguns comandos levam mais tempo para responder; outros, menos. Então, isso

08:54 depende do prompt, do idioma, de tudo combinado. E, se você se lembra do meu vídeo sobre o Needle 2, um único comando levou cerca de 40 segundos. Então, isso já é bem mais rápido. Uma dica, se você for montar isso por conta própria: diga uma frase curta, como “deixe vermelho”, em vez de dizer apenas a palavra “vermelho”, porque, nos meus testes, frases curtas foram reconhecidas corretamente de 82% a 93% das vezes, enquanto uma única palavra indicando a cor, sozinha, só funcionou em 44% das vezes. E isso pode parecer

09:24 contraintuitivo, porque você pensaria que uma palavra clara seria a coisa mais fácil de reconhecer, mas, na verdade, é o contrário. Isso porque um modelo de fala como este aprendeu com pessoas falando em frases completas, então uma única palavra, sozinha, oferece muito pouco som e quase nenhum contexto para o modelo trabalhar. Agora, fazer uma placa como esta responder tão rápido deu algum trabalho, porque a primeira versão levava quase 24 segundos para processar um comando de 2 segundos, e a maior parte do processamento em um modelo como

09:55 este é dedicada à matemática de matrizes, que basicamente consiste em fazer milhões de multiplicações entre o áudio e os pesos do modelo. Então, otimizei essa parte para processar vários quadros de áudio em uma única passagem e dividir o trabalho entre os dois núcleos do chip. Depois, transferi a matemática pesada para inteiros de 8 bits na unidade vetorial do chip, que é uma pequena peça de hardware dentro do ESP32-S3 capaz de fazer várias multiplicações ao mesmo tempo. E, com tudo isso, consegui fazer o modelo de quatro camadas responder em

10:26 cerca de 10 segundos, em média. Então, acho que é um resultado muito bom para este experimento. Agora, vamos falar sobre a precisão da transcrição, e quero deixar claro que esses números vêm de vozes de teste sintéticas, não de pessoas reais, então encare-os como uma estimativa aproximada. Mas, nos meus testes com comandos de cores em inglês, a placa acerta o comando em cerca de 78% das vezes, e isso quase não muda quando misturo ruído real captado pelo meu microfone. E o curioso é que, neste teste de comandos de cores, minha versão reduzida no chip

10:58 na verdade, supera o modelo completo da própria Cactus em todos os idiomas. O modelo pequeno em si não é mais inteligente, e essa diferença vem de dois truques que acrescentei. O primeiro é o viés para palavras-chave, em que forneço ao modelo uma lista de nomes de cores e ele recebe um pequeno incentivo para escolhê-los quando está em dúvida. O segundo é a regra de nova tentativa: se a primeira tentativa não encontrar a cor, a placa tenta de novo com outro idioma e só aceita essa resposta se a confiança nela for quase tão alta quanto na primeira. Então, é isso,

11:29 pessoal. Esse é o Whistle em poucas palavras. É um modelo de fala para texto de 16,9 megabytes que entende sete idiomas e, com alguns cortes e muita otimização, consegui fazê-lo funcionar completamente offline em um chip de US$ 10. Todo o crédito vai para a Cactus Compute; eles são os verdadeiros mágicos que criaram esse incrível modelo de fala para texto. Então, fica aqui um grande agradecimento a eles. O Whistle foi lançado sob a licença Apache 2.0 e está disponível para download no Hugging Face. Assim, você também pode começar a experimentar por conta própria.

12:01 Então, o que vocês acham do Whistle? Já experimentaram? Vão usá-lo? Que tipo de projeto vocês criariam com ele? Adoraria saber o que pensam nos comentários aqui embaixo. E, pessoal, se vocês gostam desse tipo de análise técnica detalhada, mostrem isso curtindo o vídeo e não se esqueçam de se inscrever no nosso canal. Aqui é o Andras, da Better Stack, e vejo vocês nos próximos vídeos. >> [música] [música]

Transcrição original

[00:00] Okay, folks, check this out. This is an ESP32-S3 microcontroller, and this is a tiny microphone soldered onto it. And this is a little button soldered onto a perf board that activates the microphone. And the board itself is attached to a power bank, so it’s running completely offline with no Wi-Fi and no Bluetooth connected. Now, check this out. Flash the light purple for 5 seconds.

[00:31] Look at that. How cool is that? Now, let’s try a different language. Allume la lumière en rouge. Let’s see what happens. Look at that. We’re getting a red light. How cool is that? So, the model doing all this is called Whistle, and it’s the brand new speech-to-text model from Cactus Compute, the same company that released Needle, which I’ve already covered twice on this channel. So, in

[01:02] this video, we’re going to take a look at Whistle, and I’ll show you how I squeezed it into a tiny chip that is technically too small for it. And then, I’ll show you some pretty weird things I discovered along the way. It’s going to be a lot of fun, so let’s dive into it. So, a quick bit of context here. In my previous Needle 2 video, I wrote my own inference engine to get Needle running on this exact board, and it responded to my commands that I had to type out by hand. But, Whistle now gives us the

[01:34] opportunity to deploy a fully local speech-to-text model on a microcontroller. So, Cactus released Whistle on October 2nd, and the whole model is just a single file of 16.9 MB. It transcribes English, German, French, Spanish, Italian, Dutch, and Polish, and it figures out which language you’re speaking on its own. It can also give you a timestamp for every word, and it can turn a clip into an embedding without writing out a transcript at all. For comparison, OpenAI’s Whisper base

[02:05] model is 145 MB, so Whistle is almost nine times smaller, and according to Cactus’ own benchmarks, it still beats Whisper base on LibriSpeech, which is the standard test set of people reading audiobooks out loud. On a MacBook M4 Pro laptop, it gets its first word out in about 11 ms, which is blazingly fast. And the part that makes it interesting for us is that Whistle runs on the same engine as Needle, and Cactus designed the two to be loaded side by side. So,

[02:38] in their setup, you can feed an audio clip straight in and get a tool call straight out, which is basically a voice assistant for tiny devices. Now, Cactus ships pre-built versions of its engine for 17 platforms, including phones, laptops, and a browser, but there’s no build for the ESP32 chip I’m using here. So, just like with Needle 2, if I wanted something on this board, I had to build it myself. So, here’s how I did it. So, the first problem is simple. The board has 16 MB of flash storage, and Whistle

[03:10] is 16.9 MB. So, the full model is literally bigger than the chip itself, and that’s before we even count the firmware. But, this is where the intelligence ladder comes in, which some of you will remember I covered in the Needle 3 video. So, Whistle has two halves. There’s an encoder, which listens to the audio, and there’s a decoder, which writes out the text. The decoder has eight layers, and Cactus trained it so that you can cut it off after two, three, four, or more layers,

[03:40] and every one of those cut down versions still works as a model on its own. But, the encoder always runs with all eight of its layers, so we cannot trim that part down. So, I wrote a small tool that takes the full model file and writes out a new one that only contains the layers you actually want to keep. And I checked that the strip file gives exactly the same output as the full model running at the same depth, and I made sure that Cactus’ own engine loads without any complaints. And when I printed out where all the megabytes actually go, the

[04:12] biggest chunk was actually the N-gram memory, and those are the big lookup tables I talked to about in the other needle videos, which take up about 5.3 megabytes. So, that’s almost a third of the whole file. One decoder layer, by comparison, is only about half a megabyte. So, I went with the four-layer version, which fits quite nicely once I stretched the model partition all the way to the end of the flash chip, and that leaves me with a grand total of 98 kilobytes to spare. And it also makes noticeably fewer mistakes than the

[04:44] two-layer version. So, those extra layers are definitely worth packing into it. The only catch is that needle and whistle can’t share the same board, because together that would need about 24 megabytes. So, whistle is running on its own, and instead of needle, I wrote a small parser that reads the transcript and pulls out the color and how the lights should blink. So, let’s quickly walk through what actually happens between me speaking and the text coming out, because it helps explain where all the latency goes. First, the raw audio

[05:15] gets turned into something called a mel spectrogram. The microphone records 16,000 samples per second, and the model chops that into tiny 10-ms slices. And then it measures how much energy there is at each pitch. So, you end up with something that looks like a heat map of your voice over time. And then a small stack of convolution layers squeezes that heat map down so that every slice now covers 80 ms of audio instead of 10. And that’s important because from this point on, every part of the model works

[05:47] on those 80 millisecond frames. So, what 2-second command becomes just 25 frames. And next comes the encoder. It has eight layers, and the interesting thing here is that every frame gets to look at every other frame in the clip at the same time. So, a sound at the start of your sentence can be understood in the context of what you said at the end. And finally, the decoder writes out the transcript one piece at a time, kind of like a regular language model. The very first thing it writes is a language

[06:19] token, so it literally decides whether you’re speaking English or French before it writes a single word. And every time it writes a piece of text, it looks back at the encoder’s output through something called cross attention, which is basically the decoder checking back with what it heard before it decides on the next word. The decoder also has those engram lookup tables from needle, so some of its knowledge comes from looking things up instead of calculating them. So, now let’s look at the hardware. It’s the same kind of ESP32-S3

[06:51] board I used in my Needle 2 video with 16 MB of flash and 8 MB of memory running at 240 MHz. On top of that, I soldered on an INMP441, which is a tiny digital microphone that costs a couple of dollars. And I also soldered together a little perf board with a regular push button, which lets me speak into the microphone when the button is pushed. And in total, that comes down to eight wires I had to attach to the board. And the light I’m

[07:21] controlling is the RGB LED that’s already built on the board. And just like last time, I’ll leave the link to the GitHub repo in the description below if you want to build this gadget yourself and flash it with this exact project. So, the way it works is that you hold the button while you speak, and the LED turns white, so you know it’s recording. When you let go, it pulses dimly while it’s thinking, and then it does whatever you ask for. And if you connect the board to a laptop, I have this terminal app that shows the transcript, what the LED is doing, and

[07:52] how long each step takes. The laptop is only showing the output here, but all the actual work happens on the board. So, I have my board connected here, and now if I press the button, we should see something on the TUI application. So, let’s start talking. Flash the light blue. So, now it’s transcribing. And you can see flash the light blue, as well as you can see it on the board. And

[08:23] you can see it took it a total of 8.8 seconds to process this command. Let’s try something in French. Fais clignoter la lumière violette. And it’s transcribing. And as you can see, we get a purple light here, and also on the app, and it took us 11.7 seconds. So, as you can see, it does vary. Some commands take a longer time to respond, some are shorter. So, it

[08:54] does depend on the prompt, the language, everything combined. And if you remember in my Needle 2 video, a single command took around 40 seconds. So, this is already a lot snappier. One tip, if you build this yourself, say a short phrase like make it red instead of just saying the word red, because in my tests, short phrases were recognized correctly 82 to 93% of the time, while a single color word on its own only worked 44% of the time. And this might sound

[09:24] counterintuitive, because you’d think one clear word would be the easiest to recognize, but actually, it’s the other way around. Because a speech model like this learned from people talking in full sentences, so a single word on its own gives it very little sound and almost no context to work with. Now, to get a board like this to respond in such a quick manner took some work because the very first version took almost 24 seconds for a 2-second command, and most of the processing time in a model like

[09:55] this goes into the matrix math, which is basically doing millions of multiplications between the audio and the model’s weights. So, I optimized that part so that it processes several audio frames in one pass and splits the work across both of the chip’s cores. And then I moved the heavy math to 8-bit integers on the chip’s vector unit, which is a small piece of hardware inside the ESP32-S3 that can do several multiplications at the same time. And with all of that, I got the four-layer model to respond in

[10:26] about 10 seconds on average. So, I think that’s a pretty nice result for this experiment. Now, let’s talk about transcription accuracy, and I want to be up front that these numbers come from synthetic test voices and not from real people, so take them as a rough guide. But in my tests for English color commands, the board gets the command right about 78% of the time, and that barely changes when I’m mixing real noise from my microphone. And the funny thing is that on this color command test, my cut-down version on the chip

[10:58] actually beats Cactus’s own full-size model in every language. The small model itself isn’t any smarter, and that difference comes from two tricks that I added on top. The first is keyword biasing, where I give the model a list of color words and it gets a little nudge towards them whenever it’s unsure. And the second is the retry rule, so if the first attempt doesn’t find the color, the board tries again with a different language and only accepts that answer if it’s almost as confident as the first one. So, there you have it,

[11:29] folks. That is Whistle in a nutshell. It’s a 16.9 megabyte speech-to-text model that understands seven languages and with a bit of trimming and a lot of optimization, I got it running completely offline on a $10 chip. Full credit to Cactus Compute, they are the real magicians who created this awesome speech-to-text model. So, a big shout-out to them and Whistle is released under the Apache 2.0 license and it’s available to download on Hugging Face. So, you can start tinkering with it on your own as well.

[12:01] So, what do you folks think about Whistle? Have you tried it? Will you use it? What kind of projects would you build with it? I would love to know your thoughts in the comments section down below. And folks, if you like these types of technical breakdowns, please let me know by smashing that like button underneath the video and also don’t forget to subscribe to our channel. This has been Andras from Better Stack and I will see you in the next videos. >> [music] [music]