{
"cells": [
{
"cell_type": "markdown",
"id": "4e333c36",
"metadata": {},
"source": [
"# DBbun Davis — Machine Learning Demo\n",
"This notebook shows how to build ML models using the synthetic **Davis Square** dataset.\n",
"\n",
"We’ll do three examples:\n",
"1. **Classification:** predict whether a public safety incident is **high severity** using incident, weather, and street features.\n",
"2. **Regression:** predict **noise (dB)** from weather and traffic context.\n",
"3. **Clustering:** group streets by **mobility signature** (mode mix) using K-Means.\n",
"\n",
"All **figures, tables, and models** are saved locally.\n"
]
},
{
"cell_type": "code",
"execution_count": 1,
"id": "4f2d9fff",
"metadata": {},
"outputs": [],
"source": [
"# --- User config ---\n",
"#DATA_DIR = \"./out_dbbun_davis_medium\" # Set to your dataset folder\n",
"DATA_DIR = \"./\"\n",
"FIGS_DIR = \"./ml_figs\"\n",
"TABLES_DIR = \"./ml_tables\"\n",
"MODELS_DIR = \"./ml_models\"\n",
"\n",
"import os\n",
"os.environ[\"OMP_NUM_THREADS\"] = \"1\"\n",
"os.environ[\"MKL_NUM_THREADS\"] = \"1\" # extra-safe on Windows/MKL\n",
"os.environ[\"NUMEXPR_NUM_THREADS\"] = \"1\" # extra-safe\n",
"\n",
"# --- Imports ---\n",
"import os, json, pickle, re\n",
"import numpy as np\n",
"import pandas as pd\n",
"import matplotlib.pyplot as plt\n",
"\n",
"from sklearn.model_selection import train_test_split, cross_val_score\n",
"from sklearn.preprocessing import OneHotEncoder, StandardScaler\n",
"from sklearn.compose import ColumnTransformer\n",
"from sklearn.pipeline import Pipeline\n",
"from sklearn.metrics import classification_report, confusion_matrix, roc_auc_score, RocCurveDisplay, mean_absolute_error, r2_score\n",
"from sklearn.linear_model import LogisticRegression, LinearRegression\n",
"from sklearn.ensemble import RandomForestClassifier, RandomForestRegressor\n",
"from sklearn.cluster import KMeans\n",
"\n",
"os.makedirs(FIGS_DIR, exist_ok=True)\n",
"os.makedirs(TABLES_DIR, exist_ok=True)\n",
"os.makedirs(MODELS_DIR, exist_ok=True)\n",
"\n",
"def savefig(name):\n",
" path = os.path.join(FIGS_DIR, name)\n",
" plt.savefig(path, bbox_inches=\"tight\", dpi=144)\n",
" plt.close()\n",
" print(f\"Saved figure: {path}\")\n",
"\n",
"def savetab(df, name):\n",
" path = os.path.join(TABLES_DIR, name)\n",
" df.to_csv(path, index=False)\n",
" print(f\"Saved table: {path}\")\n",
"\n",
"def savemodel(model, name):\n",
" path = os.path.join(MODELS_DIR, name)\n",
" with open(path, \"wb\") as f:\n",
" pickle.dump(model, f)\n",
" print(f\"Saved model: {path}\")"
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "0fd4f78b-44e7-424d-8f1c-3bbc29468cba",
"metadata": {},
"outputs": [],
"source": [
"import warnings\n",
"warnings.filterwarnings(\"ignore\", category=FutureWarning)"
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "2a2efd9d-75b0-43f4-894b-f7347e3febdb",
"metadata": {},
"outputs": [],
"source": [
"pd.set_option('future.no_silent_downcasting', True)"
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "0ac6980b",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Loaded tables:\n",
" streets: (15, 7) | safety: (12000, 8) | obs: (35000, 7) | weather: (101136, 7)\n"
]
}
],
"source": [
"# Load data\n",
"def load_csv(name):\n",
" return pd.read_csv(os.path.join(DATA_DIR, name))\n",
"\n",
"# Helper for WKT point -> (lon,lat)\n",
"def wkt_point_to_lonlat(wkt):\n",
" m = re.match(r\"POINT\\(([-0-9\\.]+)\\s+([-0-9\\.]+)\\)\", str(wkt))\n",
" if not m:\n",
" return np.nan, np.nan\n",
" lon, lat = float(m.group(1)), float(m.group(2))\n",
" return lon, lat\n",
"\n",
"# Tables\n",
"streets = load_csv(\"geo_streets.csv\")\n",
"parks = load_csv(\"geo_parks.csv\")\n",
"poi = load_csv(\"poi_generic.csv\")\n",
"households = load_csv(\"households.csv\")\n",
"pets = load_csv(\"pets_registry.csv\")\n",
"pet_inc = load_csv(\"pet_incidents.csv\")\n",
"trips = load_csv(\"mobility_trips.csv\")\n",
"safety = load_csv(\"public_safety.csv\")\n",
"events = load_csv(\"events_civic.csv\")\n",
"obs = load_csv(\"observations.csv\")\n",
"lines = load_csv(\"transit_lines.csv\")\n",
"stops = load_csv(\"transit_stops.csv\")\n",
"ridership = load_csv(\"transit_ridership_daily.csv\")\n",
"bike = load_csv(\"bike_infra.csv\")\n",
"traffic = load_csv(\"traffic_counts.csv\")\n",
"prices = load_csv(\"prices_index.csv\")\n",
"weather = load_csv(\"weather_daily.csv\")\n",
"trees = load_csv(\"trees_inventory.csv\")\n",
"infra = load_csv(\"infrastructure_events.csv\")\n",
"bissues = load_csv(\"building_issues.csv\")\n",
"\n",
"with open(os.path.join(DATA_DIR, \"DATA_DICTIONARY.json\"), \"r\", encoding=\"utf-8\") as f:\n",
" dd = json.load(f)\n",
"\n",
"# Basic sanity\n",
"print(\"Loaded tables:\")\n",
"print(\" streets:\", streets.shape, \"| safety:\", safety.shape, \"| obs:\", obs.shape, \"| weather:\", weather.shape)"
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "2a457810",
"metadata": {},
"outputs": [],
"source": [
"def nearest_year_join(left_df, left_year_col, right_df, right_year_col, on_key_col):\n",
" # For each (on_key_col, year) in left_df, find the right_df row with smallest |year diff|\n",
" # This is a simple but effective approach for decimated time series.\n",
" right_sorted = right_df.sort_values([on_key_col, right_year_col]).copy()\n",
" out_rows = []\n",
" for (k, y), block in left_df.groupby([on_key_col, left_year_col]):\n",
" cand = right_sorted[right_sorted[on_key_col]==k]\n",
" if cand.empty:\n",
" # no match for this key\n",
" tmp = block.copy()\n",
" tmp[\"__ry\"] = np.nan\n",
" tmp[\"__ridx\"] = -1\n",
" out_rows.append(tmp)\n",
" continue\n",
" # pick nearest by year\n",
" ridx = int((cand[right_year_col] - y).abs().idxmin())\n",
" tmp = block.copy()\n",
" tmp[\"__ry\"] = cand.loc[ridx, right_year_col]\n",
" tmp[\"__ridx\"] = ridx\n",
" out_rows.append(tmp)\n",
" joined_left = pd.concat(out_rows, axis=0)\n",
"\n",
" # Attach right_df columns by __ridx where available\n",
" joined = joined_left.merge(right_df.add_prefix(\"r__\"), left_on=\"__ridx\", right_index=True, how=\"left\")\n",
" joined = joined.drop(columns=[\"__ridx\"])\n",
" return joined"
]
},
{
"cell_type": "markdown",
"id": "ff73a6ff",
"metadata": {},
"source": [
"## 1) Classification: Predict high-severity public safety incidents\n",
"**Target:** `severity` mapped to binary: *high* vs *not-high* \n",
"**Features:** incident `category`, `reported_by`, street attributes (bike infra presence), daily weather (`temp_c`, `precip_mm`, `snow_cm`, `wind_kph`, `heatwave`)."
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "0a9bb0f2",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
" precision recall f1-score support\n",
"\n",
" 0 0.67 0.82 0.74 2026\n",
" 1 0.30 0.16 0.21 974\n",
"\n",
" accuracy 0.61 3000\n",
" macro avg 0.49 0.49 0.47 3000\n",
"weighted avg 0.55 0.61 0.57 3000\n",
"\n",
"Confusion matrix:\n",
" [[1671 355]\n",
" [ 820 154]]\n",
"ROC AUC: 0.4951799603106231\n",
"Saved figure: ./ml_figs\\clf_roc_curve.png\n",
"Saved model: ./ml_models\\incident_severity_rf.pkl\n",
"Saved table: ./ml_tables\\clf_metrics_incident_severity.csv\n"
]
}
],
"source": [
"# Prepare safety data\n",
"safety['date'] = pd.to_datetime(safety['date'])\n",
"safety['year'] = safety['date'].dt.year\n",
"safety['month'] = safety['date'].dt.month\n",
"safety['day'] = safety['date'].dt.day\n",
"\n",
"# Target\n",
"y = (safety['severity'] == 'high').astype(int)\n",
"\n",
"# Merge weather on date\n",
"weather['date'] = pd.to_datetime(weather['date'])\n",
"s_w = safety.merge(weather[['date','temp_c','precip_mm','snow_cm','wind_kph','heatwave']], on='date', how='left')\n",
"\n",
"# Street-level bike infra presence (binary, ever installed before safety year)\n",
"bike_any = bike.copy()\n",
"bike_any['has_bike_infra'] = True\n",
"s_w = s_w.merge(\n",
" bike_any[['street_id','has_bike_infra']].drop_duplicates('street_id'),\n",
" left_on='location_street_id', right_on='street_id', how='left'\n",
")\n",
"s_w['has_bike_infra'] = s_w['has_bike_infra'].fillna(False).infer_objects(copy=False)\n",
"\n",
"# Assemble features\n",
"X = s_w[['category','reported_by','has_bike_infra','temp_c','precip_mm','snow_cm','wind_kph','heatwave','month']].copy()\n",
"\n",
"# Split numeric/categorical\n",
"num_cols = ['temp_c','precip_mm','snow_cm','wind_kph','month']\n",
"cat_cols = ['category','reported_by','heatwave','has_bike_infra']\n",
"\n",
"pre = ColumnTransformer([\n",
" (\"num\", StandardScaler(), num_cols),\n",
" (\"cat\", OneHotEncoder(handle_unknown=\"ignore\"), cat_cols)\n",
"])\n",
"\n",
"clf = Pipeline([\n",
" (\"pre\", pre),\n",
" (\"rf\", RandomForestClassifier(n_estimators=200, random_state=42, class_weight=\"balanced\"))\n",
"])\n",
"\n",
"X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=42, stratify=y)\n",
"clf.fit(X_train, y_train)\n",
"\n",
"# Evaluate\n",
"pred = clf.predict(X_test)\n",
"proba = clf.predict_proba(X_test)[:,1]\n",
"\n",
"print(classification_report(y_test, pred))\n",
"cm = confusion_matrix(y_test, pred)\n",
"print(\"Confusion matrix:\\n\", cm)\n",
"\n",
"# ROC AUC & curve\n",
"auc = roc_auc_score(y_test, proba)\n",
"print(\"ROC AUC:\", auc)\n",
"\n",
"disp = RocCurveDisplay.from_predictions(y_test, proba)\n",
"plt.title(\"ROC Curve — High Severity Incident Classifier\")\n",
"savefig(\"clf_roc_curve.png\")\n",
"\n",
"# Save model\n",
"savemodel(clf, \"incident_severity_rf.pkl\")\n",
"\n",
"# Save metrics as table\n",
"metrics_tbl = pd.DataFrame({\n",
" \"roc_auc\":[auc],\n",
" \"accuracy\":[(pred==y_test).mean()],\n",
" \"n_test\":[len(y_test)]\n",
"})\n",
"savetab(metrics_tbl, \"clf_metrics_incident_severity.csv\")"
]
},
{
"cell_type": "markdown",
"id": "78159761",
"metadata": {},
"source": [
"## 2) Regression: Predict street noise (dB)\n",
"**Target:** `observations` where `metric == \"noise_db\"` → `value` (dB). \n",
"**Features:** weather (temp, wind, rain, snow, heatwave), month, traffic volumes (nearest-year by street).\n"
]
},
{
"cell_type": "code",
"execution_count": 7,
"id": "bb03cb92",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"MAE: 5.521102874867018 R^2: 0.3084211030160505\n",
"Saved figure: ./ml_figs\\regr_noise_pred_vs_actual.png\n",
"Saved model: ./ml_models\\noise_rf.pkl\n",
"Saved table: ./ml_tables\\regr_noise_metrics.csv\n"
]
}
],
"source": [
"# Filter observations to noise\n",
"noise = obs[obs['metric']=='noise_db'].copy()\n",
"noise['date'] = pd.to_datetime(noise['date'])\n",
"noise['year'] = noise['date'].dt.year\n",
"noise['month'] = noise['date'].dt.month\n",
"\n",
"# Merge weather\n",
"weather['date'] = pd.to_datetime(weather['date'])\n",
"nz = noise.merge(weather[['date','temp_c','precip_mm','snow_cm','wind_kph','heatwave']], on='date', how='left')\n",
"\n",
"# Traffic is every ~5 years; map to nearest year by street\n",
"traffic['year'] = pd.to_datetime(traffic['date']).dt.year\n",
"nz_key = nz[['location_street_id','year']].copy()\n",
"nz_key = nz_key.rename(columns={'location_street_id':'street_id'})\n",
"traffic_near = nearest_year_join(nz_key, 'year', traffic[['street_id','year','vehicles_per_day','bikes_per_day','peds_per_day']], 'year', 'street_id')\n",
"\n",
"# Merge traffic back by index alignment\n",
"nz = nz.join(traffic_near[['r__street_id','r__year','r__vehicles_per_day','r__bikes_per_day','r__peds_per_day']].reset_index(drop=True))\n",
"# If missing traffic (e.g., older years), fill with medians\n",
"for c in ['r__vehicles_per_day','r__bikes_per_day','r__peds_per_day']:\n",
" nz[c] = nz[c].fillna(nz[c].median())\n",
"\n",
"# Prepare features/target\n",
"y = nz['value'].astype(float) # noise dB\n",
"X = nz[['temp_c','precip_mm','snow_cm','wind_kph','heatwave','month','r__vehicles_per_day','r__bikes_per_day','r__peds_per_day']].copy()\n",
"\n",
"num_cols = ['temp_c','precip_mm','snow_cm','wind_kph','month','r__vehicles_per_day','r__bikes_per_day','r__peds_per_day']\n",
"cat_cols = ['heatwave']\n",
"\n",
"pre = ColumnTransformer([\n",
" (\"num\", StandardScaler(), num_cols),\n",
" (\"cat\", OneHotEncoder(handle_unknown=\"ignore\"), cat_cols)\n",
"])\n",
"\n",
"regr = Pipeline([\n",
" (\"pre\", pre),\n",
" (\"rf\", RandomForestRegressor(n_estimators=200, random_state=42))\n",
"])\n",
"\n",
"X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=42)\n",
"regr.fit(X_train, y_train)\n",
"pred = regr.predict(X_test)\n",
"\n",
"mae = mean_absolute_error(y_test, pred)\n",
"r2 = r2_score(y_test, pred)\n",
"print(\"MAE:\", mae, \" R^2:\", r2)\n",
"\n",
"# Scatter: predicted vs actual\n",
"plt.figure(figsize=(6,6))\n",
"plt.scatter(y_test, pred, alpha=0.3)\n",
"plt.xlabel(\"Actual dB\"); plt.ylabel(\"Predicted dB\")\n",
"plt.title(\"Noise Regression — Predicted vs Actual\")\n",
"savefig(\"regr_noise_pred_vs_actual.png\")\n",
"\n",
"# Save model & metrics\n",
"savemodel(regr, \"noise_rf.pkl\")\n",
"savetab(pd.DataFrame({\"MAE\":[mae], \"R2\":[r2], \"n_test\":[len(y_test)]}), \"regr_noise_metrics.csv\")"
]
},
{
"cell_type": "markdown",
"id": "11a13962",
"metadata": {},
"source": [
"## 3) Clustering: Streets by mobility signature\n",
"We compute, for each street, a **mode share vector** based on trips that originate on that street. \n",
"Then we cluster streets using **K-Means** and visualize cluster sizes."
]
},
{
"cell_type": "code",
"execution_count": 8,
"id": "8b77b4d6",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Saved figure: ./ml_figs\\cluster_elbow.png\n",
"Saved table: ./ml_tables\\cluster_sizes.csv\n"
]
},
{
"data": {
"text/html": [
"
\n",
"\n",
"
\n",
" \n",
" \n",
" | \n",
" cluster | \n",
" n_streets | \n",
"
\n",
" \n",
" \n",
" \n",
" | 0 | \n",
" 0 | \n",
" 3 | \n",
"
\n",
" \n",
" | 1 | \n",
" 1 | \n",
" 2 | \n",
"
\n",
" \n",
" | 2 | \n",
" 2 | \n",
" 5 | \n",
"
\n",
" \n",
" | 3 | \n",
" 3 | \n",
" 5 | \n",
"
\n",
" \n",
"
\n",
"
"
],
"text/plain": [
" cluster n_streets\n",
"0 0 3\n",
"1 1 2\n",
"2 2 5\n",
"3 3 5"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Saved figure: ./ml_figs\\cluster_sizes_bar.png\n",
"Saved table: ./ml_tables\\cluster_assignments.csv\n"
]
}
],
"source": [
"# Build mode share per street (origin)\n",
"mode_pvt = trips.pivot_table(index='origin_street_id', columns='mode', values='trip_id', aggfunc='count', fill_value=0)\n",
"mode_share = mode_pvt.div(mode_pvt.sum(axis=1).replace(0,1), axis=0)\n",
"\n",
"# Try several k and pick a reasonable one (elbow heuristic)\n",
"inertias = []\n",
"ks = list(range(2, 9))\n",
"for k in ks:\n",
" km = KMeans(n_clusters=k, random_state=42, n_init=10)\n",
" km.fit(mode_share)\n",
" inertias.append(km.inertia_)\n",
"\n",
"plt.figure(figsize=(6,4))\n",
"plt.plot(ks, inertias, marker=\"o\")\n",
"plt.xlabel(\"k\"); plt.ylabel(\"Inertia\")\n",
"plt.title(\"K-Means Elbow — Mobility Mode Share by Street\")\n",
"savefig(\"cluster_elbow.png\")\n",
"\n",
"# Choose k=4 as a reasonable choice for demonstration\n",
"k = 4\n",
"km = KMeans(n_clusters=k, random_state=42, n_init=10)\n",
"labels = km.fit_predict(mode_share)\n",
"mode_share_clusters = mode_share.copy()\n",
"mode_share_clusters['cluster'] = labels\n",
"\n",
"# Summarize clusters\n",
"cluster_sizes = mode_share_clusters['cluster'].value_counts().sort_index().reset_index()\n",
"cluster_sizes.columns = ['cluster','n_streets']\n",
"savetab(cluster_sizes, \"cluster_sizes.csv\")\n",
"display(cluster_sizes)\n",
"\n",
"plt.figure(figsize=(6,4))\n",
"plt.bar(cluster_sizes['cluster'], cluster_sizes['n_streets'])\n",
"plt.xlabel(\"Cluster\"); plt.ylabel(\"Number of streets\")\n",
"plt.title(\"Street Clusters by Mobility Signature\")\n",
"savefig(\"cluster_sizes_bar.png\")\n",
"\n",
"# Save cluster assignments\n",
"assignments = mode_share_clusters.reset_index()[['origin_street_id','cluster']]\n",
"savetab(assignments, \"cluster_assignments.csv\")"
]
},
{
"cell_type": "markdown",
"id": "9dc1e2af",
"metadata": {},
"source": [
"### Bonus: Interpreting models\n",
"As a quick interpretability pass, we can look at feature importance from the random forests (MDI)."
]
},
{
"cell_type": "code",
"execution_count": 9,
"id": "73f43632",
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"\n",
"\n",
"
\n",
" \n",
" \n",
" | \n",
" feature | \n",
" importance | \n",
"
\n",
" \n",
" \n",
" \n",
" | 0 | \n",
" temp_c | \n",
" 0.302091 | \n",
"
\n",
" \n",
" | 1 | \n",
" wind_kph | \n",
" 0.219432 | \n",
"
\n",
" \n",
" | 2 | \n",
" month | \n",
" 0.188248 | \n",
"
\n",
" \n",
" | 3 | \n",
" precip_mm | \n",
" 0.082657 | \n",
"
\n",
" \n",
" | 4 | \n",
" snow_cm | \n",
" 0.044882 | \n",
"
\n",
" \n",
" | 5 | \n",
" reported_by_sensor | \n",
" 0.017501 | \n",
"
\n",
" \n",
" | 6 | \n",
" reported_by_officer | \n",
" 0.016649 | \n",
"
\n",
" \n",
" | 7 | \n",
" reported_by_citizen | \n",
" 0.016428 | \n",
"
\n",
" \n",
" | 8 | \n",
" category_animal | \n",
" 0.012986 | \n",
"
\n",
" \n",
" | 9 | \n",
" category_theft | \n",
" 0.012825 | \n",
"
\n",
" \n",
" | 10 | \n",
" category_disturbance | \n",
" 0.012002 | \n",
"
\n",
" \n",
" | 11 | \n",
" category_noise | \n",
" 0.011956 | \n",
"
\n",
" \n",
" | 12 | \n",
" category_other | \n",
" 0.011694 | \n",
"
\n",
" \n",
" | 13 | \n",
" category_vandalism | \n",
" 0.010977 | \n",
"
\n",
" \n",
" | 14 | \n",
" category_traffic | \n",
" 0.010530 | \n",
"
\n",
" \n",
" | 15 | \n",
" has_bike_infra_True | \n",
" 0.010157 | \n",
"
\n",
" \n",
" | 16 | \n",
" has_bike_infra_False | \n",
" 0.009653 | \n",
"
\n",
" \n",
" | 17 | \n",
" heatwave_False | \n",
" 0.004153 | \n",
"
\n",
" \n",
" | 18 | \n",
" heatwave_nan | \n",
" 0.002672 | \n",
"
\n",
" \n",
" | 19 | \n",
" heatwave_True | \n",
" 0.002508 | \n",
"
\n",
" \n",
"
\n",
"
"
],
"text/plain": [
" feature importance\n",
"0 temp_c 0.302091\n",
"1 wind_kph 0.219432\n",
"2 month 0.188248\n",
"3 precip_mm 0.082657\n",
"4 snow_cm 0.044882\n",
"5 reported_by_sensor 0.017501\n",
"6 reported_by_officer 0.016649\n",
"7 reported_by_citizen 0.016428\n",
"8 category_animal 0.012986\n",
"9 category_theft 0.012825\n",
"10 category_disturbance 0.012002\n",
"11 category_noise 0.011956\n",
"12 category_other 0.011694\n",
"13 category_vandalism 0.010977\n",
"14 category_traffic 0.010530\n",
"15 has_bike_infra_True 0.010157\n",
"16 has_bike_infra_False 0.009653\n",
"17 heatwave_False 0.004153\n",
"18 heatwave_nan 0.002672\n",
"19 heatwave_True 0.002508"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Saved table: ./ml_tables\\clf_top_feature_importances.csv\n",
"Saved figure: ./ml_figs\\clf_feature_importances.png\n"
]
},
{
"data": {
"text/html": [
"\n",
"\n",
"
\n",
" \n",
" \n",
" | \n",
" feature | \n",
" importance | \n",
"
\n",
" \n",
" \n",
" \n",
" | 0 | \n",
" precip_mm | \n",
" 0.231075 | \n",
"
\n",
" \n",
" | 1 | \n",
" temp_c | \n",
" 0.223292 | \n",
"
\n",
" \n",
" | 2 | \n",
" snow_cm | \n",
" 0.115154 | \n",
"
\n",
" \n",
" | 3 | \n",
" wind_kph | \n",
" 0.098303 | \n",
"
\n",
" \n",
" | 4 | \n",
" month | \n",
" 0.075172 | \n",
"
\n",
" \n",
" | 5 | \n",
" r__vehicles_per_day | \n",
" 0.069528 | \n",
"
\n",
" \n",
" | 6 | \n",
" r__bikes_per_day | \n",
" 0.068437 | \n",
"
\n",
" \n",
" | 7 | \n",
" r__peds_per_day | \n",
" 0.066777 | \n",
"
\n",
" \n",
" | 8 | \n",
" heatwave_nan | \n",
" 0.048992 | \n",
"
\n",
" \n",
" | 9 | \n",
" heatwave_False | \n",
" 0.001682 | \n",
"
\n",
" \n",
" | 10 | \n",
" heatwave_True | \n",
" 0.001590 | \n",
"
\n",
" \n",
"
\n",
"
"
],
"text/plain": [
" feature importance\n",
"0 precip_mm 0.231075\n",
"1 temp_c 0.223292\n",
"2 snow_cm 0.115154\n",
"3 wind_kph 0.098303\n",
"4 month 0.075172\n",
"5 r__vehicles_per_day 0.069528\n",
"6 r__bikes_per_day 0.068437\n",
"7 r__peds_per_day 0.066777\n",
"8 heatwave_nan 0.048992\n",
"9 heatwave_False 0.001682\n",
"10 heatwave_True 0.001590"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Saved table: ./ml_tables\\regr_top_feature_importances.csv\n",
"Saved figure: ./ml_figs\\regr_feature_importances.png\n"
]
}
],
"source": [
"# Extract MDI importances from pipelines (requires access to transformed feature names)\n",
"def get_feature_names(preprocessor, num_cols, cat_cols, X):\n",
" num_feats = num_cols\n",
" # OneHot names\n",
" oh = preprocessor.named_transformers_['cat']\n",
" cat_names = list(oh.get_feature_names_out(cat_cols))\n",
" return list(num_feats) + cat_names\n",
"\n",
"# Classification importances\n",
"try:\n",
" clf_model = clf.named_steps['rf']\n",
" feat_names = get_feature_names(clf.named_steps['pre'], \n",
" ['temp_c','precip_mm','snow_cm','wind_kph','month'],\n",
" ['category','reported_by','heatwave','has_bike_infra'],\n",
" X_train)\n",
" imp = pd.Series(clf_model.feature_importances_, index=feat_names).sort_values(ascending=False)\n",
" top_imp = imp.head(20).reset_index()\n",
" top_imp.columns = ['feature','importance']\n",
" display(top_imp)\n",
" savetab(top_imp, \"clf_top_feature_importances.csv\")\n",
"\n",
" plt.figure(figsize=(8,5))\n",
" plt.barh(top_imp['feature'][::-1], top_imp['importance'][::-1])\n",
" plt.title(\"Top Feature Importances — Incident Severity RF\")\n",
" plt.xlabel(\"Importance\")\n",
" savefig(\"clf_feature_importances.png\")\n",
"except Exception as e:\n",
" print(\"Could not compute classification importances:\", e)\n",
"\n",
"# Regression importances\n",
"try:\n",
" regr_model = regr.named_steps['rf']\n",
" feat_names = get_feature_names(regr.named_steps['pre'],\n",
" ['temp_c','precip_mm','snow_cm','wind_kph','month','r__vehicles_per_day','r__bikes_per_day','r__peds_per_day'],\n",
" ['heatwave'],\n",
" X_train)\n",
" imp = pd.Series(regr_model.feature_importances_, index=feat_names).sort_values(ascending=False)\n",
" top_imp = imp.head(20).reset_index()\n",
" top_imp.columns = ['feature','importance']\n",
" display(top_imp)\n",
" savetab(top_imp, \"regr_top_feature_importances.csv\")\n",
"\n",
" plt.figure(figsize=(8,5))\n",
" plt.barh(top_imp['feature'][::-1], top_imp['importance'][::-1])\n",
" plt.title(\"Top Feature Importances — Noise RF\")\n",
" plt.xlabel(\"Importance\")\n",
" savefig(\"regr_feature_importances.png\")\n",
"except Exception as e:\n",
" print(\"Could not compute regression importances:\", e)"
]
},
{
"cell_type": "markdown",
"id": "0963228d",
"metadata": {},
"source": [
"### Next ideas\n",
"- Use **time-based splits** (train on early years, test on later) for more realistic forecasting.\n",
"- Try **Gradient Boosting** or **XGBoost/LightGBM** for stronger baselines.\n",
"- Add **spatial features** (distance to parks, density of POIs) for richer models.\n",
"- Package results into an **HTML report** or a small **Streamlit** app."
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.12.7"
}
},
"nbformat": 4,
"nbformat_minor": 5
}