KI-OCR-Rechnungsdatenerfassung mit einem einfachen Python-Skript

Was ist KI-basierte OCR?

KI-gestützte OCR geht über die Möglichkeiten herkömmlicher OCR hinaus, indem sie künstliche Intelligenz nutzt, um den Kontext zu verstehen, zahlreiche Layout-Varianten zu verarbeiten und auch aus den komplexesten Dokumenten hochwertige strukturierte Daten zu extrahieren. Während herkömmliche OCR auf das Auslesen von Texten aus festen Formaten ausgelegt ist, kann KI-OCR viele verschiedene Layouts und Konfigurationen verarbeiten, wie sie in Rechnungen und anderen Geschäftsdokumenten häufig vorkommen.

Wichtige Merkmale der KI-basierten OCR

• Kontextuelles Verständnis: KI-OCR nutzt NLP für das kontextuelle Verständnis in Dokumenten. Sie erkennt Felder wie „Gesamtbetrag“, „Rechnungsdatum“ und „Kundenname“, auch wenn diese an unterschiedlichen Positionen auftauchen.
• Flexibilität: Herkömmliche OCR gerät bei unregelmäßigen Layouts schnell an ihre Grenzen; KI-OCR ist flexibel und kann Informationen aus unterschiedlichen Rechnungsformaten ohne Mühe extrahieren.
• Datenstrukturierung: Oft liefert KI-OCR direkt strukturierte Ausgaben, die für die Nachbearbeitung einfacher zu verwenden sind als der Rohtext traditioneller OCR.

Warum KI-OCR für Rechnungen verwenden?

Rechnungen müssen effizient und mit hoher Genauigkeit verarbeitet werden – egal ob in der Buchhaltung, Logistik oder im Einkauf. KI-OCR automatisiert die Datenerfassung und optimiert die Workflows, was die Datenqualität verbessert.

Vorteile von KI-OCR für Rechnungen

• Geschwindigkeit und Effizienz: Mit KI-OCR lassen sich große Mengen an Rechnungen in kürzester Zeit verarbeiten, wodurch Ressourcen und Personal geschont werden.
• Verbesserte Genauigkeit: KI-Modelle, die auf einer Vielzahl von Dokumentenformaten trainiert wurden, reduzieren Fehler bei der manuellen Dateneingabe.
• Einfacheres Datenmanagement: Da die Daten bereits strukturiert vorliegen, können sie problemlos in Datenbanken, Analysesysteme und sogar ERP-Systeme übernommen werden.
• Skalierbarkeit: KI-OCR kann große Mengen an Dokumenten verarbeiten, ohne dass zusätzliches Personal benötigt wird – ideal für große oder schnell wachsende Unternehmen.

Der ROI beim Einsatz des KI-OCR-Tools von FlowHunt

In den meisten Unternehmen werden Rechnungsdaten noch manuell durch Mitarbeitende extrahiert. Das ist eine sehr zeitintensive und teure Aufgabe, die in vielen Branchen und Unternehmen – etwa im Steuer-, Rechts- oder Finanzwesen – automatisiert werden kann.

Dieser Prozess dauert 5 bis 15 Sekunden und kostet 0,01 – 0,02 Credits, während Sie für einen Mitarbeitenden normalerweise 15 – 30 $ pro Stunde für die gleiche Aufgabe zahlen müssten.

Ich würde sagen, FlowHunt ist um ein Vielfaches effizienter.

Herausforderungen bei der Implementierung von OCR

Obwohl OCR sehr vorteilhaft ist, gibt es einige Herausforderungen:

1. Bildqualität: Die Genauigkeit der OCR hängt stark von der Bildqualität ab. Unscharfe oder niedrig aufgelöste Bilder führen zu schlechten Ergebnissen.
2. Komplexe Formatierung: Dokumente mit komplexen Layouts, gemischten Schriftarten oder Tabellen erfordern fortschrittliche OCR-Verfahren.
3. Sprache und Zeichensatz: OCR-Software unterstützt oft nur begrenzt verschiedene Sprachen und braucht für nicht-lateinische Zeichen spezielle Modelle.
4. Fehlerrate: Keine OCR-Software ist zu 100 % genau – insbesondere bei Schreibschrift oder unregelmäßigen Fonts können Fehler entstehen.

Um diese Herausforderungen zu meistern, ist ein leistungsstarkes und flexibles OCR-Tool erforderlich. Die FlowHunt-API bietet eine robuste OCR-Lösung, die mit komplexen Dokumentstrukturen umgehen kann – ideal für groß angelegte OCR-Projekte.

Einrichtung des Python-OCR-Skripts

Um den Prozess zu automatisieren, müssen Sie folgende Python-Bibliotheken installieren:

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

Dies installiert:

• requests: Zum Senden von HTTP-Anfragen an die FlowHunt-API und zum Herunterladen der OCR-Ausgaben.
• pdf2image: Für die Umwandlung von PDF-Seiten in Bilder.
• flowhunt: Das Python-SDK von FlowHunt vereinfacht die Kommunikation mit der OCR-API.

Schritt-für-Schritt-Erklärung des Codes

Dieser Code nimmt ein PDF, wandelt es in Bilder um, sendet jedes Bild an FlowHunt zur OCR-Verarbeitung und speichert das Ergebnis im CSV-Format.

Bibliotheken importieren

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 und time helfen bei der JSON-Verarbeitung, Dateiverwaltung, regulären Ausdrücken und Zeitintervallen.
• requests: Wird für HTTP-Anfragen wie das Herunterladen der OCR-Ergebnisse verwendet.
• flowhunt: Das SDK von FlowHunt übernimmt die Authentifizierung und Kommunikation mit der OCR-API.
• pdf2image: Wandelt PDF-Seiten in Bilder um, sodass jede Seite einzeln per OCR verarbeitet werden kann.

Funktion zum Konvertieren von PDF-Seiten in 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: Wandelt jede PDF-Seite in ein Bild um.
• images[i].save: Speichert jede Seite als eigenes JPEG zur OCR-Verarbeitung.

Extrahieren der URL des Ausgabeanhangs

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

• Die Funktion ermittelt die URL zum Herunterladen der OCR-Ausgabe.
• Verwendet Regex, um das JSON-Objekt mit dem Download-Link zu finden.

API-Konfiguration und Authentifizierung

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

• Das PDF wird in Bilder umgewandelt.
• Der API-Zugang zu FlowHunt wird mit den Zugangsdaten eingerichtet.

Initialisierung des API-Clients

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

• Authentifiziert und ruft die workspace_id für nachfolgende API-Aufrufe ab.

Starten einer 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)

• Richtet eine Session zum Hochladen von Bildern und für die OCR-Verarbeitung ein.

Bilder für die OCR-Verarbeitung hochladen

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

• Lädt jedes Bild in der Session für die OCR-Verarbeitung hoch.

OCR-Verarbeitung starten und auf Ergebnisse warten

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)

• Startet die OCR-Verarbeitung und fragt alle 3 Sekunden den Status ab, bis die Verarbeitung abgeschlossen ist.

OCR-Ausgabe herunterladen und speichern

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)

• Lädt das CSV-Ergebnis herunter und speichert es lokal.

Das Skript ausführen und Ergebnisse testen

So führen Sie das Skript aus:

1. Platzieren Sie Ihr PDF im data/-Ordner.
2. Tragen Sie <FLOW_ID_HERE> und <API_KEY_HERE> mit Ihren FlowHunt-Zugangsdaten ein.
3. Führen Sie das Skript aus, um das PDF zu konvertieren, die Bilder zur OCR hochzuladen und die strukturierten CSV-Ergebnisse herunterzuladen.

Fazit

Dieses Python-Skript bietet eine effiziente Lösung, um OCR-Prozesse zu skalieren – ideal für Branchen mit hohem Dokumentenaufkommen. Dank der FlowHunt-API gelingt die Umwandlung von Dokumenten zu CSV nahtlos, was Workflows optimiert und die Produktivität steigert.

Vollständige Codeübersicht

Hier klicken für die Gist-Version.

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)