Estrazione Dati da Fatture con OCR AI tramite un Semplice Script Python

Cos’è l’OCR basato su AI?

L’OCR guidato dall’intelligenza artificiale supera le capacità dell’OCR tradizionale perché utilizza l’AI per comprendere il contesto, gestire molteplici varianti di layout e produrre estrazioni dati strutturate di alta qualità anche dai documenti più complessi. Mentre l’OCR tradizionale si limita a riconoscere testo da formati fissi, l’OCR AI è in grado di affrontare svariati tipi di layout e configurazioni, tipici di fatture e altri documenti aziendali.

Caratteristiche Chiave dell’OCR AI

• Comprensione Contestuale: L’OCR AI usa il NLP per interpretare il contesto nei documenti. Identifica campi come “Importo Totale”, “Data Fattura” e “Nome Cliente” anche quando si trovano in posizioni diverse.
• Flessibilità: L’OCR tradizionale va in crisi con layout irregolari; l’OCR AI è flessibile e può estrarre informazioni da diversi tipi di fatture senza difficoltà.
• Strutturazione dei Dati: Spesso l’OCR AI restituisce direttamente output strutturati, più facili da elaborare rispetto al testo grezzo dell’OCR tradizionale.

Perché Usare l’OCR AI per le Fatture?

Le fatture devono essere elaborate in modo efficiente e preciso, sia in ambito contabile, logistico o di approvvigionamento. L’OCR AI automatizza l’estrazione dei dati e semplifica i flussi di lavoro, migliorando l’accuratezza dei dati.

Vantaggi dell’OCR AI per le Fatture

• Velocità ed Efficienza: Con l’OCR AI si possono processare numerose fatture in pochissimo tempo, liberando risorse e personale.
• Maggiore Accuratezza: I modelli AI, addestrati su molti formati documentali, riducono gli errori tipici dell’inserimento dati manuale.
• Gestione Dati Semplificata: Poiché i dati sono già strutturati, possono essere integrati facilmente in database, sistemi di analytics o ERP.
• Scalabilità: L’OCR AI può gestire grandi volumi di documenti senza necessità di aumentare il personale, ideale per grandi aziende o realtà in rapida crescita.

Il ROI dell’OCR AI di FlowHunt

Molte aziende tradizionali estraggono i dati dalle fatture manualmente tramite personale dedicato. Si tratta di un’operazione molto dispendiosa in termini di tempo e costi, che può essere automatizzata in moltissimi settori e aziende, come studi fiscali, legali, finanziari e altri.

Questo processo richiede dai 5 ai 15 secondi e costa 0,01 – 0,02 crediti, mentre normalmente pagheresti tra i 15 e i 30 dollari l’ora a un dipendente per lo stesso compito.

Direi che FlowHunt è decisamente più efficiente.

Criticità nell’Implementazione dell’OCR

Sebbene l’OCR sia estremamente vantaggioso, presenta alcune sfide:

1. Qualità delle Immagini: L’accuratezza dell’OCR dipende molto dalla qualità delle immagini. Immagini sfocate o a bassa risoluzione producono risultati scadenti.
2. Formattazione Complessa: Documenti con layout complessi, font misti o tabelle possono richiedere elaborazione OCR avanzata.
3. Lingua e Set di Caratteri: Alcuni software OCR hanno supporto linguistico limitato e servono modelli specializzati per caratteri non latini.
4. Tasso di Errore: Nessun software OCR è accurato al 100%, specialmente con font corsivi o irregolari, che possono introdurre errori nell’output.

Per affrontare queste sfide è essenziale usare uno strumento OCR potente e flessibile. L’API di FlowHunt offre una soluzione OCR robusta, in grado di gestire anche strutture documentali complesse: ideale per progetti OCR su larga scala.

Configurare lo Script Python per l’OCR

Per automatizzare il processo, installa le seguenti librerie Python:

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

Questo installerà:

• requests: Per inviare richieste HTTP all’API di FlowHunt e scaricare gli output OCR.
• pdf2image: Per convertire le pagine PDF in immagini.
• flowhunt: L’SDK Python di FlowHunt, che semplifica l’interazione con l’API OCR.

Analisi Dettagliata del Codice

Questo codice prende un PDF, lo converte in immagini, invia ogni immagine a FlowHunt per l’elaborazione OCR e salva l’output in formato CSV.

Import delle Librerie

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 servono per la gestione di JSON, file, espressioni regolari e intervalli di tempo.
• requests: Per gestire le richieste HTTP, come il download dei risultati OCR.
• flowhunt: L’SDK di FlowHunt per autenticazione e comunicazione con l’API OCR.
• pdf2image: Converte le pagine PDF in immagini, permettendo l’OCR per pagina.

Funzione per Convertire le Pagine PDF in Immagini

def convert_pdf_to_image(path: str) -> None:
    """
    Converti un file PDF in immagini, salvando ogni pagina come 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 ogni pagina PDF in un’immagine.
• images[i].save: Salva ogni pagina come JPEG per l’OCR.

Estrazione dell’URL dell’Allegato di Output

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

• La funzione recupera l’URL per scaricare l’output OCR.
• Usa regex per trovare l’oggetto JSON con il link per il download.

Configurazione e Autenticazione API

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 il PDF in immagini.
• Configura l’accesso API con le credenziali FlowHunt.

Inizializzazione del Client 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 il workspace_id per le chiamate API successive.

Avvio di una Sessione Flow

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)

• Crea una sessione per caricare immagini e processare l’OCR.

Caricamento delle Immagini per l’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()
            )

• Carica ogni immagine nella sessione per l’elaborazione OCR.

Avvio del Processo OCR e Polling dei Risultati

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)

• Esegue l’OCR e controlla ogni 3 secondi fino al completamento.

Download e Salvataggio dell’Output 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)

• Scarica l’output CSV e lo salva localmente.

Esecuzione dello Script e Test degli Output

Per eseguire lo script:

1. Inserisci il tuo PDF nella cartella data/.
2. Aggiorna <FLOW_ID_HERE> e <API_KEY_HERE> con le tue credenziali FlowHunt.
3. Avvia lo script per convertire il PDF, caricare le immagini per l’OCR e scaricare i risultati strutturati in CSV.

Conclusione

Questo script Python offre una soluzione efficiente per scalare i processi OCR, ideale per i settori con grandi volumi di documenti. Grazie all’API di FlowHunt, la soluzione gestisce la conversione da documento a CSV, semplificando i flussi di lavoro e aumentando la produttività.

Panoramica Completa del Codice

Clicca QUI per la versione 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:
    """
    Converti un file pdf in immagine
    :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)