Claude für Python Data Science Workflows: Von Exploration bis Modell

1. Warum Python Data Science Workflows von Claude profitieren

Ein typisches Python-Data-Science-Projekt besteht zu einem großen Teil aus Arbeit, die wenig mit der eigentlichen fachlichen Fragestellung zu tun hat: Spaltennamen normalisieren, fehlende Werte behandeln, Datentypen korrigieren, Plot-Code für die zehnte Variante eines Histogramms schreiben. Claude reduziert genau diesen Anteil, indem es aus einer kurzen Beschreibung des DataFrames oder aus dem Output von df.info() und df.describe() direkt lauffähigen pandas-Code erzeugt. Der Data Scientist bleibt dabei für die fachliche Interpretation zuständig, Claude übernimmt die mechanische Umsetzung.

Der Unterschied zu einem generischen Code-Generator liegt darin, dass Claude den Kontext eines Data-Science-Workflows versteht: Es kennt gängige Fallstricke wie Data Leakage zwischen Trainings- und Testdaten, weiß, wann eine Spalte eher kategorial als numerisch behandelt werden sollte, und schlägt bei schiefen Verteilungen automatisch eine Log-Transformation vor. Diese Artikelserie zeigt, wie Claude in den einzelnen Phasen eines Python-Data-Science-Workflows eingesetzt wird: von der explorativen Analyse über Feature Engineering und Modellierung bis zur Reproduzierbarkeit und zum Code-Review.

2. Explorative Datenanalyse mit Claude beschleunigen

Die explorative Datenanalyse, kurz EDA, ist meist der erste Schritt nach dem Laden eines neuen Datensatzes und gleichzeitig der Schritt mit dem größten Wiederholungsanteil: Verteilung jeder Spalte anschauen, fehlende Werte zählen, Korrelationen prüfen, Ausreißer identifizieren. Claude generiert aus einer kurzen Beschreibung des Datensatzes ein vollständiges EDA-Skript, das genau diese Schritte systematisch durchläuft, statt dass der Data Scientist für jeden neuen Datensatz denselben Boilerplate-Code erneut schreibt.

Wichtiger als die reine Code-Generierung ist dabei die Interpretation: Claude kann aus der Ausgabe von df.describe() ableiten, welche Spalten wahrscheinlich Ausreißer enthalten, und aus einer Kreuztabelle erkennen, ob zwei kategoriale Merkmale stark korreliert sind, was später bei der Modellierung zu Multikollinearität führen könnte. Diese Hinweise ersetzen nicht die fachliche Prüfung durch den Data Scientist, sparen aber die Zeit, jede Auffälligkeit manuell aufzuspüren.

# eda.py - Exploratory data analysis generated with Claude
import pandas as pd
import numpy as np

def explore_dataframe(df: pd.DataFrame) -> None:
    """Print a structured EDA summary: shape, missing values,
    dtypes, numeric distribution, and cardinality of object columns.
    """
    print(f"Shape: {df.shape}")
    print("\nMissing values (top 10):")
    print(df.isna().sum().sort_values(ascending=False).head(10))

    numeric_cols = df.select_dtypes(include=[np.number]).columns
    print("\nNumeric summary:")
    print(df[numeric_cols].describe().T)

    object_cols = df.select_dtypes(include=["object", "category"]).columns
    print("\nCardinality of categorical columns:")
    for col in object_cols:
        print(f"  {col}: {df[col].nunique()} unique values")

    # Flag columns with skewed distribution for later log-transform
    skewed = df[numeric_cols].skew().abs().sort_values(ascending=False)
    print("\nSkewed columns (candidates for log transform):")
    print(skewed[skewed > 1.0])

df = pd.read_csv("orders.csv")
explore_dataframe(df)

3. Datenbereinigung und Feature Engineering mit Claude

Nach der Exploration folgt die Bereinigung, und hier zeigt sich der Wert von Claude besonders deutlich bei wiederkehrenden Transformationsmustern: fehlende Werte je nach Spaltentyp unterschiedlich behandeln, kategoriale Merkmale kodieren, neue Merkmale aus vorhandenen Spalten ableiten. Claude schlägt für jede Spalte eine passende Strategie vor, etwa Median-Imputation für schiefe numerische Verteilungen statt des Mittelwerts, der von Ausreißern verzerrt würde, oder One-Hot-Encoding nur für Spalten mit geringer Kardinalität, um die Dimensionalität nicht unnötig aufzublähen.

Ein besonderer Stärkepunkt liegt im Feature Engineering: Aus einem Zeitstempel lassen sich Wochentag, Stunde und Feiertagsflag ableiten, aus zwei numerischen Spalten ein Verhältnis oder eine Differenz bilden, die für ein Modell aussagekräftiger ist als die Einzelwerte. Claude schlägt solche abgeleiteten Merkmale basierend auf der fachlichen Beschreibung des Datensatzes vor, etwa dass bei einem Bestelldatensatz die Zeitspanne zwischen Bestellung und Versand ein starkes Signal für Lieferverzögerungen sein kann. Die Entscheidung, welches Feature tatsächlich in das Modell aufgenommen wird, bleibt aber immer beim Data Scientist.

# feature_engineering.py - pipeline generated and reviewed with Claude
from sklearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import OneHotEncoder, StandardScaler

numeric_features = ["order_value", "customer_age", "days_since_signup"]
categorical_features = ["shipping_method", "payment_type"]

numeric_transformer = Pipeline(steps=[
    ("imputer", SimpleImputer(strategy="median")),
    ("scaler", StandardScaler()),
])

categorical_transformer = Pipeline(steps=[
    ("imputer", SimpleImputer(strategy="most_frequent")),
    ("onehot", OneHotEncoder(handle_unknown="ignore")),
])

preprocessor = ColumnTransformer(transformers=[
    ("num", numeric_transformer, numeric_features),
    ("cat", categorical_transformer, categorical_features),
])

def add_derived_features(df):
    """Derive time-based and ratio features from raw columns."""
    df = df.copy()
    df["order_hour"] = df["order_timestamp"].dt.hour
    df["order_weekday"] = df["order_timestamp"].dt.dayofweek
    df["value_per_item"] = df["order_value"] / df["item_count"].clip(lower=1)
    return df

4. Visualisierungscode generieren und Diagramme interpretieren

Visualisierung ist ein Bereich, in dem sich viele Data Scientists wiederholt mit derselben matplotlib- oder seaborn-Syntax herumschlagen: Achsenbeschriftungen, Farbschemata, Legendenpositionen. Claude erzeugt aus einer kurzen Beschreibung des gewünschten Diagramms, etwa Verteilung des Bestellwerts nach Versandart, direkt den passenden seaborn-Code inklusive sinnvoller Beschriftung, ohne dass der Data Scientist die matplotlib-API im Detail nachschlagen muss.

Wertvoller als die reine Codegenerierung ist die Fähigkeit von Claude, ein bereits erzeugtes Diagramm zu interpretieren, wenn es als Bild in die Konversation eingebunden wird: Es erkennt bimodale Verteilungen, Ausreißer-Cluster oder eine erkennbare Korrelation zwischen zwei Achsen und formuliert daraus konkrete Hypothesen für die weitere Analyse. Diese Kombination aus Code-Generierung und Bildinterpretation verkürzt den Iterationszyklus zwischen Diagramm erstellen, Muster erkennen und nächsten Analyseschritt ableiten erheblich.

5. Von der Baseline zum Modell mit scikit-learn

Bei der eigentlichen Modellierung liefert Claude am meisten Wert, wenn es nicht sofort das komplexeste Modell vorschlägt, sondern zuerst eine einfache Baseline etabliert: ein DummyClassifier oder eine lineare Regression als Referenzpunkt, gegen den jedes komplexere Modell sich rechtfertigen muss. Diese Disziplin verhindert, dass ein Gradient-Boosting-Modell als Erfolg gefeiert wird, obwohl es kaum besser abschneidet als die einfachste denkbare Vorhersage.

Für die eigentliche Modellwahl kennt Claude die typischen Kompromisse zwischen Interpretierbarkeit und Vorhersagekraft: Eine logistische Regression liefert nachvollziehbare Koeffizienten für ein Fachpublikum, ein Random Forest oder Gradient Boosting liefert meist bessere Metriken, aber schwerer erklärbare Entscheidungen. Claude schlägt außerdem passende Kreuzvalidierungsstrategien vor, etwa eine zeitbasierte Aufteilung statt einer zufälligen Aufteilung, wenn der Datensatz eine zeitliche Ordnung hat und ein zufälliges Splitting sonst Data Leakage aus der Zukunft in die Trainingsdaten einschleusen würde.

# baseline_vs_model.py - establish a baseline before the real model
from sklearn.dummy import DummyClassifier
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.model_selection import TimeSeriesSplit, cross_val_score

X_train, y_train = load_training_data()

# Baseline: always predict the majority class
baseline = DummyClassifier(strategy="most_frequent")
baseline_scores = cross_val_score(baseline, X_train, y_train, cv=5, scoring="f1")
print(f"Baseline F1: {baseline_scores.mean():.3f}")

# Real model, evaluated with time-aware splits to avoid leakage
tscv = TimeSeriesSplit(n_splits=5)
model = GradientBoostingClassifier(random_state=42)
model_scores = cross_val_score(model, X_train, y_train, cv=tscv, scoring="f1")
print(f"Model F1: {model_scores.mean():.3f}")

if model_scores.mean() <= baseline_scores.mean() * 1.05:
    print("WARNING: model barely beats the baseline, revisit features")

6. Claude Code in Jupyter-Notebook-Workflows integrieren

Viele Data Scientists arbeiten in Jupyter-Notebooks statt in reinen Python-Skripten, und Claude Code lässt sich direkt in dieses Umfeld integrieren, indem es im selben Projektverzeichnis wie die Notebooks läuft und Zellen als eigenständige Codeblöcke bearbeitet. Statt Code direkt in der Kommandozeile zu erzeugen, formuliert man die Anfrage im Kontext der bereits geladenen Variablen und Zwischenergebnisse, sodass Claude Code eine neue Zelle vorschlägt, die nahtlos an den bestehenden Notebook-Zustand anschließt.

Ein bewährtes Muster ist, ein CLAUDE.md im Projektverzeichnis mit Angaben zum Datensatz, den erwarteten Spalten und der fachlichen Fragestellung zu hinterlegen. Claude Code liest diese Datei automatisch und muss die Projektstruktur nicht bei jeder neuen Anfrage erneut erklärt bekommen. Für explorative Notebooks mit vielen kleinen Iterationen reduziert das die Menge an Kontext, die man in jedem einzelnen Prompt wiederholen müsste, erheblich.

#!/usr/bin/env bash
# Run Claude Code inside a data science project directory
cd ~/projects/churn-analysis

# Claude reads CLAUDE.md automatically for dataset context
claude -p "Add a new cell after the EDA section that plots the
correlation heatmap for all numeric columns and highlights any
pair with |corr| > 0.8 as a candidate for feature removal."

7. Reproduzierbarkeit: Environments, Seeds und Versionen

Reproduzierbarkeit ist in Data-Science-Projekten notorisch schwierig, weil sich Ergebnisse durch unterschiedliche Paketversionen, fehlende Random Seeds oder nicht dokumentierte manuelle Zwischenschritte verändern können. Claude hilft dabei, ein Projekt reproduzierbar zu machen, indem es eine vollständige requirements.txt mit gepinnten Versionen aus dem tatsächlich installierten Environment ableitet und prüft, ob in jedem Trainingsskript ein fester Random Seed für NumPy, scikit-learn und gegebenenfalls PyTorch gesetzt ist.

Ein weiterer häufiger Fehler, den Claude im Review zuverlässig findet, ist ein Data-Leakage-Problem durch falsche Reihenfolge der Schritte: Wenn der Skalierer auf dem gesamten Datensatz statt nur auf den Trainingsdaten angepasst wird, sickern Informationen aus dem Testset in das Modell, und die Testmetriken werden künstlich zu optimistisch. Claude erkennt dieses Muster im Code, weil fit_transform auf dem vollständigen DataFrame statt auf X_train aufgerufen wird, und schlägt die Korrektur mit einer sklearn-Pipeline vor, die Fit und Transform sauber trennt.

8. Code-Review von Data-Science-Skripten mit Claude

Data-Science-Code wird seltener einem klassischen Code-Review unterzogen als Anwendungscode, obwohl fehlerhafte Analysen genauso teuer werden können wie Softwarebugs, nur oft erst spät sichtbar. Claude eignet sich gut als zusätzliche Review-Instanz für Notebooks und Skripte, weil es typische Data-Science-spezifische Probleme erkennt, die ein allgemeiner Linter übersieht: Data Leakage zwischen Train und Test, fehlende Stratifizierung bei unbalancierten Klassen, oder eine Metrik, die für das eigentliche Geschäftsproblem ungeeignet ist, etwa Accuracy bei einem stark unbalancierten Klassifikationsproblem statt F1 oder AUC.

In der Praxis bewährt sich ein Review-Prompt, der Claude explizit bittet, das Skript Zeile für Zeile auf diese Data-Science-typischen Fehlerklassen zu prüfen, statt nur allgemeine Codequalität zu bewerten. Das Ergebnis ist eine Liste konkreter Fundstellen mit Begründung, warum ein bestimmtes Muster problematisch ist, und ein Korrekturvorschlag, der sich direkt in die Pipeline einbauen lässt, ohne die gesamte Analyse neu aufzusetzen.

9. Klassischer versus Claude-gestützter Data-Science-Workflow

Der Unterschied zwischen einem klassischen und einem Claude-gestützten Workflow zeigt sich am deutlichsten in der Zeitverteilung: Wo vorher ein großer Anteil der Zeit in repetitive Code-Erstellung floss, verschiebt sich der Schwerpunkt auf fachliche Interpretation und Modellvalidierung.

Diese Verschiebung bedeutet nicht, dass Claude die fachliche Verantwortung übernimmt. Die Entscheidung, welches Feature sinnvoll ist, welche Metrik das Geschäftsproblem korrekt abbildet und ob ein Modell überhaupt produktionsreif ist, bleibt beim Data Scientist. Claude verschiebt den Zeitaufwand von der mechanischen Umsetzung hin zur fachlichen Bewertung.

10. Zusammenfassung

Claude verändert Python-Data-Science-Workflows, indem es den repetitiven Anteil von explorativer Analyse, Feature Engineering und Visualisierung deutlich reduziert. Von der ersten Sichtung eines DataFrames über Feature-Vorschläge und Baseline-Modelle bis hin zum Review auf Data Leakage begleitet Claude jede Phase des Workflows, ohne dem Data Scientist die fachliche Verantwortung abzunehmen. Die Integration in Jupyter-Notebooks über Claude Code und ein projekteigenes CLAUDE.md hält den Kontext über viele kleine Iterationen hinweg stabil.

Der größte Effekt entsteht nicht durch einzelne generierte Codezeilen, sondern durch die konsequente Anwendung über den gesamten Workflow: Baseline vor komplexem Modell, gepinnte Versionen für Reproduzierbarkeit, systematisches Review gegen Data Leakage. Wer diese Disziplin mit Claude als Copilot etabliert, gewinnt Zeit für die eigentliche fachliche Analyse zurück, statt sie in immer wiederkehrendem Boilerplate-Code zu verlieren.

11. FAQ: Claude für Python Data Science Workflows