Building an End-to-End Data Science Portfolio Project

SELECT
    market_id,
    created_at,
    actual_delivery_time,
    store_id,
    store_primary_category,
    order_protocol,
    total_items,
    subtotal,
    total_onshift_dashers,
    total_busy_dashers,
    total_outstanding_orders
FROM df
WHERE actual_delivery_time IS NOT NULL
  AND actual_delivery_time > created_at;

df["created_at"] = pd.to_datetime(df["created_at"])
df["actual_delivery_time"] = pd.to_datetime(df["actual_delivery_time"])

# 我们的目标：实际配送所花费的时间（以秒为单位）
df["delivery_duration_seconds"] = (
    df["actual_delivery_time"] - df["created_at"]
).dt.total_seconds()

# 删除缺失值和不可能值
# 通常实际配送时间在 6 分钟到几小时之间
df2 = df[df["delivery_duration_seconds"].between(60, 3 * 3600)]

df3 = df2.dropna(subset=["delivery_duration_seconds"])

df3

import polars as pl

df = pl.read_csv(
    "historical_data.csv",
    null_values=["NA"],
    try_parse_dates=True
)

df = df.with_columns(
    (pl.col("actual_delivery_time") - pl.col("created_at"))
    .dt.total_seconds()
    .alias("delivery_duration_seconds")
).filter(pl.col("delivery_duration_seconds") > 0)

df3["delivery_minutes"] = df3["delivery_duration_seconds"] / 60
df3["delivery_minutes"].describe()

import matplotlib.pyplot as plt
import seaborn as sns

# 配送时间分布
sns.histplot(df3["delivery_minutes"].clip(upper=120), bins=50)

plt.xlabel("配送时长（分钟）")

# 不同市场间的差异
df3.groupby("market_id")["delivery_minutes"].median().sort_values()

import numpy as np

df3["busy_dashers_ratio"] = (
    df3["total_busy_dashers"]
    / df3["total_onshift_dashers"]
)

df3["estimated_non_prep_duration"] = (
    df3["estimated_store_to_consumer_driving_duration"]
    + df3["estimated_order_place_duration"]
)

# 忙碌比例可能产生除零错误
df3 = df3.replace([np.inf, -np.inf], np.nan)

df3[
    [
        "busy_dashers_ratio",
        "estimated_non_prep_duration",
    ]
].head()

from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder, StandardScaler
from sklearn.pipeline import Pipeline

numeric = [
    "busy_dashers_ratio",
    "estimated_non_prep_duration",
    "total_items",
    "subtotal",
    "num_distinct_items",
    "min_item_price",
    "max_item_price",
    "total_onshift_dashers",
    "total_outstanding_orders",
]

categorical = ["market_id", "order_protocol"]

preprocess = ColumnTransformer([
    ("num", StandardScaler(), numeric),
    ("cat", OneHotEncoder(handle_unknown="ignore"), categorical),
])

# 11个原始列经过编码后变成22个模型可用特征
preprocess.fit_transform(df3[numeric + categorical].dropna()).shape

(175596, 22)

from sklearn.model_selection import train_test_split
from sklearn.dummy import DummyRegressor
from sklearn.linear_model import Ridge
from sklearn.metrics import mean_squared_error
from xgboost import XGBRegressor

data = df3[numeric + categorical + ["delivery_duration_seconds"]].dropna()

X = data[numeric + categorical]
y = data["delivery_duration_seconds"]

X_train, X_test, y_train, y_test = train_test_split(
    X,
    y,
    test_size=0.2,
    random_state=42
)

models = {
    "Baseline (mean)": DummyRegressor(strategy="mean"),
    "Ridge": Ridge(),
    "XGBoost": XGBRegressor(
        n_estimators=600,
        learning_rate=0.05,
        max_depth=7,
        subsample=0.8,
        colsample_bytree=0.8,
        random_state=42
    ),
}

for name, model in models.items():
    pipe = Pipeline([("pre", preprocess), ("model", model)])
    pipe.fit(X_train, y_train)

    rmse = mean_squared_error(y_test, pipe.predict(X_test)) ** 0.5

    print(f"{name}: RMSE = {rmse:.0f} sec")

from sklearn.model_selection import cross_val_score

pipe = Pipeline([("pre", preprocess), ("model", models["XGBoost"])])

scores = cross_val_score(
    pipe,
    X,
    y,
    cv=5,
    scoring="neg_root_mean_squared_error"
)

print("Fold RMSEs:", (-scores).round().astype(int))
print(f"CV RMSE: {-scores.mean():.0f} sec (+/- {scores.std():.0f})")

import joblib

pipe.fit(X_train, y_train)
joblib.dump(pipe, "delivery_model.joblib")

# api.py
from fastapi import FastAPI
from pydantic import BaseModel
import joblib
import pandas as pd

app = FastAPI()
model = joblib.load("delivery_model.joblib")

class Order(BaseModel):
    busy_dashers_ratio: float
    estimated_non_prep_duration: float
    total_items: int
    subtotal: float
    num_distinct_items: int
    min_item_price: float
    max_item_price: float
    total_onshift_dashers: float
    total_outstanding_orders: float
    market_id: int
    order_protocol: int

@app.post("/predict")
def predict(order: Order):
    row = pd.DataFrame([order.model_dump()])
    seconds = float(model.predict(row)[0])
    return {"predicted_delivery_seconds": round(seconds)}

import streamlit as st
import joblib
import pandas as pd

model = joblib.load("delivery_model.joblib")

st.title("Delivery Duration Predictor")

order = {
    "busy_dashers_ratio": st.slider(
        "Busy dashers ratio",
        0.0,
        2.0,
        0.5
    ),
    "estimated_non_prep_duration": st.number_input(
        "Non-prep duration (sec)",
        value=900
    ),
    "total_items": st.number_input(
        "Total items",
        value=4,
        step=1
    ),
    "subtotal": st.number_input(
        "Subtotal (cents)",
        value=3441
    ),
    "num_distinct_items": st.number_input(
        "Distinct items",
        value=4,
        step=1
    ),
    "min_item_price": st.number_input(
        "Min item price",
        value=557
    ),
    "max_item_price": st.number_input(
        "Max item price",
        value=1239
    ),
    "total_onshift_dashers": st.number_input(
        "On-shift dashers",
        value=33
    ),
    "total_outstanding_orders": st.number_input(
        "Outstanding orders",
        value=21
    ),
    "market_id": st.selectbox(
        "Market",
        [1, 2, 3, 4, 5, 6]
    ),
    "order_protocol": st.selectbox(
        "Order protocol",
        [1, 2, 3, 4, 5, 6, 7]
    ),
}

if st.button("Predict"):
    seconds = float(
        model.predict(
            pd.DataFrame([order])
        )[0]
    )

    st.metric(
        "Predicted delivery time",
        f"{seconds / 60:.1f} min"
    )