Was ist Machine Learning? Grundlagen & Ihr erstes Modell mit Python

Machine Learning (ML) ist ein Teilgebiet der künstlichen Intelligenz, das es Computern ermöglicht, aus Daten zu lernen, ohne explizit programmiert zu werden. Von Empfehlungssystemen über autonome Fahrzeuge bis hin zur medizinischen Diagnostik — ML verändert zahlreiche Branchen grundlegend. In diesem Leitfaden behandeln wir die Grundkonzepte, Lernparadigmen und praktische Python-Implementierungen.

Was ist Machine Learning?

In der traditionellen Softwareentwicklung werden Regeln manuell definiert. Beim Machine Learning entdecken Algorithmen Muster in Daten und leiten eigene Regeln ab. Mit ausreichend Daten und dem richtigen Algorithmus kann ein System auch bei zuvor ungesehenen Beispielen korrekte Vorhersagen treffen.

Standard-Workflow

1. Datensammlung: Rohdaten aus verschiedenen Quellen beschaffen
2. Datenvorverarbeitung: Fehlende Werte behandeln, Normalisierung, Feature Engineering
3. Modellauswahl: Den passenden Algorithmus für das Problem wählen
4. Training: Das Modell aus Trainingsdaten lernen lassen
5. Evaluation: Leistung an ungesehenen Testdaten messen
6. Deployment: Das Modell in die Produktion bringen

Lerntypen

Überwachtes Lernen (Supervised Learning)

Arbeitet mit gelabelten Daten. Das Modell lernt aus Eingabe-Ausgabe-Paaren.

• Klassifikation: Spam-Erkennung, Krankheitsdiagnose
• Regression: Immobilienpreisvorhersage, Temperaturprognose

Unüberwachtes Lernen (Unsupervised Learning)

Arbeitet mit ungelabelten Daten und entdeckt verborgene Strukturen.

• Clustering: Kundensegmentierung, Dokumentengruppierung
• Dimensionsreduktion: Hochdimensionale Daten mit PCA visualisieren

Bestärkendes Lernen (Reinforcement Learning)

Ein Agent lernt durch Interaktion mit seiner Umgebung mittels Belohnungs- und Bestrafungsmechanismen. Anwendung in Spielen, Robotersteuerung und Ressourcenoptimierung.

ML-Grundlagen mit Python

Datenaufbereitung mit NumPy

import numpy as np

# Feature-Matrix erstellen (4 Beispiele, 3 Merkmale)
X = np.array([
    [5.1, 3.5, 1.4],
    [4.9, 3.0, 1.4],
    [7.0, 3.2, 4.7],
    [6.4, 3.2, 4.5]
])

# Label-Vektor (0: Setosa, 1: Versicolor)
y = np.array([0, 0, 1, 1])

# Grundlegende Statistiken
print(f"Mittelwert: {X.mean(axis=0)}")
print(f"Standardabweichung: {X.std(axis=0)}")
print(f"Datenform: {X.shape}")

Klassifikation mit Scikit-learn

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, classification_report

# Datensatz laden
iris = load_iris()
X, y = iris.data, iris.target

# Aufteilung in Trainings- und Testdaten (80/20)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# Random-Forest-Klassifikator erstellen und trainieren
model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X_train, y_train)

# Vorhersagen auf Testdaten
vorhersagen = model.predict(X_test)

# Genauigkeit berechnen
genauigkeit = accuracy_score(y_test, vorhersagen)
print(f"Modell-Genauigkeit: {genauigkeit:.2%}")
print(classification_report(y_test, vorhersagen, target_names=iris.target_names))

Vorverarbeitungs-Pipeline

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn.svm import SVC

# Pipeline: Skalierung -> PCA -> SVM
pipeline = Pipeline([
    ('skalierung', StandardScaler()),
    ('dim_reduktion', PCA(n_components=2)),
    ('klassifikator', SVC(kernel='rbf'))
])

pipeline.fit(X_train, y_train)
score = pipeline.score(X_test, y_test)
print(f"Pipeline-Genauigkeit: {score:.2%}")

Feature Engineering

Feature Engineering ist der Prozess, aus Rohdaten neue Variablen zu erzeugen, die dem Modell ein besseres Lernen ermöglichen. Gut konstruierte Features können die Modellleistung unabhängig vom gewählten Algorithmus erheblich verbessern. In der Praxis verbringen Datenwissenschaftler einen Großteil ihrer Zeit mit diesem Schritt.

from sklearn.preprocessing import PolynomialFeatures
from sklearn.compose import ColumnTransformer

# Polynomiale Feature-Erweiterung
vorverarbeitung = ColumnTransformer(
    transformers=[
        ('numerisch', Pipeline([
            ('skalierung', StandardScaler()),
            ('polinom', PolynomialFeatures(degree=2, include_bias=False))
        ]), [0, 1, 2, 3]),
    ],
    remainder='passthrough'
)

volle_pipeline = Pipeline([
    ('vorverarbeitung', vorverarbeitung),
    ('klassifikator', RandomForestClassifier(n_estimators=100, random_state=42))
])

volle_pipeline.fit(X_train, y_train)
print(f"Genauigkeit nach Feature Engineering: {volle_pipeline.score(X_test, y_test):.2%}")

Kreuzvalidierung (Cross-Validation)

Eine einzelne Train/Test-Aufteilung kann je nach Datenpartitionierung irreführende Ergebnisse liefern. Die Kreuzvalidierung löst dieses Problem, indem die Daten in k Teile aufgeteilt werden und jeder Teil abwechselnd als Testset dient.

from sklearn.model_selection import cross_val_score, StratifiedKFold

# 5-fache stratifizierte Kreuzvalidierung
cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)

rf_scores = cross_val_score(
    RandomForestClassifier(n_estimators=100, random_state=42),
    X, y, cv=cv, scoring='accuracy'
)

print(f"Kreuzvalidierungs-Scores: {rf_scores}")
print(f"Durchschnittliche Genauigkeit: {rf_scores.mean():.2%} (+/- {rf_scores.std():.2%})")

Overfitting vs. Underfitting

Overfitting tritt auf, wenn das Modell die Trainingsdaten auswendig lernt. Die Trainingsgenauigkeit ist sehr hoch, die Testgenauigkeit jedoch niedrig. Lösungen umfassen Regularisierung (L1/L2), Dropout, mehr Daten oder eine Vereinfachung des Modells.

Underfitting tritt auf, wenn das Modell sowohl auf Trainings- als auch auf Testdaten schlecht abschneidet. Dies deutet darauf hin, dass das Modell nicht komplex genug ist. Lösungen: komplexeres Modell verwenden, mehr Features hinzufügen oder die Trainingszeit verlängern.

Hyperparameter-Optimierung mit GridSearchCV

from sklearn.model_selection import GridSearchCV

param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [3, 5, 10, None],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4]
}

grid_suche = GridSearchCV(
    RandomForestClassifier(random_state=42),
    param_grid,
    cv=5,
    scoring='accuracy',
    n_jobs=-1,
    verbose=1
)

grid_suche.fit(X_train, y_train)

print(f"Beste Parameter: {grid_suche.best_params_}")
print(f"Bester CV-Score: {grid_suche.best_score_:.2%}")
print(f"Testset-Genauigkeit: {grid_suche.score(X_test, y_test):.2%}")

Für große Parameterräume kann RandomizedSearchCV oder Bayesian-Optimierung (Optuna, Hyperopt) effizienter sein.

Häufige Fehler

1. Overfitting: Das Modell lernt Trainingsdaten auswendig. Lösung: Cross-Validation, Regularisierung
2. Datenleckage: Testdaten fließen in den Trainingsprozess ein
3. Fehlende Feature-Skalierung: Distanzbasierte Algorithmen benötigen skalierte Daten
4. Unbalancierte Datensätze: Ungleiche Klassenverteilung verfälscht die Genauigkeit

Zusammenfassung

Machine Learning ist eines der mächtigsten Werkzeuge der künstlichen Intelligenz. Mit überwachtem, unüberwachtem und bestärkendem Lernen lassen sich unterschiedlichste Problemtypen lösen. Das Python-Ökosystem mit NumPy, Scikit-learn und Pandas ermöglicht schnelles Prototyping und produktionsreife Lösungen. Durch Feature Engineering, Kreuzvalidierung und systematische Hyperparameter-Optimierung mit GridSearchCV können robuste ML-Projekte entwickelt werden. Die Balance zwischen Overfitting und Underfitting zu meistern, ist die grundlegende Fähigkeit jedes Machine-Learning-Ingenieurs.