import pandas as pd

# Example features for ranking hotels in a search
hotels = pd.DataFrame({
    "hotel_id": [101, 102, 103],
    "price": [3200, 4500, 2800],
    "rating": [4.2, 4.6, 3.9],
    "distance_km": [1.2, 3.5, 0.8],
    "past_ctr": [0.08, 0.11, 0.05],     # historical click-through rate
})
hotels["price_rank"] = hotels["price"].rank()
hotels["score"] = (0.5 * hotels["past_ctr"] / hotels["past_ctr"].max()
                   + 0.3 * hotels["rating"] / 5
                   - 0.2 * hotels["distance_km"] / hotels["distance_km"].max())
print(hotels.sort_values("score", ascending=False)[["hotel_id", "score"]])
# A hand-weighted baseline; a learned ranking model replaces these weights

from sklearn.datasets import make_classification
from sklearn.ensemble import HistGradientBoostingClassifier
from sklearn.metrics import average_precision_score
from sklearn.model_selection import train_test_split

X, y = make_classification(n_samples=20000, weights=[0.99, 0.01], random_state=1)
X_tr, X_te, y_tr, y_te = train_test_split(X, y, stratify=y, random_state=1)
clf = HistGradientBoostingClassifier(class_weight="balanced", random_state=1).fit(X_tr, y_tr)
print("PR-AUC:", round(average_precision_score(y_te, clf.predict_proba(X_te)[:, 1]), 3))
# PR-AUC is more informative than accuracy for rare fraud cases

import time, statistics

def score(request):
    time.sleep(0.004)          # stand-in for feature lookup + model call
    return [101, 102, 103]

timings = []
for _ in range(200):
    start = time.perf_counter()
    score({"city": "Goa"})
    timings.append((time.perf_counter() - start) * 1000)

timings.sort()
print(f"p50 {statistics.median(timings):.1f} ms, p95 {timings[int(0.95 * len(timings))]:.1f} ms")

import pandas as pd

preds = pd.read_csv("demand_predictions.csv", parse_dates=["date"])   # date, actual, predicted
preds["abs_err"] = (preds["actual"] - preds["predicted"]).abs()
weekly = preds.set_index("date").resample("W")["abs_err"].mean()
print(weekly.tail(8).round(1))
# Rising error around holidays signals the need for seasonal features or retraining

# pip install fastapi uvicorn joblib
import joblib
from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()
model = joblib.load("fraud_model.joblib")   # loaded once at start-up

class Booking(BaseModel):
    amount: float
    nights: int
    days_before_checkin: int
    new_account: bool

@app.post("/score")
def score(b: Booking):
    x = [[b.amount, b.nights, b.days_before_checkin, int(b.new_account)]]
    return {"risk": float(model.predict_proba(x)[0][1]), "model_version": "fraud_v2"}

Safe model rollout
1. Offline evaluation vs current model on recent data
2. Shadow mode: new model scores live traffic, results not used
3. A/B test on a small share of traffic
4. Watch business metrics, latency and errors
5. Gradual ramp-up; keep instant rollback ready
6. Document results and decision

Travel ML portfolio projects (public or synthetic data)
1. Hotel search ranking with offline ranking metrics
2. Booking cancellation prediction served as an API
3. Demand forecasting with holiday features
4. Fraud scoring on imbalanced data with PR-AUC evaluation
Each: README, architecture diagram, latency notes, monitoring plan

ML engineer learning plan
Phase 1: Python, SQL, ML fundamentals
Phase 2: Ranking and imbalanced classification
Phase 3: Serving models with APIs, Docker
Phase 4: Feature pipelines and freshness
Phase 5: Monitoring, drift, A/B testing
Phase 6: System design practice

Practise this system design question
'Design the ranking system for hotel search.'
Cover: requirements (latency, freshness), candidate retrieval,
features, model, serving, caching, logging, offline/online evaluation,
monitoring, rollout and failure handling.