Visão computacional local com Ollama: extraindo dados de prints inteiros em uma GPU de 8GB

Recentemente precisei automatizar uma tarefa bem específica: extrair dados estruturados (tabelas, textos, logs e valores) direto de prints de tela inteiros usando modelos multimodais rodando 100% locais no Ollama.

Uma coisa é mandar uma foto de câmera para um modelo de visão; outra bem diferente é passar uma captura de tela cheia de um dashboard, terminal ou planilha em alta resolução. Telas inteiras trazem desafios bem chatos:

1. Densidade de texto e fontes pequenas: Textos minúsculos em menus laterais ou rodapés viram borrão se o modelo fizer redimensionamento fixo agressivo (como os antigos cortes de 224x224 ou 336x336 pixels).
2. Poluição visual da interface: O modelo precisa entender a hierarquia visual para saber o que é botão, cabeçalho do navegador ou o dado que você realmente quer capturar.
3. Limite de hardware: O objetivo aqui era rodar tudo com aceleração completa em uma placa com 8GB de VRAM, mantendo respostas rápidas e sem empurrar camadas para a memória RAM do sistema.

Abaixo reuni os testes de modelos, como cada um se comportou na VRAM, o erro comum de manifesto no Ollama e o script em Python que montei para automatizar o fluxo.

1. Comparando os modelos de visão no Ollama#

Testei os principais modelos multimodais (VLMs) disponíveis no registro do Ollama para ver quem se saía melhor com telas densas:

• qwen2-vl:7b: Foi o grande destaque. Ele preserva a proporção e resolução do print muito melhor do que a média, conseguindo ler fontes pequenas em cantos da tela sem alucinar.
• gemma3:4b: Surpreendeu pela velocidade e leveza. É uma excelente opção para quem tem ainda menos memória ou quer respostas quase instantâneas.
• llama3.2-vision:11b: Muito bom em interpretação e raciocínio visual, mas ficou pesado demais para placas de 8GB, forçando parte da execução para a RAM.
• moondream: Extremamente leve (~1.9B), ótimo para perguntas simples sobre imagens, mas sofre para estruturar tabelas e ler prints cheios de detalhes.
• llava: Foi um clássico dos modelos abertos de visão, mas hoje fica para trás em comparação com a precisão de OCR do Qwen2-VL.

2. Consumo real de VRAM em uma placa de 8GB#

Ao enviar prints de alta resolução, o modelo processa muitos tokens visuais, o que aumenta o uso de memória além do tamanho básico dos pesos:

3. Resolvendo o erro de manifesto no Ollama#

Na primeira tentativa de baixar o Qwen de visão, tentei rodar:

ollama run qwen2.5-vl:7b
pulling manifest
Error: pull model manifest: file does not exist

Por que esse erro acontece?#

O registro oficial do Ollama tem convenções específicas de nomes de tags. A versão de visão multimodal da família Qwen2 está registrada na árvore como qwen2-vl (ou como qwen2.5vl, sem hífen; a tentativa com qwen2.5-vl:7b falha por não existir no catálogo).

O comando correto:#

# Baixa e roda o modelo de visão de 7B
ollama run qwen2-vl:7b

Para os outros modelos testados, as tags oficiais no registro são:

ollama run gemma3:4b
ollama run llama3.2-vision
ollama run moondream

4. Como automatizar a extração com Python#

Teste rápido no terminal#

Dá para testar direto pela linha de comando passando o prompt e o caminho da imagem:

ollama run qwen2-vl:7b "Ignore os menus da janela e extraia os dados da tabela central em formato JSON: ./print_exemplo.png"

Script em Python com a biblioteca oficial#

Para incluir essa extração em rotinas automáticas e garantir que a resposta venha em JSON limpo (sem introduções e sem quebrar a VRAM), montei este script:

import ollama

def extrair_dados_do_print(caminho_imagem: str):
    prompt = """
    Analise o print de tela fornecido e extraia todos os dados visiveis relevantes.
    Instrucoes:
    - Ignore barras de navegacao, relogio do sistema e menus laterais irrelevantes.
    - Retorne APENAS um JSON estritamente valido, sem texto introdutorio ou blocos explicativos.
    
    Formato esperado:
    {
      "titulo_pagina": "string",
      "metricas": [],
      "tabelas": [],
      "mensagens_erro": []
    }
    """

    resposta = ollama.chat(
        model='qwen2-vl:7b',
        options={
            'num_ctx': 4096  # Limita o contexto para manter a VRAM sob controle (eleve para 8192 se prints 4K sairem cortados)
        },
        messages=[{
            'role': 'user',
            'content': prompt,
            'images': [caminho_imagem]
        }]
    )

    return resposta['message']['content']

if __name__ == '__main__':
    caminho_print = './print_sistema.png'
    resultado = extrair_dados_do_print(caminho_print)
    print(resultado)

Conclusão: dicas práticas para tirar o melhor proveito#

• Deixe claro o que deve ser ignorado: Prints de tela têm muita informação inútil ao redor (barras de abas, ícones, menus de sistema). Dizer no prompt para focar só na área central ou na tabela evita que o modelo perca tempo processando detalhes irrelevantes.
• Fixe o num_ctx: Como prints grandes geram muitos tokens visuais, limitar o contexto em 4096 evita picos de memória que forçariam o Ollama a usar a RAM do computador.
• Faça um pré-corte em telas 4K: Se o print for de um monitor 4K ou ultrawide gigante, fazer um recorte simples via código na área que você quer analisar economiza memória e acelera muito a resposta.

Com o qwen2-vl:7b rodando no Ollama, você consegue um OCR de altíssima precisão e totalmente local em placas comuns de 8GB, sem depender de APIs pagas e mantendo seus dados e prints 100% na sua máquina.

Veja também

Inteligência Artificial Rodando LLMs locais no terminal: minha busca pelo modelo ideal no Ollama e Tabby

Inteligência Artificial Auditando o bypass de custos em automação CLI: analisando o OpenCode

Inteligência Artificial Por que sua IA parece defasada? O mito do "capamento" de API vs. a realidade arquitetônica

Este post está licenciado sob CC BY-NC.