Prédire le surbooking aérien avec le Machine Learning : le processus complet

import pandas as pd
import numpy as np

def build_features(bookings: pd.DataFrame,
                   pax_history: pd.DataFrame,
                   calendar: pd.DataFrame) -> pd.DataFrame:
    """
    Construit le jeu de features au point de décision (J-1, 18h00 UTC).
    Aucune colonne postérieure à ce timestamp ne doit entrer ici.
    """
    df = bookings.copy()

    # --- Temporel ---
    df["booking_lead_days"] = (
        df["departure_datetime"] - df["booking_datetime"]
    ).dt.days.clip(0, 365)

    df["dep_hour"]      = df["departure_datetime"].dt.hour
    df["dep_dayofweek"] = df["departure_datetime"].dt.dayofweek
    df["is_weekend"]    = df["dep_dayofweek"].isin([5, 6]).astype(int)

    # Encodage cyclique : l'heure 23 est proche de l'heure 0
    df["dep_hour_sin"] = np.sin(2 * np.pi * df["dep_hour"] / 24)
    df["dep_hour_cos"] = np.cos(2 * np.pi * df["dep_hour"] / 24)

    # --- Tarifaire ---
    df["is_refundable"] = df["fare_rules"].str.contains("REF", na=False).astype(int)
    df["is_changeable"] = df["fare_rules"].str.contains("CHG", na=False).astype(int)
    df["price_per_km"]  = df["fare_paid"] / df["route_distance_km"].replace(0, np.nan)
    df["is_corporate"]  = (df["sales_channel"] == "CORPORATE").astype(int)

    # --- Historique passager (fenêtre glissante, sans fuite) ---
    hist = pax_history[
        pax_history["flight_date"] < df["departure_datetime"].min()
    ]
    agg = (hist.groupby("pax_id")
                .agg(hist_flights=("pax_id", "size"),
                     hist_noshows=("is_noshow", "sum"))
                .reset_index())
    agg["hist_noshow_rate"] = agg["hist_noshows"] / agg["hist_flights"]

    df = df.merge(agg, on="pax_id", how="left")
    df["hist_flights"]     = df["hist_flights"].fillna(0)
    df["hist_noshow_rate"] = df["hist_noshow_rate"].fillna(-1)   # -1 = inconnu

    # --- Contexte et charge du vol ---
    df = df.merge(calendar, left_on=df["departure_datetime"].dt.date,
                  right_on="date", how="left")
    df["is_holiday"] = df["is_holiday"].fillna(0).astype(int)
    df["load_factor_at_decision"] = (
        df["seats_sold_at_decision"] / df["capacity"]
    )

    return df

# CORRECT : split temporel — reproduit les conditions réelles
train = df[df["departure_date"] <  "2025-10-01"]
valid = df[(df["departure_date"] >= "2025-10-01") &
           (df["departure_date"] <  "2026-01-01")]
test  = df[df["departure_date"] >= "2026-01-01"]

# INCORRECT : train_test_split(df, random_state=42)
# → des réservations du même vol se retrouvent des deux côtés,
#   le modèle "voit" le futur, les scores explosent artificiellement.

import argparse, mlflow, joblib
import lightgbm as lgb
import pandas as pd
from sklearn.metrics import roc_auc_score, average_precision_score, brier_score_loss
from sklearn.calibration import CalibratedClassifierCV

def main(args):
    mlflow.autolog()

    train = pd.read_parquet(args.train_data)
    valid = pd.read_parquet(args.valid_data)

    FEATURES = [c for c in train.columns
                if c not in ("is_noshow", "pnr", "pax_id", "departure_date")]
    CATEGORICAL = ["route", "fare_class", "sales_channel",
                   "aircraft_type", "loyalty_tier"]

    for c in CATEGORICAL:
        train[c] = train[c].astype("category")
        valid[c] = valid[c].astype("category")

    model = lgb.LGBMClassifier(
        objective="binary",
        n_estimators=2000,
        learning_rate=0.03,
        num_leaves=64,
        min_child_samples=200,
        subsample=0.8,
        colsample_bytree=0.8,
        reg_lambda=1.0,
        scale_pos_weight=1.0,   # ne pas gonfler : cela casserait la calibration
        random_state=42,
    )

    model.fit(
        train[FEATURES], train["is_noshow"],
        eval_set=[(valid[FEATURES], valid["is_noshow"])],
        eval_metric="average_precision",
        categorical_feature=CATEGORICAL,
        callbacks=[lgb.early_stopping(100), lgb.log_evaluation(100)],
    )

    # Calibration : indispensable, on veut des PROBABILITÉS fiables
    calibrated = CalibratedClassifierCV(model, method="isotonic", cv="prefit")
    calibrated.fit(valid[FEATURES], valid["is_noshow"])

    p = calibrated.predict_proba(valid[FEATURES])[:, 1]
    mlflow.log_metrics({
        "auc_roc": roc_auc_score(valid["is_noshow"], p),
        "auc_pr":  average_precision_score(valid["is_noshow"], p),
        "brier":   brier_score_loss(valid["is_noshow"], p),
    })

    mlflow.sklearn.log_model(calibrated, "model",
                             registered_model_name="noshow-predictor")

if __name__ == "__main__":
    p = argparse.ArgumentParser()
    p.add_argument("--train_data"); p.add_argument("--valid_data")
    p.add_argument("--model_output")
    main(p.parse_args())

from azure.ai.ml import MLClient, command, Input, Output
from azure.identity import DefaultAzureCredential

ml_client = MLClient(DefaultAzureCredential(),
                     subscription_id="<sub-id>",
                     resource_group_name="rg-airline-ml",
                     workspace_name="aml-revenue-mgmt")

job = command(
    code="./src",
    command=("python train.py --train_data ${{inputs.train}} "
             "--valid_data ${{inputs.valid}} "
             "--model_output ${{outputs.model}}"),
    inputs={
        "train": Input(type="uri_file", path="azureml:noshow_train:8"),
        "valid": Input(type="uri_file", path="azureml:noshow_valid:8"),
    },
    outputs={"model": Output(type="uri_folder")},
    environment="azureml://registries/azureml/environments/sklearn-1.5/labels/latest",
    compute="cpu-cluster-d8s",
    display_name="noshow-lgbm-v8",
    experiment_name="overbooking",
)

ml_client.jobs.create_or_update(job)

flight_level = (
    scored.groupby("flight_id")
          .agg(expected_noshows=("p_noshow", "sum"),
               actual_noshows=("is_noshow", "sum"),
               bookings=("pnr", "count"))
)
flight_level["error"] = (flight_level["expected_noshows"]
                         - flight_level["actual_noshows"])

print("MAE vol :", flight_level["error"].abs().mean())
print("Biais   :", flight_level["error"].mean())   # doit être proche de 0

import numpy as np

def optimal_authorization(p_show: np.ndarray,
                          capacity: int,
                          cost_spoilage: float = 180,   # € de marge perdue
                          cost_denied: float = 600,     # € UE261 + réacheminement
                          max_extra: int = 30,
                          n_sim: int = 20000,
                          seed: int = 42) -> dict:
    rng = np.random.default_rng(seed)
    results = {}

    for extra in range(0, max_extra + 1):
        n_sell = capacity + extra
        probs  = np.resize(p_show, n_sell)
        shows  = rng.binomial(1, probs, size=(n_sim, n_sell)).sum(axis=1)

        spoilage = np.maximum(capacity - shows, 0).mean()
        denied   = np.maximum(shows - capacity, 0).mean()

        results[n_sell] = cost_spoilage * spoilage + cost_denied * denied

    best = min(results, key=results.get)
    return {"authorization_level": best,
            "overbooking_seats": best - capacity,
            "expected_cost": results[best]}

from azure.ai.ml.entities import ManagedOnlineEndpoint, ManagedOnlineDeployment

endpoint = ManagedOnlineEndpoint(
    name="noshow-endpoint",
    auth_mode="aml_token",
    public_network_access="disabled",   # accès via Private Link uniquement
)
ml_client.online_endpoints.begin_create_or_update(endpoint).result()

deployment = ManagedOnlineDeployment(
    name="blue",
    endpoint_name="noshow-endpoint",
    model=ml_client.models.get("noshow-predictor", label="latest"),
    instance_type="Standard_DS3_v2",
    instance_count=2,
)
ml_client.online_deployments.begin_create_or_update(deployment).result()

# Déploiement progressif : 10 % du trafic sur la nouvelle version
endpoint.traffic = {"blue": 90, "green": 10}
ml_client.online_endpoints.begin_create_or_update(endpoint).result()

from azure.ai.ml.entities import (
    AlertNotification, MonitorSchedule, MonitorDefinition,
    ServerlessSparkCompute, DataDriftSignal
)

monitor = MonitorSchedule(
    name="noshow-drift-monitor",
    trigger={"type": "recurrence", "frequency": "week", "interval": 1},
    create_monitor=MonitorDefinition(
        compute=ServerlessSparkCompute(runtime_version="3.4",
                                       instance_type="standard_e4s_v3"),
        monitoring_signals={"data_drift": DataDriftSignal()},
        alert_notification=AlertNotification(
            emails=["revenue-mgmt@compagnie.com"]),
    ),
)
ml_client.schedules.begin_create_or_update(monitor).result()