Verkaufsdauer-Prediction:
Wie lange ein Objekt steht - vorhergesagt, nicht geschätzt

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

np.random.seed(42)

N = 1350

# --- Stadtteile mit unterschiedlicher Marktdynamik ---
stadtteile = {
    'Innenstadt':       {'nachfrage': 1.4, 'avg_preis_qm': 5200},
    'Altstadt':         {'nachfrage': 1.3, 'avg_preis_qm': 4800},
    'Universitätsvtl.': {'nachfrage': 1.5, 'avg_preis_qm': 4200},
    'Südvorstadt':      {'nachfrage': 1.2, 'avg_preis_qm': 3800},
    'Westend':          {'nachfrage': 1.0, 'avg_preis_qm': 3400},
    'Nordstadt':        {'nachfrage': 0.85, 'avg_preis_qm': 2900},
    'Industriegebiet':  {'nachfrage': 0.6, 'avg_preis_qm': 2200},
    'Umland Nord':      {'nachfrage': 0.75, 'avg_preis_qm': 2600},
    'Umland Süd':       {'nachfrage': 0.9, 'avg_preis_qm': 3000},
    'Umland West':      {'nachfrage': 0.7, 'avg_preis_qm': 2400},
}

records = []
for i in range(N):
    stadtteil = np.random.choice(list(stadtteile.keys()),
        p=[0.12,0.10,0.14,0.12,0.10,0.09,0.06,0.10,0.09,0.08])
    st = stadtteile[stadtteil]

    objekt_typ = np.random.choice(
        ['ETW','EFH','DHH','RH','MFH','Penthouse'],
        p=[0.40,0.22,0.12,0.10,0.08,0.08])
    wohnflaeche = np.random.normal(
        {'ETW':78,'EFH':145,'DHH':125,'RH':110,'MFH':320,'Penthouse':120}[objekt_typ],
        20)
    wohnflaeche = max(30, wohnflaeche)
    baujahr = np.random.choice([1960,1975,1990,2000,2010,2018,2022],
        p=[0.12,0.15,0.18,0.15,0.18,0.12,0.10])
    zimmer = np.random.choice([1,2,3,4,5,6], p=[0.05,0.20,0.30,0.25,0.12,0.08])
    zustand = np.random.choice(['Erstbezug','Saniert','Gepflegt','Renovierungsbed.'],
        p=[0.15,0.25,0.40,0.20])
    balkon = np.random.random() > 0.35
    garten = np.random.random() > 0.7 if objekt_typ in ['EFH','DHH','RH'] else False
    stellplatz = np.random.random() > 0.4
    energieeffizienz = np.random.choice(['A+','A','B','C','D','E','F'],
        p=[0.05,0.10,0.15,0.25,0.20,0.15,0.10])

    # Inserats-Monat (Saisonalität)
    monat = np.random.choice(range(1,13),
        p=[0.09,0.08,0.10,0.10,0.09,0.08,0.06,0.06,0.09,0.10,0.08,0.07])

    # Preispositionierung: Abweichung vom Marktwert
    preis_abweichung = np.random.normal(0.05, 0.10)  # +5% über Markt im Schnitt
    anzahl_fotos = np.random.choice([5,8,12,18,25,30],
        p=[0.05,0.10,0.20,0.30,0.25,0.10])

    # === VERKAUFSDAUER-MODELL (Tage) ===
    basis = 90
    # Nachfrage-Effekt: Hohe Nachfrage → schneller
    basis /= st['nachfrage']
    # Preis-Effekt: Überteuert → langsamer
    basis *= (1 + preis_abweichung * 3.5)
    # Zustand
    if zustand == 'Erstbezug': basis *= 0.7
    elif zustand == 'Renovierungsbed.': basis *= 1.6
    # Saisonalität: Frühling schnell, Winter langsam
    saison = {1:1.15,2:1.05,3:0.85,4:0.80,5:0.82,6:0.90,
             7:1.10,8:1.15,9:0.88,10:0.85,11:1.05,12:1.25}
    basis *= saison[monat]
    # Fotos: Mehr → schneller
    basis *= max(0.7, 1.3 - anzahl_fotos / 30)
    # Noise
    basis *= np.random.lognormal(0, 0.15)
    tage = int(np.clip(basis, 7, 365))

    records.append({
        'stadtteil': stadtteil, 'objekt_typ': objekt_typ,
        'wohnflaeche_qm': round(wohnflaeche,1),
        'zimmer': zimmer, 'baujahr': baujahr,
        'zustand': zustand, 'balkon': balkon,
        'garten': garten, 'stellplatz': stellplatz,
        'energieeffizienz': energieeffizienz,
        'inserat_monat': monat,
        'preis_abweichung_%': round(preis_abweichung*100,1),
        'anzahl_fotos': anzahl_fotos,
        'nachfrage_index': st['nachfrage'],
        'verkaufsdauer_tage': tage,
    })

df = pd.DataFrame(records)
print(f"Dataset: {len(df):,} Transaktionen")
print(f"Ø Verkaufsdauer: {df['verkaufsdauer_tage'].mean():.0f} Tage")
print(f"Median: {df['verkaufsdauer_tage'].median():.0f} Tage")
print(f"Spanne: {df['verkaufsdauer_tage'].min()} - {df['verkaufsdauer_tage'].max()} Tage")

# Verkaufsdauer nach Stadtteil
stadtteil_stats = df.groupby('stadtteil')['verkaufsdauer_tage'].agg(['mean','median','count'])
print(stadtteil_stats.sort_values('mean').round(0))

# Saisonalität
saison_stats = df.groupby('inserat_monat')['verkaufsdauer_tage'].mean()
print("\nØ Verkaufsdauer nach Inserat-Monat:")
print(saison_stats.round(0))

# Preis-Effekt: Korrelation Abweichung → Dauer
korr = df[['preis_abweichung_%','verkaufsdauer_tage']].corr().iloc[0,1]
print(f"\nKorrelation Preisabweichung → Dauer: {korr:.3f}")

from sklearn.preprocessing import LabelEncoder

# Numerische Encodings
le_stadtteil = LabelEncoder(); le_typ = LabelEncoder()
le_zustand = LabelEncoder(); le_energie = LabelEncoder()
df['stadtteil_enc'] = le_stadtteil.fit_transform(df['stadtteil'])
df['typ_enc'] = le_typ.fit_transform(df['objekt_typ'])
df['zustand_enc'] = le_zustand.fit_transform(df['zustand'])
df['energie_enc'] = le_energie.fit_transform(df['energieeffizienz'])

# Abgeleitete Features
df['qm_pro_zimmer'] = df['wohnflaeche_qm'] / df['zimmer']
df['ist_neubau'] = (df['baujahr'] >= 2015).astype(int)
df['ist_fruehling'] = df['inserat_monat'].isin([3,4,5]).astype(int)
df['ist_winter'] = df['inserat_monat'].isin([11,12,1]).astype(int)
df['preis_ueber_10pct'] = (df['preis_abweichung_%'] > 10).astype(int)

features = [
    'stadtteil_enc', 'typ_enc', 'wohnflaeche_qm', 'zimmer',
    'baujahr', 'zustand_enc', 'balkon', 'garten', 'stellplatz',
    'energie_enc', 'inserat_monat', 'preis_abweichung_%',
    'anzahl_fotos', 'nachfrage_index',
    'qm_pro_zimmer', 'ist_neubau', 'ist_fruehling', 'preis_ueber_10pct',
]
print(f"Feature-Matrix: {len(features)} Features × {len(df)} Objekte")

import xgboost as xgb
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_absolute_error, r2_score

X = df[features]; y = df['verkaufsdauer_tage']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2,
                                                      random_state=42)

# Punkt-Prognose
model = xgb.XGBRegressor(
    n_estimators=400, max_depth=6, learning_rate=0.05,
    subsample=0.8, colsample_bytree=0.8,
    reg_alpha=0.1, reg_lambda=1.0,
    random_state=42
)
model.fit(X_train, y_train, eval_set=[(X_test, y_test)],
         verbose=50)

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

# Quantile-Modelle für Konfidenzintervall
model_q10 = xgb.XGBRegressor(objective='reg:quantileerror',
    quantile_alpha=0.1, n_estimators=300, max_depth=5)
model_q90 = xgb.XGBRegressor(objective='reg:quantileerror',
    quantile_alpha=0.9, n_estimators=300, max_depth=5)
model_q10.fit(X_train, y_train)
model_q90.fit(X_train, y_train)

print(f"MAE:   {mae:.1f} Tage")
print(f"R²:    {r2:.3f}")
print(f"MAPE:  {mape:.1f}%")

# === Wie das Modell den Umsatz steigert ===

# 1. Mehr Abschlüsse pro Jahr (Kapazitätseffekt)
# Ein Makler betreut im Schnitt 3 bis 4 Objekte gleichzeitig -
# eine planbare Pipeline bringt 0.5 zusätzliche Abschlüsse pro Makler/Jahr (Annahme)
makler = 32  # Vertriebsmitarbeiter
zusatz_je_makler = 0.5
avg_provision = 8500  # Ø Provision pro Transaktion
zusatz_abschluesse = int(makler * zusatz_je_makler)  # 16
umsatz_zusatz = zusatz_abschluesse * avg_provision

# 2. Höhere Akquise-Quote (Eigentümer-Pitch)
# Datenbasierter Pitch hebt die Akquise-Quote von 0.35 auf 0.42 (Annahme)
pitches_pro_jahr = 320
aktuelle_quote = 0.35
neue_quote = 0.42
zusatz_auftraege = int(pitches_pro_jahr * (neue_quote - aktuelle_quote))  # 22
umsatz_akquise = zusatz_auftraege * avg_provision

# Vermiedene Preisreduktionen werden bewusst NICHT eingerechnet -
# dieser Effekt gehört zur Preisoptimierung (Modul 3), keine Doppelzählung.
total = umsatz_zusatz + umsatz_akquise

print(f"Mehr Abschlüsse/Jahr:     €{umsatz_zusatz:>10,.0f}")
print(f"Höhere Akquise-Quote:     €{umsatz_akquise:>10,.0f}")
print(f"{'─'*40}")
print(f"GESAMT:                   €{total:>10,.0f}")