1. 数据探索与可视化:先看懂数据在“说”什么
拿到一份共享单车的历史租赁数据,很多新手朋友可能会迫不及待地直接开始建模。我刚开始做数据分析的时候也这样,结果往往是模型效果很差,还不知道问题出在哪。后来踩过几次坑才明白,数据探索性分析这一步绝对不能省。它就像是打仗前的侦察,不摸清敌情就冲锋,大概率要吃败仗。
我们手头的数据通常是一个CSV文件,比如叫 bike_train.csv。里面每一行记录了一次租赁事件(或者某个时间点的汇总数据),常见的字段有 datetime(日期时间)、season(季节)、weather(天气)、temp(温度)、atemp(体感温度)、humidity(湿度)、windspeed(风速),以及我们最终要预测的目标变量 count(总租赁量),有时还会细分为 registered(注册用户)和 casual(临时用户)。
第一步,用 pandas 把它读进来,先看看“长相”。
import pandas as pd
# 加载数据
train_df = pd.read_csv('./step1/bike_train.csv')
# 快速查看前几行和基本信息
print(train_df.head())
print(train_df.info())
print(train_df.describe())
运行这几行代码,你能立刻知道数据有多少行、多少列,有没有缺失值,各个字段是什么数据类型,数值型字段的大致分布(均值、标准差、最大最小值)。比如,你可能会发现 windspeed 有很多0值,这可能是传感器误差,也可能是真的无风,需要后续判断。count 的分布可能严重右偏,这意味着存在一些租赁量极高的“尖峰”时刻。
但光看数字表格不够直观,数据可视化才是探索分析的灵魂。我们的目标是发现规律、趋势和异常。一个非常关键的维度是时间。原始数据里的 datetime 字段是字符串,我们需要把它拆开,提取出小时、星期几、月份等信息,才能观察不同时间尺度上的模式。
原始文章里给出了按小时聚合平均租赁量的例子,这是一个非常好的起点:
import matplotlib.pyplot as plt
# 从datetime中提取小时数
train_df['hour'] = train_df.datetime.apply(lambda x: x.split()[1].split(':')[0]).astype('int')
# 按小时分组,计算平均租赁量
group_hour = train_df.groupby('hour')
hour_mean = group_hour[['count', 'registered', 'casual']].mean()
# 绘制折线图
fig = plt.figure(figsize=(12, 6))
plt.plot(hour_mean['count'], label='Total Count', marker='o')
plt.plot(hour_mean['registered'], label='Registered', linestyle='--')
plt.plot(hour_mean['casual'], label='Casual', linestyle=':')
plt.title('Average Bike Rental Count per Hour of the Day')
plt.xlabel('Hour of Day')
plt.ylabel('Average Count')
plt.legend()
plt.grid(True, linestyle='--', alpha=0.7)
plt.savefig('./step1/result/hourly_trend.png', dpi=300, bbox_inches='tight')
plt.show()
这个图能立刻告诉你一天中的用车高峰。通常你会发现两个明显的峰值:早上8-9点的通勤高峰,和晚上17-18点的下班高峰。注册用户和临时用户的模式可能不同,注册用户的高峰更突出,而临时用户可能在午后和周末更活跃。除了小时,你还可以按星期几、月份/季节、是否为节假日来分组可视化。比如,画一个按星期几分组的箱线图,可以清晰地看到周末和工作日需求的差异以及数据的离散程度。
train_df['weekday'] = pd.to_datetime(train_df['date']).dt.dayofweek # 0=周一, 6=周日
plt.figure(figsize=(10,6))
train_df.boxplot(column='count', by='weekday')
plt.title('Rental Count Distribution by Weekday')
plt.suptitle('') # 去掉pandas自动生成的标题
plt.xlabel('Weekday (0=Monday)')
plt.ylabel('Rental Count')
plt.savefig('./step1/result/weekday_boxplot.png')
异常值检测也是探索阶段的重要任务。一个简单有效的方法是使用3σ原则(三倍标准差法),或者观察箱线图。那些远远偏离正常范围的“离群点”,可能是特殊事件(比如大型活动、极端天气)导致的真实情况,也可能是数据记录错误。对于后者,我们需要考虑在建模前进行处理。
# 计算均值和标准差
mean_val = train_df['count'].mean()
std_val = train_df['count'].std()
# 标记3σ以外的异常值
train_df['is_outlier'] = np.abs(train_df['count'] - mean_val) > 3 * std_val
print(f"Found {train_df['is_outlier'].sum()} potential outliers.")
花上足够的时间做数据探索,你会对这份数据产生“感觉”。你会知道什么时候需求高,什么因素可能影响需求,数据质量如何。这些直觉和发现,将直接指导下一步的特征工程——这是模型效果提升的关键。
2. 特征工程:如何把原始数据“喂”给模型
如果说数据探索是理解数据,那么特征工程就是翻译数据,把人类能看懂的时间、天气、类别,转换成机器学习模型能理解和计算的数字。这一步做得好不好,常常直接决定了模型性能的上限。我见过太多案例,换一个复杂的模型提升有限,但精心构造几个特征,效果立竿见影。
原始数据中的 datetime 字段是一个宝库。我们不能直接把“2024-01-15 08:30:00”这样的字符串扔给模型,必须把它拆解成有意义的特征。最基本的操作就是提取年、月、日、小时、星期几。
from datetime import datetime
def create_time_features(df):
"""
从datetime列创建时间相关特征
"""
df['date'] = pd.to_datetime(df['datetime']) # 先转为pandas datetime格式
df['year'] = df['date'].dt.year
df['month'] = df['date'].dt.month
df['day'] = df['date'].dt.day
df['hour'] = df['date'].dt.hour
df['weekday'] = df['date'].dt.dayofweek # 周一=0, 周日=6
df['weekend'] = df['weekday'].apply(lambda x: 1 if x >= 5 else 0) # 是否为周末
df['day_of_year'] = df['date'].dt.dayofyear
# 可以创建更复杂的周期特征,比如一天中的正弦/余弦变换,能更好地表达时间的周期性
df['hour_sin'] = np.sin(2 * np.pi * df['hour']/24)
df['hour_cos'] = np.cos(2 * np.pi * df['hour']/24)
df['weekday_sin'] = np.sin(2 * np.pi * df['weekday']/7)
df['weekday_cos'] = np.cos(2 * np.pi * df['weekday']/7)
return df
train_df = create_time_features(train_df)
为什么要做正弦余弦变换?因为“小时”这个特征,23点和0点是相邻的,但数值上23和0相差很大,模型很难理解这种循环关系。转换成正弦余弦后,这种相邻性就被完美地表达在坐标上了。这是一个非常实用的小技巧。
接下来是分类变量的处理。数据集里的 season(1-春,2-夏,3-秋,4-冬)和 weather(1-晴,2-雾/多云,3-小雪/雨,4-大雨/雪)都是类别。如果你直接把这个1-4的数字当成数值特征用,模型会错误地认为“冬天(4)”比“春天(1)”大,从而学习到错误的序关系。正确的做法是独热编码。
# 使用pandas的get_dummies进行独热编码
dummies_season = pd.get_dummies(train_df['season'], prefix='season')
dummies_weather = pd.get_dummies(train_df['weather'], prefix='weather')
dummies_month = pd.get_dummies(train_df['month'], prefix='month')
# 将生成的虚拟变量列连接到原数据框,并丢弃原始的类别列
train_df = pd.concat([train_df, dummies_season, dummies_weather, dummies_month], axis=1)
train_df = train_df.drop(['season', 'weather', 'month'], axis=1)
除了从现有字段直接衍生,我们还可以创造交互特征和聚合统计特征。比如,“温度”和“是否周末”可能单独对需求有影响,但“周末的高温”可能会引发更强的休闲出行需求,这个组合效应就需要一个交互特征(temp * weekend)来捕捉。聚合特征则像是“历史记忆”,比如“过去3小时的平均租赁量”、“昨天同一时刻的租赁量”。这类特征非常强大,因为它们引入了时间序列的依赖关系。
# 假设数据已按时间排序,计算滑动窗口均值作为特征
train_df['count_rolling_3h'] = train_df['count'].rolling(window=3, min_periods=1).mean().shift(1) # 用过去3小时均值,shift(1)避免数据泄露
# 计算昨天同一时刻的需求(需要数据包含连续多天)
# 这里假设数据是按小时连续的,可以用shift(24)来获取
train_df['count_lag_24h'] = train_df['count'].shift(24)
最后,别忘了特征缩放。像 temp、humidity、windspeed 这些连续型特征,它们的量纲和数值范围差异很大。使用基于距离的模型(如KNN、SVM)或使用正则化的模型(如Ridge、Lasso)时,必须进行标准化或归一化,否则数值大的特征会主导模型训练。
from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
# 选择需要缩放的数值列
numeric_cols = ['temp', 'atemp', 'humidity', 'windspeed']
train_df[numeric_cols] = scaler.fit_transform(train_df[numeric_cols])
特征工程是一个需要结合业务知识和反复试验的过程。没有一套固定的“金科玉律”。我的经验是,先从基础的时间、类别特征做起,构建一个基线模型,然后通过分析模型的误差(比如哪些时间点预测得特别差),再回头来思考可以构造什么新特征去修正它。这是一个迭代循环。
3. 模型构建:从线性回归到更强大的算法
有了精心准备的特征,我们就可以开始搭建预测模型了。原始文章里使用了 Ridge回归,这是一个非常明智的起点。对于很多预测问题,尤其是特征间可能存在一定相关性的情况,Ridge回归因其简单、快速且自带防止过拟合的L2正则化,常常能给出一个不错的基线分数。
让我们先复现并理解这个基线模型。核心步骤包括:数据准备、划分训练/验证集、模型训练、预测与评估。
import pandas as pd
import numpy as np
from sklearn.linear_model import Ridge
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error, mean_absolute_error
# 假设train_df是已经完成特征工程的数据框
# 定义特征列和目标列
feature_columns = [col for col in train_df.columns if col not in ['datetime', 'date', 'count', 'casual', 'registered']]
X = train_df[feature_columns].values
y = train_df['count'].values
# 划分训练集和验证集(注意:时间序列数据最好按时间划分,这里简单随机划分用于演示)
X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.2, random_state=42)
# 初始化Ridge回归模型,alpha是正则化强度
ridge_model = Ridge(alpha=1.0, random_state=42)
# 训练模型
ridge_model.fit(X_train, y_train)
# 在验证集上预测
y_pred = ridge_model.predict(X_val)
# 评估模型
mse = mean_squared_error(y_val, y_pred)
rmse = np.sqrt(mse)
mae = mean_absolute_error(y_val, y_pred)
print(f"Ridge Regression - RMSE: {rmse:.2f}, MAE: {mae:.2f}")
运行后你会得到两个关键指标:RMSE和MAE。RMSE对大的误差惩罚更重,而MAE则更直观(平均差了多少辆车)。它们是你衡量模型好坏的尺子。但是,线性模型假设特征和目标之间存在线性关系,而现实世界往往更复杂。比如,温度对需求的影响可能不是线性的:太冷或太热时需求都低,适宜温度时需求高。这时,我们就需要更灵活的模型。
一个自然的升级是树模型,比如随机森林或梯度提升树。它们能自动捕捉非线性关系和特征交互,而且对特征缩放不敏感。
from sklearn.ensemble import RandomForestRegressor
rf_model = RandomForestRegressor(n_estimators=100, max_depth=10, random_state=42, n_jobs=-1)
rf_model.fit(X_train, y_train)
y_pred_rf = rf_model.predict(X_val)
mse_rf = mean_squared_error(y_val, y_pred_rf)
print(f"Random Forest - RMSE: {np.sqrt(mse_rf):.2f}")
在我的多次实测中,随机森林通常能比Ridge回归有显著的提升。你还可以通过 feature_importances_ 属性查看哪些特征最重要,这反过来可以帮你做特征筛选。
importances = rf_model.feature_importances_
indices = np.argsort(importances)[::-1]
print("Feature ranking:")
for i, idx in enumerate(indices[:10]): # 打印前10重要的特征
print(f"{i+1}. {feature_columns[idx]} ({importances[idx]:.4f})")
你会发现,小时、温度、星期几、历史需求(如果你构造了)等特征排名很靠前。这验证了我们特征工程的方向是对的。如果想追求极致的性能,可以尝试梯度提升机,比如 XGBoost 或 LightGBM。它们速度更快,效果往往也更好,但需要调更多的参数。
# 以LightGBM为例
import lightgbm as lgb
# 创建数据集格式
train_data = lgb.Dataset(X_train, label=y_train)
val_data = lgb.Dataset(X_val, label=y_val, reference=train_data)
# 设置参数
params = {
'objective': 'regression',
'metric': 'rmse',
'boosting_type': 'gbdt',
'num_leaves': 31,
'learning_rate': 0.05,
'feature_fraction': 0.9,
'verbose': 0
}
# 训练
gbm_model = lgb.train(params,
train_data,
valid_sets=[val_data],
num_boost_round=1000,
callbacks=[lgb.early_stopping(stopping_rounds=50)])
y_pred_lgb = gbm_model.predict(X_val, num_iteration=gbm_model.best_iteration)
print(f"LightGBM - RMSE: {np.sqrt(mean_squared_error(y_val, y_pred_lgb)):.2f}")
模型选择没有绝对的最好,只有最适合。Ridge回归简单可解释;随机森林稳健,开箱即用;LightGBM/XGBoost强大但需要调参。我的建议是,从一个简单的基线开始,逐步尝试更复杂的模型,并用验证集的分数来说话。同时,一定要考虑模型复杂度与计算成本的平衡。一个需要训练1小时的复杂模型,如果只比5分钟训练好的简单模型好1%,在有些场景下可能并不划算。
4. 模型优化与评估:让预测更准一点
当我们有了一个初步的模型,比如RMSE在80左右,接下来的目标就是把它优化到75,甚至70。这个过程就像打磨一件工艺品,需要耐心和技巧。优化主要围绕几个方面:参数调优、模型集成、误差分析和交叉验证。
首先说参数调优。像随机森林的 n_estimators(树的数量)、max_depth(树的最大深度),LightGBM的 learning_rate(学习率)、num_leaves(叶子数),这些参数对结果影响很大。手动调参效率低,我们通常使用 网格搜索 或 随机搜索,让计算机自动寻找最优组合。
from sklearn.model_selection import GridSearchCV
# 以Ridge回归为例,调整alpha参数
param_grid = {'alpha': [0.01, 0.1, 0.5, 1.0, 2.0, 5.0, 10.0]}
ridge = Ridge(random_state=42)
grid_search = GridSearchCV(ridge, param_grid, cv=5, scoring='neg_mean_squared_error', verbose=1, n_jobs=-1)
grid_search.fit(X_train, y_train)
print(f"Best alpha: {grid_search.best_params_['alpha']}")
print(f"Best CV score (negative MSE): {grid_search.best_score_}")
best_ridge_model = grid_search.best_estimator_
这里用了5折交叉验证,可以更稳健地评估参数性能,避免过拟合到某一次的训练-验证划分上。对于更复杂的模型,随机搜索(RandomizedSearchCV)在超参数空间较大时效率更高。
单一的模型可能已经逼近了其能力的极限,这时可以尝试模型集成。简单来说,就是“三个臭皮匠,顶个诸葛亮”。我们可以把之前训练好的Ridge、随机森林、LightGBM模型组合起来,让它们“投票”决定最终的预测值。常用方法有投票法和堆叠法。
from sklearn.ensemble import VotingRegressor
# 假设我们已经有了三个训练好的模型:ridge_model, rf_model, lgb_model
voting_reg = VotingRegressor(
estimators=[('ridge', ridge_model), ('rf', rf_model), ('lgb', lgb_model)],
weights=[1, 2, 3] # 可以根据模型表现分配权重
)
voting_reg.fit(X_train, y_train)
y_pred_vote = voting_reg.predict(X_val)
堆叠法更复杂一些,它用初级模型的预测结果作为新特征,去训练一个次级模型(也叫元模型)。这通常能获得更好的效果,但也要小心过拟合。
无论用什么方法,误差分析都是优化过程中最重要的一环。你不能只看一个总的RMSE数字,而要深入看看模型到底在哪些地方预测错了。把验证集中预测误差最大的那些样本挑出来,仔细研究。
# 计算每个样本的绝对误差
val_df = pd.DataFrame(X_val, columns=feature_columns) # 假设我们把验证集特征转回了DataFrame
val_df['true_count'] = y_val
val_df['pred_count'] = y_pred
val_df['abs_error'] = np.abs(val_df['true_count'] - val_df['pred_count'])
# 找出误差最大的前20个样本
top_errors = val_df.nlargest(20, 'abs_error')
print(top_errors[['hour', 'weekday', 'temp', 'true_count', 'pred_count', 'abs_error']].head())
# 分析这些样本的共同点:是不是都在节假日?天气异常?还是某个特定时间段?
你可能会发现,模型在节假日早上的预测普遍偏低,或者在暴雨天气下的预测偏差很大。这说明我们可能缺少相关的特征(比如“是否为特殊节日”、“降雨强度”),或者需要对现有特征在这些特殊场景下的作用进行更精细的建模(比如为节假日引入一个交互特征)。
最后,在模型最终定型前,一定要使用时间序列交叉验证。因为我们的数据是按时间顺序的,传统的随机K折交叉验证会破坏时间结构,导致“用未来的数据预测过去”这种数据泄露。更合理的方法是使用滑动窗口或扩展窗口的方式进行验证。
from sklearn.model_selection import TimeSeriesSplit
tscv = TimeSeriesSplit(n_splits=5)
cv_scores = []
for train_index, val_index in tscv.split(X):
X_train_cv, X_val_cv = X[train_index], X[val_index]
y_train_cv, y_val_cv = y[train_index], y[val_index]
model = Ridge(alpha=1.0)
model.fit(X_train_cv, y_train_cv)
score = np.sqrt(mean_squared_error(y_val_cv, model.predict(X_val_cv)))
cv_scores.append(score)
print(f"TimeSeries CV RMSE scores: {cv_scores}")
print(f"Average RMSE: {np.mean(cv_scores):.2f} (+/- {np.std(cv_scores):.2f})")
这个平均RMSE和标准差,才是对你模型泛化能力更可靠的估计。优化是一个永无止境的过程,但在实际项目中,我们需要设定一个合理的停止点。当增加的特征或模型的复杂度带来的提升微乎其微,或者计算成本远超收益时,当前的模型就是一个可以交付的好模型了。记住,没有完美的模型,只有适合当前业务需求和资源约束的解决方案。
5801



被折叠的 条评论
为什么被折叠?



