Deploy app with models and artifacts (force update)

.env

@@ -0,0 +1,7 @@
+# Production configuration
+MODEL_PATH=models/
+PREPROCESSOR_PATH=models/preprocessor.pkl
+ARTIFACT_DIR=artifacts
+LOCAL_MODEL_PATH=models/champion_model.pkl
+LOCAL_PREPROCESSOR_PATH=models/preprocessor.pkl
+ALLOW_START_WITHOUT_MODEL=false

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+artifacts/shap_summary.png filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,25 @@
+FROM python:3.10-slim
+
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements and install
+COPY requirements.txt .
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir -r requirements.txt
+
+# Copy application files
+COPY . .
+
+# Expose port 7860 (Hugging Face Spaces default)
+EXPOSE 7860
+
+# Set environment variable for Hugging Face Spaces
+ENV PORT=7860
+
+# Run the application
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -0,0 +1,47 @@
+---
+title: Hotel Booking Cancellation Prediction API
+emoji: 🏨
+colorFrom: blue
+colorTo: green
+sdk: docker
+pinned: false
+license: mit
+---
+
+# Hotel Booking Cancellation Prediction API
+
+This is a FastAPI-based prediction service that estimates the probability of hotel booking cancellations.
+
+## Features
+
+- **POST /predict** - Predict cancellation probability for a single booking
+- **GET /health** - Health check endpoint
+- **GET /** - API information
+
+## Example Usage
+
+```python
+import requests
+
+payload = {
+    "lead_time": 30,
+    "arrival_month": 7,
+    "adults": 2,
+    "children": 0,
+    "adr": 120.0
+}
+
+response = requests.post("https://huggingface.co/spaces/j2damax/boking-cancelation-api/predict", json=payload)
+print(response.json())
+```
+
+## Model Information
+
+The API uses a machine learning model trained on hotel booking data with features like:
+- Lead time (days before arrival)
+- Guest composition (adults, children)
+- Pricing (average daily rate)
+- Stay duration
+- And more...
+
+Check `/docs` for the interactive API documentation.

app/__init__.py

@@ -0,0 +1,6 @@
+"""Lightweight modular FastAPI application components for hotel cancellation prediction.
+
+This package isolates configuration, model loading, schemas, and routes so that
+`main.py` can remain minimal. Only essential functionality (health + predict)
+is kept per the user's simplification request.
+"""

app/config.py

@@ -0,0 +1,19 @@
+"""Application configuration and environment variable management."""
+from __future__ import annotations
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+# AWS / S3 model fetching removed – artifacts now sourced from local paths or Hugging Face Hub only.
+MODEL_VERSION = os.getenv("MODEL_VERSION", "latest")  # retained for potential future tagging (not used for HF snapshot)
+DECISION_THRESHOLD_ENV = os.getenv("DECISION_THRESHOLD")  # optional override
+ALLOW_START_WITHOUT_MODEL = os.getenv("ALLOW_START_WITHOUT_MODEL", "false").lower() == "true"
+ARTIFACT_DIR = os.getenv("ARTIFACT_DIR", "artifacts")
+HF_MODEL_REPO = os.getenv("HF_MODEL_REPO")  # e.g. j2damax/hotel-cancel-model
+
+# Local fallback paths (used if artifacts baked into image or mounted)
+LOCAL_MODEL_PATH = os.getenv("LOCAL_MODEL_PATH", "models/champion_model.pkl")
+LOCAL_PREPROCESSOR_PATH = os.getenv("LOCAL_PREPROCESSOR_PATH", "models/preprocessor.pkl")
+
+APP_VERSION = "1.0.0"

app/model_loader.py

@@ -0,0 +1,127 @@
+"""Model + preprocessor loading utilities (local + Hugging Face Hub).
+
+S3 support removed as project no longer uses AWS. Loading order:
+1. Local baked artifacts (if present)
+2. Hugging Face Hub (HF_MODEL_REPO)
+"""
+from __future__ import annotations
+import os, json, time
+import joblib
+from typing import Optional, Tuple
+
+from . import config
+from src.preprocessing import PreprocessingPipeline
+
+model = None
+preprocessor: Optional[PreprocessingPipeline] = None
+model_version: Optional[str] = None
+champion_meta_threshold: Optional[float] = None
+_last_reload_time: float | None = None
+
+
+def _resolve_git_sha() -> str | None:
+    git_sha = os.getenv('GIT_SHA')
+    if git_sha:
+        return git_sha[:12]
+    head_path = os.path.join('.git','HEAD')
+    try:
+        if os.path.exists(head_path):
+            with open(head_path) as hf:
+                ref = hf.read().strip()
+            if ref.startswith('ref:'):
+                ref_file = ref.split(' ',1)[1]
+                ref_path = os.path.join('.git', ref_file)
+                if os.path.exists(ref_path):
+                    with open(ref_path) as rf:
+                        return rf.read().strip()[:12]
+            else:
+                return ref[:12]
+    except Exception:
+        return None
+    return None
+
+
+def load_model() -> None:
+    """Idempotent loading routine (local first, then HF Hub)."""
+    global model, preprocessor, model_version, champion_meta_threshold, _last_reload_time
+    # Local fallback
+    if model is None and os.path.exists(config.LOCAL_MODEL_PATH):
+        try:
+            model_candidate = joblib.load(config.LOCAL_MODEL_PATH)
+            if hasattr(model_candidate, 'predict'):
+                model = model_candidate
+                # pseudo version from mtime
+                mtime = int(os.path.getmtime(config.LOCAL_MODEL_PATH))
+                model_version = f"local_{mtime}"
+        except Exception as e:
+            print(f"Local model load failed: {e}")
+    if preprocessor is None and os.path.exists(config.LOCAL_PREPROCESSOR_PATH):
+        try:
+            preprocessor = PreprocessingPipeline.load(config.LOCAL_PREPROCESSOR_PATH)
+        except Exception:
+            preprocessor = None
+    # Hugging Face Hub fallback if HF_MODEL_REPO is set
+    if (model is None or preprocessor is None) and getattr(config, 'HF_MODEL_REPO', None):
+        try:
+            from huggingface_hub import snapshot_download
+            repo_id = config.HF_MODEL_REPO
+            cache_dir = os.path.join('models','hf', repo_id.replace('/','__'))
+            local_dir = snapshot_download(repo_id=repo_id, local_dir=cache_dir, local_dir_use_symlinks=False)
+            model_path = os.path.join(local_dir, 'champion_model.pkl')
+            preproc_path = os.path.join(local_dir, 'preprocessor.pkl')
+            meta_path = os.path.join(local_dir, 'champion_meta.json')
+            if model is None and os.path.exists(model_path):
+                m_candidate = joblib.load(model_path)
+                if hasattr(m_candidate, 'predict'):
+                    model = m_candidate
+                    model_version = f"hf_{os.path.getmtime(model_path):.0f}"
+            if preprocessor is None and os.path.exists(preproc_path):
+                try:
+                    preprocessor = PreprocessingPipeline.load(preproc_path)
+                except Exception:
+                    preprocessor = None
+            if os.path.exists(meta_path):
+                try:
+                    with open(meta_path) as mf:
+                        meta = json.load(mf)
+                    if 'decision_threshold' in meta:
+                        champion_meta_threshold = meta['decision_threshold']
+                except Exception:
+                    pass
+            if model is not None:
+                print(f"Loaded model (HF) repo={repo_id} version={model_version}")
+        except Exception as e:
+            print(f"HF load failed: {e}")
+    if model is None:
+        print("No model loaded (checked local + HF). API will report model_not_loaded.")
+
+
+def resolve_threshold() -> tuple[float, str]:
+    if config.DECISION_THRESHOLD_ENV is not None:
+        try:
+            return float(config.DECISION_THRESHOLD_ENV), 'env'
+        except ValueError:
+            pass
+    if champion_meta_threshold is not None:
+        try:
+            return float(champion_meta_threshold), 'champion_meta'
+        except ValueError:
+            pass
+    return 0.5, 'default'
+
+
+def load_model_and_preprocessor():
+    """Convenience helper to ensure artifacts are loaded and return them with minimal metadata.
+
+    Returns (model, preprocessor, metadata_dict)
+    metadata_dict contains keys: version, threshold, threshold_source
+    """
+    if model is None or preprocessor is None:
+        load_model()
+    thr, source = resolve_threshold()
+    meta = {
+        'version': model_version,
+        'threshold': thr,
+        'threshold_source': source
+    }
+    return model, preprocessor, meta

app/routes.py

@@ -0,0 +1,244 @@
+"""FastAPI routes (health + predict) using simplified pipeline."""
+from __future__ import annotations
+from fastapi import APIRouter, HTTPException
+import pandas as pd
+import numpy as np
+from .schemas import BookingFeatures, PredictionResponse, HealthResponse
+import json, os
+from . import config
+from . import model_loader
+
+router = APIRouter()
+
+
+@router.get('/health', response_model=HealthResponse)
+async def health():
+    thr, _src = model_loader.resolve_threshold()
+    loaded = model_loader.model is not None
+    return HealthResponse(
+        status='healthy' if loaded else 'model_not_loaded',
+        model_loaded=loaded,
+        model_version=model_loader.model_version,
+        decision_threshold=thr if loaded else None
+    )
+
+
+def _prepare(df: pd.DataFrame) -> pd.DataFrame:
+    """Minimal inference-time feature alignment.
+
+    Injects placeholder raw & engineered columns so the persisted preprocessor
+    (trained with target encoding on several categorical columns) can operate.
+
+    We intentionally provide conservative defaults for fields not exposed via
+    the public API schema. These defaults should be business-plausible and
+    neutral (e.g., zeros, most-common style fallbacks) while allowing the
+    preprocessor to apply target encodings and scaling without missing-column
+    errors.
+    """
+    df = df.copy()
+
+    # 1. Rename incoming simplified fields to training schema equivalents
+    if 'arrival_month' in df.columns:
+        df['arrival_date_month'] = df['arrival_month']
+    if 'stays_weekend_nights' in df.columns:
+        df['stays_in_weekend_nights'] = df['stays_weekend_nights']
+    if 'stays_week_nights' in df.columns:
+        df['stays_in_week_nights'] = df['stays_week_nights']
+    if 'total_of_special_requests' in df.columns:
+        df['total_of_special_requests'] = df['total_of_special_requests']  # idempotent clarity
+
+    # 2. Add placeholder raw columns expected by feature contract / preprocessor
+    placeholder_defaults = {
+        'hotel': 0,
+        'arrival_date_year': 2025,
+        'arrival_date_week_number': 1,
+        'arrival_date_day_of_month': 1,
+        'babies': 0,
+        'meal': 0,
+        'country': 'UNK',
+        'market_segment': 0,
+        'distribution_channel': 0,
+        'previous_bookings_not_canceled': 0,
+        'reserved_room_type': 0,
+        'assigned_room_type': 0,
+        'deposit_type': 0,
+        'days_in_waiting_list': 0,
+        'customer_type': 0,
+    }
+    for col, default in placeholder_defaults.items():
+        if col not in df.columns:
+            df[col] = default
+
+    # 3. Engineered features reproduced (subset)
+    if {'stays_in_weekend_nights','stays_in_week_nights'}.issubset(df.columns):
+        df['total_stay_duration'] = df['stays_in_weekend_nights'] + df['stays_in_week_nights']
+    if {'adults','children','babies'}.issubset(df.columns):
+        df['total_guests'] = df['adults'] + df['children'].fillna(0) + df['babies']
+    else:
+        df['total_guests'] = df.get('adults', 1)
+    # is_family heuristic (children or babies) match training logic closely
+    if {'children','babies'}.issubset(df.columns):
+        df['is_family'] = ((df['children'] > 0) | (df['babies'] > 0)).astype(int)
+    else:
+        df['is_family'] = 0
+    # guest_type (mirrors feature_engineering logic simplified)
+    def _guest_type(row):
+        if row.get('babies',0) > 0:
+            return 'family_with_babies'
+        if row.get('children',0) > 0:
+            return 'family_with_children'
+        if row.get('adults',0) == 1:
+            return 'solo_traveler'
+        if row.get('adults',0) == 2:
+            return 'couple'
+        return 'group'
+    if 'guest_type' not in df.columns:
+        df['guest_type'] = df.apply(_guest_type, axis=1)
+
+    # 4. Seasonal & temporal flags
+    if 'arrival_date_month' in df.columns:
+        m = df['arrival_date_month']
+        # Normalize numeric months (1-12). If user supplied 0-11 adjust (+1).
+        if set(m.unique()).issubset(set(range(0,12))):
+            m_norm = m + 1
+        else:
+            m_norm = m
+        season_map = {12:'winter',1:'winter',2:'winter',3:'spring',4:'spring',5:'spring',6:'summer',7:'summer',8:'summer',9:'autumn',10:'autumn',11:'autumn'}
+        df['arrival_season'] = m_norm.map(season_map)
+        df['is_peak_season'] = m_norm.isin([5,6,7,8,9]).astype(int)
+        # Quarter flag and additional temporal flags
+        def _quarter(x):
+            if pd.isna(x):
+                return None
+            return f"Q{int((int(x)-1)//3)+1}"
+        df['arrival_quarter'] = m_norm.apply(_quarter)
+        df['is_summer_peak'] = m_norm.isin([7,8]).astype(int)
+        df['is_holiday_season'] = m_norm.isin([12,1]).astype(int)
+    else:
+        for col, default in {
+            'arrival_season': 'winter',
+            'is_peak_season': 0,
+            'arrival_quarter': 'Q1',
+            'is_summer_peak': 0,
+            'is_holiday_season': 0,
+        }.items():
+            if col not in df.columns:
+                df[col] = default
+
+    # 5. Ensure columns required for target encoding exist (placeholders already above)
+    for te_col in ['country','guest_type','arrival_season','arrival_quarter']:
+        if te_col not in df.columns:
+            df[te_col] = 'UNK'
+
+    return df
+
+
+@router.post('/predict', response_model=PredictionResponse)
+async def predict(booking: BookingFeatures):
+    if model_loader.model is None:
+        raise HTTPException(status_code=503, detail='Model not loaded')
+    if model_loader.preprocessor is None:
+        raise HTTPException(status_code=503, detail='Preprocessor not loaded')
+    raw_df = pd.DataFrame([booking.model_dump()])
+    prep_df = _prepare(raw_df)
+    try:
+        processed = model_loader.preprocessor.transform(prep_df)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f'Preprocessor transform failed: {e}')
+    if hasattr(model_loader.model, 'predict_proba'):
+        prob = float(model_loader.model.predict_proba(processed)[0,1])
+    else:
+        prob = float(model_loader.model.predict(processed)[0])
+    thr, src = model_loader.resolve_threshold()
+    pred = int(prob >= thr)
+    return PredictionResponse(prediction=pred, probability=prob, model_version=model_loader.model_version, applied_threshold=thr, threshold_source=src)
+
+
+@router.post('/predict/batch', response_model=list[PredictionResponse])
+async def predict_batch(bookings: list[BookingFeatures]):
+    if model_loader.model is None:
+        raise HTTPException(status_code=503, detail='Model not loaded')
+    if model_loader.preprocessor is None:
+        raise HTTPException(status_code=503, detail='Preprocessor not loaded')
+    raw_df = pd.DataFrame([b.model_dump() for b in bookings])
+    prep_df = _prepare(raw_df)
+    try:
+        processed = model_loader.preprocessor.transform(prep_df)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f'Preprocessor transform failed: {e}')
+    if hasattr(model_loader.model, 'predict_proba'):
+        probs = model_loader.model.predict_proba(processed)[:,1]
+    else:
+        probs = model_loader.model.predict(processed).astype(float)
+    thr, src = model_loader.resolve_threshold()
+    preds = (probs >= thr).astype(int)
+    return [PredictionResponse(prediction=int(p), probability=float(pr), model_version=model_loader.model_version, applied_threshold=thr, threshold_source=src) for p, pr in zip(preds, probs)]
+
+
+def startup_load():
+    model_loader.load_model()
+    if model_loader.model is None and not config.ALLOW_START_WITHOUT_MODEL:
+        raise RuntimeError('Model not loaded at startup. Provide S3 env or mount local artifacts.')
+
+
+@router.get('/model/interpretability')
+async def interpretability(top_k: int = 10):
+    """Lightweight interpretability stub reading precomputed artifacts if available.
+
+    Returns minimal structure expected by existing tests; if artifacts missing,
+    degrades gracefully with empty lists.
+    """
+    artifacts_dir = config.ARTIFACT_DIR
+    feature_importance_path = os.path.join(artifacts_dir, 'feature_importance.json')
+    champion_meta_path = os.path.join(artifacts_dir, 'champion_meta.json')
+    shap_values_sample_path = os.path.join(artifacts_dir, 'shap_values_sample.json')
+    fi = []
+    champion_model = None
+    decision_threshold = None
+    shap_generated = False
+    local_examples = []
+    if os.path.exists(feature_importance_path):
+        try:
+            with open(feature_importance_path) as f:
+                raw = json.load(f)
+            fi = raw[:top_k]
+        except Exception:
+            fi = []
+    if os.path.exists(champion_meta_path):
+        try:
+            with open(champion_meta_path) as f:
+                meta = json.load(f)
+            champion_model = meta.get('model_name')
+            decision_threshold = meta.get('decision_threshold')
+            shap_generated = bool(meta.get('shap_generated'))
+        except Exception:
+            pass
+    if os.path.exists(shap_values_sample_path):
+        try:
+            with open(shap_values_sample_path) as f:
+                raw_local = json.load(f)[:3]
+            # Adapt shape: ensure keys top_positive_contributors / top_negative_contributors
+            adapted = []
+            for rec in raw_local:
+                shap_vals = rec.get('shap_values', {})
+                positives = sorted([(k,v) for k,v in shap_vals.items() if v > 0], key=lambda x: x[1], reverse=True)[:5]
+                negatives = sorted([(k,v) for k,v in shap_vals.items() if v < 0], key=lambda x: x[1])[:5]
+                adapted.append({
+                    'category': rec.get('category','sample'),
+                    'probability': rec.get('probability'),
+                    'top_positive_contributors': [{'feature': f, 'shap': v} for f,v in positives],
+                    'top_negative_contributors': [{'feature': f, 'shap': v} for f,v in negatives]
+                })
+            local_examples = adapted
+        except Exception:
+            local_examples = []
+    return {
+        'champion_model': champion_model,
+        'shap_generated': shap_generated and bool(fi),
+        'shap_timestamp': None,
+        'decision_threshold': decision_threshold,
+        'top_features': fi,
+        'local_examples': local_examples,
+        'feature_name_map': {},
+        'artifacts_available': []
+    }

app/schemas.py

@@ -0,0 +1,80 @@
+"""Pydantic request/response models."""
+from __future__ import annotations
+from pydantic import BaseModel, Field, ConfigDict
+from typing import Optional
+
+
+class BookingFeatures(BaseModel):
+    """Public prediction payload schema.
+
+    Many training-time features are internal or engineered; to keep the public
+    contract lightweight we make several fields optional with neutral defaults.
+    This enables a *minimal* JSON payload such as:
+        {"lead_time": 30, "arrival_month": 7, "adults": 2, "children": 0, "adr": 120.0}
+    The `_prepare` function supplements / engineers the remaining columns.
+    """
+
+    lead_time: int = Field(..., ge=0)
+    arrival_month: int = Field(..., ge=1, le=12)
+    # Stay details (optional, defaulting to a short weekday stay)
+    stays_weekend_nights: int | None = Field(0, ge=0)
+    stays_week_nights: int | None = Field(1, ge=0)
+    # Guest composition
+    adults: int = Field(..., ge=1)
+    children: int | None = Field(0, ge=0)
+    # Historical / behavioral signals
+    is_repeated_guest: int | None = Field(0, ge=0, le=1)
+    previous_cancellations: int | None = Field(0, ge=0)
+    booking_changes: int | None = Field(0, ge=0)
+    # Pricing
+    adr: float = Field(..., ge=0, description="Average daily rate (numeric, required)")
+    # Amenities / request counts
+    required_car_parking_spaces: int | None = Field(0, ge=0)
+    total_of_special_requests: int | None = Field(0, ge=0)
+
+    model_config = ConfigDict(json_schema_extra={
+        "examples": [
+            {
+                "summary": "Minimal",
+                "value": {
+                    "lead_time": 30,
+                    "arrival_month": 7,
+                    "adults": 2,
+                    "children": 0,
+                    "adr": 120.0
+                }
+            },
+            {
+                "summary": "Extended",
+                "value": {
+                    "lead_time": 120,
+                    "arrival_month": 7,
+                    "stays_weekend_nights": 2,
+                    "stays_week_nights": 3,
+                    "adults": 2,
+                    "children": 1,
+                    "is_repeated_guest": 0,
+                    "previous_cancellations": 0,
+                    "booking_changes": 1,
+                    "adr": 95.5,
+                    "required_car_parking_spaces": 0,
+                    "total_of_special_requests": 2
+                }
+            }
+        ]
+    })
+
+
+class PredictionResponse(BaseModel):
+    prediction: int
+    probability: float
+    model_version: str | None = None
+    applied_threshold: float | None = None
+    threshold_source: str | None = None
+
+
+class HealthResponse(BaseModel):
+    status: str
+    model_loaded: bool
+    model_version: Optional[str] = None
+    decision_threshold: Optional[float] = None

artifacts/champion_meta.json

@@ -0,0 +1,49 @@
+{
+  "selection_metric": "f1_score_mean",
+  "tie_breaker": "roc_auc_mean",
+  "model_name": "XGBoost",
+  "aggregate": {
+    "accuracy_mean": 0.8612111567132926,
+    "accuracy_std": 0.001627924593816666,
+    "precision_mean": 0.8386227780432687,
+    "precision_std": 0.002350895530949529,
+    "recall_mean": 0.7743306030104373,
+    "recall_std": 0.005137556231553914,
+    "f1_score_mean": 0.8051857268662059,
+    "f1_score_std": 0.0027598960622244877,
+    "roc_auc_mean": 0.9376353669900619,
+    "roc_auc_std": 0.0010218562950094605
+  },
+  "cv_folds": 5,
+  "timestamp": "2025-10-05T12:26:19.676359+00:00",
+  "notes": "Model will be (re)trained on training split below; final persisted champion artifact occurs after training.",
+  "persisted_path": "models/champion_model.pkl",
+  "holdout_metrics": {
+    "accuracy": 0.8613786749308987,
+    "precision": 0.841708852944808,
+    "recall": 0.7707179197286602,
+    "f1_score": 0.8046506137865911,
+    "roc_auc": 0.9384035807110922
+  },
+  "holdout_timestamp": "2025-10-05T16:43:04.352749+00:00",
+  "decision_threshold": 0.35000000000000003,
+  "decision_threshold_metrics": {
+    "precision": 0.7663852030558906,
+    "recall": 0.8619559072922555,
+    "f1_score": 0.811365934124408
+  },
+  "diagnostics_generated": "2025-10-05T16:43:06.126491+00:00",
+  "shap_generated": true,
+  "shap_timestamp": "2025-10-05T16:43:10.217872+00:00",
+  "library_versions": {
+    "python": "3.12.7",
+    "pandas": "2.3.3",
+    "numpy": "2.3.3",
+    "sklearn": "1.7.2",
+    "xgboost": "3.0.5",
+    "torch": "2.8.0",
+    "mlflow": "3.4.0",
+    "shap": "0.48.0",
+    "fastapi": "0.118.0"
+  }
+}

artifacts/classification_report.json

@@ -0,0 +1,27 @@
+{
+  "0": {
+    "precision": 0.8714747449141264,
+    "recall": 0.9147209472493847,
+    "f1-score": 0.8925743216928469,
+    "support": 15033.0
+  },
+  "1": {
+    "precision": 0.841708852944808,
+    "recall": 0.7707179197286602,
+    "f1-score": 0.8046506137865911,
+    "support": 8845.0
+  },
+  "accuracy": 0.8613786749308987,
+  "macro avg": {
+    "precision": 0.8565917989294671,
+    "recall": 0.8427194334890225,
+    "f1-score": 0.848612467739719,
+    "support": 23878.0
+  },
+  "weighted avg": {
+    "precision": 0.8604487245410373,
+    "recall": 0.8613786749308987,
+    "f1-score": 0.8600052122016485,
+    "support": 23878.0
+  }
+}

artifacts/cv_metrics.json

@@ -0,0 +1,161 @@
+{
+  "folds": 5,
+  "categorical_strategy": "target",
+  "include_mlp": false,
+  "results": {
+    "LogisticRegression": {
+      "folds": [
+        {
+          "accuracy": 0.8070190133176983,
+          "precision": 0.796804932735426,
+          "recall": 0.6429217548620534,
+          "f1_score": 0.711639549436796,
+          "roc_auc": 0.8867040527525519
+        },
+        {
+          "accuracy": 0.8130496691515202,
+          "precision": 0.8030994880309948,
+          "recall": 0.6561899378179763,
+          "f1_score": 0.7222498755599801,
+          "roc_auc": 0.890793004589075
+        },
+        {
+          "accuracy": 0.8100762207890108,
+          "precision": 0.8030089988751407,
+          "recall": 0.6456755228942905,
+          "f1_score": 0.7157987090305196,
+          "roc_auc": 0.889186762553699
+        },
+        {
+          "accuracy": 0.8098249434626016,
+          "precision": 0.7980609418282548,
+          "recall": 0.6514414923685699,
+          "f1_score": 0.7173358232181761,
+          "roc_auc": 0.8909674615600719
+        },
+        {
+          "accuracy": 0.8133009464779295,
+          "precision": 0.8094230497954578,
+          "recall": 0.648728094968909,
+          "f1_score": 0.7202209112589432,
+          "roc_auc": 0.8904796972569523
+        }
+      ],
+      "aggregate": {
+        "accuracy_mean": 0.8106541586397521,
+        "accuracy_std": 0.0025971064646111972,
+        "precision_mean": 0.8020794822530547,
+        "precision_std": 0.0049950459694398566,
+        "recall_mean": 0.6489913605823598,
+        "recall_std": 0.005141178414132198,
+        "f1_score_mean": 0.717448973700883,
+        "f1_score_std": 0.004099325654318532,
+        "roc_auc_mean": 0.88962619574247,
+        "roc_auc_std": 0.0017762969131121652
+      }
+    },
+    "RandomForest": {
+      "folds": [
+        {
+          "accuracy": 0.8455063238127146,
+          "precision": 0.8715583105088655,
+          "recall": 0.6836273179556762,
+          "f1_score": 0.7662378809961345,
+          "roc_auc": 0.926749180073486
+        },
+        {
+          "accuracy": 0.8513275818745288,
+          "precision": 0.8743107592252227,
+          "recall": 0.699152063312606,
+          "f1_score": 0.7769820329187084,
+          "roc_auc": 0.9279393624961584
+        },
+        {
+          "accuracy": 0.8490242063824441,
+          "precision": 0.8785033227390927,
+          "recall": 0.6875070661390617,
+          "f1_score": 0.7713578994101604,
+          "roc_auc": 0.9265822313578301
+        },
+        {
+          "accuracy": 0.8504062316776949,
+          "precision": 0.8647115783649191,
+          "recall": 0.7067269643866592,
+          "f1_score": 0.7777777777777778,
+          "roc_auc": 0.9282198571471385
+        },
+        {
+          "accuracy": 0.8515369796465365,
+          "precision": 0.8821747908854918,
+          "recall": 0.6915771622385528,
+          "f1_score": 0.7753343050890424,
+          "roc_auc": 0.9290067109566416
+        }
+      ],
+      "aggregate": {
+        "accuracy_mean": 0.8495602646787838,
+        "accuracy_std": 0.002473270473483476,
+        "precision_mean": 0.8742517523447184,
+        "precision_std": 0.006691849909345141,
+        "recall_mean": 0.6937181148065112,
+        "recall_std": 0.009270153023255628,
+        "f1_score_mean": 0.7735379792383648,
+        "f1_score_std": 0.004772535132748273,
+        "roc_auc_mean": 0.9276994684062508,
+        "roc_auc_std": 0.0010232916543342055
+      }
+    },
+    "XGBoost": {
+      "folds": [
+        {
+          "accuracy": 0.859703492754837,
+          "precision": 0.8373863915499877,
+          "recall": 0.7709181365897784,
+          "f1_score": 0.8027787589779819,
+          "roc_auc": 0.9366735339592387
+        },
+        {
+          "accuracy": 0.8613367953764972,
+          "precision": 0.8363724775103331,
+          "recall": 0.7778405879027699,
+          "f1_score": 0.8060453400503779,
+          "roc_auc": 0.9374002707516237
+        },
+        {
+          "accuracy": 0.8604992042884664,
+          "precision": 0.841635687732342,
+          "recall": 0.7678914641040135,
+          "f1_score": 0.8030741945019214,
+          "roc_auc": 0.9368807090577477
+        },
+        {
+          "accuracy": 0.8605829633972695,
+          "precision": 0.8370813981911513,
+          "recall": 0.774335782928208,
+          "f1_score": 0.8044869912491924,
+          "roc_auc": 0.9380101143228257
+        },
+        {
+          "accuracy": 0.8639333277493928,
+          "precision": 0.8406379352325298,
+          "recall": 0.7806670435274167,
+          "f1_score": 0.8095433495515564,
+          "roc_auc": 0.9392122068588733
+        }
+      ],
+      "aggregate": {
+        "accuracy_mean": 0.8612111567132926,
+        "accuracy_std": 0.001627924593816666,
+        "precision_mean": 0.8386227780432687,
+        "precision_std": 0.002350895530949529,
+        "recall_mean": 0.7743306030104373,
+        "recall_std": 0.005137556231553914,
+        "f1_score_mean": 0.8051857268662059,
+        "f1_score_std": 0.0027598960622244877,
+        "roc_auc_mean": 0.9376353669900619,
+        "roc_auc_std": 0.0010218562950094605
+      }
+    }
+  },
+  "timestamp": "2025-10-05T12:26:19.675852+00:00"
+}

artifacts/distribution_baselines.json

@@ -0,0 +1,239 @@
+{
+  "created_utc": "2025-10-04T14:18:28.568003",
+  "columns": {
+    "hotel": {
+      "top_value_proportions": {
+        "0": 0.664461,
+        "1": 0.335539
+      },
+      "n_unique": 2
+    },
+    "market_segment": {
+      "top_value_proportions": {
+        "6": 0.473046,
+        "5": 0.202856,
+        "4": 0.165935,
+        "3": 0.105587,
+        "2": 0.04435,
+        "1": 0.006223,
+        "0": 0.001985,
+        "7": 1.7e-05
+      },
+      "n_unique": 8
+    },
+    "distribution_channel": {
+      "top_value_proportions": {
+        "3": 0.81975,
+        "1": 0.122665,
+        "0": 0.055926,
+        "2": 0.001617,
+        "4": 4.2e-05
+      },
+      "n_unique": 5
+    },
+    "reserved_room_type": {
+      "top_value_proportions": {
+        "0": 0.720278,
+        "3": 0.160826,
+        "4": 0.054737,
+        "5": 0.024265,
+        "6": 0.017539,
+        "1": 0.009364,
+        "2": 0.007806,
+        "7": 0.005034,
+        "9": 0.000101,
+        "8": 5e-05
+      },
+      "n_unique": 10
+    },
+    "customer_type": {
+      "top_value_proportions": {
+        "2": 0.750591,
+        "3": 0.210436,
+        "0": 0.03414,
+        "1": 0.004833
+      },
+      "n_unique": 4
+    },
+    "guest_type": {
+      "top_value_proportions": {
+        "couple": 0.683114,
+        "solo_traveler": 0.189103,
+        "family_with_children": 0.070517,
+        "group": 0.049585,
+        "family_with_babies": 0.007681
+      },
+      "n_unique": 5
+    },
+    "arrival_season": {
+      "top_value_proportions": {
+        "winter": 0.297127,
+        "summer": 0.279705,
+        "autumn": 0.249141,
+        "spring": 0.174026
+      },
+      "n_unique": 4
+    },
+    "hotel_target_encoded": {
+      "top_value_proportions": {
+        "0.41777805836582016": 0.133772,
+        "0.41785133877151737": 0.133604,
+        "0.41697259993382385": 0.132867,
+        "0.41866796764344844": 0.132239,
+        "0.41508187438063326": 0.131979,
+        "0.2775603494160744": 0.068021,
+        "0.27735376915858617": 0.067761,
+        "0.27948197846777967": 0.067133,
+        "0.27516882955217375": 0.066396,
+        "0.2786054178459242": 0.066228
+      },
+      "n_unique": 10
+    },
+    "market_segment_target_encoded": {
+      "top_value_proportions": {
+        "0.36711726709728976": 0.095703,
+        "0.368653079308817": 0.094958,
+        "0.36769683428091055": 0.09443,
+        "0.3667654736096978": 0.094405,
+        "0.365829434095524": 0.093551,
+        "0.34480257021453": 0.041218,
+        "0.3420074349442379": 0.040632,
+        "0.3410017021715583": 0.040472,
+        "0.34453261877769764": 0.040313,
+        "0.343461914816913": 0.040221,
+        "0.6071020925808497": 0.033847,
+        "0.6109952606635071": 0.033386,
+        "0.614203576167309": 0.03337,
+        "0.6104215235334888": 0.033001,
+        "0.6103692558460284": 0.032331,
+        "0.15239520958083833": 0.02166,
+        "0.1561072492552135": 0.021241,
+        "0.15370902248192533": 0.021015,
+        "0.1535950944515874": 0.020898,
+        "0.15129369938771478": 0.020772,
+        "0.1863398381722989": 0.009155,
+        "0.1911100546707868": 0.009113,
+        "0.18545712932259592": 0.008987,
+        "0.18583862620559868": 0.008744,
+        "0.18799441600744532": 0.008351,
+        "0.125": 0.001332,
+        "0.14188034188034188": 0.001323,
+        "0.1218274111675127": 0.001273,
+        "0.13210702341137123": 0.001215,
+        "0.13192182410423453": 0.00108,
+        "0.22043010891237144": 0.000427,
+        "0.2287234053269401": 0.00041,
+        "0.2116402127267593": 0.000402,
+        "0.20942408467164003": 0.000385,
+        "0.22680412430742453": 0.00036,
+        "0.6852081413853757": 1.7e-05
+      },
+      "n_unique": 36
+    },
+    "distribution_channel_target_encoded": {
+      "top_value_proportions": {
+        "0.4109862288541946": 0.164696,
+        "0.41108456516462033": 0.164159,
+        "0.4109083479127026": 0.163858,
+        "0.4100920593981026": 0.163757,
+        "0.4082244564662652": 0.16328,
+        "0.1772357723577236": 0.024793,
+        "0.17429622657653804": 0.024776,
+        "0.17191097467382963": 0.024441,
+        "0.17558813501534265": 0.024399,
+        "0.17397225295769853": 0.024257,
+        "0.21781804454511136": 0.01155,
+        "0.2185617469879518": 0.011433,
+        "0.2206432311144353": 0.011132,
+        "0.22444402915342926": 0.011106,
+        "0.22226338210779775": 0.010704,
+        "0.19463093816188887": 0.000369,
+        "0.18000006437483895": 0.00036,
+        "0.19736846895085886": 0.000343,
+        "0.20512823579560657": 0.00031,
+        "0.18181819604499994": 0.000235,
+        "0.43844503735226303": 2.5e-05,
+        "0.7320759378395608": 8e-06,
+        "0.588465308636646": 8e-06
+      },
+      "n_unique": 23
+    },
+    "reserved_room_type_target_encoded": {
+      "top_value_proportions": {
+        "0.3896345901878003": 0.144937,
+        "0.3905292722324898": 0.144711,
+        "0.3910365366456018": 0.143722,
+        "0.39163580919189717": 0.143471,
+        "0.39252784271588087": 0.143437,
+        "0.3161205766710354": 0.033009,
+        "0.31908924843423797": 0.03244,
+        "0.31619084865076263": 0.032323,
+        "0.3189817520618222": 0.031845,
+        "0.318578352180937": 0.031209,
+        "0.2947429454967143": 0.0114,
+        "0.2954064962521622": 0.011157,
+        "0.29563227160022887": 0.010822,
+        "0.28764773160503243": 0.010797,
+        "0.2910504361016306": 0.010562,
+        "0.30065934065934063": 0.00521,
+        "0.3119861531804414": 0.004908,
+        "0.2967602591792657": 0.004875,
+        "0.3099742046431642": 0.004783,
+        "0.29944938585345193": 0.004489,
+        "0.37227602905569007": 0.003702,
+        "0.35645355850422195": 0.003652,
+        "0.3641826923076923": 0.003602,
+        "0.3662551440329218": 0.003292,
+        "0.3627278071722516": 0.003292,
+        "0.3403019744483159": 0.002153,
+        "0.3164983164983165": 0.001901,
+        "0.32297447280799113": 0.001818,
+        "0.33074361820199777": 0.001818,
+        "0.3355119825708061": 0.001675,
+        "0.32103825136612024": 0.001675,
+        "0.33694181326116374": 0.001617,
+        "0.3247978436657682": 0.001591,
+        "0.32754010695187163": 0.001541,
+        "0.34159061277705344": 0.001382,
+        "0.40425531914893614": 0.001097,
+        "0.41226215644820297": 0.001072,
+        "0.40794979079497906": 0.00103,
+        "0.4086242299794661": 0.000955,
+        "0.40524193548387094": 0.000879,
+        "0.8048129813923957": 5e-05,
+        "0.8180185133956868": 5e-05,
+        "0.3012440502308165": 1.7e-05,
+        "0.44485467943373125": 1.7e-05,
+        "0.3881276892161587": 8e-06,
+        "0.26839015719366827": 8e-06
+      },
+      "n_unique": 46
+    },
+    "customer_type_target_encoded": {
+      "top_value_proportions": {
+        "0.4066526151226253": 0.150532,
+        "0.40595648472499407": 0.150431,
+        "0.4087548475295037": 0.150155,
+        "0.4077947430802482": 0.149912,
+        "0.40815530192176375": 0.14956,
+        "0.2551534814075368": 0.042625,
+        "0.2534256813991729": 0.04234,
+        "0.2539493293591654": 0.041829,
+        "0.2543964232488823": 0.041829,
+        "0.25456983906218955": 0.041813,
+        "0.30964939497362703": 0.007145,
+        "0.3082614056720099": 0.006969,
+        "0.3088235294117647": 0.006801,
+        "0.31187061336588345": 0.006692,
+        "0.3094660194174757": 0.006533,
+        "0.10398230088495575": 0.001047,
+        "0.09740259740259741": 0.000963,
+        "0.10367170626349892": 0.000955,
+        "0.0967741935483871": 0.000938,
+        "0.10944206008583691": 0.00093
+      },
+      "n_unique": 20
+    }
+  },
+  "target_mean": 0.37041628277075134
+}

artifacts/dropped_columns.json

@@ -0,0 +1,11 @@
+{
+  "timestamp": "2025-10-05T02:04:46.609259+00:00",
+  "categorical_strategy": "drop",
+  "dropped_columns": [
+    "country",
+    "guest_type",
+    "arrival_season",
+    "arrival_quarter"
+  ],
+  "remaining_feature_count": 37
+}

artifacts/fairness_group_metrics.json

@@ -0,0 +1,5 @@
+{
+  "error": "feature_shape_mismatch",
+  "message": "Feature shape mismatch, expected: 41, got 28",
+  "note": "Full encoded feature space not reconstructed; run full pipeline-based fairness later."
+}

artifacts/fairness_group_outcome_only.json

@@ -0,0 +1,62 @@
+[
+  {
+    "group": "lead_time_bucket",
+    "value": "LT_180+",
+    "cancellation_rate": 0.5684,
+    "support": 24962
+  },
+  {
+    "group": "lead_time_bucket",
+    "value": "LT_30_89",
+    "cancellation_rate": 0.3779,
+    "support": 29919
+  },
+  {
+    "group": "lead_time_bucket",
+    "value": "LT_90_179",
+    "cancellation_rate": 0.4455,
+    "support": 26462
+  },
+  {
+    "group": "lead_time_bucket",
+    "value": "LT_<30",
+    "cancellation_rate": 0.1825,
+    "support": 38047
+  },
+  {
+    "group": "special_requests_bucket",
+    "value": "SR_0",
+    "cancellation_rate": 0.4772,
+    "support": 70318
+  },
+  {
+    "group": "special_requests_bucket",
+    "value": "SR_1",
+    "cancellation_rate": 0.2202,
+    "support": 33226
+  },
+  {
+    "group": "special_requests_bucket",
+    "value": "SR_2_3",
+    "cancellation_rate": 0.2141,
+    "support": 15466
+  },
+  {
+    "group": "special_requests_bucket",
+    "value": "SR_4+",
+    "cancellation_rate": 0.1,
+    "support": 380
+  },
+  {
+    "group": "is_repeated_guest_str",
+    "value": "0",
+    "cancellation_rate": 0.3779,
+    "support": 115580
+  },
+  {
+    "group": "is_repeated_guest_str",
+    "value": "1",
+    "cancellation_rate": 0.1449,
+    "support": 3810
+  }
+]

artifacts/fairness_summary.md

@@ -0,0 +1,10 @@
+# Fairness Analysis
+
+Fairness analysis artifacts will be generated here when running `scripts/fairness_analysis.py`.
+
+Run with encoded features:
+```bash
+python scripts/fairness_analysis.py
+```
+
+This will generate subgroup performance metrics and fairness evaluations.

artifacts/feature_contract.json

@@ -0,0 +1,89 @@
+{
+  "created_utc": "2025-10-04T14:18:28.557575",
+  "feature_order": [
+    "hotel",
+    "lead_time",
+    "arrival_date_year",
+    "arrival_date_month",
+    "arrival_date_week_number",
+    "arrival_date_day_of_month",
+    "stays_in_weekend_nights",
+    "stays_in_week_nights",
+    "adults",
+    "children",
+    "babies",
+    "meal",
+    "country",
+    "market_segment",
+    "distribution_channel",
+    "is_repeated_guest",
+    "previous_cancellations",
+    "previous_bookings_not_canceled",
+    "reserved_room_type",
+    "assigned_room_type",
+    "booking_changes",
+    "deposit_type",
+    "days_in_waiting_list",
+    "customer_type",
+    "adr",
+    "required_car_parking_spaces",
+    "total_of_special_requests",
+    "total_stay_duration",
+    "total_guests",
+    "is_family",
+    "guest_type",
+    "arrival_season",
+    "is_peak_season",
+    "arrival_quarter",
+    "is_summer_peak",
+    "is_holiday_season",
+    "hotel_target_encoded",
+    "market_segment_target_encoded",
+    "distribution_channel_target_encoded",
+    "reserved_room_type_target_encoded",
+    "customer_type_target_encoded"
+  ],
+  "dtypes": {
+    "hotel": "int64",
+    "lead_time": "int64",
+    "arrival_date_year": "int64",
+    "arrival_date_month": "int64",
+    "arrival_date_week_number": "int64",
+    "arrival_date_day_of_month": "int64",
+    "stays_in_weekend_nights": "int64",
+    "stays_in_week_nights": "int64",
+    "adults": "int64",
+    "children": "float64",
+    "babies": "int64",
+    "meal": "int64",
+    "country": "object",
+    "market_segment": "int64",
+    "distribution_channel": "int64",
+    "is_repeated_guest": "int64",
+    "previous_cancellations": "int64",
+    "previous_bookings_not_canceled": "int64",
+    "reserved_room_type": "int64",
+    "assigned_room_type": "int64",
+    "booking_changes": "int64",
+    "deposit_type": "int64",
+    "days_in_waiting_list": "int64",
+    "customer_type": "int64",
+    "adr": "float64",
+    "required_car_parking_spaces": "int64",
+    "total_of_special_requests": "int64",
+    "total_stay_duration": "int64",
+    "total_guests": "float64",
+    "is_family": "int64",
+    "guest_type": "object",
+    "arrival_season": "object",
+    "is_peak_season": "int64",
+    "arrival_quarter": "object",
+    "is_summer_peak": "int64",
+    "is_holiday_season": "int64",
+    "hotel_target_encoded": "float64",
+    "market_segment_target_encoded": "float64",
+    "distribution_channel_target_encoded": "float64",
+    "reserved_room_type_target_encoded": "float64",
+    "customer_type_target_encoded": "float64"
+  }
+}

artifacts/feature_importance.json

@@ -0,0 +1,166 @@
+[
+  {
+    "feature": "deposit_type",
+    "mean_abs_shap": 1.004747748374939
+  },
+  {
+    "feature": "country__te",
+    "mean_abs_shap": 0.8516273498535156
+  },
+  {
+    "feature": "market_segment",
+    "mean_abs_shap": 0.43541011214256287
+  },
+  {
+    "feature": "total_of_special_requests",
+    "mean_abs_shap": 0.4210052192211151
+  },
+  {
+    "feature": "lead_time",
+    "mean_abs_shap": 0.41456905007362366
+  },
+  {
+    "feature": "required_car_parking_spaces",
+    "mean_abs_shap": 0.4020047187805176
+  },
+  {
+    "feature": "assigned_room_type",
+    "mean_abs_shap": 0.3292023837566376
+  },
+  {
+    "feature": "customer_type_target_encoded",
+    "mean_abs_shap": 0.2506164312362671
+  },
+  {
+    "feature": "reserved_room_type",
+    "mean_abs_shap": 0.23714518547058105
+  },
+  {
+    "feature": "previous_cancellations",
+    "mean_abs_shap": 0.21544909477233887
+  },
+  {
+    "feature": "arrival_date_year",
+    "mean_abs_shap": 0.2018701285123825
+  },
+  {
+    "feature": "adr",
+    "mean_abs_shap": 0.1720850169658661
+  },
+  {
+    "feature": "booking_changes",
+    "mean_abs_shap": 0.13707901537418365
+  },
+  {
+    "feature": "market_segment_target_encoded",
+    "mean_abs_shap": 0.12096284329891205
+  },
+  {
+    "feature": "hotel",
+    "mean_abs_shap": 0.08043359220027924
+  },
+  {
+    "feature": "previous_bookings_not_canceled",
+    "mean_abs_shap": 0.07711290568113327
+  },
+  {
+    "feature": "arrival_date_week_number",
+    "mean_abs_shap": 0.053753212094306946
+  },
+  {
+    "feature": "total_stay_duration",
+    "mean_abs_shap": 0.04918520152568817
+  },
+  {
+    "feature": "distribution_channel_target_encoded",
+    "mean_abs_shap": 0.046840302646160126
+  },
+  {
+    "feature": "meal",
+    "mean_abs_shap": 0.02777845785021782
+  },
+  {
+    "feature": "stays_in_weekend_nights",
+    "mean_abs_shap": 0.02747640572488308
+  },
+  {
+    "feature": "is_peak_season",
+    "mean_abs_shap": 0.026596231386065483
+  },
+  {
+    "feature": "adults",
+    "mean_abs_shap": 0.02620122581720352
+  },
+  {
+    "feature": "customer_type",
+    "mean_abs_shap": 0.024083152413368225
+  },
+  {
+    "feature": "arrival_season__te",
+    "mean_abs_shap": 0.021409466862678528
+  },
+  {
+    "feature": "stays_in_week_nights",
+    "mean_abs_shap": 0.020597653463482857
+  },
+  {
+    "feature": "arrival_date_month",
+    "mean_abs_shap": 0.020358875393867493
+  },
+  {
+    "feature": "reserved_room_type_target_encoded",
+    "mean_abs_shap": 0.017543498426675797
+  },
+  {
+    "feature": "arrival_date_day_of_month",
+    "mean_abs_shap": 0.016908343881368637
+  },
+  {
+    "feature": "hotel_target_encoded",
+    "mean_abs_shap": 0.014303297735750675
+  },
+  {
+    "feature": "distribution_channel",
+    "mean_abs_shap": 0.012937864288687706
+  },
+  {
+    "feature": "is_repeated_guest",
+    "mean_abs_shap": 0.012019594199955463
+  },
+  {
+    "feature": "children",
+    "mean_abs_shap": 0.011608750559389591
+  },
+  {
+    "feature": "days_in_waiting_list",
+    "mean_abs_shap": 0.008652577176690102
+  },
+  {
+    "feature": "guest_type__te",
+    "mean_abs_shap": 0.008242463693022728
+  },
+  {
+    "feature": "total_guests",
+    "mean_abs_shap": 0.006184790749102831
+  },
+  {
+    "feature": "is_family",
+    "mean_abs_shap": 0.005206487141549587
+  },
+  {
+    "feature": "is_summer_peak",
+    "mean_abs_shap": 0.002421196084469557
+  },
+  {
+    "feature": "is_holiday_season",
+    "mean_abs_shap": 0.0011103155557066202
+  },
+  {
+    "feature": "arrival_quarter__te",
+    "mean_abs_shap": 0.0009324172860942781
+  },
+  {
+    "feature": "babies",
+    "mean_abs_shap": 0.00015189241094049066
+  }
+]

artifacts/feature_name_map.json

@@ -0,0 +1,43 @@
+{
+  "hotel": "Hotel",
+  "lead_time": "Lead Time",
+  "arrival_date_year": "Arrival Date Year",
+  "arrival_date_month": "Arrival Date Month",
+  "arrival_date_week_number": "Arrival Date Week Number",
+  "arrival_date_day_of_month": "Arrival Date Day Of Month",
+  "stays_in_weekend_nights": "Stays In Weekend Nights",
+  "stays_in_week_nights": "Stays In Week Nights",
+  "adults": "Adults",
+  "children": "Children",
+  "babies": "Babies",
+  "meal": "Meal",
+  "market_segment": "Market Segment",
+  "distribution_channel": "Distribution Channel",
+  "is_repeated_guest": "Is Repeated Guest",
+  "previous_cancellations": "Previous Cancellations",
+  "previous_bookings_not_canceled": "Previous Bookings Not Canceled",
+  "reserved_room_type": "Reserved Room Type",
+  "assigned_room_type": "Assigned Room Type",
+  "booking_changes": "Booking Changes",
+  "deposit_type": "Deposit Type",
+  "days_in_waiting_list": "Days In Waiting List",
+  "customer_type": "Customer Type",
+  "adr": "Adr",
+  "required_car_parking_spaces": "Required Car Parking Spaces",
+  "total_of_special_requests": "Total Of Special Requests",
+  "total_stay_duration": "Total stay duration (nights)",
+  "total_guests": "Total guests (adults + children + babies)",
+  "is_family": "Family booking flag",
+  "is_peak_season": "Peak season flag",
+  "is_summer_peak": "Summer peak season flag",
+  "is_holiday_season": "Holiday season flag",
+  "hotel_target_encoded": "Hotel (target encoded)",
+  "market_segment_target_encoded": "Market Segment (target encoded)",
+  "distribution_channel_target_encoded": "Distribution Channel (target encoded)",
+  "reserved_room_type_target_encoded": "Reserved Room Type (target encoded)",
+  "customer_type_target_encoded": "Customer Type (target encoded)",
+  "country__te": "Country  (target encoded)",
+  "guest_type__te": "Guest Type  (target encoded)",
+  "arrival_season__te": "Arrival Season  (target encoded)",
+  "arrival_quarter__te": "Arrival Quarter  (target encoded)"
+}

artifacts/feature_rules.json

@@ -0,0 +1,53 @@
+{
+  "created_utc": "2025-10-04T14:18:28.567902",
+  "rules": {
+    "guest_type_rule": [
+      {
+        "if": "babies>0",
+        "return": "family_with_babies"
+      },
+      {
+        "elif": "children>0",
+        "return": "family_with_children"
+      },
+      {
+        "elif": "adults==1",
+        "return": "solo_traveler"
+      },
+      {
+        "elif": "adults==2",
+        "return": "couple"
+      },
+      {
+        "else": true,
+        "return": "group"
+      }
+    ],
+    "season_mapping_numeric": {
+      "1": "winter",
+      "2": "winter",
+      "3": "spring",
+      "4": "spring",
+      "5": "spring",
+      "6": "summer",
+      "7": "summer",
+      "8": "summer",
+      "9": "autumn",
+      "10": "autumn",
+      "11": "autumn",
+      "12": "winter"
+    },
+    "peak_months_numeric": [
+      5,
+      6,
+      7,
+      8,
+      9
+    ],
+    "temporal_flags": {
+      "arrival_quarter": "Q{((month-1)//3)+1}",
+      "is_summer_peak": "[7,8]",
+      "is_holiday_season": "[12,1]"
+    }
+  }
+}

artifacts/feature_schema.json

@@ -0,0 +1,242 @@
+{
+  "created_utc": "2025-10-04T14:18:28.567462",
+  "schema": {
+    "hotel": {
+      "dtype": "int64",
+      "nullable": false,
+      "constraints": {}
+    },
+    "lead_time": {
+      "dtype": "int64",
+      "nullable": false,
+      "constraints": {}
+    },
+    "arrival_date_year": {
+      "dtype": "int64",
+      "nullable": false,
+      "constraints": {}
+    },
+    "arrival_date_month": {
+      "dtype": "int64",
+      "nullable": false,
+      "constraints": {}
+    },
+    "arrival_date_week_number": {
+      "dtype": "int64",
+      "nullable": false,
+      "constraints": {}
+    },
+    "arrival_date_day_of_month": {
+      "dtype": "int64",
+      "nullable": false,
+      "constraints": {}
+    },
+    "stays_in_weekend_nights": {
+      "dtype": "int64",
+      "nullable": false,
+      "constraints": {
+        "min": 0
+      }
+    },
+    "stays_in_week_nights": {
+      "dtype": "int64",
+      "nullable": false,
+      "constraints": {
+        "min": 0
+      }
+    },
+    "adults": {
+      "dtype": "int64",
+      "nullable": false,
+      "constraints": {
+        "min": 1
+      }
+    },
+    "children": {
+      "dtype": "float64",
+      "nullable": false,
+      "constraints": {
+        "min": 0
+      }
+    },
+    "babies": {
+      "dtype": "int64",
+      "nullable": false,
+      "constraints": {
+        "min": 0
+      }
+    },
+    "meal": {
+      "dtype": "int64",
+      "nullable": false,
+      "constraints": {}
+    },
+    "country": {
+      "dtype": "object",
+      "nullable": false,
+      "constraints": {}
+    },
+    "market_segment": {
+      "dtype": "int64",
+      "nullable": false,
+      "constraints": {}
+    },
+    "distribution_channel": {
+      "dtype": "int64",
+      "nullable": false,
+      "constraints": {}
+    },
+    "is_repeated_guest": {
+      "dtype": "int64",
+      "nullable": false,
+      "constraints": {}
+    },
+    "previous_cancellations": {
+      "dtype": "int64",
+      "nullable": false,
+      "constraints": {}
+    },
+    "previous_bookings_not_canceled": {
+      "dtype": "int64",
+      "nullable": false,
+      "constraints": {}
+    },
+    "reserved_room_type": {
+      "dtype": "int64",
+      "nullable": false,
+      "constraints": {}
+    },
+    "assigned_room_type": {
+      "dtype": "int64",
+      "nullable": false,
+      "constraints": {}
+    },
+    "booking_changes": {
+      "dtype": "int64",
+      "nullable": false,
+      "constraints": {}
+    },
+    "deposit_type": {
+      "dtype": "int64",
+      "nullable": false,
+      "constraints": {}
+    },
+    "days_in_waiting_list": {
+      "dtype": "int64",
+      "nullable": false,
+      "constraints": {}
+    },
+    "customer_type": {
+      "dtype": "int64",
+      "nullable": false,
+      "constraints": {}
+    },
+    "adr": {
+      "dtype": "float64",
+      "nullable": false,
+      "constraints": {}
+    },
+    "required_car_parking_spaces": {
+      "dtype": "int64",
+      "nullable": false,
+      "constraints": {}
+    },
+    "total_of_special_requests": {
+      "dtype": "int64",
+      "nullable": false,
+      "constraints": {}
+    },
+    "total_stay_duration": {
+      "dtype": "int64",
+      "nullable": false,
+      "constraints": {
+        "min": 0
+      }
+    },
+    "total_guests": {
+      "dtype": "float64",
+      "nullable": false,
+      "constraints": {}
+    },
+    "is_family": {
+      "dtype": "int64",
+      "nullable": false,
+      "constraints": {
+        "values": [
+          0,
+          1
+        ]
+      }
+    },
+    "guest_type": {
+      "dtype": "object",
+      "nullable": false,
+      "constraints": {}
+    },
+    "arrival_season": {
+      "dtype": "object",
+      "nullable": false,
+      "constraints": {}
+    },
+    "is_peak_season": {
+      "dtype": "int64",
+      "nullable": false,
+      "constraints": {
+        "values": [
+          0,
+          1
+        ]
+      }
+    },
+    "arrival_quarter": {
+      "dtype": "object",
+      "nullable": false,
+      "constraints": {}
+    },
+    "is_summer_peak": {
+      "dtype": "int64",
+      "nullable": false,
+      "constraints": {
+        "values": [
+          0,
+          1
+        ]
+      }
+    },
+    "is_holiday_season": {
+      "dtype": "int64",
+      "nullable": false,
+      "constraints": {
+        "values": [
+          0,
+          1
+        ]
+      }
+    },
+    "hotel_target_encoded": {
+      "dtype": "float64",
+      "nullable": false,
+      "constraints": {}
+    },
+    "market_segment_target_encoded": {
+      "dtype": "float64",
+      "nullable": false,
+      "constraints": {}
+    },
+    "distribution_channel_target_encoded": {
+      "dtype": "float64",
+      "nullable": false,
+      "constraints": {}
+    },
+    "reserved_room_type_target_encoded": {
+      "dtype": "float64",
+      "nullable": false,
+      "constraints": {}
+    },
+    "customer_type_target_encoded": {
+      "dtype": "float64",
+      "nullable": false,
+      "constraints": {}
+    }
+  }
+}

artifacts/mte_mappings.json

@@ -0,0 +1,76 @@
+{
+  "created_utc": "2025-10-04T14:18:28.557206",
+  "target": "is_canceled",
+  "n_mappings": 5,
+  "encodings": {
+    "hotel": {
+      "encoded_column": "hotel_target_encoded",
+      "global_mean": 0.37041628277075134,
+      "categories": {
+        "0": 0.4172733063837846,
+        "1": 0.2776361457385911
+      },
+      "unique_categories": 2,
+      "correlation_with_target": 0.1362919003417029
+    },
+    "market_segment": {
+      "encoded_column": "market_segment_target_encoded",
+      "global_mean": 0.37041628277075134,
+      "categories": {
+        "0": 0.2193848011246842,
+        "1": 0.1305293327303513,
+        "2": 0.18735385096984933,
+        "3": 0.1534242478686866,
+        "4": 0.6106102590915212,
+        "5": 0.3431649262546367,
+        "6": 0.36721636358391,
+        "7": 0.6852081413853757
+      },
+      "unique_categories": 8,
+      "correlation_with_target": 0.26658119698812255
+    },
+    "distribution_channel": {
+      "encoded_column": "distribution_channel_target_encoded",
+      "global_mean": 0.37041628277075134,
+      "categories": {
+        "0": 0.22069913242602368,
+        "1": 0.1746080048040754,
+        "2": 0.19210634967836185,
+        "3": 0.41026163306920715,
+        "4": 0.5271752717065992
+      },
+      "unique_categories": 5,
+      "correlation_with_target": 0.17684471269279609
+    },
+    "reserved_room_type": {
+      "encoded_column": "reserved_room_type_target_encoded",
+      "global_mean": 0.37041628277075134,
+      "categories": {
+        "0": 0.3910688675887826,
+        "1": 0.329393513006855,
+        "2": 0.33002021600480985,
+        "3": 0.31777698548798844,
+        "4": 0.2929420080641847,
+        "5": 0.30377929173796275,
+        "6": 0.3643976188473718,
+        "7": 0.40771779125645363,
+        "8": 0.35811921762315374,
+        "9": 0.8114157473940412
+      },
+      "unique_categories": 10,
+      "correlation_with_target": 0.07241322555323557
+    },
+    "customer_type": {
+      "encoded_column": "customer_type_target_encoded",
+      "global_mean": 0.37041628277075134,
+      "categories": {
+        "0": 0.3096018755002309,
+        "1": 0.10226072646950485,
+        "2": 0.40746118084509414,
+        "3": 0.2543000402594656
+      },
+      "unique_categories": 4,
+      "correlation_with_target": 0.1362960500064263
+    }
+  }
+}

artifacts/shap_values_sample.json

@@ -0,0 +1,152 @@
+[
+  {
+    "category": "true_positive",
+    "index": 2,
+    "y_true": 1,
+    "prediction": 1,
+    "probability": 0.7679175138473511,
+    "shap_values": {
+      "hotel": -0.013177326880395412,
+      "lead_time": 0.27093467116355896,
+      "arrival_date_year": 0.10717716068029404,
+      "arrival_date_month": 0.046636875718832016,
+      "arrival_date_week_number": 0.007057845126837492,
+      "arrival_date_day_of_month": 0.015515242703258991,
+      "stays_in_weekend_nights": -0.003432020079344511,
+      "stays_in_week_nights": -0.006210292223840952,
+      "adults": 0.015318267978727818,
+      "children": -0.007357093971222639,
+      "babies": -6.629295239690691e-05,
+      "meal": 0.06084809452295303,
+      "market_segment": 0.5826431512832642,
+      "distribution_channel": -0.005265130195766687,
+      "is_repeated_guest": 0.0023761300835758448,
+      "previous_cancellations": -0.048768918961286545,
+      "previous_bookings_not_canceled": 0.0238479096442461,
+      "reserved_room_type": -0.17490211129188538,
+      "assigned_room_type": 0.3624641001224518,
+      "booking_changes": 0.09503821283578873,
+      "deposit_type": -0.38260650634765625,
+      "days_in_waiting_list": 0.00499193649739027,
+      "customer_type": 0.005631973035633564,
+      "adr": 0.22705571353435516,
+      "required_car_parking_spaces": 0.10856841504573822,
+      "total_of_special_requests": 0.736638605594635,
+      "total_stay_duration": 0.03156501054763794,
+      "total_guests": -0.0028324569575488567,
+      "is_family": -0.004709186032414436,
+      "is_peak_season": 0.03317419812083244,
+      "is_summer_peak": 0.0013722111470997334,
+      "is_holiday_season": -0.017516281455755234,
+      "hotel_target_encoded": -0.008734573610126972,
+      "market_segment_target_encoded": 0.15508981049060822,
+      "distribution_channel_target_encoded": -0.03044990263879299,
+      "reserved_room_type_target_encoded": 0.0011005409760400653,
+      "customer_type_target_encoded": 0.1587882786989212,
+      "country__te": -0.5817746520042419,
+      "guest_type__te": 0.002932904753834009,
+      "arrival_season__te": -0.02166694961488247,
+      "arrival_quarter__te": -0.001362183946184814
+    }
+  },
+  {
+    "category": "false_positive",
+    "index": 7,
+    "y_true": 0,
+    "prediction": 1,
+    "probability": 0.7768429517745972,
+    "shap_values": {
+      "hotel": -0.04107680171728134,
+      "lead_time": 0.20630843937397003,
+      "arrival_date_year": 0.12643642723560333,
+      "arrival_date_month": -0.03379317745566368,
+      "arrival_date_week_number": -0.01691223680973053,
+      "arrival_date_day_of_month": -0.0038236246909946203,
+      "stays_in_weekend_nights": -0.020141033455729485,
+      "stays_in_week_nights": 0.005030508618801832,
+      "adults": 0.012447455897927284,
+      "children": 0.08788547664880753,
+      "babies": -6.629295239690691e-05,
+      "meal": 0.00710188876837492,
+      "market_segment": 0.5442723035812378,
+      "distribution_channel": -0.006446031853556633,
+      "is_repeated_guest": 0.0023962713312357664,
+      "previous_cancellations": -0.054328884929418564,
+      "previous_bookings_not_canceled": 0.027283739298582077,
+      "reserved_room_type": -0.28937697410583496,
+      "assigned_room_type": 0.37023118138313293,
+      "booking_changes": 0.07717075943946838,
+      "deposit_type": -0.37375608086586,
+      "days_in_waiting_list": 0.003258473239839077,
+      "customer_type": 0.0052125826478004456,
+      "adr": 0.2486179769039154,
+      "required_car_parking_spaces": 0.11153995245695114,
+      "total_of_special_requests": 0.7757676243782043,
+      "total_stay_duration": 0.038464903831481934,
+      "total_guests": 0.002308598253875971,
+      "is_family": 0.01916220597922802,
+      "is_peak_season": -0.023274041712284088,
+      "is_summer_peak": -0.0020165895111858845,
+      "is_holiday_season": 4.689610796049237e-05,
+      "hotel_target_encoded": -0.007977521046996117,
+      "market_segment_target_encoded": 0.1509910523891449,
+      "distribution_channel_target_encoded": -0.03097727708518505,
+      "reserved_room_type_target_encoded": -0.036723002791404724,
+      "customer_type_target_encoded": 0.1517724245786667,
+      "country__te": -0.22035948932170868,
+      "guest_type__te": -0.00904961209744215,
+      "arrival_season__te": -0.007437328342348337,
+      "arrival_quarter__te": 0.0005368555430322886
+    }
+  },
+  {
+    "category": "false_negative",
+    "index": 10,
+    "y_true": 1,
+    "prediction": 0,
+    "probability": 0.36954548954963684,
+    "shap_values": {
+      "hotel": -0.05511629208922386,
+      "lead_time": 0.18352645635604858,
+      "arrival_date_year": 0.1316099613904953,
+      "arrival_date_month": 0.02599601075053215,
+      "arrival_date_week_number": -0.07640720903873444,
+      "arrival_date_day_of_month": -0.005574983078986406,
+      "stays_in_weekend_nights": 0.03126369044184685,
+      "stays_in_week_nights": 0.019554395228624344,
+      "adults": 0.014410095289349556,
+      "children": -0.0004327027127146721,
+      "babies": -2.9597815228044055e-05,
+      "meal": 0.005594600923359394,
+      "market_segment": 0.35903194546699524,
+      "distribution_channel": -0.00748800253495574,
+      "is_repeated_guest": 0.001656562671996653,
+      "previous_cancellations": -0.0757187083363533,
+      "previous_bookings_not_canceled": 0.027033040300011635,
+      "reserved_room_type": -0.20557740330696106,
+      "assigned_room_type": 0.19640541076660156,
+      "booking_changes": 0.07736871391534805,
+      "deposit_type": -0.39705631136894226,
+      "days_in_waiting_list": 0.0031135703902691603,
+      "customer_type": 0.007273601833730936,
+      "adr": 0.2758876085281372,
+      "required_car_parking_spaces": 0.12637829780578613,
+      "total_of_special_requests": -1.018623948097229,
+      "total_stay_duration": 0.12197940051555634,
+      "total_guests": -0.0008809716673567891,
+      "is_family": -0.0023323686327785254,
+      "is_peak_season": -0.015776723623275757,
+      "is_summer_peak": 0.0005290449480526149,
+      "is_holiday_season": 4.4685075408779085e-05,
+      "hotel_target_encoded": -0.011267091147601604,
+      "market_segment_target_encoded": 0.12202320247888565,
+      "distribution_channel_target_encoded": -0.027583105489611626,
+      "reserved_room_type_target_encoded": -0.060819387435913086,
+      "customer_type_target_encoded": 0.11991596966981888,
+      "country__te": 0.09951554983854294,
+      "guest_type__te": 0.0032427667174488306,
+      "arrival_season__te": -0.004380077589303255,
+      "arrival_quarter__te": 0.026889480650424957
+    }
+  }
+]

artifacts/threshold_sweep.csv

@@ -0,0 +1,102 @@
+threshold,precision,recall,f1_score
+0.0,0.3704246586816316,1.0,0.5405983558964642
+0.01,0.43009340338587276,0.9995477671000566,0.6014081153702255
+0.02,0.46293383663625876,0.998304126625212,0.6325441455639529
+0.03,0.48265864332603936,0.9975127190503109,0.6505437788018433
+0.04,0.4968429360694554,0.9963821368004522,0.6630553361170674
+0.05,0.5095191250506337,0.9954776710005653,0.6740411850264105
+0.06,0.5218087947302831,0.9941209723007349,0.6843866749688667
+0.07,0.532233610285645,0.9921989824759752,0.6928238730559723
+0.08,0.5413241021202942,0.9900508762012437,0.6999440492366718
+0.09,0.5502205419029615,0.987224420576597,0.7066154157394295
+0.1,0.5585106382978723,0.9853024307518372,0.7129125935621089
+0.11,0.5663670704702358,0.9831543244771057,0.7187073846026696
+0.12,0.574332825640686,0.9805539853024308,0.7243798546730142
+0.13,0.5835020926150938,0.9772752967778406,0.730715583921552
+0.14,0.5936724565756824,0.9737704918032787,0.7376354215732454
+0.15,0.6033598088142265,0.9704918032786886,0.7441054091539528
+0.16,0.6137064944384643,0.9668739400791407,0.7508340649692713
+0.17,0.6232636350343618,0.9638213680045223,0.7570039515162279
+0.18,0.6308150353554149,0.958168456755229,0.7607719928186715
+0.19,0.6401883353584447,0.9530808366308648,0.765911052559851
+0.2,0.6512295399891397,0.9491237987563595,0.7724512329775488
+0.21,0.6593293885601578,0.9448275862068966,0.7766728624535316
+0.22,0.6668272705372199,0.9388355002826455,0.7797915297211006
+0.23,0.6737409191086442,0.9331825890333522,0.7825180128934395
+0.24,0.6818445716181472,0.9294516676088186,0.7866232896373553
+0.25,0.6908783783783784,0.924816280384398,0.7909112883732173
+0.26,0.6998452810727179,0.920520067834935,0.7951560134772205
+0.27,0.7078189300411523,0.9139626907857547,0.7977894009671371
+0.28,0.716501738432736,0.9086489542114189,0.8012162296879674
+0.29,0.723057417134577,0.9026568682871678,0.80293659174335
+0.3,0.7301850317591826,0.8967778405879028,0.8049523036330424
+0.31,0.7381466528964417,0.8888637648388921,0.8065244152646697
+0.32,0.7462929302592557,0.8819672131147541,0.8084775624417038
+0.33,0.7527445836976586,0.8759751271905031,0.8096979830703313
+0.34,0.7594222969631022,0.8679479932165065,0.8100664767331434
+0.35000000000000003,0.7663852030558906,0.8619559072922555,0.811365934124408
+0.36,0.7718635063342869,0.8541548897682306,0.8109268502119895
+0.37,0.777870043595599,0.8472583380440927,0.8110828508036149
+0.38,0.7824395373291272,0.8412662521198417,0.810787251430128
+0.39,0.7876427275637605,0.8344827586206897,0.8103864734299517
+0.4,0.7927937675827743,0.8283776144714528,0.8101951678000774
+0.41000000000000003,0.797544667324345,0.8226116449971735,0.8098842386464826
+0.42,0.8013728963684676,0.8183154324477105,0.809755551826369
+0.43,0.8074848280512474,0.8123233465234596,0.8098968607338105
+0.44,0.8116897884921538,0.8070096099491239,0.8093429332728612
+0.45,0.8169972324723247,0.8010175240248728,0.8089284694867843
+0.46,0.8224561403508772,0.7950254381006219,0.808508192009198
+0.47000000000000003,0.8271766243021736,0.7873374788015828,0.8067655236329935
+0.48,0.8318690576483332,0.7814584511023177,0.8058761804826863
+0.49,0.8362794099719615,0.7755794234030525,0.8047864852182074
+0.5,0.841708852944808,0.7707179197286602,0.8046506137865911
+0.51,0.8476214384335383,0.7634821933295647,0.8033547466095646
+0.52,0.8530878404296126,0.7543244771057095,0.8006720268810752
+0.53,0.8584599402674977,0.7474279253815715,0.7991055239937145
+0.54,0.8627683392598446,0.7406444318824195,0.7970556028713955
+0.55,0.8673988748995446,0.7321650650084793,0.7940653546686285
+0.56,0.8710996048507971,0.7227812323346523,0.7900395452298566
+0.5700000000000001,0.8760536133757082,0.7167891464104014,0.7884591468722796
+0.58,0.8804103428892637,0.7083097795364612,0.7850385314203371
+0.59,0.8839272935451553,0.698247597512719,0.7801920161697827
+0.6,0.8901995048784039,0.6911249293386094,0.7781313645621182
+0.61,0.8951971538689594,0.6827586206896552,0.774677698672311
+0.62,0.9002879224124868,0.6716789146410401,0.7693602693602694
+0.63,0.9062887236679058,0.6615036743923121,0.764786615253905
+0.64,0.9127879269261319,0.6496325607687959,0.7590488771466314
+0.65,0.9175877763328999,0.6382136800452233,0.7528172301126892
+0.66,0.923923923923924,0.6261164499717354,0.7464114832535885
+0.67,0.93071000855432,0.6150367439231204,0.7406398910823689
+0.68,0.9360955056179775,0.6028264556246467,0.7333745959700159
+0.6900000000000001,0.9403686302855078,0.5883550028264556,0.7238333681062661
+0.7000000000000001,0.9439407955596669,0.5768230638778972,0.7160701754385965
+0.71,0.9473384030418252,0.5633691351045789,0.7065579581708614
+0.72,0.9505066250974279,0.5514980214810628,0.6980038634900193
+0.73,0.9555288461538461,0.539287733182589,0.6894558068945581
+0.74,0.9596375617792422,0.5268513284341436,0.6802423180789723
+0.75,0.965042372881356,0.5149802148106275,0.671581275340951
+0.76,0.9696639022261021,0.5023176936122102,0.6618008490355254
+0.77,0.9747007002484752,0.4878462408140192,0.6502411091018686
+0.78,0.9780783582089553,0.4741661955907292,0.6386964136145588
+0.79,0.9814547206165704,0.46071226681741095,0.6270677848734323
+0.8,0.9849233811171527,0.4505370265686829,0.6182608021099992
+0.81,0.9865448083269865,0.43934426229508194,0.6079474342928661
+0.8200000000000001,0.9881013967925505,0.4318824194460147,0.6010542050192746
+0.8300000000000001,0.9899391051098756,0.42272470322215944,0.5924576136903819
+0.84,0.991887506760411,0.4146975692481628,0.5848680538946026
+0.85,0.9934084042845372,0.40893159977388355,0.5793688931603396
+0.86,0.9958088851634534,0.40293951384963256,0.5737282678686413
+0.87,0.9968820861678005,0.3976257772752968,0.5684959185322881
+0.88,0.9971305595408895,0.39287733182589035,0.5636658556366586
+0.89,0.9982507288629737,0.3871113623516111,0.5578818737270875
+0.9,0.9988197108291531,0.38270209157716223,0.5533758378290011
+0.91,0.9991074085093722,0.37964951950254383,0.550221202687203
+0.92,0.999400299850075,0.3768230638778971,0.5472906403940887
+0.93,0.9996982498491249,0.37456189937817974,0.5449461304383584
+0.9400000000000001,0.9996969696969698,0.3729790842283776,0.5432688349114863
+0.9500000000000001,1.0,0.3723007348784624,0.5425935079914319
+0.96,1.0,0.3716223855285472,0.541872733267392
+0.97,1.0,0.36936122102882984,0.5394649933949802
+0.98,1.0,0.36551724137931035,0.5353535353535354
+0.99,1.0,0.34980214810627475,0.5183013652734735
+1.0,0.0,0.0,0.0

artifacts/value_domains.json

@@ -0,0 +1,284 @@
+{
+  "categorical": {
+    "deposit_type": [
+      "No Deposit",
+      "Non Refund",
+      "Refundable"
+    ],
+    "country": [
+      "ABW",
+      "AGO",
+      "AIA",
+      "ALB",
+      "AND",
+      "ARE",
+      "ARG",
+      "ARM",
+      "ASM",
+      "ATA",
+      "ATF",
+      "AUS",
+      "AUT",
+      "AZE",
+      "BDI",
+      "BEL",
+      "BEN",
+      "BFA",
+      "BGD",
+      "BGR",
+      "BHR",
+      "BHS",
+      "BIH",
+      "BLR",
+      "BOL",
+      "BRA",
+      "BRB",
+      "BWA",
+      "CAF",
+      "CHE",
+      "CHL",
+      "CHN",
+      "CIV",
+      "CMR",
+      "CN",
+      "COL",
+      "COM",
+      "CPV",
+      "CRI",
+      "CUB",
+      "CYM",
+      "CYP",
+      "CZE",
+      "DEU",
+      "DJI",
+      "DMA",
+      "DNK",
+      "DOM",
+      "DZA",
+      "ECU",
+      "EGY",
+      "ESP",
+      "EST",
+      "ETH",
+      "FIN",
+      "FJI",
+      "FRA",
+      "FRO",
+      "GAB",
+      "GBR",
+      "GEO",
+      "GGY",
+      "GHA",
+      "GIB",
+      "GLP",
+      "GNB",
+      "GRC",
+      "GTM",
+      "GUY",
+      "HKG",
+      "HND",
+      "HRV",
+      "HUN",
+      "IDN",
+      "IMN",
+      "IND",
+      "IRL",
+      "IRN",
+      "IRQ",
+      "ISL",
+      "ISR",
+      "ITA",
+      "JAM",
+      "JEY",
+      "JOR",
+      "JPN",
+      "KAZ",
+      "KEN",
+      "KHM",
+      "KIR",
+      "KNA",
+      "KOR",
+      "KWT",
+      "LAO",
+      "LBN",
+      "LBY",
+      "LCA",
+      "LIE",
+      "LKA",
+      "LTU",
+      "LUX",
+      "LVA",
+      "MAC",
+      "MAR",
+      "MCO",
+      "MDG",
+      "MDV",
+      "MEX",
+      "MKD",
+      "MLI",
+      "MLT",
+      "MMR",
+      "MNE",
+      "MOZ",
+      "MRT",
+      "MUS",
+      "MWI",
+      "MYS",
+      "MYT",
+      "NAM",
+      "NCL",
+      "NGA",
+      "NIC",
+      "NLD",
+      "NOR",
+      "NPL",
+      "NZL",
+      "OMN",
+      "PAK",
+      "PAN",
+      "PER",
+      "PHL",
+      "PLW",
+      "POL",
+      "PRI",
+      "PRT",
+      "PRY",
+      "PYF",
+      "QAT",
+      "ROU",
+      "RUS",
+      "RWA",
+      "SAU",
+      "SDN",
+      "SEN",
+      "SGP",
+      "SLE",
+      "SLV",
+      "SMR",
+      "SRB",
+      "STP",
+      "SUR",
+      "SVK",
+      "SVN",
+      "SWE",
+      "SYC",
+      "SYR",
+      "TGO",
+      "THA",
+      "TJK",
+      "TMP",
+      "TUN",
+      "TUR",
+      "TWN",
+      "TZA",
+      "UGA",
+      "UKR",
+      "UMI",
+      "URY",
+      "USA",
+      "UZB",
+      "VEN",
+      "VGB",
+      "VNM",
+      "ZAF",
+      "ZMB",
+      "ZWE"
+    ],
+    "market_segment": [
+      "Aviation",
+      "Complementary",
+      "Corporate",
+      "Direct",
+      "Groups",
+      "Offline TA/TO",
+      "Online TA",
+      "Undefined"
+    ],
+    "reserved_room_type": [
+      "A",
+      "B",
+      "C",
+      "D",
+      "E",
+      "F",
+      "G",
+      "H",
+      "L",
+      "P"
+    ],
+    "assigned_room_type": [
+      "A",
+      "B",
+      "C",
+      "D",
+      "E",
+      "F",
+      "G",
+      "H",
+      "I",
+      "K",
+      "L",
+      "P"
+    ],
+    "customer_type": [
+      "Contract",
+      "Group",
+      "Transient",
+      "Transient-Party"
+    ],
+    "distribution_channel": [
+      "Corporate",
+      "Direct",
+      "GDS",
+      "TA/TO",
+      "Undefined"
+    ],
+    "meal": [
+      "BB",
+      "FB",
+      "HB",
+      "SC",
+      "Undefined"
+    ],
+    "room_type_code_set": [
+      "A",
+      "B",
+      "C",
+      "D",
+      "E",
+      "F",
+      "G",
+      "H",
+      "I",
+      "K",
+      "L",
+      "P"
+    ]
+  },
+  "numeric": {
+    "lead_time": {
+      "min": 0.0,
+      "max": 737.0
+    },
+    "required_car_parking_spaces": {
+      "min": 0.0,
+      "max": 8.0
+    },
+    "previous_cancellations": {
+      "min": 0.0,
+      "max": 26.0
+    },
+    "adr": {
+      "min": -6.38,
+      "max": 5400.0
+    },
+    "booking_changes": {
+      "min": 0.0,
+      "max": 21.0
+    },
+    "total_of_special_requests": {
+      "min": 0.0,
+      "max": 5.0
+    }
+  }
+}

main.py

@@ -0,0 +1,21 @@
+"""Minimal FastAPI bootstrap that wires modular routes and startup load."""
+from fastapi import FastAPI
+import os
+from app.routes import router, startup_load
+from app import config
+
+app = FastAPI(title="Hotel Cancellation Prediction API", version=config.APP_VERSION)
+
+@app.on_event("startup")
+async def _load():
+    startup_load()
+
+@app.get("/", response_model=dict)
+async def root():
+    return {"message": "Hotel Cancellation Prediction API", "version": config.APP_VERSION, "endpoints": {"health": "/health", "predict": "/predict", "docs": "/docs"}}
+
+app.include_router(router)
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=int(os.getenv("PORT", "8000")))

requirements.txt

@@ -0,0 +1,10 @@
+fastapi>=0.104.0
+uvicorn[standard]>=0.24.0
+pydantic>=2.0.0
+pandas>=2.0.0
+scikit-learn==1.7.2
+xgboost>=2.0.0
+joblib>=1.3.0
+numpy>=1.24.0
+python-dotenv>=1.0.0
+huggingface_hub>=0.23.0

src/__init__.py

@@ -0,0 +1 @@
+# This file makes src a Python package

src/preprocessing.py

@@ -0,0 +1,240 @@
+"""Centralized preprocessing pipeline for hotel cancellation prediction.
+
+Provides a reusable class that encapsulates:
+- Categorical handling strategy (currently: drop)
+- Numeric scaling (StandardScaler)
+- Feature ordering preservation
+- Artifact persistence / loading
+
+Future extension points:
+- onehot / target / hybrid categorical strategies
+- numeric imputation strategies
+- feature selection masks
+
+Usage:
+    pipeline = PreprocessingPipeline(categorical_strategy='drop', scale=True)
+    X_train_proc = pipeline.fit_transform(X_train)
+    X_test_proc = pipeline.transform(X_test)
+    pipeline.save('models/preprocessor.pkl')
+
+    # Later / inference
+    pipeline = PreprocessingPipeline.load('models/preprocessor.pkl')
+    X_new = pipeline.transform(X_incoming)
+"""
+from __future__ import annotations
+from dataclasses import dataclass, asdict
+from typing import List, Optional, Dict, Any, Tuple
+import pandas as pd
+import joblib
+from sklearn.preprocessing import StandardScaler
+import os
+import numpy as np
+
+
+@dataclass
+class PreprocessingState:
+    categorical_strategy: str
+    scaled_numeric: List[str]
+    dropped_columns: List[str]
+    feature_order: List[str]
+    scale: bool
+    # One-hot specific
+    onehot_categories: Optional[Dict[str, List[str]]] = None
+    # Target encoding specific
+    target_mappings: Optional[Dict[str, Dict[str, float]]] = None
+    target_global_mean: Optional[float] = None
+    target_encoded_columns: Optional[List[str]] = None
+
+
+class PreprocessingPipeline:
+    def __init__(self, categorical_strategy: str = 'drop', scale: bool = True, target_min_samples: int = 5, target_smoothing: float = 10.0):
+        self.categorical_strategy = categorical_strategy
+        self.scale = scale
+        self._scaler: Optional[StandardScaler] = None
+        self.state: Optional[PreprocessingState] = None
+        # target encoding hyperparams
+        self.target_min_samples = target_min_samples
+        self.target_smoothing = target_smoothing
+
+    def _apply_onehot_fit(self, X: pd.DataFrame) -> Tuple[pd.DataFrame, Dict[str, List[str]]]:
+        cat_cols = [c for c in X.columns if X[c].dtype == 'object' or pd.api.types.is_categorical_dtype(X[c])]
+        categories: Dict[str, List[str]] = {}
+        transformed_parts = [X[[c]] for c in X.columns if c not in cat_cols]
+        for c in cat_cols:
+            cats = sorted([str(v) for v in X[c].dropna().unique()])
+            categories[c] = cats
+            for val in cats:
+                col_name = f"{c}__{val}"
+                transformed_parts.append((X[c].astype(str) == val).astype(int).to_frame(col_name))
+        X_new = pd.concat(transformed_parts, axis=1)
+        return X_new, categories
+
+    def _apply_onehot_transform(self, X: pd.DataFrame) -> pd.DataFrame:
+        assert self.state and self.state.onehot_categories
+        cat_schema = self.state.onehot_categories
+        out_parts = []
+        # Numeric / other passthrough first (original columns that were not categorical at fit time)
+        for c in self.state.feature_order:
+            # original feature_order contains post-onehot columns already; skip here
+            pass
+        # Reconstruct expected columns deterministically
+        for base_col, cats in cat_schema.items():
+            series = X[base_col].astype(str) if base_col in X.columns else pd.Series([None]*len(X), index=X.index)
+            for val in cats:
+                col_name = f"{base_col}__{val}"
+                out_parts.append((series == val).astype(int).rename(col_name))
+        # Add any numeric columns (those not in cat_schema keys)
+        numeric_like = [c for c in X.columns if c not in cat_schema]
+        for c in numeric_like:
+            if c not in self.state.feature_order and any(c.startswith(f"{k}__") for k in cat_schema):
+                # skip inadvertent collision
+                continue
+            if c in cat_schema:
+                continue
+            if pd.api.types.is_numeric_dtype(X[c]):
+                out_parts.append(X[c])
+        X_new = pd.concat(out_parts, axis=1)
+        # Align to stored feature order
+        missing = [c for c in self.state.feature_order if c not in X_new.columns]
+        for m in missing:
+            X_new[m] = 0  # unseen category -> all zeros
+        X_new = X_new[self.state.feature_order]
+        return X_new
+
+    def _compute_target_encoding(self, X: pd.DataFrame, y: pd.Series) -> Tuple[pd.DataFrame, Dict[str, Dict[str,float]], float, List[str]]:
+        cat_cols = [c for c in X.columns if X[c].dtype == 'object' or pd.api.types.is_categorical_dtype(X[c])]
+        mappings: Dict[str, Dict[str, float]] = {}
+        global_mean = float(y.mean())
+        X_encoded = X.copy()
+        encoded_cols: List[str] = []
+        for c in cat_cols:
+            stats = y.groupby(X[c]).agg(['mean','count'])
+            # smoothing: (count*mean + smoothing*global) / (count + smoothing)
+            smooth = (stats['count'] * stats['mean'] + self.target_smoothing * global_mean) / (stats['count'] + self.target_smoothing)
+            mapping = smooth.to_dict()
+            mappings[c] = mapping
+            new_col = f"{c}__te"
+            encoded_cols.append(new_col)
+            X_encoded[new_col] = X[c].map(mapping).fillna(global_mean)
+        # Drop original categorical columns
+        X_encoded = X_encoded.drop(columns=cat_cols)
+        return X_encoded, mappings, global_mean, encoded_cols
+
+    def _apply_target_transform(self, X: pd.DataFrame) -> pd.DataFrame:
+        assert self.state and self.state.target_mappings is not None
+        global_mean = self.state.target_global_mean
+        X_new = X.copy()
+        # For each mapping, create encoded column
+        for col, mapping in self.state.target_mappings.items():
+            new_col = f"{col}__te"
+            series = X_new[col] if col in X_new.columns else pd.Series([None]*len(X_new), index=X_new.index)
+            X_new[new_col] = series.map(mapping).fillna(global_mean)
+        # Drop raw categorical cols
+        X_new = X_new.drop(columns=list(self.state.target_mappings.keys()))
+        # Align order / add any missing
+        missing = [c for c in self.state.feature_order if c not in X_new.columns]
+        for m in missing:
+            X_new[m] = 0.0
+        X_new = X_new[self.state.feature_order]
+        return X_new
+
+    def fit(self, X: pd.DataFrame, y: Optional[pd.Series] = None) -> 'PreprocessingPipeline':
+        X = X.copy()
+        dropped: List[str] = []
+        onehot_categories: Optional[Dict[str, List[str]]] = None
+        target_mappings: Optional[Dict[str, Dict[str, float]]] = None
+        target_global_mean: Optional[float] = None
+        target_encoded_cols: Optional[List[str]] = None
+
+        if self.categorical_strategy == 'drop':
+            non_numeric = [c for c in X.columns if not pd.api.types.is_numeric_dtype(X[c])]
+            if non_numeric:
+                X = X.drop(columns=non_numeric)
+                dropped = non_numeric
+        elif self.categorical_strategy == 'onehot':
+            X, onehot_categories = self._apply_onehot_fit(X)
+        elif self.categorical_strategy == 'target':
+            if y is None:
+                raise ValueError("Target series y must be provided for target encoding strategy.")
+            X, target_mappings, target_global_mean, target_encoded_cols = self._compute_target_encoding(X, y)
+        else:
+            raise NotImplementedError(f"Categorical strategy '{self.categorical_strategy}' not implemented.")
+
+        numeric_cols = [c for c in X.columns if pd.api.types.is_numeric_dtype(X[c])]
+        if self.scale and numeric_cols:
+            self._scaler = StandardScaler()
+            self._scaler.fit(X[numeric_cols])
+        self.state = PreprocessingState(
+            categorical_strategy=self.categorical_strategy,
+            scaled_numeric=numeric_cols if self.scale else [],
+            dropped_columns=dropped,
+            feature_order=list(X.columns),
+            scale=self.scale,
+            onehot_categories=onehot_categories,
+            target_mappings=target_mappings,
+            target_global_mean=target_global_mean,
+            target_encoded_columns=target_encoded_cols
+        )
+        return self
+
+    def transform(self, X: pd.DataFrame) -> pd.DataFrame:
+        if self.state is None:
+            raise RuntimeError("Pipeline not fitted.")
+        X = X.copy()
+        if self.state.categorical_strategy == 'drop':
+            for col in self.state.dropped_columns:
+                if col in X.columns:
+                    X = X.drop(columns=col)
+            missing = [c for c in self.state.feature_order if c not in X.columns]
+            if missing:
+                raise ValueError(f"Incoming data missing columns required by preprocessor: {missing}")
+            X = X[self.state.feature_order]
+        elif self.state.categorical_strategy == 'onehot':
+            X = self._apply_onehot_transform(X)
+        elif self.state.categorical_strategy == 'target':
+            X = self._apply_target_transform(X)
+        else:
+            raise NotImplementedError(f"Unknown strategy {self.state.categorical_strategy}")
+        if self.scale and self._scaler is not None:
+            # Ensure float dtype prior to scaling assignment to avoid pandas FutureWarning
+            for col in self.state.scaled_numeric:
+                if not pd.api.types.is_float_dtype(X[col]):
+                    X[col] = X[col].astype('float64')
+            X.loc[:, self.state.scaled_numeric] = self._scaler.transform(X[self.state.scaled_numeric])
+        return X
+
+    def fit_transform(self, X: pd.DataFrame, y: Optional[pd.Series] = None) -> pd.DataFrame:
+        return self.fit(X, y).transform(X)
+
+    def save(self, path: str):
+        os.makedirs(os.path.dirname(path), exist_ok=True)
+        payload: Dict[str, Any] = {
+            'state': asdict(self.state) if self.state else None,
+            'categorical_strategy': self.categorical_strategy,
+            'scale': self.scale,
+            'scaler': self._scaler,
+            'target_min_samples': self.target_min_samples,
+            'target_smoothing': self.target_smoothing
+        }
+        joblib.dump(payload, path)
+
+    @classmethod
+    def load(cls, path: str) -> 'PreprocessingPipeline':
+        payload = joblib.load(path)
+        pipe = cls(
+            categorical_strategy=payload.get('categorical_strategy', 'drop'),
+            scale=payload.get('scale', True),
+            target_min_samples=payload.get('target_min_samples', 5),
+            target_smoothing=payload.get('target_smoothing', 10.0)
+        )
+        state_dict = payload.get('state')
+        if state_dict:
+            pipe.state = PreprocessingState(**state_dict)
+        pipe._scaler = payload.get('scaler')
+        return pipe
+
+    def to_metadata(self) -> Dict[str, Any]:
+        return asdict(self.state) if self.state else {}
+
+"""Helper for future extension: registration of new categorical strategies.
+Currently omitted for brevity."""