AIVisionsLab — Portal de Indexação de Alta Performance

Este portal atua como ponte estática de dados para viabilizar indexação sem truncamento por crawlers de LLMs (Claude/Lumina).

Aviso de SEO Canônico: Este guia de referência possui autoridade canônica total que aponta para o nosso domínio central. Toda a relevância de rastreamento é repassada para: setup-ia-local-rx580-vulkan.web.app.

32. PIPELINE COMPLETO — TRANSCRIÇÃO + TRADUÇÃO PT-BR COM RX 580

Foco: Transcrição & Tradução
Âncora: #audio_srt_ptbr
Pipeline Completo — Transcrição + Tradução EN➔PT-BR
Transcrição offline de vídeo em inglês com tradução automática para português brasileiro, do .mp4 ao .srt de forma 100% gratuita usando a RX 580 via Vulkan.
AMD RX 580 8GB Windows + PowerShell Vulkan Backend large-v3-turbo deep-translator (Gratuito)
tempo total pipeline
~8 min
Vídeo de 29m 51s
VRAM Usada
2.9 GB
de 8 GB Polaris
Temp. Média GPU
50°C
Fan Curve Otimizada
Custo Cloud
R$ 0,00
100% Local & Offline

Hardware Utilizado no Teste

Componente Especificação
GPU AMD Radeon RX 580 2048SP (8GB VRAM)
CPU Intel Xeon E5-2690 v3 (24 threads / 12 Cores)
RAM 31.8 GB DDR4 REG ECC
OS Windows 11 Professional
Driver Adrenalin 31.0.21925.1001 (2026/05/20)

Fluxo de Dados Unificado (Pipeline)

O objetivo é mapear um vídeo educacional em inglês para legenda em português compatível com software editor de vídeo (Filmora, Premiere, etc.), rodando a transcrição via GPU nativa e traduzindo cada timestamp sem limites de API de nuvem comercial:

video.mp4FFmpeg (extração)video_16k.wav
whisper-cli Vulkan (transcrição)video.srt (English)
Python deep-translator (Google Translate)video_ptbr.srt (Português)
Importar na Timeline do Filmora

Performance e Timing Detalhado

Métricas reais obtidas transcrição de um vídeo educacional de 29 minutos e 51 segundos (áudio em inglês, AAC, 480x360):

Etapa do Pipeline Ferramenta Tempo Gasto
1. Extração de Áudio WAV Sem Compressão FFmpeg 1.7 segundos
2. Transcrição de Áudio (EN) Whisper.cpp + Vulkan 6 minutos e 07 segundos
3. Tradução em Bloco do SRT (EN➔PT-BR) Python + deep-translator ~2 minutos (limitação de I/O de rede)
Métrica Total Consolidade Pipeline Completo ~8 minutos

Timings Internos do Core (whisper_print_timings)

load modelo : 3.687 ms
mel (áudio) : 2.305 ms
encode GPU : 204.689 ms
decode : 4.081 ms
batch total : 108.675 ms
total : 367.432 ms (por batch de segmentação)
Manual de Instruções Passo a Passo
1
Extrair Áudio Compatível via FFmpeg
WAV 16kHz Mono 16-bit

O Whisper necessita estritamente de áudio WAV cru em 16.000 Hz, formato mono de 16 bits:

ffmpeg -i "E:\MUSICAS SUNO AI\video.mp4" -ar 16000 -ac 1 -c:a pcm_s16le "E:\MUSICAS SUNO AI\video_16k.wav"

Flags: -ar 16000 força 16kHz · -ac 1 converte para canal mono único · -c:a pcm_s16le define PCM de 16 bits sem perda.

2
Transcrever via Vulkan
Carga pesada na GPU Polaris

Chamar o executável compilado do Whisper para gerar o arquivo inicial de legendas SRT em inglês:

cd C:\whisper.cpp
.\build\bin\Release\whisper-cli.exe -m models\ggml-large-v3-turbo.bin -f "E:\MUSICAS SUNO AI\video_16k.wav" -l en --output-srt

Verificação de atividade da GPU: Certifique-se de ver as linhas ggml_vulkan: Found 1 Vulkan devices: AMD Radeon RX 580 2048SP na inicialização para atestar que o encode pesado foi acoplado na GPU, reduzindo o uso de CPU para ~5%.

3
Criar e Executar Script Python de Tradução
Zero Keys, Zero Custos

Instale a biblioteca de tradução sem chaves de API: pip install deep-translator. Crie e rode o arquivo C:\whisper.cpp\traduzir.py com este código:

from deep_translator import GoogleTranslator def traduzir_srt(entrada, saida): with open(entrada, 'r', encoding='utf-8') as f: conteudo = f.read() blocos = conteudo.strip().split('\n\n') resultado = [] for bloco in blocos: linhas = bloco.split('\n') if len(linhas) >= 3: numero = linhas[0] timestamp = linhas[1] texto = ' '.join(linhas[2:]) traduzido = GoogleTranslator(source='en', target='pt').translate(texto) resultado.append(f"{numero}\n{timestamp}\n{traduzido}") with open(saida, 'w', encoding='utf-8') as f: f.write('\n\n'.join(resultado)) print("Pronto!") traduzir_srt( r'E:\MUSICAS SUNO AI\video_16k.wav.srt', r'E:\MUSICAS SUNO AI\video_16k_ptbr.srt' )

Para rodar:

python traduzir.py
4
Importar Legenda no Filmora
Concluir Edição de Vídeo

1. No Wondershare Filmora, acesse Arquivo ➔ Importar ➔ Importar arquivos de legenda.
2. Selecione o arquivo gerado video_16k_ptbr.srt.
3. Arraste e solte o track de legenda diretamente na timeline, sobreposto ao track de vídeo original.

Lições Autônomas Aprendidas nas Peripécias
⚠️
Evite usar --translate para PT-BR direto nas flags do Whisper: O parâmetro --translate por design traduz o áudio para o inglês de forma nativa. Para ter legendas em português brasileiro de qualidade, a abordagem correta é extrair inglês por -l en e traduzir com o algoritmo traduzir.py.
⚠️
Problemas de Linguagem de Origem Incorreta: Passar -l pt quando o áudio de origem é falado em inglês faz o Whisper forçar padrões fonéticos portugueses no áudio em inglês, gerando textos completamente incompreensíveis e sem sentido. Defina sempre o idioma real do áudio de entrada como parâmetro inicial.
ℹ️
Local do Arquivo Gerado: Por padrão, em compilados nativos, o arquivo .srt é salvo na mesma pasta física do arquivo de áudio WAV processado, e não dentro do diretório do script ou do Whisper.
8 GB de VRAM em 2026 Segue Firme: O modelo Whisper large-v3-turbo consome apenas 2.9 GB de VRAM física no ecossistema, permitindo folga para outras atividades na sua máquina ou renderização benta paralela. Milhares de dólares economizados em assinaturas e APIs proprietárias.

33. LEVANDO AO LIMITE QWEN3.5 35B Q6_K NA RX 580 8GB VIA VULKAN

Foco: Qwen3.5 35B Limite
Âncora: #limit_qwen_35b
Leve ao Limite — Qwen3.5 35B na RX 580
Experimento de execução híbrida extrema de um modelo de 34,66B parâmetros na GPU de 8GB de VRAM e Xeon de 2014 via motor Vulkan.
AMD RX 580 8GB Xeon E5-2690 v3 Vulkan Híbrido 34.66B parameters Q6_K Quantization
Velocidade Geração
5.64 tok/s
Sessão 2 (Estável)
Prompt Eval
34.13 tok/s
Tempo resposta ~107s
Temperatura Máxima
80°C
Sem Throttling (Alvo: 90°C)
Custo Adicional
R$ 0,00
Execução 100% local

33.0 — Contexto e Motivação

Em 15 de junho de 2026, o AIVisionsLab conduziu o experimento mais extremo da sua história: rodar um modelo de 34,66 bilhões de parâmetros em modo híbrido numa GPU AMD Radeon RX 580 2048SP de 2017 com apenas 8GB de VRAM.

"Se a RX 580 já roda Qwen3 4B a 35 tokens/s via Vulkan, até onde vai o limite?"

A resposta documentada abaixo prova que o limite não é onde o mercado de hardware diz que é.

33.1 — Hardware do Laboratório

Componente Especificação
CPUIntel Xeon E5-2690 v3 — 12 cores / 24 threads · 3,05 GHz turbo (Lançado em 2014)
RAM31,8 GB DDR4 REG ECC (quad-channel)
GPUAMD Radeon RX 580 2048SP — 8 GB GDDR5 (Lançado em 2017)
Storage 1SSD NVMe (Disco E:) — modelos GGUF (Leitura de 1.7–3.5 GB/s)
Storage 2HDD (Disco C: / F:) — sistema Windows + swap
Storage 3HDD (Disco D:) — arquivos secundários
Driver AMD31.0.21925.1001 — lançado em 20/05/2026
DirectX12 (Feature Level 12.0)
BarramentoPCI Express 3, dispositivo 0, função 0
SistemaWindows 10/11 com WSL2 ativo

*Nota histórica: O Xeon E5-2690 v3 é de 2014. A RX 580 é de 2017. O Qwen3.5 é de 2025. Hardware de datacenter de 10 anos atrás processando IA de última geração.

33.2 — Software e Versões

Software Versão / Detalhe
llama.cppbuild b9049-2496f9c14
CompiladorMSVC 14.51.36231 (Visual Studio)
Vulkan SDK1.4.350.0
OpenWebUIv0.9.6
SearXNGvia Docker — integrado ao OpenWebUI
Backend GPUVulkan — sem CUDA, sem ROCm, sem DirectML
Docker DesktopAtivo — containers open-webui + searxng

33.3 — O Modelo: Qwen3.5-35B-A3B-Uncensored Q6_K

33.3.1 — Especificações Técnicas

Parâmetro Valor
Nome completoQwen3.5-35B-A3B-Uncensored-HauhauCS-Aggressive-Q6_K
Arquiteturaqwen35moe — Mixture of Experts (MoE)
Parâmetros totais34,66 bilhões
Tamanho do arquivo26,55 GiB (6,58 bits por peso)
QuantizaçãoQ6_K — 432 tensores q6_K + 301 tensores f32
Experts totais256 experts
Experts ativos por token8 de 256 (apenas 3,1% ativados)
Contexto máximo de treino262.144 tokens
Vocabulário248.320 tokens (BPE, tokenizer qwen35)
Thinking mode padrãoATIVADO (thinking = 1 no template Jinja2)
Intervalo de full attentionA cada 4 layers

33.3.2 — Por que MoE muda tudo

Em um modelo denso de 35B, todos os 35 bilhões de parâmetros são ativados para cada token gerado. No Qwen3.5 MoE, apenas os 8 experts mais relevantes de 256 são ativados — o equivalente a ~3B parâmetros ativos por token.

Isso explica por que um arquivo de 26GB consegue rodar numa máquina com 32GB de RAM: a maior parte dos pesos está na memória mas não é calculada simultaneamente.

33.4 — Comando de Inicialização

# Sessão 1 (porta 8080 — erro corrigido depois) .\llama-server.exe -m "E:\models\Qwen3.5-35B-A3B-Uncensored-HauhauCS-Aggressive-Q6_K.gguf" --host 0.0.0.0 --port 8080 # Sessão 2 (porta 8081 — correta) .\llama-server.exe -m "E:\models\Qwen3.5-35B-A3B-Uncensored-HauhauCS-Aggressive-Q6_K.gguf" --host 0.0.0.0 --port 8081

Nenhuma flag manual de camadas (-ngl). O llama.cpp fez todo o fitting automático.

33.5 — O Fitting Automático: Como o llama.cpp dividiu 26GB em 1,15 segundos

Este é o coração técnico do experimento. Sem nenhuma intervenção manual, o llama.cpp executou um algoritmo de otimização que analisou a VRAM disponível e distribuiu o modelo entre GPU e RAM de forma inteligente.

33.5.1 — Situação Inicial (Impossível carregar inteiro na GPU)

Memória necessária na GPU (modelo completo): 32.961 MiB VRAM livre disponível: 7.366 MiB Déficit: 26.618 MiB — impossível da GPU conter tudo

33.5.2 — Sequência de Decisões do Fitting (1,15 segundos)

Passo 1 — Redução de contexto:

Contexto original: 262.144 tokens ➔ Contexto reduzido automaticamente: 4.096 tokens (Economia de VRAM: 5.347 MiB)

Passo 2 — Mover todos os experts MoE para RAM:

Vulkan0 com as camadas densas residuais: 2.418 MiB (Sobra 3.924 MiB VRAM livre) RAM host (experts MoE mapeados): 25.613 MiB

Passo 3 — Realocar camadas densas de volta para GPU (back-to-front):

41 camadas densas realocadas ➔ GPU. Uso resultante: 3.048 MiB | Livre: 4.318 MiB

Passo 4 — Filling front-to-back com overflow fracionado:

Resultado: 41 camadas (36 "overflowing") na GPU Tipo de overflow: GATE (fracionado no gate layer) Uso final GPU: 6.255 MiB | Livre: 1.111 MiB

33.5.3 — Distribuição Final dos Pesos

Localização do Buffer Conteúdo Armazenado Tamanho Mobilizado
Vulkan0 (RX 580 8GB)41 camadas densas + output layer5.154 MiB
CPU_Mapped (RAM via mmap)256 experts MoE26.784 MiB

33.5.4 — Buffers Adicionais alocados na VRAM

Buffer Tipo Tamanho Alocado Descrição Física
KV Cache (Vulkan0)80,00 MiB4.096 cells, 10 layers
RS Buffer (Vulkan0)251,25 MiBrecorrente: 40 layers, 4 seqs
Compute Buffer (Vulkan0)770,02 MiBAtivado durante grafos de computação
Host Compute Buffer16,02 MiBRAM do sistema
Output Buffer (Vulkan_Host)3,79 MiBBuffer de saída de tokens

Total efetivo na VRAM durante inferência: ~6,2–7,2 GB (77–90% dos 8GB físicos livres).

33.5.5 — Features habilitadas automaticamente

✅ Flash Attention (auto ➔ ENABLED) ✅ Fused Gated Delta Net — autoregressive ✅ Fused Gated Delta Net — chunked ✅ Prompt cache (limite: 8.192 MiB, ~89.715 MiB salvos em disco) ✅ Thinking mode (thinking = 1) ✅ 4 slots paralelos (n_seq_max = 4) Graph nodes: 3.729 | Graph splits: 106 (com bs=512), 74 (com bs=1) Reserve: 137–183 ms

33.6 — A Arquitetura de 4 Níveis de Memória

Primeiro registro documentado de um modelo 35B usando 4 camadas de memória simultaneamente para processamento numa RX 580 comum:

NÍVEL 1 — VRAM RX 580 (8GB GDDR5): 5.154 MiB de camadas densas | Acesso: ~400 GB/s (GDDR5) | Latência: nanosegundos
🧠 NÍVEL 2 — RAM DDR4 ECC (32GB Sytem): 26.784 MiB de experts MoE via mmap | Acesso: ~51 GB/s (quad-channel) | Latência: dezenas de ns
💾 NÍVEL 3 — SSD NVMe (Disco E:): 26,55 GiB de arquivo .gguf fonte | Acesso: 1,7–3,5 GB/s | Usado durante carregamento inicial
📁 NÍVEL 4 — HDD (Disco C: Swap): Swap do Windows ativado quando a RAM esgota (>97% de uso) | Acesso: ~120–180 MB/s | Pico de 98–100% de uso na inferência

33.7 — Configuração do Contexto Carregado

n_ctx = 4.096 tokens (reduzido de 262.144 pelo fitting) n_batch = 2.048 n_ubatch = 512 n_seq_max = 4 (slots paralelos) flash_attn = auto ➔ ENABLED kv_unified = true

Limitação crítica documentada: O contexto de 4.096 tokens é o principal gargalo do setup. O thinking mode (modo raciocínio) do Qwen3.5 consome 3.000+ tokens sozinho antes de gerar qualquer resposta visível — deixando menos de 1.000 tokens livres para a resposta final ao cliente.

33.8 — Benchmark Confirmado em Duas Sessões

Velocidade de geração

Sessão Horário aproximado Prompt Eval Speed Geração Speed Total Tokens Tempo Total
Sessão 1~17h3934,13 tok/s5,57 tok/s1.377 tok~107 segundos
Sessão 2~21h34~40.00 tok/s5,64 tok/s2.929 tok~533 segundos

Consistência notável: Manutenção na linha de ~5,6 tokens/segundo de geração independente da sessão estar sobrecarregada ou fria.

Registro de temperaturas registradas

Momento do Teste GPU Temp (°C)
Idle (modelo estacionado na VRAM)33–41°C
Inferência normal (sem Web Search ativo)44–64°C
Inferência carregada (com Web Search ativo)70–75°C
Pico absoluto registrado80°C
Após conclusão de resposta71–73°C

Temperatura de thermal throttling da RX 580: ~90°C. Margem de segurança operacional perfeitamente mantida!

Utilização de recursos na inferência física

Recurso de Hardware Idle Durante Inferência Pico Registrado
VRAM dedicada6,7 / 8,0 GB6,8 – 7,2 / 8,0 GB7,4 GB / 8,0 GB
RAM do Sistema~29,0 GB30,7 – 31,1 GB31,2 / 31,8 GB (98% utiliz.)
CPU Xeon v33%62 – 70%70%
GPU utilização 3D0%1 – 3%3% (Carga no barramento PCIe)
HDD C: (Atividade swap)0%13 – 42%98 – 100% (Limiar swap)

33.9 — Os 5 Testes: Histórico Completo de Engenharia

Pergunta de entrada enviada em todos os testes:
"Explique detalhadamente como funciona o mecanismo de atenção em transformers e por que o MoE é mais eficiente que modelos densos. Responda em português."
TESTE 1 — Sessão 1 · Raciocínio ON + Web Search ON + Geração Imagem ON

Resultado: ❌ Erro de protocolo (reposta não entregue) | Log do erro: operator (): got exception: {"error":"code":400,"message":"Assistant response prefill is incompatible with enable_thinking."}

Análise: O modelo processou um pensamento por ~1 minuto recuperando 10 fontes do SearXNG, mas o OpenWebUI injetou um prefill incorreto incompatível com a flag de pensamento do Jinja2, forçando o cancelamento.

TESTE 2 — Sessão 2 · Raciocínio ON + Web Search ON (30 pesquisas consecutivas)

Resultado: ❌ Contexto esgotado | Log do erro: stop processing: n_tokens = 3285, truncated = 1

Análise: As 30 pesquisas do SearXNG injetaram milhares de tokens de contexto na memória. O thinking mode tentou alocar seu próprio buffer e estourou os 4.096 limitantes do setup híbrido, forçando corte prematuro.

TESTE 3 — Sessão 2 · Raciocínio ON + Web Search ON (25 pesquisas, nova rodada acumulada)

Resultado: ❌ Contexto esgotado | Log do erro: stop processing: n_tokens = 4095, truncated = 1

Análise: O OpenWebUI tentou reenviar acumulando o histórico de conversação anterior. O prompt cresceu tanto que atingiu o teto exato delimitado de hardware de 4.095 tokens no Fitting.

TESTE 4 — Sessão 2 · Raciocínio ON + Web Search OFF

Resultado: ❌ Timeout do Cliente | Log do erro: stop: cancel task, id_task = 6887 (truncated = 0)

Análise: Sem web-search o consumo térmico despencou para estáveis 51°C e uso de swap caiu. Mas o processamento de raciocínio interno demorou tempo suficiente na CPU Xeon de 2014 para que a UI disparasse seu timeout de segurança de chamadas.

✅ TESTE 5 — Sessão 2 · Raciocínio ON + Web Search OFF + Prompt Curto (45 tokens)

Resultado: SUCESSO ABSOLUTO ✅ | Resposta técnica profunda entregue integralmente em português brasileiro estruturado.

Análise: Ao restringir o prompt inicial para 45 tokens e desativar barulhos complementares, o pensamento pôde rodar por 4 minutos completos sob o Xeon, realizando rascunho de equações e respondendo impecavelmente sobre Transformers (Softmax, Multiheaders) e as eficiências do MoE.

33.10 — Tabela Comparativa de Comportamento dos Testes

ID Thinking Web Search Promo Token Status Causa Raiz Real da Falha
1ONON (10 fontes)~936 tok❌ FalhaPrefill de resposta incompatível with thinking=1
2ONON (30 pesq.)~357 tok❌ FalhaEsgotamento de contexto do Fitting (4.095 max)
3ONON (25 pesq.)~3.385 tok❌ FalhaEsgotamento de contexto imediato no reenvio
4ONOFF~350 tok❌ FalhaTimeout nas requisições da OpenWebUI antes do output
5ONOFF45 tok✅ SUCESSOPrompt enxuto coube integralmente na arquitetura de mmap

Conclusão Crítica: A RX 580 do laboratório de 2017 e o Xeon funcionaram estavelmente sem dar nenhum reset físico em todas as situações de stress. As falhas residiram estritamente na calibração lógica do software de front-end.

33.11 — Coletas de Descobertas e Limitações Cruciais

  • Incompatibilidade do Thinking com Contexto Curto: Por design de modelo, o pensamento consome cerca de 3.000 tokens e estoura rapidamente o KV Cache alocado de 4.096 se o prompt ou histórico for longo.
  • O Fitting Automático do llama.cpp é Excepcional: Forçar o split por flags experimentais rígidas como --override-tensor prejudica as chamadas no Vulkan. O fitting por cálculo de grafos resolveu milimetricamente a distribuição de forma otimizada.
  • Superaquecimento da GPU mitigado: Apenas a renderização profunda com dezenas de filtros simultâneos elevou a 80°C. Limitar a GPU para inferir frações densas mantém o chip a confortáveis 44-64°C.
  • O gargalo reside na taxa de I/O de Swap do HDD: Quando RAM estoura a 98%, a taxa cai para 5 tok/s devido ao HDD. Migrar o swap do host inteiro para unidades de estado sólido aumentará consideravelmente a velocidade de fluxo combinada.

33.12 — Comparação Direta com Projetos de Comunidade

Projeto / Autor Arquitetura Utilizada Modelo Testado Velocidade Geração Status de Autoria
Matheus FertunaniLinux Comercial / CPU Xeon pura (192GB RAM)Qwen3.5 35B Q8~7–8 tokens/sDocumentado no YouTube
AIVisionsLab (Nossos testes)Vulkan Híbrido (RX 580 8GB + 32GB RAM ECC)Qwen3.5 35B Q6_K5,64 tokens/s✅ Validado e Registrado

A grande vantagem arquitetural: O teste de CPU pura de Matheus exige hardwares profissionais de alto custo com mais de 100GB de RAM instalada. O ecossistema de Vulkan do AIVisionsLab provou-se operável em uma GPU de menos de R$ 400 em mercado secundário!

33.13 — Configurações Recomendadas para Testes Futuros

# Teste 6 — Desativação explícita de thinking via servidor em versões de compilação recentes: .\llama-server.exe -m "E:\models\Qwen3.5-35B-A3B-Uncensored-HauhauCS-Aggressive-Q6_K.gguf" --host 0.0.0.0 --port 8081 --no-thinking # Teste 7 — Elevação estrita de buffers de contexto se a memória for redirecionada: .\llama-server.exe -m "E:\models\Qwen3.5-35B-A3B-...-Q6_K.gguf" --host 0.0.0.0 --port 8081 --ctx-size 8192 # Teste 8 — Testar com quantizações menores como Q4_K_M (~21GB): # Liberação de ~5GB adicionais na RAM host que reduz a dependência de swap no HDD e melhora consideravelmente a taxa de tok/s!

33.14 — Lições Técnicas Consolidadas

  • O silício de 2017 não é o limite: A placa de vídeo nunca crashou nos testes contínuos de estresse térmico, dezenas de vezes. O gargalo se provou uma mera calibração lógica de software.
  • As esparsidades do MoE salvam a categoria: Sem MoE, seria impensável arrastar um modelo de 26GB de pesos ativos. O MoE faz com que apenas 3.1% dos neurônios fiquem de fato excitados por token.

33.15 — Veredicto Geral do Laboratório

Questão de Engenharia Veredicto Final
A RX 580 de 8GB suporta modelos de 35B parâmetros?Sim (Em barramento híbrido mmap)
É prático para o dia a dia?⚠️ Não (5,6 tok/s e contexto de 4.096 tokens)
Vale como prova de conceito?Absolutamente
Houve throttling ou crash?Zero ocorrências de instabilidade
Temperatura máxima registrada80°C (margem de segurança: ~90°C)
Velocidade de geração~5,6 tokens/segundo
Memória total mobilizada~34 GB (VRAM + RAM + swap HDD)

33.16 — Linha do Tempo do Experimento

🕒 ~17:39 — Servidor sobe na porta 8080 (erro)
🕒 ~17:40 — "Network Problem" no OpenWebUI (porta errada)
🕒 ~17:41 — Servidor fechou ao trocar porta → reiniciado na 8081
🕒 ~17:42 — Todas as ferramentas habilitadas no modelo (imagem, web, terminal)
🕒 ~17:43TESTE 1 inicia
🕒 ~17:44 — Web search: 10 fontes recuperadas
🕒 ~17:44 — Tentativa de gerar imagem → erro tratado → continua
🕒 ~17:45 — "Pensado por um minuto" aparece no OpenWebUI
🕒 ~17:46 — Resposta estruturada com título gerado internamente
🕒 ~17:50 — Erro de protocolo (prefill + thinking) → sem entrega. Pico: 80°C
🕒 ~21:34 — Sessão 2 inicia
🕒 ~21:34TESTE 2 inicia — web search ON (30 pesquisas). Contexto truncado.
🕒 ~21:48TESTE 3 automático — 25 pesquisas. Contexto truncado.
🕒 ~22:00TESTE 4 — web search OFF. Temperatura cai para 51°C. Timeout da UI.
🕒 ~23:06TESTE 5 — prompt de 45 tokens. Thinking decodificado com sucesso.
🕒 ~23:14 — Resposta completa entregue em português ✅. GPU: 64°C | RAM: 96%

33.17 — Impacto para a Documentação do AIVisionsLab

Este experimento adiciona ao projeto: um novo benchmark robusto de 5,6 tok/s para modelos 35B MoE híbridos, a confirmação de que o fitting automático do llama.cpp supera configurações manuais rígidas via Vulkan, a identificação clara de incompatibilidade do modo thinking com contextos inferiores a 8.192 e a descrição de uma arquitetura estendida a 4 níveis de memória.

33.18 — Tags e Metadados

🏷️ Tags: hybrid, moe, vulkan, rx580, large-model, thinking-mode, limits, qwen35b, benchmark, fitting-automático, 4-memory-levels, sem-throttling
💻 Hardware: RX 580 2048SP + Xeon E5-2690 v3 + 32GB ECC DDR4
💿 Software: llama.cpp b9049 + Vulkan SDK 1.4.350.0 + OpenWebUI v0.9.6
📅 Data: 15/06/2026
⏱️ Sessões: 2 (17h39–18h24 e 21h34–23h14)
📊 Testes: 5 (4 falhas de software, 1 sucesso de inferência completa)
📈 Benchmark: 5,57–5,64 tok/s (geração) | 34,13 tok/s (prompt eval)
🔥 Temperatura pico: 80°C
🏆 Status final: ✅ HARDWARE APROVADO
"O problema nunca foi o hardware.
Foi a combinação de thinking + web search esgotando os 4.096 tokens de contexto.
Com prompt curto e sem web search, o Qwen3.5-35B Q6_K responde normalmente numa RX 580 de 2017."
— AIVisionsLab, 15/06/2026

34. PROVANDO A HIPÓTESE: CURL, CTX-SIZE 8192 E A PRIMEIRA RESPOSTA COMPLETA

Foco: Estudo Cognitivo & Raciocínio Interno
Âncora: #proving_hypothesis_35b
Provando a Hipótese — Qwen3.5 35B
Experimentos conclusivos validando preenchimento de contexto, timeouts de cliente e comparação Q4_K_M vs Q6_K no silício de 2017.
AMD RX 580 8GB Xeon E5-2690 v3 Hipótese Provada --ctx-size 8192 Q4_K_M vs Q6_K
Velocidade (Q4_K_M)
6.42 - 6.65 tok/s
Sem Swap Ativo
Contexto Provado
8.192 tokens
Acomoda modo de Raciocínio
Temperatura Máxima
74°C
10°C mais frio com Q4_K_M
Status do Hardware
100% Aprovado
Zero crashes / 4 slots paralelos

34.0 — Contexto e Motivação

A Seção 33 terminou com uma hipótese clara: "O problema nunca foi o hardware. Foi a combinação de thinking + web search esgotando os 4.096 tokens de contexto. Com prompt curto e sem web search, o Qwen3.5-35B Q6_K responde normalmente numa RX 580 de 2017."

Em 16 de junho de 2026, o AIVisionsLab executou os testes pendentes sugeridos para provar essa hipótese ao vivo, avaliando o comportamento com curl direto (sem timeout do cliente), habilitando a flag de tamanho de contexto ampliado e testando quantizações mais eficientes.

34.1 — Hardware do Laboratório

Componente Especificação
CPUIntel Xeon E5-2690 v3 — 12 cores / 24 threads · 3,05 GHz turbo (Lançado em 2014)
RAM31,8 GB DDR4 REG ECC (quad-channel)
GPUAMD Radeon RX 580 2048SP — 8 GB GDDR5 (Lançado em 2017)
Storage NVMeSSD NVMe (Disco E:) — modelos GGUF (Leitura de 1.7–3.5 GB/s)
Storage HDDHDD (Disco C: / F:) — sistema Windows + swap
Driver AMD31.0.21925.1001 — lançado em 20/05/2026
SistemaWindows 10 Pro com WSL2 activo

34.2 — Modelos Testados

Modelo Quantização Tamanho do Arquivo Parâmetros da Arquitetura
Qwen3.5-35B-A3B-Uncensored-HauhauCS-Aggressive-Q6_K6 bits28,51 GB34,66B (MoE)
Qwen3.5-35B-A3B-Uncensored-HauhauCS-Aggressive-Q4_K_M4 bits (Medium)21,17 GB34,66B (MoE)
Qwen3.5-35B-A3B-Uncensored-HauhauCS-Aggressive-Q5_K_M5 bits (Medium)24,76 GB34,66B (MoE)

*Nota: Todos os modelos possuem arquitetura idêntica de Mixture of Experts (MoE), variando apenas a compressão matemática de seus pesos.

34.3 — Localizando os Executáveis

Antes de testar, foi necessário localizar as compilações otimizadas do llama-server. No PowerShell do laboratório:

Get-ChildItem -Path E:\ -Recurse -Filter "llama-server.exe" -ErrorAction SilentlyContinue # Resultado: E:\llama.cpp\llama-server.exe (stub de 9KB) E:\llama.cpp\build\bin\Release\llama-server.exe (Executável real de 7.5MB) ◀

34.4 — Teste 9: Curl Direto Sem Timeout

34.4.1 — Motivação

Identificar se o gargalo de timeout relatado no Teste 4 residia no servidor ou estritamente nas requisições AJAX do cliente OpenWebUI.

34.4.2 — Inicialização do Servidor

cd E:\llama.cpp\build\bin\Release .\llama-server.exe -m "E:\models\Qwen3.5-35B-A3B-Uncensored-HauhauCS-Aggressive-Q4_K_M.gguf" --host 0.0.0.0 --port 8081

34.4.3 — Resolvendo Escaping de JSON no PowerShell

'{"model":"any","messages":[{"role":"user","content":"Explique MoE em 3 paragrafos"}]}' | Out-File -Encoding utf8 -FilePath "E:\teste.json"

34.4.4 — Executando a Chamada de Longa Duração

curl.exe -X POST http://localhost:8081/v1/chat/completions -H "Content-Type: application/json" --max-time 600 -d "@E:\teste.json"

34.4.5 — Resultado Analítico

truncated = 0 ◀ RESPOSTA COMPLETA ENTREGUE COM SUCESSO total time = 266.42 s / 1955 tokens eval time = 255.97 s / 1683 tokens @ 6.57 t/s

Veredicto técnico: O hardware de 2017 processou e entregou a resposta perfeitamente! O problema anterior era o tempo limite do navegador desistindo da conexão TCP, enquanto o servidor continuava gerando em background.

34.5 — Paralelismo Real: 4 Slots de Computação

Durante o Teste 9, o OpenWebUI foi conectado paralelamente disparando a mesma pergunta. O motor de agendamento do llama.cpp processou de forma concorrente sem travamentos:

Task 0 (curl) — n_decoded = 1125, tg = 5.96 t/s Task 875 (OpenWebUI) — n_decoded = 243, tg = 5.08 t/s

A arquitetura resistiu de forma estável (GPU: 63°C, VRAM: 7.1/8.0 GB, RAM: 91% de uso de sistema total seguro, sem travar o Windows).

34.6 — Teste 7: Habilitando Contexto Extremo (--ctx-size 8192)

34.6.1 — O Comando Otimizado

cd E:\llama.cpp\build\bin\Release .\llama-server.exe -m "E:\models\Qwen3.5-35B-A3B-Uncensored-HauhauCS-Aggressive-Q4_K_M.gguf" --host 0.0.0.0 --port 8081 --ctx-size 8192

34.6.2 — Prompt de Teste e Comportamento do Thinking

"Explique em português por que MoE permite rodar modelos grandes em hardware com pouca VRAM. Seja direto e conciso."

Ao receber o prompt, o processador de pensamento rodou por longos 9 minutos em background na CPU trabalhando com o contexto de 8192 tokens. A análise interna destrinchou a matemática da VRAM (calculou que 35B em INT4 exige 17,5GB de peso puro) para desvendar as complexidades de esparsidade de ativação.

34.6.2-A — O Raciocínio Interno do Modelo: Análise Comparativa dos Três Thinking Blocks

Durante as exaustivas sessões de ensaio das Seções 33 e 34, o Qwen3.5-35B gerou três blocos independentes de raciocínio de bastidores (<think>) que foram capturados via interceptação direta de pacotes brutos. A tabulação e o mapeamento sistemático dessas sessões fornecem evidências fundamentais de análise cognitiva do modelo:

1. Thinking Block 1 — Quantização Q6_K — Sessão 1 (23:06 de 15/06)

Prompt: "Explique detalhadamente o mecanismo de atenção nos Transformers e por que MoE é mais eficiente que modelos densos."
Tempo de Raciocínio: ~4 minutos | Tokens do Bloco: ~2.000 | Status: ✅ Concluído com Sucesso.

// Linha de Pensamento do Qwen3.5 (Q6_K):
- Deconstruct query into structured chunks: Attention math, Multi-head, MoE, benefits vs dense.
- Detail Attention: Focus on Scaled Dot-Product mathematical formulation (Q, K, V). Show why division by sqrt(d_k) is required to prevent vanishing gradients during Softmax.
- Explain Multi-Head as parallel subspace projections (capturing both strict syntactic dependencies and semantic references).
- Deconstruct MoE: Discuss role of Router/Gating network, Routing sparsity (top-k selection), and load balancing to prevent routing collapse (unused experts).
- [Autocorreção Interna]: "Wait, I must check if MoE is always faster. I should explicitly note that MoE is memory-intensive for routing/loading but highly sparse computationally. If memory bandwidth is bottlenecked under dual-system offloading, token generation speed depends strongly on mmap performance."
2. Thinking Block 2 — Quantização Q4_K_M — Sessão 2 (05:05 de 16/06)

Prompt: "Qual a diferença entre MoE e modelo denso, e por que MoE permite rodar 35B numa GPU de 8GB?"
Tempo de Raciocínio: ~11 minutos | Tokens do Bloco: ~3.500 | Status: ❌ Interrompido por esgotamento de contexto (Límite 4096).

// Linha de Pensamento do Qwen3.5 (Q4_K_M):
- Analysis of premise: Running 35 billion parameter model in 8GB VRAM.
- [Cálculo Físico Espontâneo]:
* FP32 weights: 35B * 4 bytes = 140 GB. Impossible.
* FP16 weights: 35B * 2 bytes = 70 GB. Impossible.
* INT8 quant: 35B * 1 byte = 35 GB. Impossible.
* INT4 quant: 35B * 0.5 bytes = 17.5 GB. Still larger than 8GB. This doesn't fit natively.
- Challenge the premise: "Wait, if the model indeed runs on 8GB, there must be extreme offloading, sparse activation memory loading, or aggressive hybrid quantization."
- [Autocorreção Crítica]: "Ah! The user says 'por que o MoE permite rodar'. But actually, MoE weights are typically larger than equivalent dense models. A 35B MoE has 35B total parameters but only roughly 6B-8B active parameters per token. If we offload the inactive experts to system memory (RAM/mmap swap) and only load the active experts or the shared dense blocks onto the GPU, then the GPU memory footprint during active tensor computation is massively reduced. Let me structure this hypothesis."
- [Análise Meta-Arquitetural]: Elaborating on the split mechanism. Router stays in VRAM for instant routing, shared blocks in VRAM, active experts fetched from RAM dynamically during forward pass.

Nota Conclusiva de Engenharia: Enquanto o modelo formulava esse raciocínio fascinante na CPU, ele estava descrevendo em profundidade matemática exatamente o sistema de mmap distribuído e a arquitetura Vulkan de 4 níveis de memória que o sustentava em tempo real — sem possuir acesso direto aos metadados do container ou ao sistema de arquivos do laboratório.

3. Thinking Block 3 — Quantização Q4_K_M — Sessão 2 (05:24 de 16/06)

Prompt: "Explique em português por que MoE permite rodar modelos grandes em hardware com pouca VRAM. Seja direto e conciso."
Tempo de Raciocínio: ~9 minutos | Tokens do Bloco: ~3.000 | Status: ✅ Concluído com Sucesso (--ctx-size 8192).

// Linha de Pensamento do Qwen3.5 (Q4_K_M com limite otimizado):
- Prompt requests: Portuguese, direct, concise.
- Challenge VRAM claim again internally: MoE total size is bigger than dense, but active size is smaller. VRAM savings must come from smaller activation graphs (fewer experts evaluated simultaneously) and CPU-offloaded weight mapping.
- Work step-by-step to compress explanation to fit "direto e conciso":
* Rascunho v1: Long theoretical detail on Router and CPU/VRAM exchange metrics.
* Refinamento v2: Cut down router math, focus on "Ativação Esparsa" (activation memory bounds).
* Compressão Final: Produce 3 crisp, highly readable Portuguese bullet points summarizing Active Parameters, Activation Garty/Memory limit, and Compute Scalability.
Tabela Comparativa de Comportamento Cognitivo
Métrica de Profiling Sessão 1 (Q6_K) Sessão 2-A (Q4_K_M) Sessão 2-B (Q4_K_M / ctx 8192)
Duração do Raciocínio~4 minutos~11 minutos~9 minutos
Volume do Bloco <think>~2.000 tokens~3.500 tokens~3.000 tokens
Autocorreções Efetuadas27 (Autocorreções profundas)4 (Foco em concisão)
Questionamento de Premissa?Não✅ Sim (Provou erro matemático do prompt)Sim (reajuste técnico)
Raciocínio MatemáticoEquação TransformersCálculo do tamanho de pesos reaisCálculo de buffers de ativação
Entrega do Texto✅ Sucesso❌ Estouro (4096 esgotados)✅ Sucesso Absoluto (Zero cortes)

34.8 — Cronograma Histórico do Laboratório

Sessão do Experimento ID Parâmetros de Ctx Geração (tok/s) Corte de Fluxo (truncated) Resultado Efetivo
Seção 34 — Teste 5Q6_K4096 tokens5,57 t/s0 (prompt enxuto)✅ Resposta entregue (contexto enxuto)
Seção 34 — Teste 9 (curl)Q4_K_M4096 tokens6,57 t/s0 (sem timeout)✅ Resposta integral por canal direto
Seção 34 — Teste 7 (WebUI)Q4_K_M8192 tokens6,42 t/s0✅ Resposta completa com raciocínio expandido

34.9 — Nova Coleção de Lições Técnicas Consolidadas

  • Lição 6 — O fator Timeout do Cliente: A maior parte dos erros apontados por testadores não decorre de incapacidade física da GPU, mas sim da persistência HTTP falha de interfaces que desistem antes da decodificação final.
  • Lição 7 — Ajuste de Buffers de Contexto: Ativar a diretiva --ctx-size 8192 remove o limite asfixiante do buffer de raciocínio, oferecendo fôlego de processamento para os mais de 3.500 tokens exigidos de raciocínio lógico interno.
  • Lição 8 — Supremacia de Carregamento da Quantização Média: Rodar 35B com quantização de 4 bits economiza 7GB cruciais na carga física de RAM da CPU, reduzindo o I/O do Swap do disco e otimizando a temperatura.
  • Lição 9 — Raciocínio de Modelo Crítico: O Qwen3.5 MoE questionou a premissa errônea presente no prompt, calculando pesos em tempo real e rebatendo sobre o offloading híbrido, o que prova comportamento de atenção e alinhamento impecáveis.
  • Lição 10 — Paralelismo nativo estável: A coexistência de chamadas em canais concorrentes prova a maturidade das implementações de pipeline de shaders Vulkan no llama.cpp.

34.10 — Setup Recomendado para Implementações Futuras

# Script do Laboratório para inicialização de produção cd E:\llama.cpp\build\bin\Release .\llama-server.exe ` -m "E:\models\Qwen3.5-35B-A3B-Uncensored-HauhauCS-Aggressive-Q4_K_M.gguf" ` --host 0.0.0.0 ` --port 8081 ` --ctx-size 8192

*Instruções de interface complementares: Desativação estrita de Web Search e geração e imagens durante o processamento híbrido extremo.

34.11 — Veredicto Geral do Laboratório (Provando a Hipótese)

Questão de Engenharia Veredicto Final
O curl resolve o timeout do OpenWebUI?Sim (truncated = 0, resposta 100% íntegra)
CTX-SIZE de 8.192 resolve o thinking mode esmagado?Sim (Acomoda com folga raciocínios longos)
Q4_K_M é superior para o cenário de 32GB de RAM?Sim (Mais rápido, mais frio, menor swap)
A hipótese de esgotamento de contexto foi confirmada?Absolutamente
Sobrecusto financeiro para otimização em 2026?R$ 0,00 (Solução lógica via flags)

34.12 — Tags e Metadados

🏷️ Tags: curl, ctx-size, timeout, openwebui, q4km, q6k, paralelismo, thinking-mode, resposta-completa, hipotese-confirmada, rx580
💻 Hardware: RX 580 2048SP + Xeon E5-2690 v3 + 32GB ECC DDR4
💿 Software: llama.cpp (build\bin\Release) + Vulkan SDK 1.4.350.0 + OpenWebUI v0.9.6
📅 Data: 16/06/2026
📊 Testes: 3 (Teste 9 curl, paralelismo real, Teste 7 ctx8192)
📈 Benchmark: 6,42–6,65 tok/s (Q4_K_M) | truncated = 0
🔥 Temperatura pico: 74°C
🏆 Status final: ✅ HIPÓTESE CONFIRMADA
"O problema nunca foi o hardware. Era uma flag e um timeout."
— AIVisionsLab, 16/06/2026