Humayun Hasimler

Einführung

Eine der größten Herausforderungen in ML-Projekten ist es, trainierte Modelle in der Praxis nutzbar zu machen.
Data Scientists erzielen oft gute Ergebnisse im Training, aber das Einsetzen in Produktionsumgebungen ist ein ganz anderer Prozess. Dieser Prozess heißt Model Deployment.

Fragen dabei sind:

Wie wird das Modell aufgerufen? (REST API, Batch, Streaming)
Wo läuft es? (On-Prem, Cloud, Edge)
Wie wird es überwacht? (Monitoring, Logging)
Wie werden neue Versionen veröffentlicht? (CI/CD, A/B Testing)

In diesem Leitfaden lernen Sie:

Grundkonzepte von Deployment,
Bereitstellung mit Flask,
Containerisierung mit Docker,
Automatisierung mit CI/CD und GitOps.

Voraussetzungen

Sie benötigen:

Python-Kenntnisse und ML-Bibliotheken (scikit-learn, joblib)
Flask-Grundlagen (REST API)
Docker-Wissen
Git und CI/CD-Basics
Grundbegriffe: training, inference, model registry

Schritt 1 – Grundkonzepte

1.1 Batch vs Online Inference

Batch Inference: Vorhersagen auf großen Datenmengen, z. B. nächtliche Segmentierungen.
Online Inference: Echtzeitvorhersagen, z. B. Produktempfehlungen per API.

1.2 On-Prem vs Cloud Deployment

On-Premises: Eigenes Rechenzentrum, mehr Kontrolle, mehr Aufwand.
Cloud Deployment: AWS SageMaker, Azure ML, GCP Vertex AI bieten Skalierbarkeit.

1.3 Model Registry

Eine Model Registry speichert Versionen und Metadaten.
Beispiele: MLflow, DVC, SageMaker Registry.

mlflow sklearn log-model -m "model.pkl" -r "my_model_registry"

Schritt 2 – Flask API

2.1 Training eines Modells

from sklearn.datasets import load_iris
from sklearn.linear_model import LogisticRegression
import joblib

iris = load_iris()
X, y = iris.data, iris.target

model = LogisticRegression(max_iter=200)
model.fit(X, y)

joblib.dump(model, "model.pkl")

2.2 Flask API erstellen

from flask import Flask, request, jsonify
import joblib

app = Flask(__name__)
model = joblib.load("model.pkl")

@app.route("/predict", methods=["POST"])
def predict():
    data = request.get_json()
    prediction = model.predict([data["features"]])
    return jsonify({"prediction": prediction.tolist()})

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=5000)

2.3 API testen

curl -X POST http://localhost:5000/predict     -H "Content-Type: application/json"     -d '{"features":[5.1, 3.5, 1.4, 0.2]}'

Schritt 3 – Dockerisierung

3.1 Dockerfile

FROM python:3.10-slim

WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt

COPY . .
CMD ["python", "app.py"]

3.2 requirements.txt

flask
scikit-learn
joblib

3.3 Build & Run

docker build -t flask-ml-model .
docker run -p 5000:5000 flask-ml-model

Schritt 4 – CI/CD & GitOps

4.1 GitHub Actions

name: Deploy Model API

on:
  push:
    branches: [ main ]

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
    - uses: actions/checkout@v2
    - name: Build Docker image
      run: docker build -t flask-ml-model .
    - name: Push to Registry
      run: docker push myrepo/flask-ml-model:latest

4.2 GitOps mit ArgoCD

apiVersion: apps/v1
kind: Deployment
metadata:
  name: ml-model
spec:
  replicas: 2
  selector:
    matchLabels:
      app: ml-model
  template:
    metadata:
      labels:
        app: ml-model
    spec:
      containers:
      - name: ml-model
        image: myrepo/flask-ml-model:latest
        ports:
        - containerPort: 5000

Schritt 5 – Herausforderungen

Latenz: Niedrige Antwortzeit in Echtzeit erforderlich.
Skalierung: Modelle müssen mit Traffic skalieren.
Monitoring: Accuracy kann sinken (Concept Drift).
Versionierung: Rollout per A/B- oder Canary-Tests.

Fazit

Wir haben den Prozess des Model Deployment behandelt:

Grundkonzepte (Batch vs Online, On-Prem vs Cloud, Registry),
Bereitstellung mit Flask API,
Containerisierung mit Docker,
CI/CD und GitOps.