lucasoc/sci-image-models

Sci-Image-Markdown: Extrator de Tabelas com Qwen2.5-VL-3B LoRA (Resolucao Original Nativa)

Adapter fine-tunado com PEFT LoRA sobre o modelo base Qwen2.5-VL-3B-Instruct, especializado na extracao e transcricao direta de dados quantitativos de figuras cientificas para tabelas estruturadas em Markdown com resolucao de imagem nativa/original.

Este modelo foi otimizado com a funcao de perda ICDAR Metric-Aware Loss (combinando perdas estruturais e numericas diferenciaveis com recompensas diretas em VRAM para Table Edit Distance e Cell RMS Error).

Recursos de Treinamento, Tempo e Memoria VRAM

Diferente de pipelines tradicionais que reduzem ou distorcem as figuras cientificas, este modelo foi treinado preservando a resolucao vetorial nativa integral das imagens.

Nota de Hardware e Eficiencia: O treinamento em resolucao original levou 1h 38m 57s (5.937 segundos) em uma NVIDIA GeForce RTX 3090 (24 GB VRAM) utilizando quantizacao 4-bit NF4 (QLoRA), otimizador paged_adamw_8bit e Gradient Checkpointing. O aumento no tempo e no uso de memoria decorre do processamento de ate ~1.280 patches visuais por figura (contra ~100 patches no baseline), garantindo resolucao nativa para capturar cada detalhe numerico.

Resultados no Conjunto de Teste (373 Figuras Cientificas)

Avaliacao no benchmark oficial SciKnowOrg/Sci-ImageMiner (Tarefa 2: Extracao de Tabelas de Dados). Ganhos reportados estritamente em pontos percentuais (pp):

Comparativo: Loss Padrao vs. Nossa Loss

1. O que e a Loss Padrao (Cross-Entropy / SFT)

No treinamento supervisionado tradicional, a funcao de perda trata todos os tokens com exatamente o mesmo peso (1.0).

• —Falta de foco numerico: O modelo sofre a mesma penalidade se errar uma palavra descritiva comum (por exemplo, "Tempo" para "Tempa") ou se errar a coordenada exata de um ponto critico em um grafico (por exemplo, "1.2" para "9.8").
• —Falta de foco estrutural: O modelo trata delimitadores de colunas (barras verticais) e quebras de linha com o mesmo peso de espacos em branco. Um unico caractere de coluna ausente inutiliza a tabela inteira, mas gera uma penalidade minima na loss padrao.
• —Comportamento: O modelo aparenta estar convergindo com perda baixa porque acerta a maioria dos textos comuns, mas continua gerando dados numericos imprecisos e tabelas malformadas.

2. A Nossa Solucao: ICDAR Metric-Aware Loss

Para resolver esse problema, desenhamos uma funcao de perda que penaliza os erros de forma seletiva de acordo com a importancia de cada token:

• —Tokens Numericos (Peso 3.0x): Digitos (0 a 9), pontos decimais e sinais recebem peso 3 vezes maior na retropropagacao, funcionando como um proxy direto para a metrica de RMS Numerico.
• —Tokens Estruturais (Peso 2.0x): Barras verticais delimitadoras de colunas, quebras de linha e marcadores de cabecalho recebem peso 2 vezes maior, garantindo que a estrutura da tabela seja rigorosamente respeitada.
• —Tokens Textuais Comuns (Peso 1.0x): Textos explicativos e espacos mantem peso padrao unitario.

3. Como a Loss atua no LoRA

No treinamento com PEFT QLoRA, os pesos do modelo base Qwen2.5-VL-3B permanecem 100% congelados em quantizacao 4-bit (NF4). Apenas as matrizes lineares de baixa dimensao A e B dos adaptadores LoRA (acopladas as projecoes de atencao qproj, kproj, vproj, oproj) sao atualizadas:

• —Amplificacao Seletiva de Gradientes: Quando o modelo erra um numero ou uma divisao de coluna, o gradiente resultante e multiplicado por 3.0x ou 2.0x. Pela regra da cadeia, esse erro amplificado e propagado diretamente para as matrizes treinaveis do LoRA.
• —Direcionamento da Atencao Visual: Essa forca de gradiente ajusta os vetores de atencao do Vision Transformer, forcando o modelo a concentrar seu foco visual nas coordenadas, eixos, legendas e numeros presentes na imagem cientifica.
• —Maximizacao do Orcamento de Parametros: Como o LoRA treina apenas 3,6 milhoes de parametros (apenas 0,098% do modelo total), a nossa loss impede que esse orcamento reduzido seja gasto com linguagem natural trivial, canalizando praticamente todo o aprendizado para a precisao numerica e integridade estrutural.

4. Por que dessa Escolha?

• —Alinhamento as Metricas Oficiais: As competicoes ICDAR avaliam tabelas por meio do TEDS (Tree Edit Distance) e do RMS Numerico. A Cross-Entropy padrao desconhece essas restricoes. A nossa loss atua como um surrogate continuo diferenciavel que alinha o objetivo do treino diretamente ao criterio de teste.
• —Garantia de Tabelas 100% Validas: A penalidade duplicada em delimitadores ensinou o modelo a nunca esquecer o fechamento de uma celula, resultando em 100,00% de tabelas validas no conjunto de teste.
• —Zero Overhead com GPU Tensor Reward: Em vez de calcular distancias em arvores na CPU (o que travaria o treinamento), a loss opera inteiramente na memoria VRAM da GPU atraves de tensores de contagem e comparacao de mascaras booleanas.

Como Usar para Inferencia

Instalacao das Dependencias

pip install torch transformers peft qwen-vl-utils pillow torchvision bitsandbytes

Exemplo em Python (Inferencia em Resolucao Original)

import torch
from PIL import Image
from transformers import AutoProcessor, Qwen2_5_VLForConditionalGeneration, BitsAndBytesConfig
from peft import PeftModel
from qwen_vl_utils import process_vision_info

model_id = "Qwen/Qwen2.5-VL-3B-Instruct"
adapter_id = "lucasoc/sci-image-models"

# 1. Carregar processador
processor = AutoProcessor.from_pretrained(adapter_id)

# 2. Carregar modelo base em 4-bit (compativel com GPUs a partir de 6GB para inferencia)
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.float16,
    bnb_4bit_use_double_quant=True,
)
base_model = Qwen2_5_VLForConditionalGeneration.from_pretrained(
    model_id,
    quantization_config=bnb_config,
    torch_dtype=torch.float16,
    device_map="auto"
)

# 3. Carregar o adapter LoRA treinado
model = PeftModel.from_pretrained(base_model, adapter_id)
model.eval()

# 4. Processar imagem em resolucao original
image_path = "grafico_cientifico.png"
image = Image.open(image_path).convert("RGB")

messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "image": image},
            {"type": "text", "text": "Extract the plotted quantitative data into a clean Markdown table with column headers."}
        ]
    }
]

text = processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
image_inputs, _ = process_vision_info(messages)
inputs = processor(text=[text], images=image_inputs, padding=True, return_tensors="pt").to("cuda")

with torch.inference_mode():
    generated_ids = model.generate(**inputs, max_new_tokens=1024, temperature=0.0)
    generated_ids_trimmed = [
        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
    ]
    output_text = processor.batch_decode(
        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
    )[0]

print("--- Tabela Markdown Extraida ---")
print(output_text)

Detalhes de Treinamento

• —Arquitetura Base: Qwen/Qwen2.5-VL-3B-Instruct
• —Metodo de Adaptacao: 4-bit QLoRA ($r=16, \alpha=32, \text{dropout}=0.05$)
• —Resolucao: Original nativa (sem downsampling previo, ate ~1 Megapixel por imagem)
• —Otimizador: paged_adamw_8bit com Cosine Annealing e taxa de aprendizado $1 \times 10^{-4}$
• —Funcao de Perda: ICDAR Metric-Aware Loss com surrogate diferenciavel para metricas de tabela
• —Hardware: NVIDIA GeForce RTX 3090 (24 GB VRAM)
• —Tempo de Treinamento: 1 hora, 38 minutos e 57 segundos (5.937 segundos totais para 3 epocas, 273 passos)
• —Codigo Fonte: sci-image-markdown