AI OCR-fakturadataudtræk med et simpelt Python-script

Hvad er AI-baseret OCR?

AI-drevet OCR går ud over traditionel OCR’s kapaciteter ved at bruge kunstig intelligens til at forstå kontekst, håndtere mange forskellige layouts og levere struktureret dataudtræk selv fra de mest komplekse dokumenter. Hvor traditionel OCR er designet til at hente tekst fra et fast format, kan AI OCR håndtere mange typer layouts og konfigurationer, som er almindelige i fakturaer og andre forretningsdokumenter.

Nøglefunktioner ved AI-baseret OCR

• Kontextforståelse: AI OCR bruger NLP til at forstå konteksten i dokumenter. Den identificerer felter som “Totalbeløb”, “Fakturadato” og “Kundenavn”, selvom disse felter optræder forskellige steder.
• Fleksibilitet: Traditionel OCR fejler ofte med uregelmæssige layouts; AI OCR er fleksibel og kan udtrække information fra forskellige fakturaformater uden problemer.
• Datastrukturering: Ofte leverer AI OCR direkte strukturerede output, som er lettere at efterbehandle end traditionel OCR’s rå tekstoutput.

Hvorfor bruge AI OCR til fakturaer?

Fakturaer skal behandles effektivt og med høj nøjagtighed, uanset om det er i regnskabs-, logistik- eller indkøbsafdelingen. AI OCR automatiserer dataudtræk og glatter arbejdsgange, hvilket forbedrer datanøjagtigheden.

Fordele ved AI OCR til fakturaer

• Hastighed og effektivitet: Med AI OCR kan et stort antal fakturaer behandles på minimal tid, hvilket frigør ressourcer og arbejdskraft.
• Forbedret nøjagtighed: AI-modeller, der er trænet på mange forskellige dokumentformater, reducerer fejl forbundet med manuel dataindtastning.
• Glattere databehandling: Da data allerede er struktureret, integreres det nemt i databaser, analysesystemer og endda ERP-systemer.
• Skalerbarhed: AI OCR kan behandle store mængder dokumenter uden behov for flere medarbejdere, hvilket gør det ideelt for store eller hurtigt voksende organisationer.

ROI ved brug af FlowHunt’s AI OCR-værktøj

De fleste almindelige virksomheder udtrækker data fra fakturaer manuelt ved at bruge medarbejdere til disse opgaver. Det er en meget tidskrævende og dyr proces, som kan automatiseres i mange forskellige brancher og virksomheder, såsom skat, jura, finans og flere.

Denne proces tager 5 til 15 sekunder og koster 0,01 – 0,02 credits, hvor du normalt skulle betale 15 – 30 USD i timen for en medarbejder til at udføre samme opgave.

Jeg vil sige, at FlowHunt er langt mere effektiv.

Udfordringer ved implementering af OCR

Selvom OCR er meget gavnligt, er der nogle udfordringer:

1. Billedkvalitet: OCR-nøjagtighed afhænger meget af billedkvaliteten. Slørede eller lavopløselige billeder giver dårlige resultater.
2. Kompleks formatering: Dokumenter med komplekse layouts, blandede skrifttyper eller tabeller kan kræve avanceret OCR-behandling.
3. Sprog og tegnsæt: OCR-software kan have begrænset sprogsupport, hvilket kræver specialmodeller for ikke-latinske tegn.
4. Fejlrate: Ingen OCR-software er 100% nøjagtig, især med kursiv eller uregelmæssige skrifttyper, hvilket kan introducere fejl i output.

For at tackle disse udfordringer er det vigtigt at bruge et kraftfuldt og fleksibelt OCR-værktøj. FlowHunt’s API leverer en robust OCR-løsning, der kan håndtere komplekse dokumentstrukturer, hvilket gør den ideel til storskala OCR-projekter.

Opsætning af Python OCR-scriptet

For at automatisere processen skal du installere følgende Python-biblioteker:

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

Dette installerer:

• requests: Til at sende HTTP-forespørgsler til FlowHunt’s API og hente OCR-uddata.
• pdf2image: Til at konvertere PDF-sider til billeder.
• flowhunt: FlowHunt’s Python SDK, som forenkler interaktionen med OCR API’et.

Gennemgang af koden trin for trin

Denne kode tager en PDF, konverterer den til billeder, sender hvert billede til FlowHunt til OCR-behandling og gemmer outputtet i CSV-format.

Importér biblioteker

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 og time hjælper med JSON-håndtering, filstyring, regulære udtryk og tidsintervaller.
• requests: Bruges til at håndtere HTTP-forespørgsler, f.eks. download af OCR-resultater.
• flowhunt: FlowHunt’s SDK håndterer godkendelse og kommunikation med OCR API’et.
• pdf2image: Konverterer PDF-sider til billeder, så hver side kan OCR-behandles.

Funktion til at konvertere PDF-sider til billeder

def convert_pdf_to_image(path: str) -> None:
    """
    Konverter en PDF-fil til billeder, hvor hver side gemmes som 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: Konverterer hver PDF-side til et billede.
• images[i].save: Gemmer hver side som individuel JPEG til OCR-behandling.

Udtræk af output-attachment-URL

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

• Funktionen henter URL’en til download af OCR-outputtet.
• Bruger regex til at finde JSON-objektet med downloadlinket.

API-konfiguration og autentificering

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>"}
)

• Konverterer PDF’en til billeder.
• Opsætter API-adgang med FlowHunt-legitimationsoplysninger.

Initialisering af API-klienten

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

• Autentificerer og henter workspace_id til efterfølgende API-kald.

Start en Flow-session

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)

• Opretter en session til upload af billeder og OCR-behandling.

Upload af billeder til OCR-behandling

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()
            )

• Uploader hvert billede i sessionen til OCR-behandling.

Udløsning af OCR-behandling og polling efter resultater

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)

• Starter OCR-behandlingen og poller hvert 3. sekund indtil færdig.

Download og gem OCR-output

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)

• Downloader CSV-outputtet og gemmer det lokalt.

Kør scriptet og test output

Sådan kører du scriptet:

1. Placer din PDF i data/-mappen.
2. Opdater <FLOW_ID_HERE> og <API_KEY_HERE> med dine FlowHunt-legitimationsoplysninger.
3. Kør scriptet for at konvertere PDF, uploade billeder til OCR og hente de strukturerede CSV-resultater.

Konklusion

Dette Python-script tilbyder en effektiv løsning til at skalere OCR-processer, ideelt til brancher med stort dokumentbehandlingsbehov. Med FlowHunt’s API håndterer denne løsning konvertering fra dokument til CSV, strømline arbejdsgange og øger produktiviteten.

Fuld kodeoversigt

Klik HER for Gist-versionen.

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)