PricingLoginStart free
AI Agents · Leçon

Générer automatiquement des graphiques et visualisations

Générez des graphiques matplotlib/seaborn et renvoyez des images en base64.

Leçon 3 sur 413 étapes

Générer automatiquement des graphiques et visualisations est une leçon AI Agents gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage AI Agents, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours AI Agents comprend 4 leçons au total.

Pourquoi les agents génèrent des graphiques

Les nombres présentés dans du texte sont difficiles à interpréter. Un graphique montrant les tendances des ventes sur 12 mois communique en quelques secondes ce qu’un paragraphe de nombres ne peut pas faire.

Un agent d’analyse de données capable de générer des visualisations est beaucoup plus utile : il produit le même résultat qu’un analyste humain, à savoir des nombres et des graphiques.

Configuration de Matplotlib en mode non interactif

Par défaut, matplotlib ouvre une fenêtre GUI. Dans un agent exécuté côté serveur sans affichage, vous devez passer au moteur Agg, qui effectue uniquement un rendu vers un fichier, sans GUI.

Définissez ce moteur avant d’importer pyplot afin d’éviter les erreurs d’affichage.

import matplotlib
matplotlib.use('Agg')  # must be set BEFORE importing pyplot
import matplotlib.pyplot as plt
import os

OUTPUT_DIR = '/tmp/agent_charts'
os.makedirs(OUTPUT_DIR, exist_ok=True)

# Verify no display is needed
print('Backend:', matplotlib.get_backend())  # Should print: Agg

Génération de graphiques à barres

Les graphiques à barres comparent des valeurs entre différentes catégories. Utilisez-les pour les classements des N premiers éléments, les comparaisons entre catégories et les comparaisons avant/après.

import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
import os

OUTPUT_DIR = '/tmp/agent_charts'
os.makedirs(OUTPUT_DIR, exist_ok=True)

def create_bar_chart(labels, values, title, xlabel, ylabel, filename):
    fig, ax = plt.subplots(figsize=(10, 6))
    bars = ax.bar(labels, values, color='steelblue', edgecolor='white')

    # Add value labels on bars
    for bar, value in zip(bars, values):
        ax.text(
            bar.get_x() + bar.get_width() / 2,
            bar.get_height() + max(values) * 0.01,
            f'{value:,.0f}', ha='center', va='bottom', fontsize=9
        )

    ax.set_title(title, fontsize=14, pad=15)
    ax.set_xlabel(xlabel)
    ax.set_ylabel(ylabel)
    plt.xticks(rotation=45, ha='right')
    plt.tight_layout()

    path = os.path.join(OUTPUT_DIR, filename)
    plt.savefig(path, dpi=150, bbox_inches='tight')
    plt.close()
    return path

Génération de graphiques linéaires

Les graphiques linéaires montrent les tendances au fil du temps. Utilisez-les pour les séries temporelles : ventes quotidiennes, croissance du nombre d’utilisateurs sur plusieurs mois ou indicateurs de performance au fil des cycles de développement.

import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
import os

OUTPUT_DIR = '/tmp/agent_charts'
os.makedirs(OUTPUT_DIR, exist_ok=True)

def create_line_chart(x_values, y_values, title, xlabel, ylabel, filename, label=None):
    fig, ax = plt.subplots(figsize=(10, 5))
    ax.plot(x_values, y_values, marker='o', linewidth=2, markersize=5,
            color='darkorange', label=label or ylabel)

    # Highlight min and max points
    max_idx = y_values.index(max(y_values))
    min_idx = y_values.index(min(y_values))
    ax.annotate(f'Max: {max(y_values):,.0f}',
                xy=(x_values[max_idx], y_values[max_idx]),
                xytext=(5, 10), textcoords='offset points', color='green')

    ax.set_title(title, fontsize=14, pad=15)
    ax.set_xlabel(xlabel)
    ax.set_ylabel(ylabel)
    ax.grid(True, alpha=0.3)
    plt.xticks(rotation=45, ha='right')
    plt.tight_layout()

    path = os.path.join(OUTPUT_DIR, filename)
    plt.savefig(path, dpi=150, bbox_inches='tight')
    plt.close()
    return path

Génération de nuages de points

Les nuages de points mettent en évidence les relations entre deux variables numériques, comme la corrélation entre les dépenses publicitaires et le chiffre d’affaires, ou entre le montant d’une commande et le délai de livraison.

import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
import numpy as np
import os

OUTPUT_DIR = '/tmp/agent_charts'
os.makedirs(OUTPUT_DIR, exist_ok=True)

def create_scatter_chart(x_values, y_values, title, xlabel, ylabel, filename, add_trendline=True):
    fig, ax = plt.subplots(figsize=(8, 6))
    ax.scatter(x_values, y_values, alpha=0.6, color='royalblue', edgecolors='white', s=60)

    if add_trendline and len(x_values) > 2:
        z = np.polyfit(x_values, y_values, 1)
        p = np.poly1d(z)
        x_line = sorted(x_values)
        ax.plot(x_line, p(x_line), 'r--', alpha=0.7, label='Trend')
        ax.legend()

    # Compute and show correlation
    corr = np.corrcoef(x_values, y_values)[0, 1]
    ax.text(0.05, 0.95, f'r = {corr:.2f}', transform=ax.transAxes,
            fontsize=10, verticalalignment='top')

    ax.set_title(title, fontsize=14, pad=15)
    ax.set_xlabel(xlabel)
    ax.set_ylabel(ylabel)
    plt.tight_layout()

    path = os.path.join(OUTPUT_DIR, filename)
    plt.savefig(path, dpi=150, bbox_inches='tight')
    plt.close()
    return path

Génération d’histogrammes

Les histogrammes montrent la distribution d’une variable numérique unique : la répartition des montants des commandes, la distribution de l’âge des clients ou celle des délais de réponse.

import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
import numpy as np
import os

OUTPUT_DIR = '/tmp/agent_charts'
os.makedirs(OUTPUT_DIR, exist_ok=True)

def create_histogram(values, title, xlabel, filename, bins=20):
    fig, ax = plt.subplots(figsize=(8, 5))
    n, bin_edges, patches = ax.hist(values, bins=bins, color='mediumseagreen',
                                     edgecolor='white', alpha=0.8)

    # Add mean and median lines
    mean_val = np.mean(values)
    median_val = np.median(values)
    ax.axvline(mean_val, color='red', linestyle='--', label=f'Mean: {mean_val:.1f}')
    ax.axvline(median_val, color='blue', linestyle='--', label=f'Median: {median_val:.1f}')

    ax.set_title(title, fontsize=14, pad=15)
    ax.set_xlabel(xlabel)
    ax.set_ylabel('Frequency')
    ax.legend()
    plt.tight_layout()

    path = os.path.join(OUTPUT_DIR, filename)
    plt.savefig(path, dpi=150, bbox_inches='tight')
    plt.close()
    return path

Encodage en base64 pour la réponse de l’agent

Après avoir enregistré le graphique dans un fichier PNG, encodez-le en base64 afin qu’il puisse être renvoyé sous forme de chaîne sérialisable en JSON dans le résultat de l’outil. L’appelant peut ensuite le restituer ou l’afficher.

import base64

def file_to_base64(filepath):
    with open(filepath, 'rb') as f:
        return base64.b64encode(f.read()).decode('utf-8')

def create_chart_result(chart_path, chart_type, caption):
    b64 = file_to_base64(chart_path)
    return {
        'type': 'image',
        'chart_type': chart_type,
        'format': 'png',
        'base64': b64,
        'caption': caption,
        'file_path': chart_path
    }

# Usage after creating a chart
path = create_bar_chart(['Q1', 'Q2', 'Q3', 'Q4'], [12000, 15000, 18000, 22000],
                        'Quarterly Revenue', 'Quarter', 'Revenue ($)', 'revenue.png')
result = create_chart_result(path, 'bar', 'Quarterly revenue showing consistent growth')
print(f'Chart encoded: {len(result["base64"])} chars')

Génération de légendes

Un graphique sans légende oblige l’observateur à l’interpréter lui-même. Demandez au LLM de générer une légende d’une phrase décrivant l’enseignement clé visible dans le graphique.

def generate_chart_caption(chart_type, data_summary, question):
    prompt = f'''A {chart_type} chart was generated to answer: "{question}"

Data summary:
{data_summary}

Write a single clear sentence describing the most important insight shown in the chart.
Focus on the key finding, not on describing what type of chart it is.

Caption:'''
    caption = llm_call(prompt).strip()
    # Ensure it ends with a period
    if caption and not caption.endswith('.'):
        caption += '.'
    return caption

# Example
caption = generate_chart_caption(
    chart_type='bar',
    data_summary='Q1: $12k, Q2: $15k, Q3: $18k, Q4: $22k (83% total growth)',
    question='How did quarterly revenue trend this year?'
)
print(caption)
# -> "Revenue grew consistently each quarter, with Q4 nearly doubling Q1 figures."

Sélection automatique du type de graphique

Les différents types de questions nécessitent différents types de graphiques. Plutôt que de coder en dur le graphique à utiliser, laissez le LLM décider en fonction des caractéristiques des données et du type de question.

import json

CHART_TYPE_PROMPT = '''Choose the best chart type to answer this question.

Question: {question}
Data has columns: {columns}
Data sample: {sample}

Available chart types:
- bar: comparing values across categories
- line: trends over time
- scatter: relationship between two numeric variables
- histogram: distribution of one numeric variable
- pie: composition/proportions (use sparingly)

Return JSON: {{"chart_type": "bar", "x": "category_column", "y": "value_column",
              "title": "Chart title", "xlabel": "X label", "ylabel": "Y label"}}'''

def select_chart_type(question, df):
    sample = df.head(3).to_dict(orient='records')
    response = llm_call(CHART_TYPE_PROMPT.format(
        question=question,
        columns=list(df.columns),
        sample=json.dumps(sample, default=str)
    ))
    return json.loads(response)

Outil unifié de génération de graphiques

Regroupez tous les types de graphiques dans un seul outil que les agents peuvent appeler. L’outil sélectionne automatiquement le type de graphique s’il n’est pas spécifié, crée le graphique, l’encode et génère une légende.

import pandas as pd

def generate_chart(df_name, question, chart_type=None, filename=None):
    df = dataframes.get(df_name)
    if df is None:
        return {'error': f'{df_name!r} not found'}

    # Auto-select chart type if not specified
    if not chart_type:
        spec = select_chart_type(question, df)
    else:
        spec = {'chart_type': chart_type}

    ct = spec.get('chart_type', 'bar')
    x_col = spec.get('x', df.columns[0])
    y_col = spec.get('y', df.select_dtypes(include='number').columns[0])
    title = spec.get('title', question[:60])
    fname = filename or f'chart_{ct}.png'

    x_vals = df[x_col].tolist()
    y_vals = df[y_col].tolist()

    if ct == 'bar':
        path = create_bar_chart(x_vals, y_vals, title, x_col, y_col, fname)
    elif ct == 'line':
        path = create_line_chart(x_vals, y_vals, title, x_col, y_col, fname)
    elif ct == 'histogram':
        path = create_histogram(y_vals, title, y_col, fname)
    else:
        path = create_scatter_chart(x_vals, y_vals, title, x_col, y_col, fname)

    caption = generate_chart_caption(ct, f'{x_col} vs {y_col}', question)
    return create_chart_result(path, ct, caption)

Graphiques multiséries et groupés

Lorsque vous comparez plusieurs groupes (par exemple, le chiffre d’affaires par région au fil du temps), utilisez des graphiques groupés ou multiséries. Matplotlib prend en charge plusieurs lignes dans un même graphique ainsi que les graphiques à barres groupées avec décalage.

import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
import numpy as np
import os

OUTPUT_DIR = '/tmp/agent_charts'
os.makedirs(OUTPUT_DIR, exist_ok=True)

def create_grouped_bar_chart(categories, series_data, title, xlabel, ylabel, filename):
    n_groups = len(categories)
    n_series = len(series_data)
    bar_width = 0.8 / n_series
    x = np.arange(n_groups)

    fig, ax = plt.subplots(figsize=(12, 6))
    colors = ['steelblue', 'darkorange', 'forestgreen', 'crimson']

    for i, (label, values) in enumerate(series_data.items()):
        offset = (i - (n_series - 1) / 2) * bar_width
        ax.bar(x + offset, values, bar_width, label=label,
               color=colors[i % len(colors)], alpha=0.85)

    ax.set_xticks(x)
    ax.set_xticklabels(categories, rotation=30, ha='right')
    ax.set_title(title, fontsize=14, pad=15)
    ax.set_xlabel(xlabel)
    ax.set_ylabel(ylabel)
    ax.legend()
    plt.tight_layout()

    path = os.path.join(OUTPUT_DIR, filename)
    plt.savefig(path, dpi=150, bbox_inches='tight')
    plt.close()
    return path

Vérification des connaissances

Pourquoi le moteur Agg de matplotlib doit-il être défini avant l’importation de pyplot dans un agent exécuté côté serveur ?

Réponds-y dans la leçon interactive

Récapitulatif : génération automatisée de graphiques et de visualisations

Les agents de données génèrent des graphiques en configurant le moteur Agg de matplotlib (sans GUI), en créant des graphiques avec plt.savefig(), en réalisant un encodage en base64 pour le transport JSON et en générant des légendes rédigées par le LLM qui mettent en évidence les enseignements clés.

Quatre types de graphiques essentiels : bar (comparaisons entre catégories), line (séries temporelles), scatter (corrélations avec une droite de tendance) et histogram (distributions). La sélection automatique du type de graphique permet au LLM de choisir la meilleure visualisation en fonction des caractéristiques des données et de la question de l’utilisateur.

Gratuit pour commencer

Apprends AI Agents avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours
60
Leçons
239
Commencer gratuitementVoir le cours complet

Questions Fréquemment Posées

La leçon « Générer automatiquement des graphiques et visualisations » est-elle gratuite ?

Oui — le texte complet de « Générer automatiquement des graphiques et visualisations » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours AI Agents, passe à CoddyKit PRO. Le cours AI Agents comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Générer automatiquement des graphiques et visualisations » ?

Générez des graphiques matplotlib/seaborn et renvoyez des images en base64. Tu pratiques AI Agents avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer AI Agents ?

Aucune expérience préalable n'est requise. AI Agents sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Générer automatiquement des graphiques et visualisations » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon AI Agents ?

Oui. Chaque leçon AI Agents inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Schéma d’interpréteur de code pour l’analyse de données
  2. Outils d’agents pilotés par pandas
  3. Générer automatiquement des graphiques et visualisations
  4. Agents de synthèse statistique
← Retour à AI Agents