Machine Learning mit Python: Scikit-learn für Einsteiger

Einführung in Machine Learning

Machine Learning (ML) ist eine der faszinierendsten Anwendungen der Informatik, die es Computern ermöglicht, aus Daten zu lernen und Vorhersagen zu treffen. Python mit der Scikit-learn-Bibliothek macht es einfacher denn je, in die Welt des maschinellen Lernens einzusteigen.

Was ist Machine Learning?

Machine Learning ist ein Teilbereich der Künstlichen Intelligenz, bei dem Algorithmen Muster in Daten erkennen und diese nutzen, um Vorhersagen über neue, unbekannte Daten zu treffen. Statt explizit programmiert zu werden, "lernen" diese Algorithmen aus Beispielen.

1. Scikit-learn Installation und Grundlagen

# Installation der benötigten Bibliotheken
# pip install scikit-learn pandas numpy matplotlib seaborn

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import accuracy_score, classification_report, confusion_matrix

# Scikit-learn Version prüfen
import sklearn
print(f"Scikit-learn Version: {sklearn.__version__}")

# Matplotlib für deutsche Darstellung konfigurieren
plt.rcParams['figure.figsize'] = (10, 6)
plt.rcParams['font.size'] = 12
sns.set_style("whitegrid")

2. Arten des Machine Learning

Es gibt drei Hauptkategorien des maschinellen Lernens:

🧠 ML-Kategorien:

Supervised Learning (Überwachtes Lernen): Lernen mit bekannten Eingabe-Ausgabe-Paaren
Unsupervised Learning (Unüberwachtes Lernen): Muster in Daten ohne bekannte Ausgaben finden
Reinforcement Learning (Verstärkungslernen): Lernen durch Belohnung und Bestrafung

3. Supervised Learning: Klassifikation

Beginnen wir mit einem klassischen Klassifikationsproblem - der Vorhersage von Kursanmeldungen basierend auf Teilnehmerdaten.

Daten vorbereiten:

# Simulierte Kursdaten erstellen
np.random.seed(42)

# Teilnehmerdaten generieren
n_samples = 1000

teilnehmer_daten = pd.DataFrame({
    'alter': np.random.normal(30, 8, n_samples),
    'programmiererfahrung_jahre': np.random.exponential(2, n_samples),
    'wochenstunden_verfügbar': np.random.normal(10, 4, n_samples),
    'vorherige_kurse': np.random.poisson(1, n_samples),
    'gehalt': np.random.normal(50000, 15000, n_samples),
    'hat_studium': np.random.choice([0, 1], n_samples, p=[0.3, 0.7])
})

# Negative Werte korrigieren
teilnehmer_daten['alter'] = np.clip(teilnehmer_daten['alter'], 18, 65)
teilnehmer_daten['programmiererfahrung_jahre'] = np.clip(teilnehmer_daten['programmiererfahrung_jahre'], 0, 20)
teilnehmer_daten['wochenstunden_verfügbar'] = np.clip(teilnehmer_daten['wochenstunden_verfügbar'], 2, 20)
teilnehmer_daten['gehalt'] = np.clip(teilnehmer_daten['gehalt'], 20000, 100000)

# Zielvariable erstellen: Wird sich für Fortgeschrittenen-Kurs anmelden?
# Basierend auf komplexer Formel mit verschiedenen Faktoren
kurs_wahrscheinlichkeit = (
    0.02 * teilnehmer_daten['alter'] +
    0.15 * teilnehmer_daten['programmiererfahrung_jahre'] +
    0.05 * teilnehmer_daten['wochenstunden_verfügbar'] +
    0.1 * teilnehmer_daten['vorherige_kurse'] +
    0.00002 * teilnehmer_daten['gehalt'] +
    0.3 * teilnehmer_daten['hat_studium'] +
    np.random.normal(0, 0.5, n_samples)  # Zufälligkeit hinzufügen
)

# In Binäre Klassifikation umwandeln
teilnehmer_daten['meldet_sich_an'] = (kurs_wahrscheinlichkeit > np.median(kurs_wahrscheinlichkeit)).astype(int)

print("Teilnehmer-Daten Übersicht:")
print(teilnehmer_daten.head())
print(f"\nAnmeldungsrate: {teilnehmer_daten['meldet_sich_an'].mean():.2%}")
print(f"\nDatentypen:\n{teilnehmer_daten.dtypes}")
print(f"\nFehlende Werte:\n{teilnehmer_daten.isnull().sum()}")

Explorative Datenanalyse:

# Datenverteilung visualisieren
fig, axes = plt.subplots(2, 3, figsize=(18, 12))
fig.suptitle('Teilnehmer-Daten Analyse', fontsize=16)

# Alter-Verteilung
axes[0, 0].hist(teilnehmer_daten['alter'], bins=30, alpha=0.7, color='skyblue')
axes[0, 0].set_title('Altersverteilung')
axes[0, 0].set_xlabel('Alter')
axes[0, 0].set_ylabel('Häufigkeit')

# Programmiererfahrung
axes[0, 1].hist(teilnehmer_daten['programmiererfahrung_jahre'], bins=30, alpha=0.7, color='lightgreen')
axes[0, 1].set_title('Programmiererfahrung')
axes[0, 1].set_xlabel('Jahre')
axes[0, 1].set_ylabel('Häufigkeit')

# Verfügbare Stunden
axes[0, 2].hist(teilnehmer_daten['wochenstunden_verfügbar'], bins=30, alpha=0.7, color='coral')
axes[0, 2].set_title('Verfügbare Wochenstunden')
axes[0, 2].set_xlabel('Stunden/Woche')
axes[0, 2].set_ylabel('Häufigkeit')

# Anmeldungen nach Alter
alter_gruppen = pd.cut(teilnehmer_daten['alter'], bins=5, labels=['18-25', '26-33', '34-41', '42-49', '50+'])
anmeldung_nach_alter = teilnehmer_daten.groupby(alter_gruppen)['meldet_sich_an'].mean()
axes[1, 0].bar(anmeldung_nach_alter.index, anmeldung_nach_alter.values, color='purple', alpha=0.7)
axes[1, 0].set_title('Anmeldungsrate nach Altersgruppe')
axes[1, 0].set_ylabel('Anmeldungsrate')
axes[1, 0].tick_params(axis='x', rotation=45)

# Erfahrung vs Anmeldung
erfahrung_gruppen = pd.cut(teilnehmer_daten['programmiererfahrung_jahre'], bins=4, labels=['0-2', '3-5', '6-10', '11+'])
anmeldung_nach_erfahrung = teilnehmer_daten.groupby(erfahrung_gruppen)['meldet_sich_an'].mean()
axes[1, 1].bar(anmeldung_nach_erfahrung.index, anmeldung_nach_erfahrung.values, color='orange', alpha=0.7)
axes[1, 1].set_title('Anmeldungsrate nach Erfahrung')
axes[1, 1].set_ylabel('Anmeldungsrate')

# Korrelationsmatrix
korrelation = teilnehmer_daten.corr()
im = axes[1, 2].imshow(korrelation, cmap='coolwarm', aspect='auto')
axes[1, 2].set_title('Korrelationsmatrix')
axes[1, 2].set_xticks(range(len(korrelation.columns)))
axes[1, 2].set_yticks(range(len(korrelation.columns)))
axes[1, 2].set_xticklabels(korrelation.columns, rotation=45, ha='right')
axes[1, 2].set_yticklabels(korrelation.columns)

# Korrelationswerte anzeigen
for i in range(len(korrelation.columns)):
    for j in range(len(korrelation.columns)):
        axes[1, 2].text(j, i, f'{korrelation.iloc[i, j]:.2f}', 
                        ha='center', va='center', color='white' if abs(korrelation.iloc[i, j]) > 0.5 else 'black')

plt.tight_layout()
# plt.show()  # Auskommentiert für Demo
print("Explorative Datenanalyse Plots erstellt")

Daten aufteilen und vorverarbeiten:

# Features (X) und Target (y) separieren
X = teilnehmer_daten.drop('meldet_sich_an', axis=1)
y = teilnehmer_daten['meldet_sich_an']

print(f"Features Shape: {X.shape}")
print(f"Target Shape: {y.shape}")
print(f"Feature Namen: {X.columns.tolist()}")

# Train-Test Split
X_train, X_test, y_train, y_test = train_test_split(
    X, y, 
    test_size=0.2, 
    random_state=42, 
    stratify=y  # Gleiche Verteilung in Train/Test
)

print(f"\nTraining Set: {X_train.shape[0]} Samples")
print(f"Test Set: {X_test.shape[0]} Samples")
print(f"Anmeldungsrate Training: {y_train.mean():.2%}")
print(f"Anmeldungsrate Test: {y_test.mean():.2%}")

# Feature Scaling (Standardisierung)
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# Überprüfung der Skalierung
print(f"\nVor Skalierung - Alter Mittelwert: {X_train['alter'].mean():.2f}, Std: {X_train['alter'].std():.2f}")
print(f"Nach Skalierung - Alter Mittelwert: {X_train_scaled[:, 0].mean():.2f}, Std: {X_train_scaled[:, 0].std():.2f}")

# Feature Namen für scaled data behalten
feature_names = X.columns.tolist()
X_train_scaled_df = pd.DataFrame(X_train_scaled, columns=feature_names)
X_test_scaled_df = pd.DataFrame(X_test_scaled, columns=feature_names)

4. Klassifikationsmodelle trainieren

Lassen Sie uns verschiedene ML-Algorithmen vergleichen:

# Verschiedene Klassifikatoren importieren
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier
from sklearn.svm import SVC
from sklearn.neighbors import KNeighborsClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.tree import DecisionTreeClassifier

# Modelle definieren
modelle = {
    'Logistic Regression': LogisticRegression(random_state=42),
    'Random Forest': RandomForestClassifier(n_estimators=100, random_state=42),
    'Support Vector Machine': SVC(random_state=42, probability=True),
    'K-Nearest Neighbors': KNeighborsClassifier(n_neighbors=5),
    'Naive Bayes': GaussianNB(),
    'Decision Tree': DecisionTreeClassifier(random_state=42, max_depth=10)
}

# Modelle trainieren und evaluieren
modell_ergebnisse = {}

for name, model in modelle.items():
    print(f"\n=== {name} ===")
    
    # Modell trainieren
    model.fit(X_train_scaled, y_train)
    
    # Vorhersagen
    y_pred = model.predict(X_test_scaled)
    y_pred_proba = model.predict_proba(X_test_scaled)[:, 1] if hasattr(model, 'predict_proba') else None
    
    # Metriken berechnen
    accuracy = accuracy_score(y_test, y_pred)
    
    # Ergebnisse speichern
    modell_ergebnisse[name] = {
        'model': model,
        'accuracy': accuracy,
        'predictions': y_pred,
        'probabilities': y_pred_proba
    }
    
    print(f"Accuracy: {accuracy:.4f}")
    print(f"Classification Report:")
    print(classification_report(y_test, y_pred))

# Beste Modelle anzeigen
print("\n=== Modell-Vergleich ===")
for name, ergebnis in sorted(modell_ergebnisse.items(), key=lambda x: x[1]['accuracy'], reverse=True):
    print(f"{name:25}: {ergebnis['accuracy']:.4f}")
    
# Bestes Modell auswählen
bestes_modell_name = max(modell_ergebnisse.keys(), key=lambda x: modell_ergebnisse[x]['accuracy'])
bestes_modell = modell_ergebnisse[bestes_modell_name]['model']
print(f"\nBestes Modell: {bestes_modell_name}")

Detaillierte Modell-Analyse:

# Confusion Matrix für bestes Modell
beste_predictions = modell_ergebnisse[bestes_modell_name]['predictions']

plt.figure(figsize=(8, 6))
cm = confusion_matrix(y_test, beste_predictions)
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', 
           xticklabels=['Meldet sich nicht an', 'Meldet sich an'],
           yticklabels=['Meldet sich nicht an', 'Meldet sich an'])
plt.title(f'Confusion Matrix - {bestes_modell_name}')
plt.ylabel('Tatsächliche Werte')
plt.xlabel('Vorhergesagte Werte')
# plt.show()

# Feature Importance (wenn verfügbar)
if hasattr(bestes_modell, 'feature_importances_'):
    importances = bestes_modell.feature_importances_
    
    # Feature Importance Plot
    plt.figure(figsize=(10, 6))
    indices = np.argsort(importances)[::-1]
    
    plt.title(f'Feature Importance - {bestes_modell_name}')
    plt.bar(range(X.shape[1]), importances[indices])
    plt.xticks(range(X.shape[1]), [feature_names[i] for i in indices], rotation=45, ha='right')
    plt.ylabel('Importance')
    plt.tight_layout()
    # plt.show()
    
    print("\nFeature Importance Ranking:")
    for i, idx in enumerate(indices):
        print(f"{i+1}. {feature_names[idx]}: {importances[idx]:.4f}")

elif hasattr(bestes_modell, 'coef_'):
    # Für lineare Modelle: Koeffizienten anzeigen
    coef = bestes_modell.coef_[0]
    
    plt.figure(figsize=(10, 6))
    indices = np.argsort(np.abs(coef))[::-1]
    
    plt.title(f'Feature Coefficients - {bestes_modell_name}')
    colors = ['red' if c < 0 else 'blue' for c in coef[indices]]
    plt.bar(range(len(coef)), coef[indices], color=colors, alpha=0.7)
    plt.xticks(range(len(coef)), [feature_names[i] for i in indices], rotation=45, ha='right')
    plt.ylabel('Coefficient Value')
    plt.axhline(y=0, color='black', linestyle='-', alpha=0.3)
    plt.tight_layout()
    # plt.show()
    
    print("\nFeature Coefficients:")
    for i, idx in enumerate(indices):
        print(f"{feature_names[idx]}: {coef[idx]:.4f}")

5. Model Selection und Cross-Validation

# Cross-Validation für robuste Bewertung
from sklearn.model_selection import cross_val_score, GridSearchCV
from sklearn.metrics import make_scorer, f1_score

# 5-Fold Cross-Validation für alle Modelle
print("=== Cross-Validation Ergebnisse ===")
cv_results = {}

for name, model in modelle.items():
    cv_scores = cross_val_score(model, X_train_scaled, y_train, cv=5, scoring='accuracy')
    cv_results[name] = cv_scores
    
    print(f"{name:25}: {cv_scores.mean():.4f} (+/- {cv_scores.std() * 2:.4f})")

# Hyperparameter-Tuning für Random Forest
print("\n=== Hyperparameter Tuning (Random Forest) ===")

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

rf = RandomForestClassifier(random_state=42)
grid_search = GridSearchCV(
    rf, 
    param_grid, 
    cv=3,  # 3-fold CV für Geschwindigkeit
    scoring='accuracy',
    n_jobs=-1,  # Alle CPU-Kerne nutzen
    verbose=1
)

grid_search.fit(X_train_scaled, y_train)

print(f"Beste Parameter: {grid_search.best_params_}")
print(f"Beste CV Score: {grid_search.best_score_:.4f}")

# Optimiertes Modell auf Test-Set evaluieren
optimiertes_modell = grid_search.best_estimator_
y_pred_optimiert = optimiertes_modell.predict(X_test_scaled)
accuracy_optimiert = accuracy_score(y_test, y_pred_optimiert)

print(f"Test Accuracy (optimiert): {accuracy_optimiert:.4f}")
print(f"Verbesserung: {accuracy_optimiert - modell_ergebnisse['Random Forest']['accuracy']:.4f}")

6. Regression: Vorhersage kontinuierlicher Werte

Lassen Sie uns nun ein Regressionsproblem lösen - die Vorhersage der wahrscheinlichen Kursgebühr, die ein Teilnehmer zu zahlen bereit ist:

# Regression: Bereitschaft zur Zahlung vorhersagen
from sklearn.linear_model import LinearRegression
from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import mean_squared_error, r2_score, mean_absolute_error

# Target-Variable für Regression erstellen
# Zahlungsbereitschaft basierend auf Teilnehmermerkmalen
teilnehmer_daten['zahlungsbereitschaft'] = (
    100 +  # Basis
    5 * teilnehmer_daten['alter'] +
    30 * teilnehmer_daten['programmiererfahrung_jahre'] +
    10 * teilnehmer_daten['wochenstunden_verfügbar'] +
    50 * teilnehmer_daten['vorherige_kurse'] +
    0.003 * teilnehmer_daten['gehalt'] +
    100 * teilnehmer_daten['hat_studium'] +
    np.random.normal(0, 50, n_samples)  # Zufälligkeit
)

# Negative Werte vermeiden
teilnehmer_daten['zahlungsbereitschaft'] = np.clip(teilnehmer_daten['zahlungsbereitschaft'], 100, 1000)

print(f"Zahlungsbereitschaft Statistiken:")
print(teilnehmer_daten['zahlungsbereitschaft'].describe())

# Daten für Regression vorbereiten
X_reg = teilnehmer_daten.drop(['meldet_sich_an', 'zahlungsbereitschaft'], axis=1)
y_reg = teilnehmer_daten['zahlungsbereitschaft']

X_train_reg, X_test_reg, y_train_reg, y_test_reg = train_test_split(
    X_reg, y_reg, test_size=0.2, random_state=42
)

# Skalierung
X_train_reg_scaled = scaler.fit_transform(X_train_reg)
X_test_reg_scaled = scaler.transform(X_test_reg)

# Regressionsmodelle
regression_modelle = {
    'Linear Regression': LinearRegression(),
    'Random Forest Regression': RandomForestRegressor(n_estimators=100, random_state=42)
}

regression_ergebnisse = {}

for name, model in regression_modelle.items():
    print(f"\n=== {name} ===")
    
    # Modell trainieren
    model.fit(X_train_reg_scaled, y_train_reg)
    
    # Vorhersagen
    y_pred_reg = model.predict(X_test_reg_scaled)
    
    # Metriken
    mse = mean_squared_error(y_test_reg, y_pred_reg)
    rmse = np.sqrt(mse)
    mae = mean_absolute_error(y_test_reg, y_pred_reg)
    r2 = r2_score(y_test_reg, y_pred_reg)
    
    regression_ergebnisse[name] = {
        'model': model,
        'predictions': y_pred_reg,
        'mse': mse,
        'rmse': rmse,
        'mae': mae,
        'r2': r2
    }
    
    print(f"R² Score: {r2:.4f}")
    print(f"RMSE: {rmse:.2f}€")
    print(f"MAE: {mae:.2f}€")

# Regression Visualisierung
plt.figure(figsize=(15, 5))

for i, (name, ergebnis) in enumerate(regression_ergebnisse.items()):
    plt.subplot(1, 3, i+1)
    plt.scatter(y_test_reg, ergebnis['predictions'], alpha=0.6)
    plt.plot([y_test_reg.min(), y_test_reg.max()], [y_test_reg.min(), y_test_reg.max()], 'r--', lw=2)
    plt.xlabel('Tatsächliche Zahlungsbereitschaft (€)')
    plt.ylabel('Vorhergesagte Zahlungsbereitschaft (€)')
    plt.title(f'{name}\nR² = {ergebnis["r2"]:.3f}')

# Residuen Plot
plt.subplot(1, 3, 3)
best_reg_model_name = max(regression_ergebnisse.keys(), key=lambda x: regression_ergebnisse[x]['r2'])
best_reg_predictions = regression_ergebnisse[best_reg_model_name]['predictions']
residuen = y_test_reg - best_reg_predictions

plt.scatter(best_reg_predictions, residuen, alpha=0.6)
plt.axhline(y=0, color='r', linestyle='--')
plt.xlabel('Vorhergesagte Werte')
plt.ylabel('Residuen')
plt.title(f'Residuen Plot - {best_reg_model_name}')

plt.tight_layout()
# plt.show()
print(f"\nBestes Regressionsmodell: {best_reg_model_name}")

7. Unsupervised Learning: Clustering

Lassen Sie uns Teilnehmer in Gruppen unterteilen, ohne vorher zu wissen, welche Gruppen existieren:

# Clustering mit K-Means
from sklearn.cluster import KMeans
from sklearn.decomposition import PCA

# Daten für Clustering vorbereiten (ohne Target-Variable)
X_cluster = X_reg.copy()
X_cluster_scaled = StandardScaler().fit_transform(X_cluster)

# Optimale Anzahl Cluster finden (Elbow-Method)
inertias = []
K_range = range(2, 11)

for k in K_range:
    kmeans = KMeans(n_clusters=k, random_state=42, n_init=10)
    kmeans.fit(X_cluster_scaled)
    inertias.append(kmeans.inertia_)

# Elbow Plot
plt.figure(figsize=(12, 5))

plt.subplot(1, 2, 1)
plt.plot(K_range, inertias, 'bo-')
plt.xlabel('Anzahl Cluster (k)')
plt.ylabel('Inertia')
plt.title('Elbow Method für optimale Cluster-Anzahl')
plt.grid(True)

# K-Means mit 4 Clustern
k_optimal = 4
kmeans = KMeans(n_clusters=k_optimal, random_state=42, n_init=10)
cluster_labels = kmeans.fit_predict(X_cluster_scaled)

# PCA für Visualisierung (2D)
pca = PCA(n_components=2)
X_pca = pca.fit_transform(X_cluster_scaled)

# Cluster Visualisierung
plt.subplot(1, 2, 2)
colors = ['red', 'blue', 'green', 'purple', 'orange']
for i in range(k_optimal):
    cluster_points = X_pca[cluster_labels == i]
    plt.scatter(cluster_points[:, 0], cluster_points[:, 1], 
               c=colors[i], alpha=0.6, label=f'Cluster {i+1}')

# Cluster-Zentren
zentren_pca = pca.transform(kmeans.cluster_centers_)
plt.scatter(zentren_pca[:, 0], zentren_pca[:, 1], 
           c='black', marker='x', s=300, linewidths=3, label='Zentren')

plt.xlabel(f'PC1 ({pca.explained_variance_ratio_[0]:.1%} Varianz)')
plt.ylabel(f'PC2 ({pca.explained_variance_ratio_[1]:.1%} Varianz)')
plt.title('K-Means Clustering (PCA Projektion)')
plt.legend()
plt.grid(True)

plt.tight_layout()
# plt.show()

# Cluster-Charakteristika analysieren
cluster_df = X_cluster.copy()
cluster_df['Cluster'] = cluster_labels

print("\n=== Cluster Charakteristika ===")
cluster_stats = cluster_df.groupby('Cluster').agg({
    'alter': 'mean',
    'programmiererfahrung_jahre': 'mean',
    'wochenstunden_verfügbar': 'mean',
    'vorherige_kurse': 'mean',
    'gehalt': 'mean',
    'hat_studium': 'mean'
}).round(2)

print(cluster_stats)

# Cluster-Größen
cluster_größen = pd.Series(cluster_labels).value_counts().sort_index()
print(f"\nCluster-Größen:")
for i, size in enumerate(cluster_größen):
    print(f"Cluster {i+1}: {size} Teilnehmer ({size/len(cluster_labels)*100:.1f}%)")

8. Modell-Evaluation und Best Practices

🎯 ML Best Practices:

Datenqualität prüfen: Fehlende Werte, Ausreißer, Duplikate
Features verstehen: Domain-Wissen einbringen
Cross-Validation nutzen: Robuste Modell-Bewertung
Overfitting vermeiden: Regularisierung und Validation-Sets
Mehrere Modelle vergleichen: Verschiedene Algorithmen testen
Feature Engineering: Neue Features aus bestehenden ableiten
Interpretierbarkeit bedenken: Verstehen, warum Modell entscheidet

Praktische Anwendung des Modells:

# Funktion für neue Vorhersagen
def vorhersage_kursanmeldung(alter, erfahrung, stunden, kurse, gehalt, studium):
    """
    Vorhersage ob sich eine Person für fortgeschrittenen Kurs anmeldet
    """
    # Input in richtige Form bringen
    input_data = np.array([[alter, erfahrung, stunden, kurse, gehalt, studium]])
    
    # Skalieren (mit dem trainierten Scaler)
    input_scaled = scaler.transform(input_data)
    
    # Vorhersage mit bestem Modell
    prediction = bestes_modell.predict(input_scaled)[0]
    probability = bestes_modell.predict_proba(input_scaled)[0][1] if hasattr(bestes_modell, 'predict_proba') else None
    
    return prediction, probability

# Beispiel-Vorhersagen
print("=== Beispiel-Vorhersagen ===")

beispiele = [
    {"name": "Anna (Anfängerin)", "alter": 25, "erfahrung": 0.5, "stunden": 8, "kurse": 0, "gehalt": 35000, "studium": 1},
    {"name": "Max (Erfahren)", "alter": 35, "erfahrung": 5, "stunden": 12, "kurse": 2, "gehalt": 65000, "studium": 1},
    {"name": "Lisa (Quereinsteigerin)", "alter": 42, "erfahrung": 1, "stunden": 6, "kurse": 1, "gehalt": 45000, "studium": 0}
]

for beispiel in beispiele:
    pred, prob = vorhersage_kursanmeldung(
        beispiel["alter"], beispiel["erfahrung"], beispiel["stunden"],
        beispiel["kurse"], beispiel["gehalt"], beispiel["studium"]
    )
    
    ergebnis = "wird sich anmelden" if pred == 1 else "wird sich nicht anmelden"
    if prob is not None:
        print(f"{beispiel['name']}: {ergebnis} (Wahrscheinlichkeit: {prob:.2%})")
    else:
        print(f"{beispiel['name']}: {ergebnis}")

# Feature Engineering Beispiel
def create_advanced_features(df):
    """Erweiterte Features erstellen"""
    df_enhanced = df.copy()
    
    # Ratio Features
    df_enhanced['gehalt_pro_stunde'] = df_enhanced['gehalt'] / (df_enhanced['wochenstunden_verfügbar'] * 52)
    df_enhanced['erfahrung_pro_alter'] = df_enhanced['programmiererfahrung_jahre'] / df_enhanced['alter']
    
    # Kategorische Features
    df_enhanced['erfahrung_level'] = pd.cut(df_enhanced['programmiererfahrung_jahre'], 
                                           bins=[0, 1, 3, 8, float('inf')], 
                                           labels=['Anfänger', 'Junior', 'Mittel', 'Senior'])
    
    df_enhanced['alter_gruppe'] = pd.cut(df_enhanced['alter'], 
                                        bins=[0, 25, 35, 45, float('inf')], 
                                        labels=['Jung', 'Mittel', 'Erfahren', 'Senior'])
    
    # Interaktions-Features
    df_enhanced['zeit_x_erfahrung'] = df_enhanced['wochenstunden_verfügbar'] * df_enhanced['programmiererfahrung_jahre']
    
    return df_enhanced

print("\n=== Feature Engineering Beispiel ===")
enhanced_features = create_advanced_features(teilnehmer_daten.head())
print(enhanced_features[['gehalt_pro_stunde', 'erfahrung_pro_alter', 'erfahrung_level', 'alter_gruppe']].head())

9. Weiterführende Themen

Nach diesem Einstieg können Sie sich mit fortgeschrittenen Themen beschäftigen:

🚀 Nächste Schritte im ML-Learning:

Deep Learning: Neuronale Netzwerke mit TensorFlow/PyTorch
Natural Language Processing: Textanalyse und Sprachverarbeitung
Computer Vision: Bilderkennung und -verarbeitung
Time Series Analysis: Zeitreihenvorhersagen
Ensemble Methods: Modell-Kombinationen für bessere Performance
MLOps: Machine Learning in Produktion
Reinforcement Learning: Lernen durch Belohnung

Empfohlene Libraries und Tools:

# Erweiterte ML-Bibliotheken
libraries_overview = {
    "Grundlagen": [
        "scikit-learn - Umfassende ML-Bibliothek",
        "pandas - Datenmanipulation", 
        "numpy - Numerische Berechnungen",
        "matplotlib/seaborn - Visualisierung"
    ],
    "Deep Learning": [
        "tensorflow - Google's ML-Framework",
        "pytorch - Facebook's ML-Framework", 
        "keras - High-level Neural Network API"
    ],
    "Spezialisierte Bereiche": [
        "nltk/spacy - Natural Language Processing",
        "opencv - Computer Vision",
        "xgboost/lightgbm - Gradient Boosting",
        "statsmodels - Statistische Modelle"
    ],
    "Deployment": [
        "flask/fastapi - Web APIs für Modelle",
        "streamlit - Schnelle ML-Apps",
        "docker - Containerisierung",
        "mlflow - ML Lifecycle Management"
    ]
}

print("=== Empfohlene ML-Libraries ===")
for kategorie, libs in libraries_overview.items():
    print(f"\n{kategorie}:")
    for lib in libs:
        print(f"  • {lib}")

# Ressourcen für weiterführendes Lernen
print(f"\n=== Lernressourcen ===")
ressourcen = [
    "Kaggle - Wettbewerbe und Datasets",
    "Google Colab - Kostenlose GPU/TPU für Experimente", 
    "Papers with Code - Neueste Forschung mit Code",
    "Scikit-learn Documentation - Umfassende Dokumentation",
    "Bold Haze Data Science Kurs - Strukturiertes Lernen"
]

for ressource in ressourcen:
    print(f"  • {ressource}")

Fazit

Machine Learning mit Python und Scikit-learn öffnet Ihnen die Tür zu einer faszinierenden Welt der Datenanalyse und künstlichen Intelligenz. Sie haben gelernt, wie Sie:

Daten für ML-Projekte vorbereiten und explorieren
Klassifikations- und Regressionsmodelle erstellen
Modelle evaluieren und optimieren
Unsupervised Learning für Mustererkennnung nutzen
Best Practices für robuste ML-Projekte anwenden

Der Schlüssel zum Erfolg in Machine Learning liegt in der Praxis. Beginnen Sie mit kleinen Projekten, experimentieren Sie mit verschiedenen Algorithmen und entwickeln Sie ein Gefühl für die Daten.

Über den Autor

Dieser Artikel wurde vom Data Science Team bei Bold Haze verfasst. Unser Team entwickelt täglich ML-Modelle für reale Anwendungsfälle und teilt gerne praktische Erfahrungen mit der Community.