FAQ-Glossar zur Data Science Schulung

In der Data Science Schulung begleiten wir den kompletten Workflow: Daten verstehen, bereinigen, analysieren, visualisieren und Modelle trainieren – reproduzierbar vom Rohdatensatz bis zur belastbaren Erkenntnis bzw. einem ersten Modell. Wir arbeiten praxisnah mit realistischen Datensätzen, damit Teilnehmende den End-to-End-Prozess erleben: vom Import über EDA bis zu einem evaluierten Modell samt Metriken und kurzer Ergebnisstory. Besonderer Fokus liegt auf sauberer Methodik (kein Leakage, sinnvolle Splits) und nachvollziehbarer Dokumentation, damit Ergebnisse der Data Science Schulung fachlich erklärbar und wiederholbar bleiben.

Beispielcode aus der Data Science Schulung:

# Übung aus der Data Science Schulung: CSV laden, filtern, Mittelwert
import pandas as pd
df = pd.read_csv('teilnehmer_daten.csv')
print(df[df['gruppe']=='A']['wert'].mean())

In der Schulung nutzen wir Pandas als Basis für tabellarische Daten und üben deklarative Operationen Schritt für Schritt.

In der Data Science Schulung beginnen wir mit Überblick (df.head, df.info, df.describe), prüfen fehlende Werte und Ausreißer und erstellen erste Visualisierungen. Hypothesen werden iterativ formuliert und überprüft. Wir zeigen, wie gute Fragestellungen (»Was vermute ich?«) in Tests übersetzt werden, und wie man schnelle Exploration von späteren Modellannahmen trennt. Teilnehmende lernen typische Fallen kennen (z. B. implizite Filter, falsche Typen) und bauen eine saubere EDA-Checkliste auf.

Beispielcode aus der Data Science Schulung:

df.head()
df.info()
df.describe(numeric_only=True)

So erhalten Teilnehmende schnell ein Gefühl für Struktur, Datentypen und Größenordnungen – die Basis für alle nächsten Schritte.

Histogramme/Boxplots für Verteilungen, Balken/Spalten für Häufigkeiten, Scatterplots für Zusammenhänge. In der Schulung achten wir auf klare Achsen, sinnvolle Skalen und eine Aussage pro Chart. Wir üben, wie man eine Hypothese visual unterstützt (Konfidenz, Vergleichsgruppen) und wann Log-Skalen oder Facets Sinn ergeben. Außerdem thematisieren wir Storytelling: Titel/Untertitel beantworten die Frage »Was soll ich hier lernen?«.

Beispielcode aus der Data Science Schulung:

import matplotlib.pyplot as plt
plt.hist(df['alter'].dropna(), bins=20)
plt.title('Verteilung Alter')

Teilnehmende lernen, wie Binning und Ausreißererkennung die Interpretation verbessern.

Um Generalisierungsleistung realistisch zu messen und Leakage zu vermeiden. In der Schulung betonen wir: Der Testsatz beeinflusst keine Trainingsentscheidungen. Wir vergleichen unterschiedliche Split-Strategien (random, stratifiziert, zeitbasiert) und zeigen, wie sich falsche Splits auf Metriken und Business-Entscheidungen auswirken. Best Practice: Splits früh festlegen und für alle weiteren Schritte konsistent nutzen.

Beispielcode aus der Data Science Schulung:

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

Fixierte Seeds (random_state) machen Ergebnisse reproduzierbar – wichtig für Übungen und Reviews.

Pipelines bündeln Vorverarbeitung und Modell, verhindern Leakage und ermöglichen konsistentes Tuning via Grid/Randomized Search. In der Data Science Schulung lernen Teilnehmende, alle datenlernenden Schritte (Skalierung, Encoding, Selektion) in die Pipeline zu legen. So bleibt der Prozess wiederholbar, sauber testbar und deploy-fähig. Wir demonstrieren Pipeline-Pfadbenennung (z. B. 'clf__C') und getrennte Numerik/Kategorik-Preprocessing-Zweige.

Beispielcode aus der Data Science Schulung:

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression

pipe = Pipeline([
  ('scaler', StandardScaler()),
  ('clf', LogisticRegression(max_iter=1000))
])

Die Schulung zeigt, wie alle Schritte korrekt und wiederholbar auf Train/Test angewendet werden.

Accuracy, Precision, Recall, F1-Score und ROC-AUC. Bei unausgewogenen Klassen sind Precision/Recall oft aussagekräftiger als Accuracy – das üben wir explizit. Wir besprechen Schwellenwahl, PR-Kurven und Kosten-/Nutzen-Überlegungen pro Fehlerart. Ziel der Data Science Schulung ist es, Metriken mit Fachzielen zu verknüpfen und nicht isoliert zu optimieren.

Beispielcode aus der Data Science Schulung:

from sklearn.metrics import classification_report
print(classification_report(y_test, y_pred))

Der Report liefert pro Klasse Precision/Recall/F1 plus macro/weighted Mittelwerte – ideal für Vergleiche im Kurs.

MAE (robuster gegen Ausreißer), RMSE (straft große Fehler), R² (erklärte Varianz). Interpretation erfolgt immer im fachlichen Kontext der Schulungsfälle. Wir zeigen, wie Residuenplots systematische Fehler sichtbar machen und wie sich Metriken bei Segmenten (z. B. Kundengruppen) unterscheiden können. So lernen Teilnehmende, Ergebnisse sauber zu kommunizieren.

Beispielcode aus der Data Science Schulung:

from sklearn.metrics import mean_absolute_error, r2_score
mae = mean_absolute_error(y_test, y_pred)
r2  = r2_score(y_test, y_pred)

Kombinierte Metriken liefern ein runderes Bild – besonders bei heteroskedastischen Daten.

Strategien: Löschen, einfache Imputation (Median/Mode) und modellbasierte Imputation. Wir dokumentieren Annahmen und testen die Sensitivität der Ergebnisse. In der Data Science Schulung vergleichen wir die Auswirkung verschiedener Strategien auf Metriken und Fairness und verankern Imputation konsequent in Pipelines. Wichtig: Imputer nie auf Gesamtdaten fitten (Leakage).

Beispielcode aus der Data Science Schulung:

from sklearn.impute import SimpleImputer
imp = SimpleImputer(strategy='median')

Imputation gehört in die Pipeline – so vermeiden wir Leakage in Übungen und Projekten.

Für SVM, kNN und lineare Modelle sind skalenbewusste Features entscheidend. Wir nutzen StandardScaler/MinMaxScaler konsequent in Pipelines. Im Kurs behandeln wir Ausreißer-Robustheit (RobustScaler) und zeigen, wie falsche Skalierung zu instabilen Koeffizienten oder schlechter Konvergenz führt. Regel: fit() nur auf Trainingsdaten.

Beispielcode aus der Data Science Schulung:

from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()

Im Kurs: Auf Trainingsdaten fitten, auf Testdaten nur transformieren – nie umgekehrt.

One-Hot für nominale Merkmale, OrdinalEncoder für echte Rangfolgen. High-Cardinality behandeln wir vorsichtig (z. B. Target Encoding mit strikter CV). Wir sprechen außerdem über seltende Kategorien, Domänenwissen für sinnvolle Gruppierungen und Speicher-/Laufzeit-Aspekte im Deployment.

Beispielcode aus der Data Science Schulung:

from sklearn.preprocessing import OneHotEncoder
ohe = OneHotEncoder(handle_unknown='ignore', sparse_output=False)

handle_unknown='ignore' verhindert Fehler mit neuen Kategorien im Test/Deploy – das demonstrieren wir im Kurs.

Baselines (Mittelwert/Mehrheitsklasse) setzen eine Untergrenze. Nur wer die Baseline schlägt, liefert echten Mehrwert – das macht Überoptimierung sichtbar. Wir nutzen Baselines auch, um Datenlecks zu entlarven (»zu gute« Scores) und um Stakeholdern Transparenz über den inkrementellen Nutzen komplexerer Modelle zu geben.

Beispielcode aus der Data Science Schulung:

from sklearn.dummy import DummyClassifier
dummy = DummyClassifier(strategy='most_frequent')

Schneller Reality-Check zu Beginn jeder Übung – bevor komplexe Modelle eingesetzt werden.

CV stabilisiert die Schätzung der Generalisierung. Wir nutzen (Stratified)KFold; bei Zeitreihen TimeSeriesSplit – alles integriert in Pipelines. In der Data Science Schulung diskutieren wir Varianz/Bias der Schätzung, geeignete Fold-Zahlen und wie man CV mit Hyperparameter-Suche sauber kombiniert. Außerdem: wie man Leckagen innerhalb der CV-Schleife vermeidet.

Beispielcode aus der Data Science Schulung:

from sklearn.model_selection import cross_val_score
scores = cross_val_score(pipe, X, y, cv=5)

Mehrere Folds glätten Zufallseffekte einzelner Splits – ein Kernprinzip in den Übungen.

Für kleine Suchräume verwenden wir GridSearchCV, für größere RandomizedSearchCV – immer zusammen mit Pipeline und CV, um Leakage zu verhindern. Wir behandeln sinnvolle Suchräume (Log-Skalen!), frühe Abbrüche und reproduzierbare Konfigurationen. Ziel der Data Science Schulung ist ein robustes Setup, das auch bei neuen Daten stabil bleibt.

Beispielcode aus der Data Science Schulung:

from sklearn.model_selection import RandomizedSearchCV
param_dist = {'clf__C':[0.1,1,10], 'clf__penalty':['l2']}
search = RandomizedSearchCV(pipe, param_distributions=param_dist, n_iter=5, cv=5)

Wir verweisen in der Schulung auf Pipeline-Pfade (z. B. 'clf__C'), damit Tuning korrekt greift.

Wir üben class_weight, geeignete Schwellen, stratifizierte Splits und passende Metriken (ROC-AUC, PR-AUC). Oversampling (z. B. SMOTE) nur mit sauberer CV. Im Kurs vergleichen wir Maßnahmen anhand PR-Kurve und Kostenmatrix, damit die Wahl daten- und zielgetrieben erfolgt.

Beispielcode aus der Data Science Schulung:

from sklearn.linear_model import LogisticRegression
clf = LogisticRegression(class_weight='balanced', max_iter=1000)

Gewichtete Verluste sind oft praktikabler und stabiler als reines Oversampling – das vergleichen wir im Kurs.

Zur Reduktion von Overfitting und Kosten. Wir zeigen modellbasierte Auswahl (Regularisierung) und Wrapper-Methoden – immer in Pipelines. Teilnehmende lernen, Stabilität der Auswahl per CV zu prüfen und fachliche Interpretierbarkeit im Auge zu behalten.

Beispielcode aus der Data Science Schulung:

from sklearn.feature_selection import SelectFromModel
from sklearn.linear_model import Lasso
sel = SelectFromModel(Lasso(alpha=0.01))

So findet die Auswahl im CV-Loop statt und bleibt realistisch.

Zur Kompression und Visualisierung hochdimensionaler Daten. Wir diskutieren den Trade-off: Varianzabdeckung vs. Interpretierbarkeit. In der Data Science Schulung zeigen wir, wann PCA Performance bringt (Rauschen ↓) und wann domänenspezifische Features die bessere Wahl sind.

Beispielcode aus der Data Science Schulung:

from sklearn.decomposition import PCA
pca = PCA(n_components=2)

Vorher skalieren; Varianzanteile pro Komponente interpretieren – das wird im Kurs geübt.

Als robuste Defaults für tabellarische Daten mit wenig Feature-Engineering. Wir achten auf frühe Stop-Kriterien und interpretieren Feature Importance kritisch. Im Kurs vergleichen wir Out-of-Bag-Schätzung, Lernkurven und den Einfluss von Hyperparametern auf Bias/Varianz und Laufzeit.

Beispielcode aus der Data Science Schulung:

from sklearn.ensemble import RandomForestClassifier
rf = RandomForestClassifier(n_estimators=200, random_state=42)

Gute Baseline für viele Klassifikationsaufgaben; Hyperparameter steuern Bias/Varianz – das testen wir gemeinsam.

Für kleine bis mittlere, gut skalierte Datensätze. Kernel-Tricks erlauben nichtlineare Trennungen; C und gamma sind dabei zentral. Wir üben Grid/Random-Search im Log-Raum und zeigen, wie Feature-Skalierung und Schwellenwahl die Praxis-Performance beeinflussen.

Beispielcode aus der Data Science Schulung:

from sklearn.svm import SVC
svm = SVC(kernel='rbf', probability=True)

Skalierung ist Pflicht; Tuning via CV wird im Kurs an Beispieldatensätzen geübt.

k-Means für kompakte Kugelcluster, DBSCAN für beliebige Formen und Rauschtoleranz. Evaluation mit Silhouetten-Score und fachlichem Feedback. Wir zeigen, wie Feature-Wahl und Skalierung Cluster formen, und wie man Cluster sinnvoll benennt und validiert (Stichproben, Profile).

Beispielcode aus der Data Science Schulung:

from sklearn.cluster import KMeans
km = KMeans(n_clusters=4, n_init='auto', random_state=42)

Wir zeigen, wie Skalierung und Feature-Wahl das Ergebnis beeinflussen und dokumentiert werden muss.

Zeitliche Ordnung respektieren (kein Shuffle), lag/rolling-Features, TimeSeriesSplit. Look-ahead-Bias vermeiden wir konsequent in allen Schritten. In der Data Science Schulung vergleichen wir Sliding-Window-Validierung, Horizon-Metriken und saisonale Effekte, damit Prognosen realitätsnah bleiben.

Beispielcode aus der Data Science Schulung:

from sklearn.model_selection import TimeSeriesSplit
tscv = TimeSeriesSplit(n_splits=5)

Train liegt immer vor Test in der Zeit – wir simulieren reale Vorhersagesituationen.

Wir speichern ganze Pipelines mit joblib/pickle. Dazu versionieren wir Datenvorbereitung und Pakete für reproduzierbare Ergebnisse. Im Kurs behandeln wir außerdem Eingabevalidierung, einfache Inferenz-Skripte und das Nachziehen von Preprocessing im Deployment.

Beispielcode aus der Data Science Schulung:

import joblib
joblib.dump(pipe, 'model.joblib')
pipe = joblib.load('model.joblib')

Zusätzlich üben wir Input-Validierung im Deployment – kein blinder Trust in externe Daten.

Globale Methoden (Feature Importance, Permutation) und lokale Ansätze (z. B. SHAP) ergänzen sich. Wir achten auf Korrelationen und Verzerrungen in den Daten. Ziel der Data Science Schulung: verständliche, prüfbare Aussagen für Stakeholder – ohne Scheingenauigkeit oder Overclaiming.

Beispielcode aus der Data Science Schulung:

from sklearn.inspection import permutation_importance
r = permutation_importance(pipe, X_test, y_test, n_repeats=10, random_state=42)

Permutation misst Importanz über Performance-Drop – modellagnostisch und gut demonstrierbar im Kurs.

Vorverarbeitung vor dem Split, Zielvariable in Features, zeitliche Vermischung – all das vermeiden wir. Regel: Alles Gelernte gehört in die Pipeline und in den CV-Loop. Wir üben typische Fehlschritte bewusst, um ihren Effekt auf Metriken sichtbar zu machen, und etablieren Checklisten für Reviews.

Beispielcode aus der Data Science Schulung:

# Korrekt: Erst splitten, dann fit() nur auf Train; transform() getrennt für Train/Test in der Pipeline

So bleiben Validierungsergebnisse ehrlich und übertragbar – das zeigen wir an Fehlerszenarien.

Seeds setzen, Versionen pinnen (requirements.txt/pyproject), Artefakte versionieren (Modelle, Datenschnitte) und Notebooks in testbare Module überführen. Wir thematisieren außerdem Umgebungs-Snapshots (z. B. Lockfiles) und klare Ergebnis-Protokolle, damit Teams später nahtlos anschließen können.

Beispielcode aus der Data Science Schulung:

pip freeze > requirements.txt
# im Code: random_state=42 / np.random.seed(42)

Klare Versionierung + Seeds ermöglichen nachvollziehbare Ergebnisse über Zeit und Teams.

Automatisierte Trainingsläufe, Modell- & Datenversionierung, Validierung vor Deployment und Monitoring im Betrieb. Wir zeigen den Weg vom Notebook zum Service. Im Kurs priorisieren wir kleine, robuste Bausteine (Pipelines, Checks, einfache Deploy-Pfade), um schnell Nutzen zu liefern – statt früh komplexe Plattformen aufzubauen.

Beispielcode aus der Data Science Schulung:

# Praxisleitfaden im Kurs: Artefakte speichern (joblib), Inferenz-Skript, Healthcheck-Endpoint, einfache Drift-Checks

Wir starten bewusst klein und robust – statt mit überkomplexen Plattformen.

Skalierung/Encoding, Interaktionen, Binning, Log-Transforms und zielgruppenspezifische Ableitungen – immer in Pipelines und validiert per Cross-Validation. Wir arbeiten an Fallbeispielen, um messbare Verbesserungen gegen Baselines nachzuweisen und dokumentieren Annahmen transparent für spätere Reviews.

Beispielcode aus der Data Science Schulung:

import numpy as np
df['umsatz_log'] = np.log1p(df['umsatz'].clip(lower=0))

Log-Transform stabilisiert schiefe Verteilungen; clip vermeidet negative Werte – beides typische Kursübungen.

Mit Rolling-Origin/Expanding Windows (TimeSeriesSplit). Features werden nur aus der Vergangenheit gebildet; Leaks werden aktiv verhindert. Wir zeigen, wie sich Fensterbreiten und Vorhersagehorizonte auf Bias/Varianz auswirken und wie man Ergebnisse stakeholder-tauglich zusammenfasst.

Beispielcode aus der Data Science Schulung:

from sklearn.model_selection import TimeSeriesSplit
for tr, te in TimeSeriesSplit(4).split(X):
    pass

Jeder Fold simuliert „Zukunft aus Vergangenheit“ – realitätsnäher als zufällige Splits.

Exploration ja, Produktivlogik nein: Wir versionieren, nummerieren Zellen, frieren Zufall, und exportieren wiederverwendbaren Code in Module samt Tests. Außerdem besprechen wir Review-fähige Notebooks (klarer Ablauf, wenige, sprechende Plots) und Übergaben in Pipelines/Jobs für die nächsten Projektphasen.

Beispielcode aus der Data Science Schulung:

# %run src/features.py   # Wiederverwendbare Kursfunktionen aus Modulen einbinden

Die Trennung von Experiment (Notebook) und Bibliothek (Modul) steigert Qualität und Wiederverwendbarkeit – das üben wir praktisch.