DeepSeek-OCR: um guia prático com 7 exemplos do mundo real

DeepSeek-OCR é um novo modelo de grande porte de visão e linguagem que entende estrutura, interpreta tabelas, extrai gráficos e encara até matemática, memes e vários idiomas.

Neste guia, eu coloco o DeepSeek-OCR à prova em tarefas reais de ponta a ponta — de anotações manuscritas a gráficos complexos, memes e documentos multilíngues. Vamos passar por:

• Extração de gráficos e tabelas
• Análise de química e fórmulas
• Reconhecimento de texto manuscrito
• Equações e saída em Markdown
• OCR para memes e imagens de redes sociais
• Compreensão de documentos multilíngues

No fim, você vai ver onde o DeepSeek-OCR brilha e onde ainda tropeça. Se você está explorando OCR open source, vale conferir estes experimentos antes de escolher seu pipeline. Também recomendo dar uma olhada no nosso tutorial do DeepSeek V3.2-Speciale.

O que é o DeepSeek-OCR?

DeepSeek-OCR é um modelo aberto de visão-linguagem com 3 bilhões de parâmetros, treinado para compreensão de documentos. Ele usa compressão ótica de contexto mapeando grandes contextos visuais 2D em tokens de visão comprimidos, permitindo processar documentos enormes com eficiência.

Alguns recursos importantes incluem:

• Leitura de grandes documentos digitalizados, recibos, notas fiscais, artigos científicos etc.
• Interpretação de tabelas, gráficos e figuras geométricas.
• Suporte a textos multilíngues e manuscritos.

Como o DeepSeek-OCR funciona?

O DeepSeek-OCR foi projetado para lidar com uma ampla variedade de imagens de documentos, de gráficos e tabelas a escrita manual, matemática e texto em vários idiomas. Em vez de tratar imagens e texto como domínios separados, ele usa a modalidade visual como um motor de compressão para textos longos, permitindo que grandes modelos de linguagem (LLMs) processem muito mais informação usando dramaticamente menos tokens. Vamos destrinchar a arquitetura e o que a diferencia:

O pipeline de ponta a ponta: do codificador ao decodificador

Em alto nível, o DeepSeek-OCR tem dois componentes principais:

• DeepEncoder (Tokenizador e compressor de visão)
• Decodificador DeepSeek-3B MoE (gerador de texto)

Fonte: DeepSeek-OCR: Contexts Optical Compression

1. Pré-processamento da imagem de entrada: O pipeline começa com uma imagem de documento, como um contrato digitalizado, um bilhete manuscrito, uma tabela financeira etc. Essa imagem é dividida em uma grade de blocos de 16x16 pixels, as menores “palavras visuais” que o modelo entende.

2. DeepEncoder: o DeepEncoder é um mecanismo de visão em múltiplas etapas projetado para equilibrar resolução, uso de memória e compressão de informação. Ele opera em três estágios principais:

• SAM (Segment Anything Model, 80M parâmetros): cuida da atenção local analisando pequenos blocos sobrepostos para capturar detalhes finos e layout.
• Compressor convolucional (downsample 16×): reduz drasticamente o número de tokens de visão ao comprimir recursos locais, fazendo com que menos tokens cheguem à etapa cara de atenção global.
• CLIP ViT: um transformer de visão (300M parâmetros) que aplica atenção global para entender a estrutura e o contexto geral do documento, atuando como camada de embedding para os tokens comprimidos.

3. De tokens visuais para texto: o decodificador MoE comprime os tokens de visão que são enviados ao decodificador DeepSeek-3B MoE (Mixture-of-Experts) para inferência eficiente, ativando apenas os especialistas mais relevantes por amostra e reduzindo custo computacional sem sacrificar acurácia.

4. Flexibilidade guiada por prompt: o sistema direciona o formato de saída (Markdown, tabelas HTML, fórmulas químicas SMILES, layouts multilíngues etc.) apenas alterando o prompt, como fazemos com LLMs.

O DeepSeek-OCR mostra que uma única imagem de documento pode ser “comprimida” em até 1/10 do número de tokens exigidos por texto puro, sem perda substancial de acurácia. 

Demo do DeepSeek OCR: aplicação Gradio

Nesta seção, vamos configurar uma aplicação web completa no Gradio para rodar OCR do DeepSeek-OCR direto no seu navegador ou no Google Colab. Com poucos passos, você envia imagens de gráficos, tabelas, notas à mão, memes, matemática, texto multilíngue e recebe uma saída estruturada com bounding boxes.

Passo 1: pré-requisitos

Antes de começar, garanta que os seguintes pré-requisitos estejam atendidos:

!pip install -q "transformers==4.46.3" "tokenizers==0.20.3" einops addict easydict pillow gradioTecnologia

O comando acima instala todas as bibliotecas Python necessárias para o DeepSeek-OCR e o Gradio, incluindo as versões compatíveis mais recentes de transformers, tokenizers, processamento de imagens (pillow) e o toolkit de UI do Gradio. 

Observação: este código roda em uma L4 GPU com High RAM no Google Colab.

Passo 2: imports

Com as dependências instaladas, agora configuramos os imports.

import os, time, torch, gradio as gr
from PIL import Image
from transformers import AutoModel, AutoTokenizer
from datetime import datetime
import random
import stringTecnologia

Importamos os módulos essenciais de Python para I/O de arquivos, inferência de modelo (torch), construção de UI (gradio), manipulação de imagem (PIL) e utilitários para gerenciar caminhos e IDs de execução aleatórios.

Passo 3: carregar o modelo

Com as bibliotecas instaladas, você já pode carregar o modelo DeepSeek-OCR do Hugging Face. Porém, o acesso a certos modelos exige autenticação com um access token do Hugging Face.

Veja como configurar seu access token do Hugging Face no Google Colab:

• Adicione um segredo no Colab: no seu notebook do Google Colab, clique no ícone de chave (“Secrets”) na barra lateral esquerda e selecione “Add a Secret”.
• Crie um token no Hugging Face: faça login na sua conta do Hugging Face, vá em configurações e encontre “Access Tokens”. Clique em “Create new token”, escolha a permissão adequada (geralmente “Read”) e gere seu token.
• Copie e cole o token: copie o seu novo access token e cole no campo “Add a Secret” do Colab. Isso permite que seu notebook acesse o modelo DeepSeek-OCR com segurança.

Agora você está pronto para autenticar e prosseguir com o carregamento do modelo!

model_id = "deepseek-ai/DeepSeek-OCR"
tok = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True)
if tok.pad_token is None and tok.eos_token is not None:
    tok.pad_token = tok.eos_token
model = AutoModel.from_pretrained(
    model_id,
    trust_remote_code=True,
    use_safetensors=True,
    attn_implementation="eager"
).to(dtype=torch.bfloat16, device="cuda").eval()Tecnologia

O código acima carrega o modelo oficial DeepSeek-OCR e o tokenizer direto do Hugging Face. Em seguida, garante compatibilidade do tokenizer definindo o token de padding e carrega o modelo no formato bfloat16.

Passo 4: função auxiliar

Com o modelo pronto, vamos criar um diretório novo para cada saída do modelo e manter cada execução de OCR organizada. Assim, o texto extraído, as visualizações com caixas e os logs ficam salvos sem sobrescrever resultados anteriores.

def new_run_dir(base="/content/runs"):
    os.makedirs(base, exist_ok=True)
    ts = datetime.now().strftime("%Y%m%d-%H%M%S")
    rid = ''.join(random.choices(string.ascii_lowercase + string.digits, k=5))
    path = os.path.join(base, f"run_{ts}_{rid}")
    os.makedirs(path)
    return pathTecnologia

A função new_run_dir cria um diretório de saída único para cada execução, com base no carimbo de data/hora e em um sufixo aleatório. Isso evita sobrescrever resultados e ajuda a organizar arquivos para inspeção ou debug.

Passo 5: handler de OCR

Este é o motor principal do app Gradio do DeepSeek-OCR. Ele converte a imagem enviada para o formato correto, redimensiona se o arquivo for muito grande e, a cada execução, salva tudo em uma nova pasta.

def gr_ocr(image, mode, custom_prompt, base_size, image_size, crop_mode):
    img = image.convert("RGB")
    if max(img.size) > 2000:
        s = 2000 / max(img.size)
        img = img.resize((int(img.width*s), int(img.height*s)), Image.LANCZOS)
    run_dir = new_run_dir()
    img_path_proc = os.path.join(run_dir, "input.png")
    img.save(img_path_proc, optimize=True)
    if mode == "Custom Prompt" and custom_prompt.strip():
        prompt = custom_prompt.strip()
    else:
        prompt = DEMO_MODES[mode]["prompt"]
    t0 = time.time()
    try:
        with torch.inference_mode():
            _ = model.infer(
                tok,
                prompt=prompt,
                image_file=img_path_proc,
                output_path=run_dir,
                base_size=base_size,
                image_size=image_size,
                crop_mode=crop_mode,
                save_results=True,
                test_compress=True
            )
    except ZeroDivisionError:
        print(" [Patched] Division by zero in compression ratio (valid_img_tokens==0). Ignored.")
    dt = time.time() - t0
    result_file = os.path.join(run_dir, "result.mmd")
    if not os.path.exists(result_file):
        result_file = os.path.join(run_dir, "result.txt")
    result = "[No text extracted]"
    if os.path.exists(result_file):
        with open(result_file, "r", encoding="utf-8") as f:
            result = f.read().strip() or "[No text extracted]"
    boxed_path = os.path.join(run_dir, "result_with_boxes.jpg")
    boxed_img = Image.open(boxed_path) if os.path.exists(boxed_path) else None
    stats = f"""
**{dt:.1f}s** | Image: {img.size[0]}×{img.size[1]} px  
**Output directory:** {run_dir}  
"""
    return result, stats, boxed_imgTecnologia

A função gr_ocr encapsula o pré-processamento, a inferência e o pós-processamento no app Gradio do DeepSeek-OCR. Ela faz o seguinte:

• Padronização e pré-processamento de imagem: converte qualquer imagem para RGB para garantir compatibilidade. Se a imagem excede 2000 px em qualquer dimensão, ela é redimensionada proporcionalmente para evitar estouro de memória da GPU.
• Gerenciamento de diretórios de execução: cada execução de OCR fica isolada em um diretório único, o que permite rastreabilidade essencial para processamento em lote, debug e reprodutibilidade.
• Inferência eficiente: o modelo é chamado dentro de torch.inference_mode() para evitar cálculos de gradiente, reduzindo memória e acelerando a inferência.
• Tratamento de exceções e bordas: lida com exceções como ZeroDivisionError em casos raros de compressão de tokens, sem interromper a experiência do usuário.
• Agregação e visualização de resultados: após a inferência, carrega o texto extraído e uma imagem com sobreposição das caixas delimitadoras para inspeção rápida.
• Integração com a UI: retorna uma tupla com saída do OCR, estatísticas de processamento e a imagem anotada para integração direta com o Gradio.

Vamos para a interface interativa e ver o DeepSeek-OCR em ação.

Passo 6: UI no Gradio

No passo final, definimos uma interface interativa no Gradio para o DeepSeek-OCR, permitindo enviar imagens, selecionar diferentes modos de extração, ajustar configurações avançadas e visualizar as saídas em uma única UI web.

DEMO_MODES = {
    "Document ➔ Markdown": {
        "prompt": "<image>\n<|grounding|>Convert the document to markdown.",
        "desc": "Extracts full document text as Markdown, preserving structure (headings, tables, lists, etc.).",
        "base_size": 1024, "image_size": 640, "crop_mode": False
    },
    "Chart Deep Parsing": {
        "prompt": "<image>\nParse all charts and tables. Extract data as HTML tables.",
        "desc": "Extracts tabular/chart data into HTML tables.",
        "base_size": 1024, "image_size": 640, "crop_mode": False
    },
    "Chemical Formula Recognition": {
        "prompt": "<image>\nExtract all chemical formulas and SMILES.",
        "desc": "Extracts chemical structures and formulae.",
        "base_size": 1024, "image_size": 768, "crop_mode": False
    },
    "Geometry Parsing": {
        "prompt": "<image>\nExtract all geometric figures and their measurements.",
        "desc": "Parses diagrams and extracts geometric data.",
        "base_size": 1024, "image_size": 768, "crop_mode": False
    },
    "Plain Text Extraction": {
        "prompt": "<image>\nFree OCR.",
        "desc": "Fast, plain text OCR of the image.",
        "base_size": 768, "image_size": 512, "crop_mode": False
    },
    "Multilingual Document": {
        "prompt": "<image>\n<|grounding|>Extract text. Preserve all languages and structure.",
        "desc": "Extracts multi-language content, preserves structure.",
        "base_size": 1024, "image_size": 640, "crop_mode": False
    },
    "Custom Prompt": {
        "prompt": "",
        "desc": "Provide your own custom prompt for flexible OCR or parsing.",
        "base_size": 1024, "image_size": 640, "crop_mode": False
    }
}
with gr.Blocks(theme=gr.themes.Soft()) as demo:
    gr.Markdown("""
    <div style="text-align:center;">
        <h1>DeepSeek-OCR Demo</h1>
    </div>
    """)
    with gr.Row():
        with gr.Column():
            gr.Markdown("### Input")
            image_input = gr.Image(type="pil", label="Upload Document/Image", height=350)
            gr.Markdown("#### Demo Modes (From Paper)")
            mode = gr.Radio(
                choices=list(DEMO_MODES.keys()), value="Document to Markdown", label="Select Capability to Test"
            )
            desc = gr.Markdown(DEMO_MODES["Document to Markdown"]["desc"])
            custom_prompt = gr.Textbox(label="Custom Prompt", visible=False)
            with gr.Accordion("Advanced Settings", open=False):
                base_size = gr.Slider(512, 1280, value=DEMO_MODES["Document to Markdown"]["base_size"], step=64, label="Base Size")
                image_size = gr.Slider(512, 1280, value=DEMO_MODES["Document to Markdown"]["image_size"], step=64, label="Image Size")
                crop_mode = gr.Checkbox(value=DEMO_MODES["Document to Markdown"]["crop_mode"], label="Dynamic Resolution (Crop Mode)")
            process_btn = gr.Button("Process Image", variant="primary")
        with gr.Column():
            gr.Markdown("### Results")
            ocr_output = gr.Textbox(label="Extracted Content", lines=22, show_copy_button=True)
            status_out = gr.Markdown("_Process an image to see stats and output dir_")
            boxed_output = gr.Image(label="Result with Bounding Boxes", type="pil")
    def update_mode(selected):
        d = DEMO_MODES[selected]
        return d["desc"], gr.update(visible=selected=="Custom Prompt"), d["base_size"], d["image_size"], d["crop_mode"]
    mode.change(update_mode, inputs=mode,
                outputs=[desc, custom_prompt, base_size, image_size, crop_mode])
    process_btn.click(
        gr_ocr,
        inputs=[image_input, mode, custom_prompt, base_size, image_size, crop_mode],
        outputs=[ocr_output, status_out, boxed_output]
    )
demo.launch(share=True, debug=True)Tecnologia

Vamos entender esse código em partes:

• Modos e prompts da demo: o dicionário DEMO_MODES encapsula as principais capacidades de OCR do DeepSeek-OCR, como "Document to Markdown", "Chart Deep Parsing", "Chemical Formula Recognition" e outras. Cada modo inclui um prompt padrão, uma descrição e parâmetros recomendados de processamento de imagem, permitindo alternar as tarefas de extração na hora.
• Arquitetura em blocos: a UI é construída usando a API de alto nível Blocks do Gradio. A interface é dividida em duas colunas: um painel de entrada para enviar a imagem, escolher o modo de OCR e ajustar parâmetros avançados como tamanho da imagem e modo de recorte; e o painel de saída que exibe o conteúdo extraído, as estatísticas e uma imagem anotada com caixas nas regiões detectadas.
• Controles dinâmicos da UI: há botões de rádio, sliders, checkboxes e campos de texto que se ajustam automaticamente conforme o modo selecionado, melhorando a usabilidade e reduzindo configuração manual.
• Gatilho de inferência e resultados: ao clicar no botão Process Image, a aplicação chama o handler principal gr_ocr passando as seleções atuais. As saídas são renderizadas imediatamente no painel de resultados.

Observação: talvez você precise reiniciar a sessão no Google Colab se ele continuar retornando saída do input anterior.

Com a aplicação Gradio pronta, vamos testar o DeepSeek-OCR com uma série de exemplos práticos.

Exemplo 1 do app DeepSeek OCR: análise profunda de gráficos

No demo do Gradio, eu quis ver o quão bem o modelo extrai dados tabulares de gráficos — ainda um desafio para a maioria dos modelos de visão e OCR.

Usei dois casos clássicos de teste:

• Um gráfico de barras no estilo Statista e
• Um gráfico de análise técnica complexo, repleto de sinais “BUY/SELL” e sobreposições numéricas

O DeepSeek-OCR retornou uma tabela HTML para cada gráfico, com células correspondentes a categorias, valores e rótulos encontrados na imagem.

O que funcionou: o modelo capturou todo o texto visível e a estrutura do gráfico, e a saída veio em formato de tabela HTML, utilizável por máquina e mantendo a lógica tabular. Ele até processou gráficos financeiros complexos, tentando tabular cada número e rótulo.

Onde teve dificuldade: a saída bruta é muito verbosa, com muitos <td> e <tr>, o que dificulta interpretar rapidamente. Em gráficos complexos, às vezes o modelo duplicou entradas ou perdeu a estrutura visual de mais alto nível, resultando em uma tabela excessivamente carregada com repetições de "BUY"/"SELL" e valores.

Em fluxos reais, o ideal é pós-processar o HTML para legibilidade ou importar no Excel ou Pandas.

A interpretação de gráficos do DeepSeek-OCR é uma forma inteligente de “digitalização” de gráficos, mas a saída pesada em HTML é mais indicada para pipelines de dados ou parsing adicional, não para revisão humana rápida.

Exemplo 2: extração de fórmulas químicas

No teste seguinte, avaliei como o DeepSeek-OCR lida com extração de informações químicas a partir de imagens estruturadas. O modo químico foi pensado para converter tanto dados tabulares quanto estruturas moleculares gráficas em formatos legíveis por máquina, como tabelas HTML e notação SMILES.

Enviei dois tipos de imagens e observei o seguinte:

• Extração de fórmulas textuais: neste caso, o modelo transcreveu com precisão nomes e fórmulas moleculares (como “Glicose: C₆H₁₂O₆”, “Butano: C₄H₁₀”). Porém, a saída veio como código bruto de tabela HTML que, embora estruturado, não é tão fácil de ler de relance. A conversão foi rápida e razoavelmente precisa para texto puro.

• Reconhecimento de estruturas moleculares: em imagens com diagramas químicos, o DeepSeek-OCR tentou extrair as strings SMILES correspondentes. Por exemplo, gerou SMILES para etano e propano. Apesar de reconhecer que eram estruturas químicas, os SMILES nem sempre eram quimicamente válidos, indicando limitações ao interpretar imagens moleculares mais complexas.

No geral, a extração química oferece um caminho rápido para digitalizar dados e tentar reconhecer estruturas moleculares, mas precisa de refinamento para parsing químico confiável, especialmente em estruturas complexas.

Exemplo 3: OCR de texto manuscrito

Depois, testei notas manuscritas — um clássico desafio para OCR, principalmente quando a escrita é estilizada ou varia de tamanho. 

Enviei a imagem de uma lista de química escrita à mão, com nomes de compostos em papel pautado. Após o processamento, o modo Document to Markdown extraiu o texto e preservou bem a estrutura. Reconheceu o cabeçalho e listou cada composto em sua própria linha, como na imagem original. As caixas delimitadoras confirmaram visualmente a identificação correta de cada linha e bloco de texto.

Esse resultado mostra a capacidade do modelo de transcrever conteúdo manuscrito para texto digital. Alguns detalhes de formatação podem se perder, mas a extração geral foi bem precisa neste exemplo.

Exemplo 4: extração de equações

Outro teste padrão é ler e interpretar corretamente equações matemáticas em notação de livros didáticos. Enviei uma imagem com equações complexas em estilo LaTeX para avaliar se o modelo detecta e também extrai e formata as expressões com precisão.

O DeepSeek-OCR detectou as quatro equações e as extraiu como strings LaTeX. A saída ficou limpa, com cada equação em sua própria linha no formato padrão.

As caixas também foram sobrepostas corretamente (aproximadamente), mostrando que o modelo localiza e segmenta expressões matemáticas individuais com precisão.

Chamou atenção o fato de a estrutura matemática ter sido preservada com comandos como \frac para frações e formatação adequada de variáveis, deixando o resultado pronto para documentação.

Exemplo 5: extração de tabelas

Uma das tarefas mais comuns e valiosas de OCR é extrair dados tabulares de imagens de documentos — especialmente relatórios digitalizados, artigos e datasets. Para avaliar o DeepSeek-OCR nisso, enviei a imagem de uma tabela econômica estruturada entre vários países.

Após selecionar o modo "Chart Deep Parsing" e processar a imagem, o DeepSeek-OCR converteu a tabela visual em uma estrutura de tabela HTML. A saída (à direita) contém <table> e <td> mapeando linhas e colunas como texto puro. As caixas confirmaram a segmentação correta da região principal da tabela.

O modelo extrai bem tabelas simples, embora seja comum precisar de pós-processamento — a saída em HTML bruto não é a mais amigável para revisão rápida ou análise de dados direta.

Exemplo 6: OCR em memes

Aqui, testei a extração de texto em memes populares — um cenário real com texto sobreposto a fundos complexos, fontes variadas e fora do padrão de documentos.

Enviei um meme clássico com texto branco em caixa alta sobre uma cena de filme (Leonardo DiCaprio em Django Unchained) e rodei o modo Document to Markdown.

Fonte: Media.io

O resultado foi surpreendentemente robusto: capturou todas as palavras na ordem correta, sem erros de ortografia nem omissões, mesmo com o fundo complexo. 

Embora não haja marcação estrutural, a extração é muito útil para tarefas como análise de sentimento de memes, moderação de conteúdo ou busca textual.

Exemplo 7: OCR multilíngue

Uma das forças do DeepSeek-OCR é o suporte a textos multilíngues — essencial em documentos ou imagens com mistura de idiomas.

Testei com amostras variadas, incluindo uma placa de rua com texto em chinês e um exemplo sintético com frases em chinês, japonês e coreano.

Fonte: DeepSeek OCR no Hugging Face

Ao processar esses exemplos multilíngues, o modo document-to-Markdown detectou e extraiu scripts não ingleses com precisão. Na foto de rua, o modelo identificou e retornou o parágrafo inteiro em chinês. 

No exemplo com idiomas mistos, separou e “rotulou” corretamente as seções em chinês, japonês e coreano, preservando formatação e blocos de texto. As sobreposições de caixas também mostraram detecção precisa de cada região de texto.

Ainda assim, dois avisos importantes:

• Velocidade de processamento: OCR multilíngue é significativamente mais lento que inglês ou extração de tabelas. Meus testes mostraram tempo bem maior, possivelmente pela complexidade extra na detecção e decodificação de scripts.
• Erros ocasionais: às vezes a saída inclui tokens redundantes ou texto com formatação incorreta.

Apesar desses pontos, o DeepSeek-OCR entrega um OCR multilíngue robusto, capaz de lidar com scripts mistos e fotos do mundo real.

Considerações finais sobre o DeepSeek-OCR

O DeepSeek-OCR faz a ponte entre o OCR clássico e os LLMs multimodais modernos. Seu maior trunfo é a versatilidade: um único pipeline que lê documentos digitalizados, extrai tabelas e gráficos complexos, entende equações e estruturas químicas e ainda funciona com memes, manuscritos e dezenas de idiomas.

Dito isso, não é perfeito. As saídas de gráficos e tabelas podem ser verbosas demais, o reconhecimento de estruturas químicas às vezes falha e o processamento multilíngue pode ser visivelmente mais lento. Layouts visuais complexos tendem a exigir pós-processamento para uso direto.

Mas, para pesquisa, rotinas acadêmicas, prototipagem rápida e para quem precisa de OCR avançado além de texto puro, o DeepSeek-OCR já soa como um avanço relevante sobre ferramentas legadas. 

Se você quer se aprofundar no ecossistema DeepSeek, recomendo o curso Working with DeepSeek in Python.