0Pricing
AI Engineering Academy · Leçon

Extraire des données d’un texte non structuré

Construisez un pipeline d’extraction d’informations qui lit du texte brut, comme des e-mails, des reçus et des articles, puis renvoie des champs structurés avec des types, des valeurs par défaut et une validation.

Extraire des données d’un texte non structuré est une leçon AI Engineering Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage AI Engineering Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours AI Engineering Academy comprend 4 leçons au total.

Le problème de l’extraction d’informations

Les organisations croulent sous les textes non structurés : e-mails, tickets d’assistance, contrats, factures, articles de presse, notes médicales et publications sur les réseaux sociaux. Des données structurées précieuses sont enfouies dans ces textes, mais leur extraction manuelle est lente, coûteuse et sujette aux erreurs. Les LLM dotés de sorties structurées changent la donne : ils peuvent lire n’importe quel texte et remplir un schéma prédéfini avec les champs pertinents, à grande échelle et avec une précision raisonnable.

L’extraction d’informations (IE) est le processus qui consiste à identifier et à extraire automatiquement des faits structurés à partir de textes non structurés. L’IE fondée sur les LLM surpasse largement les approches antérieures fondées sur des règles ou sur le traitement classique du langage naturel, car les LLM comprennent le contexte, la synonymie et les informations implicites sans nécessiter de motifs regex élaborés manuellement pour chaque variante.

Cas d’utilisation courants de l’extraction

L’extraction d’informations alimente de nombreuses applications métier utiles :

  • Traitement des factures : extraire le fournisseur, les postes, les montants et les dates d’échéance des factures PDF afin d’automatiser la gestion des comptes fournisseurs
  • Analyse des contrats : extraire les parties, les dates d’entrée en vigueur, les conditions de paiement et les clauses de résiliation des documents juridiques
  • Analyse des CV : extraire les compétences, l’expérience, la formation et les coordonnées des CV pour les systèmes ATS
  • Routage des tickets d’assistance : extraire la catégorie, la gravité, le produit concerné et le niveau du client afin d’orienter automatiquement les tickets
  • Veille médiatique : extraire les entités, les événements et les sentiments des articles de presse pour la veille concurrentielle

Créer un pipeline d’extraction d’e-mails

Construisons un pipeline d’extraction pratique qui lit les e-mails des clients et en extrait des données structurées exploitables. Le pipeline utilise un schéma Pydantic pour définir précisément ce que nous voulons obtenir de chaque e-mail, puis traite les e-mails par lots.

import openai
from pydantic import BaseModel
from typing import List, Optional
from enum import Enum

client = openai.OpenAI()

class Priority(str, Enum):
    urgent = 'urgent'
    high = 'high'
    normal = 'normal'
    low = 'low'

class EmailExtraction(BaseModel):
    subject_summary: str
    sender_intent: str
    product_mentioned: Optional[str]
    issue_category: str  # billing / technical / general / feedback
    priority: Priority
    action_required: bool
    action_description: Optional[str]
    customer_sentiment: str  # positive / negative / neutral / frustrated

def extract_from_email(email_body: str) -> EmailExtraction:
    result = client.beta.chat.completions.parse(
        model='gpt-4o-mini',
        messages=[
            {'role': 'system', 'content': 'You are an expert at analyzing customer emails and extracting structured information for a support team.'},
            {'role': 'user', 'content': f'Analyze this customer email:\n\n{email_body}'}
        ],
        response_format=EmailExtraction
    )
    return result.choices[0].message.parsed

Reconnaissance d’entités nommées avec les LLM

La reconnaissance d’entités nommées (NER) est une tâche classique d’IE : elle consiste à identifier et à classer les entités nommées (personnes, organisations, lieux, dates et montants) dans un texte. Les LLM simplifient considérablement la NER : il vous suffit de décrire les entités recherchées, et ils les extraient sans nécessiter de modèle de NER spécialement entraîné.

import openai
from pydantic import BaseModel
from typing import List, Optional

client = openai.OpenAI()

class NamedEntity(BaseModel):
    text: str       # The exact text as it appears
    entity_type: str  # PERSON / ORG / LOCATION / DATE / MONEY / PRODUCT
    normalized: Optional[str]  # Standardized form where applicable

class NERResult(BaseModel):
    entities: List[NamedEntity]

text = '''
Apple Inc. CEO Tim Cook announced yesterday that the company will invest $1.2 billion
in a new manufacturing facility in Austin, Texas, expected to open in Q3 2026.
'''

result = client.beta.chat.completions.parse(
    model='gpt-4o-mini',
    messages=[
        {'role': 'system', 'content': 'Extract all named entities from the text. Classify each as PERSON, ORG, LOCATION, DATE, MONEY, or PRODUCT.'},
        {'role': 'user', 'content': text}
    ],
    response_format=NERResult
)
for entity in result.choices[0].message.parsed.entities:
    print(f'[{entity.entity_type}] {entity.text}')

Extraire des documents à grande échelle

Pour les pipelines d’extraction en production qui traitent des milliers de documents, vous avez besoin d’un traitement asynchrone et d’une gestion des limites de débit. Un schéma courant utilise asyncio avec un sémaphore pour traiter les documents en parallèle tout en respectant les limites de débit de l’API.

import asyncio
import openai
from pydantic import BaseModel
from typing import List, Optional

async_client = openai.AsyncOpenAI()

class InvoiceExtraction(BaseModel):
    vendor: str
    total_amount: Optional[float]
    currency: str
    invoice_date: Optional[str]

async def extract_invoice(doc_text: str, semaphore: asyncio.Semaphore) -> InvoiceExtraction:
    async with semaphore:  # Limit concurrent requests
        result = await async_client.beta.chat.completions.parse(
            model='gpt-4o-mini',
            messages=[
                {'role': 'system', 'content': 'Extract invoice data.'},
                {'role': 'user', 'content': doc_text}
            ],
            response_format=InvoiceExtraction
        )
        return result.choices[0].message.parsed

async def process_invoices(documents: List[str]):
    sem = asyncio.Semaphore(5)  # Max 5 concurrent requests
    tasks = [extract_invoice(doc, sem) for doc in documents]
    return await asyncio.gather(*tasks, return_exceptions=True)

# results = asyncio.run(process_invoices(invoice_texts))
print('Async pipeline defined - handles rate limits via semaphore')

Gérer les informations implicites et déduites

Les LLM peuvent extraire non seulement les informations explicitement énoncées, mais aussi les informations déduites ou implicites. Si un avis indique : « J’utilise ce produit quotidiennement depuis un mois et il fonctionne toujours parfaitement », le modèle peut déduire que la durabilité est un attribut positif, même si le mot « durabilité » n’apparaît jamais. C’est un avantage majeur par rapport à l’extraction fondée sur des expressions régulières, qui ne peut trouver que ce qui est explicitement présent.

Toutefois, cette capacité comporte un risque : le modèle peut déduire à l’excès et remplir des champs avec des suppositions plutôt qu’avec des faits. Pour les extractions à forts enjeux (juridiques, financières ou médicales), ajoutez un champ confidence à votre schéma et demandez au modèle d’évaluer son degré de certitude, en signalant les extractions peu fiables pour une vérification humaine.

Concevoir les invites d’extraction

La qualité de votre extraction dépend largement de la conception de l’invite. Principes essentiels pour les invites d’extraction :

  • Définir les champs ambigus : si « date » peut désigner la date de facture, la date d’échéance ou la date de réception, précisez exactement celle que vous voulez
  • Fournir des exemples pour les formats inhabituels : « Pour le prix, renvoyez uniquement la valeur numérique, par exemple 29.99 et non $29.99 »
  • Gérer la normalisation : « Normalisez les noms de pays sous forme de codes ISO 3166-1 alpha-2 »
  • Préciser la source de l’extraction : « Extrayez uniquement de la ligne d’objet, pas du corps de l’e-mail »

Considérez l’invite d’extraction comme une spécification précise destinée à un opérateur humain de saisie de données : chaque ambiguïté que vous laissez dans l’invite devient une décision que le modèle prendra de manière incohérente.

Extraction en plusieurs passes pour les documents complexes

Certains documents sont trop complexes pour être extraits en une seule passe, car le schéma complet est volumineux, les différentes sections nécessitent des compétences différentes ou la structure du document est très variable. L’extraction en plusieurs passes décompose la tâche en étapes successives : classer d’abord le type de document, puis extraire le schéma approprié pour ce type.

import openai
from pydantic import BaseModel
from typing import Optional

client = openai.OpenAI()

class DocumentType(BaseModel):
    doc_type: str  # invoice / contract / resume / report
    confidence: float

def classify_document(text: str) -> str:
    result = client.beta.chat.completions.parse(
        model='gpt-4o-mini',
        messages=[
            {'role': 'system', 'content': 'Classify the document type.'},
            {'role': 'user', 'content': text[:500]}  # Use only the beginning for classification
        ],
        response_format=DocumentType
    )
    return result.choices[0].message.parsed.doc_type

# Then route to the appropriate extraction schema
EXTRACTION_SCHEMAS = {
    'invoice': 'InvoiceSchema',  # Replace with actual Pydantic classes
    'contract': 'ContractSchema',
    'resume': 'ResumeSchema',
}

print('Multi-pass: classify first, then extract with the right schema')

Enrichissement après extraction

Les données extraites nécessitent souvent un enrichissement après l’extraction initiale : convertir les noms d’entreprises extraits en formes normalisées en interrogeant une base de données d’entreprises, rechercher le code postal extrait pour renseigner la ville et l’État, ou convertir les dates extraites dans un format standard. Cette étape d’enrichissement doit avoir lieu dans le code de votre application après l’extraction, et non pendant l’appel au LLM.

En séparant l’extraction et l’enrichissement, vous rendez le pipeline plus facile à tester et à maintenir. Vous pouvez tester unitairement la logique d’enrichissement de manière indépendante et remplacer le modèle d’extraction sans modifier votre code d’enrichissement.

Mesurer la précision de l’extraction

Pour les pipelines d’extraction en production, mesurez systématiquement la précision sur un ensemble de test annoté. Les principales métriques sont :

  • Précision par champ : pourcentage de champs correctement extraits pour chaque document
  • Correspondance exacte : la valeur du champ correspond exactement à la vérité terrain
  • Correspondance normalisée : la valeur du champ correspond après normalisation (par exemple, '$1,234.00' == '1234.0')
  • Taux de faux positifs : fréquence à laquelle le modèle extrait un champ qui devrait être nul
  • Taux de faux négatifs : fréquence à laquelle le modèle renvoie une valeur nulle pour un champ qui est présent

Effectuez cette évaluation chaque fois que vous changez de modèle, mettez à jour les invites ou ajoutez de nouvelles sources de documents à votre pipeline. Même de faibles baisses de précision peuvent avoir un impact métier important lors du traitement de milliers de documents.

Journalisation de l’extraction pour une amélioration continue

Chaque résultat d’extraction en production constitue une donnée susceptible d’améliorer votre pipeline. Consignez dans une base de données chaque document d’entrée, chaque sortie extraite et toute erreur de validation. Prélevez périodiquement des exemples dans les journaux de production afin d’identifier les échecs fréquents : certains formats de documents avec lesquels le modèle éprouve des difficultés, des champs souvent nuls alors qu’ils ne devraient pas l’être, ou des valeurs inhabituelles qui indiquent une dérive de l’invite.

Ces données consignées deviennent également votre futur ensemble de données d’entraînement si vous souhaitez un jour ajuster un modèle spécifiquement pour votre tâche d’extraction. Vous disposez ainsi d’une solution plus précise et moins coûteuse que des LLM généralistes pour l’extraction structurée.

Vérification rapide

Testez votre compréhension des concepts d’ingénierie de l’IA présentés dans cette leçon.

Récapitulatif de la leçon

Dans cette leçon, vous avez appris que : les LLM dotés de schémas Pydantic extraient de manière fiable des données structurées depuis n’importe quelle source de texte non structurée, que le traitement asynchrone avec des sémaphores permet l’extraction par lots de milliers de documents tout en respectant les limites de débit, et que l’extraction en plusieurs passes commence par classer les documents, puis applique le schéma approprié à chaque type. Nous allons maintenant créer une logique de validation et de nouvelle tentative automatique pour gérer les cas où les données extraites ne respectent pas les règles métier.

Questions Fréquemment Posées

La leçon « Extraire des données d’un texte non structuré » est-elle gratuite ?

Oui — le texte complet de « Extraire des données d’un texte non structuré » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours AI Engineering Academy, passe à CoddyKit PRO. Le cours AI Engineering Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Extraire des données d’un texte non structuré » ?

Construisez un pipeline d’extraction d’informations qui lit du texte brut, comme des e-mails, des reçus et des articles, puis renvoie des champs structurés avec des types, des valeurs par défaut et u… Tu pratiques AI Engineering Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer AI Engineering Academy ?

Aucune expérience préalable n'est requise. AI Engineering Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Extraire des données d’un texte non structuré » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon AI Engineering Academy ?

Oui. Chaque leçon AI Engineering Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Mode JSON et response_format
  2. Sorties structurées avec Pydantic
  3. Extraire des données d’un texte non structuré
  4. Valider et relancer les sorties incorrectes
← Retour à AI Engineering Academy