AI OCR-fakturauttrekking med et enkelt Python-skript

Hva er AI-basert OCR?

AI-drevet OCR går lenger enn tradisjonell OCR ved å bruke kunstig intelligens for å forstå kontekst, håndtere mange ulike oppsett, og levere høykvalitets strukturell datauttrekking selv fra de mest komplekse dokumentene. Mens tradisjonell OCR er laget for å hente ut tekst fra et fast format, kan AI OCR håndtere mange typer oppsett og konfigurasjoner som ofte finnes i fakturaer og andre forretningsdokumenter.

Nøkkelfunksjoner ved AI-basert OCR

• Kontekstforståelse: AI OCR bruker NLP for å forstå innholdet i dokumenter. Den identifiserer felt som “Totalbeløp”, “Fakturadato” og “Kundenavn” selv om disse feltene dukker opp på ulike steder.
• Fleksibilitet: Tradisjonell OCR sliter med uregelmessige oppsett; AI OCR er fleksibel og kan hente ut informasjon fra ulike fakturaformater uten problemer.
• Datakonstruksjon: Ofte gir AI OCR direkte ut strukturerte data som er enklere å etterbehandle enn tradisjonell OCR sitt råtekst-resultat.

Hvorfor bruke AI OCR for fakturaer?

Fakturaer må behandles effektivt og med høy grad av nøyaktighet, enten det gjelder regnskap, logistikk eller innkjøp. AI OCR automatiserer datauttrekking og strømlinjeformer arbeidsflyten, og forbedrer datanøyaktigheten.

Fordeler med AI OCR for fakturaer

• Hastighet og effektivitet: Med AI OCR kan et stort antall fakturaer behandles på minimal tid, noe som frigjør ressurser og arbeidskraft.
• Forbedret nøyaktighet: AI-modeller, trent på et bredt utvalg av dokumentformater, reduserer feil forbundet med manuell dataregistrering.
• Smidig databehandling: Siden dataene allerede er strukturert, kan de enkelt integreres i databaser, analysesystemer og til og med ERP-systemer.
• Skalerbarhet: AI OCR kan behandle store mengder dokumenter uten å trenge flere ansatte, noe som gjør det ideelt for store organisasjoner eller selskaper i vekst.

ROI ved bruk av FlowHunt sitt AI OCR-verktøy

De fleste tradisjonelle selskaper trekker ut data fra fakturaer manuelt ved hjelp av ansatte. Dette er en svært tidkrevende og kostbar prosess som kan automatiseres i mange ulike bransjer og selskaper, som skatt, jus, finans med mer.

Denne prosessen tar 5 til 15 sekunder og koster 0.01 – 0.02 kreditter, der du normalt ville betalt $15 – $30 per time for at en ansatt skulle utført samme oppgave.

Jeg vil si at FlowHunt er langt mer effektiv.

Utfordringer ved implementering av OCR

Selv om OCR er svært gunstig, finnes det noen utfordringer:

1. Bildekvalitet: OCR-nøyaktighet avhenger i stor grad av bildekvaliteten. Uskarpe eller lavoppløselige bilder gir dårlige resultater.
2. Komplekse oppsett: Dokumenter med komplekse oppsett, blandede fonter eller tabeller kan kreve avansert OCR-behandling.
3. Språk og tegnsett: OCR-programvare kan ha begrenset språkundestøttelse og trenger spesialiserte modeller for ikke-latinske tegn.
4. Feilrate: Ingen OCR-programvare er 100% nøyaktig, særlig med håndskrift eller uregelmessige fonter, noe som kan føre til feil i utdataene.

For å møte disse utfordringene er det viktig å bruke et kraftig og fleksibelt OCR-verktøy. FlowHunt sin API gir en robust OCR-løsning som kan håndtere komplekse dokumentstrukturer, og egner seg perfekt for store OCR-prosjekter.

Sette opp Python OCR-skriptet

For å automatisere prosessen må du installere følgende Python-biblioteker:

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

Dette installerer:

• requests: For å sende HTTP-forespørsler til FlowHunt sin API og laste ned OCR-resultater.
• pdf2image: For å konvertere PDF-sider til bilder.
• flowhunt: FlowHunt sin Python SDK, som forenkler kommunikasjonen med OCR-API-et.

Trinnvis gjennomgang av koden

Denne koden tar en PDF, konverterer den til bilder, sender hvert bilde til FlowHunt for OCR-prosessering, og lagrer resultatet i CSV-format.

Importer 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 hjelper med JSON-håndtering, filbehandling, regulære uttrykk og tidsintervaller.
• requests: Brukes for å håndtere HTTP-forespørsler, som å laste ned OCR-resultater.
• flowhunt: FlowHunt sin SDK håndterer autentisering og kommunikasjon med OCR-API-et.
• pdf2image: Konverterer PDF-sider til bilder, slik at hver side kan OCR-behandles individuelt.

Funksjon for å konvertere PDF-sider til bilder

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: Gjør hver PDF-side om til et bilde.
• images[i].save: Lagrer hver side som en individuell JPEG for OCR-prosessering.

Ekstrahere utdata-vedleggs-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

• Funksjonen henter ut URL-en for nedlasting av OCR-utdata.
• Bruker regex for å finne JSON-objektet med nedlastingslenken.

API-konfigurasjon og autentisering

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 til bilder.
• Setter opp API-tilgang med FlowHunt-legitimasjon.

Initialisere API-klient

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

• Autentiserer og henter workspace_id for påfølgende API-kall.

Starte en flyt-økt

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)

• Setter opp en økt for opplasting av bilder og OCR-behandling.

Laste opp bilder for 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()
            )

• Laster opp hvert bilde i økten for OCR-behandling.

Starte OCR-prosessering og polle etter resultat

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-prosessering og sjekker hvert 3. sekund til det er ferdig.

Laste ned og lagre OCR-utdata

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)

• Laster ned CSV-resultatet og lagrer det lokalt.

Kjøre skriptet og teste resultatet

For å kjøre skriptet:

1. Plasser PDF-filen din i data/-mappen.
2. Oppdater <FLOW_ID_HERE> og <API_KEY_HERE> med FlowHunt-legitimasjon.
3. Kjør skriptet for å konvertere PDF, laste opp bilder til OCR og laste ned de strukturerte CSV-resultatene.

Konklusjon

Dette Python-skriptet gir en effektiv løsning for å skalere OCR-prosesser, ideelt for bransjer med store dokumentbehandlingsbehov. Med FlowHunt sin API håndterer denne løsningen konvertering fra dokument til CSV, strømlinjeformer arbeidsflyt og øker produktiviteten.

Fullstendig kodeoversikt

Klikk HER for Gist-versjonen.

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)