Générer des graphiques et visualisations

Leçon corrigée le 2 novembre 2026 d’après la documentation d’OpenAI : l’outil Code Interpreter exige un paramètre container (ajouté à tous les exemples), les parties de texte de l’entrée sont de type input_text, et la recherche web utilise l’outil web_search (web_search_preview n’est plus qu’un outil hérité, sans filtres de domaines). Les fichiers générés se récupèrent avec les fonctions fichiers_generes et telecharger de la leçon 10. Les fichiers joints au message sont téléversés avec l’usage user_data, celui que recommande OpenAI pour les entrées du modèle (File inputs). Sources : Code Interpreter · Web search.

Un graphique produit par Code Interpreter n’est pas une image générée : c’est le rendu d’un vrai script matplotlib, exécuté sur vos vraies données. La distinction est importante — les axes sont justes, les valeurs correspondent au fichier, et vous pouvez demander le code pour le rejouer chez vous.

Trois bibliothèques cohabitent dans le container et ne servent pas au même usage. matplotlib fait tout, au prix de la verbosité. seaborn ajoute une couche statistique qui rend les distributions et les corrélations lisibles en une ligne. plotly produit du HTML interactif, à réserver aux livrables qu’on explore à la souris. Nommez celle que vous voulez dans le prompt : sans consigne, le modèle prend matplotlib.

Graphiques simples avec matplotlib

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Cree un graphique en barres montrant les ventes par mois : "
          "Jan=120, Fev=98, Mar=145, Avr=167, Mai=189, Jun=210, "
          "Jul=195, Aou=178, Sep=220, Oct=245, Nov=267, Dec=312. "
          "Style professionnel, couleurs bleues, titre et labels.",
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}],
    instructions="Utilise matplotlib avec un style professionnel. "
                "Police sans-serif, grille légère, pas de cadre supérieur ni droit."
)

# Recuperer l'image generee
for ann in fichiers_generes(response):
    telecharger(client, ann, "ventes_mensuelles.png")

Graphiques à partir de données fichier

C’est l’usage le plus courant, et celui où la valeur est la plus nette : vous téléversez le fichier, vous décrivez le graphique voulu, et le modèle se charge de la lecture, du typage des colonnes et du tracé. Aucune étape de préparation manuelle, et surtout aucune transcription de chiffres — donc aucune erreur de recopie.

with open("performance_equipe.csv", "rb") as f:
    fichier = 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": (
                "A partir de ce fichier, cree un dashboard avec 4 graphiques : "
                "1. Évolution du chiffre d'affaires par mois (line chart) "
                "2. Répartition par catégorie de produit (pie chart) "
                "3. Top 10 des clients par CA (horizontal bar chart) "
                "4. Corrélation entre quantité et montant (scatter plot) "
                "Arrange les 4 graphiques dans une grille 2x2."
            )},
            {"type": "input_file", "file_id": fichier.id}
        ]
    }],
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}],
    instructions="Cree une figure matplotlib avec 4 sous-graphiques. "
                "Utilise une palette de couleurs cohérente. "
                "Resolution 1920x1080, DPI 150. "
                "Exporte en PNG haute qualité."
)

Visualisations statistiques avec seaborn

seaborn devient intéressant dès que la question porte sur une distribution ou une relation plutôt que sur une série de valeurs. Une boîte à moustaches par catégorie ou une matrice de corrélation disent en un coup d’œil ce qu’un tableau de chiffres ne révèle qu’après lecture attentive — et c’est exactement ce qu’on attend d’un graphique.

response = client.responses.create(
    model="gpt-5.6-terra",
    input=[{
        "role": "user",
        "content": [
            {"type": "input_text", "text": (
                "Analyse statistique visuelle de ces données : "
                "1. Heatmap de la matrice de corrélation "
                "2. Distribution de chaque variable numérique (histogrammes + KDE) "
                "3. Boxplots par catégorie pour identifier les outliers "
                "4. Pairplot des 5 variables principales"
            )},
            {"type": "input_file", "file_id": fichier.id}
        ]
    }],
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}],
    instructions="Utilise seaborn avec le thème 'whitegrid'. "
                "Annote les valeurs dans la heatmap. "
                "Utilise la palette 'coolwarm' pour les corrélations."
)

Graphiques interactifs avec plotly

plotly change la nature du livrable : au lieu d’une image figée, vous obtenez un fichier HTML autonome où l’on peut zoomer, survoler, filtrer. C’est le bon choix pour un tableau de bord que quelqu’un explorera, le mauvais pour une figure destinée à un document imprimé ou à un e-mail.

response = client.responses.create(
    model="gpt-5.6-terra",
    input=[{
        "role": "user",
        "content": [
            {"type": "input_text", "text": (
                "Cree un graphique interactif plotly montrant l'evolution "
                "des ventes avec : "
                "- Zoom et sélection de plage de dates "
                "- Tooltip au survol avec détails "
                "- Boutons pour filtrer par catégorie "
                "- Export en fichier HTML autonome"
            )},
            {"type": "input_file", "file_id": fichier.id}
        ]
    }],
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)

# Récupérer le fichier HTML interactif
for ann in fichiers_generes(response):
    if ann.filename.endswith(".html"):
        telecharger(client, ann, "dashboard_interactif.html")

Personnalisation avancée

Charte graphique d’entreprise

Un graphique produit par défaut se reconnaît immédiatement, et fait amateur dans un document d’entreprise. Passer ses couleurs, ses polices et ses conventions dans instructions suffit à obtenir des figures homogènes d’un rapport à l’autre — et comme ces instructions sont réutilisables, l’effort n’est consenti qu’une fois.

CHARTE_GRAPHIQUE = """
Regles de visualisation :
- Couleur principale : #1E3A5F (bleu marine)
- Couleur secondaire : #E74C3C (rouge)
- Couleur accent : #F39C12 (orange)
- Fond : blanc (#FFFFFF)
- Police : sans-serif
- Pas de cadre autour des graphiques
- Grille legere en gris clair (#E0E0E0)
- Titre en gras, taille 14
- Labels des axes en taille 11
- Legende en bas a droite
- Toujours inclure la source des données en bas a gauche
- Resolution minimale : 1200x800 pixels
"""

response = client.responses.create(
    model="gpt-5.6-terra",
    input=[{
        "role": "user",
        "content": [
            {"type": "input_text", "text": "Cree un graphique d'evolution du CA trimestriel"},
            {"type": "input_file", "file_id": fichier.id}
        ]
    }],
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}],
    instructions=CHARTE_GRAPHIQUE
)

Pattern : générateur de rapports visuels

def generer_rapport_visuel(
    fichier_path: str,
    titre_rapport: str,
    sections: list[str]
) -> list[str]:
    """Génère un rapport avec graphiques a partir de données."""
    with open(fichier_path, "rb") as f:
        fichier = client.files.create(file=f, purpose="user_data")

    images = []

    for i, section in enumerate(sections):
        response = client.responses.create(
            model="gpt-5.6-terra",
            input=[{
                "role": "user",
                "content": [
                    {"type": "input_text", "text": f"Section {i+1} du rapport '{titre_rapport}' : {section}"},
                    {"type": "input_file", "file_id": fichier.id}
                ]
            }],
            tools=[{"type": "code_interpreter", "container": {"type": "auto"}}],
            instructions=(
                "Cree un graphique professionnel pour cette section. "
                "Inclus un titre descriptif et des annotations pertinentes. "
                "Exporte en PNG 1200x800 DPI 150."
            )
        )

        for ann in fichiers_generes(response):
            nom = f"rapport_section_{i+1}.png"
            telecharger(client, ann, nom)
            images.append(nom)

    return images

# Utilisation
graphiques = generer_rapport_visuel(
    "ventes_annuelles.csv",
    "Bilan Commercial 2025",
    [
        "Évolution mensuelle du chiffre d'affaires avec tendance",
        "Répartition des ventes par region (carte ou treemap)",
        "Comparaison des performances par commercial (barres groupées)",
        "Prévisions pour les 3 prochains mois (avec intervalle de confiance)"
    ]
)

Conseils pour des graphiques de qualité

instructions_qualite = """
Pour chaque graphique :
- Choisis le type de graphique le plus adapte aux données
- Utilise des couleurs accessibles (contraste suffisant)
- Evite les graphiques 3D sauf demande explicite
- Limite les pie charts a 6 categories maximum
- Ajoute des annotations pour les points importants
- Utilise des echelles adaptees (pas de zero tronque sauf justifie)
- Exporte toujours en haute resolution
"""

Points clés à retenir

matplotlib, seaborn et plotly sont disponibles dans le sandbox
Passez vos données via input_file pour des graphiques basés sur des fichiers réels
Définissez une charte graphique dans les instructions pour la cohérence
Récupérez les images générées dans les annotations container_file_citation, puis téléchargez-les par l’API des conteneurs (fonctions fichiers_generes et telecharger de la leçon 10)
Plotly permet de générer des dashboards HTML interactifs