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

Présentation

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 des données 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 dans le traitement affectent non seulement les cycles des comptes fournisseurs et la visibilité des flux de trésorerie, mais introduisent également des goulots d'étranglement en matière de conformité, de vérification et de production de rapports.

Ce tutoriel explique comment mettre en oeuvre un pipeline automatisé qui surveille un seau dans Oracle Cloud Infrastructure (OCI) pour les images de facture entrantes, extrait du contenu textuel à l'aide du service Vision OCI, puis applique le service Intelligence artificielle générative pour OCI (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	Objet
Service de visualisation pour OCI	Exécute le registre OCR sur les images de facture chargées.
Service d'intelligence artificielle générative pour OCI	Extrait des données JSON structurées à partir du texte ROC brut à l'aide d'invites instantanées.
Service de stockage d'objets pour OCI	Stocke les images de facture d'entrée et les résultats JSON de sortie.

Objectifs

Automatisez l'ingestion des factures à partir du stockage d'objets OCI.
Extraire les données structurées des documents numérisés semi-structurés.
Intégrer la reconnaissance optique de caractères (OCR) et le LLM dans les pipelines en temps réel à l'aide des services d'intelligence artificielle pour OCI.

Conditions requises

Un compte OCI avec accès à :
- Service de visualisation OCI
- Service d'intelligence artificielle générative pour OCI
- Service de stockage d'objets pour OCI
Une version Python 3.10 ou ultérieure.
Seau pour les images d'entrée (par exemple, input-bucket) et autre pour les fichiers de sortie (par exemple, output-bucket).
Téléchargez les fichiers suivants :

Tâche 1 : Configurer les ensembles Python

Exécutez le fichier requirements.txt à l'aide de la commande suivante.
```
pip install -r requirements.txt
```
Exécutez le script Python (main.py).
Chargez des images de facture (par exemple, .png, .jpg) dans votre seau d'entrée.
Attendez que l'image soit traitée et que le fichier JSON extrait soit enregistré dans le seau 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 seau, l'ID compartiment et le point d'extrémité 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"
}

Initialiser 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 de trousse SDK OCI pour accéder aux services de stockage d'objets et de visualisation OCI. Pour plus d'informations, voir Service de visualisation pour OCI.

Initialiser le GML :

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 d'intelligence artificielle générative pour OCI pour la compréhension du langage naturel et la conversion de texte à structure.

Invite de quelques clichés :
```
few_shot_examples = [ ... ]
instruction = """
You are a fiscal data extractor.
...
"""
```
Ce code utilise un apprentissage avec peu d'instantanés 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 au service de visualisation OCI.
Demande la détection de texte.
Retourne le texte brut extrait.

Extraction de données avec GML :

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, un exemple avec quelques clichés et du texte OCR.
Prépare les données ROC retournées par le service de visualisation OCI.
Envoie-le au service d'intelligence artificielle générative pour OCI.
Reçoit les champs JSON structurés (sous forme de chaîne).
OCI Vision prend en charge la reconnaissance optique de caractères portugaise (language="POR" peut être utilisé au lieu de "ENG").

Enregistrer la sortie dans le stockage d'objets OCI :
```
def save_output(result, file_name):
    ...
```
Ce code charge le résultat structuré dans le seau de sortie à l'aide du nom de fichier initial avec l'extension .json.
Boucle principale - Surveiller et traiter :
```
def monitor_bucket():
    ...
```
Routine principale :
- Surveille le seau d'entrée toutes les 30 secondes.
- Détecte les nouveaux fichiers .png, .jpg, .jpeg.
- Exécute le registre OCR, le grand modèle de langage et le chargement dans l'ordre.
- Conserve le suivi des fichiers déjà traités dans la mémoire.
Point d'entrée :
```
if __name__ == "__main__":
    monitor_bucket()
```
Ce code démarre l'observateur de seau et commence à traiter automatiquement les factures.

Tâche 3 : Exécuter le code

Exécutez le code à l'aide de la commande suivante.

python main.py

Tâche 4 : Suggestions de test

Utiliser des factures réelles ou fictives avec des gammes de produits lisibles et un nom de client.
Chargez plusieurs images dans le seau d'entrée en séquence pour voir le traitement automatisé.
Connectez-vous à la console OCI, naviguez jusqu'au service Stockage d'objets pour vérifier les résultats dans les deux seaux.

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

Facture

Tâche 5 : Voir la sortie attendue

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

Note :

OCI Vision prend en charge la reconnaissance optique de caractères portugaise (language="POR" peut être utilisé au lieu de "ENG").

L'invite de GML peut être ajustée 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 erreurs.

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

Remerciements

Auteur - Cristiano Hoshikawa (Oracle LAD A - Analyste des solutions d'équipe)

Ressources d'apprentissage supplémentaires

Explorez d'autres laboratoires sur le site docs.oracle.com/learn ou accédez à plus de contenu d'apprentissage gratuit sur le canal Oracle Learning YouTube. De plus, visitez education.oracle.com/learning-explorer pour devenir un explorateur Oracle Learning.

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

Informations sur le titre et les droits d'auteur

Automate Invoice Images with OCI Vision and OCI Generative AI

G39784-01