ChatGPT Data Analysis / Code Interpreter

À la fin de ce tutoriel ChatGPT Data Analysis, vous saurez utiliser le sandbox Python intégré (ex-Code Interpreter / Advanced Data Analysis) : uploader un CSV factice d’incidents, nettoyer et agréger, générer des charts, télécharger les artefacts, lire le code généré avant de faire confiance aux chiffres — plus un aperçu API code_interpreter pour automatiser côté DevOps.

Niveau : Débutant / Intermédiaire · Temps estimé : 40–50 min · Versions testées : ChatGPT (plans payants 2026, GPT-4o et successeurs) · API OpenAI Responses + code_interpreter · Dernière vérification : 2026-09-11

Prérequis

• Compte ChatGPT avec Data Analysis / exécution de code (plans Plus / Team / Enterprise ; free tier souvent très limité)
• Navigateur récent ; 1–2 CSV de lab (< 5 Mo)
• Notions CSV ; optionnel : bases pandas pour relire le code
• Voisins (HOLD possible) : slash commands, Memory, Actions
• Hub : IA pour DevOps 2026 · landing IA

Coût : abonnement ChatGPT payant. Lab local : 0 € (/tmp/lab-chatgpt-da). Aucun secret, PAT, kubeconfig ou log nominatif réel dans le chat.

Ce que nous allons construire

ChatGPT Data Analysis (lab 2026)
  ├── /tmp/lab-chatgpt-da/incidents.csv
  ├── Upload chat → sandbox Python
  ├── Nettoyage + agrégats (pandas)
  ├── Charts + téléchargement
  ├── Checklist : lire le code avant les chiffres
  ├── API code_interpreter (aperçu)
  └── vs Jupyter / Claude / Julius · quiz · FAQ

(Alt : « ChatGPT Data Analysis / Code Interpreter — sandbox Python, upload CSV, charts DevOps 2026 ».)

Leçon #24 du plan IA Outils 2026 : après Memory et Search, on traite l’exécution de code sur vos fichiers — indispensable pour des runbooks data sans Jupyter local à chaque incident. Objectif : chiffres rejouables, pas des insights flous.

Étape 1 — Noms et place dans le produit (2023 → 2026)

Plugin Code Interpreter (2023) renommé Advanced Data Analysis, puis intégré dans ChatGPT (plus de toggle plugin sur les plans supportés). En 2026 on dit Data Analysis ou exécution de code ; l’API garde le nom code_interpreter.

Concrètement :

• Le modèle écrit du Python, l’exécute dans un sandbox isolé, puis commente le résultat.
• Les chiffres viennent du runtime (pandas, numpy…) — sauf si le résumé textuel déforme la sortie. Règle d’or : lire le code et les tables, pas seulement le paragraphe.
• Sandbox éphémère : pas d’accès VPC / Snowflake / Postgres sans connecteur ou Actions.

Côté DEH, Data Analysis est un banc d’essai (hypothèse sur un export d’alertes, chart pour un canal incident, calcul documenté avant notebook), pas un entrepôt durable. La stack (pandas, numpy, matplotlib/seaborn, scikit-learn, openpyxl) couvre la plupart des one-shots ops ; JDBC, Redis ou GPU : sortez du chat. Les trois noms historiques (Code Interpreter, Advanced Data Analysis, Data Analysis) désignent le même runtime d’exécution.

Étape 2 — Lab : CSV d’incidents factice

Préparez un jeu anonyme sur votre machine.

mkdir -p /tmp/lab-chatgpt-da && cd /tmp/lab-chatgpt-da

cat > incidents.csv << 'EOF'
incident_id,opened_at,service,severity,status,env,region
INC-1001,2026-09-01T08:12:00Z,api,P2,resolved,prod,eu-west
INC-1002,2026-09-01T09:40:00Z,web,P3,resolved,prod,eu-west
INC-1003,2026-09-01T11:05:00Z,worker,P1,mitigated,prod,us-east
INC-1004,2026-09-02T07:22:00Z,api,P2,open,staging,eu-west
INC-1005,2026-09-02T14:18:00Z,api,P3,resolved,prod,us-east
INC-1006,2026-09-03T06:55:00Z,web,P2,resolved,prod,eu-west
INC-1007,2026-09-03T16:01:00Z,db,P1,resolved,prod,eu-west
INC-1008,2026-09-04T10:33:00Z,api,P2,open,prod,us-east
INC-1009,2026-09-04T19:47:00Z,worker,P3,resolved,staging,eu-west
INC-1010,2026-09-05T08:09:00Z,web,P2,mitigated,prod,eu-west
EOF

wc -l incidents.csv   # 11 lignes (1 header + 10)

Règles DEH : pas de noms clients, e-mails, IPs privées, tokens. Export réel : anonymisez d’abord (cut, jq, script local) avant tout upload. Le vocabulaire severity/env/region colle aux post-mortems SRE ; vous rejouerez ensuite un taux P1 ou des filtres région sur un export scrubbé. Gardez le fichier sous /tmp seulement. Au-delà de quelques Mo : échantillonnez (ex. 30 derniers jours) pour limiter lenteur, contexte brûlé et colonnes sensibles oubliées.

Étape 3 — Upload et premier prompt structuré

Dans ChatGPT :

1. Joignez incidents.csv (trombone / drag-and-drop). Formats : CSV, TSV, XLSX, JSON, PDF, Parquet — restez sous quelques Mo pour le lab.
2. Prompt à quatre ingrédients : verbe, grain, filtre, sortie.

Prompt modèle :

Tu as incidents.csv. Sans inventer de lignes :
1) Affiche dtypes, nb de lignes, valeurs manquantes.
2) Compte les incidents par service et par severity (tableaux).
3) Trace un bar chart du volume par service.
4) Liste les incidents status=open.
Montre le code Python exécuté et les tables complètes.
Ne stocke aucun secret ; dataset lab uniquement.

Attendu : pandas, read_csv, value_counts/groupby, chart, résumé. Skimmez le filtre (status == "open") et les colonnes groupées — 80 % des erreurs de logique sont là. Exemples d’ingrédients : grain « par service et par jour », filtre env=prod, sortie « tableau + bar chart téléchargeable ». Code manquant : exigez le Python complet. Totaux suspects : df.shape et value_counts(dropna=False) avant tout graphique.

Étape 4 — Nettoyage, export et charts

Dans le même fil (le sandbox réutilise souvent les fichiers du fil) :

Ajoute une colonne opened_date (UTC, date seule).
Filtre env=prod. Calcule le top severity par service (prod seulement).
Exporte le tableau agrégé en CSV téléchargeable.
Si une colonne est ambiguë, demande avant d'imputer.

Conversion CSV→Excel/JSON ou chart line : OK. Charts interactifs (bar, pie, scatter, line selon UI 2026) parfois personnalisables ; sinon image statique. Exigez un lien de téléchargement nommé (prod-by-service.csv) : l’aperçu inline se perd dans un long fil ; en revue d’incident, joignez le CSV au ticket. Drive / OneDrive (plans payants) : vérifiez la rétention org avant d’y coller de la prod. Le sandbox n’est pas un ETL temps réel — refresh horaire = cron/pipeline hors chat.

Étape 5 — Sécurité et hygiène DevOps

Risque	Pourquoi	Mitigation
Upload de secrets	Fichier chez le fournisseur	Scrub PAT, .env, kubeconfig ; dataset lab
PII / RGPD	Tickets avec emails	Anonymiser / hasher hors chat
Confiance aveugle	Résumé ≠ code	Lire code + tables ; rejouer en local si critique
Session éphémère	Artefacts perdus	Télécharger CSV/PNG tout de suite
Données prod live	Pas de JDBC natif VPC	Export contrôlé, Actions / API maison

Runbooks : extrait filtré (rg, jq, SQL limitée), pas le dump brut. Suite : ChatGPT pour DevOps (runbooks). RSSI avant exports clients. Politique PME : (1) synthétique/anonymisé sauf Enterprise + DPA ; (2) zéro secret dans colonnes ou prompt ; (3) chiffre publié en rapport externe = rejoué en local ou job audité. ChatGPT accélère ; ce n’est pas la source de vérité réglementaire.

Étape 6 — Aperçu API code_interpreter

Endpoint Responses (illustratif, aucun secret) :

{
  "tools": [
    {
      "type": "code_interpreter",
      "container": {
        "type": "auto",
        "memory_limit": "4g"
      }
    }
  ]
}

• auto : crée ou réutilise un container lié au contexte.
• explicit : créez un container via l’API Containers, puis passez son id.
• memory_limit : 1g (défaut), 4g, 16g, 64g (facturation selon palier).

Plots/CSV via annotations container — récupérez-les avant expiration. Pipeline CI : artefact déjà scrubbé, schema JSON de sortie (Structured outputs), code exécuté archivé dans les logs. Préférez l’API dès qu’il faut un rapport sans humain (J+1, fin de sprint) ou un audit trail (code, hash fichier, version modèle). Le chat itère mieux sur la question métier ; l’API fige le happy path. Début simple : job CSV scrubbé → trois agrégats → échec si le JSON ne valide pas le schema.

Étape 7 — Quand choisir quoi ?

Besoin	ChatGPT Data Analysis	Jupyter local	Claude (artifacts)	Julius / BI
Exploration one-shot CSV	Excellent	Excellent	Bon	Excellent si connecteurs
DB privée (Snowflake, PG)	Non natif	Oui	Non natif	Souvent oui (Pro)
Audit / air-gap	Non	Oui	Non	Non
Charts rapides	Oui	Oui	Oui	Oui
Reproductibilité git	Faible	Forte	Moyenne	Variable

Règle DEH : prototype dans ChatGPT ; industrialisez (notebook ou job Git) dès qu’un chiffre entre dans un rapport client ou un post-mortem. Data Analysis pour comprendre vite ; Jupyter/script dès que la question revient chaque semaine. Claude artifacts est voisin pour code + preview ; Julius/BI gagne si la donnée ne doit pas sortir de Snowflake/BigQuery.

Erreurs fréquentes

Symptôme	Cause probable	Correctif
« Je ne peux pas exécuter de code »	Plan / modèle sans tool	Modèle / plan avec Data Analysis
Totaux faux	Filtre oublié (env, dates)	Exiger le code + value_counts brut
Upload refusé	Fichier trop gros / type	Échantillonner ; CSV plutôt que xlsx géant
Chart vide	Colonnes / NaN	df.head(), df.columns, dropna
Fuite de secret	Export brut	Scrub local avant upload
Perte du PNG	Session expirée	Download immédiat

Quiz (4 questions)

1. D’où viennent principalement les chiffres dans Data Analysis ?
– A. D’une recherche web
– B. De l’exécution Python dans un sandbox
– C. Du seul modèle de langage sans runtime

2. Pourquoi lire le code généré ?
– A. Pour installer pandas localement à chaque fois
– B. Pour détecter un filtre / groupby incorrect malgré un résumé confiant
– C. Parce que l’API l’exige toujours

3. Que faire avant d’uploader un export Jira/ServiceNow ?
– A. Anonymiser PII et retirer secrets
– B. Ajouter les mots de passe en colonne pour « contexte »
– C. Forcer memory_limit: 64g

4. L’outil API s’appelle :
– A. jupyter_kernel
– B. code_interpreter
– C. data_plugin_v1

Réponses : 1‑B · 2‑B · 3‑A · 4‑B

FAQ

Data Analysis remplace-t-il Jupyter ?
Non. Exploration rapide oui ; reproductibilité, CI et revue de pairs : notebook ou script dans Git.

Puis-je brancher ma base de prod ?
Pas en natif dans le sandbox. Exportez un extrait scrubbé, ou passez par Actions / un backend que vous contrôlez (ChatGPT Actions).

Le fichier reste-t-il chez OpenAI ?
Traitez tout upload comme données tiers. Politique Enterprise, rétention et DPA selon contrat — en doute, dataset synthétique uniquement.

Comment forcer l’affichage du code Python ?
Demandez « montre le code complet exécuté dans le sandbox, sans le tronquer », puis vérifiez filtres et groupby. Sans code visible, refusez le chiffre.

Quelle taille de fichier viser pour un lab ?
Quelques Mo, centaines ou milliers de lignes. Au-delà : échantillonnez ou découpez par période. Un CSV léger reste le meilleur compromis.

Charts interactifs ou image statique ?
Selon l’UI 2026 et le type : bar / line / scatter / pie parfois interactifs ; sinon PNG. Dans tous les cas, téléchargez l’artefact avant de fermer la session.

Pour aller plus loin

• Docs OpenAI : Code Interpreter (API)
• Hub : IA pour DevOps 2026 · IA
• Voisins : slash commands · Memory · Actions · Custom GPTs · runbooks DevOps · Teams / Enterprise

Maillage série IA Outils 2026 (module C)

← Précédent	ChatGPT Memory
→ Suite	ChatGPT Actions & outils
Hub	IA pour DevOps : parcours 2026