Einführung in Künstliche Intelligenz und Maschinelles Lernen: Konzepte, reale Anwendungsfälle und wie man anfängt

Künstliche Intelligenz (KI) und Maschinelles Lernen (ML) sind aus Forschungslaboren in Alltagsprodukte übergegangen — sie treiben Empfehlungen, Betrugserkennung, Sprachassistenten, medizinische Bildgebung und industrielle Automatisierung an. Dieses Tutorial bietet eine praktische Einführung auf mittlerem Niveau: Wir definieren Kernbegriffe, ordnen reale Anwendungsfälle passenden Techniken zu und führen durch den Aufbau und das Wachstum einer angewandten ML-Praxis — vom ersten Modell bis zu Produktionssystemen und Monitoring. Unterwegs sehen Sie Code, Workflows und Ratschläge aus realen Projekten sowie moderne Tools, die aktuelle Best Practices widerspiegeln.

Wichtige Konzepte, die Sie tatsächlich nutzen werden

Vor Tools und Code sollten Sie ein paar Begriffe abstimmen, die in der Praxis wichtig sind.

• Künstliche Intelligenz vs Maschinelles Lernen vs Deep Learning

  • KI: jegliche Technik, die Maschinen befähigt, Aufgaben zu erledigen, die typischerweise menschliche Intelligenz erfordern (Schlussfolgern, Planung, Wahrnehmung, Sprache).
  • ML: ein Teilgebiet der KI, in dem Systeme Muster aus Daten lernen anstatt explizite Regeln zu folgen.
  • Deep Learning (DL): ein Teilgebiet des ML, das neuronale Netze mit vielen Schichten verwendet; exzellent in der Wahrnehmung (Vision, Audio) und bei der Modellierung von Sequenzen (Sprache).

• Arten des Lernens

  • Überwachtes Lernen: Lernen aus gelabelten Beispielen (x → y). Anwendungsfälle: Klassifikation (Spam/Kein Spam), Regression (Nachfrageprognose).
  • Unüberwachtes Lernen: Entdeckung von Struktur ohne Labels. Anwendungsfälle: Kundensegmentierung, Anomalieerkennung, Dimensionsreduktion.
  • Selbstüberwachtes Lernen: Lernen aus intrinsischen Signalen in den Daten (z. B. Vorhersage des nächsten Tokens). Grundlage moderner Sprach- und Bildmodelle.
  • Verstärkendes Lernen (RL): Lernen, durch Trial-and-Error Belohnung zu maximieren. Anwendungsfälle: Robotik, Empfehlungspolicies, Spiele.
  • Generative Modellierung: Erzeugen neuer Datensamples (Text, Bilder, Audio), die mit den Trainingsdaten konsistent sind. Techniken: autoregressive Transformer, Diffusionsmodelle, VAE, GANs.

• Häufige Daten/Modalitäten

  • Tabellarisch: Zeilen und Spalten (Marketing, Finanzen, Betrieb). Oft am besten mit Baum-Ensembles (XGBoost/LightGBM) oder linearen/logistischen Baselines bedient.
  • Text: Token-Sequenzen; nutzen Sie Transformer, Embeddings, RAG-Systeme.
  • Vision: Bilder/Video-Frames; verwenden Sie CNNs oder Vision Transformer (ViT).
  • Zeitreihen: Sequenzen über die Zeit; nutzen Sie Lag-Features, Prophet, gradient-boosted Trees oder Sequenzmodelle.
  • Multimodal: Kombination aus Text, Bild, Audio (z. B. Produktkatalog mit Bildern und Beschreibungen).

• Modellevaluation und Metriken

  • Klassifikation: Accuracy (nur für ausgeglichene Klassen), Precision/Recall, F1, ROC-AUC, PR-AUC (besser bei Klassenungleichgewicht), Konfusionsmatrix, Kalibrierung.
  • Regression: MAE, RMSE, R^2; für Forecasting: MAPE, Pinball-Loss (Quantil), Coverage.
  • Ranking/Empfehlungen: NDCG, MAP, recall@k, CTR-Lift.
  • NLP: BLEU/ROUGE für Generierung (nur bedingt aussagekräftig), Perplexity; menschliche Evaluation und aufgabenspezifische Metriken oft nötig.
  • Computer Vision: mAP für Detection, IoU für Segmentierung.

• Bias–Varianz, Overfitting und Regularisierung

  • Underfitting: Modell zu einfach für das Muster; Test- und Trainingsfehler sind hoch.
  • Overfitting: Modell merkt sich Rauschen; Training sehr gut, Test schlecht. Gegenmaßnahmen: Cross-Validation, richtige Regularisierung, Early Stopping und genügend Daten.
  • Regularisierung: L1/L2-Strafen, Dropout, Weight Decay, Datenaugmentation.

• Datenaufteilungen und Validierung

  • Hold-out-Split für schnelle Checks; k-fold Cross-Validation für Robustheit.
  • Zeitreihen: immer zeitliche Splits nutzen, um Kausalität zu respektieren.
  • Group-Splits verhindern Leakage über verwandte Instanzen (Nutzer, Sessions).

• Foundation-Modelle und Embeddings

  • Vorgefertigte Transformer lernen allgemeine Repräsentationen (Embeddings).
  • Downstream-Aufgaben können Embeddings als Features nutzen oder durch Fine-Tuning/Adapter anpassen.
  • Retrieval-Augmented Generation (RAG) fundiert generative Modelle mit Ihren Daten, indem relevante Kontexte zur Abfragezeit abgerufen werden.

Reale Anwendungsfälle und passende Techniken

Die Wahl der richtigen Methode beginnt mit klarer Definition des Ziels und der Einschränkungen.

• E‑Commerce Empfehlungen

  • Aufgaben: ähnliche Artikel, Next-Best-Purchase, personalisiertes Ranking.
  • Techniken: Matrixfaktorisierung, Two-Tower-Retrieval, gradient-boosted Trees für Ranking, sequenzielle Recommender oder Embeddings + Nearest-Neighbor-Suche.

• Betrugserkennung und Risikobewertung

  • Ungleichgewichtige Klassifikation mit Concept Drift.
  • Techniken: Baum-Ensembles (XGBoost/LightGBM), Outlier-Detection (Isolation Forest), costsensitive Lernverfahren, Sliding-Window-Retraining und SHAP für Interpretierbarkeit.

• Kundenabwanderung und Customer Lifetime Value

  • Tabellarische Klassifikation/Regression mit Risiko zeitlicher Lecks.
  • Techniken: Feature-Engineering aus Events, Survival-Modelle, Uplift-Modeling für Interventionen.

• Suche und Fragebeantwortung

  • Techniken: BM25 + dense retrieval mit Embeddings, Cross-Encoder fürs Reranking, RAG-Pipelines für fundierte Antworten.

• Predictive Maintenance und IoT

  • Sensordaten als Zeitreihen, multivariate Anomalien.
  • Techniken: Feature-Extraktion (rollende Statistiken, FFT), Forecasting (Prophet, CatBoost), Autoencoder für Anomalieerkennung.

• Computer Vision

  • Qualitätsprüfung, OCR, medizinische Bildgebung.
  • Techniken: CNN/ViT-Backbones, Transfer Learning mit Linear Probing + Fine-Tune, Datenaugmentation, Umgang mit Klassenungleichgewicht.

• NLP im Unternehmen

  • Dokumentenklassifikation, NER, Zusammenfassung.
  • Techniken: Transformer auf gelabelten Subsets fine-tunen; für Generierung RAG + Prompt-Engineering + Guardrails.

• Marketing und Experimente

  • Uplift-Modeling für kausalen Kampagneneffekt, Bandits für Budgetzuweisung, Attributionsmodelle.

• Cybersicherheit

  • Log-Anomalieerkennung, Malware-Klassifikation.
  • Techniken: Sequenzmodelle auf Logs, graphbasierte Erkennung, semi‑überwachtes Lernen, One-Class-SVMs.

• Finanzprognosen

  • Portfoliosignale, Nachfrageprognosen.
  • Techniken: gradient-boosted Trees auf engineered Features, Quantilprognosen, Backtesting mit realistischen Beschränkungen.

Wie man anfängt: Fähigkeiten, Tools und Umgebung

Sie brauchen kein Rechenzentrum zum Start — klein anfangen, iterieren, dann skalieren.

• Voraussetzungen (mittleres Niveau)

  • Python-Programmierung (Funktionen, Klassen, virtuelle Umgebungen).
  • Wahrscheinlichkeitsrechnung und Statistik (Verteilungen, Hypothesentests), Lineare Algebra (Vektoren, Matrizen), Kalkül‑Intuition für Optimierung.
  • Software‑Handwerk: Git, Tests, Reproduzierbarkeit.

• Tools

  • Sprachen: Python 3.10+ (3.11 empfohlen für Performance).
  • Kernbibliotheken: numpy, pandas, scikit-learn, matplotlib/seaborn, XGBoost/LightGBM, catboost.
  • Deep Learning: PyTorch oder TensorFlow/Keras; Hugging Face Transformers und Datasets für NLP.
  • Experiment-Tracking: MLflow oder Weights & Biases; Datenversionierung mit DVC.
  • Notebooks: JupyterLab oder VS Code.
  • Cloud-Notebooks: Google Colab, Kaggle Notebooks für GPU-Zugriff.

• Umgebung einrichten (Beispiel mit mamba/conda)

  mamba create -n ml-intro python=3.11 -y
  mamba activate ml-intro
  pip install numpy pandas scikit-learn matplotlib seaborn xgboost lightgbm mlflow jupyterlab
  # For deep learning and NLP
  pip install torch --index-url https://download.pytorch.org/whl/cpu
  pip install transformers datasets evaluate accelerate
  

• Datenquellen zum Üben

  • Tabellarisch: UCI ML repository (z. B. Adult, Heart Disease), Kaggle-Wettbewerbe/-Datasets.
  • Text: Hugging Face Datasets (AG News, IMDB), Wikipedia-Dumps.
  • Vision: CIFAR-10, Fashion-MNIST, COCO-Subsets.

Ein erstes End-to-End-Projekt: Churn-Vorhersage mit tabellarischen Daten

Churn-Vorhersage ist ein klassisches Business-Problem: identifizieren Sie Kunden, die wahrscheinlich kündigen, damit Sie intervenieren können (Rabatte, Support, Feature-Einführung).

1) Problem und Ziel definieren

• Vorhersage: Wird ein Kunde im nächsten Zeitraum kündigen? Binäre Klassifikation.
• Einschränkungen: Klassenungleichgewicht, temporale Leakage (Nutzung zukünftiger Informationen).
• Erfolgsmetrik: PR-AUC oder recall@k bei festgelegter Precision-Schwelle (Interventionsbudget), Geschäfts-KPI wie verringerte Churn-Rate.

2) Daten zusammenstellen und prüfen

• Eingaben: Kundendemografie, Abonnementplan, Engagement-Features, Support-Tickets, Zahlungshistorie.
• Labels: churned (1), wenn Konto innerhalb der nächsten 30 Tage geschlossen wird; sonst 0.
• Prüfen auf:
  • Leakage: Features, die nach dem Vorhersagezeitpunkt erstellt wurden (entfernen/verschieben).
  • Fehlmuster: sind fehlende Werte informativ? Imputation oder Missing-Indikatoren verwenden.
  • Klassenungleichgewicht: z. B. 5–10 % Churner.

3) Daten korrekt aufteilen

• Verwenden Sie einen temporalen Split: auf älteren Perioden trainieren, auf neueren validieren.
• Für ein Tutorial ohne Zeitstempel: stratified Split, um Klassenverteilung zu halten.

4) Baselines und eine saubere Pipeline etablieren

Beginnen Sie mit einer einfachen, korrekten Baseline und einer reproduzierbaren Pipeline. Das setzt eine Messlatte und liefert eine Vorlage zum Iterieren.

import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split, StratifiedKFold, cross_val_score
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder, StandardScaler
from sklearn.impute import SimpleImputer
from sklearn.pipeline import Pipeline
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import classification_report, roc_auc_score, average_precision_score

# Example: load your dataset
df = pd.read_csv("churn.csv")  # columns: features + 'churn' label
y = df['churn'].astype(int)
X = df.drop(columns=['churn'])

num_cols = X.select_dtypes(include=['int64','float64']).columns
cat_cols = X.select_dtypes(include=['object','category','bool']).columns

numeric = Pipeline(steps=[
    ("imputer", SimpleImputer(strategy="median")),
    ("scaler", StandardScaler())
])
categorical = Pipeline(steps=[
    ("imputer", SimpleImputer(strategy="most_frequent")),
    ("onehot", OneHotEncoder(handle_unknown="ignore"))
])

preprocess = ColumnTransformer(
    transformers=[
        ("num", numeric, num_cols),
        ("cat", categorical, cat_cols)
    ])

model = LogisticRegression(max_iter=200, n_jobs=-1)
pipe = Pipeline(steps=[("prep", preprocess), ("model", model)])

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, stratify=y, random_state=42
)

pipe.fit(X_train, y_train)
probs = pipe.predict_proba(X_test)[:,1]
print("ROC-AUC:", roc_auc_score(y_test, probs))
print("PR-AUC:", average_precision_score(y_test, probs))
print(classification_report(y_test, (probs > 0.5).astype(int)))

Wichtige Punkte:

• ColumnTransformer verhindert Leakage, weil Preprocessing nur auf Trainingsdaten gelernt wird.
• Beginnen Sie mit logistischer Regression für Interpretierbarkeit und Kalibrierung.

5) Mit Klassenungleichgewicht umgehen

• Methoden:
  • class_weight="balanced" in linearen Modellen einstellen.
  • Entscheidungsschwellen anhand der PR-Kurve ändern; für Business-KPI optimieren.
  • Resampling: SMOTE oder Undersampling (vorsichtig in CV einsetzen).
  • Focal Loss oder angepasste Verluste in Baum-Ensembles.

6) Starke tabellarische Modelle (Baum-Ensembles) ausprobieren

Gradient-boosted Trees dominieren oft tabellarische Benchmarks.

from sklearn.model_selection import RandomizedSearchCV
from xgboost import XGBClassifier

xgb = XGBClassifier(
    n_estimators=500,
    learning_rate=0.05,
    max_depth=6,
    subsample=0.8,
    colsample_bytree=0.8,
    eval_metric="auc",
    tree_method="hist"
)

pipe_xgb = Pipeline(steps=[("prep", preprocess), ("model", xgb)])

param_dist = {
    "model__n_estimators": [300, 500, 800],
    "model__max_depth": [4, 6, 8],
    "model__learning_rate": [0.03, 0.05, 0.1],
    "model__subsample": [0.7, 0.8, 1.0],
    "model__colsample_bytree": [0.7, 0.8, 1.0],
    "model__min_child_weight": [1, 5, 10],
    "model__gamma": [0, 1, 5]
}

cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
search = RandomizedSearchCV(
    pipe_xgb, param_distributions=param_dist,
    n_iter=25, scoring="average_precision", cv=cv,
    verbose=1, n_jobs=-1, random_state=42
)
search.fit(X_train, y_train)
best = search.best_estimator_
probs = best.predict_proba(X_test)[:,1]
print("Best PR-AUC:", average_precision_score(y_test, probs))

Hinweise:

• Verwenden Sie average_precision (PR-AUC), wenn die Daten unausgeglichen sind.
• Belassen Sie Preprocessing in der Pipeline, um Feature-Drift zwischen Training und Inferenz zu vermeiden.

7) Fehler, Kalibrierung und Feature‑Importance untersuchen

• Konfusionsmatrix: Wo verpassen wir Churner? Probieren Sie Threshold-Movement, um Recall zu erhöhen.
• Kalibrierung: Baum-Ensembles können schlecht kalibriert sein; nutzen Sie CalibratedClassifierCV oder isotone Regression.
• Interpretierbarkeit:
  • Global: Feature-Importance (Gain), Permutation Importance.
  • Lokal: SHAP-Werte zur Erklärung einzelner Vorhersagen (bei korrelierten Features mit Vorsicht verwenden).

8) Machen Sie Ihr Modell als Service verfügbar

Verpacken Sie die Inferenz, damit Downstream-Systeme Vorhersagen konsumieren können.

# save.py
import joblib
joblib.dump(best, "churn_model.joblib")

# serve.py
from fastapi import FastAPI
import joblib
import pandas as pd

app = FastAPI()
model = joblib.load("churn_model.joblib")

@app.post("/predict")
def predict(features: dict):
    X = pd.DataFrame([features])
    prob = float(model.predict_proba(X)[:,1][0])
    return {"churn_probability": prob}

Ausführen:

• uvicorn serve:app --host 0.0.0.0 --port 8000
• Testen mit curl oder Postman; stellen Sie sicher, dass die Keys im Request-Payload genau den Trainings-Features entsprechen.

9) Experimente und Daten versionieren

• Verwenden Sie MLflow, um Parameter, Metriken und Artefakte zu protokollieren:

  import mlflow
  mlflow.start_run()
  mlflow.log_params(search.best_params_)
  mlflow.log_metric("pr_auc", average_precision_score(y_test, probs))
  mlflow.sklearn.log_model(best, "model")
  mlflow.end_run()
  

• Versionieren Sie Datensätze mit DVC oder Git LFS, um Änderungen an Daten-Slices nachzuverfolgen und Reproduzierbarkeit sicherzustellen.

10) Sicher deployen und überwachen

• Shadow-Deploy neuer Modelle, um sie mit dem aktuellen Champion zu vergleichen.
• Monitoring:
  • Data Drift: Änderungen in Feature-Verteilungen (PSI, KL-Divergenz).
  • Performance-Drift: Verzögerte Labels erschweren das Monitoring; nutzen Sie Proxy-Metriken.
  • Vorhersageverteilung und Kalibrierungsdrift.
• Retrain-Cadence: planen Sie regelmäßiges Retraining oder triggern Sie es bei Drift-Schwellen.

Häufige Fallstricke und wie man sie vermeidet

• Target Leakage

  • Verwendung von Features, die nach dem Vorhersagezeitpunkt erstellt wurden (z. B. Anzahl Logins in der nächsten Woche).
  • Lösung: zeitbewusste Feature-Erzeugung und Validierung; Fenster einfrieren.

• Falsche Validierung

  • Zufälliges k-fold bei Zeitreihen oder Leakage über Nutzer-Gruppen.
  • Lösung: zeitbasierte Splits; GroupKFold für Nutzer/Sessions.

• Overfitting auf Testset oder Leaderboard

  • Zu viele Iterationen, gesteuert durch denselben Test → Selektionsbias.
  • Lösung: finales, unangetastetes Testset; für Modellauswahl verschachtelte CV verwenden.

• Metrik passt nicht zur Geschäftsentscheidung

  • Optimierung von ROC-AUC, obwohl Interventionen von Top‑k-Precision abhängen.
  • Lösung: Metriken wählen, die mit der Handlungsfähigkeit übereinstimmen (PR-AUC, Kostenkurven).

• Vernachlässigung asymmetrischer Kosten

  • False negatives sind teuer; false positives verschwenden Outreach.
  • Lösung: kostenbewusste Schwellen, angepasste Loss-Funktionen, erwarteter Wert-Analyse.

• Schlechte Datenqualität und -lineage

  • Fehlende Werte, Duplikate, inkonsistente IDs.
  • Lösung: Data Contracts, Schema-Checks (Great Expectations), Unit-Tests für Features.

• Reproduzierbarkeitslücken

  • Ungepinntes Dependency-Management, nicht-deterministische Seeds, fehlendes Preprocessing bei Inferenz.
  • Lösung: Lockfiles (pip-tools/poetry), deterministische Konfigurationen, vollständige Pipelines.

• Sicherheits- und Datenschutzlücken

  • PII in Logs oder Trainingsdaten; Prompt-Injection in LLM-Apps.
  • Lösung: Anonymisierung, Tokenisierung, Zugriffskontrollen, Prompt-Sanitization, Allow-/Deny-Listen.

• Interpretierbarkeit und Compliance

  • Regulatoren oder Stakeholder benötigen Erklärungen für Entscheidungen.
  • Lösung: erklärbare Modelle wählen, wenn nötig; Model Cards und Datasheets für Datensätze dokumentieren.

Über Tabellarisches hinaus: modernes NLP und RAG in der Praxis

Large Language Models (LLMs) sind nützlich für Klassifikation, Extraktion und Generierung, aber Unternehmens-Deployments benötigen Grounding, Schutzvorkehrungen und Monitoring.

• Wann LLMs vs klassisches ML

  • Wenige Labels, Long-Tail-Textvielfalt: LLMs glänzen (few-shot).
  • Stabile, strukturierte Labels mit viel Daten: kleinere überwachte Modelle sind günstiger und schneller.

• RAG (Retrieval-Augmented Generation)

  • Indexieren Sie domänenspezifische Dokumente als Embeddings; rufen Sie relevante Chunks zur Abfragezeit ab; fügen Sie sie als Kontext in Prompts ein.
  • Vorteile: geringeres Halluzinationsrisiko, einfacheres Aktualisieren (Re-Index), weniger Bedarf an Fine-Tuning.

• Minimaler RAG-Sketch

  # Pseudocode with sentence-transformers + FAISS + an LLM API
  from sentence_transformers import SentenceTransformer
  import faiss, numpy as np
  
  docs = ["policy A ...", "runbook B ...", "FAQ C ..."]
  model = SentenceTransformer("all-MiniLM-L6-v2")
  embeddings = model.encode(docs, normalize_embeddings=True)
  index = faiss.IndexFlatIP(embeddings.shape[1])
  index.add(embeddings)
  
  def retrieve(query, k=3):
    q = model.encode([query], normalize_embeddings=True)
    scores, I = index.search(q, k)
    return [docs[i] for i in I[0]]
  
  question = "How do I reset my SSO token?"
  context = "\n".join(retrieve(question))
  prompt = f"Answer using only the context:\n{context}\n\nQuestion: {question}"
  # Call your LLM here with 'prompt' and return the answer.
  

• Fine-Tuning vs Adapter

  • Full Fine-Tuning ist teuer und anfällig bei Updates.
  • Parameter‑effizientes Fine‑Tuning (LoRA, Adapter) ändert nur einen kleinen Teil der Gewichte, spart Rechenaufwand und bewahrt das Basismodell.

• Sicherheit und Evaluation für LLMs

  • Testen auf Prompt-Injection, Datenexfiltration, Jailbreaks.
  • Evaluation mit Suites: Groundedness, Toxicity, PII-Leakage, aufgabenspezifische Genauigkeit.
  • Guardrails einbauen (Regex-Filter, Policy-Klassifizierer) und System-Prompts mit Beschränkungen verwenden.

Ein reproduzierbarer ML-Workflow, den Sie übernehmen können

Bewegen Sie sich von Ad-hoc-Notebooks zu einem engineering‑reifen Workflow.

• Projektstruktur

  • notebooks/: Exploration; src/: Feature-Pipelines und Training; tests/: Unit-Tests; data/: versionierte Eingaben; models/: Artefakte.
  • config/: YAML oder JSON für Parameter; Hydra oder pydantic-Settings für Overrides verwenden.

• Experiment-Tracking und Registries

  • Hyperparameter, Code-Commit, Datenversion, Metriken nachverfolgen.
  • „Champion“ und „Challenger“ Modelle im MLflow Model Registry registrieren; Promotionen verwalten.

• Feature-Pipelines

  • Features von Roh-Logs zu Trainingstables materialisieren mit Spark, Dask oder Python-Jobs.
  • Feature Stores in Betracht ziehen, um Konsistenz zwischen Training und Inferenz sicherzustellen.

• CI/CD für ML

  • CI: Lint, Unit-Tests und einen kleinen Trainings-Smoketest ausführen.
  • CD: Docker-Image bauen, in Staging deployen, Canary laufen lassen, Promotion basierend auf SLOs.

• Batch vs Echtzeit

  • Batch-Scoring für nächtliche Churn-Listen oder monatliche Risiko-Scores.
  • Echtzeit-APIs für Betrug, Ranking, konversationelle UX.

• Observability

  • Inputs, Vorhersagen und Metadaten mit Datenschutzkontrollen protokollieren.
  • Auf Data Drift, Ausreißer und Performance-Regressions überwachen.
  • Alerts für anomaleträchtigen Traffic und unerwartete Input-Schemata einrichten.

Praktische Tipps, Muster und Heuristiken

• Einfach anfangen

  • Baselines: logistische/lineare Modelle oder naive Forecasts können mit guten Features gewinnen.
  • Fehleranalyse machen, bevor Sie mehr Rechenleistung einkaufen.

• Aufwand in Daten investieren

  • Feature-Engineering und Datenbereinigung liefern oft 80 % der Verbesserungen bei tabellarischen Problemen.
  • Für Vision/NLP sind Datenaugmentation und -kuratierung genauso wichtig wie Architekturänderungen.

• Die richtige Metrik verwenden

  • Bevorzugen Sie PR-AUC bei seltenen Positiven; berücksichtigen Sie Geschäftsrestriktionen (Budget, Kapazität).

• Hyperparameter-Suche

  • Verwenden Sie Randomized Search oder Bayes-Optimierung (Optuna) statt Grid Search für Effizienz.
  • Suchraum mit Domänenwissen begrenzen; Early Stopping nutzen.

• Regularisierung und Early Stopping

  • Bäume: Learning Rate + n_estimators + Early Stopping auf Validierung.
  • Neuronale Netze: Dropout, Weight Decay, patience-basiertes Early Stopping.

• Cross-Validation richtig anwenden

  • GroupKFold oder zeitbasierte Splits wo relevant.
  • Sicherstellen, dass Fits innerhalb der CV-Schleife stattfinden, um Leakage zu vermeiden.

• Reproduzierbarkeits-Checkliste

  • Dependencies pinnen; Random Seeds erfassen; Daten-Hashes und Umgebungsdetails loggen.

• Interpretierbarkeit

  • SHAP für lokale/globale Erklärungen nutzen; Stabilität über Kohorten prüfen.
  • Bieten Sie Gegenfaktische an, wenn möglich, um Nutzeraktionen zu unterstützen.

• Sicherheit und Datenschutz

  • Dependencies scannen, Ressourcenlimits setzen, Inputs validieren.
  • Für LLMs: Nutzereingaben im Kontext säubern und Tool-Zugriffe kontrollieren.

• Kosten- und Latenzbudgetierung

  • Kosten pro 1k Vorhersagen schätzen; Batchgröße optimieren, Modelle quantisieren (int8) und Embeddings cachen.

Erweiterung des Starterprojekts: Zeitbewusstsein und kausales Denken

Reale Systeme leben in der Zeit und reagieren auf Interventionen — modellieren Sie das entsprechend.

• Zeitbewusste Features

  • Features mit festen Fenstern konstruieren (letzte 7/30/90 Tage).
  • Lagged-Statistiken und Recency/Frequency/Monetary (RFM)-Features verwenden.

• Kohorten- und Segmentauswertung

  • Metriken nach Region, Tarif, Akquisitionskanal slice’n, um unterschiedliche Performance zu entdecken.

• Counterfactuals und Uplift

  • Wenn Sie auf Churn-Vorhersagen reagieren, ändern Sie die Ergebnisse.
  • Uplift-Modelle versuchen vorherzusagen, welche Kunden ihr Verhalten durch eine Intervention ändern; auswerten mit A/B-Tests oder Causal Forests.

• Experimente nach dem Deployment

  • Validieren Sie den geschäftlichen Impact mit kontrollierten Experimenten.
  • Überwachen Sie Interferenzen und Feedback-Loops (z. B. Betrugsmodelle, die Traffic blockieren und damit Datenverteilungen ändern).

Ein kompaktes Deep-Learning-Beispiel: Textklassifikation mit Transformern

Wenn Textsemantik wichtig ist und Sie moderate Labels haben, kann ein kleines Transformer-Fine-Tune klassische Modelle übertreffen.

from datasets import load_dataset
from transformers import AutoTokenizer, AutoModelForSequenceClassification, TrainingArguments, Trainer
import evaluate
import numpy as np

dataset = load_dataset("ag_news")
tokenizer = AutoTokenizer.from_pretrained("distilbert-base-uncased")

def tokenize(batch):
    return tokenizer(batch["text"], truncation=True, padding="max_length", max_length=256)

tokenized = dataset.map(tokenize, batched=True)
tokenized = tokenized.rename_column("label", "labels")
tokenized.set_format(type="torch", columns=["input_ids", "attention_mask", "labels"])

model = AutoModelForSequenceClassification.from_pretrained("distilbert-base-uncased", num_labels=4)
metric = evaluate.load("accuracy")

def compute_metrics(eval_pred):
    logits, labels = eval_pred
    preds = np.argmax(logits, axis=-1)
    return {"accuracy": metric.compute(predictions=preds, references=labels)["accuracy"]}

args = TrainingArguments(
    output_dir="out",
    evaluation_strategy="epoch",
    save_strategy="epoch",
    learning_rate=3e-5,
    per_device_train_batch_size=16,
    per_device_eval_batch_size=32,
    num_train_epochs=2,
    weight_decay=0.01,
    logging_steps=50
)

trainer = Trainer(
    model=model,
    args=args,
    train_dataset=tokenized["train"].shuffle(seed=42).select(range(40000)),
    eval_dataset=tokenized["test"],
    compute_metrics=compute_metrics
)
trainer.train()

Tipps:

• Beginnen Sie immer mit einer kleinen Untermenge, um die Pipeline zu überprüfen.
• GPU/CPU-Auslastung überwachen; Datenladeflaschenhälse vermeiden.