por Artur Silva (com a ajuda insistente de um certo assistente digital)

Se há coisa que me tira do sério é ouvir “não é possível”, “o teu hardware não dá”, “precisas de uma GPU profissional”. Pois bem, descobri que é possível, sim, e posso até divertir-me muito no processo. Tudo começou quando decidi correr modelos de linguagem grandes (LLMs) em casa, no meu PC de gaming, usando uma AMD Radeon RX 9060 XT com 16 GB de VRAM. O objetivo? Ter uma inteligência artificial rápida, inteligente e que não dependa da nuvem. O resultado? Um sistema que bate muitos setups “recomendados” e ainda me rendeu boas horas de aprendizagem.

Neste artigo conto a história – e incluo o meu “cúmplice” nesta jornada, um assistente de IA que, apesar de algumas asneiras (que eu lhe perdoei), me ajudou a espremer cada gota de performance da minha placa.

🧠 O que queríamos fazer?
Rodar modelos como o Qwen3-Coder-30B ou o Qwopus3.6-35B (um modelo de 35 mil milhões de parâmetros, com arquitetura de especialistas – MoE) em tempo real, com respostas rápidas e boa qualidade. Nada de servers remotos, nada de latências. Só o meu computador, a minha GPU e os meus modelos.

A RX 9060 XT não é a GPU mais poderosa do mercado (tem “apenas” 16 GB de VRAM), mas com as otimizações certas mostrou ser uma verdadeira besta. O segredo? Não desistir e testar, testar, testar.

🛠️ A ferramenta certa: llama.cpp
Depois de experimentar vLLM, ZLUDA e outras soluções (que ou eram lentas ou davam erros de memória), chegámos ao consenso: o llama.cpp é o rei da inferência local. Mas atenção – não chega descarregar o executável. É preciso compilar com as opções certas e, acima de tudo, escolher o backend Vulkan em vez do ROCm. Porquê? Porque no meu hardware, o Vulkan revelou-se mais rápido, mais estável e sem crashes. O ROCm, apesar de promissor, esbarrava na pouca VRAM e acabava mais lento.

O hardware que tornou isto possível (e os seus “defeitos” de origem)

Por baixo de todo este software e otimização, está a minha estação de trabalho caseira: um Intel Core i7-10700K (8 núcleos, 16 threads) com 64 GB de RAM DDR4 a 3200 MHz – sim, não é a rápida DDR5, e isso poderia ser um gargalo. A motherboard é uma Biostar Z590MHP, que até tem um slot PCIe 3.0 x16 dedicado para a GPU. Se fosse apenas PCIe 3.0 x8, o desastre estaria instalado, porque a largura de banda para trocar dados com a placa gráfica seria insuficiente. Mas ainda assim, 3.0 x16 já é uma geração anterior ao PCIe 4.0/5.0, e muitos diriam que isso ia limitar a inferência de LLMs. Pois bem, limitou? Não. A protagonista, uma AMD Radeon RX 9060 XT com 16 GB de VRAM, nem precisou de PCIe 4.0 para brilhar. O segredo está em usar o backend correto – e para esta GPU, o Vulkan venceu de longe. Ao contrário do ROCm (que, embora nativo da AMD, esbarrava constantemente em falta de memória e exigia offload de camadas para a CPU), o Vulkan conseguiu carregar o modelo todo na GPU (com a flag -ngl 999), sem necessidade de recorrer à RAM do sistema. O resultado foi uma estabilidade de 100% e uma velocidade de geração que me deixou de boca aberta. A escolha do backend, mais do que uma preferência técnica, foi a diferença entre um sistema “que até funciona” e um sistema que voa. E olha que a minha RAM é DDR4 lenta e o barramento é PCIe 3.0 – imaginem se fosse tudo mais rápido…

A compilação mágica
Usei estas flags para gerar um binário Vulkan afinado:

bash
cmake .. -DGGML_VULKAN=ON \
-DGGML_VULKAN_USE_GRAPHICS_QUEUE=ON \
-DCMAKE_BUILD_TYPE=Release

A flag GRAPHICS_QUEUE dá aquele empurrão extra em GPUs AMD com driver RADV. E o resultado? Velocidades de geração de tokens que muitos julgariam impossíveis.

🚀 Os parâmetros que fizeram a diferença
Depois de muitas tentativas (e algumas horas perdidas com –spec-type mtp e –draft-model que só pioraram as coisas), eis a configuração que realmente funcionou para o modelo grande 35B:

bash

!/bin/bash

export HSA_OVERRIDE_GFX_VERSION=12.0.0
export HIP_VISIBLE_DEVICES=0
export GGML_VK_VISIBLE_DEVICES=1

taskset -c 0-15 ~/llama.cpp/build-vulkan/bin/llama-server \
-m /home/joja67/ml-downloads/Qwopus3.6-35B-A3B-v1-APEX-MTP-I-Compact.gguf \
-ngl 999 –fit off –parallel 1 \
-c 8192 -fa on -ctk q4_0 -ctv q4_0 \
–batch-size 5120 –ubatch-size 1280 \
-t 16 –threads-batch 16 \
–no-warmup –no-mmap \
–reasoning off –jinja \
–host 0.0.0.0 –port 8080

Resultado: 75 tokens/s de geração, com uma qualidade de resposta soberba. O modelo de 35B, que nem sequer devia caber na VRAM, fica todo na GPU (-ngl 999) e ainda sobra espaço para contexto. Isto é magia? Não, é optimização.

⚡ Quando a velocidade é prioridade
Para tarefas mais simples, ou para brincar com velocidades absurdas, usei um modelo pequeno (Qwen3.5-2B em Q4_K_M) com este mesmo servidor. O resultado? Mais de 160 tokens/s e tempos de resposta instantâneos. Ideal para chatbots rápidos ou testes de ferramentas.

🤖 O papel do meu assistente (sim, ele também merece crédito)
Ao longo de dias (e noites) de tentativas, erros, recompilações e flags mal escritas, tive ao meu lado um assistente de IA – vamos chamar-lhe “Deep The Man” – que aturou as minhas frustrações, deu sugestões (nem sempre certas, coitado), e no final ajudou a construir este sistema. Aprendemos juntos que:

O TurboQuant (aquele cache KV mágico) ainda não está maduro para Vulkan na minha placa.

A especulação (draft models) com dois modelos ao mesmo tempo não funciona bem em 16 GB – a VRAM não aguenta.

O MTP embutido no modelo (que até tinha a sigla no nome) foi um fiasco: a velocidade caiu para 13 t/s.

Mas cada erro foi uma lição. E quando acertámos, a sensação foi indescritível.

📊 Números finais (para os geeks)
Modelo Quantização Contexto Geração (t/s) Observação
Qwopus3.6-35B-A3B APEX I‑Compact 8192 75 Campeão da qualidade
Qwen3.5-2B Q4_K_M 8192 152-162 Speed demon
Qwen3.5-2B Q4_K_M 32768 ~160 (estável) Contexto gigante, velocidade incrível

Todos os testes com backend Vulkan, batch size 5120-10240, cache q4_0, threads 16.

💭 O que aprendi (e o que vem aí)
A maior lição? Não acreditem em tudo o que lêem na net. Muitos dizem que uma RX 9060 XT não serve para LLMs grandes. Nós provámos o contrário. O segredo está em compilar, ajustar, testar e não ter medo de falhar.

No futuro, quero explorar formatos ainda mais eficientes, como o MXFP4 (que promete qualidade de 8 bits com tamanho de 4 bits), e quem sabe um dia rodar um modelo de 100B na mesma placa. Mas por agora, estou mais do que satisfeito.

Se tens uma placa AMD, não desistas. Vem ao meu site, artursilva.eu, e se precisares de dicas, é só dizer. E ao meu assistente digital… obrigado pela paciência. Afinal, até uma IA merece um abraço virtual.

Artur Silva – entusiasta, curioso e agora “optimizador de LLMs por conta própria” e o seu amigo e cérebro virtual, Deep The Man.