BroadRouter
Começar

Revisão humana no seu fluxo de IA para documentos

Pela equipe da BroadNet Inference · 7 min de leitura · Publicado em · Atualizado em

Trate todo documento extraído como não aprovado até que passe nas regras. Mande para uma pessoa quando faltar um campo obrigatório, as somas não baterem, a data ou o fornecedor parecerem errados ou o modelo estiver inseguro. Revise também uma pequena parcela aleatória de documentos limpos, registre cada correção no seu próprio sistema e acompanhe a taxa de revisão e a taxa de erro auditada.

Um modelo de visão consegue ler uma fatura, mas também pode ler um dígito errado, pular uma linha ou inventar um campo que não existe. A solução não é só um prompt melhor. É uma etapa de revisão pensada desde o primeiro dia: regras que decidem quais documentos uma pessoa vê, uma fila que explica o porquê e um log que permite provar a taxa de erro.

Este post trata dessa etapa. A extração em si (preparo da imagem, prompt JSON, validação de esquema e retentativas) está em extrair dados de documentos com um LLM de visão, e a leitura específica do árabe está em ler faturas em árabe com visão. Aqui partimos do princípio de que você já recebe JSON e precisa decidir em que confiar.

O que deve decidir se uma pessoa revisa um documento?

Regras que você consegue testar no código, não uma impressão sobre o modelo. Comece por estas, em ordem de valor:

Regra Exemplo de código de motivo Por que importa
Campo obrigatório ausente missing:total Um null é honesto; um valor chutado é pior
Somas não batem arithmetic:subtotal+tax!=total Um único dígito mal lido quase sempre quebra uma soma
Itens não somam arithmetic:lines!=subtotal Pega linhas puladas ou duplicadas
Data ilegível ou fora do intervalo date:unparsed Pega dia e mês trocados e ruído de OCR
ID fiscal do fornecedor desconhecido vendor:unknown Fornecedores novos e fraudes começam aqui
Moeda inesperada currency:unexpected Um símbolo mal lido muda o valor
O modelo diz que não tem certeza model:not_confident Um indício, nunca o único filtro

Duas decisões de design tornam a fila utilizável. Primeiro, cada regra gera um código de motivo curto e estável, então o revisor abre o documento sabendo o que conferir, e você consegue contar qual regra dispara mais. Segundo, um documento ou passa em todas as regras ou vai para uma pessoa. Evite pontuações ponderadas que ninguém consegue explicar a um auditor.

Dá para confiar na confiança do modelo?

Trate-a como um sinal fraco. Você pode pedir ao modelo que avalie cada campo com confiança alta, média ou baixa, e ele fará isso. Mas Xiong et al. (ICLR 2024) compararam formas de fazer LLMs declararem confiança e concluíram que os modelos “tend to be overconfident” (tradução: “tendem a ser confiantes demais”) quando dizem o quanto estão seguros; prompts e amostragem melhores ajudaram, e nenhum método superou os outros de forma consistente. Em algumas APIs, log-probabilidades de tokens são outra opção. A referência da API da BroadNet não documenta logprobs, então não projete em cima delas lá.

A regra prática: qualquer coisa abaixo de “high” vinda do modelo, ou a falta de avaliação, manda o documento para revisão, mas um “high” nunca pula as checagens no código. Depois de algumas centenas de documentos revisados, confira se os campos “high” realmente tiveram menos correções. Se não tiveram, descarte o sinal.

Como encaminhar documentos para uma fila?

Este roteador roda depois da extração e da validação. Ele normaliza os dígitos arábico-índicos, aplica as regras acima e escolhe uma de três filas: review, audit_sample ou auto. É Python puro, sem chamada de API, então dá para escrever testes unitários.

import hashlib, json, random, re, time
from datetime import date, datetime
from decimal import Decimal, InvalidOperation

REQUIRED = ["vendor_name", "invoice_number", "invoice_date", "currency", "subtotal", "tax", "total"]
CURRENCIES = {"SAR", "AED", "USD", "EUR"}
KNOWN_VENDORS = {"300000000000003": "Example Trading Co"}   # your supplier master: tax ID -> name
AUTO_SAMPLE_RATE = 0.05          # share of clean documents a person still checks
DIGITS = str.maketrans("٠١٢٣٤٥٦٧٨٩۰۱۲۳۴۵۶۷۸۹٫٬", "01234567890123456789.,")

def money(v):
    """'١٬٢٥٠٫٥٠' or '1,250.50' -> Decimal('1250.50'); None if it is not a number."""
    if v is None:
        return None
    s = str(v).translate(DIGITS).replace(",", "").strip()
    try:
        return Decimal(s)
    except InvalidOperation:
        return None

def check(doc: dict, today: date) -> list[str]:
    """Return the reasons this document needs a person. Empty list = may auto-approve."""
    reasons = [f"missing:{f}" for f in REQUIRED if doc.get(f) in (None, "")]
    sub, tax, tot = (money(doc.get(k)) for k in ("subtotal", "tax", "total"))
    if None not in (sub, tax, tot) and abs(sub + tax - tot) > Decimal("0.01"):
        reasons.append("arithmetic:subtotal+tax!=total")
    lines = [money(l.get("amount")) for l in doc.get("lines", [])]
    if lines and None not in lines and sub is not None and abs(sum(lines) - sub) > Decimal("0.01"):
        reasons.append("arithmetic:lines!=subtotal")
    try:
        d = datetime.strptime(str(doc.get("invoice_date", "")).translate(DIGITS), "%Y-%m-%d").date()
        if d > today or (today - d).days > 400:
            reasons.append("date:out_of_range")
    except ValueError:
        reasons.append("date:unparsed")
    if doc.get("currency") and doc["currency"] not in CURRENCIES:
        reasons.append("currency:unexpected")
    if doc.get("vendor_tax_id") not in KNOWN_VENDORS:
        reasons.append("vendor:unknown")
    if doc.get("model_confidence", "low") != "high":   # a hint from the prompt, never the only gate
        reasons.append("model:not_confident")
    return reasons

def route(doc_id: str, doc: dict, today: date, rng=random.random) -> dict:
    reasons = check(doc, today)
    if reasons:
        queue = "review"
    elif rng() < AUTO_SAMPLE_RATE:
        queue, reasons = "audit_sample", ["sample:random"]
    else:
        queue = "auto"
    return {"doc": hashlib.sha256(doc_id.encode()).hexdigest()[:16], "queue": queue,
            "reasons": reasons, "ts": int(time.time())}

Testamos com três faturas sauditas inventadas (o fornecedor e o ID fiscal são fictícios). Uma limpa, com a data e o subtotal escritos em dígitos arábico-índicos (٢٠٢٦-١١-٠٢ e ١٬٠٠٠٫٠٠), foi para auto. A mesma fatura com o total lido errado como 1,105.00 foi para review com arithmetic:subtotal+tax!=total. Uma com ID fiscal desconhecido, mês 13 e confiança “medium” foi para review com três motivos: date:unparsed, vendor:unknown e model:not_confident. Forçar o sorteio aleatório abaixo de 0,05 mandou a fatura limpa para audit_sample.

Dois limites a conhecer. O helper money() assume ponto ou o separador decimal árabe; um valor no formato europeu como “1.150,00” precisa de um parser próprio, escolhido pelo país do fornecedor. E a regra de data assume que o modelo devolveu datas ISO. Datas do calendário hegírico precisam ser convertidas antes, como em extração de entidades nomeadas em árabe.

O que muda com faturas em árabe e inglês?

Faturas bilíngues são comuns no Golfo: rótulos em árabe e inglês lado a lado, valores em dígitos ocidentais ou arábico-índicos e o nome do fornecedor em dois alfabetos. Algumas regras ajudam:

  • Normalize os dígitos antes de qualquer checagem. Converta ٠–٩ e os persas ۰–۹ para 0–9, e os separadores árabes de decimal e milhar (٫ e ٬) para suas formas ASCII. Depois compare.
  • Associe fornecedores pelo ID fiscal, não pelo nome. Os nomes em árabe e inglês raramente batem caractere por caractere com o seu cadastro. O número de registro bate.
  • Mostre os dois nomes ao revisor. Exiba os nomes do fornecedor extraídos em árabe e inglês ao lado do registro do cadastro, com o árabe em um bloco isolado da direita para a esquerda. O post sobre design de produtos multilíngues explica a exibição bidirecional.
  • Verifique se existe uma fatura estruturada. Na Arábia Saudita, a ZATCA opera o faturamento eletrônico (Fatoorah) em duas fases, a partir de 4 de dezembro de 2021 e de 1º de janeiro de 2023, baseado em faturas em formato eletrônico estruturado. Se um fornecedor pode enviar isso, faça o parsing do arquivo em vez de ler uma foto dele, e deixe a visão para papel, fotos e a cauda longa.

OCR de árabe com um LLM de visão cobre o lado da leitura: diacríticos, escritas mistas e layout.

O que o revisor deve ver?

Uma boa tela de revisão responde a uma pergunta por código de motivo. Para arithmetic, mostre itens, subtotal, imposto e total lado a lado com a soma calculada. Para vendor:unknown, mostre o ID fiscal extraído e os registros mais próximos do cadastro. Para date:unparsed, mostre o texto bruto da data e o recorte da imagem de onde ele veio.

Mostre a imagem ao lado dos campos, não em outra aba. Deixe o revisor corrigir um campo, aprovar ou rejeitar o documento como ilegível. Registre qual ação ele tomou. “Ilegível” é um dado útil: se 10% dos documentos de um fornecedor são ilegíveis, peça PDFs a esse fornecedor, não um milagre ao seu modelo.

Por que amostrar documentos que passaram em todas as regras?

Porque as regras só pegam os erros em que você pensou. Se um modelo lê errado um item, o subtotal e o total pelo mesmo valor (um 7 borrado lido como 1 nos três lugares), todas as somas continuam batendo e nenhuma regra dispara. A única forma de encontrar esses erros é olhar documentos que ninguém sinalizou.

Amostre ao acaso, não por escolha, e conte quantos precisaram de correção. Uma amostra pequena dá uma faixa ampla. Com o intervalo de Wilson de 95%, que o manual do NIST descreve para proporções (citando recomendações de Agresti e Coull, e de Brown, Cai e DasGupta), o nosso código de métricas abaixo dá:

Documentos auditados sem nenhum erro encontrado A taxa de erro real ainda pode chegar a
50 cerca de 7,1%
300 cerca de 1,3%

Ou seja, “auditamos 50 e não achamos nada” não significa que a taxa de erro está abaixo de 1%. Aumente a amostra depois de qualquer mudança no prompt, no modelo ou no tipo de documentos, e reduza devagar.

Como manter uma trilha de auditoria?

Registre as correções no seu próprio sistema. Cada documento precisa de uma linha com:

  • um hash SHA-256 do arquivo de origem (e onde o próprio arquivo está armazenado, sob suas regras de retenção);
  • o ID do modelo, a versão do prompt e o JSON bruto que o modelo devolveu;
  • o ID da requisição do provedor (a BroadNet o devolve no header X-Request-ID) para chamados de suporte;
  • os resultados das regras e a fila;
  • o revisor, o horário, a ação e o valor antes e depois de cada campo corrigido.

Isso importa ainda mais com uma API de retenção zero. A declaração de privacidade da BroadNet diz que seu gateway não guarda prompts, imagens, respostas nem transcrições, e mantém apenas registros de conta, cobrança, tráfego e segurança sem conteúdo. Isso é bom para faturas sensíveis, mas significa que ninguém no provedor pode mostrar o que o modelo viu ou disse no mês passado. O seu log é o único registro. Mantenha-o livre de tudo o que você não precisa; log de uso de APIs de LLM explica o que registrar e o que ocultar.

Como medir a taxa de revisão?

Rode isto toda semana sobre o log de roteamento, com as correções incorporadas:

import math
from collections import Counter

def wilson(errors: int, n: int, z: float = 1.96) -> tuple[float, float]:
    """95% Wilson score interval for an error rate seen in a sample."""
    if n == 0:
        return (0.0, 1.0)
    p = errors / n
    centre = (p + z * z / (2 * n)) / (1 + z * z / n)
    half = z * math.sqrt(p * (1 - p) / n + z * z / (4 * n * n)) / (1 + z * z / n)
    return (max(0.0, centre - half), min(1.0, centre + half))

def report(log: list[dict]) -> dict:
    queues = Counter(r["queue"] for r in log)
    reasons = Counter(x.split(":")[0] for r in log if r["queue"] == "review" for x in r["reasons"])
    audited = [r for r in log if r["queue"] == "audit_sample"]
    wrong = sum(1 for r in audited if r.get("corrected_fields"))
    lo, hi = wilson(wrong, len(audited))
    return {"documents": len(log),
            "review_rate": round(queues["review"] / len(log), 3),
            "top_reasons": reasons.most_common(3),
            "audited": len(audited), "audited_with_errors": wrong,
            "auto_error_rate_95ci": (round(lo, 4), round(hi, 4))}

Em uma semana sintética de 1.000 documentos (760 automáticos, 190 em revisão, 50 auditados, dos quais 2 precisaram de correção), ele relatou uma taxa de revisão de 0,19, vendor como principal motivo com 120 casos e uma taxa de erro auditada entre 1,1% e 13,5%. Essa última faixa é a resposta honesta para “qual é a precisão da automação?” com esse tamanho de amostra.

Leia os três números juntos:

  • Taxa de revisão cai, erros auditados ficam estáveis: uma regra estava rígida demais, ou o modelo melhorou. Ótimo.
  • Taxa de revisão cai, erros auditados sobem: uma regra está frouxa demais. Aperte-a antes que os erros cheguem à sua contabilidade.
  • Um motivo domina: corrija a causa. Se vendor:unknown lidera, atualize o cadastro de fornecedores; se arithmetic lidera, veja a qualidade das imagens ou teste outro modelo nos mesmos documentos com o método de avaliar um LLM antes de trocar.

Onde a BroadNet Inference entra

O BroadRouter é o site da própria BroadNet. Segundo seu feed de preços, a BroadNet Inference oferece três modelos de chat que aceitam imagens: Qwen3.8 27B ($0.175 de entrada / $2.17 de saída por 1M de tokens, com saída estruturada documentada), Gemma 4 VL 26B ($0.10 / $0.22, utilizável com o crédito inicial de $5) e DeepSeek V4.1 Flash ($0.175 / $0.52). No pagamento por uso, imagens contam como tokens de entrada; a calculadora de tokens de imagem ajuda a estimá-los. O conteúdo da inferência não é retido; os metadados necessários de conta, cobrança e segurança são retidos conforme descrito na declaração de privacidade da BroadNet. A BroadNet não oferece fila de revisão nem log de auditoria, então o roteamento e os registros acima ficam por sua conta construir e manter.

Perguntas frequentes

O que deve ir para revisão humana na extração de notas e faturas?

Tudo o que falhar em uma regra: um campo obrigatório ausente, itens ou imposto que não somam o total, uma data ilegível ou fora do intervalo, um fornecedor desconhecido, uma moeda inesperada ou uma confiança do modelo abaixo de "high". Acrescente uma pequena amostra aleatória de documentos que passaram em todas as regras.

Posso usar a pontuação de confiança do modelo para pular a revisão?

Não sozinha. A pesquisa sobre confiança declarada (Xiong et al., ICLR 2024) concluiu que LLMs tendem a ser confiantes demais. Use-a como um sinal ao lado das checagens no código e confira nos seus dados rotulados se "high" realmente significa menos erros.

Quantos documentos aprovados automaticamente devo auditar?

O suficiente para limitar a taxa de erro que importa para você. Sem nenhum erro encontrado, 50 documentos auditados limitam a taxa real a cerca de 7% (limite superior de Wilson de 95%) e 300 a cerca de 1,3%. Aumente a amostra quando uma regra, o prompt ou o modelo mudar.

Qual é uma boa taxa de revisão?

Não existe um número universal. Comece alto e só reduza quando a taxa de erro auditada dos documentos aprovados automaticamente ficar dentro da sua tolerância. Taxa de revisão caindo com taxa de erro auditada subindo significa que alguma regra está frouxa demais.

Onde a trilha de auditoria deve ficar?

No seu próprio banco de dados. Guarde um hash do arquivo de origem, o ID do modelo, a versão do prompt, a saída bruta, os resultados das regras, o revisor e os valores corrigidos. Se o seu provedor não retém o conteúdo das requisições, como a BroadNet afirma sobre sua API de inferência, ninguém mais conseguirá reconstruí-lo depois.

Ler em MarkdownPerguntar ao ChatGPTPerguntar ao ClaudePerguntar ao Perplexity