Extraction de données de factures par OCR IA avec un script Python simple

Qu’est-ce que l’OCR basé sur l’IA ?

L’OCR piloté par l’IA va au-delà des capacités de l’OCR traditionnel car il utilise l’intelligence artificielle pour comprendre le contexte, traiter une grande variété de mises en page et produire une extraction de données structurées de haute qualité, même à partir des documents les plus complexes. Alors que l’OCR traditionnel est conçu pour extraire du texte à partir d’un format fixe, l’OCR IA peut gérer de nombreux types de dispositions courantes dans les factures et autres documents professionnels.

Fonctionnalités clés de l’OCR basé sur l’IA

• Compréhension contextuelle : L’OCR IA utilise le TAL pour comprendre le contexte des documents. Il identifie des champs comme « Montant total », « Date de facture » ou « Nom du client », même lorsque ces champs apparaissent à des emplacements différents.
• Flexibilité : L’OCR traditionnel a du mal avec les mises en page irrégulières ; l’OCR IA est flexible et peut extraire des informations de différents formats de factures sans difficulté.
• Structuration des données : Souvent, l’OCR IA fournit directement des sorties structurées, plus faciles à exploiter ensuite que le texte brut issu de l’OCR traditionnel.

Pourquoi utiliser l’OCR IA pour les factures ?

Les factures doivent être traitées efficacement et avec un haut degré de précision, que ce soit pour la comptabilité, la logistique ou les achats. L’OCR IA automatise l’extraction des données et fluidifie les processus, améliorant la précision des données.

Avantages de l’OCR IA pour les factures

• Vitesse et efficacité : Avec l’OCR IA, un grand nombre de factures peuvent être traitées en un temps minimal, libérant des ressources et du personnel.
• Précision accrue : Les modèles IA, entraînés sur une grande variété de formats de documents, réduisent les erreurs liées à la saisie manuelle.
• Gestion des données facilitée : Les données étant déjà structurées, elles s’intègrent facilement dans les bases de données, les systèmes d’analyses ou même les ERP.
• Scalabilité : L’OCR IA peut traiter de gros volumes de documents sans nécessiter plus de personnel, ce qui le rend idéal pour les grandes organisations ou celles qui se développent rapidement.

Le ROI de l’outil OCR IA de FlowHunt

La plupart des entreprises conventionnelles extraient les données de factures manuellement en mobilisant des salariés pour ces tâches. C’est une opération très chronophage et coûteuse, qui peut être automatisée dans de nombreux secteurs (fiscal, juridique, financier, etc.).

Ce processus prend 5 à 15 secondes et coûte 0,01 – 0,02 crédits, là où il faudrait habituellement payer 15 à 30 $ de l’heure pour qu’un employé effectue la même tâche.

On peut dire que FlowHunt est bien plus efficace, et de loin.

Problèmes rencontrés lors de la mise en œuvre de l’OCR

Bien que l’OCR soit très utile, il comporte certains défis :

1. Qualité d’image : La précision de l’OCR dépend fortement de la qualité de l’image. Les images floues ou de faible résolution donnent de mauvais résultats.
2. Mise en page complexe : Les documents avec des mises en page complexes, des polices variées ou des tableaux nécessitent un traitement OCR avancé.
3. Langue et jeu de caractères : Les logiciels OCR peuvent avoir un support limité des langues, nécessitant des modèles spécialisés pour les caractères non latins.
4. Taux d’erreur : Aucun OCR n’est fiable à 100 %, surtout avec des écritures manuscrites ou des polices irrégulières, ce qui peut introduire des erreurs.

Pour surmonter ces défis, il est essentiel d’utiliser un outil OCR puissant et flexible. L’API FlowHunt propose une solution OCR robuste, capable de gérer des structures de documents complexes, idéale pour les projets OCR à grande échelle.

Mise en place du script OCR Python

Pour automatiser le processus, installez les bibliothèques Python suivantes :

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

Cela installe :

• requests : Pour envoyer des requêtes HTTP à l’API FlowHunt et télécharger les résultats OCR.
• pdf2image : Pour convertir les pages PDF en images.
• flowhunt : Le SDK Python de FlowHunt, qui simplifie l’interaction avec l’API OCR.

Explication détaillée du code

Ce code prend un PDF, le convertit en images, envoie chaque image à FlowHunt pour traitement OCR et enregistre le résultat au format CSV.

Importer les bibliothèques

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, et time servent à la gestion JSON, aux fichiers, aux expressions régulières et aux temporisations.
• requests : utilisé pour les requêtes HTTP, comme le téléchargement des résultats OCR.
• flowhunt : le SDK FlowHunt gère l’authentification et la communication avec l’API OCR.
• pdf2image : convertit les pages PDF en images, permettant l’OCR page par page.

Fonction pour convertir les pages PDF en images

def convert_pdf_to_image(path: str) -> None:
    """
    Convertit un fichier PDF en images JPEG (une image par page).
    """
    images = convert_from_path(path)
    for i in range(len(images)):
        images[i].save('data/images/' + 'page' + str(i) + '.jpg', 'JPEG')

• convert_from_path : convertit chaque page PDF en image.
• images[i].save : enregistre chaque page individuellement en JPEG pour l’OCR.

Extraction de l’URL de téléchargement du résultat OCR

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

• Cette fonction récupère l’URL pour télécharger le résultat OCR.
• Utilise une regex pour extraire l’objet JSON contenant le lien de téléchargement.

Configuration de l’API et authentification

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

• Convertit le PDF en images.
• Configure l’accès à l’API avec les identifiants FlowHunt.

Initialisation du client API

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

• Authentifie et récupère le workspace_id pour les appels suivants.

Démarrage d’une session Flow

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)

• Crée une session pour téléverser les images et traiter l’OCR.

Téléversement des images pour le traitement OCR

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

• Téléverse chaque image dans la session pour traitement OCR.

Appel du traitement OCR et récupération des résultats

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)

• Déclenche le traitement OCR et interroge toutes les 3 secondes jusqu’à la fin.

Téléchargement et sauvegarde du résultat OCR

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)

• Télécharge le fichier CSV et le sauvegarde localement.

Lancer le script et vérifier le résultat

Pour exécuter ce script :

1. Placez votre PDF dans le dossier data/.
2. Renseignez <FLOW_ID_HERE> et <API_KEY_HERE> avec vos identifiants FlowHunt.
3. Lancez le script pour convertir le PDF, téléverser les images pour OCR et télécharger les résultats structurés au format CSV.

Conclusion

Ce script Python offre une solution efficace pour industrialiser l’OCR, idéale pour les secteurs traitant de grands volumes de documents. Grâce à l’API FlowHunt, cette solution gère la conversion PDF vers CSV, simplifiant les workflows et augmentant la productivité.

Aperçu complet du code

Cliquer ICI pour la version Gist.

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)