Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Flux de travail de données avec l'interpréteur de code

Lekcija 14 od 20 Posodobljeno 2. november 2026 Razvijalec
Na tej strani
  1. Flux de travail de données avec l’interpréteur de code
  2. Flux de travail 1 : Rapport financier automatisé
  3. Flux de travail 2 : Analyse de cohorte
  4. Flux de travail 3 : Scoring et segmentation
  5. Flux de travail 4 : Prévisions et tendances
  6. Orchestration d’un flux de travail multi-étapes
  7. Clés de compréhension

Leçon mise à jour le 2 novembre 2026 sur la base de la documentation OpenAI : l’outil Code Interpreter nécessite un paramètre container (ajouté à tous les exemples), les parties textuelles de l’entrée sont de type input_text, et la recherche web utilise l’outil web_search (web_search_preview est désormais un outil obsolète sans filtres de domaine). Les fichiers générés sont récupérés via les fonctions fichiers_generes et telecharger de la leçon 10. Les fichiers joints au message sont téléchargés avec l’objectif user_data, ce qu’OpenAI recommande pour les entrées du modèle (File inputs). Sources : Code Interpreter · Recherche web.

Flux de travail de données avec l’interpréteur de code

Les leçons précédentes ont traité des tâches individuelles une par une. Une analyse réelle les enchaîne : tu importes, nettoies, calcules, visualises et exportes. C’est la chaîne, et non chaque étape isolée, qui consomme du temps lorsqu’elle est effectuée manuellement.

Les quatre flux de travail ci-dessous sont des cas concrets, volontairement variés : reporting périodique, analyse comportementale dans le temps, segmentation et prévision. Lis-les moins pour le code que pour la structure du prompt : numérotée, explicite sur les livrables attendus et précise sur le format. Cette structure transforme une demande vague en un rapport exploitable, que tu peux appliquer directement à tes propres données.

Flux de travail 1 : Rapport financier automatisé

Le reporting périodique est le meilleur candidat à l’automatisation pour une raison simple : les fichiers changent, mais la structure du rapport reste identique. Une fois que tu as rédigé et validé le prompt pour un mois, il fonctionne pour les onze suivants. Note l’instruction finale, qui demande une exportation Excel par section. Cela rend le résultat directement partageable, au lieu de te laisser avec un texte nécessitant un reformatage.

from openai import OpenAI

client = OpenAI()

# Téléchargement des fichiers sources
files = {}
for name in ["revenus_2025.xlsx", "depenses_2025.xlsx", "budget_previsionnel.xlsx"]:
    with open(name, "rb") as f:
        file_obj = client.files.create(file=f, purpose="user_data")
        files[name] = file_obj.id

content = [
    {"type": "input_text", "text": (
        "Génère un rapport financier complet à partir de ces 3 fichiers : "
        "1. RÉSUMÉ : Chiffre d'affaires total, marge brute, résultat net "
        "2. ANALYSE MENSUELLE : Évolution mois par mois avec variations "
        "3. ÉCARTS BUDGÉTAIRES : Comparaison réel vs prévisionnel, écarts significatifs "
        "4. GRAPHIQUES : "
        "   - Évolution des revenus et des dépenses (double axe) "
        "   - Cascade des écarts budgétaires "
        "   - Répartition des dépenses par catégorie "
        "5. EXPORT : Fichier Excel avec un onglet par section"
    )}
]
for fid in files.values():
    content.append({"type": "input_file", "file_id": fid})

response = client.responses.create(
    model="gpt-5.6-terra",
    input=[{"role": "user", "content": content}],
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}],
    instructions=(
        "Produis un rapport professionnel. "
        "Affiche les chiffres avec des séparateurs de milliers. "
        "Utilise le format européen (virgule décimale). "
        "Commente chaque écart significatif (> 5 %)."
    )
)

# Récupération de tous les fichiers générés
for ann in fichiers_generes(response):
    telecharger(client, ann, f"sortie_{ann.filename}")
    print(f"Généré : {ann.filename}")

Flux de travail 2 : Analyse de cohorte

L’analyse de cohorte suit dans le temps des groupes formés à la même date d’entrée. Peu d’équipes effectuent ce calcul régulièrement car sa mise en place est fastidieuse. C’est précisément pour cela qu’il vaut la peine de la déléguer : la logique est standard, seules les données changent.

with open("utilisateurs.csv", "rb") as f:
    file_obj = client.files.create(file=f, purpose="user_data")

response = client.responses.create(
    model="gpt-5.6-terra",
    input=[{
        "role": "user",
        "content": [
            {"type": "input_text", "text": (
                "Effectue une analyse de cohorte sur ces données utilisateurs : "
                "1. Définis les cohortes par mois d'inscription "
                "2. Calcule le taux de rétention par cohorte (mois 1, 2, ..., 12) "
                "3. Crée une carte thermique de rétention "
                "4. Identifie la cohorte ayant la meilleure rétention "
                "5. Estime la LTV par cohorte "
                "6. Exporte le tableau de rétention en CSV"
            )},
            {"type": "input_file", "file_id": file_obj.id}
        ]
    }],
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}],
    instructions=(
        "Montre le code étape par étape. "
        "Affiche les résultats intermédiaires. "
        "Pour la carte thermique, utilise une palette verte (foncé = bon, clair = faible). "
        "Annote chaque cellule avec le pourcentage."
    )
)

Flux de travail 3 : Scoring et segmentation

Ici, le modèle ne se contente pas de décrire les données ; il construit un score et forme des groupes. Cela nécessite une précaution : demande toujours la méthode en plus du résultat. Un segment comme « clients à risque » sans les critères qui l’ont produit est inutilisable : personne ne peut le contester, le reproduire ou le corriger.

def segmenter_clients(file_path: str) -> dict:
    """Segmente les clients en utilisant RFM et le clustering."""
    with open(file_path, "rb") as f:
        file_obj = client.files.create(file=f, purpose="user_data")

    response = client.responses.create(
        model="gpt-5.6-terra",
        input=[{
            "role": "user",
            "content": [
                {"type": "input_text", "text": (
                    "Effectue une segmentation client RFM : "
                    "1. Calcule la Récence, la Fréquence et le Montant pour chaque client "
                    "2. Attribue un score RFM de 1 à 5 pour chaque dimension "
                    "3. Crée des segments : Champions, Fidèles, À risque, Perdus "
                    "4. Applique K-Means (k=4 à 8, choisis le meilleur k avec la méthode du coude) "
                    "5. Visualise les segments en 2D (ACP ou t-SNE) "
                    "6. Profile chaque segment : taille, revenu moyen, fréquence "
                    "7. Export : CSV avec le segment par client + rapport type PDF"
                )},
                {"type": "input_file", "file_id": file_obj.id}
            ]
        }],
        tools=[{"type": "code_interpreter", "container": {"type": "auto"}}],
        instructions=(
        "Utilise sklearn pour le clustering. "
        "Normalise les variables avant le clustering. "
        "Affiche le graphique du coude pour justifier le choix de k. "
        "Crée un graphique radar par segment."
    )
    )

    output_files = []
    for ann in fichiers_generes(response):
        telecharger(client, ann, ann.filename)
        output_files.append(ann.filename)

    return {
        "analysis": response.output_text,
        "files": output_files
    }

Flux de travail 4 : Prévisions et tendances

La prévision est le flux de travail où la prudence compte le plus. Le conteneur peut exécuter une régression ou une décomposition saisonnière, et il le fera même si tes données ne s’y prêtent pas : vingt points de données suffisent à produire une courbe parfaitement présentable mais totalement dénuée de sens. Exige l’intervalle de confiance et les hypothèses du modèle : c’est ce qui distingue une projection d’une extrapolation.

response = client.responses.create(
    model="gpt-5.6-terra",
    input=[{
        "role": "user",
        "content": [
            {"type": "input_text", "text": (
                "Sur la base de ces données de ventes mensuelles : "
                "1. Décompose la série temporelle (tendance, saisonnalité, résidu) "
                "2. Applique un lissage exponentiel (Holt-Winters) "
                "3. Prévois les 6 prochains mois avec un intervalle de confiance à 95 % "
                "4. Compare avec une régression linéaire simple "
                "5. Génère un graphique avec l'historique + les prévisions "
                "6. Calcule les métriques d'erreur (MAE, RMSE, MAPE)"
            )},
            {"type": "input_file", "file_id": file_obj.id}
        ]
    }],
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}],
    instructions=(
        "Utilise statsmodels pour la décomposition et la prévision. "
        "Colore l'intervalle de confiance en bleu transparent. "
        "Marque clairement la séparation entre l'historique et les prévisions."
    )
)

Orchestration d’un flux de travail multi-étapes

Au-delà d’une certaine taille, un seul prompt atteint ses limites : l’analyse dérive, une instruction intermédiaire est oubliée et tu perds le fil de l’étape en cours. Découper le processus en appels successifs, tous fonctionnant dans le même conteneur où les fichiers de l’étape précédente restent disponibles, restaure ce que tu as perdu : un point de contrôle après chaque étape et la capacité de reprendre depuis l’étape défaillante au lieu de tout recommencer.

class WorkflowData:
    def __init__(self):
        self.client = OpenAI()
        # Un conteneur explicite : les fichiers produits restent disponibles d'une étape à l'autre
        self.container = self.client.containers.create(name="workflow-data")
        self.intermediate_files = []

    def step(self, instruction: str, file_ids: list[str] | None = None) -> str:
        """Exécute une étape du flux de travail dans le conteneur partagé."""
        content = [{"type": "input_text", "text": instruction}]
        for fid in file_ids or []:
            content.append({"type": "input_file", "file_id": fid})

        response = self.client.responses.create(
            model="gpt-5.6-terra",
            input=[{"role": "user", "content": content}],
            tools=[{"type": "code_interpreter", "container": self.container.id}],
        )

        # Mémorise les fichiers générés pour les télécharger à la fin
        self.intermediate_files.extend(fichiers_generes(response))
        return response.output_text

    def download_results(self, output_folder: str):
        """Télécharge les fichiers générés avant l'expiration du conteneur."""
        import os
        os.makedirs(output_folder, exist_ok=True)
        for ann in self.intermediate_files:
            telecharger(self.client, ann, os.path.join(output_folder, ann.filename))

# Utilisation
wf = WorkflowData()

# Étape 1 : Import et nettoyage
with open("donnees_brutes.csv", "rb") as f:
    file_obj = client.files.create(file=f, purpose="user_data")

wf.step(
    "Nettoie ce CSV : supprime les doublons, gère les valeurs manquantes, "
    "normalise les types. Exporte le résultat.",
    [file_obj.id]
)

# Étape 2 : Analyse
wf.step("Calcule les KPI clés et identifie les tendances.")

# Étape 3 : Visualisation
wf.step("Crée 4 graphiques clés pour un rapport de direction.")

# Étape 4 : Export
wf.step("Compile le tout dans un fichier Excel avec des onglets et des graphiques intégrés.")

wf.download_results("./sortie_workflow/")

Clés de compréhension

  • Décompose les flux de travail complexes en étapes avec transmission de fichiers
  • Utilise des instructions détaillées pour chaque étape
  • Le modèle gère nativement l’analyse statistique et le machine learning de base
  • Récupère systématiquement les fichiers intermédiaires pour la traçabilité
  • Combine analyse de données et visualisation en un seul appel pour des rapports complets