AI OCR -laskudatan poiminta yksinkertaisella Python-skriptillä

Mitä on tekoälypohjainen OCR?

Tekoälyohjattu OCR ylittää perinteisen OCR:n kyvykkyydet hyödyntämällä tekoälyä asiayhteyksien ymmärtämiseen, monipuolisten asettelujen käsittelyyn sekä korkealaatuisen rakenteisen datan poimintaan monimutkaisistakin asiakirjoista. Siinä missä perinteinen OCR on suunniteltu poimimaan tekstiä kiinteästä muodosta, AI-OCR pystyy käsittelemään monia erilaisia asetteluja ja rakenteita, joita laskuissa ja muissa yritysasiakirjoissa esiintyy.

Tekoälypohjaisen OCR:n keskeiset ominaisuudet

• Kontekstin ymmärrys: AI-OCR hyödyntää NLP:tä asiakirjojen kontekstin ymmärtämiseen. Se tunnistaa kentät, kuten “Yhteissumma”, “Laskun päivämäärä” ja “Asiakkaan nimi” vaikka ne esiintyisivät eri paikoissa.
• Joustavuus: Perinteinen OCR menee helposti sekaisin epäsäännöllisissä asetteluissa; AI-OCR on joustava ja poimii tietoa erilaisista laskumuodoista ilman ongelmia.
• Datan rakenteistaminen: Usein AI-OCR tuottaa suoraan rakenteisia tulosteita, jotka ovat paljon helpompia jatkokäsittelylle kuin perinteisen OCR:n raakateksti.

Miksi käyttää AI-OCR:ää laskuille?

Laskut tulee käsitellä tehokkaasti ja erittäin tarkasti, oli kyse sitten taloushallinnosta, logistiikasta tai hankinnoista. AI-OCR automatisoi tiedon poiminnan ja virtaviivaistaa työnkulkuja, parantaen tietojen tarkkuutta.

AI-OCR:n hyödyt laskuille

• Nopeus ja tehokkuus: AI-OCR:llä suuri määrä laskuja voidaan käsitellä hyvin nopeasti, vapauttaen resursseja ja työvoimaa.
• Parantunut tarkkuus: Laajasti erilaisilla dokumenteilla koulutetut AI-mallit vähentävät manuaaliseen syöttöön liittyviä virheitä.
• Sujuvampi tiedonhallinta: Koska tieto on jo rakenteista, se yhdistyy helposti tietokantoihin, analytiikkajärjestelmiin ja jopa ERP-järjestelmiin.
• Skaalautuvuus: AI-OCR pystyy käsittelemään suuria dokumenttimääriä ilman henkilöstön lisäämistä – ihanteellista isoille tai nopeasti kasvaville organisaatioille.

FlowHuntin AI-OCR-työkalun ROI

Useimmat yritykset poimivat laskudataa manuaalisesti työntekijöiden avulla. Tämä on aikaa vievää ja kallista, vaikka prosessi voitaisiin automatisoida monilla eri toimialoilla, kuten vero-, laki- ja talousyrityksissä sekä muissa.

Tämä prosessi vie 5–15 sekuntia ja maksaa 0,01–0,02 krediittiä, kun taas työntekijälle samasta työstä pitäisi maksaa 15–30 dollaria tunnilta.

Väitän, että FlowHunt on huomattavasti tehokkaampi.

Haasteet OCR:n käyttöönotossa

Vaikka OCR on erittäin hyödyllinen, siihen liittyy joitakin haasteita:

1. Kuvanlaatu: OCR:n tarkkuus riippuu huomattavasti kuvanlaadusta. Epätarkat tai matalaresoluutioiset kuvat tuottavat huonoja tuloksia.
2. Monimutkaiset asettelut: Asiakirjat, joissa on monimutkaisia asetteluja, sekafontteja tai taulukoita, voivat vaatia kehittynyttä OCR-käsittelyä.
3. Kieli ja merkkivalikoima: OCR-ohjelmistolla voi olla rajoitettu kielituki, mikä vaatii erikoismalleja ei-latinalaisille merkeille.
4. Virheprosentti: Mikään OCR-ohjelma ei ole 100 % tarkka, erityisesti käsin kirjoitetuilla tai epäsäännöllisillä fonteilla, mikä voi aiheuttaa virheitä tulosteessa.

Näiden haasteiden ratkaisemiseksi on tärkeää käyttää tehokasta ja joustavaa OCR-työkalua. FlowHuntin API tarjoaa vankan OCR-ratkaisun, joka kykenee käsittelemään monimutkaisia dokumenttirakenteita – ihanteellinen laajamittaisiin OCR-projekteihin.

Python OCR -skriptin käyttöönotto

Prosessin automatisoimiseksi sinun tulee asentaa seuraavat Python-kirjastot:

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

Tämä asentaa:

• requests: HTTP-pyyntöjen lähettämiseen FlowHuntin API:in ja OCR-tulosteiden lataamiseen.
• pdf2image: PDF-sivujen muuntamiseen kuviksi.
• flowhunt: FlowHuntin Python SDK, joka helpottaa vuorovaikutusta OCR-API:n kanssa.

Koodin vaiheittainen läpikäynti

Tämä koodi ottaa PDF:n, muuntaa sen kuviksi, lähettää jokaisen kuvan FlowHuntiin OCR-käsittelyä varten ja tallentaa tuloksen CSV-muodossa.

Kirjastojen tuonti

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 ja time auttavat JSON:n käsittelyssä, tiedostojen hallinnassa, säännöllisissä lausekkeissa ja aikaväleissä.
• requests: HTTP-pyyntöjen hallintaan, esimerkiksi OCR-tulosten lataamiseen.
• flowhunt: FlowHuntin SDK huolehtii autentikoinnista ja yhteyksistä OCR-API:in.
• pdf2image: Muuntaa PDF-sivut kuviksi mahdollistaen yksittäisen sivun OCR:n.

Funktio PDF-sivujen muuntamiseen kuviksi

def convert_pdf_to_image(path: str) -> None:
    """
    Muunna PDF-tiedosto kuviksi, tallentaen jokaisen sivun JPEG-muodossa.
    """
    images = convert_from_path(path)
    for i in range(len(images)):
        images[i].save('data/images/' + 'page' + str(i) + '.jpg', 'JPEG')

• convert_from_path: Muuntaa jokaisen PDF-sivun kuvaksi.
• images[i].save: Tallentaa jokaisen sivun erilliseksi JPEG-kuvaksi OCR-käsittelyä varten.

Output Attachment -URL:n poiminta

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

• Funktio hakee URL:n OCR-tulosteen lataamista varten.
• Käyttää regexiä löytääkseen JSON-olion latauslinkin kanssa.

API-konfigurointi ja autentikointi

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

• Muuntaa PDF:n kuviksi.
• Määrittää API-yhteyden FlowHuntin tunnuksilla.

API-asiakasohjelman alustaminen

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

• Autentikoi ja hakee workspace_id jatkokäyttöä varten.

Flow-istunnon aloitus

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)

• Luo istunnon kuvien lataamista ja OCR-prosessointia varten.

Kuvien lataaminen OCR-käsittelyyn

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

• Lataa jokaisen kuvan istuntoon OCR-käsittelyä varten.

OCR-prosessoinnin käynnistäminen ja tulosten polling

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)

• Käynnistää OCR-prosessin ja tarkistaa tilan 3 sekunnin välein kunnes valmis.

OCR-tuloksen lataaminen ja tallennus

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)

• Lataa CSV-tulosteen ja tallentaa sen paikallisesti.

Skriptin suorittaminen ja tulosten testaus

Skriptin suorittamiseksi:

1. Sijoita PDF-tiedostosi data/-kansioon.
2. Päivitä <FLOW_ID_HERE> ja <API_KEY_HERE> FlowHunt-tunnuksillasi.
3. Suorita skripti – PDF muunnetaan, kuvat ladataan OCR:ään ja rakenteiset CSV-tulokset ladataan.

Yhteenveto

Tämä Python-skripti tarjoaa tehokkaan ratkaisun OCR-prosessien skaalaamiseen – ihanteellinen aloille, joilla on suuri dokumenttien käsittelytarve. FlowHuntin API:lla tämä ratkaisu hoitaa dokumenttien muunnon CSV-muotoon, virtaviivaistaa työnkulkuja ja lisää tuottavuutta.

Koko koodi

Klikkaa TÄSTÄ Gist-versioon.

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)