Dwell-time prediction:
The invisible costs at the loading bay

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

np.random.seed(42)

# --- Kundenstruktur mit realistischen Eigenschaften ---
kunden = []
for i in range(43):
    branche = np.random.choice(['Automotive', 'FMCG', 'Baustoffe',
                                 'Pharma', 'Chemie', 'Lebensmittel'])
    basis_standzeit = np.random.normal(45, 18)
    rampen_count = np.random.choice([1,2,3,4,6,8],
                                     p=[0.15,0.25,0.25,0.2,0.1,0.05])
    kunden.append({
        'kunde_id': f'K-{i+1:03d}',
        'branche': branche,
        'basis_standzeit_min': max(15, basis_standzeit),
        'rampen': rampen_count,
        'hat_zeitfenster': np.random.random() > 0.4,
        'wochenend_zuschlag': np.random.uniform(1.0, 1.5)
    })

# --- 18.000 Anfahrten generieren ---
records = []
start_date = datetime(2024, 1, 1)
for _ in range(18000):
    kunde = np.random.choice(kunden)
    tag_offset = np.random.randint(0, 365)
    ankunft = start_date + timedelta(days=tag_offset,
                hours=np.random.normal(9, 3))
    wochentag = ankunft.weekday()
    standzeit = kunde['basis_standzeit_min']
    if wochentag == 0: standzeit *= 1.3
    if wochentag == 4: standzeit *= 1.15
    if 11 <= ankunft.hour <= 13: standzeit *= 1.25
    standzeit += np.random.normal(0, 12)
    standzeit = max(10, standzeit)
    records.append({
        'datum': ankunft.date(), 'ankunft_zeit': ankunft.strftime('%H:%M'),
        'wochentag': wochentag, 'kunde_id': kunde['kunde_id'],
        'branche': kunde['branche'], 'rampen': kunde['rampen'],
        'hat_zeitfenster': kunde['hat_zeitfenster'],
        'ladungstyp': np.random.choice(['Komplett','Teilladung','Stückgut']),
        'gewicht_t': round(np.random.uniform(2,24),1),
        'standzeit_min': round(standzeit,1)
    })
df = pd.DataFrame(records)
print(f"Dataset: {len(df)} Anfahrten, {df['kunde_id'].nunique()} Kunden")

# Durchschnittliche Standzeit pro Wochentag
wochentag_stats = df.groupby('wochentag')['standzeit_min'].agg(['mean','std','count'])
print("Standzeit nach Wochentag:")
print(wochentag_stats.round(1))

# Top 10 Kunden mit höchster durchschnittlicher Standzeit
kunde_ranking = df.groupby(['kunde_id','branche'])['standzeit_min'].agg(
    mean_standzeit='mean', total_anfahrten='count',
    total_stunden=lambda x: x.sum() / 60
).sort_values('mean_standzeit', ascending=False)

# Kosten-Kalkulation: €0.75/min pro LKW (Fahrer + Fahrzeug)
kosten_pro_min = 0.75
df['kosten_eur'] = df['standzeit_min'] * kosten_pro_min

from sklearn.preprocessing import LabelEncoder, StandardScaler

df['stunde'] = df['ankunft_zeit'].apply(lambda x: int(x.split(':')[0]))
df['ist_montag'] = (df['wochentag'] == 0).astype(int)
df['ist_freitag'] = (df['wochentag'] == 4).astype(int)
df['mittagszeit'] = ((df['stunde'] >= 11) & (df['stunde'] <= 13)).astype(int)

df = df.sort_values('datum')
df['kunde_rolling_avg'] = df.groupby('kunde_id')['standzeit_min'].transform(
    lambda x: x.rolling(20, min_periods=1).mean())
df['kunde_rolling_std'] = df.groupby('kunde_id')['standzeit_min'].transform(
    lambda x: x.rolling(20, min_periods=1).std().fillna(0))

le_branche = LabelEncoder(); le_ladung = LabelEncoder()
df['branche_enc'] = le_branche.fit_transform(df['branche'])
df['ladung_enc'] = le_ladung.fit_transform(df['ladungstyp'])

features = ['wochentag','stunde','ist_montag','ist_freitag','mittagszeit',
            'rampen','hat_zeitfenster','branche_enc','ladung_enc',
            'gewicht_t','kunde_rolling_avg','kunde_rolling_std']
print(f"Feature-Matrix: {len(features)} Features × {len(df)} Samples")

import torch
import torch.nn as nn
from torch.utils.data import DataLoader, TensorDataset

class StandzeitLSTM(nn.Module):
    def __init__(self, input_dim=12, hidden_dim=64, num_layers=2, dropout=0.2):
        super().__init__()
        self.lstm = nn.LSTM(input_size=input_dim, hidden_size=hidden_dim,
            num_layers=num_layers, dropout=dropout, batch_first=True)
        self.attention = nn.Sequential(
            nn.Linear(hidden_dim, 32), nn.Tanh(), nn.Linear(32, 1))
        self.regressor = nn.Sequential(
            nn.Linear(hidden_dim, 32), nn.ReLU(),
            nn.Dropout(dropout), nn.Linear(32, 1))

    def forward(self, x):
        lstm_out, _ = self.lstm(x)
        attn_weights = torch.softmax(self.attention(lstm_out), dim=1)
        context = (lstm_out * attn_weights).sum(dim=1)
        return self.regressor(context).squeeze(-1)

model = StandzeitLSTM()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
criterion = nn.HuberLoss(delta=10.0)
print(f"Model Parameters: {sum(p.numel() for p in model.parameters()):,}")

from sklearn.metrics import mean_absolute_error, r2_score

y_pred = model(X_test_seq); y_true = y_test
mae = mean_absolute_error(y_true, y_pred)
r2 = r2_score(y_true, y_pred)
mape = (np.abs(y_true - y_pred) / y_true).mean() * 100

baseline_pred = df.groupby('kunde_id')['standzeit_min'].transform(
    lambda x: x.rolling(5).mean().shift(1))
mae_baseline = mean_absolute_error(y_true, baseline_pred[test_idx])
print(f"LSTM MAE: {mae:.1f} min → {(1-mae/mae_baseline)*100:.0f}% besser als Baseline")

KOSTEN_PRO_MIN = 0.75
total_standzeit_min = df['standzeit_min'].sum()
total_kosten = total_standzeit_min * KOSTEN_PRO_MIN
df['ueber_ziel'] = (df['standzeit_min'] - 30).clip(lower=0)
vermeidbar = df['ueber_ziel'].sum() * KOSTEN_PRO_MIN
print(f"Gesamt-Kosten: €{total_kosten:,.0f}")
print(f"Davon vermeidbar: €{vermeidbar:,.0f}")