Invoice Parse – Fakturadatautvinning for PDF-er og skannede dokumenter

Hvis du noen gang har måttet behandle en faktura manuelt, vet du hvor tidkrevende og kjedelig prosessen kan være. For ikke å nevne, det er utsatt for feil siden det er lett å gå glipp av noe når du gjør alt for hånd.

Det er her fakturaparsere kommer inn. Disse verktøyene automatiserer prosessen med å trekke ut data fra fakturaer, noe som gjør det raskt og enkelt å få informasjonen du trenger. Dette kan spare deg for mye tid og problemer og bidra til å sikre at fakturaene dine behandles nøyaktig.

Denne artikkelen utforsker prosessen med utvinning av fakturadata ved hjelp av fakturaparsere, med en diskusjon av noen av de beste metodene for å gjøre det, inkludert tabellutvinning, avansert OCR og dyp læring.

Vi vil også undersøke fordelene med automatisk utvinning av fakturadata fremfor manuell behandling. La oss dykke rett inn.

Hva er en fakturaparser?

En fakturaparser er en type programvare som er utviklet for å lese og tolke fakturadokumenter. Dette kan inkludere PDF-er, bilder og andre typer filer.

Formålet med en fakturaparser er å trekke ut nøkkelinformasjon fra en faktura, for eksempel faktura-ID, totalt forfalt beløp, fakturadato, kundenavn og så videre. Fakturaparsere kan bidra til å sikre nøyaktighet ved å unngå feil som kan oppstå fra manuell datautvinning.

Denne informasjonen kan deretter brukes til ulike formål, som f.eks AP-automatisering, måned slutt regnskap lukke prosess, og fakturahåndtering.

Fakturaparsere kan være frittstående programmer eller integreres i større forretningssystemer. Disse verktøyene gjør det enklere for team å generere rapporter eller eksportere data til andre applikasjoner, for eksempel Excel, og brukes ofte sammen med andre applikasjoner for forretningsadministrasjon.

Det finnes mange forskjellige programvareløsninger for fakturaanalyse på markedet, så det er viktig å velge en som oppfyller dine spesifikke behov.

Hvordan fungerer en fakturaparser?

For å forstå hvordan fakturaparsere fungerer, er det viktig å ha praktisk kunnskap om parsere.

Parsere brukes til å tolke og behandle dokumenter skrevet på et spesifikt markup-språk. De bryter dokumentet ned i mindre biter, kalt tokens, og analyserer deretter hvert token for å bestemme betydningen og hvordan det passer inn i dokumentets generelle struktur.

For å gjøre dette, må parsere ha en sterk forståelse av grammatikken til markup-språket som brukes. Dette lar dem identifisere individuelle tokens og korrekt forstå relasjonene mellom dem. Avhengig av parseren kan denne prosessen enten være manuell eller automatisk. Manuelle parsere krever at noen går gjennom dokumentet og identifiserer hvert token, mens automatiske parsere bruker algoritmer for å oppdage og behandle tokens automatisk. Uansett spiller parsere en viktig rolle for å gi mening om dokumenter skrevet på markup-språk.

Ved datautvinning kan fakturaparsing analysere et fakturadokument og trekke ut relevant informasjon.

Tenk for eksempel på tilfellet hvor du har fått mange fakturaer og ønsker å lagre data fra dem i et strukturert format. Fakturaparsing lar deg laste inn alle filene og kjøre optisk tegngjenkjenning (OCR) slik at dataene kan leses og alle nøkkelverdi-parene trekkes ut i løpet av noen få minutter. Deretter kan du bruke noen etterbehandlingsalgoritmer for å lagre dem i mer lesbare formater som JSON eller CSV. Du kan også bygge prosesser og arbeidsflyter ved å bruke fakturaanalyse for å automatisere utvinningen av fakturaer fra bedriftens poster.

Fakturaanalyse med Python

Python er et programmeringsspråk for ulike datautvinningsoppgaver, inkludert fakturaparsing. Denne delen vil lære deg hvordan du bruker Python-biblioteker til å trekke ut data fra fakturaer.

Det er vanskelig å bygge en generisk state-of-the-art fakturaparser som kan kjøre på alle datatyper, siden den inkluderer ulike oppgaver som å lese tekst, håndtere språk, fonter, dokumentjustering og trekke ut nøkkelverdi-par. Men med hjelp fra åpen kildekode-prosjekter og litt oppfinnsomhet kunne vi i det minste løse noen av disse problemene og komme i gang.

For eksempel vil vi bruke et verktøy kalt tabula på en eksempelfaktura - et pythonbibliotek for å trekke ut tabeller for fakturaanalyse. For å kjøre kodebiten nedenfor, sørg for at både Python og tabula/tabulate er installert på den lokale maskinen.

sample-invoice.pdf.

from tabula import read_pdf
from tabulate import tabulate
# PDF file to extract tables from
file = "sample-invoice.pdf"

# extract all the tables in the PDF file
#reads table from pdf file
df = read_pdf(file ,pages="all") #address of pdf file
print(tabulate(df[0]))
print(tabulate(df[1]))

Produksjon

-  ------------  ----------------
0  Order Number  12345
1  Invoice Date  January 25, 2016
2  Due Date      January 31, 2016
3  Total Due     $93.50
-  ------------  ----------------

-  -  -------------------------------  ------  -----  ------
0  1  Web Design                       $85.00  0.00%  $85.00
      This is a sample description...
-  -  -------------------------------  ------  -----  ------

Vi kunne trekke ut tabellene fra en PDF-fil med noen få linjer med kode. Dette er fordi PDF-filen var godt formatert, justert og opprettet elektronisk (ikke fanget av kamera). Derimot, hvis dokumentet hadde blitt fanget opp av et kamera i stedet for å bli produsert elektronisk, ville det vært mye vanskeligere for disse algoritmene å trekke ut dataene – det er her optisk tegngjenkjenning kommer inn i bildet.

La oss bruke Tesseract, en populær OCR-motor for python, for å analysere en faktura.

import cv2
import pytesseract
from pytesseract import Output

img = cv2.imread('sample-invoice.jpg')

d = pytesseract.image_to_data(img, output_type=Output.DICT)
print(d.keys())

Dette skal gi deg følgende utgang -

dict_keys(['level', 'page_num', 'block_num', 'par_num', 'line_num', 'word_num', 'left', 'top', 'width', 'height', 'conf', 'text'])

Ved å bruke denne ordboken kan vi få hvert ord oppdaget, informasjonen om grenseboksen, teksten i dem og selvtillitspoeng.

Du kan plotte boksene ved å bruke koden nedenfor -

n_boxes = len(d['text'])
for i in range(n_boxes):
    if float(d['conf'][i]) > 60:
        (x, y, w, h) = (d['left'][i], d['top'][i], d['width'][i], d['height'][i])
        img = cv2.rectangle(img, (x, y), (x + w, y + h), (0, 255, 0), 2)

cv2.imshow('img', img)
cv2.waitKey(0)

Du vil se følgende utgang:

Slik kan vi bruke og gjenkjenne regionene til en faktura. Egendefinerte algoritmer må imidlertid bygges for utvinning av nøkkelverdi-par. Vi lærer mer om dette i de følgende avsnittene.

Problemene med eldre fakturatolkere (regelbasert registrering)

I dag er mange organisasjoner fortsatt avhengige av eldre systemer for utvinning av fakturadata.

Disse "regelbaserte" systemene analyserer hver ordrelinje på fakturaer og sammenligner dem deretter med et sett med regler for å avgjøre om informasjonen skal legges til databasen deres.

Denne metoden har vært brukt i lang tid, men har flere ulemper. La oss se på noen vanlige problemer for eldre fakturaparsere.

• Sidetilt under skanning: Et problem med regelbaserte fakturaparsere er at de kan ha problemer med «sidetilt». Dette skjer når feltene i en faktura ikke er plassert i en rett linje, noe som gjør det vanskelig for parseren å nøyaktig identifisere og trekke ut dataene. Dette kan ofte være forårsaket av skrivere som ikke skriver ut jevnt eller av manuell inntasting av data som kanskje ikke er riktig justert.
• Formatendring: Et av de vanligste problemene en virksomhet står overfor er fakturaer som ikke er formatert i standardformat. Dette kan skape problemer når du prøver å trekke ut data fra en faktura. For eksempel kan forskjellige fonter brukes, og fakturaoppsettet kan endres fra en måned til en annen. Det er vanskelig å analysere dataene og bestemme hva hver kolonne representerer. For eksempel kan noen nye felt legges til fakturaen, eller noen eksisterende felt kan plasseres i forskjellige posisjoner. Eller det kan være en helt ny struktur som gjør at en vanlig regelbasert parser ikke vil kunne gjenkjenne fakturaer riktig.
• Tabellutvinning: Regelbaserte tabelluttrekkere er ofte den mest enkle og enkle måten å trekke ut data fra en tabell. Imidlertid har de sine begrensninger når de håndterer tabeller som ikke inneholder noen overskrifter eller inkluderer nullverdier i spesifikke kolonner fordi disse scenariene vil forårsake en uendelig sløyfe under behandling som resulterer i enten å kaste bort tid på å laste uendelig lange rader inn i minnet (eller ikke sende ut noe i det hele tatt) hvis det var avhengige uttrykk som også involverer disse attributtene. I tillegg, når tabeller spenner over flere sider, behandler regelbaserte parsere dem som forskjellige tabeller i stedet for én, og vil dermed villede utvinningsprosessen.

Bygg en AI-basert fakturaparser med Nanonets

Fakturaparsere med optisk tegngjenkjenning (OCR) og dyp læring kan trekke ut data fra fakturaer som er skannet eller konvertert til PDF-filer. Disse dataene kan deretter fylle ut regnskapsprogramvare, spore utgifter og generere rapporter.

Dyplæringsalgoritmer kan lære å identifisere spesifikke elementer i en faktura, for eksempel kundens navn, adresse og produktinformasjon. Dette muliggjør mer nøyaktig datautvinning og kan redusere tiden som trengs for å legge inn data manuelt i et system. Å bygge slike algoritmer krever imidlertid mye tid og ekspertise, men ikke bekymre deg; Nanonetter har ryggen din!

Nanonets er en OCR-programvare som bruker kunstig intelligens for å automatisere utvinningen av tabeller fra PDF-dokumenter, bilder og skannede filer. I motsetning til andre løsninger, krever det ikke separate regler og maler for hver nye dokumenttype. I stedet er den avhengig av kognitiv intelligens for å håndtere semistrukturerte og usynlige dokumenter mens den forbedres over tid. Du kan også tilpasse utdataene til kun å trekke ut tabeller eller dataoppføringer av din interesse.

Den er rask, nøyaktig, enkel å bruke, lar brukere bygge tilpassede OCR-modeller fra bunnen av, og har noen pene Zapier-integrasjoner. Digitaliser dokumenter, trekk ut tabeller eller datafelt, og integrer med hverdagsappene dine via APIer i et enkelt, intuitivt grensesnitt.

[Innebygd innhold]

Hvorfor er Nanonets den beste PDF-parseren?

• Nanonetter kan trekke ut data på siden mens kommandolinje-PDF-parsere bare trekker ut objekter, overskrifter og metadata som (tittel, #pages, krypteringsstatus, etc.)
• Nanonets PDF-parsingsteknologi er ikke malbasert. Bortsett fra å tilby forhåndsopplærte modeller for populære bruksområder, kan Nanonets PDF-analyseringsalgoritme også håndtere usynlige dokumenttyper!
• Bortsett fra å håndtere opprinnelige PDF-dokumenter, lar Nanonets innebygde OCR-funksjoner også håndtere skannede dokumenter og bilder!
• Robuste automatiseringsfunksjoner med AI- og ML-funksjoner.
• Nanonetter håndterer ustrukturerte data, vanlige databegrensninger, flersidige PDF-dokumenter, tabeller og flere linjer med letthet.
• Nanonets er et verktøy uten kode som kontinuerlig kan lære seg og trene seg på egendefinerte data for å gi utdata som ikke krever etterbehandling.

Automatisert fakturaparsing med Nanonets – skaper fullstendig berøringsfrie fakturabehandlingsarbeidsflyter

Integrer dine eksisterende verktøy med Nanonets og automatiser datainnsamling, eksportlagring og bokføring.

Nanonetter kan også hjelpe med å automatisere arbeidsflyter for fakturaparsing ved å:

• Importere og konsolidere fakturadata fra flere kilder – e-post, skannede dokumenter, digitale filer/bilder, skylagring, ERP, API, etc.
• Fange og trekke ut fakturadata på en intelligent måte fra fakturaer, kvitteringer, regninger og andre økonomiske dokumenter.
• Kategorisering og koding av transaksjoner basert på forretningsregler.
• Sette opp automatiserte godkjenningsarbeidsflyter for å få interne godkjenninger og administrere unntak.
• Avstemming av alle transaksjoner.
• Integrerer sømløst med ERP-er eller regnskapsprogramvare som Quickbooks, Sage, Xero, Netsuite og mer.