Order-volume forecasting:
What your customers will order next month

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

np.random.seed(606)

# --- Kundenprofile mit individuellem Bestellverhalten ---
kunden = []
branchen = ['Automotive', 'FMCG', 'Baustoffe', 'Pharma',
            'Chemie', 'Lebensmittel', 'E-Commerce', 'Maschinenbau']

for i in range(43):
    branche = np.random.choice(branchen)
    # Jeder Kunde hat individuelle Saisonalität
    saison_peak = np.random.choice(['Q1','Q2','Q3','Q4'],
        p=[0.15,0.20,0.25,0.40])  # Q4 häufigster Peak
    basis_auftraege_woche = np.random.uniform(8, 45)
    wochentag_muster = np.random.dirichlet(np.ones(5) * 2)  # Mo-Fr Verteilung

    kunden.append({
        'kunde_id': f'K-{i+1:03d}',
        'branche': branche,
        'basis_woche': basis_auftraege_woche,
        'saison_peak': saison_peak,
        'wochentag_muster': wochentag_muster,
        'trend': np.random.normal(0.002, 0.004),  # Wöchentlicher Trend
        'volatilitaet': np.random.uniform(0.10, 0.35),
    })

# --- 104 Wochen (2 Jahre) Auftragsdaten ---
records = []
start = datetime(2023, 1, 2)

for kunde in kunden:
    for woche in range(104):
        datum = start + timedelta(weeks=woche)
        monat = datum.month
        quartal = (monat - 1) // 3 + 1

        # Saisonalität
        saison_faktor = 1.0
        peak_q = int(kunde['saison_peak'][1])
        if quartal == peak_q: saison_faktor = 1.45
        elif abs(quartal - peak_q) == 1: saison_faktor = 1.15
        elif abs(quartal - peak_q) == 2: saison_faktor = 0.75

        # Trend
        trend_faktor = 1 + kunde['trend'] * woche

        # Wochenvolumen
        vol = kunde['basis_woche'] * saison_faktor * trend_faktor
        vol *= np.random.lognormal(0, kunde['volatilitaet'])
        vol = max(1, vol)

        # Aufschlüsselung nach Wochentag
        for wt in range(5):
            tages_vol = vol * kunde['wochentag_muster'][wt]
            auftraege = max(0, int(np.random.poisson(tages_vol)))
            if auftraege > 0:
                records.append({
                    'datum': (datum + timedelta(days=wt)).date(),
                    'kw': woche + 1,
                    'wochentag': wt,
                    'kunde_id': kunde['kunde_id'],
                    'branche': kunde['branche'],
                    'auftraege': auftraege,
                    'tonnen': round(auftraege * np.random.uniform(8, 22), 1),
                    'quartal': quartal,
                })

df = pd.DataFrame(records)
print(f"Aufträge: {df['auftraege'].sum():,}")
print(f"Kunden: {df['kunde_id'].nunique()}")
print(f"Zeitraum: {df['datum'].min()} bis {df['datum'].max()}")
print(f"Ø Aufträge/Woche: {df.groupby('kw')['auftraege'].sum().mean():.0f}")

from statsmodels.tsa.seasonal import seasonal_decompose

# Wöchentliche Aggregation (Gesamtflotte)
weekly = df.groupby('kw')['auftraege'].sum().reset_index()
weekly.columns = ['kw', 'auftraege']

# STL-Dekomposition: Trend + Saisonalität + Residuum
result = seasonal_decompose(
    weekly['auftraege'],
    model='multiplicative',
    period=52  # Jahres-Saisonalität
)

print("Trend-Stärke:", weekly['auftraege'].iloc[-12:].mean() /
                         weekly['auftraege'].iloc[:12].mean())
print("Saisonale Amplitude:",
      result.seasonal.max() / result.seasonal.min())

# Kunden-Level Dekomposition: Wer hat die stärkste Saisonalität?
kunde_saison = df.groupby(['kunde_id','quartal'])['auftraege'].sum().unstack()
kunde_saison['amplitude'] = kunde_saison.max(axis=1) / kunde_saison.min(axis=1)
print("\nTop 5 Kunden mit stärkster Saisonalität:")
print(kunde_saison.nlargest(5, 'amplitude')[['amplitude']])

import torch
import torch.nn as nn

class VolumeForecaster(nn.Module):
    """
    Multi-Target LSTM für Auftragsvolumen-Prognose.
    Input:  Letzte 12 Wochen × (43 Kunden-Volumina + 8 Features)
    Output: Nächste 4 Wochen × 43 Kunden-Volumina
    """
    def __init__(self, n_kunden=43, n_features=8,
                 hidden=128, layers=2):
        super().__init__()
        input_dim = n_kunden + n_features

        self.lstm = nn.LSTM(
            input_size=input_dim,
            hidden_size=hidden,
            num_layers=layers,
            dropout=0.15,
            batch_first=True
        )

        # Attention über die 12 Eingabe-Wochen
        self.attn = nn.Sequential(
            nn.Linear(hidden, 64), nn.Tanh(),
            nn.Linear(64, 1)
        )

        # 4-Wochen-Output pro Kunde
        self.head = nn.Sequential(
            nn.Linear(hidden, 128), nn.ReLU(),
            nn.Dropout(0.1),
            nn.Linear(128, n_kunden * 4)  # 43 × 4 Wochen
        )
        self.n_kunden = n_kunden

    def forward(self, x):
        out, _ = self.lstm(x)
        # Attention-weighted context
        w = torch.softmax(self.attn(out), dim=1)
        ctx = (out * w).sum(dim=1)
        pred = self.head(ctx)
        return pred.view(-1, 4, self.n_kunden)

# --- Training ---
model = VolumeForecaster()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
criterion = nn.HuberLoss(delta=5.0)

# Features pro Woche: Kalenderwoche, Quartal, Feiertage, Vorjahr,
#                     Branchenindex, Temperatur, Dieselpreis, BIP-Trend

print(f"Modell-Parameter: {sum(p.numel() for p in model.parameters()):,}")
print(f"Input:  12 Wochen × 51 Features (43 Kunden + 8 Kontext)")
print(f"Output: 4 Wochen × 43 Kunden-Prognosen")

# === KAPAZITÄTS-OPTIMIERUNG DURCH FORECASTING ===

# 1. Reduktion Subunternehmer-Einsatz
# Aktuell: 18% der Touren an Subunternehmer (reaktive Planung)
# Mit Forecast: 12% (geplante Vergabe statt Notfall)
touren_pro_jahr = 42_000
sub_aktuell = int(touren_pro_jahr * 0.18)
sub_forecast = int(touren_pro_jahr * 0.12)
sub_erspart = sub_aktuell - sub_forecast
kosten_diff_pro_tour = 85  # € Mehrkosten Sub vs. eigen (Notfall-Aufschlag)
ersparnis_sub = sub_erspart * kosten_diff_pro_tour

# 2. Fahrzeug-Leerstand reduzieren
# Aktuell: 8.5% Leerstandquote (Fahrzeug bereit, kein Auftrag)
# Mit Forecast: 5.2% (vorausschauende Tourenplanung)
lkw = 150
arbeitstage = 250
lkw_tage = lkw * arbeitstage
leerstand_diff = (0.085 - 0.052) * lkw_tage
kosten_leerstand_tag = 120  # Fixkosten pro LKW-Tag
ersparnis_leerstand = leerstand_diff * kosten_leerstand_tag * 0.5  # 50% realisierbar

# 3. Bessere Verhandlungsposition bei Stammkunden
# Proaktive Kapazitätszusage → höhere Vertragsbindung → weniger Preisdruck
ersparnis_verhandlung = 28_000  # Geschätzt: bessere Margen bei 5 Großkunden

# 4. Personalplanung (Fahrer)
# Weniger Überstunden durch vorausschauende Schichtplanung
ersparnis_personal = 18_000  # Überstunden-Reduktion

total = ersparnis_sub + ersparnis_leerstand + ersparnis_verhandlung + ersparnis_personal

print(f"Sub-Reduktion:       €{ersparnis_sub:>10,.0f}")
print(f"Leerstand-Reduktion: €{ersparnis_leerstand:>10,.0f}")
print(f"Verhandlungseffekt:  €{ersparnis_verhandlung:>10,.0f}")
print(f"Personalplanung:     €{ersparnis_personal:>10,.0f}")
print(f"{'─'*40}")
print(f"GESAMT:              €{total:>10,.0f}")