Audio8 ASR Infinite: 89% de erros contra 6%, com o mesmo áudio

Autoria: Prompt Engineer 48 · 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: Audio8 ASR Infinite: 89% Wrong vs 6% Wrong, Same Audio · Canal: Prompt Engineer 48 · 05:45 · Assistir no YouTube

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

Resumo

O vídeo testa o Audio8 ASR Infinite, um modelo de reconhecimento de fala, com diferentes tipos de áudio e configurações de execução. Em uma GPU RTX 4090, o caminho padrão em PyTorch degrada após cerca de dois minutos, mas o uso do vLLM com janela deslizante mantém os erros baixos e a memória estável em um teste contínuo de 34 minutos. O modelo teve bons resultados em áudio limpo e em chinês, mas enfrentou dificuldades com ruído, áudio de qualidade telefônica e trechos que misturam idiomas e números. O teste também mostra que o modelo não cabe no laptop com 8 GB de VRAM e que nomes e jargões são fontes comuns de erro.

Pontos-chave

O Audio8 ASR Infinite é apresentado como um modelo de 4 bilhões de parâmetros, Apache 2.0, compatível com inglês e chinês.
O modelo não carregou no laptop com RTX 4060 e 8 GB de VRAM.
Em testes controlados, a transcrição de áudio limpo teve zero erros; o resultado variou em testes com números, jargões, ruído e fala acelerada.
Quatro dos seis trechos do LibreSpeech ficaram abaixo de 6% de erros, embora um trecho curto tenha tido o pior resultado.
Em PyTorch, a transcrição de um áudio de 8 minutos e meio começou bem, mas chegou a 89% de erros após cerca de dois minutos.
Com vLLM e o mecanismo de janela deslizante, o mesmo áudio teve 6% de erros, sem que nenhum minuto ultrapassasse 8%.
Em uma execução contínua de 34 minutos, o erro geral foi de 5,4% e a memória da GPU permaneceu praticamente estável.
O autor estima um custo de cerca de US$ 17,76 por dia para um fluxo contínuo no pod testado, mas informa que testou apenas um fluxo.
O modelo insere pontuação, letras maiúsculas e números, mas ainda erra nomes próprios e termos técnicos.

Capítulos

Início	Capítulo	Resumo
00:00	Apresentação do modelo e do teste	O autor apresenta o Audio8 ASR Infinite e explica que vai investigar se a janela deslizante permite transcrever áudio longo sem degradar.
01:05	Testes iniciais e limites de execução	O modelo não carrega no laptop com 8 GB de VRAM, então o autor aluga uma RTX 4090 e começa os testes com fala controlada, números e idiomas diferentes.
02:38	Áudios reais e falha em PyTorch	O autor avalia clipes do LibreSpeech e observa que a execução em PyTorch degrada após cerca de dois minutos de um áudio longo.
03:41	Janela deslizante e teste contínuo	Com vLLM, o mesmo áudio fica em 6% de erros e um teste contínuo de 34 minutos mantém a precisão e o uso de memória estáveis.
04:43	Custo, erros em nomes e conclusão	O autor estima o custo de um fluxo contínuo, mostra erros em nomes e jargões e resume os pontos fortes e as limitações do modelo.

Citações

A forma normal de executá-lo desmoronou depois de dois minutos. — 00:00

A parte infinita está no vLLM. — 03:10

Mesmo áudio: agora são 6%, e nenhum minuto passa de oito. — 03:41

Nomes e jargões são onde ele escorrega. — 05:14

Conceitos e entidades

Audio8 ASR Infinite (modelo): Modelo de reconhecimento automático de fala avaliado no vídeo, apresentado como capaz de processar fluxos longos com uma janela deslizante.
Edge Zero (empresa): Equipe associada ao Audio8 ASR Infinite na apresentação do vídeo.
vLLM (ferramenta): Ferramenta usada para executar o modelo com o mecanismo de janela deslizante que mantém o desempenho em áudios longos.
PyTorch (ferramenta): Framework usado para executar o modelo no teste que começou a falhar após cerca de dois minutos de áudio.
RunPod (empresa): Serviço pelo qual o autor alugou uma GPU RTX 4090 para realizar os testes.
RTX 4090 (modelo): GPU de 24 GB usada nos testes em nuvem.
LibriSpeech (repo): Conjunto de dados de fala do qual o autor selecionou seis clipes para avaliar a transcrição.
Apache License 2.0 (conceito): Licença indicada no vídeo para o Audio8 ASR Infinite.

Tradução completa (pt-BR)

00:00 Certo. Este é um modelo de fala para texto, e eu dei a ele 8 minutos e meio de áudio de uma só vez. A forma normal de executá-lo desmoronou depois de 2 minutos. A outra forma reduziu os erros para 6%. Vamos ver por quê. Ele se chama Audio8 ASR Infinite e é de uma equipe chamada Edge Zero. É um modelo de 4 bilhões de parâmetros, Apache 2.0, em inglês e chinês. Ele escuta como um fluxo 12 vezes e meia por segundo e escreve um token a cada vez. Por baixo dos panos, os ouvidos são a torre de áudio em tempo real Vox Troll, e a boca é o Qwen 2.5 3B. O modelo

00:32 tem 8,17 GB em BFloat16, então guarde esse número. Agora, a grande promessa na página é 24/7. O checkpoint só tem um contexto de 30 segundos, mas um cache deslizante supostamente mantém a memória e a latência estáveis para sempre. É isso que quero verificar. Então, o que fiz foi montar um plano. Primeiro, tentar no meu próprio laptop. Segundo, se não der certo, alugar uma GPU. E terceiro, jogar vários tipos de áudio nele e ver o que falha. Primeiro, meu laptop. É uma RTX 4060 com 8 GB. Os pesos ocupam 7,6 GB,

01:05 e o Windows já ocupa cerca de 1 GB da placa. Então, a memória livre aqui é 6,93. Mesmo assim, vamos tentar. O carregamento trava com uma violação de acesso duas vezes. Depois, carrego direto na GPU, e o sistema operacional diz que o arquivo de paginação é pequeno demais. Então, não dá neste laptop. Vamos alugar uma GPU. Aluguei uma RTX 4090 na RunPod, com 24 GB, por 74 centavos por hora. Instalei torch 2.13 e transformers 5.13, as versões exatas fixadas pelo repo.

01:36 Uma coisa deu errado: a parte antiga do torchaudio na imagem. Removi-a, e funcionou. No primeiro teste, criei uma frase com a minha própria voz clonada, então sei exatamente quais são as palavras, e dá para ver que ele acertou todas, incluindo as vírgulas e as letras maiúsculas. Zero erros. Em seguida, números e jargão. Eu disse 24 GB, e ele escreveu 24 em algarismos. Meu avaliador contou isso como um erro. Deu 17,9%; depois que corrigi o avaliador, caiu para 3,6%. Estou mostrando os dois números. Agora, em chinês, essa frase teve

02:08 zero erros. Depois, misturei chinês e inglês, com um número no meio, e ele falhou. Eu disse RTX 4090, e ele escreveu algo completamente diferente. Isso dá 20% de erros de caracteres. Agora, vamos dificultar. Com ruído rosa por cima, o final da frase se perde. Em uma parte, escreve “74 por hora”. Acelerando para 1,75 vez, 10% de erros. Áudio com qualidade de telefone, 5%. Então, o ruído é o ponto fraco aqui. Agora, pessoas de verdade: estes são seis trechos do LibreSpeech. Quatro dos seis ficam abaixo de

02:38 6%. O mais longo, um trecho de 30 segundos, ficou em 14%, e o pior é um trecho curto em que ele ouviu “Norris” em vez de “Norris”. A página deles informa 3,04% no conjunto limpo completo. Então, não vou afirmar nada que contradiga isso. Qual é a velocidade? Em PyTorch puro, na 4090, fica entre 0,8 e 0,9 vez o tempo real. Então, acompanha o ritmo, mas não é rápido. O pico de memória é de cerca de 8 GB, então cabe numa placa de 24 GB, sobrando bastante espaço. Agora, o teste importante: 8 minutos e meio de fala real em PyTorch puro. O primeiro

03:10 minuto vai bem, com 7% de erros. Depois de cerca de 2 minutos, desmorona. Daí em diante, só escreve “the the the”, com 89% de erros. Então, o caminho de PyTorch puro não é o infinito. A parte infinita está no vLLM. A forma oficial do repo é pelo Docker, mas um pod não consegue executar Docker, então instalei o vLLM 0.27.1 diretamente e configurei o plugin à mão. E estas são as três linhas de status que mostram que ele foi injetado: o agendador deslizante, o endpoint em tempo real e apenas uma rota em tempo real. Os mesmos 8 minutos e meio,

03:41 o mesmo áudio. Agora, são 6% de erros, e nenhum minuto passa de 8%. Entraram 1.150 palavras, saíram 1.150 palavras, e a memória da GPU ficou entre 10.428 e 10.438 MB o tempo todo. Certo, 8 minutos não são 24/7, então repeti o mesmo áudio quatro vezes: 34 minutos em um fluxo contínuo. A cada 2 minutos, os erros ficam entre 3% e 6,5%. No total, 5,4%. O tempo por etapa: 57 milissegundos no primeiro minuto. 58 no último minuto. A memória fica em 10.487, com um pico de cerca de 400 megabytes.

04:13 Também dá para trocar latência por precisão. Em 2 minutos de fala real, 240 milissegundos dão 8,2%; 327, 480, 6,7; 566,3. Então, cada aumento no tempo de espera traz um ganho cada vez menor. Há também um sinal semântico de fim de turno. Criei um trecho com 3 segundos de silêncio no meio e 5 segundos no final. Durante a pausa, a probabilidade fica em média em 0,8 e chega a 0,95. Enquanto estou falando, fica em torno de 0,1, com um pico de 0,64 em uma vírgula. Mas, para ser honesto, o silêncio puro

04:43 é o caso fácil. Não testei uma pausa para pensar. Mais uma coisa: o custo no RunPod. Foram necessários 451 segundos para processar 510 segundos de áudio. Então, é um pouco mais rápido que o tempo real, com um fluxo em uma 4090. Testei apenas um fluxo, então um fluxo 24/7 neste pod custa cerca de US$ 17,76 por dia. E mais um último teste, que é o meu favorito. Peguei a maior parte da narração deste próprio vídeo e dei ao modelo. Ele chegou a 6% de erros, e os erros são divertidos. Ouviu Vox Stroll como Vox Stroll, Quan como Kean e

05:14 Tor Giap Show como Tor Giap Tor Giap Portion. Então, é nos nomes e no jargão que ele escorrega. Os pontos positivos: Apache 2.0. Ele insere pontuação, letras maiúsculas e algarismos para você. O chinês saiu limpo, e a janela deslizante realmente funciona no vLLM. Os pontos negativos: não roda em um laptop com 8 GB. O caminho de PyTorch puro falha depois de 2 minutos. A mistura de idiomas com números falhou. E ele depende de versões exatas. É isso. Tudo o que mostrei é resultado real de uma execução real. A seguir, quero testar o cliente web deles com um microfone ao vivo e ver quantos

05:45 fluxos uma placa consegue suportar. Vejo vocês no próximo vídeo. Obrigado.

Transcrição original

[00:00] All right. So, this is a speech to text model, and I gave it 8 and 1/2 minutes of audio in one go. The normal way of running it fell apart after 2 minutes. The other way got it down to 6% errors. Let’s go ahead and see why. It’s called audio 8 ASR infinite from a team called Edge Zero. It’s a 4 billion parameter model Apache 2.0 English and Chinese. It listens as a stream 12 and 1/2 times a second and writes one token every time. Under the hood, the ears are the Vox Troll real-time audio tower, and the mouth is when 2.53 billion. The model

[00:32] file is 8.17 GB in BFloat16, so keep that number in your head. Now, the big claim on the card is 24/7. The checkpoint only has a 30-second context, but a rolling cash is supposed to keep memory and latency flat forever. That is the thing I want to check. So, what I’ve done is I’ve made a plan. One, try it on my own laptop. Two, if that fails, rent a GPU. And three, throw a lot of different audio at it and see what breaks. First, my laptop. This is an RTX 4060 with 8 GB. The weights are 7.6 GB,

[01:05] and Windows already holds about 1 GB of the card. So, free memory here is 6.93. Even so, let’s go ahead and try. The load crashes with an access violation twice. Then I load straight to the GPU, and the OS says the paging file is too small. So, it’s a no on this laptop. Let’s rent a GPU. So, I rented one RTX 4090 on RunPod, 24 GB, 74 cents an hour. I installed torch 2.13 and transformers 5.13, the exact versions the repo pins.

[01:36] One thing broke, the old tor git tor git portion in the image. I removed it, and it worked. First test, I made a sentence with my own cloned voice, so I know the exact words, and you can see it got every word right with the commas and the capital letters. Zero errors. Next, numbers and jargon. I said 24 GB, and it wrote 24 with digits. My scorer counted that as a mistake. 17.9% after I fixed the scorer, it’s 3.6. I’m showing you both numbers. Now, Chinese this sentence

[02:08] zero errors. Then I mixed Chinese and English with a number in the middle and this one falls over. I said RTX 4090 and it wrote something completely different. That’s 20% character errors. Now, let’s make it hard. Pink noise on top and the end of the sentence breaks it. Writes 74 an hour on one part. Speed it up 1.75 times 10%. Phone quality audio 5%. So, noise is the weak spot here. Now, real people, these are six clips from LibreSpeech. Four of the six are under

[02:38] 6%. The longest one, a 30-second clip, is 14 and the worst is a short clip where it heard Norris instead of Norris. Their card says 3.04% on the full clean set. So, I’m not going to claim anything against that. How fast is it? In plain PyTorch on the 4090 between 0.8 and 0.9 of real time. So, it keeps up, but it’s not fast. Peak memory is about 8 GB, so it fits on a 24 GB card with a lot of room left. Now, the important has 8 and 1/2 minutes of real speech in plain PyTorch. The first

[03:10] minute is fine, 7% errors. Then after about 2 minutes, it collapses. It just writes the the the 89% errors from there on. So, the plain PyTorch path is not the infinite one. The infinite part lives in vLLM. The repo’s official way is Docker, but a pod can’t run Docker, so I installed vLLM 0.27.1 directly and set the plugin by hand. And these are the three health lines that tell you it’s injected, the rolling scheduler, the real-time endpoint and only one real-time road. Same 8 and 1/2 minutes,

[03:41] same audio. Now, it’s 6% and no minute goes over eight. 1150 words in, 1150 words out and the GPU memory 10,428 to 10,438 MB the whole time. Okay, so 8 minutes is not 24/7, so I looped the same audio four times, 34 minutes in one continuous stream. Every 2 minutes stays between 3 and 6 and 1/2 percent. 5.4 overall, the step time. First minute, 57 milliseconds. Last minute, 58. Memory sits at 10,487 with one spike of about 400 megabytes.

[04:13] You can also trade delay for accuracy. On 2 minutes of real speech, 240 milliseconds gives 8. 2%, 327, 480, 6.7, 566.3. So, every extra bit of waiting buys you less and less. There’s also a semantic end-of-turn signal. I made a clip with a 3-second silence in the middle and 5 seconds at the end. In the gap, the probability averages 0.8 and peaks at 0.95. While I’m talking, it’s around 0.1 with one bump to 0.64 at a comma. Honest note though, plain silence

[04:43] is the easy case. I did not test a thinking pause. One more thing, cost on paste. It took 400 51 seconds to do 510 seconds of audio. So, a bit faster than real time, one stream on 14090. I only tested one stream, so a 24/7 stream on this pod is about $17.76 a day. And one last test, and this is my favorite. I took most of the narration of this very video and gave it to the model. It got it down to 6% and the mistakes are the fun ones. It heard Vox Stroll as Vox Stroll, Quan as Kean, and

[05:14] Tor Giap Show as Tor Giap Tor Giap Portion. So, names and jargon are where it slips. So, the good, Apache 2.0. It puts in punctuation, capitals, and digits for you. Chinese was clean and the rolling window really works in VLLM. The bad, it will not run on an 8-gig laptop. The plain PyTorch path breaks after 2 minutes. Mixed language with numbers failed. And it’s pinned to exact versions. So, that’s it. Everything I showed is real output from a real run. Next, I want to try their web client with a live microphone and see how many

[05:45] streams one card can hold. I will see you in the next one. Thank you.