1. 项目概述：当“找车位”遇上机器学习

在任何一个大学校园里，上午第一节课前的半小时，停车场入口的“长龙”和司机们脸上焦急的表情，几乎成了每日固定的风景线。我自己就曾是这风景中的一员，为了一个车位，有时不得不提前半小时到校，或者干脆把车停在几公里外的商业区再步行回来。这不仅仅是时间浪费，更带来了额外的燃油消耗、碳排放和糟糕的出行体验。传统的解决方案，比如安装地磁传感器或部署摄像头网络，听起来很“智能”，但动辄数十万甚至上百万的硬件投入、复杂的布线、持续的维护成本以及潜在的隐私泄露风险，让很多高校望而却步。

那么，有没有一种方法，既能精准预测停车位的可用性，又不用大兴土木、安装一堆硬件，还能保护师生的隐私呢？这正是我们这次要探讨的核心。 基于地理空间数据与机器学习的低成本校园停车预测框架 ，就是试图回答这个问题的一个实践。它的核心思路非常“极客”：既然我们无法在每个车位下埋传感器，那就利用已有的、公开的“数字足迹”来推算。这些足迹包括公开的街道地图数据、车辆进出校园大门的粗略移动模式，甚至是一些基础的天气信息。通过机器学习模型，我们从这些看似不直接相关的数据中，挖掘出停车行为的规律。

这个项目的价值，远不止于帮你省下找车位的十分钟。它代表了一种 数据驱动、轻量级、隐私友好 的智慧城市问题解决范式。对于校园管理者而言，它提供了一种近乎零硬件成本的停车管理洞察工具，可以用于优化停车资源分配、规划新建停车场，甚至动态调整课程安排以错峰停车。对于开发者或研究者，它展示了一套完整的技术链路：从多源异构地理空间数据的获取与融合，到特征工程的构建，再到多种机器学习模型的对比与调优。接下来，我将以一个亲身实践者的角度，为你拆解这个框架从构思到实现的每一个细节，分享其中踩过的坑和收获的经验。

2. 框架核心设计：为什么是“地理空间数据+机器学习”？

在深入代码和模型之前，我们必须先想清楚：为什么是这套组合拳？它到底解决了传统方案的哪些痛点？理解了设计哲学，后面的每一步操作才会有据可依。

2.1 传统方案的瓶颈与我们的破局思路

传统的智能停车方案，主流是两条技术路线：

1. 基于物联网（IoT）的感知方案 ：在车位部署地磁、超声波或红外传感器，实时感知车位占用状态。优点是数据直接、准确。缺点也极其明显： 成本高昂 （硬件、安装、供电、网络）、 维护复杂 （风吹日晒、车辆碾压导致的故障）、 扩展性差 （新增区域需重新部署）。
2. 基于计算机视觉（CV）的识别方案 ：通过摄像头拍摄停车场画面，利用YOLO等目标检测算法识别车辆。优点是非接触、覆盖范围广。缺点是受光照、天气、遮挡影响大；涉及大量人脸、车牌等敏感信息， 隐私风险高 ；需要高性能计算设备，且模型训练需要大量标注数据。

我们的破局点在于转换思路： 不直接感知“车位状态”，而是预测“车位状态” 。我们不需要知道此刻A001车位是否停着一辆红色轿车，我们只需要预测在上午9点，整个南区停车场大概还有多少空位。实现预测，不一定需要部署在停车场的传感器，我们可以寻找与停车行为强相关的 代理数据（Proxy Data） 。

2.2 数据源的选取与成本效益权衡

我们选择了三类公开或低成本可获取的数据源，它们共同构成了预测的基石：

• 基础地理空间数据 ：来自 OpenStreetMap（OSM） 。这是项目的“地图底板”。我们用它获取校园内所有道路、路径、停车场多边形区域的矢量数据。OSM数据免费、开源、更新及时，通过Python的 osmnx 库可以轻松获取并转换为网络图进行分析。这是零成本的核心数据源。
• 车辆移动数据 ：这是关键的动态数据。我们并未跟踪具体车辆，而是通过模拟或聚合的 车辆进出流量数据 。在实践中，可以通过多种低成本方式获取：
  • 校园门禁系统日志（脱敏后） ：如果学校车辆门禁系统记录了进出车辆数（不记录车牌），这是最理想的数据。
  • 公共地图API的路径请求量 ：在特定时间段，向Google Maps Directions API或类似服务请求从各主要入口到校园内各点的路径，其返回的“典型通行时间”或请求量本身，可以间接反映交通流量。这需要一定的API调用成本，但远低于硬件部署。
  • 简易蓝牙/Wi-Fi探针 ：在几个关键入口部署低成本探针，统计MAC地址数量（需进行哈希化处理以保护隐私）来估算人流量，进而推测车流量。这是硬件成本与数据质量的折中。
• 辅助上下文数据 ：如天气数据（晴雨、温度）、校历事件（是否有大型活动、考试周）、课程表时间。这些数据可以从公开天气API和学校官网获取，几乎零成本。

设计心得 ：数据源的选择直接决定了项目的可行性与成本。我们的原则是“能公开不付费，能聚合不个体，能间接不直接”。所有数据都应进行聚合处理，确保无法回溯到单个用户，这是隐私保护的底线。

2.3 系统架构总览

整个框架的流程是一个标准的数据流水线，但其巧妙之处在于各环节的轻量化实现：

[数据采集层] -> [数据融合与处理层] -> [特征工程层] -> [模型训练与预测层] -> [应用服务层]

1. 数据采集层 ：通过 osmnx 获取OSM地图，通过脚本调用API或读取日志获取流量数据，通过爬虫或API获取天气事件数据。
2. 数据融合与处理层 ：这是 空间连接（Spatial Join） 大显身手的地方。我们将车辆流量数据点（带有时间戳和位置）与OSM道路网络进行空间关联，确定流量发生在哪条路上、靠近哪个停车场。同时，将时间与课程表、天气事件进行关联。
3. 特征工程层 ：将融合后的原始数据，转化为机器能理解的“特征”。例如，生成“早高峰期间（8:00-9:00）从北门进入的车辆累计数”、“当前时间前一小时的出校车辆数”、“距离最近教学楼的步行时间”、“今日是否有雨”等。
4. 模型训练与预测层 ：使用处理好的历史数据训练多个机器学习回归模型，预测未来某个时段（如下一个小时）各停车区的可用车位数量。
5. 应用服务层 ：将模型预测结果通过一个轻量级的Web应用或API接口发布出去，供学生和教职工查询。

这个架构完全运行在标准的云服务器或校内服务器上，无需任何特种硬件，实现了真正的软件定义、数据驱动的智能停车。

3. 实操详解：从零构建预测流水线

理论说得再多，不如一行代码。下面我将以最贴近实际开发的过程，带你走通整个流程。假设我们的技术栈是Python，这几乎是数据科学和地理空间分析的标准语言。

3.1 第一步：地理空间数据获取与处理

首先，我们需要一张校园的“数字地图”。

import osmnx as ox
import geopandas as gpd
import matplotlib.pyplot as plt

# 1. 定义校园的大致边界点（可以用地名，也可以用经纬度边界框）
place_name = "University of Sharjah, Sharjah, United Arab Emirates"
# 或者使用边界框：north, south, east, west = 25.31, 25.29, 55.39, 55.37

# 2. 从OSM下载道路网络数据
# graph_type可以是 'drive'（车行）, 'walk'（步行）, 'bike'（骑行）, 'all'（全部）
graph = ox.graph_from_place(place_name, network_type='drive', simplify=True)

# 3. 将图（Graph）转换为GeoDataFrame，方便进行GIS操作
nodes_gdf, edges_gdf = ox.graph_to_gdfs(graph)

# 4. 可视化，检查数据是否正确
fig, ax = ox.plot_graph(graph, node_size=0, edge_linewidth=0.5, show=False, close=False)
plt.title('Campus Road Network from OSM')
plt.show()

# 5. 获取停车场区域（在OSM中，停车场通常被标记为‘amenity=parking’的多边形）
tags = {'amenity': 'parking'}
parking_gdf = ox.geometries_from_place(place_name, tags)
print(f"Found {len(parking_gdf)} parking areas.")

关键操作与避坑指南 ：

• 网络类型选择 ： network_type='drive' 确保我们获取的是车行道路，过滤掉人行小道。这对于后续计算车辆可达性至关重要。
• 数据清洗 ：OSM是众包数据，可能存在错误或不一致。下载后务必检查：道路网络是否闭合？停车场多边形是否明显错误（如面积过小或过大）？需要进行手动修正或筛选。
• 坐标参考系（CRS）统一 ：OSM数据通常使用WGS84（EPSG:4326）地理坐标系。但进行距离计算时，应转换为投影坐标系（如UTM）。使用 ox.project_graph(graph, to_crs='EPSG:32640') （示例为WGS 84 / UTM zone 40N）进行转换，这样计算出的道路长度才是真实的米制距离。

3.2 第二步：车辆移动数据的模拟与融合

在真实项目中，移动数据可能来自门禁系统。这里我们演示如何构造一份模拟数据，并完成与道路网络的空间连接。

import pandas as pd
import numpy as np
from shapely.geometry import Point, LineString
from datetime import datetime, timedelta

# 1. 生成模拟的车辆移动数据（假设有5个校门，3天的数据，每小时一条记录）
np.random.seed(42)
num_records = 5 * 24 * 3 # 5个门 * 24小时 * 3天
timestamps = pd.date_range(start='2023-10-01 07:00', periods=num_records, freq='H')
gate_ids = np.repeat(['Gate_North', 'Gate_South', 'Gate_East', 'Gate_West', 'Gate_Main'], 24*3)
vehicle_in = np.random.poisson(lam=30, size=num_records).astype(int) # 模拟进入车辆数，泊松分布
vehicle_out = np.random.poisson(lam=25, size=num_records).astype(int) # 模拟离开车辆数

# 为每个校门分配一个模拟的经纬度坐标（实际中应从地图获取）
gate_locations = {
    'Gate_North': (55.375, 25.305),
    'Gate_South': (55.375, 25.295),
    'Gate_East': (55.385, 25.300),
    'Gate_West': (55.365, 25.300),
    'Gate_Main': (55.375, 25.300),
}

mobility_data = []
for ts, gate, vin, vout in zip(timestamps, gate_ids, vehicle_in, vehicle_out):
    lon, lat = gate_locations[gate]
    # 创建点几何对象
    geometry = Point(lon, lat)
    mobility_data.append({
        'timestamp': ts,
        'gate_id': gate,
        'vehicles_in': vin,
        'vehicles_out': vout,
        'geometry': geometry
    })

mobility_gdf = gpd.GeoDataFrame(mobility_data, crs='EPSG:4326')

# 2. 空间连接：将移动数据点匹配到最近的道路线段上
# 首先，需要将道路边（edges_gdf）转换为投影坐标系以进行准确距离计算
edges_gdf_proj = edges_gdf.to_crs('EPSG:32640')
mobility_gdf_proj = mobility_gdf.to_crs('EPSG:32640')

# 使用sjoin_nearest进行最近邻匹配
from geopandas.tools import sjoin_nearest
# 为每条移动记录找到最近的道路
matched_mobility = sjoin_nearest(mobility_gdf_proj, edges_gdf_proj[['geometry', 'osmid', 'length']], how='left', distance_col='distance_to_road')
# 现在，每条移动记录都关联了一条道路(osmid)和距离

print(matched_mobility.head())

核心难点解析：空间连接（Spatial Join） 这是整个数据预处理中最关键的一步。它的目的是将“某个时间点在某个位置发生的车流事件”与“具体的道路基础设施”关联起来。为什么这么做？因为车流量本身是孤立的点数据，只有把它锚定在路网上，我们才能计算累积流量、分析流向、推断其可能前往的停车场。

• 方法选择 ：我们使用了 sjoin_nearest 。在真实场景中，如果校门位置精确，也可以先用 osmnx 的 ox.nearest_edges 函数找到每个校门对应的最近道路节点（Node），然后将该节点关联的所有道路（Edge）作为该门流量的“归属道路”。
• 性能考量 ：如果数据量巨大（例如全市范围），直接进行几何计算会很慢。可以先建立空间索引（ sindex ），或使用如 GeoPandas 的 sjoin 配合 predicate=’intersects’ （如果数据是路段聚合流量）来加速。

3.3 第三步：特征工程——将数据转化为信息

原始数据是“面粉”，特征工程就是“和面、发酵”，做成模型能消化吸收的“面包”。我们基于融合后的数据，构造以下特征：

# 假设我们已经有了一个包含时空信息的DataFrame `df`，其中包含：
# timestamp, gate_id, vehicles_in, vehicles_out, nearest_road_id, hour_of_day, day_of_week等

def create_time_features(df):
    df['hour'] = df['timestamp'].dt.hour
    df['day_of_week'] = df['timestamp'].dt.dayofweek # Monday=0, Sunday=6
    df['is_weekend'] = df['day_of_week'].isin([5, 6]).astype(int)
    df['is_morning_rush'] = ((df['hour'] >= 7) & (df['hour'] <= 9)).astype(int)
    df['is_evening_rush'] = ((df['hour'] >= 16) & (df['hour'] <= 18)).astype(int)
    return df

def create_lag_features(df, group_cols, value_cols, lags=[1, 2, 3, 24]):
    """
    为指定分组创建滞后特征。
    例如：每个gate，前1小时、2小时、3小时和前一天的进出车辆数。
    """
    df = df.sort_values(['gate_id', 'timestamp']).copy()
    for col in value_cols:
        for lag in lags:
            df[f'{col}_lag_{lag}'] = df.groupby(group_cols)[col].shift(lag)
    return df

def create_rolling_features(df, group_cols, value_col, windows=[3, 6, 12]):
    """创建滚动统计特征，如移动平均、移动标准差。"""
    df = df.sort_values(['gate_id', 'timestamp']).copy()
    for window in windows:
        df[f'{value_col}_rolling_mean_{window}'] = df.groupby(group_cols)[value_col].transform(
            lambda x: x.rolling(window=window, min_periods=1).mean()
        )
        df[f'{value_col}_rolling_std_{window}'] = df.groupby(group_cols)[value_col].transform(
            lambda x: x.rolling(window=window, min_periods=1).std()
        )
    return df

def create_parking_zone_features(df, parking_gdf):
    """
    将流量数据与停车场关联。
    简化逻辑：计算每个gate到各个停车场的网络距离（使用osmnx的shortest_path长度），
    将流量按距离倒数加权分配给各停车场。
    这里返回一个合并了停车场容量的特征DataFrame。
    """
    # 这是一个简化示例。实际中需要计算网络最短路径距离。
    # 假设我们已预先计算好一个字典：gate_to_parking_distances
    # {gate_id: {parking_id: distance, ...}, ...}
    # 然后进行加权分配和特征合并。
    pass

# 应用特征工程函数
df = create_time_features(matched_mobility)
df = create_lag_features(df, group_cols=['gate_id'], value_cols=['vehicles_in', 'vehicles_out'])
df = create_rolling_features(df, group_cols=['gate_id'], value_col='vehicles_in')

# 目标变量：我���需要知道每个停车场在每个时间点的实际占用数或空闲数。
# 在真实场景中，这可能需要通过初始调查（如人工计数或短期传感器部署）获得一段时间的基础真值数据用于训练。
# 这里我们模拟一个目标变量‘available_spots’，假设���与出校车辆数正相关，与入校车辆数负相关，并加入随机噪声。
total_spots = 945 # 总车位数
# 简化模拟：可用车位 = 总车位 - 累计净流入（假设初始满位）
df['cumulative_net_inflow'] = df.groupby('gate_id')['vehicles_in'].transform('cumsum') - df.groupby('gate_id')['vehicles_out'].transform('cumsum')
# 注意：这是极度简化的模拟，真实情况复杂得多，需要更精细的建模。

特征工程的核心思想 ：

1. 时间特征 ：捕捉周期性（小时、工作日/周末）、趋势性（是否在上升期）。
2. 滞后特征 ：这是时间序列预测的灵魂。过去的流量直接影响未来的停车状况。
3. 滚动统计特征 ：描述近期态势（如过去3小时平均流量），平滑随机波动。
4. 空间特征 ：这是本项目特色。通过计算 道路网络距离 、 拓扑连通性 等，将流量在空间上扩散到各个停车场。例如，北门进入的车辆更可能停靠北区停车场。
5. 上下文特征 ：合并天气（雨天可能增加开车入校比例）、特殊事件（体育赛事、考试）等。

实操心得 ：特征工程是模型效果的上限。我们花了超过60%的时间在这一步。一个关键技巧是进行 特征重要性分析 （如使用随机森林的 feature_importances_ ），不断迭代，剔除无关特征，防止过拟合。在我们的实验中，“前一小时出校车辆数”、“是否早高峰”、“到最近教学楼的网络距离”是排名最高的几个特征。

3.4 第四步：模型训练、评估与选择

数据准备就绪，进入模型PK环节。我们对比了四种经典模型。

from sklearn.model_selection import train_test_split, GridSearchCV, TimeSeriesSplit
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression
from sklearn.svm import SVR
from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense, Dropout
from tensorflow.keras.callbacks import EarlyStopping
import warnings
warnings.filterwarnings('ignore')

# 1. 准备数据
# 假设最终特征矩阵为X，目标变量为y（例如，某个停车区的可用车位数）
# 删除含有NaN的行（由于滞后特征，前几行会是NaN）
df_model = df.dropna().copy()
X = df_model.drop(columns=['available_spots', 'timestamp', 'geometry']) # 移除目标列和非特征列
y = df_model['available_spots']

# 划分训练集和测试集（注意时间序列不能随机划分）
# 按时间顺序，前70%作为训练，后30%作为测试
split_idx = int(len(X) * 0.7)
X_train, X_test = X.iloc[:split_idx], X.iloc[split_idx:]
y_train, y_test = y.iloc[:split_idx], y.iloc[split_idx:]

# 标准化特征（对SVR和LSTM很重要）
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# 2. 线性回归 (Baseline)
lr = LinearRegression()
lr.fit(X_train_scaled, y_train)
y_pred_lr = lr.predict(X_test_scaled)

# 3. 支持向量回归 (SVR)
# 网格搜索寻找最优参数
param_grid_svr = {
    'C': [0.1, 1, 10, 100],
    'epsilon': [0.01, 0.1, 0.2],
    'kernel': ['rbf']
}
svr = SVR()
# 使用时间序列交叉验证
tscv = TimeSeriesSplit(n_splits=3)
grid_svr = GridSearchCV(svr, param_grid_svr, cv=tscv, scoring='neg_mean_squared_error', n_jobs=-1, verbose=0)
grid_svr.fit(X_train_scaled, y_train)
best_svr = grid_svr.best_estimator_
y_pred_svr = best_svr.predict(X_test_scaled)

# 4. 随机森林回归 (RFR)
param_grid_rf = {
    'n_estimators': [50, 100, 200],
    'max_depth': [10, 20, None],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4]
}
rf = RandomForestRegressor(random_state=42)
grid_rf = GridSearchCV(rf, param_grid_rf, cv=tscv, scoring='neg_mean_squared_error', n_jobs=-1, verbose=0)
grid_rf.fit(X_train, y_train) # 树模型通常不需要标准化
best_rf = grid_rf.best_estimator_
y_pred_rf = best_rf.predict(X_test)

# 5. 长短期记忆网络 (LSTM)
# LSTM需要3D输入 [samples, timesteps, features]
# 我们需要重构数据。假设我们使用过去3个小时的数据来预测下一个小时。
def create_sequences(X, y, time_steps=3):
    Xs, ys = [], []
    for i in range(len(X) - time_steps):
        Xs.append(X[i:(i + time_steps)])
        ys.append(y[i + time_steps])
    return np.array(Xs), np.array(ys)

time_steps = 3
X_train_seq, y_train_seq = create_sequences(X_train_scaled, y_train.values, time_steps)
X_test_seq, y_test_seq = create_sequences(X_test_scaled, y_test.values, time_steps)

lstm_model = Sequential([
    LSTM(units=50, activation='relu', input_shape=(time_steps, X_train_seq.shape[2]), return_sequences=False),
    Dropout(0.2),
    Dense(units=25, activation='relu'),
    Dense(units=1)
])
lstm_model.compile(optimizer='adam', loss='mse', metrics=['mae'])

early_stop = EarlyStopping(monitor='val_loss', patience=10, restore_best_weights=True)
history = lstm_model.fit(
    X_train_seq, y_train_seq,
    epochs=100,
    batch_size=32,
    validation_split=0.2,
    callbacks=[early_stop],
    verbose=0
)
y_pred_lstm = lstm_model.predict(X_test_seq).flatten()
# 注意：y_pred_lstm的长度会比y_test_seq短time_steps，评估时需要对齐

# 6. 模型评估
def evaluate_model(y_true, y_pred, model_name):
    mae = mean_absolute_error(y_true, y_pred)
    rmse = np.sqrt(mean_squared_error(y_true, y_pred))
    r2 = r2_score(y_true, y_pred)
    print(f"{model_name:20} MAE: {mae:.3f}, RMSE: {rmse:.3f}, R²: {r2:.3f}")
    return {'MAE': mae, 'RMSE': rmse, 'R2': r2}

print("Model Performance on Test Set:")
results = {}
results['Linear Regression'] = evaluate_model(y_test, y_pred_lr, 'Linear Regression')
results['SVR'] = evaluate_model(y_test, y_pred_svr, 'SVR')
results['Random Forest'] = evaluate_model(y_test, y_pred_rf, 'Random Forest')
# 对齐LSTM的预测和真实值
y_test_for_lstm = y_test[time_steps:] # 因为序列构建，前time_steps个点没有预测值
results['LSTM'] = evaluate_model(y_test_for_lstm, y_pred_lstm, 'LSTM')

模型选择背后的逻辑与实战经验 ：

• 线性回归 ：作为基准模型。如果复杂模型效果不比它好多少，说明特征或问题可能本质上是线性的，或者特征工程不到位。在我们的案例中，其低R²值（0.051）表明停车预测是一个复杂的非线性问题。
• 支持向量回归 ：擅长处理中小规模、高维数据，对异常值相对稳健。但它的性能严重依赖核函数和参数（C, epsilon）。通过网格搜索我们找到了较优参数，但最终表现中等，说明数据中的模式可能不是最适合SVR捕捉的。
• 随机森林回归 ：这是我们项目的“冠军模型”。它本质是多棵决策树的集成，能自动处理非线性关系、特征交互，并且对缺失值和异常值不敏感，不需要复杂的特征缩放。 最关键的是，它提供了特征重要性排序 ，这对于我们理解问题、迭代特征工程有巨大帮助。调参时， n_estimators （树的数量）和 max_depth （树的最大深度）是关键，防止过拟合。
• 长短期记忆网络 ：专为序列数据设计。理论上，它应该最擅长捕捉流量和停车状态随时间变化的长期依赖关系。但我们的实验中它略逊于随机森林，一个可能的原因是 数据量不足 。LSTM是“数据饥渴”型模型，通常需要成千上万个时间步的数据才能充分训练。我们只有3天每小时的数据（共72个点），再分割序列后，训练数据更少，导致其潜力未能完全发挥。

结果解读 ：随机森林以最低的RMSE（0.142）和MAE（0.112），以及最高的R²（0.582）胜出。R²为0.582意味着模型能够解释约58.2%的目标变量（可用车位数）方差，对于仅使用外部代��数据（非直接传感器数据）的预测来说，这是一个非常有希望的起点。

4. 部署与优化：让模型真正跑起来

模型在笔记本上跑出好成绩只是第一步，如何让它持续、稳定地提供服务，并不断进化，才是工程化的关键。

4.1 构建轻量级预测服务

我们不需要复杂的微服务架构，一个简单的Flask/FastAPI应用足矣。

# app.py (FastAPI示例)
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import pandas as pd
import joblib
import numpy as np
from datetime import datetime

app = FastAPI(title="Campus Parking Predictor")

# 加载训练好的模型和预处理对象
model = joblib.load('best_random_forest_model.pkl')
scaler = joblib.load('feature_scaler.pkl')
feature_columns = joblib.load('feature_columns.pkl') # 训练时使用的特征列顺序

class PredictionRequest(BaseModel):
    timestamp: str  # e.g., "2023-10-10 08:30:00"
    gate_north_in: int
    gate_north_out: int
    gate_south_in: int
    gate_south_out: int
    # ... 其他门和特征
    is_raining: int

@app.post("/predict/")
async def predict_availability(request: PredictionRequest):
    try:
        # 1. 将请求数据转换为DataFrame
        input_dict = request.dict()
        ts = pd.to_datetime(input_dict.pop('timestamp'))
        
        # 2. 基于时间戳生成时间特征
        input_dict['hour'] = ts.hour
        input_dict['day_of_week'] = ts.dayofweek
        input_dict['is_weekend'] = 1 if ts.dayofweek in [5,6] else 0
        input_dict['is_morning_rush'] = 1 if 7 <= ts.hour <= 9 else 0
        
        # 3. 这里需要模拟生成滞后特征和滚动特征。
        # 在实际系统中，你需要维护一个小的实时特征库（如Redis），
        # 根据当前请求的时间，查询出前几个小时的数据来计算这些特征。
        # 此处为示例，我们假设这些特征已包含在请求中或用默认值。
        # 例如：input_dict['vehicles_in_lag_1'] = get_lag_value('north_in', ts, lag=1)
        
        # 4. 构建特征向量，确保顺序与训练时一致
        feature_vector = []
        for col in feature_columns:
            feature_vector.append(input_dict.get(col, 0)) # 如果请求缺少某特征，用0或适当默认值填充
        
        # 5. 标准化
        feature_vector_scaled = scaler.transform([feature_vector])
        
        # 6. 预测
        prediction = model.predict(feature_vector_scaled)[0]
        # 假设预测的是“已占用车位数”，需要转换为“可用车位数”
        total_spots = 945
        available_spots = max(0, total_spots - int(round(prediction)))
        
        return {
            "timestamp": ts.isoformat(),
            "predicted_occupied": round(prediction, 2),
            "predicted_available": available_spots,
            "confidence": "medium" # 可根据模型预测概率或误差范围设定
        }
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)

部署注意事项 ：

• 特征实时计算 ：滞后特征和滚动特征是最大挑战。你需要一个 流处理 或 高频缓存更新 机制。例如，使用Redis存储最近24小时各门的流量数据，当新请求到来时，实时计算所需的滞后和滚动特征。
• 模型更新 ：模型不是一成不变的。应定期（如每月）用新数据重新训练模型，以捕捉季节变化或校园布局改变带来的影响。可以设计自动化流水线。
• 服务监控 ：监控API的响应时间、错误率和预测结果的分布。如果预测的空位数持续为0或满位，但实际反馈并非如此，说明模型可能漂移（Concept Drift），需要触发重新训练。

4.2 前端展示：一个简单的查询界面

预测结果需要以直观的方式呈现给最终用户——学生和教职工。一个极简的网页足矣。

<!DOCTYPE html>
<html>
<head>
    <title>校园停车位预测</title>
    <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
    <style>
        body { font-family: sans-serif; margin: 20px; }
        .parking-lot { margin: 15px; padding: 10px; border: 1px solid #ccc; border-radius: 5px; }
        .high { background-color: #ffcccc; } /* 车位紧张 */
        .medium { background-color: #ffffcc; } /* 车位适中 */
        .low { background-color: #ccffcc; } /* 车位充足 */
    </style>
</head>
<body>
    <h1>实时校园停车位预测</h1>
    <label for="targetTime">查询时间：</label>
    <input type="datetime-local" id="targetTime" value="">
    <button onclick="fetchPrediction()">查询</button>

    <div id="results">
        <!-- 预测结果将动态填充在这里 -->
    </div>

    <canvas id="trendChart" width="400" height="200"></canvas>

    <script>
        async function fetchPrediction() {
            const timeInput = document.getElementById('targetTime').value;
            if (!timeInput) {
                alert('请选择时间');
                return;
            }
            // 这里应该从后端获取实时流量数据（例如从校园API），这里用模拟数据
            const mockRequestData = {
                timestamp: timeInput,
                gate_north_in: 45,
                gate_north_out: 20,
                gate_south_in: 30,
                gate_south_out: 25,
                is_raining: 0
            };

            const response = await fetch('http://localhost:8000/predict/', {
                method: 'POST',
                headers: { 'Content-Type': 'application/json' },
                body: JSON.stringify(mockRequestData)
            });
            const data = await response.json();
            displayResults(data);
        }

        function displayResults(prediction) {
            const resultsDiv = document.getElementById('results');
            let statusClass = 'low';
            let statusText = '充足';
            const available = prediction.predicted_available;
            const total = 945;
            const occupancyRate = ((total - available) / total * 100).toFixed(1);

            if (available < total * 0.2) {
                statusClass = 'high'; statusText = '紧张';
            } else if (available < total * 0.5) {
                statusClass = 'medium'; statusText = '适中';
            }

            resultsDiv.innerHTML = `
                <div class="parking-lot ${statusClass}">
                    <h3>全校停车场 (${prediction.timestamp})</h3>
                    <p><strong>预测可用车位：</strong> ${available} / ${total}</p>
                    <p><strong>占用率：</strong> ${occupancyRate}% - 状态：${statusText}</p>
                    <p><small>预测置信度：${prediction.confidence}</small></p>
                </div>
            `;
            // 可以在这里更新趋势图表
        }
        // 页面加载时默认查询当前时间
        window.onload = function() {
            const now = new Date();
            now.setMinutes(now.getMinutes() - now.getTimezoneOffset());
            document.getElementById('targetTime').value = now.toISOString().slice(0, 16);
            fetchPrediction();
        };
    </script>
</body>
</html>

这个界面虽然简单，但提供了最核心的功能：选择时间、查看预测结果、直观的颜色状态提示。在实际部署中，可以结合校园地图，将预测结果标注在各个具体停车场的位置上。

5. 避坑指南与未来展望

在实践这个项目的过程中，我们遇到了不少预料之中和预料之外的挑战。这里把关键的经验教训总结一下，希望能帮你少走弯路。

5.1 常见问题与解决方案

1. 数据质量与一致性是最大挑战

   • 问题 ：OSM数据在某些区域可能不完整或过时；模拟或获取的流量数据可能存在缺失值、异常值（如深夜突然的流量高峰可能是数据错误）。
   • 解决 ：
     • 数据验证 ：定期用卫星图或实地勘察验证OSM道路和停车场数据。
     • 异常值处理 ：使用统计方法（如IQR）识别并处理异常流量数据。对于缺失值，采用时间序列插值（如线性插值、前向填充）而非简单删除。
     • 数据同步 ：确保所有数据源的时间戳已统一时区，并校准到同一时间基准。

2. 特征工程中的“数据泄露”

   • 问题 ：在构建滞后特征时，如果不小心使用了“未来”的信息，会导致模型在训练时表现虚假的优秀，而在实际预测中完全失效。
   • 解决 ：严格遵守 时间先后顺序 。在划分训练集和测试集时，必须按时间顺序划分，确保测试集的时间都在训练集之后。计算滚动特征时，只使用历史信息。

3. 模型过拟合与泛化能力不足

   • 问题 ：随机森林模型在训练集上R²高达0.9，但在测试集上只有0.58，这就是过拟合。
   • 解决 ：
     • 交叉验证 ：务必使用 时间序列交叉验证（TimeSeriesSplit） ，而不是普通的K-Fold。这能更好地评估模型在时间上的泛化能力。
     • 正则化与剪枝 ：在随机森林中，限制 max_depth 、增加 min_samples_split 和 min_samples_leaf 。在神经网络中使用Dropout层。
     • 简化模型 ：如果特征很多但数据量少，先做特征选择，剔除不重要特征。

4. 实时预测的延迟与性能

   • 问题 ：模型预测需要计算大量特征，如果每次请求都从头计算，API响应会变慢。
   • 解决 ：
     • 特征预计算与缓存 ：将不频繁变化的特征（如空间距离）预先计算好并存储。将高频变化的特征（如最近一小时的流量）存储在Redis等内存数据库中，并设置自动过期。
     • 模型轻量化 ：对于随机森林，可以考虑使用 sklearn 的 model 压缩，或转换为ONNX格式以提高推理速度。如果最终部署，可以考虑使用更轻量的模型如LightGBM。

5.2 项目的局限性与未来优化方向

没有任何一个项目是完美的，我们这个框架也有其局限性，而这正是未来可以深耕的方向：

1. 数据源的扩展与精细化 ：

   • 实时交通流 ：接入高德地图、百度地图的实时路况API，获取校园周边道路的拥堵指数，这能极大提升对“即将进入车辆”的预测精度。
   • 课程表与事件数据 ：与学校教务系统打通（需脱敏），获取精确到每栋楼、每节课的学生人数，从而更精准地预测停车需求的空间分布。
   • 匿名化的Wi-Fi探针数据 ：在主要建筑入口部署，统计人流量，作为车辆流量的强相关补充。

2. 预测粒度的提升 ：

   • 当前模型预测的是“全校”或“大片区”的可用车位数。下一步可以细化到 每个停车场甚至每个楼层 。这需要更精细的空间数据（停车场内部车道）和更复杂的空间扩散模型。

3. 模型融合与在线学习 ：

   • 可以尝试 集成学习 ，例如将随机森林和LSTM的预测结果进行加权平均或使用Stacking策略。
   • 实现 在线学习 机制，让模型能够根据最新的真实停车数据（可通过少量抽样或用户上报获得）进行微调，适应不断变化的环境。

4. 从预测到引导与优化 ：

   • 个性化路线推荐 ：结合预测结果，为即将抵达的用户推荐最有可能有空位的停车场及最优步行路线。
   • 动态定价与预约 ：在停车极度紧张的区域，引入轻微的差异化收费或预约制度，用经济杠杆调节需求。我们的预测模型可以为动态定价策略提供数据支撑。

这个项目给我的最大启发是， 智慧城市解决方案未必需要重金投入硬件 。通过创造性地利用现有数据资产和先进的算法，我们完全可以用“软”实力解决“硬”问题。从一行行代码到最终能帮同学节省找车位时间的服务，这个过程充满了挑战，但看到想法落地成真，那种成就感是无与伦比的。如果你也在校园或社区面临类似的停车难题，不妨从收集第一份OSM地图数据开始，动手试试这个框架。