Extração de Dados de Faturas com OCR de IA usando um Script Python Simples

O que é OCR baseada em IA?

O OCR orientado por IA vai além das capacidades do OCR tradicional, pois utiliza inteligência artificial para compreender o contexto, lidar com várias variações de layout e produzir extração de dados estruturados de alta qualidade mesmo dos documentos mais complexos. Enquanto o OCR tradicional é projetado para captar texto de um formato fixo, o OCR de IA pode lidar com muitos tipos de layouts e configurações comuns em faturas e outros documentos empresariais.

Principais Características do OCR de IA

• Compreensão Contextual: O OCR de IA utiliza PNL para entender o contexto nos documentos. Ele identifica campos como “Valor Total”, “Data da Fatura” e “Nome do Cliente” mesmo quando esses campos aparecem em diferentes locais.
• Flexibilidade: O OCR tradicional costuma falhar com layouts irregulares; o OCR de IA é flexível e pode extrair informações de diferentes tipos de formatos de faturas sem dificuldades.
• Estruturação de Dados: Frequentemente, o OCR de IA fornece saídas já estruturadas, facilitando o pós-processamento em relação à saída bruta de texto do OCR tradicional.

Por que usar OCR de IA para Faturas?

Faturas precisam ser processadas de forma eficiente e com alto grau de precisão, seja no departamento de contabilidade, logística ou compras. O OCR de IA automatiza a extração de dados e facilita os fluxos de trabalho, melhorando a precisão dos dados.

Benefícios do OCR de IA para Faturas

• Velocidade e Eficiência: Com o OCR de IA, um grande número de faturas pode ser processado em pouco tempo, liberando recursos e mão de obra.
• Maior Precisão: Modelos de IA treinados em ampla variedade de formatos de documentos reduzem erros associados à entrada manual de dados.
• Gestão de Dados Mais Fluida: Como os dados já vêm estruturados, integram-se facilmente a bancos de dados, sistemas analíticos e até sistemas ERP.
• Escalabilidade: O OCR de IA pode processar grandes volumes de documentos sem exigir mais pessoal, tornando-o ideal para grandes organizações ou empresas em rápida expansão.

O ROI de usar a ferramenta de OCR de IA da FlowHunt

A maioria das empresas convencionais extrai dados de faturas manualmente, utilizando funcionários para essas tarefas. Isso é um processo muito demorado e caro, que pode ser automatizado em diversas áreas e empresas, como escritórios de contabilidade, jurídicos, financeiros e outros.

Esse processo leva de 5 a 15 segundos e custa de 0,01 a 0,02 créditos, enquanto normalmente seria necessário pagar de $15 a $30 por hora para um funcionário realizar a mesma tarefa.

Eu diria que a FlowHunt é muito mais eficiente por uma grande margem.

Desafios na Implementação de OCR

Embora o OCR seja altamente benéfico, ele apresenta alguns desafios:

1. Qualidade da Imagem: A precisão do OCR depende significativamente da qualidade da imagem. Imagens borradas ou de baixa resolução geram resultados ruins.
2. Formatação Complexa: Documentos com layouts complexos, fontes variadas ou tabelas podem exigir processamento avançado de OCR.
3. Idioma e Conjunto de Caracteres: O software de OCR pode ter suporte limitado a idiomas, exigindo modelos especializados para caracteres não latinos.
4. Taxa de Erro: Nenhum software de OCR é 100% preciso, especialmente com fontes cursivas ou irregulares, podendo causar erros na saída.

Para superar esses desafios, é essencial utilizar uma ferramenta de OCR poderosa e flexível. A API da FlowHunt oferece uma solução robusta, capaz de lidar com estruturas documentais complexas, sendo ideal para projetos de OCR em larga escala.

Configurando o Script Python de OCR

Para automatizar o processo, você precisará instalar as seguintes bibliotecas Python:

pip install requests pdf2image git+https://github.com/QualityUnit/flowhunt-python-sdk.git

Isso instala:

• requests: Para enviar requisições HTTP para a API da FlowHunt e baixar os resultados do OCR.
• pdf2image: Para converter páginas de PDF em imagens.
• flowhunt: SDK Python da FlowHunt, que simplifica a interação com a API de OCR.

Passo a Passo do Código

Este código vai pegar um PDF, converter em imagens, enviar cada imagem para a FlowHunt para processamento de OCR e salvar a saída em formato CSV.

Importando Bibliotecas

import json
import os
import re
import time
import requests
import flowhunt
from flowhunt.rest import ApiException
from pprint import pprint
from pdf2image import convert_from_path

• json, os, re e time ajudam no manuseio de JSON, gerenciamento de arquivos, expressões regulares e intervalos de tempo.
• requests: Usado para lidar com requisições HTTP, como baixar os resultados do OCR.
• flowhunt: O SDK da FlowHunt gerencia autenticação e comunicação com a API de OCR.
• pdf2image: Converte páginas de PDF em imagens, permitindo OCR por página.

Função para Converter Páginas do PDF em Imagens

def convert_pdf_to_image(path: str) -> None:
    """
    Convert a PDF file to images, storing each page as a JPEG.
    """
    images = convert_from_path(path)
    for i in range(len(images)):
        images[i].save('data/images/' + 'page' + str(i) + '.jpg', 'JPEG')

• convert_from_path: Converte cada página do PDF em uma imagem.
• images[i].save: Salva cada página como um JPEG individual para o processamento de OCR.

Extraindo a URL do Anexo de Saída

def extract_attachment_url(data_string):
    pattern = r'```flowhunt\n({.*})\n```'
    match = re.search(pattern, data_string, re.DOTALL)
    if match:
        json_string = match.group(1)
        try:
            json_data = json.loads(json_string)
            return json_data.get('download_link', None)
        except json.JSONDecodeError:
            print("Error: Failed to decode JSON.")
            return None
    return None

• A função recupera a URL para baixar o resultado do OCR.
• Utiliza regex para encontrar o objeto JSON com o link de download.

Configuração da API e Autenticação

convert_pdf_to_image("data/test.pdf")
FLOW_ID = "<FLOW_ID_HERE>"

configuration = flowhunt.Configuration(
    host="https://api.flowhunt.io",
    api_key={"APIKeyHeader": "<API_KEY_HERE>"}
)

• Converte o PDF em imagens.
• Configura o acesso à API com as credenciais da FlowHunt.

Inicializando o Cliente da API

with flowhunt.ApiClient(configuration) as api_client:
    auth_api = flowhunt.AuthApi(api_client)
    api_response = auth_api.get_user()
    workspace_id = api_response.api_key_workspace_id

• Autentica e recupera o workspace_id para chamadas subsequentes da API.

Iniciando uma Sessão de Fluxo

flows_api = flowhunt.FlowsApi(api_client)
from_flow_create_session_req = flowhunt.FlowSessionCreateFromFlowRequest(flow_id=FLOW_ID)
create_session_rsp = flows_api.create_flow_session(workspace_id, from_flow_create_session_req)

• Configura uma sessão para upload de imagens e processamento de OCR.

Fazendo o Upload das Imagens para o Processamento de OCR

for image in os.listdir("data/images"):
    image_name, image_extension = os.path.splitext(image)
    with open("data/images/" + image, "rb") as file:
        try:
            flow_sess_attachment = flows_api.upload_attachments(
                create_session_rsp.session_id,
                file.read()
            )

• Faz o upload de cada imagem na sessão para processamento de OCR.

Acionando o Processamento de OCR e Monitorando Resultados

invoke_rsp = flows_api.invoke_flow_response(
    create_session_rsp.session_id, 
    flowhunt.FlowSessionInvokeRequest(message="")
)
while True:
    get_flow_rsp = flows_api.poll_flow_response(
        create_session_rsp.session_id, invoke_rsp.message_id
    )
    print("Flow response: ", get_flow_rsp)
    if get_flow_rsp.response_status == "S":
        print("done OCR")
        break
    time.sleep(3)

• Aciona o processamento OCR e verifica a cada 3 segundos até a conclusão.

Baixando e Salvando a Saída do OCR

attachment_url = extract_attachment_url(get_flow_rsp.final_response[0])
if attachment_url:
    response = requests.get(attachment_url)
    with open("data/results/" + image_name + ".csv", "wb") as file:
        file.write(response.content)

• Baixa a saída em CSV e salva localmente.

Executando o Script e Testando o Resultado

Para executar este script:

1. Coloque seu PDF na pasta data/.
2. Atualize <FLOW_ID_HERE> e <API_KEY_HERE> com suas credenciais da FlowHunt.
3. Execute o script para converter o PDF, enviar as imagens para OCR e baixar os resultados estruturados em CSV.

Conclusão

Este script Python oferece uma solução eficiente para escalar processos de OCR, ideal para setores com grande demanda de processamento documental. Com a API da FlowHunt, essa solução faz a conversão de documentos para CSV, otimizando fluxos de trabalho e aumentando a produtividade.

Código Completo

Clique AQUI para a versão Gist.

import json
import os
import re
import time
import requests
import flowhunt
from flowhunt.rest import ApiException
from pprint import pprint
from pdf2image import convert_from_path

def convert_pdf_to_image(path: str) -> None:
    """
    Convert a pdf file to an image
    :return:
    """
    images = convert_from_path(path)
    for i in range(len(images)):
        images[i].save('data/images/' + 'page'+ str(i) +'.jpg', 'JPEG')

def extract_attachment_url(data_string):
    pattern = r'```flowhunt\n({.*})\n```'
    match = re.search(pattern, data_string, re.DOTALL)
    if match:
        json_string = match.group(1)
        try:
            json_data = json.loads(json_string)
            return json_data.get('download_link', None)
        except json.JSONDecodeError:
            print("Error: Failed to decode JSON.")
            return None
    return None

convert_pdf_to_image("data/test.pdf")
FLOW_ID = "<FLOW_ID_HERE>"

configuration = flowhunt.Configuration(host = "https://api.flowhunt.io",
                                       api_key = {"APIKeyHeader": "<API_KEY_HERE>"})

with flowhunt.ApiClient(configuration) as api_client:
    auth_api = flowhunt.AuthApi(api_client)
    api_response = auth_api.get_user()
    workspace_id = api_response.api_key_workspace_id

    flows_api = flowhunt.FlowsApi(api_client)
    from_flow_create_session_req = flowhunt.FlowSessionCreateFromFlowRequest(
        flow_id=FLOW_ID
    )
    create_session_rsp = flows_api.create_flow_session(workspace_id, from_flow_create_session_req)

    for image in os.listdir("data/images"):
        image_name, image_extension = os.path.splitext(image)
        with open("data/images/" + image, "rb") as file:
            try:
                flow_sess_attachment = flows_api.upload_attachments(
                    create_session_rsp.session_id,
                    file.read()
                )
                invoke_rsp = flows_api.invoke_flow_response(create_session_rsp.session_id, flowhunt.FlowSessionInvokeRequest(
                    message="",
                ))
                while True:
                    get_flow_rsp = flows_api.poll_flow_response(create_session_rsp.session_id, invoke_rsp.message_id)
                    print("Flow response: ", get_flow_rsp)
                    if get_flow_rsp.response_status == "S":
                        print("done OCR")
                        attachment_url = extract_attachment_url(get_flow_rsp.final_response[0])
                        if attachment_url:
                            print("Attachment URL: ", attachment_url, "\n Downloading the file...")
                            response = requests.get(attachment_url)
                            with open("data/results/" + image_name + ".csv", "wb") as file:
                                file.write(response.content)
                        break
                    time.sleep(3)
            except ApiException as e:
                print("error for file ", image)
                print(e)