Parcourir les aide-mémoire · Ingénierie IA pour les données

Technologie: Ingénierie IA pour les donnéesCatégorie: Conception de promptsNiveau: IntermédiaireMis à jour

Patrons de prompts pour l’ingénierie des données

Des patrons de prompts réutilisables pour l’ingénierie des données : génération SQL, interprétation de schéma, mapping de colonnes, règles de qualité et analyse d’incident, avec sortie structurée, hypothèses explicites et validation.

Sur cette page
  1. Problème
  2. Réponse rapide
  3. Patron de base
  4. Code / commandes
  5. 1. Génération de SQL
  6. 2. Explication de SQL
  7. 3. Interprétation de schéma
  8. 4. Mapping de colonnes
  9. 5. Génération de règles de qualité des données
  10. 6. Résumé de journaux
  11. 7. Analyse d’incident
  12. 8. Explication de notebook et de code
  13. 9. Documentation de pipeline
  14. 10. Enrichissement des métadonnées
  15. Techniques réutilisables
  16. Mauvais prompt ou meilleur prompt
  17. Patron de sortie structurée
  18. Patron « demander les hypothèses »
  19. Patron « renvoyer l’incertitude »
  20. Étape de validation
  21. Points à vérifier
  22. Erreurs fréquentes
  23. 1. Envoyer des secrets ou des données clients brutes
  24. 2. Envoyer tout le schéma
  25. 3. Aucun format de sortie
  26. 4. Exécuter directement le SQL généré
  27. 5. Mélanger instructions et données
  28. 6. Exiger une certitude
  29. Notes de production
  30. Liste de contrôle
  31. Étape suivante
  32. Pour aller plus loin

Problème

Les LLM peuvent aider dans le travail de données quotidien :

  • écrire et expliquer du SQL
  • interpréter des schémas inconnus
  • faire correspondre des colonnes source à un modèle cible
  • rédiger des règles de qualité des données
  • résumer des journaux et des incidents
  • documenter des notebooks et des pipelines
  • enrichir des métadonnées

Un prompt vague donne une réponse plausible mais difficile à vérifier. Les tâches de données exigent des prompts qui précisent le contexte, les contraintes et la sortie attendue, ainsi qu’une étape de validation qui ne fait pas confiance au modèle.

Réponse rapide

Utilisez la même structure pour chaque prompt de données :

Objectif :     quoi produire, pour qui
Contexte :     uniquement le schéma, l'échantillon, les journaux ou les règles nécessaires
Contraintes :  dialecte, conventions de nommage, limites, ce qu'il ne faut pas faire
Entrée :       la donnée ou la question, clairement délimitée
Sortie :       format exact (schéma JSON, SQL seul, tableau)
Validation :   ce qui rend la réponse acceptable ; lister les hypothèses ; répondre « inconnu » en cas de doute

Validez ensuite la sortie avec du code, la base de données ou un relecteur avant de l’utiliser.

Ne mettez jamais de secrets, d’identifiants ni de données clients sensibles brutes dans un prompt.

Patron de base

## Objectif
Écris une requête T-SQL qui répond à la question ci-dessous.

## Contexte
Tables (seules celles-ci existent) :
orders(order_id int pk, customer_id int, order_date date, status varchar, amount decimal(12,2))
customers(customer_id int pk, country char(2), segment varchar)

## Contraintes
- SQL Server 2022, SELECT en lecture seule
- utilise uniquement les tables et colonnes listées
- renvoie au maximum 1000 lignes

## Entrée
<question>Chiffre d'affaires par pays des commandes expédiées en septembre 2026.</question>

## Sortie
Renvoie du JSON : {"sql": string, "assumptions": [string], "confidence": "high" | "medium" | "low"}

## Validation
S'il manque une colonne nécessaire, renvoie "sql": null et explique-le dans "assumptions".

Délimitez les entrées (<question>, <logs>, <schema>) pour que les données ne soient pas confondues avec les instructions.

Code / commandes

1. Génération de SQL

Mauvais :

Écris une requête pour le chiffre d'affaires par pays.

Mieux : utilisez le patron de base ci-dessus. Il fixe le dialecte, les tables exactes, les filtres à interpréter et un format à valider.

Validez avant d’exécuter : compilez sans exécuter, avec un compte en lecture seule.

SET NOEXEC ON;   -- SQL Server : compile et vérifie les noms, sans exécuter

SELECT TOP (1000) c.country, SUM(o.amount) AS revenue
FROM dbo.orders AS o
JOIN dbo.customers AS c ON c.customer_id = o.customer_id
WHERE o.status = 'shipped'
  AND o.order_date >= '2026-09-01' AND o.order_date < '2026-10-01'
GROUP BY c.country;

SET NOEXEC OFF;

Les autres moteurs ont des équivalents (par exemple EXPLAIN). Comparez ensuite le résultat à un chiffre connu avant de faire confiance à la requête.


2. Explication de SQL

Explique ce que fait cette requête à un analyste de données.

<sql>
...requête...
</sql>

Sortie (Markdown) :
1. Objectif en une phrase.
2. Logique étape par étape (jointures, filtres, regroupements).
3. Granularité du résultat : ce que représente une ligne.
4. Risques : doublons possibles dus aux jointures, gestion des NULL, bornes de dates.
Ne réécris pas la requête.

Demander la granularité et les risques transforme une paraphrase en revue.


3. Interprétation de schéma

Décris la signification métier probable de chaque table et les relations entre elles.

<schema>
...DDL ou liste des colonnes avec types, clés et quelques valeurs d'exemple masquées...
</schema>

Sortie JSON :
{"tables": [{"name": string, "meaning": string, "grain": string,
             "keys": [string], "evidence": string, "confidence": "high"|"medium"|"low"}]}

Tout ce qui est déduit uniquement des noms doit avoir "confidence": "low".

4. Mapping de colonnes

Fais correspondre les colonnes source au modèle cible.

<source_columns>cust_no, e_mail, ctry, created_ts, mkt_optin</source_columns>
<target_columns>customer_id, email, country_code, signup_date, marketing_consent</target_columns>

Règles :
- chaque colonne source correspond à au plus une colonne cible
- si aucune cible ne convient, utilise null
- n'invente pas de colonnes cibles

Sortie JSON :
{"mappings": [{"source": string, "target": string | null,
               "transformation": string | null, "confidence": number}]}

Validez le mapping avec du code :

import json

ALLOWED_TARGETS = {"customer_id", "email", "country_code", "signup_date", "marketing_consent"}


def validate_mapping(raw: str, source_columns: set[str]) -> list[str]:
    """Renvoie les problèmes trouvés ; une liste vide signifie que le mapping peut passer en revue humaine."""
    try:
        mapping = json.loads(raw)
    except json.JSONDecodeError as exc:
        return [f"JSON invalide : {exc}"]
    problems = []
    for item in mapping.get("mappings", []):
        source, target, confidence = item.get("source"), item.get("target"), item.get("confidence")
        if source not in source_columns:
            problems.append(f"colonne source inconnue : {source}")
        if target is not None and target not in ALLOWED_TARGETS:
            problems.append(f"colonne cible inconnue : {target}")
        if not isinstance(confidence, (int, float)) or not 0 <= confidence <= 1:
            problems.append(f"confiance invalide pour {source}")
    return problems

5. Génération de règles de qualité des données

Propose des contrôles de qualité des données pour cette table.

<table_profile>
column, type, null_pct, distinct_count, min, max, sample_values (masquées)
...
</table_profile>

Sortie JSON :
{"rules": [{"column": string, "check": "not_null"|"unique"|"range"|"allowed_values"|"pattern",
            "parameters": object, "reason": string, "severity": "error"|"warning"}]}

Fonde chaque règle sur le profil. Ne propose pas de seuil sans preuve ; indique « à confirmer ».

Transformez les règles acceptées en code (SQL, PySpark ou votre framework de qualité) et relisez-les comme n’importe quel code.


6. Résumé de journaux

Résume ces journaux de pipeline pour un ingénieur d'astreinte.

<logs>
...200 dernières lignes pertinentes, secrets et jetons retirés...
</logs>

Sortie :
- Première erreur (horodatage, composant, message)
- Enchaînement probable des événements (5 puces maximum)
- Ce que ces journaux NE montrent PAS
Cite les lignes de journal à l'identique ; ne reformule pas les messages d'erreur.

Filtrez d’abord les journaux avec du code (niveau, fenêtre de temps, ID d’exécution). N’envoyez pas des fichiers de journaux entiers.


7. Analyse d’incident

Aide à analyser cet incident. Tu assistes, tu ne décides pas.

<timeline>...</timeline>
<metrics>...</metrics>
<recent_changes>...</recent_changes>

Sortie JSON :
{"hypotheses": [{"cause": string, "supporting_evidence": [string],
                 "contradicting_evidence": [string], "next_check": string}],
 "unknowns": [string]}

Classe les hypothèses selon les preuves. N'affirme pas une cause racine comme un fait.

8. Explication de notebook et de code

Explique cette cellule de notebook à un ingénieur de données qui découvre le projet.

<code language="python">
...
</code>

Sortie :
1. Ce qu'elle lit et écrit (tables, fichiers, chemins).
2. Les transformations dans l'ordre.
3. Les effets de bord (écrasements, suppressions, merges).
4. Les risques de performance (collect(), boucles sur les lignes, shuffles importants).

9. Documentation de pipeline

Rédige une documentation de ce pipeline à partir de sa définition.

<pipeline_definition>...JSON/YAML, secrets retirés...</pipeline_definition>

Sortie Markdown avec les sections : Objectif, Planification, Sources, Cibles, Étapes,
Gestion des échecs, Responsables (« à définir » s'ils ne figurent pas dans l'entrée).
Décris uniquement ce qui figure dans la définition.

10. Enrichissement des métadonnées

Propose des descriptions métier et des étiquettes pour ces colonnes.

<columns>nom, type, table, valeurs d'exemple (masquées)</columns>

Sortie JSON :
{"columns": [{"name": string, "description": string,
              "tags": [string], "pii_suspected": boolean, "confidence": "high"|"medium"|"low"}]}

Utilise uniquement ces étiquettes : finance, customer, product, operational, reference.

Stockez les suggestions comme brouillons à faire approuver par un responsable des données (data steward).

Techniques réutilisables

Mauvais prompt ou meilleur prompt

Mauvais Meilleur
« Corrige ce SQL » « Ce T-SQL renvoie des doublons par commande. Explique pourquoi et renvoie une requête corrigée. Garde les mêmes colonnes en sortie. »
« Résume les journaux » « Liste la première erreur, le composant en échec et la dernière étape réussie. Cite les lignes à l’identique. »
« Fais correspondre ces colonnes » « Associe chaque colonne source à une colonne cible ou à null. Renvoie du JSON conforme à ce schéma. »

Patron de sortie structurée

  • Définissez le schéma dans le prompt, ou utilisez la fonction de sortie structurée du fournisseur.
  • Utilisez des énumérations pour les catégories.
  • Analysez et validez avec du code ; relancez ou escaladez en cas d’échec.

Patron « demander les hypothèses »

Avant la réponse, liste les hypothèses faites sur les données
(granularité, fuseau horaire, signification des statuts, gestion des NULL).

C’est dans les hypothèses que les réponses sur les données se trompent ; les rendre explicites accélère la revue.

Patron « renvoyer l’incertitude »

Si l'entrée ne contient pas assez d'informations, renvoie "unknown"
et liste ce qui manque. Ne devine pas.

Donnez au modèle un moyen légitime de dire qu’il ne sait pas.

Étape de validation

Sortie Valider avec
SQL Compilation sans exécution, compte en lecture seule, limite de lignes, comparaison à un total connu
JSON Analyse + validation de schéma + valeurs autorisées
Mappings / règles Contrôles en code + approbation humaine
Résumés Les lignes citées existent dans la source
Code Tests, linting, revue

Points à vérifier

  • Des réponses qui utilisent des tables ou colonnes absentes du contexte.
  • Des hypothèses manquantes sur la granularité, les fuseaux horaires ou les NULL.
  • Des réponses assurées à des questions auxquelles l’entrée ne permet pas de répondre.
  • Des sorties conformes au schéma mais qui échouent aux contrôles métier.
  • Des valeurs sensibles qui apparaissent dans les prompts ou les journaux.

Erreurs fréquentes

1. Envoyer des secrets ou des données clients brutes

Chaînes de connexion, clés, jetons et données personnelles n’ont rien à faire dans un prompt. Masquez, échantillonnez, synthétisez ou agrégez d’abord.

2. Envoyer tout le schéma

Un contexte volumineux et non pertinent coûte des tokens et favorise les mauvaises jointures. Envoyez les tables utiles.

3. Aucun format de sortie

Le texte libre est difficile à valider et à utiliser dans un pipeline.

4. Exécuter directement le SQL généré

Compilez-le, exécutez-le en lecture seule avec des limites et vérifiez le résultat.

5. Mélanger instructions et données

Des données collées sans délimiteurs peuvent être prises pour des instructions, y compris des instructions cachées dans les données elles-mêmes.

6. Exiger une certitude

« Quelle est la cause racine ? » invite à une supposition assurée. Demandez des hypothèses étayées par des preuves.

Notes de production

  • Gardez les prompts sous contrôle de version sous forme de modèles ; journalisez la version du modèle de prompt avec chaque appel.
  • Construisez les prompts en code à partir de modèles, pas en concaténant la saisie utilisateur dans les instructions.
  • Traitez documents récupérés, journaux et saisies utilisateur comme des données non fiables.
  • Utilisez un rôle de base de données en lecture seule pour toute requête générée.
  • Masquez ou retirez données personnelles et secrets avant de construire les prompts ; vérifiez ce que capture votre journalisation.
  • Gardez un petit jeu d’évaluation par prompt et relancez-le après chaque modification ou changement de modèle.

Liste de contrôle

  • Objectif, contexte, contraintes, entrée, sortie et validation sont explicites.
  • Seuls le schéma, l’échantillon ou les journaux nécessaires sont envoyés.
  • Les entrées sont délimitées.
  • La sortie a un format défini.
  • Le modèle doit lister ses hypothèses et peut répondre « inconnu ».
  • La sortie est validée par du code, la base de données ou un relecteur.
  • Aucun secret ni donnée sensible brute dans les prompts.

Étape suivante

  • Les prompts sont trop longs ou trop chers → Optimiser les tokens d’un LLM.
  • Vous ne savez pas quel contexte inclure → Ingénierie du contexte pour les LLM.
  • Les résultats restent faibles malgré un bon prompt → Choisir le bon modèle d’IA.

← Tous les aide-mémoire