SH

Sascha Hess

xenosystems.de - IT-Consulting & Data Management

www.xenosystems.de

Strategische Wissens-Roadmap 2026

BI & Governance

Predictive Analytics

Vorhersagemodelle für mittelständische Datenteams

1

10 Predictive-Fallen

Typische Fehler beim Einstieg in Vorhersagemodelle — mit Gegenmaßnahmen

2

5 KMU-Anwendungsfälle

Churn, Absatz, Lager, Zahlungsausfall, Wartung — sofort einsatzbereit

3

Modelle ohne Data-Science-Team

SQL-native Vorhersagen und AutoML für bestehende BI-Teams

4

Governance-Framework

Modell-Versionierung, Monitoring und Erklärbarkeit für den Mittelstand

5

30-Tage-Einstiegsplan

Vom ersten Modell bis zum produktiven Power-BI-Dashboard

WER DIESES KIT NUTZEN KANN

■  BI-Entwickler mit SQL-Kenntnissen und Power-BI-Erfahrung — kein Data-Science-Studium erforderlich.

■  IT-Leiter, die Predictive Analytics strategisch einführen wollen — mit klarer Roadmap und Governance.

■  Controlling und Fachabteilungen, die verstehen wollen, was Vorhersagemodelle leisten können und was nicht.

■  Data Engineers, die bestehende ETL/ELT-Pipelines um Vorhersage-Features erweitern möchten.

WAS PREDICTIVE ANALYTICS NICHT IST

■  Kein Orakel — Modelle sagen Wahrscheinlichkeiten voraus, keine Gewissheiten.

■  Kein Ersatz für Domänenwissen — ein Modell ohne Fachexpertise liefert Zahlen ohne Kontext.

■  Keine Einmallösung — Modelle degradieren über Zeit und müssen überwacht und neu trainiert werden.

■  Kein KI-Projekt — tabellarische Vorhersagen mit scikit-learn haben nichts mit LLMs oder generativer KI zu tun.

Klassifikation

Churn-Vorhersage

Gradient Boosting (XGBoost)

Mittel

Klassifikation

Zahlungsausfall-Risiko

Logistische Regression

Niedrig

Regression

Monatsumsatz-Prognose

Random Forest Regressor

Mittel

Regression

Lieferzeit-Schätzung

Linear Regression + Features

Niedrig

Zeitreihe

Absatzplanung

Prophet / ARIMA

Mittel

Zeitreihe

Lagerbestandsoptimierung

Prophet + Saisonalität

Mittel

Anomalie

Betrugserkennung

Isolation Forest

Mittel

Cluster

Kundensegmentierung

K-Means

Niedrig

Accuracy

Klassifikation

Anteil korrekt klassifizierter Fälle

> 80 % (bei balancierten Klassen)

AUC-ROC

Klassifikation

Trennschärfe bei verschiedenen Schwellenwerten

> 0.75

Precision

Klassifikation

Wie viele Alarme sind echte Alarme?

Hoch bei teuren False Positives

Recall

Klassifikation

Wie viele echte Fälle werden erkannt?

Hoch bei teuren False Negatives

MAE

Regression

Mittlerer absoluter Fehler

So klein wie möglich

MAPE

Regression / Zeitreihe

Prozentualer Fehler

< 10 % für Absatzplanung

RMSE

Regression

Bestraft große Ausreißer stärker

Niedriger als MAE-Baseline

WELCHE METRIK FÜR WELCHEN ANWENDUNGSFALL

■  Churn-Vorhersage → AUC-ROC + Recall (verpasste Churner sind teuer).

■  Zahlungsausfallrisiko → Precision + AUC-ROC (False Positives sperren gute Kunden).

■  Absatzplanung → MAPE (Prozentfehler ist für das Controlling verständlich).

■  Lageroptimierung → MAE + Service Level (Fehlmengenkosten vs. Lagerkosten abwägen).

-- Churn-Features aus Transaktionsdaten berechnen

-- Label: Kein Kauf in den letzten 90 Tagen (für historisches Training)

CREATE OR ALTER VIEW ml.V_Churn_Features AS

SELECT

    k.KundenNr,

    -- Recency: Tage seit letztem Kauf

    DATEDIFF(DAY, MAX(b.Bestelldatum), GETDATE())           AS recency_tage,

    -- Frequency: Anzahl Bestellungen letztes Jahr

    COUNT(CASE WHEN b.Bestelldatum >= DATEADD(YEAR,-1,GETDATE())

               THEN 1 END)                                  AS frequency_12m,

    -- Monetary: Umsatz letztes Jahr

    SUM(CASE WHEN b.Bestelldatum >= DATEADD(YEAR,-1,GETDATE())

             THEN b.Nettobetrag ELSE 0 END)                 AS monetary_12m,

    -- Trend: Umsatz Q4 vs. Q3 (negative Tendenz = Churn-Signal)

    SUM(CASE WHEN b.Bestelldatum >= DATEADD(MONTH,-3,GETDATE())

             THEN b.Nettobetrag ELSE 0 END) -

    SUM(CASE WHEN b.Bestelldatum BETWEEN DATEADD(MONTH,-6,GETDATE())

                                     AND DATEADD(MONTH,-3,GETDATE())

             THEN b.Nettobetrag ELSE 0 END)                 AS umsatz_trend_q,

    -- Support-Kontakte als Unzufriedenheits-Signal

    COUNT(DISTINCT t.TicketID)                              AS support_tickets_6m,

    -- Produktbreite: Kunden mit nur 1 Kategorie churnen öfter

    COUNT(DISTINCT a.Warengruppe)                           AS warengruppen_anzahl,

    -- Label für Training (0=aktiv, 1=abgewandert)

    CASE WHEN MAX(b.Bestelldatum) < DATEADD(DAY,-90,GETDATE()) THEN 1

         ELSE 0 END                                         AS churn_label

FROM dbo.Kunden k

LEFT JOIN dbo.Bestellungen b ON k.KundenNr = b.KundenNr

LEFT JOIN dbo.Tickets t ON k.KundenNr = t.KundenNr

    AND t.ErstelltAm >= DATEADD(MONTH,-6,GETDATE())

LEFT JOIN dbo.Artikel a ON b.ArtikelNr = a.ArtikelNr

GROUP BY k.KundenNr;

-- Zeitreihen-Features für Absatzprognose

CREATE OR ALTER VIEW ml.V_Absatz_Features AS

SELECT

    ArtikelNr,

    DATEPART(YEAR,  Bestelldatum)       AS jahr,

    DATEPART(MONTH, Bestelldatum)       AS monat,

    DATEPART(WEEK,  Bestelldatum)       AS kalenderwoche,

    -- Saison-Encoding (zyklisch)

    SIN(2 * PI() * DATEPART(MONTH,Bestelldatum) / 12) AS saison_sin,

    COS(2 * PI() * DATEPART(MONTH,Bestelldatum) / 12) AS saison_cos,

    -- Lag-Features: Menge der Vorwochen als Prädiktor

    SUM(Menge)                          AS menge_aktuell,

    LAG(SUM(Menge),1) OVER (PARTITION BY ArtikelNr ORDER BY

        DATEPART(YEAR,Bestelldatum), DATEPART(WEEK,Bestelldatum)) AS menge_vorwoche,

    LAG(SUM(Menge),4) OVER (PARTITION BY ArtikelNr ORDER BY

        DATEPART(YEAR,Bestelldatum), DATEPART(WEEK,Bestelldatum)) AS menge_vor4wochen,

    LAG(SUM(Menge),52) OVER (PARTITION BY ArtikelNr ORDER BY

        DATEPART(YEAR,Bestelldatum), DATEPART(WEEK,Bestelldatum)) AS menge_vorjahr,

    -- Rollierender Durchschnitt 4 Wochen

    AVG(SUM(Menge)) OVER (PARTITION BY ArtikelNr ORDER BY

        DATEPART(YEAR,Bestelldatum), DATEPART(WEEK,Bestelldatum)

        ROWS BETWEEN 3 PRECEDING AND CURRENT ROW)      AS rolling_avg_4w

FROM dbo.Bestellpositionen

GROUP BY ArtikelNr, DATEPART(YEAR,Bestelldatum),

         DATEPART(MONTH,Bestelldatum), DATEPART(WEEK,Bestelldatum);

-- Zahlungsausfall-Features aus Buchungsdaten

CREATE OR ALTER VIEW ml.V_Zahlungsrisiko_Features AS

SELECT

    k.KundenNr,

    -- Bisherige Zahlungshistorie

    AVG(DATEDIFF(DAY, r.Faelligkeitsdatum,

        ISNULL(z.Zahlungsdatum, GETDATE())))            AS avg_zahlungsverzug_tage,

    MAX(DATEDIFF(DAY, r.Faelligkeitsdatum,

        ISNULL(z.Zahlungsdatum, GETDATE())))            AS max_zahlungsverzug_tage,

    COUNT(CASE WHEN z.Zahlungsdatum IS NULL

               AND r.Faelligkeitsdatum < GETDATE()

               THEN 1 END)                              AS offene_mahnungen,

    -- Offener Betrag relativ zum Jahrsumsatz

    SUM(CASE WHEN z.Zahlungsdatum IS NULL

             THEN r.Betrag ELSE 0 END)                  AS offener_betrag,

    SUM(r.Betrag) / NULLIF(COUNT(DISTINCT

        YEAR(r.Rechnungsdatum)), 0)                     AS jahresumsatz_avg,

    -- Branche und Unternehmensgröße als kategorische Features

    k.Branche,

    k.Groessenklasse,

    -- Label: Zahlung > 30 Tage überfällig

    MAX(CASE WHEN DATEDIFF(DAY, r.Faelligkeitsdatum,

        ISNULL(z.Zahlungsdatum,'9999-12-31')) > 30

        THEN 1 ELSE 0 END)                              AS zahlungsausfall_label

FROM dbo.Kunden k

JOIN dbo.Rechnungen r ON k.KundenNr = r.KundenNr

LEFT JOIN dbo.Zahlungen z ON r.RechnungsID = z.RechnungsID

GROUP BY k.KundenNr, k.Branche, k.Groessenklasse;

-- Lager-Features für Nachbestellpunkt-Berechnung

CREATE OR ALTER VIEW ml.V_Lager_Features AS

SELECT

    l.ArtikelNr,

    -- Durchschnittlicher täglicher Verbrauch

    SUM(v.Menge) / NULLIF(DATEDIFF(DAY,

        MIN(v.Buchungsdatum), MAX(v.Buchungsdatum)), 0) AS avg_tagesverbrauch,

    -- Variabilität des Verbrauchs (Standardabweichung)

    STDEV(tages_v.tages_menge)                          AS stdev_tagesverbrauch,

    -- Lieferzeit aus Bestellhistorie

    AVG(DATEDIFF(DAY, b.Bestelldatum,

        b.Wareneingangsdatum))                          AS avg_lieferzeit_tage,

    MAX(DATEDIFF(DAY, b.Bestelldatum,

        b.Wareneingangsdatum))                          AS max_lieferzeit_tage,

    -- Aktueller Bestand

    l.AktuellerBestand,

    l.Meldebestand                                      AS aktueller_meldebestand

FROM dbo.Lagerbestand l

JOIN dbo.Lagerbewegungen v ON l.ArtikelNr = v.ArtikelNr

    AND v.BewegungsTyp = 'ABGANG'

JOIN dbo.Bestellungen b ON l.ArtikelNr = b.ArtikelNr

    AND b.Wareneingangsdatum IS NOT NULL

CROSS APPLY (

    SELECT CAST(Buchungsdatum AS DATE) AS tag,

           SUM(Menge) AS tages_menge

    FROM dbo.Lagerbewegungen

    WHERE ArtikelNr = l.ArtikelNr AND BewegungsTyp = 'ABGANG'

    GROUP BY CAST(Buchungsdatum AS DATE)

) tages_v

GROUP BY l.ArtikelNr, l.AktuellerBestand, l.Meldebestand;

-- Maschinensensor-Features für Predictive Maintenance

CREATE OR ALTER VIEW ml.V_Maintenance_Features AS

SELECT

    s.MaschinenID,

    s.MessZeitpunkt,

    -- Aktuelle Sensorwerte

    s.Temperatur_C,

    s.Vibration_mm_s,

    s.Druck_bar,

    s.Laufzeit_h,

    -- Abweichung vom Normalbereich (z-Score vereinfacht)

    (s.Temperatur_C - avg_t.avg_temp) /

        NULLIF(avg_t.std_temp, 0)                       AS temp_zscore,

    -- Trendfeature: Temperaturanstieg letzte Stunde

    s.Temperatur_C - LAG(s.Temperatur_C, 60) OVER

        (PARTITION BY s.MaschinenID ORDER BY s.MessZeitpunkt) AS temp_delta_1h,

    -- Betriebsstunden seit letzter Wartung

    DATEDIFF(HOUR, w.LetzteWartung,

        s.MessZeitpunkt)                                AS stunden_seit_wartung,

    -- Label: Ausfall innerhalb der nächsten 24 Stunden

    CASE WHEN EXISTS (

        SELECT 1 FROM dbo.Ausfaelle a

        WHERE a.MaschinenID = s.MaschinenID

          AND a.AusfallZeitpunkt BETWEEN s.MessZeitpunkt

              AND DATEADD(HOUR,24,s.MessZeitpunkt)

    ) THEN 1 ELSE 0 END                                AS ausfall_24h_label

FROM dbo.Sensordaten s

CROSS JOIN (

    SELECT AVG(Temperatur_C) AS avg_temp,

           STDEV(Temperatur_C) AS std_temp

    FROM dbo.Sensordaten

) avg_t

LEFT JOIN dbo.Wartungshistorie w ON s.MaschinenID = w.MaschinenID

    AND w.LetzteWartung = (

        SELECT MAX(LetzteWartung) FROM dbo.Wartungshistorie

        WHERE MaschinenID = s.MaschinenID

          AND LetzteWartung <= s.MessZeitpunkt

    );

# Korrekter Train/Test-Split für tabellarische Daten

from sklearn.model_selection import train_test_split

X = df.drop('churn_label', axis=1)

y = df['churn_label']

# Zeitreihen: NICHT zufällig splitten

# X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)  # FALSCH bei Zeitreihen

# Korrekter zeitbasierter Split

df_sorted = df.sort_values('datum')

split_idx = int(len(df_sorted) * 0.8)

X_train = df_sorted.iloc[:split_idx].drop('churn_label', axis=1)

X_test  = df_sorted.iloc[split_idx:].drop('churn_label', axis=1)

y_train = df_sorted.iloc[:split_idx]['churn_label']

y_test  = df_sorted.iloc[split_idx:]['churn_label']

from sklearn.ensemble import GradientBoostingClassifier

from sklearn.metrics import classification_report, roc_auc_score

# class_weight='balanced' kompensiert Ungleichgewicht automatisch

model = GradientBoostingClassifier(

    n_estimators=200,

    max_depth=4,

    learning_rate=0.05,

    random_state=42

)

# Für GBM: sample_weight beim fit übergeben

import numpy as np

class_weights = len(y_train) / (2 * np.bincount(y_train))

sample_weights = class_weights[y_train]

model.fit(X_train, y_train, sample_weight=sample_weights)

# Immer mehrere Metriken ausgeben

y_pred = model.predict(X_test)

y_prob = model.predict_proba(X_test)[:,1]

print(classification_report(y_test, y_pred))

print(f"AUC-ROC: {roc_auc_score(y_test, y_prob):.3f}")

-- Data-Leakage-Check: Features zeitlich korrekt begrenzen

-- FALSCH: Gesamtumsatz des Kunden (enthält zukünftige Käufe)

-- SUM(Nettobetrag) AS umsatz_gesamt  -- LEAKAGE!

-- RICHTIG: Umsatz bis zum Vorhersage-Stichtag begrenzen

DECLARE @Stichtag DATE = '2025-06-30';  -- Vorhersage-Zeitpunkt

SELECT KundenNr,

    SUM(CASE WHEN Bestelldatum <= @Stichtag

             THEN Nettobetrag ELSE 0 END) AS umsatz_bis_stichtag,

    -- Label: Verhalten NACH dem Stichtag

    CASE WHEN MAX(Bestelldatum) < DATEADD(DAY,90,@Stichtag)

         THEN 1 ELSE 0 END AS churn_label_90tage

FROM dbo.Bestellungen

GROUP BY KundenNr;

import shap

# SHAP-Werte berechnen (funktioniert für alle Tree-Modelle)

explainer = shap.TreeExplainer(model)

shap_values = explainer.shap_values(X_test)

# Top-3-Features für jeden Kunden zurückgeben

import pandas as pd

shap_df = pd.DataFrame(shap_values, columns=X_test.columns)

top3_features = shap_df.abs().apply(

    lambda row: row.nlargest(3).index.tolist(), axis=1

)

# In SQL Server zurückschreiben für Power BI

import joblib, datetime

# Modell persistieren mit Versionsstempel

version = datetime.date.today().strftime('%Y%m%d')

model_path = f'models/churn_model_{version}.pkl'

joblib.dump(model, model_path)

print(f"Modell gespeichert: {model_path}")

# Metadaten in SQL Server loggen

# INSERT INTO dbo.ML_Modelle (Version, Pfad, AUC_Test, TrainingsDatum, Features)

# VALUES (@version, @path, @auc, GETDATE(), @feature_list)

from sklearn.metrics import precision_recall_curve

import matplotlib.pyplot as plt

precisions, recalls, thresholds = precision_recall_curve(y_test, y_prob)

# Optimalen Schwellenwert für F1-Maximum finden

f1_scores = 2 * (precisions * recalls) / (precisions + recalls + 1e-8)

best_threshold = thresholds[f1_scores[:-1].argmax()]

print(f"Optimaler Schwellenwert: {best_threshold:.3f}")

print(f"Precision: {precisions[f1_scores[:-1].argmax()]:.3f}")

print(f"Recall:    {recalls[f1_scores[:-1].argmax()]:.3f}")

-- Logistische Regression als SQL-Funktion (Koeffizienten aus Training)

-- Koeffizienten werden einmalig in Python trainiert, dann hier hinterlegt

CREATE OR ALTER FUNCTION dbo.FN_Churn_Score (

    @recency_tage        FLOAT,

    @frequency_12m       FLOAT,

    @monetary_12m        FLOAT,

    @umsatz_trend_q      FLOAT,

    @support_tickets_6m  FLOAT,

    @warengruppen_anzahl FLOAT

)

RETURNS FLOAT

AS

BEGIN

    -- Koeffizienten aus Python-Training (einmalig aktualisieren)

    DECLARE @intercept  FLOAT = -1.24;

    DECLARE @b_recency  FLOAT =  0.031;   -- positiv: länger weg = mehr Risiko

    DECLARE @b_freq     FLOAT = -0.18;   -- negativ: mehr Käufe = weniger Risiko

    DECLARE @b_monetary FLOAT = -0.0002;

    DECLARE @b_trend    FLOAT = -0.00015;

    DECLARE @b_support  FLOAT =  0.42;   -- positiv: Tickets = Unzufriedenheit

    DECLARE @b_breite   FLOAT = -0.29;

    DECLARE @logit FLOAT =

        @intercept

        + @b_recency  * @recency_tage

        + @b_freq     * @frequency_12m

        + @b_monetary * @monetary_12m

        + @b_trend    * @umsatz_trend_q

        + @b_support  * @support_tickets_6m

        + @b_breite   * @warengruppen_anzahl;

    -- Sigmoid-Funktion: Wahrscheinlichkeit zwischen 0 und 1

    RETURN 1.0 / (1.0 + EXP(-@logit));

END

-- Alle Kunden täglich scoreen

SELECT

    k.KundenNr,

    k.Name,

    f.recency_tage,

    f.support_tickets_6m,

    dbo.FN_Churn_Score(

        f.recency_tage, f.frequency_12m, f.monetary_12m,

        f.umsatz_trend_q, f.support_tickets_6m, f.warengruppen_anzahl

    ) AS churn_wahrscheinlichkeit,

    CASE WHEN dbo.FN_Churn_Score(

        f.recency_tage, f.frequency_12m, f.monetary_12m,

        f.umsatz_trend_q, f.support_tickets_6m, f.warengruppen_anzahl

    ) > 0.35 THEN 'RISIKO' ELSE 'OK' END AS churn_status

FROM dbo.Kunden k

JOIN ml.V_Churn_Features f ON k.KundenNr = f.KundenNr;

-- Python direkt in SQL Server ausführen (ML Services aktiviert)

-- Einmalige Aktivierung: sp_configure 'external scripts enabled', 1; RECONFIGURE;

EXEC sp_execute_external_script

    @language = N'Python',

    @script = N'

import pandas as pd

import joblib

# Modell aus Dateisystem laden

model = joblib.load("C:\\MLModels\\churn_model_20260301.pkl")

# Vorhersagen auf Input-Daten

features = InputDataSet[[

    "recency_tage","frequency_12m","monetary_12m",

    "umsatz_trend_q","support_tickets_6m","warengruppen_anzahl"

]].fillna(0)

InputDataSet["churn_score"]  = model.predict_proba(features)[:,1]

InputDataSet["churn_risiko"] = (InputDataSet["churn_score"] > 0.35).astype(int)

OutputDataSet = InputDataSet[["KundenNr","churn_score","churn_risiko"]]

    ',

    @input_data_1 = N'SELECT * FROM ml.V_Churn_Features',

    @input_data_1_name = N'InputDataSet',

    @output_data_1_name = N'OutputDataSet'

WITH RESULT SETS ((KundenNr INT, churn_score FLOAT, churn_risiko INT));

-- Täglicher SQL Agent Job: Scores berechnen und speichern

CREATE OR ALTER PROCEDURE dbo.ML_Lade_Churn_Scores AS

BEGIN

    TRUNCATE TABLE dbo.ML_Churn_Scores_Aktuell;

    INSERT INTO dbo.ML_Churn_Scores_Aktuell (KundenNr, ChurnScore, ChurnRisiko, BerechnungsDatum)

    SELECT

        KundenNr,

        dbo.FN_Churn_Score(recency_tage, frequency_12m, monetary_12m,

            umsatz_trend_q, support_tickets_6m, warengruppen_anzahl),

        CASE WHEN dbo.FN_Churn_Score(recency_tage, frequency_12m, monetary_12m,

            umsatz_trend_q, support_tickets_6m, warengruppen_anzahl) > 0.35

             THEN 1 ELSE 0 END,

        CAST(GETDATE() AS DATE)

    FROM ml.V_Churn_Features;

    -- Historische Scores für Trendanalyse archivieren

    INSERT INTO dbo.ML_Churn_Scores_Historie

    SELECT * FROM dbo.ML_Churn_Scores_Aktuell;

END

import pandas as pd

import numpy as np

import pyodbc

import joblib

from sklearn.ensemble import GradientBoostingClassifier

from sklearn.model_selection import train_test_split, cross_val_score

from sklearn.preprocessing import StandardScaler

from sklearn.pipeline import Pipeline

from sklearn.metrics import classification_report, roc_auc_score

import datetime

# ── 1. Daten aus SQL Server laden ────────────────────────────────────────────

conn = pyodbc.connect(

    "DRIVER={ODBC Driver 18 for SQL Server};"

    "SERVER=MEIN-SERVER;DATABASE=DWH;Trusted_Connection=yes"

)

df = pd.read_sql("SELECT * FROM ml.V_Churn_Features", conn)

conn.close()

feature_cols = [

    "recency_tage","frequency_12m","monetary_12m",

    "umsatz_trend_q","support_tickets_6m","warengruppen_anzahl"

]

X = df[feature_cols].fillna(0)

y = df["churn_label"]

# ── 2. Zeitbasierter Split (neueste 20% als Test) ────────────────────────────

split = int(len(X) * 0.8)

X_train, X_test = X.iloc[:split], X.iloc[split:]

y_train, y_test = y.iloc[:split], y.iloc[split:]

# ── 3. Pipeline: Scaler + Modell ─────────────────────────────────────────────

class_weights = len(y_train) / (2 * np.bincount(y_train.values))

sample_weights = class_weights[y_train.values]

pipeline = Pipeline([

    ("scaler", StandardScaler()),

    ("model",  GradientBoostingClassifier(

        n_estimators=200, max_depth=4,

        learning_rate=0.05, random_state=42

    ))

])

pipeline.fit(X_train, y_train, model__sample_weight=sample_weights)

# ── 4. Evaluation ────────────────────────────────────────────────────────────

y_pred = pipeline.predict(X_test)

y_prob = pipeline.predict_proba(X_test)[:,1]

print("=== Modell-Evaluation ===")

print(classification_report(y_test, y_pred, target_names=["Aktiv","Churn"]))

print(f"AUC-ROC: {roc_auc_score(y_test, y_prob):.3f}")

# ── 5. Modell speichern ──────────────────────────────────────────────────────

version = datetime.date.today().strftime('%Y%m%d')

joblib.dump(pipeline, f"models/churn_{version}.pkl")

print(f"Modell gespeichert: churn_{version}.pkl")

from prophet import Prophet

import pandas as pd

import pyodbc

# Artikelumsatz für Prognose laden

conn = pyodbc.connect("DRIVER={ODBC Driver 18 for SQL Server};"

    "SERVER=MEIN-SERVER;DATABASE=DWH;Trusted_Connection=yes")

df = pd.read_sql("""

    SELECT CAST(Bestelldatum AS DATE) AS ds,

           SUM(Nettobetrag)           AS y

    FROM dbo.Bestellpositionen

    WHERE ArtikelNr = 'ART-0042'

    GROUP BY CAST(Bestelldatum AS DATE)

    ORDER BY ds

""", conn)

# Prophet erwartet Spalten 'ds' (Datum) und 'y' (Zielwert)

model = Prophet(

    seasonality_mode='multiplicative',   # bei starker Saisonalität

    yearly_seasonality=True,

    weekly_seasonality=True,

    changepoint_prior_scale=0.05         # Konservativer Trend-Wechsel

)

model.fit(df)

# Prognose 12 Wochen voraus

future   = model.make_future_dataframe(periods=84)   # 84 Tage = 12 Wochen

forecast = model.predict(future)

# Ergebnis in SQL Server zurückschreiben

result = forecast[['ds','yhat','yhat_lower','yhat_upper']].tail(84)

result.columns = ['Datum','Prognose','Prognose_Min','Prognose_Max']

result['ArtikelNr'] = 'ART-0042'

result['BerechnungsDatum'] = pd.Timestamp.today()

result.to_sql('ML_Absatzprognose', conn, schema='dbo',

              if_exists='append', index=False)

print(f"Prognose für 84 Tage geschrieben: {len(result)} Zeilen")

from azure.ai.ml import MLClient

from azure.ai.ml.automl import classification

from azure.ai.ml.entities import Data

from azure.identity import DefaultAzureCredential

# Verbindung zu Azure ML Workspace

ml_client = MLClient(

    DefaultAzureCredential(),

    subscription_id  = "IHRE-SUBSCRIPTION-ID",

    resource_group   = "ihre-resource-group",

    workspace_name   = "ihr-ml-workspace"

)

# AutoML Klassifikations-Job konfigurieren

automl_job = classification(

    compute      = "cpu-cluster",

    experiment_name = "churn-prediction-2026",

    training_data   = ml_client.data.get("churn-features", version="latest"),

    target_column_name = "churn_label",

    primary_metric     = "AUC_weighted",

    # Suchraum begrenzen für schnellere Ergebnisse im KMU

    allowed_training_algorithms = [

        "GradientBoosting","RandomForest","LightGBM","LogisticRegression"

    ],

    enable_model_explainability = True,   # SHAP-Werte automatisch

    enable_stack_ensemble       = False,  # Für KMU meist nicht nötig

    max_trials = 20,                      # Max. Algorithmen testen

    timeout_minutes = 60

)

returned_job = ml_client.jobs.create_or_update(automl_job)

print(f"Job gestartet: {returned_job.name}")

AUTOML VS. MANUELLE PIPELINE

■  AutoML eignet sich für: schnellen Proof of Concept, Teams ohne ML-Erfahrung, initiale Modellauswahl.

■  Manuelle Pipeline eignet sich für: Production-Grade Deployment, benutzerdefiniertes Feature Engineering, strenge Governance-Anforderungen, Modelle die häufig neu trainiert werden.

■  Empfehlung: AutoML für den Einstieg und die Algorithmuswahl, dann manuell nachbauen und optimieren.

-- Power BI Basis-View: Kunden mit Scores und Handlungsempfehlung

CREATE OR ALTER VIEW rpt.V_Churn_Dashboard AS

SELECT

    k.KundenNr,

    k.Name,

    k.Vertriebsmitarbeiter,

    k.Region,

    k.Jahresumsatz,

    s.ChurnScore,

    CASE

        WHEN s.ChurnScore >= 0.60 THEN 'KRITISCH'

        WHEN s.ChurnScore >= 0.35 THEN 'WARNUNG'

        ELSE 'STABIL'

    END AS RisikoKlasse,

    CASE

        WHEN s.ChurnScore >= 0.60 THEN

            'Sofort kontaktieren: ' +

            CASE WHEN f.support_tickets_6m > 2 THEN 'Support-Probleme klären. '

                 WHEN f.recency_tage > 60 THEN 'Letzte Bestellung vor ' +

                    CAST(f.recency_tage AS VARCHAR) + ' Tagen. '

                 WHEN f.umsatz_trend_q < -500 THEN 'Umsatzrückgang erkannt. '

                 ELSE 'Persönliches Gespräch vereinbaren. ' END

        WHEN s.ChurnScore >= 0.35 THEN 'Reaktivierungsangebot prüfen'

        ELSE 'Kein Handlungsbedarf'

    END AS Handlungsempfehlung,

    f.recency_tage,

    f.frequency_12m,

    f.support_tickets_6m,

    s.BerechnungsDatum

FROM dbo.Kunden k

JOIN dbo.ML_Churn_Scores_Aktuell s ON k.KundenNr = s.KundenNr

JOIN ml.V_Churn_Features f ON k.KundenNr = f.KundenNr;

-- Absatzprognose-View mit Konfidenzintervall und Vergleich zu Vorjahr

CREATE OR ALTER VIEW rpt.V_Absatzprognose_Dashboard AS

SELECT

    p.ArtikelNr,

    a.Bezeichnung,

    a.Warengruppe,

    p.Datum,

    p.Prognose,

    p.Prognose_Min,

    p.Prognose_Max,

    -- Vergleich mit Vorjahr

    hist.IstMenge AS VorjahresMenge,

    ROUND((p.Prognose - hist.IstMenge) /

        NULLIF(hist.IstMenge,0) * 100, 1)   AS VeraenderungVJ_Pct,

    -- Ampel: Prognose weicht stark von Vorjahr ab

    CASE

        WHEN ABS((p.Prognose - hist.IstMenge) / NULLIF(hist.IstMenge,0)) > 0.3

        THEN 'PRÜFEN'

        ELSE 'PLAUSIBEL'

    END AS Plausibilitaet,

    p.BerechnungsDatum

FROM dbo.ML_Absatzprognose p

JOIN dbo.Artikel a ON p.ArtikelNr = a.ArtikelNr

LEFT JOIN (

    SELECT ArtikelNr,

           CAST(DATEADD(YEAR,1,Bestelldatum) AS DATE) AS Datum,

           SUM(Menge) AS IstMenge

    FROM dbo.Bestellpositionen

    GROUP BY ArtikelNr, CAST(DATEADD(YEAR,1,Bestelldatum) AS DATE)

) hist ON p.ArtikelNr = hist.ArtikelNr AND p.Datum = hist.Datum

WHERE p.Datum >= CAST(GETDATE() AS DATE);

-- Zentrale Modell-Verwaltung ohne externe MLOps-Plattform

CREATE TABLE dbo.ML_Modelle (

    ModellID       INT IDENTITY PRIMARY KEY,

    ModellName     NVARCHAR(100),         -- 'churn_gradient_boosting'

    Version        NVARCHAR(20),          -- '20260301'

    Anwendungsfall NVARCHAR(100),         -- 'Churn-Vorhersage'

    Algorithmus    NVARCHAR(100),         -- 'GradientBoostingClassifier'

    Features       NVARCHAR(MAX),         -- JSON: Feature-Liste

    AUC_Train      DECIMAL(5,4),

    AUC_Test       DECIMAL(5,4),

    TrainingsDatum DATETIME2,

    TrainingsZeilen INT,

    ModelDatei     NVARCHAR(500),         -- Pfad zur .pkl-Datei

    Status         NVARCHAR(20) DEFAULT 'KANDIDAT', -- KANDIDAT/AKTIV/ARCHIV

    Notizen        NVARCHAR(MAX)

);

-- Monitoring-Tabelle: monatliche Performance-Messung

CREATE TABLE dbo.ML_Monitoring (

    MonitoringID   INT IDENTITY PRIMARY KEY,

    ModellID       INT REFERENCES dbo.ML_Modelle(ModellID),

    MessDatum      DATE,

    AUC_Aktuell    DECIMAL(5,4),

    Precision_Aktuell DECIMAL(5,4),

    Recall_Aktuell    DECIMAL(5,4),

    AnzahlVorhersagen INT,

    DriftScore     DECIMAL(5,4),  -- Population Stability Index

    Status         NVARCHAR(20),  -- OK / WARNUNG / KRITISCH

    Kommentar      NVARCHAR(500)

);

import pyodbc, joblib, pandas as pd

from sklearn.metrics import roc_auc_score

from scipy.stats import ks_2samp  # Datendrift-Test

def monitor_modell(modell_id: int, server: str, database: str):

    conn = pyodbc.connect(f"DRIVER={{ODBC Driver 18 for SQL Server}};"

                          f"SERVER={server};DATABASE={database};Trusted_Connection=yes")

    # Aktives Modell laden

    meta = pd.read_sql(

        f"SELECT * FROM dbo.ML_Modelle WHERE ModellID={modell_id}", conn

    ).iloc[0]

    model = joblib.load(meta['ModelDatei'])

    # Aktuelle Daten mit Ground Truth (Kunden die inzwischen churned sind)

    df_aktuell = pd.read_sql("""

        SELECT f.*, CASE WHEN MAX(b.Bestelldatum) < DATEADD(DAY,-90,GETDATE())

                         THEN 1 ELSE 0 END AS churn_label_ist

        FROM ml.V_Churn_Features f

        LEFT JOIN dbo.Bestellungen b ON f.KundenNr = b.KundenNr

        GROUP BY f.KundenNr, f.recency_tage, f.frequency_12m,

                 f.monetary_12m, f.umsatz_trend_q,

                 f.support_tickets_6m, f.warengruppen_anzahl

    """, conn)

    feature_cols = ["recency_tage","frequency_12m","monetary_12m",

                    "umsatz_trend_q","support_tickets_6m","warengruppen_anzahl"]

    X = df_aktuell[feature_cols].fillna(0)

    y = df_aktuell["churn_label_ist"]

    # AUC auf aktuellen Daten

    y_prob   = model.predict_proba(X)[:,1]

    auc_neu  = roc_auc_score(y, y_prob)

    auc_basis = meta['AUC_Test']

    # Datendrift: KS-Test auf Recency (wichtigstes Feature)

    df_train  = pd.read_sql("SELECT recency_tage FROM ml.V_Churn_Features_Train", conn)

    ks_stat, _ = ks_2samp(df_train['recency_tage'], df_aktuell['recency_tage'])

    # Status bestimmen

    delta = auc_basis - auc_neu

    status = 'OK' if delta < 0.05 else ('WARNUNG' if delta < 0.10 else 'KRITISCH')

    # In Monitoring-Tabelle schreiben

    cursor = conn.cursor()

    cursor.execute("""

        INSERT INTO dbo.ML_Monitoring

            (ModellID, MessDatum, AUC_Aktuell, AnzahlVorhersagen, DriftScore, Status, Kommentar)

        VALUES (?,CAST(GETDATE() AS DATE),?,?,?,?,?)

    """, modell_id, round(auc_neu,4), len(X), round(ks_stat,4), status,

         f"AUC-Delta: {delta:.3f}, KS-Drift: {ks_stat:.3f}")

    conn.commit()

    if status == 'KRITISCH':

        print(f"ALARM: Modell {meta['ModellName']} degradiert! "

              f"AUC {auc_basis:.3f} → {auc_neu:.3f}")

    return status

Risikoklassifizierung

Pflicht

Nicht nötig

Datenschutzbeauftragten einbeziehen

Technische Dokumentation

Pflicht

Empfohlen

ML_Modelle-Tabelle + README

Menschliche Aufsicht

Pflicht

Best Practice

Keine vollautomatischen Entscheidungen

Datenqualitätsprüfung

Pflicht

Best Practice

DQ-Framework aus Kit 2

Logging & Monitoring

Pflicht

Best Practice

ML_Monitoring-Tabelle

Erklärbarkeit

Pflicht

Best Practice

SHAP-Werte in Power BI

HOCHRISIKO-KI IM KMU

Vorhersagemodelle für Absatz, Lager und technische Wartung sind in der Regel KEIN Hochrisiko-KI. Modelle, die Personalentscheidungen, Kreditvergaben oder Zugang zu Dienstleistungen beeinflussen, können Hochrisiko sein. Im Zweifel: Datenschutzbeauftragten und ggf. Rechtsberatung einbeziehen.

VOR DEM START

Wählen Sie einen einzigen Anwendungsfall für den Start — idealerweise Churn oder Absatzprognose, da hier die Datenlage in den meisten KMU bereits gut ist. Benennen Sie einen Fachsponsor aus dem Business, der den ROI bewertet. Prüfen Sie, ob ML Services in SQL Server aktiviert werden können.

ERGEBNIS NACH 30 TAGEN

Ihr Ergebnis nach 30 Tagen: Ein produktiv laufendes Vorhersagemodell mit täglicher automatischer Aktualisierung, einem Power-BI-Dashboard mit Handlungsempfehlungen, einem Governance-Framework für zukünftige Modelle und einem Fachbereich, der Vorhersagen versteht und nutzt.

Predictive Analytics Einstieg

Aufbau des ersten produktiven Vorhersagemodells für Ihr KMU — von der Datenanalyse bis zum Power-BI-Dashboard. Scope: 4-6 Wochen.

BI-Dashboard-Aufbau

Power BI / DeltaMaster Dashboards inkl. ETL-Strecken, Data-Warehouse-Aufbau und ML-Integration — für KMU ab 1 Woche Projektumfang.

SQL Server DB Health Check

Professioneller Audit Ihres SQL Servers — Managementreport, Risikobewertung und Maßnahmenplan. Scope: 3-5 Tage.

KI-Readiness Assessment

Bewertung Ihrer Datenqualität, Systemlandschaft und Prozessreife für den KI-Einstieg — mit konkretem Fahrplan und AI Act Compliance Check.

Interim IT-Management

Übernahme der IT-Steuerung auf Zeit — Budgetplanung, Dienstleister-Management, strategische IT-Ausrichtung.