Reifenverschleiß-Prediction:
Wann wird es teuer?

import pandas as pd
import numpy as np
from datetime import datetime, timedelta

np.random.seed(2024)

# --- Fahrzeugflotte ---
LKW_COUNT = 150
POSITIONEN = ['VL', 'VR', 'HL1', 'HL2', 'HR1', 'HR2',
              'AL1', 'AL2', 'AR1', 'AR2']  # V=Vorne, H=Hinten, A=Auflieger

# Streckenprofile: Jeder LKW hat ein dominantes Streckenprofil
streckenprofile = {
    'Autobahn-dominiert':  {'ab_anteil': 0.75, 'verschleiss_faktor': 0.85},
    'Mischverkehr':        {'ab_anteil': 0.50, 'verschleiss_faktor': 1.00},
    'Stadt-/Verteiler':    {'ab_anteil': 0.20, 'verschleiss_faktor': 1.35},
    'Bergstrecken':        {'ab_anteil': 0.55, 'verschleiss_faktor': 1.25},
}

fahrzeuge = []
for i in range(LKW_COUNT):
    profil = np.random.choice(list(streckenprofile.keys()),
                               p=[0.35, 0.30, 0.25, 0.10])
    fahrzeuge.append({
        'lkw_id': f'LKW-{i+1:03d}',
        'streckenprofil': profil,
        'km_pro_woche': np.random.normal(2200, 400),
        'avg_beladung_t': np.random.normal(18, 4),
        'avg_geschwindigkeit': np.random.normal(72, 8),
        'bremsvorgaenge_pro_100km': np.random.normal(45, 15),
        'reifenmarke': np.random.choice(['Michelin', 'Continental',
                        'Bridgestone', 'Goodyear', 'Pirelli']),
    })

# --- Wochenweise Verschleißsimulation ---
records = []
for fzg in fahrzeuge:
    profil = streckenprofile[fzg['streckenprofil']]
    for pos in POSITIONEN:
        # Position beeinflusst Verschleiß: Lenkachse > Antriebsachse > Auflieger
        pos_faktor = 1.0
        if pos.startswith('V'): pos_faktor = 1.15    # Lenkung
        elif pos.startswith('H'): pos_faktor = 1.10  # Antrieb
        else: pos_faktor = 0.90                     # Auflieger

        profiltiefe = 8.0  # mm Neuzustand
        reifen_alter_wochen = np.random.randint(0, 30)

        for woche in range(52):
            km = fzg['km_pro_woche'] * np.random.uniform(0.7, 1.3)
            beladung = fzg['avg_beladung_t'] * np.random.uniform(0.6, 1.2)

            # Verschleißformel: f(km, beladung, profil, position, alter)
            verschleiss_mm = (
                km / 1000
                * 0.035
                * profil['verschleiss_faktor']
                * pos_faktor
                * (1 + beladung / 100)
                * (1 + reifen_alter_wochen * 0.002)
                * np.random.lognormal(0, 0.12)
            )

            profiltiefe = max(0.5, profiltiefe - verschleiss_mm)
            reifen_alter_wochen += 1
            datum = datetime(2024, 1, 1) + timedelta(weeks=woche)

            records.append({
                'datum': datum.date(),
                'kw': woche + 1,
                'lkw_id': fzg['lkw_id'],
                'position': pos,
                'streckenprofil': fzg['streckenprofil'],
                'reifenmarke': fzg['reifenmarke'],
                'km_woche': round(km),
                'beladung_t': round(beladung, 1),
                'bremsvorgaenge': int(fzg['bremsvorgaenge_pro_100km']
                                     * km / 100),
                'profiltiefe_mm': round(profiltiefe, 2),
                'reifen_alter_wochen': reifen_alter_wochen,
            })

            # Reifenwechsel wenn unter 3mm (gesetzl. Minimum: 1.6mm)
            if profiltiefe < 3.0:
                profiltiefe = 8.0
                reifen_alter_wochen = 0

df = pd.DataFrame(records)
print(f"Dataset: {len(df):,} Messwerte")
print(f"Fahrzeuge: {df['lkw_id'].nunique()}")
print(f"Reifenwechsel erkannt: {(df['profiltiefe_mm'] == 8.0).sum():,}")

# Verschleißrate berechnen: mm/1000km pro Position & Profil
df['verschleiss_rate'] = df.groupby(['lkw_id','position'])['profiltiefe_mm'].diff().abs()
df['rate_per_1000km'] = df['verschleiss_rate'] / (df['km_woche'] / 1000)

# Durchschnittliche Verschleißrate nach Streckenprofil
profil_rates = df.groupby('streckenprofil')['rate_per_1000km'].mean()
print("Ø Verschleiß (mm/1000km) nach Streckenprofil:")
print(profil_rates.sort_values(ascending=False).round(3))

# Durchschnittliche Verschleißrate nach Position
pos_rates = df.groupby('position')['rate_per_1000km'].mean()
print("\nØ Verschleiß (mm/1000km) nach Position:")
print(pos_rates.sort_values(ascending=False).round(3))

# Korrelation: Beladung → Verschleiß
corr = df[['beladung_t','rate_per_1000km','bremsvorgaenge','km_woche']].corr()
print("\nKorrelationsmatrix:")
print(corr.round(3))

from sklearn.preprocessing import LabelEncoder, StandardScaler

# --- Kernfrage: Fällt dieser Reifen in den nächsten 4 Wochen unter 3mm? ---
# → Regression: Vorhergesagte Profiltiefe in 4 Wochen
# → Klassifikation: Wechsel nötig ja/nein

# Rolling Features: Verschleiß-Trend der letzten 8 Wochen
df['verschleiss_trend_8w'] = df.groupby(['lkw_id','position'])['rate_per_1000km'].transform(
    lambda x: x.rolling(8, min_periods=2).mean()
)

# Verschleißbeschleunigung: Wird es schneller schlimmer?
df['verschleiss_accel'] = df.groupby(['lkw_id','position'])['verschleiss_trend_8w'].transform(
    lambda x: x.diff(4)
)

# Verbleibende Restprofiltiefe über Grenze
df['reserve_mm'] = df['profiltiefe_mm'] - 3.0

# Geschätzte Restlaufzeit (Wochen) bei aktuellem Trend
df['est_restlaufzeit_wo'] = np.where(
    df['verschleiss_trend_8w'] > 0,
    df['reserve_mm'] / df['verschleiss_trend_8w'] / df['km_woche'] * 1000,
    99
)

# Encoding
le_profil = LabelEncoder()
le_marke = LabelEncoder()
le_pos = LabelEncoder()
df['profil_enc'] = le_profil.fit_transform(df['streckenprofil'])
df['marke_enc'] = le_marke.fit_transform(df['reifenmarke'])
df['pos_enc'] = le_pos.fit_transform(df['position'])

features = [
    'profiltiefe_mm', 'reifen_alter_wochen', 'km_woche',
    'beladung_t', 'bremsvorgaenge',
    'profil_enc', 'marke_enc', 'pos_enc',
    'verschleiss_trend_8w', 'verschleiss_accel',
    'reserve_mm', 'est_restlaufzeit_wo', 'kw'
]

# Target: Profiltiefe in 4 Wochen
df['target_4w'] = df.groupby(['lkw_id','position'])['profiltiefe_mm'].shift(-4)
df['wechsel_4w'] = (df['target_4w'] < 3.0).astype(int)

print(f"Feature-Matrix: {len(features)} Features")
print(f"Positive Klasse (Wechsel nötig): {df['wechsel_4w'].mean()*100:.1f}%")

import xgboost as xgb
from sklearn.model_selection import TimeSeriesSplit
from sklearn.metrics import (precision_score, recall_score,
                              f1_score, roc_auc_score)

# --- Train/Test Split: Zeitlich (letzte 8 Wochen = Test) ---
train = df[df['kw'] <= 44].dropna(subset=['target_4w'])
test = df[(df['kw'] > 44) & (df['kw'] <= 48)].dropna(subset=['target_4w'])

X_train, y_train = train[features], train['wechsel_4w']
X_test, y_test = test[features], test['wechsel_4w']

# --- XGBoost mit Class-Imbalance-Handling ---
scale_pos = (y_train == 0).sum() / (y_train == 1).sum()

model = xgb.XGBClassifier(
    n_estimators=300,
    max_depth=6,
    learning_rate=0.05,
    subsample=0.8,
    colsample_bytree=0.8,
    scale_pos_weight=scale_pos,
    eval_metric='aucpr',
    early_stopping_rounds=20,
    use_label_encoder=False,
    random_state=42
)

model.fit(
    X_train, y_train,
    eval_set=[(X_test, y_test)],
    verbose=50
)

# --- Evaluation ---
y_pred = model.predict(X_test)
y_prob = model.predict_proba(X_test)[:, 1]

print(f"Precision: {precision_score(y_test, y_pred):.3f}")
print(f"Recall:    {recall_score(y_test, y_pred):.3f}")
print(f"F1-Score:  {f1_score(y_test, y_pred):.3f}")
print(f"AUC-ROC:   {roc_auc_score(y_test, y_prob):.3f}")

# === KOSTEN-MODELL: Reaktiv vs. Prädiktiv ===

# Reaktiver Ansatz (Status quo)
kosten_reaktiv = {
    'zu_fruehe_wechsel': 0.15,    # 15% werden zu früh gewechselt
    'verschenktes_profil_mm': 1.5, # Ø 1.5mm Restprofil bei zu frühem Wechsel
    'pannen_pro_jahr': 12,       # Reifenbedingte Pannen/Jahr (150 LKW)
    'kosten_panne': 1800,        # Pannendienst + Standzeit + Folgekosten
    'ungeplante_werkstatt': 45,   # Ungeplante Werkstattbesuche/Jahr
    'kosten_ungeplant_extra': 280,# Mehrkosten vs. geplanter Wechsel
    'bussgelder': 8,              # Bußgelder/Jahr wegen Profil
    'bussgeld_schnitt': 375,     # Ø Bußgeld
}

# Prädiktiver Ansatz (mit Modell)
reifen_gesamt = 150 * 12  # 150 LKW × 12 Reifen/Jahr
kosten_reifen = 420         # Ø Kosten pro Reifen

# 1. Einsparung durch optimales Timing
zu_frueh = int(reifen_gesamt * kosten_reaktiv['zu_fruehe_wechsel'])
profil_wert_pro_mm = kosten_reifen / 5.0  # 8mm - 3mm = 5mm nutzbares Profil
ersparnis_timing = zu_frueh * kosten_reaktiv['verschenktes_profil_mm'] * profil_wert_pro_mm

# 2. Pannenvermeidung
pannen_vermieden = int(kosten_reaktiv['pannen_pro_jahr'] * 0.85)  # 85% vermeidbar
ersparnis_pannen = pannen_vermieden * kosten_reaktiv['kosten_panne']

# 3. Planbare Werkstattbesuche
ungeplant_vermieden = int(kosten_reaktiv['ungeplante_werkstatt'] * 0.80)
ersparnis_werkstatt = ungeplant_vermieden * kosten_reaktiv['kosten_ungeplant_extra']

# 4. Bußgeld-Vermeidung
ersparnis_bussgeld = kosten_reaktiv['bussgelder'] * kosten_reaktiv['bussgeld_schnitt']

# 5. Einkaufsoptimierung (Marken-Insights)
ersparnis_einkauf = reifen_gesamt * 0.08 * kosten_reifen  # 8% Einsparung durch bessere Markenwahl

total = ersparnis_timing + ersparnis_pannen + ersparnis_werkstatt + ersparnis_bussgeld + ersparnis_einkauf

print(f"Einsparung Timing:      €{ersparnis_timing:>10,.0f}")
print(f"Einsparung Pannen:      €{ersparnis_pannen:>10,.0f}")
print(f"Einsparung Werkstatt:   €{ersparnis_werkstatt:>10,.0f}")
print(f"Einsparung Bußgeld:     €{ersparnis_bussgeld:>10,.0f}")
print(f"Einsparung Einkauf:     €{ersparnis_einkauf:>10,.0f}")
print(f"{'─'*42}")
print(f"GESAMT JÄHRLICH:        €{total:>10,.0f}")