Workflows de données avec Code Interpreter
Op deze pagina
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 typeinput_text, et la recherche web utilise l’outilweb_search(web_search_previewest désormais un outil obsolète sans filtres de domaine). Les fichiers générés sont récupérés via les fonctionsfichiers_generesettelechargerde la leçon 10. Les fichiers joints au message sont téléchargés avec l’objectifuser_data, ce qu’OpenAI recommande pour les entrées du modèle (File inputs). Sources : Code Interpreter · Recherche web.
Workflows de données avec Code Interpreter
Les leçons précédentes ont traité des tâches individuelles une par une. Une analyse réelle les enchaîne : vous importez, nettoyez, calculez, visualisez et exportez. C’est la chaîne, et non chaque étape isolée, qui consomme du temps lorsqu’elle est effectuée manuellement.
Les quatre workflows ci-dessous sont des cas concrets, volontairement variés : reporting périodique, analyse comportementale dans le temps, segmentation et prévisions. Lisez-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 actionnable, que vous pouvez appliquer directement à vos propres données.
Workflow 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 vous avez rédigé et validé le prompt pour un mois, il fonctionne pour les onze suivants. Notez l’instruction finale, qui demande une exportation Excel par section. Cela rend le résultat directement partageable, au lieu de vous 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érez 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 (axe double) "
" - 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=(
"Produisez un rapport professionnel. "
"Affichez les chiffres avec des séparateurs de milliers. "
"Utilisez le format européen (virgule décimale). "
"Commentez 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}")
Workflow 2 : Analyse de cohorte
L’analyse de cohorte suit des groupes formés à la même date d’entrée au fil du temps. 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 est rentable 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": (
"Effectuez une analyse de cohorte sur ces données utilisateurs : "
"1. Définissez les cohortes par mois d'inscription "
"2. Calculez le taux de rétention par cohorte (mois 1, 2, ..., 12) "
"3. Créez une carte thermique de rétention "
"4. Identifiez la cohorte ayant la meilleure rétention "
"5. Estimez la LTV par cohorte "
"6. Exportez le tableau de rétention en CSV"
)},
{"type": "input_file", "file_id": file_obj.id}
]
}],
tools=[{"type": "code_interpreter", "container": {"type": "auto"}}],
instructions=(
"Montrez le code étape par étape. "
"Affichez les résultats intermédiaires. "
"Pour la carte thermique, utilisez une palette verte (foncé = bon, clair = faible). "
"Annotez chaque cellule avec le pourcentage."
)
)
Workflow 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 : demandez 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": (
"Effectuez une segmentation client RFM : "
"1. Calculez la Récence, la Fréquence et le Montant pour chaque client "
"2. Attribuez un score RFM de 1 à 5 pour chaque dimension "
"3. Créez des segments : Champions, Fidèles, À risque, Perdus "
"4. Appliquez K-Means (k=4 à 8, choisissez le meilleur k via la méthode du coude) "
"5. Visualisez les segments en 2D (ACP ou t-SNE) "
"6. Profilez 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=(
"Utilisez sklearn pour le clustering. "
"Normalisez les variables avant le clustering. "
"Affichez le graphique du coude pour justifier le choix de k. "
"Créez 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
}
Workflow 4 : Prévisions et tendances
La prévision est le workflow où la prudence est la plus cruciale. Le conteneur peut exécuter une régression ou une décomposition saisonnière, et il le fera même si vos 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. Exigez 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écomposez la série temporelle (tendance, saisonnalité, résidu) "
"2. Appliquez un lissage exponentiel (Holt-Winters) "
"3. Prévoyez les 6 prochains mois avec un intervalle de confiance à 95 % "
"4. Comparez avec une régression linéaire simple "
"5. Générez un graphique avec l'historique + les prévisions "
"6. Calculez les métriques d'erreur (MAE, RMSE, MAPE)"
)},
{"type": "input_file", "file_id": file_obj.id}
]
}],
tools=[{"type": "code_interpreter", "container": {"type": "auto"}}],
instructions=(
"Utilisez statsmodels pour la décomposition et les prévisions. "
"Colorez l'intervalle de confiance en bleu transparent. "
"Marquez clairement la séparation entre l'historique et les prévisions."
)
)
Orchestration d’un workflow en plusieurs étapes
Au-delà d’une certaine taille, un prompt unique atteint ses limites : l’analyse dérive, une instruction intermédiaire est oubliée et vous perdez 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 vous avez 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 workflow 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(
"Nettoyez ce CSV : supprimez les doublons, gérez les valeurs manquantes, "
"normalisez les types. Exportez le résultat.",
[file_obj.id]
)
# Étape 2 : Analyse
wf.step("Calculez les KPI clés et identifiez les tendances.")
# Étape 3 : Visualisation
wf.step("Créez 4 graphiques clés pour un rapport de direction.")
# Étape 4 : Export
wf.step("Compilez le tout dans un fichier Excel avec des onglets et des graphiques intégrés.")
wf.download_results("./sortie_workflow/")
Belangrijkste punten
- Décomposez les workflows complexes en étapes avec transmission de fichiers
- Utilisez 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érez systématiquement les fichiers intermédiaires pour la traçabilité
- Combinez analyse de données et visualisation en un seul appel pour des rapports complets