Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Atelier : Extraction structurée

Lektion 15 av 16 Uppdaterad 28 juli 2026 Nybörjare
På denna sida
  1. Objectif de l’atelier
  2. Exercice 1 : Extraction JSON depuis un texte libre
  3. Exercice 2 : Résumé structuré de document
  4. Exercice 3 : Traduction technique avec préservation du format
  5. Viktiga punkter

Objectif de l’atelier

Cet atelier approfondit une compétence introduite lors du précédent : l’extraction structurée, c’est-à-dire la transformation de texte libre en données exploitables par un programme. Il fait le pont entre le langage naturel et tes systèmes d’information : la facture reçue en PDF devient une ligne dans ton logiciel de comptabilité, l’article de veille devient une entrée de tableau de bord. Tu vas t’exercer sur trois cas concrets avec les modèles Mistral : extraction JSON, résumé de document dans un format imposé et traduction technique avec préservation de la mise en forme. Tu réviseras également deux techniques vues dans la section sur les paramètres : le pré-remplissage de l’assistant et les séquences d’arrêt.

Exercice 1 : Extraction JSON depuis un texte libre

Scénario de départ : tu automatises le traitement des factures reçues par e-mail. Le texte varie d’un fournisseur à l’autre, mais tu dois toujours extraire les mêmes champs. Le prompt système verrouille tout ce qui peut l’être : JSON pur sans commentaires, null pour les champs manquants (pas de « non fourni » ni de chaînes vides, car ton code vérifiera is None), des montants sous forme de nombres sans symbole de devise, des dates au format ISO 8601, et la TVA séparée du montant hors taxe. Chacune de ces règles évite un bug d’analyse en aval.

messages = [
    {
        "role": "system",
        "content": """You are a data extractor specialized in accounting documents.
Strict rules:
- Return ONLY valid JSON, no comments or additional text
- If a field is not found, use null (not "not provided", not "")
- Amounts must be numbers (no euro symbol in the value)
- Dates in ISO 8601 format (YYYY-MM-DD)
- VAT must be extracted separately from the pre-tax amount"""
    },
    {
        "role": "user",
        "content": """Extract data from this invoice:

"FACTURE N° 2026-0847
Date : 15 mars 2026

De : CloudServ SAS
     42 rue de la Paix, 75002 Paris
     SIRET : 823 456 789 00012

À : TechCorp SARL
    12 avenue des Champs, 69001 Lyon

Désignation : Hébergement cloud - Pack Premium
Période : 01/03/2026 au 31/03/2026
Montant HT : 1 250,00 EUR
TVA 20% : 250,00 EUR
Total TTC : 1 500,00 EUR

Conditions de paiement : 30 jours fin de mois
IBAN : FR76 3000 4000 0500 0001 2345 678"

JSON Schema:
{
  "numero_facture": "string",
  "date_facture": "string (YYYY-MM-DD)",
  "fournisseur": {
    "nom": "string",
    "adresse": "string",
    "siret": "string"
  },
  "client": {
    "nom": "string",
    "adresse": "string"
  },
  "lignes": [
    {
      "designation": "string",
      "periode": "string",
      "montant_ht": "number"
    }
  ],
  "tva_taux": "number",
  "tva_montant": "number",
  "total_ttc": "number",
  "conditions_paiement": "string",
  "iban": "string"
}"""
    },
    {
        "role": "assistant",
        "content": "{"
    }
]

response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    temperature=0.0,
    stop=["\n}"]
)
# Reconstruct the JSON: "{" + response + "\n}"

Résultat attendu :

{
  "numero_facture": "2026-0847",
  "date_facture": "2026-03-15",
  "fournisseur": {
    "nom": "CloudServ SAS",
    "adresse": "42 rue de la Paix, 75002 Paris",
    "siret": "823 456 789 00012"
  },
  "client": {
    "nom": "TechCorp SARL",
    "adresse": "12 avenue des Champs, 69001 Lyon"
  },
  "lignes": [
    {
      "designation": "Hébergement cloud - Pack Premium",
      "periode": "01/03/2026 au 31/03/2026",
      "montant_ht": 1250.00
    }
  ],
  "tva_taux": 20,
  "tva_montant": 250.00,
  "total_ttc": 1500.00,
  "conditions_paiement": "30 jours fin de mois",
  "iban": "FR76 3000 4000 0500 0001 2345 678"
}

Remarque la combinaison du pré-remplissage de l’assistant (le message "{") et de la séquence d’arrêt : le premier force directement le modèle à produire du JSON sans préambule du type « Voici les données extraites : », le second l’empêche de continuer après l’accolade fermante. Tu reconstruis ensuite le JSON complet côté code.

Exercice 2 : Résumé structuré de document

Deuxième scénario : tu alimentes un tableau de bord de veille interne avec des résumés de longs rapports. Pour garantir un affichage uniforme, chaque résumé doit suivre exactement le même format : le prompt système l’impose, champ par champ, avec des limites de longueur.

messages = [
    {
        "role": "system",
        "content": """You produce structured summaries for a monitoring dashboard.
Mandatory format for each summary:
{
  "titre_court": "max 60 characters",
  "resume": "max 3 sentences, factual, no opinion",
  "impact_business": "low | medium | high",
  "secteurs": ["list of affected sectors"],
  "action_requise": true/false,
  "action_detail": "description if action required, null otherwise"
}"""
    },
    {
        "role": "user",
        "content": """Summarize this article for our monitoring dashboard:

"L'Union européenne a adopté le 28 mars 2026 un nouveau règlement sur
l'intelligence artificielle (AI Act 2.0) qui renforce les obligations de
transparence pour les systèmes de génération de texte et d'images. Les
entreprises qui déploient des modèles de plus de 10 milliards de paramètres
devront désormais publier un rapport d'évaluation des risques trimestriel et
mettre en place un système de traçabilité des contenus générés. Les sanctions
pour non-conformité peuvent atteindre 6% du chiffre d'affaires mondial annuel.
Le règlement entre en vigueur le 1er janvier 2027, avec une période de
transition de 6 mois pour les entreprises déjà en activité. Les PME de moins
de 50 salariés bénéficient d'un régime allégé avec des obligations réduites
de reporting."

Return the structured JSON."""
    }
]

response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    temperature=0.1
)

Voici ce que tu devrais obtenir : un résumé factuel qui condense sans déformer, et un champ d’action qui transforme la veille en décision :

{
  "titre_court": "AI Act 2.0 : nouvelles obligations de transparence IA",
  "resume": "L'UE adopte un renforcement de l'AI Act imposant des rapports trimestriels pour les grands modèles. Les sanctions atteignent 6% du CA mondial. Entrée en vigueur le 1er janvier 2027 avec régime allégé pour les PME.",
  "impact_business": "élevé",
  "secteurs": ["intelligence artificielle", "technologie", "réglementation"],
  "action_requise": true,
  "action_detail": "Évaluer la conformité de nos modèles et planifier la mise en place du reporting trimestriel avant janvier 2027."
}

Ici, la température passe à 0,1 au lieu de 0,0 : un résumé nécessite une légère latitude dans la formulation, contrairement à l’extraction pure où chaque valeur provient du texte source.

Exercice 3 : Traduction technique avec préservation du format

Troisième scénario : traduire une documentation technique du français vers l’anglais tout en conservant exactement la mise en forme Markdown et les termes techniques. Le piège de la traduction technique réside ici : un traducteur trop zélé traduira temperature par « température » dans un exemple de code, et la documentation ne correspondra plus à l’API réelle. La parade consiste à lister explicitement ce qui est intouchable.

messages = [
    {
        "role": "system",
        "content": """You are a technical translator from French to English.

Rules:
- Preserve Markdown formatting EXACTLY (headers, lists, code blocks)
- Do NOT translate terms in backticks
- Do NOT translate variable, function, or parameter names
- Code blocks remain identical (translate comments only)
- Adapt idiomatic expressions to the English technical context
- Use American English"""
    },
    {
        "role": "user",
        "content": """Translate this documentation passage:

## Configuration de l'API

Pour commencer, installez le package `mistralai` :

```bash
pip install mistralai

Authentification

Vous devez configurer votre clé API avant tout appel :

# Initialisation du client Mistral
client = Mistral(api_key="votre-clé")

Important : ne stockez jamais votre clé API en dur dans le code. Utilisez plutôt des variables d’environnement ou un gestionnaire de secrets.

Paramètres disponibles

  • temperature : contrôle la créativité (défaut : 0.7)
  • top_p : filtrage par probabilité cumulée (défaut : 1.0)
  • max_tokens : limite de tokens en sortie""" } ]

response = client.chat.complete( model=“mistral-large-latest”, messages=messages, temperature=0.2 )

Pour valider le résultat, vérifie point par point : les en-têtes Markdown (`##`, `###`) sont conservés, les termes entre backticks (`mistralai`, `temperature`, `top_p`, `max_tokens`) restent en anglais, les blocs de code sont identiques sauf pour le commentaire traduit, le gras (`**Important**`) est préservé, et les listes gardent leur structure. Tout écart sur l'un de ces points signale une règle à renforcer dans le prompt système.

## Techniques avancées pour l'extraction

Une règle d'or traverse cet atelier : ne fais jamais aveuglément confiance à la sortie du modèle. Après l'extraction, valide toujours le JSON côté code :

```python
import json

try:
    data = json.loads(response.choices[0].message.content)
    # Validate required fields
    required_fields = ["numero_facture", "date_facture", "total_ttc"]
    for field in required_fields:
        if field not in data or data[field] is None:
            print(f"Missing field: {field}")
except json.JSONDecodeError:
    print("Invalid response, retry with temperature=0")

Et si, malgré tout, le modèle ne renvoie pas de JSON valide, suis une procédure d’escalade :

  1. Réessaie avec temperature=0.0
  2. Utilise le pré-remplissage de l’assistant pour forcer le format
  3. Ajoute un exemple (one-shot) de la sortie attendue
  4. En dernier recours, analyse la réponse avec une expression régulière pour extraire le JSON

Viktiga punkter

  • Le pré-remplissage de l’assistant et les séquences d’arrêt garantissent un JSON valide
  • Fournis toujours le schéma JSON exact dans le prompt
  • Température 0 pour l’extraction, 0,1–0,2 pour les résumés
  • Valide systématiquement la sortie côté code
  • Pour la traduction technique, liste explicitement ce qui ne doit pas être traduit