Automatisez les images de facture avec OCI Vision et OCI Generative AI

Introduction

Les entreprises reçoivent souvent des milliers de factures dans des formats non structurés sous forme d'images numérisées ou de PDF provenant de fournisseurs et de fournisseurs de services. L'extraction manuelle de données à partir de ces factures, telles que le numéro de facture, le nom du client, les articles achetés et le montant total, est un processus chronophage et sujet aux erreurs.

Ces retards de traitement affectent non seulement les cycles de comptabilité fournisseurs et la visibilité du flux de trésorerie, mais introduisent également des goulets d'étranglement en matière de conformité, d'audit et de reporting.

Ce tutoriel explique comment implémenter un pipeline automatisé qui surveille un bucket dans Oracle Cloud Infrastructure (OCI) pour les images de facture entrantes, extrait le contenu textuel à l'aide d'OCI Vision, puis applique OCI Generative AI (LLM) pour extraire des données fiscales structurées telles que le numéro de facture, le client et la liste d'articles.

Les services OCI utilisés dans ce tutoriel sont les suivants :

Service	Description
OCI Vision	Effectue un registre OCR sur les images de facture chargées.
OCI Generative AI	Extrait les données JSON structurées à partir du texte OCR brut à l'aide d'invites ponctuelles.
OCI Object Storage	Stocke les images de facture d'entrée et les résultats JSON de sortie.

Objectifs

Automatisez l'ingestion des factures à partir d'OCI Object Storage.
Extraire des données structurées à partir de documents numérisés semi-structurés.
Intégrez la reconnaissance optique de caractères (OCR) et le LLM dans des pipelines en temps réel à l'aide des services d'IA OCI.

Prérequis

Un compte OCI avec accès aux éléments suivants :
- OCI Vision
- OCI Generative AI
- OCI Object Storage
Une version 3.10 Python ou ultérieure.
Un bucket pour les images d'entrée (par exemple, input-bucket) et un autre pour les fichiers de sortie (par exemple, output-bucket).
Téléchargez les fichiers suivants :

Tâche 1 : configurer des packages Python

Exécutez le fichier requirements.txt en utilisant la commande suivante.
```
pip install -r requirements.txt
```
Exécutez le script Python (main.py).
Téléchargez des images de facture (par exemple, .png, .jpg) vers le bucket d'entrée.
Attendez que l'image soit traitée et que le fichier JSON extrait soit enregistré dans le bucket de sortie.

Tâche 2 : comprendre le code

Charger la configuration:

with open("./config", "r") as f:
    config_data = json.load(f)

Ce code charge toutes les valeurs de configuration requises, telles que l'espace de noms, les noms de bucket, l'ID de compartiment et l'adresse de LLM.

Entrez vos paramètres de configuration dans le fichier config.

{
    "oci_profile": "DEFAULT",
    "namespace": "your_namespace",
    "input_bucket": "input-bucket",
    "output_bucket": "output-bucket",
    "compartment_id": "ocid1.compartment.oc1..xxxx",
    "llm_endpoint": "https://inference.generativeai.us-chicago-1.oci.oraclecloud.com"
}

Initialisez les clients OCI :

oci_config = oci.config.from_file("~/.oci/config", PROFILE)
object_storage = oci.object_storage.ObjectStorageClient(oci_config)
ai_vision_client = oci.ai_vision.AIServiceVisionClient(oci_config)

Ce code configure les clients du kit SDK OCI pour accéder aux services OCI Object Storage et OCI Vision. Pour plus d'informations, reportez-vous à OCI Vision.

Initialiser le LLM :

llm = ChatOCIGenAI(
    model_id="meta.llama-3.1-405b-instruct",
    service_endpoint=LLM_ENDPOINT,
    compartment_id=COMPARTMENT_ID,
    auth_profile=PROFILE,
    model_kwargs={"temperature": 0.7, "top_p": 0.75, "max_tokens": 2000},
)

Ce code initialise le modèle OCI Generative AI pour la compréhension du langage naturel et la conversion de texte en structure.

Invite de quelques captures :
```
few_shot_examples = [ ... ]
instruction = """
You are a fiscal data extractor.
...
"""
```
Ce code utilise l'apprentissage ponctuel en fournissant un exemple de sortie attendue afin que le modèle apprenne à extraire des champs structurés tels que number of invoice, customer, location et items.

ROC avec OCI Vision :

def perform_ocr(file_name):
print(f"📄 Performing OCR on: {file_name}")

response = ai_vision_client.analyze_document(
    analyze_document_details=oci.ai_vision.models.AnalyzeDocumentDetails(
        features=[
            oci.ai_vision.models.DocumentTableDetectionFeature(
            feature_type="TEXT_DETECTION")],
        document=oci.ai_vision.models.ObjectStorageDocumentDetails(
            source="OBJECT_STORAGE",
            namespace_name=NAMESPACE,
            bucket_name=INPUT_BUCKET,
            object_name=file_name),
        compartment_id=COMPARTMENT_ID,
        language="POR",
        document_type="INVOICE")
)
print(response.data)
return response.data

Cette fonction :

Envoie l'image à OCI Vision.
Détection de texte des demandes.
Renvoie le texte brut extrait.

Extraction de données avec LLM :

def extract_data_with_llm(ocr_result, file_name):
    # 🔍 Extrai texto OCR (usando a estrutura da resposta do OCI Vision)
    extracted_lines = []
    for page in getattr(ocr_result, 'pages', []):
        for line in getattr(page, 'lines', []):
            extracted_lines.append(line.text.strip())

    plain_text = "\n".join(extracted_lines)

    # 🧠 Monta o prompt com instrução, few-shot e texto OCR limpo
    prompt = instruction + "\n" + "\n".join(few_shot_examples) + f"\nInvoice text:\n{plain_text}\nExtracted fields (JSON format):"

    # 🔗 Chamada ao LLM
    response = llm([HumanMessage(content=prompt)])

    # 🧪 Tenta extrair JSON puro da resposta
    try:
        content = response.content.strip()
        first_brace = content.find("{")
        last_brace = content.rfind("}")
        json_string = content[first_brace:last_brace + 1]
        parsed_json = json.loads(json_string)
    except Exception as e:
        print(f"⚠️ Erro ao extrair JSON da resposta do LLM: {e}")
        parsed_json = {"raw_response": response.content}

    return {
        "file": file_name,
        "result": parsed_json,
        "timestamp": datetime.utcnow().isoformat()
    }

Cette fonction :

Combine des instructions, des exemples peu tracés et du texte OCR.
Prépare les données OCR renvoyées par OCI Vision.
Envoie-le à OCI Generative AI.
Reçoit des champs JSON structurés (sous forme de chaîne).
OCI Vision prend en charge le registre OCR portugais (language="POR" peut être utilisé à la place de "ENG").

Enregistrer la sortie dans OCI Object Storage :
```
def save_output(result, file_name):
    ...
```
Ce code télécharge le résultat structuré dans le bucket de sortie à l'aide du nom de fichier d'origine avec l'extension .json.
Boucle principale - Surveiller et traiter :
```
def monitor_bucket():
    ...
```
Routine principale qui :
- Surveille le bucket d'entrée toutes les 30 secondes.
- Détecte les nouveaux fichiers .png, .jpg et .jpeg.
- Exécute l'OCR, le LLM et le téléchargement dans l'ordre.
- Conserve la trace des fichiers déjà traités en mémoire.
Point de saisie :
```
if __name__ == "__main__":
    monitor_bucket()
```
Ce code démarre le contrôleur de regroupement et commence le traitement automatique des factures.

Tâche 3 : exécuter le code.

Exécutez le code en utilisant la commande suivante.

python main.py

Tâche 4 : Suggestions de test

Utilisez des factures réelles ou fictives avec des lignes de produits et un nom de client lisibles.
Chargez plusieurs images dans le bucket d'entrée en séquence pour voir le traitement automatisé.
Connectez-vous à la console OCI, accédez à Object Storage pour vérifier les résultats dans les deux buckets.

Remarque : Dans ce tutoriel, l'exemple utilisé est une facture brésilienne pour illustrer la complexité des attributs et de la disposition, ainsi que la façon dont l'invite a été créée pour résoudre ce cas.

Facture

Tâche 5 : afficher la sortie attendue

Pour chaque image de facture chargée, examinez le fichier de bucket de sortie traité. Un fichier .json correspondant est généré avec un contenu structuré, comme indiqué dans l'image suivante.

Remarque :

OCI Vision prend en charge le registre OCR portugais (language="POR" peut être utilisé à la place de "ENG").

LLM invite peut être ajusté pour extraire d'autres champs tels que CNPJ, quantidade, data de emissão, etc.

Envisagez de conserver processed_files avec une base de données ou un fichier pour rendre le processus tolérant aux pannes.

Ce processus peut être utilisé avec le cas d'emploi Créer un agent AI avec le serveur de protocole de communication multi-agent pour la résolution des factures en tant qu'image de facture prétraitée. La facture est une facture de transfert par rapport au client de la société. Les champs Client et Lieu sont saisis à partir du créateur de la facture.

Accusés de réception

Auteur - Cristiano Hoshikawa (Oracle LAD A - Ingénieur solutions d'équipe)

Ressources de formation supplémentaires

Explorez d'autres ateliers sur le site docs.oracle.com/learn ou accédez à d'autres contenus d'apprentissage gratuits sur le canal Oracle Learning YouTube. En outre, visitez le site education.oracle.com/learning-explorer pour devenir un explorateur Oracle Learning.

Pour obtenir de la documentation sur le produit, consultez Oracle Help Center.

Informations relatives au titre et au copyright

Automate Invoice Images with OCI Vision and OCI Generative AI

G39789-01