Ride-Hailing Demand Modeling & Forecasting Questions

# pseudocode / Python-ish
import pandas as pd
import numpy as np
import lightgbm as lgb
from sklearn.model_selection import ParameterSampler
from sklearn.preprocessing import OrdinalEncoder

# 1. Prepare raw time-series data: df with ['datetime','city','zone','rides', ...exog vars...]
df = df.sort_values(['city','zone','datetime'])

# 2. Feature builder: create lags and rolling stats
def build_features(group, lags=[1,24,48], windows=[24,168]):
    for l in lags:
        group[f'lag_{l}'] = group['rides'].shift(l)
    for w in windows:
        group[f'roll_mean_{w}'] = group['rides'].shift(1).rolling(w).mean()
    # add hour/day/week cyclical
    group['hour_sin'] = np.sin(2*np.pi*group.datetime.dt.hour/24)
    group['hour_cos'] = np.cos(2*np.pi*group.datetime.dt.hour/24)
    return group

df = df.groupby(['city','zone']).apply(build_features).dropna()

# 3. Encode categorical city/zone (ordinal or target encoding)
cat_cols = ['city','zone']
enc = OrdinalEncoder()
df[cat_cols] = enc.fit_transform(df[cat_cols])

# 4. Create multi-step targets (direct method): target_h = rides shifted -h
H = 24
for h in range(1, H+1):
    df[f'target_t+{h}'] = df['rides'].shift(-h)

# drop rows with NA targets
df = df.dropna()

# 5. Rolling-origin CV generator
def rolling_origin_splits(df_time, initial_window, horizon, step):
    start = initial_window
    while start + horizon <= len(df_time):
        train_idx = np.arange(0, start)
        test_idx = np.arange(start, start+horizon)
        yield train_idx, test_idx
        start += step

# 6. Hyperparameter search (random sample)
param_space = {'num_leaves':[31,63], 'learning_rate':[0.05,0.1], 'n_estimators':[100,300]}
search = list(ParameterSampler(param_space, n_iter=6, random_state=0))

best = {}
for h in range(1, H+1):   # train separate model per horizon
    best_score = np.inf
    for params in search:
        cv_scores = []
        for train_idx, val_idx in rolling_origin_splits(df, initial_window=2000, horizon=168, step=168):
            X_train = df.iloc[train_idx].drop([f'target_t+{k}' for k in range(1,H+1)], axis=1)
            y_train = df.iloc[train_idx][f'target_t+{h}']
            X_val = df.iloc[val_idx].drop([f'target_t+{k}' for k in range(1,H+1)], axis=1)
            y_val = df.iloc[val_idx][f'target_t+{h}']
            model = lgb.LGBMRegressor(**params)
            model.fit(X_train, y_train, categorical_feature=cat_cols, eval_set=[(X_val,y_val)], early_stopping_rounds=50, verbose=False)
            preds = model.predict(X_val)
            cv_scores.append(mean_absolute_error(y_val, preds))
        if np.mean(cv_scores) < best_score:
            best_score = np.mean(cv_scores)
            best[h] = (params, best_score)

# 7. Final training: train each horizon model on full train period using best[h]
# 8. Prediction: for a given current time, build features, predict targets 1..24 directly

# Notes:
# - Direct strategy trains one model per horizon (robust, avoids error accumulation).
# - Recursive strategy predicts t+1 then feeds it to predict t+2; simpler but error compounds.
# - Consider time-based holdout for final test, scale exogenous covariates, and use target encoding for high-cardinality zone IDs.