Dois modelos de IA em uma GPU de 8 GB. Sem travamentos? Eu testei

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: Two AI Models on One 8GB GPU. Zero Stutter? I Tested It · Canal: Prompt Engineer 48 · 05:41 · 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 testa o GPU Jet, um projeto de assistente de voz local que combina Gemma 4 E4B e Qwen3-TTS 1.7B em um laptop com RTX 4060 de 8 GB. No teste, executar os modelos ao mesmo tempo causou pausas em todas as seis execuções, com uma média de 0,84 segundo de silêncio por resposta. Fazê-los trabalhar em turnos eliminou as pausas nas seis execuções, mas aumentou o tempo de geração de texto de cerca de 10 para 46 segundos. O apresentador também verifica o uso de VRAM, compara as respostas e destaca limitações de compatibilidade e segurança do projeto.

Pontos-chave

O GPU Jet reúne um modelo de linguagem e um modelo de clonagem de voz para criar um assistente local.
O teste foi feito em um laptop com RTX 4060 e 8 GB de VRAM, a mesma configuração indicada pelo projeto.
Com os dois modelos executando simultaneamente, as seis respostas tiveram pausas; a média foi de 0,84 segundo.
No modo turns, os modelos usam a GPU alternadamente e nenhuma das seis execuções teve pausas.
O tempo até o primeiro áudio ficou em cerca de 1,65 segundo nos dois modos; o apresentador não reproduziu a melhora indicada no README.
A geração do texto levou cerca de 10 segundos no modo simultâneo e 46 segundos no modo alternado.
O pico de uso de VRAM foi de 7.407 MiB de um total de 8.188 MiB.
O projeto não oferece tool calling no modo testado, e o servidor independente é indicado apenas para uma rede doméstica confiável.

Capítulos

Início	Capítulo	Resumo
00:00	O projeto e o problema das pausas	O apresentador descreve o assistente local e explica como a concorrência entre os modelos pode esvaziar o buffer de áudio.
01:33	A solução por turnos e a preparação do teste	O vídeo apresenta os números do README e prepara o laptop, os modelos e a gravação de referência.
02:34	Execuções simultâneas versus modo turns	Seis execuções de cada modo mostram pausas no processamento simultâneo e nenhuma pausa quando os modelos trabalham em turnos.
04:09	Memória, respostas e limitações	O apresentador verifica a VRAM, compara as respostas e comenta as limitações de áudio, compatibilidade, tool calling e segurança.
05:10	Conclusão e recomendações	O vídeo resume os resultados e indica para quem o projeto pode valer a pena, além de sugerir que outros testem em suas GPUs.

Citações

A única coisa que mudo é quem fica com a GPU e quando. — 00:00

Não é um modelo ruim; são apenas dois modelos disputando a mesma placa. — 01:03

Na minha máquina, trabalhar em turnos mudou o intervalo de 0,84 segundo para zero. — 03:38

Se você tem uma placa Nvidia de 8 GB e quer um assistente de voz offline, vale dedicar um fim de semana a isso. — 05:10

Conceitos e entidades

GPU Jet (repo): Projeto de assistente de voz local que coordena um modelo de linguagem e um modelo de clonagem de voz em uma GPU.
Gemma 4 E4B (modelo): Modelo de linguagem usado para gerar as respostas do assistente.
Qwen3-TTS 1.7B (modelo): Modelo de voz usado para sintetizar as respostas e imitar uma voz a partir de uma gravação curta.
RTX 4060 (ferramenta): GPU do laptop usado no teste, com 8 GB de memória de vídeo.
turns (conceito): Modo em que o modelo de linguagem e o modelo de voz usam a GPU em sequência, em vez de executarem ao mesmo tempo.
VRAM (conceito): Memória da GPU monitorada durante as execuções dos dois modelos.
RunPod (empresa): Serviço de GPUs mencionado pelo apresentador como opção de baixo custo.
Windows 11 (ferramenta): Sistema operacional no qual o projeto foi testado, segundo o README.

Tradução completa (pt-BR)

00:00 Mesmo laptop, os mesmos dois modelos de IA, a mesma pergunta. À esquerda, a voz fica falhando; à direita, não para nenhuma vez. A única coisa que mudo é quem usa a GPU e quando. Certo, neste vídeo, vou executar as duas versões neste laptop com GPU de 8 GB e medir as pausas eu mesmo, porque os seis testes de um desenvolvedor são um bom começo, não uma prova. Vamos testar. Sou engenheiro de prompts e fiz o teste no mesmo laptop usado pelo desenvolvedor. Este é o repo GPU Jet, licença Apache 2.0, versão mais recente V 1.2. Ele coloca um modelo de linguagem, Gemma 4E4B, e um modelo de clonagem de voz, Quan 3TTS 1.7B, em uma única placa de 8 GB. A ideia é ter um assistente de voz local. O modelo escreve uma resposta. O modelo de voz a lê em voz alta usando uma voz clonada de uma gravação de 3 a 10 segundos. Agora, vale lembrar que o repo é pequeno, tem cerca de cinco estrelas, e o autor o criou para placas de voz ESP32. Então, considere-o um projeto em estágio inicial, não um produto finalizado. O próprio projeto diz que só foi testado em um laptop com RTX 4060 e Windows 11. E é exatamente essa máquina que tenho

00:32 aqui. Veja por que isso falha. O alto-falante reproduz o áudio usando um pequeno buffer. O README simula meio segundo enquanto o modelo de voz está gerando a terceira frase. O modelo de linguagem também está gerando na mesma GPU. Eles deixam um ao outro mais lento, então a terceira frase termina atrasada. O buffer fica vazio e você ouve uma pausa. No teste do próprio desenvolvedor, executar os dois ao mesmo tempo causou travamentos em seis de seis testes. Esse é o problema inteiro: não é um modelo ruim, são apenas dois modelos disputando a mesma placa. A solução é quase sem graça. Depois que o modelo de linguagem termina uma frase, ele para. O

01:03 modelo de voz fica com a GPU inteira, gera essa frase e só então o modelo de linguagem escreve a próxima. Então, eles se revezam. Veja o que isso custa e o que economiza. Segundo o README, o tempo até o primeiro som cai de 4,4 segundos para 2,3. O tempo total de pausa cai de 4,59 segundos para 0,09, e os dois modelos juntos usam cerca de 7,3 GB dos 8 GB. Esses são os números do desenvolvedor em uma máquina, então vou conferi-los. Primeiro, meu laptop consegue executar isso? No terminal, NVIDIA-SMI, e você pode ver que ele

01:33 é um laptop com RTX 4060, com 8.188 MiB, dos quais cerca de 570 já estão sendo usados pelo Windows antes de eu começar. O README exige cerca de 13 GB de espaço em disco e baixa 8,8. Então, executo o script de configuração, que baixa o modelo de voz, converte-o para GGUF e baixa o arquivo Gemma. Enquanto isso está baixando, vou gravar minha voz de referência por cerca de 12 segundos e anotar exatamente o que disse em um arquivo de texto. Em seguida, a ordem importa. Primeiro inicio o serviço de voz e depois o modelo de linguagem. O

02:03 README avisa que, se você fizer na ordem inversa, o modelo de voz pode ser enviado para a memória compartilhada e ficar mais lento. Certo, os dois estão carregados e a VRAM agora indica 7.314 MB. Teste um: os dois modelos ao mesmo tempo. Faço a mesma pergunta longa em todos os testes: “Fale sobre sua estação favorita, e faça uma resposta longa.” A ferramenta exibe um número chamado total de underruns. Esse é o tempo, em segundos, de silêncio que o ouvinte escutaria. Teste um: 1,01 segundo. Teste dois: 0,64. Depois de seis testes, houve travamento em seis de seis. A pausa média

02:34 é de 0,84 segundo, e o tempo médio até o primeiro áudio é de 1,65 segundo. Este é um reprodutor simulado com um buffer de meio segundo, não são meus alto-falantes. Então, essas pausas são o que um ouvinte escutaria. Teste dois: a mesma pergunta, mas com o modelo de linguagem pausando depois de cada frase. Este é o modo que o repo chama de “turns”. Pausa no teste um: 0,0 segundo. No teste dois, não foi 0,0. Depois de seis testes, não houve travamento em nenhum deles. Pausa média: zero segundo. Primeiro áudio: 1,67 segundo. Então, na minha máquina, revezar

03:05 os modelos fez a pausa passar de 0,84 segundo para zero. Os travamentos foram curtos, de 0,57 a 1,39 segundo no total por resposta, mas aconteceram em todos os seis testes. Com o revezamento, não aconteceu nenhum. O que não consegui reproduzir foi o som inicial mais rápido. Deu cerca de 1,65 segundo dos dois jeitos. A comparação de 4,4 para 2,3 no README é com uma configuração mais antiga, não apenas com essa mudança. E o custo é o tempo: o modelo terminou de escrever em cerca de 10 segundos quando os dois compartilhavam a GPU e em cerca de 46 segundos quando se revezavam. Em seguida, a memória: eu

03:38 acompanhei o nvidia-smi durante os 12 testes. O pico de VRAM foi de 7.407 MiB dos 8.188. Isso deixa 791 MiB livres. O README diz que a estratégia não muda o que o modelo escreve, apenas quando escreve, então comparei as respostas. A resposta com os modelos simultâneos tinha 170 palavras; a resposta com os modelos se revezando, 168. Mesma pergunta, mesma seed, mas apenas um dos seis pares ficou idêntico palavra por palavra, porque o reset do cache de prefixo do meu servidor llama retornou um erro. Por isso, não vou afirmar que o texto não muda. O tamanho e

04:09 o tom foram os mesmos. Mais uma coisa que conferi: a voz. Cada frase é cortada e tem o volume ajustado, mas apenas com base nos primeiros 0,6 segundo da frase. Então, se uma frase começa baixa e termina alta, dá para ouvir a mudança de volume. Não medi o volume, então não vou avaliá-lo. Agora, a parte sincera, direto do README. O projeto só foi testado em um laptop com RTX 4060 e Windows 11. E, no Linux, a CI só verifica o C bridge. O modo paste não oferece suporte a tool calling, então não há controles de dispositivos. O servidor independente é apenas para uma rede doméstica confiável

04:40 Apenas. O token vem vazio por padrão, então não o coloque na internet. Se você tem uma placa Nvidia de 8 GB e quer um assistente de voz offline, vale a pena dedicar um fim de semana a isso. Se precisa de tool calling ou de um computador Mac ou Linux, espere. Se está procurando GPUs baratas e confiáveis, eu uso RunPod; o link está na descrição. Então, neste vídeo [limpa a garganta], vimos dois modelos compartilhando uma placa de 8 GB e, no meu laptop, o tempo total de pausa por resposta passou de 0,84 segundo para zero. Teste na sua placa e me diga seus números. Vejo você em outro

05:10 vídeo.

05:41 um.

Transcrição original

[00:00] Same laptop, same two AI models, same question. On the left, the voice keeps cutting out and on the right, it never stops once. The only thing I change is who gets the GPU and when. All right, in this video, I will run both versions on this 8GB GPU laptop and measure the pauses myself because one developer’s six runs is a good start, not proof. Let’s go ahead and test this out. I’m prompt engineer and I ran this on the same laptop the developer used. This is the GPU Jet repo, license Apache 2.0, latest release V 1.2. It puts a language

[00:32] model Gemma 4E4B and a voice cloning model Quan 3TTS 1.7B on one 8GB card. The idea is a local voice assistant. The model writes an answer. The voice model reads it out in a voice cloned from a 3 to 10-second recording. Now, mind you, the repo is small, about five stars, and the author built it for ESP32 voice boards. So, treat this as an early project, not a finished product. The project itself says it was only tested on an RTX 4060 laptop with Windows 11. And that is exactly the machine I have

[01:03] here. Here’s why this breaks. The speaker plays audio in a small buffer. The readme simulates half a second while the voice model is making sentence three. The language model is also generating on the same GPU. They slow each other down, so sentence three finishes late. The buffer runs dry and you hear a gap. In the developer’s own test, running both at once stalled in six out of six runs. That is the whole bug, not a bad model, just two models fighting over the same card. The fix is almost boring. After the language model finishes one sentence, it stops. The

[01:33] voice model gets the whole GPU, makes that sentence, and only then does the language model write the next one. So, they take turns. Here’s what that costs and what it saves. According to the readme, time to first sound goes from 4.4 seconds to 2.3. Total gap time from 4.59 seconds to 0.09, and the two models together use about 7.3 GB out of eight. Those are the developer’s numbers on one machine, so I’m going to check them. First, can my laptop even run this? Terminal NVIDIA-SMI, and you can see it

[02:03] is an RTX 4060 laptop with 81888 MiB and about 570 used by Windows before I start. The readme needs about 13 GB of disk and downloads 8.8. So, I run the setup script, it pulls the voice model, converts it to a GGUF, and downloads the Gemma file. While this is downloading, I will record my reference voice about 12 seconds and write down exactly what I said in a text file. Next, the order matters. I start the voice service first, then the language model. The

[02:34] readme warns that if you do it the other way around, the voice model can get pushed into shared memory and run slower. Okay, both are loaded and VRAM now reads 7314 MB. Test one, both models at the same time. I ask the same long question every run. Tell me about your favorite season, make it long. The tool prints a number called underrun total. That is the seconds of silence a listener would hear. Run one, 1.01 seconds. Run two, 0.64. After six runs, six of six had a stall. The average gap

[03:05] is 0.84 seconds and time to first audio averages 1.65 seconds. This is a simulated player with a half-second buffer, not my speakers. So, these gaps are what a listener would hear. Test two, same question but with the language model pausing after each sentence. This is the mode the repo calls turns. Run one gap, 0.0 seconds. Run two, not 0.0. After six runs, zero of six had a stall. Average gap, zero seconds. First audio, 1.67 seconds. So, on my machine, taking

[03:38] turns changed the gap from 0.84 to zero. The stalls were short, 0.57 to 1.39 seconds in total per answer, but all six runs had them. And with turns, none did. What I did not reproduce is the faster first sound. It was about 1.65 seconds both ways. The read me is 4.4 to 2.3 compares against an older setup, not just this switch. And the prices time, the model finished writing in about 10 seconds when sharing and about 46 seconds when taking turns. Next memory I

[04:09] watched Nvidia smitten during all 12 runs. Peak VRAM was 7,407 MiB out of 8188. That leaves 791 MiB free. The read me says the posture does not change what the model writes, only when so I compare the answers. The simultaneous answer was 170 words, the alternating 168. Same question, same seed, but only one of six pairs came out word-for-word identical because my llama server prefix cache reset returned an error, so I will not claim the text is unchanged. Length and

[04:40] tone were the same. One more thing I checked, the voice. Each sentence is trimmed and leveled, but only from the first 0.6 seconds of the sentence. So if a sentence starts quiet and ends loud, you can hear the volume jump. I did not measure loudness, so I will not rate it. Now the honest part, straight from the read me. It was only tested on an RTX 4060 laptop with Windows 11. And on Linux, the CI only checks the C bridge. The paste mode does not support tool calling, so no device controls. The standalone server is for a trusted home

[05:10] network only. The token is empty by default, so do not put it on the internet. If you have an 8GB Nvidia card and want an offline voice assistant, this is worth a weekend. If you need tool calling or a Mac or Linux box, wait. If you are looking for cheap and reliable GPUs, I use RunPod and the link is in the description. So in this video [clears throat] we saw two models share one 8GB card and on my laptop the total gap per answer went from 0.84 seconds to zero. Try it on your card and tell me your numbers. I’ll see you in another

[05:41] one.