Grundlagen Machine Learning

Was ist Machine Learning?

Machine Learning (ML) ist ein Teilbereich der Künstlichen Intelligenz, bei dem Computer aus Daten lernen, anstatt explizit programmiert zu werden. Statt Regeln vorzugeben (“wenn Temperatur > 30°C, dann heiß”), zeigst du dem System Beispiele und es lernt die Regeln selbst.

Die drei Lernarten

Der ML-Workflow

1. Problem definieren → Was soll vorhergesagt/erkannt werden?
2. Daten sammeln    → Woher kommen die Trainingsdaten?
3. Daten aufbereiten → Bereinigen, Transformieren, Splitten
4. Modell wählen    → Welcher Algorithmus passt?
5. Training         → Modell auf Trainingsdaten trainieren
6. Evaluation       → Performance auf Testdaten messen
7. Optimierung      → Hyperparameter tunen, Fehler analysieren
8. Deployment       → Modell in Produktion bringen
9. Monitoring       → Performance überwachen, Drift erkennen

Wichtige Konzepte

Overfitting, Underfitting und der Bias-Variance Trade-off

Das häufigste Problem in der ML-Praxis ist Overfitting: Das Modell lernt die Trainingsdaten so gut, dass es auch deren Rauschen und Ausreißer auswendig lernt – und auf neuen Daten versagt.

Trainingsdaten-Accuracy: 99%
Testdaten-Accuracy:      67%
→ Klassisches Overfitting

Das Gegenteil ist Underfitting: Das Modell ist zu einfach, um die echten Muster zu erfassen.

Trainingsdaten-Accuracy: 71%
Testdaten-Accuracy:      69%
→ Underfitting – Modell zu simpel oder zu wenig Training

Dahinter steckt der Bias-Variance Trade-off:

	Bias (hoch)	Variance (hoch)
Bedeutung	Modell zu simpel, lernt Muster nicht	Modell zu komplex, lernt Rauschen
Symptom	Underfitting	Overfitting
Lösung	Komplexeres Modell, mehr Features	Regularisierung, mehr Daten, Dropout

Gegenmaßnahmen bei Overfitting:

• Mehr Trainingsdaten beschaffen
• Regularisierung (L1/L2) – bestraft zu große Gewichte
• Dropout (bei neuronalen Netzen) – deaktiviert zufällig Neuronen
• Einfacheres Modell wählen
• Early Stopping – Training abbrechen bevor Validierungsfehler steigt

Welcher Algorithmus für welches Problem?

Die Wahl des Algorithmus hängt von Datenmenge, Interpretierbarkeit und Aufgabentyp ab:

Algorithmus	Stärken	Wann nutzen?
Logistic Regression	Schnell, interpretierbar, stabil	Binäre Klassifikation, Baseline, wenig Daten
Random Forest	Robust, kein Scaling nötig, Feature Importance	Tabellarische Daten, gemischte Features
Gradient Boosting (XGBoost)	Sehr hohe Accuracy auf Tabellendaten	Kaggle-Wettbewerbe, strukturierte Daten
SVM	Gut bei hochdimensionalen Daten	Text-Klassifikation, kleine Datensätze
K-Means	Einfach, skalierbar	Clustering ohne Labels
Neuronales Netz	Universell, sehr mächtig	Bilder, Text, Audio, große Datensätze

Faustregel: Starte immer mit Logistic Regression oder Random Forest als Baseline. Komplexere Modelle nur dann, wenn die Baseline nicht ausreicht.

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score

X, y = load_iris(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Baseline: Logistic Regression
lr = LogisticRegression(max_iter=200)
lr.fit(X_train, y_train)
print(f"Logistic Regression: {accuracy_score(y_test, lr.predict(X_test)):.2%}")

# Komplexer: Random Forest
rf = RandomForestClassifier(n_estimators=100, random_state=42)
rf.fit(X_train, y_train)
print(f"Random Forest:       {accuracy_score(y_test, rf.predict(X_test)):.2%}")

# Feature Importance zeigen
import pandas as pd
feature_names = load_iris().feature_names
importance = pd.Series(rf.feature_importances_, index=feature_names).sort_values(ascending=False)
print(importance)

Loss Function und Gradient Descent

Die Loss Function misst, wie weit die Vorhersage vom tatsächlichen Wert entfernt ist. Gradient Descent minimiert diesen Fehler schrittweise – wie ein Ball, der ins Tal rollt.

Iteration 1: Loss = 2.45  ← weit vom Minimum
Iteration 10: Loss = 0.83
Iteration 50: Loss = 0.21
Iteration 100: Loss = 0.09 ← nahe am Minimum

Die Learning Rate bestimmt die Schrittgröße: Zu groß → überspringt das Minimum. Zu klein → Training dauert ewig.

Train/Validation/Test Split

Daten werden aufgeteilt:

• Training (70-80%): Zum Lernen
• Validation (10-15%): Zum Tunen der Hyperparameter
• Test (10-15%): Zur finalen Evaluation – nur einmal verwenden!

Wer den Test-Split mehrfach nutzt, um sein Modell zu verbessern, lügt sich an: Das Modell ist dann auf den Testdaten optimiert, nicht auf echten ungesehenen Daten.

Von ML zu Deep Learning

Deep Learning nutzt neuronale Netze mit vielen Schichten (daher “deep”). Der entscheidende Unterschied zu klassischem ML: Deep Learning lernt Features automatisch aus Rohdaten – du musst keine Features manuell engineeren.

Klassisches ML:   Rohdaten → [Feature Engineering] → Algorithmus → Vorhersage
Deep Learning:    Rohdaten → [Neuronales Netz lernt Features selbst] → Vorhersage

Wann Deep Learning, wann klassisches ML?

Kriterium	Klassisches ML	Deep Learning
Datenmenge	Hunderte bis Tausende	Zehntausende bis Millionen
Hardware	CPU reicht	GPU fast immer nötig
Interpretierbarkeit	Hoch (Random Forest, LR)	Niedrig (“Black Box”)
Feature Engineering	Manuell nötig	Automatisch
Trainingszeit	Sekunden bis Minuten	Stunden bis Tage
Tabellarische Daten	✅ Random Forest/XGBoost besser	❌ Selten Vorteil
Bilder, Text, Audio	❌ Schwach	✅ State of the Art

Architektur-Überblick

• CNNs (Convolutional Neural Networks) – Bilderkennung, Objekterkennung
• RNNs / LSTMs – Sequenzdaten, Zeitreihen (weitgehend durch Transformer abgelöst)
• Transformer – Text, Code, Bilder, Audio – die Basis aller modernen LLMs
• GANs – Generierung realistischer Bilder (Stable Diffusion nutzt Diffusionsmodelle)
• Diffusionsmodelle – Bildgenerierung (DALL-E, Midjourney, Stable Diffusion)

Der Durchbruch kam durch drei Faktoren: Mehr Daten (Internet-Scale), mehr Rechenleistung (GPUs/TPUs) und bessere Architekturen (Transformer, 2017). LLMs wie GPT-5 sind im Kern Transformer, die auf Billionen von Tokens trainiert wurden.

Häufige Fehler und wie du sie vermeidest

Problem: „Mein Modell hat 99% Accuracy – aber funktioniert in der Praxis schlecht”

Ursache: Overfitting oder Data Leakage – Testdaten haben das Training beeinflusst, oder das Modell hat Trainingsdaten auswendig gelernt. Lösung: Strikten Train/Validation/Test Split einhalten. Testdaten nur einmal verwenden. Accuracy auf Trainings- vs. Testdaten vergleichen – große Lücke = Overfitting.

Problem: „Ich weiß nicht welchen Algorithmus ich nehmen soll”

Ursache: Kein systematischer Auswahlprozess. Lösung: Immer mit einer einfachen Baseline starten (Logistic Regression oder Random Forest). Nur zu komplexeren Modellen wechseln wenn die Baseline nachweislich nicht ausreicht. Komplexität ist kein Qualitätsmerkmal.

Problem: „Das Modell trainiert, aber der Loss sinkt nicht”

Ursache: Learning Rate zu hoch oder zu niedrig, falsche Loss Function, oder Daten nicht normalisiert. Lösung: Learning Rate um Faktor 10 reduzieren. Features skalieren (StandardScaler oder MinMaxScaler). Loss Function zum Problem passend wählen (MSE für Regression, CrossEntropy für Klassifikation).

Problem: „Mein Modell funktioniert auf neuen Daten nicht mehr”

Ursache: Data Drift – die Verteilung der Produktionsdaten hat sich gegenüber den Trainingsdaten verändert. Lösung: Monitoring einrichten das Eingabe-Verteilungen überwacht. Modell regelmäßig mit neuen Daten neu trainieren. Feature-Verteilungen in Produktion vs. Training vergleichen.