Tutorial: Como usar Gemma 4 para extrair dados de PDFs como imagens sem OCR

Extrair texto de PDFs parece simples — até você encontrar um documento escaneado, um formulário preenchido ou uma tabela com células mescladas. Ferramentas como pdfplumber e PyPDF2 funcionam bem com PDFs digitais que têm camada de texto, mas falham silenciosamente com PDFs baseados em imagem. O Gemma 4 do Google DeepMind muda esse jogo: trate cada página como uma imagem e deixe o modelo ler.

O que mudou em 2026

O Gemma 4, lançado em abril de 2026 com licença Apache 2.0, lista explicitamente parsing de documentos e PDFs como capacidade nativa, junto com OCR, compreensão de gráficos, reconhecimento de caligrafia e compreensão de telas. Tudo isso rodando 100% local — sem API key, sem chamadas à nuvem, sem dados saindo do seu servidor.

✅ O que você ganha

• Unifica PDFs digitais e escaneados: o mesmo pipeline funciona para ambos — o modelo lê a página como um humano lê uma página impressa
• Preservação de layout: tabelas, colunas múltiplas, formulários — o modelo vê a estrutura visual, não apenas a ordem de leitura
• Zero-shot: sem templates por tipo de documento, sem OCR pipeline, sem parser de layout
• Execução local: sem enviar documentos confidenciais para APIs de terceiros
• Token budget ajustável: 70 a 1120 tokens visuais por imagem — controle direto entre precisão e velocidade

⚠️ O que você NÃO ganha

• Velocidade em CPU: sem GPU, espere 30-90 segundos por página
• Modelos gated: é preciso criar conta no Hugging Face e aceitar os termos de uso
• Substituto de OCR tradicional para texto simples: para PDFs digitais de coluna única, pdfplumber ainda é mais rápido

Requisitos

Modelos Gemma 4 disponíveis

Passo a passo

1. Instalar dependências

# Python 3.10+ obrigatório
python --version

# Criar ambiente virtual
python -m venv gemma4-env
source gemma4-env/bin/activate       # macOS / Linux

# Instalar pacotes
pip install   "transformers>=4.51.0"   "torch>=2.3.0"   "accelerate>=0.30.0"   "pymupdf>=1.24.0"   "Pillow>=10.0.0"   "bitsandbytes>=0.43.0"

# Login no Hugging Face (precisa de token de leitura)
huggingface-cli login

2. Verificar dispositivo

import torch

def detect_device():
    if torch.cuda.is_available():
        name = torch.cuda.get_device_name(0)
        vram = torch.cuda.get_device_properties(0).total_memory / 1e9
        print(f"CUDA GPU: {name} ({vram:.1f} GB VRAM)")
        return "cuda", torch.bfloat16
    elif torch.backends.mps.is_available():
        print("Apple Silicon MPS detectado")
        return "mps", torch.float16
    else:
        print("CPU — lento mas funcional")
        return "cpu", None

device, dtype = detect_device()
print(f"Dispositivo: {device}")

3. Carregar Gemma 4

from transformers import AutoProcessor, Gemma4ForConditionalGeneration
import torch

model_id = "google/gemma-4-E4B-it"

model = Gemma4ForConditionalGeneration.from_pretrained(
    model_id,
    device_map="auto",
    torch_dtype=torch.bfloat16,
)
processor = AutoProcessor.from_pretrained(model_id)

4. Renderizar PDF como imagem

import pymupdf

def pdf_to_images(pdf_path, dpi=200):
    # Converte cada pagina do PDF em imagem de alta resolucao.
    doc = pymupdf.open(pdf_path)
    images = []
    for page in doc:
        pix = page.get_pixmap(dpi=dpi)
        img = Image.frombytes("RGB", [pix.width, pix.height], pix.samples)
        images.append(img)
    return images

# Exemplo
imgs = pdf_to_images("fatura.pdf", dpi=200)
print(f"Páginas renderizadas: {len(imgs)}")

5. Extrair dados com prompt zero-shot

messages = [
    {"role": "user", "content": [
        {"type": "image", "image": imgs[0]},
        {"type": "text", "text": "Extraia os campos: vendor_name, invoice_number, invoice_date, due_date, line_items (com description, quantity, unit_price, total), subtotal, tax, total. Retorne APENAS JSON valido."}
    ]}
]

inputs = processor.apply_chat_template(
    messages, add_generation_prompt=True, tokenize=True,
    return_dict=True, return_tensors="pt"
).to(model.device)

outputs = model.generate(**inputs, max_new_tokens=2048)
response = processor.decode(outputs[0], skip_special_tokens=True)
print(response)

Casos de uso reais

• Processamento de faturas: pipeline de intake de documentos que extrai fornecedor, número, itens e totais de faturas escaneadas ou digitais
• Digitalização de contratos: extrair cláusulas, partes envolvidas, datas e valores de contratos jurídicos complexos com múltiplas colunas
• Formulários governamentais: processar formulários preenchidos à mão ou digitalmente, mantendo a associação campo-valor
• Relatórios financeiros trimestrais: extrair tabelas de balanço e DRE de PDFs com layouts complexos e notas de rodapé
• Prontuários médicos: processar documentos clínicos escaneados preservando a relação entre campos de formulário e valores

Comparação com alternativas

Troubleshooting

• ❌ CUDA out of memory: Reduza o token budget para 140 ou use o modelo E2B-it (6 GB VRAM). Adicione load_in_4bit=True para quantização.
• ❌ “gated model” no Hugging Face: Acesse huggingface.co/google/gemma-4-E4B-it, aceite os termos e gere um token em Settings → Access Tokens.
• ❌ Campo extraído vazio ou errado: Aumente o token budget para 1120 e o DPI para 300. Considere processar metade da página por vez para documentos muito densos.
• ❌ JSON mal formatado na resposta: Adicione "Retorne APENAS JSON válido" ao prompt e use json.loads() com try/except para validação.
• ❌ Mistura de colunas em tabelas de duas colunas: O 2D RoPE do Gemma 4 resolve isso nativamente, mas em casos extremos recorte a página em metades verticais.

FAQ

Preciso de GPU para usar o Gemma 4? Não obrigatoriamente. CPU funciona, mas é lento (30-90s por página). O Google Colab gratuito oferece GPU T4 com 15 GB VRAM.

Posso usar com documentos em português? Sim. O Gemma 4 tem suporte multilíngue robusto. Para documentos em português, o desempenho é comparável ao inglês em extração de campos estruturados.

Qual a diferença entre E2B e E4B? O E4B-it tem o dobro de parâmetros efetivos (4.5B vs 2.3B) e pontua muito melhor no OmniDocBench (0.181 vs 0.290). Para uso em produção, prefira o E4B-it.

Funciona com PDFs de múltiplas páginas? Sim. Processe uma página por vez. Para documentos muito longos, implemente um loop que acumula resultados por página.

O modelo mantém dados em memória? Há risco de vazamento? Não. Por ser execução local, nenhum dado sai da sua máquina. Após o processamento, os dados na VRAM são liberados.

Tendência

Em 2027, a tendência é que modelos de visão-linguagem como o Gemma 4 se tornem o padrão para processamento de documentos, substituindo pipelines frágeis de OCR + parser. A capacidade de tratar PDFs como imagens e extrair informações com linguagem natural elimina a distinção artificial entre documentos “escaneados” e “digitais”. Empresas que adotarem essa abordagem agora estarão à frente quando a tecnologia se tornar commodity.