Automatische Erstellung von Diagrammen und Visualisierungen
matplotlib-/seaborn-Diagramme generieren und Bildergebnisse als Base64 zurückgeben.
Automatische Erstellung von Diagrammen und Visualisierungen ist eine kostenlose AI Agents-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des AI Agents-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der AI Agents-Kurs umfasst insgesamt 4 Lektionen.
Warum Agenten Diagramme erzeugen
Zahlen in Textform sind schwer zu erfassen. Ein Diagramm, das Verkaufstrends über 12 Monate zeigt, vermittelt in wenigen Sekunden, was ein Absatz voller Zahlen nicht leisten kann.
Ein Datenanalyseagent, der Visualisierungen erzeugen kann, ist deutlich nützlicher – er erstellt dieselbe Ausgabe wie ein menschlicher Analyst: sowohl Zahlen als auch Diagramme.
Nicht interaktives Matplotlib einrichten
Standardmäßig öffnet matplotlib ein GUI-Fenster. In einem Agenten, der serverseitig und ohne Anzeige ausgeführt wird, müssen Sie auf das Agg-Backend umschalten – es rendert ausschließlich in eine Datei und verwendet keine GUI.
Setzen Sie dies vor dem Import von pyplot, um Anzeige-Fehler zu vermeiden.
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: AggBalkendiagramme erzeugen
Balkendiagramme vergleichen Werte über Kategorien hinweg. Verwenden Sie sie für Top-N-Ranglisten, Kategorienvergleiche und Vorher-Nachher-Vergleiche.
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 pathLiniendiagramme erzeugen
Liniendiagramme zeigen Trends im Zeitverlauf. Verwenden Sie sie für Zeitreihendaten: tägliche Umsätze, Nutzerwachstum über mehrere Monate oder Leistungskennzahlen über mehrere 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 pathStreudiagramme erzeugen
Streudiagramme machen Zusammenhänge zwischen zwei numerischen Variablen sichtbar – etwa die Korrelation zwischen Werbeausgaben und Umsatz oder zwischen Bestellgröße und Lieferzeit.
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 pathHistogramme erzeugen
Histogramme zeigen die Verteilung einer einzelnen numerischen Variable – etwa die Verteilung von Bestellwerten, Kundenalter oder Antwortzeiten.
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 pathBase64-Kodierung für die Agentenantwort
Nachdem Sie das Diagramm als PNG-Datei gespeichert haben, kodieren Sie es als Base64, damit es als JSON-serialisierbare Zeichenfolge im Tool-Ergebnis zurückgegeben werden kann. Der Aufrufer kann es anschließend rendern oder anzeigen.
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')Beschriftungen erzeugen
Ein Diagramm ohne Beschriftung zwingt die Betrachtenden, es selbst zu interpretieren. Lassen Sie das LLM eine einzeilige Beschriftung erzeugen, die die im Diagramm sichtbare wichtigste Erkenntnis beschreibt.
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."Diagrammtyp automatisch auswählen
Unterschiedliche Fragen erfordern unterschiedliche Diagrammtypen. Statt den zu verwendenden Diagrammtyp fest zu programmieren, lassen Sie das LLM anhand der Datenmerkmale und des Fragetypus entscheiden.
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)Einheitliches Tool zur Diagrammerzeugung
Fassen Sie alle Diagrammtypen in einem einzigen Tool zusammen, das Agenten aufrufen können. Wenn kein Diagrammtyp angegeben ist, wählt das Tool automatisch einen aus, erstellt das Diagramm, kodiert es und erzeugt eine Beschriftung.
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)Diagramme mit mehreren Datenreihen und Gruppierungen
Verwenden Sie beim Vergleich mehrerer Gruppen (z. B. Umsatz nach Region im Zeitverlauf) gruppierte Diagramme oder Diagramme mit mehreren Datenreihen. Matplotlib unterstützt mehrere Linien in einem Diagramm sowie gruppierte Balkendiagramme mit Versätzen.
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 pathWissenscheck
Warum muss das Agg-Backend von matplotlib vor dem Import von pyplot festgelegt werden, wenn der Agent serverseitig ausgeführt wird?
Rückblick: Automatisierte Diagramm- und Visualisierungserzeugung
Datenagenten erzeugen Diagramme, indem sie das matplotlib-Agg-Backend festlegen (keine GUI), Diagramme mit plt.savefig() erstellen, sie für den JSON-Transport als Base64 kodieren und vom LLM formulierte Beschriftungen erzeugen, die wichtige Erkenntnisse hervorheben.
Vier grundlegende Diagrammtypen: Balken (Kategorienvergleiche), Linien (Zeitreihen), Streudiagramme (Korrelationen mit Trendlinie) und Histogramme (Verteilungen). Durch die automatische Auswahl des Diagrammtyps kann das LLM anhand der Datenmerkmale und der Benutzerfrage die beste Visualisierung auswählen.
Lerne AI Agents mit einem KI-Tutor — kostenlos
Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.
- Kurse
- 60
- Lektionen
- 239
Häufig gestellte Fragen
Ist die Lektion „Automatische Erstellung von Diagrammen und Visualisierungen“ kostenlos?
Ja — der vollständige Text von „Automatische Erstellung von Diagrammen und Visualisierungen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des AI Agents-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der AI Agents-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Automatische Erstellung von Diagrammen und Visualisierungen“?
matplotlib-/seaborn-Diagramme generieren und Bildergebnisse als Base64 zurückgeben. Du übst AI Agents mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um AI Agents zu starten?
Keine Vorkenntnisse erforderlich. AI Agents auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.
Wie lange dauert die Lektion „Automatische Erstellung von Diagrammen und Visualisierungen“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser AI Agents-Lektion Code schreiben und ausführen?
Ja. Jede AI Agents-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Code-Interpreter-Muster für Datenanalysen
- Pandas-basierte Daten-Agent-Tools
- Automatische Erstellung von Diagrammen und Visualisierungen
- Agenten für statistische Zusammenfassungen