Generación automatizada de gráficos y visualizaciones
Genere gráficos con matplotlib/seaborn y devuelva resultados de imágenes en base64.
Generación automatizada de gráficos y visualizaciones es una lección gratuita de AI Agents en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de AI Agents, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de AI Agents incluye 4 lecciones en total.
Por qué los agentes generan gráficos
Los números en texto son difíciles de interpretar. Un gráfico que muestre las tendencias de ventas durante 12 meses comunica en segundos lo que un párrafo de números no puede.
Un agente de análisis de datos capaz de generar visualizaciones es mucho más útil: produce el mismo resultado que un analista humano, tanto números como gráficos.
Configuración de Matplotlib no interactivo
De forma predeterminada, matplotlib abre una ventana de interfaz gráfica. En un agente (que se ejecuta en el servidor sin pantalla), debe cambiar al backend Agg: solo renderiza en archivos, sin interfaz gráfica.
Configúrelo antes de importar pyplot para evitar errores de visualización.
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: AggGeneración de gráficos de barras
Los gráficos de barras comparan valores entre categorías. Utilícelos para clasificaciones de los primeros N elementos, comparaciones entre categorías y comparaciones de antes y despué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 pathGeneración de gráficos de líneas
Los gráficos de líneas muestran tendencias a lo largo del tiempo. Utilícelos para datos de series temporales: ventas diarias, crecimiento de usuarios durante varios meses o métricas de rendimiento a lo largo de los sprints.
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 pathGeneración de gráficos de dispersión
Los gráficos de dispersión revelan relaciones entre dos variables numéricas: la correlación entre la inversión publicitaria y los ingresos, o entre el tamaño del pedido y el tiempo de entrega.
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 pathGeneración de histogramas
Los histogramas muestran la distribución de una única variable numérica: cómo se distribuyen los valores de los pedidos, la distribución de las edades de los clientes o la distribución de los tiempos de respuesta.
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 pathCodificación en base64 para la respuesta del agente
Después de guardar el gráfico como archivo PNG, codifíquelo en base64 para poder devolverlo como una cadena serializable en JSON en el resultado de la herramienta. El llamador podrá renderizarlo o mostrarlo.
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')Generación de descripciones
Un gráfico sin descripción obliga al lector a interpretarlo por su cuenta. Haga que el LLM genere una descripción de una sola oración que explique la conclusión clave visible en el gráfico.
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."Selección automática del tipo de gráfico
Distintas preguntas requieren distintos tipos de gráficos. En lugar de fijar de antemano qué gráfico utilizar, permita que el LLM decida según las características de los datos y el tipo de pregunta.
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)Herramienta unificada de generación de gráficos
Integre todos los tipos de gráficos en una sola herramienta que los agentes puedan llamar. Si no se especifica, la herramienta selecciona automáticamente el tipo de gráfico, lo crea, lo codifica y genera una descripción.
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)Gráficos de varias series y agrupados
Al comparar varios grupos (por ejemplo, los ingresos por región a lo largo del tiempo), utilice gráficos agrupados o de varias series. Matplotlib admite varias líneas en un mismo gráfico y gráficos de barras agrupadas con desplazamientos.
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 pathComprobación de conocimientos
¿Por qué debe configurarse el backend Agg de matplotlib antes de importar pyplot en un agente que se ejecuta en el servidor?
Recapitulación: generación automatizada de gráficos y visualizaciones
Los agentes de datos generan gráficos de la siguiente manera: configuran el backend Agg de matplotlib (sin interfaz gráfica), crean gráficos con plt.savefig(), utilizan la codificación en base64 para transportarlos en JSON y generan descripciones escritas por el LLM que destacan las conclusiones clave.
Cuatro tipos de gráficos esenciales: barras (comparaciones entre categorías), líneas (series temporales), dispersión (correlaciones con línea de tendencia) e histogramas (distribuciones). La selección automática del tipo de gráfico permite que el LLM elija la mejor visualización según las características de los datos y la pregunta del usuario.
Preguntas frecuentes
¿La lección «Generación automatizada de gráficos y visualizaciones» es gratis?
Sí — el texto completo de «Generación automatizada de gráficos y visualizaciones» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de AI Agents, actualiza a CoddyKit PRO. El curso de AI Agents incluye 4 lecciones en total.
¿Qué aprenderé en «Generación automatizada de gráficos y visualizaciones»?
Genere gráficos con matplotlib/seaborn y devuelva resultados de imágenes en base64. Practicas AI Agents con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar AI Agents?
No se requiere experiencia previa. AI Agents en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.
¿Cuánto tiempo toma la lección «Generación automatizada de gráficos y visualizaciones»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de AI Agents?
Sí. Cada lección de AI Agents incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Patrón de intérprete de código para análisis de datos
- Herramientas de agentes basadas en Pandas
- Generación automatizada de gráficos y visualizaciones
- Agentes de resúmenes estadísticos