代码收藏家 【实战】机器学习Kaggle比赛—House Prices – Advanced Regression Techniques
House Prices – Advanced Regression Techniques
一、准备工作
（1）查看项目概述
网址：https://www.kaggle.com/competitions/house-prices-advanced-regression-techniques/overview
简单来说，就是我们需要根据一些房子的信息数据（所有房子的79个特征表现，部分房子的真实房价），来预测其他的房子的价格。
（2）下载数据集
一直往下翻
（3）导入部分必要的库
import pandas as pd
import numpy as np
import matplotlib
import matplotlib.pyplot as plt
from scipy.stats import skew
（4）参数设置（图形显示大小+屏蔽警告）
%matplotlib inline
matplotlib.rcParams['figure.figsize'] = (12.0, 6.0)
import warnings
warnings.filterwarnings("ignore")
（5）导入数据集
train = pd.read_csv('train.csv')
test = pd.read_csv('test.csv')
二、特征分析
（1）分析数据特征
（2）分析时间序列特征
year_feats = [col for col in all_data.columns if "Yr" in col or 'Year' in col]
year_feats
根据 YrSold 列对 all_data 中此列数据框进行分组，并计算每个分组中 SalePrice 列的中位数，然后绘制这些中位数随时间变化的折线图
combined_df = pd.concat([train,test],axis=0)
combined_df.groupby('YrSold')['SalePrice'].median().plot()
plt.xlabel('Year Sold')
plt.ylabel('House Price')
plt.title('House price vs YearSold')
for feature in year_feats:
if feature != 'YrSold':
hs = combined_df.copy()
plt.scatter(hs[feature],hs['SalePrice'])
plt.xlabel(feature)
plt.ylabel('SalePrice')
plt.show()
可以看到随着时间的增加，价格是逐增加的
三、数据预处理
（一）合并数据
all_data = pd.concat([train.loc[:, 'MSSubClass':'SaleCondition'],test.loc[:, 'MSSubClass':'SaleCondition']])
（二）对于数字特征
（1）减小时间特征值的大小
在某些情况下，直接使用年份数据可能不如使用年龄数据有效，年龄数据可以减少年份数据中的噪声，并可能提高模型的性能
for feature in ['YearBuilt','YearRemodAdd','GarageYrBlt']:
all_data[feature]=all_data['YrSold']-all_data[feature]
（2） 正态化 SalePrice
prices = pd.DataFrame({"price":train["SalePrice"],"log(price + 1)":np.log1p(train["SalePrice"])})
train["SalePrice"] = np.log1p(train["SalePrice"])
numeric_feats = all_data.dtypes[all_data.dtypes != 'object'].index
skewed_feats = train[numeric_feats].apply(lambda x: skew(x.dropna()))
skewed_feats = skewed_feats[skewed_feats > 0.75]
skewed_feats = skewed_feats.index
all_data[skewed_feats] = np.log1p(all_data[skewed_feats])
（3）连续值归一化（有些数太大了，严重影响拟合情况）
all_data[numeric_feats] = all_data[numeric_feats].apply(lambda x: (x - x.mean())/(x.std()))
（4）无效值用该列平均值填充
all_data = all_data.fillna(all_data.mean())
（三）对于类别特征
将 all_data 数据框中的分类变量进行独热编码，并将结果重新赋值给 all_data。经过 get_dummies 处理后，all_features 数据框中的每个分类变量都会被转换为多个二进制列，每个列对应一个分类变量的一个唯一值。
如果 dummy_na=True，还会为每个包含 NaN 的分类变量创建一个额外的列来表示 NaN 值。
all_data = pd.get_dummies(all_data)
四、建立模型
（一）数据准备
（1）分别拿到训练和测试特征，训练标签
因之前合并了数据进行特征处理，这里把数据集拆分还原为训练集和测试集，还要将训练标签拆分出来
.shape( ) 返回一个包含数据框形状的元组 (rows, columns)，这里.shape[0]通过索引 [0] 访问元组的第一个元素，即数据框的行数，作用就是计算并存储 train 数据框的行数，即训练数据集的样本数量 train.SalePrice 从名为 train 的 DataFrame 中提取 SalePrice 这一列，并将其赋值给变量 y
X_train = all_data[:train.shape[0]]
X_test = all_data[train.shape[0]:]
y = train.SalePrice
（2）导入训练模型所需的库
Ridge 和 RidgeCV：
Ridge 是 Ridge 回归模型，一种线性回归的正则化版本，通过添加 L2 正则化项（即平方和惩罚项）来防止过拟合。
RidgeCV 是 Ridge 回归的交叉验证版本，用于自动选择最佳的正则化参数（alpha）。ElasticNet：
ElasticNet 是一种结合了 L1 和 L2 正则化的线性回归模型。它同时使用 L1 正则化（Lasso）和 L2 正则化（Ridge）来平衡特征选择和模型复杂度。LassoCV 和 LassoLarsCV：
LassoCV 是 Lasso 回归的交叉验证版本，Lasso 回归通过添加 L1 正则化项（即绝对值和惩罚项）来进行特征选择和防止过拟合。
LassoLarsCV 是使用最小角回归（Least Angle Regression, LARS）算法的 Lasso 回归的交叉验证版本，适用于高维数据集。
from sklearn.linear_model import Ridge, RidgeCV, ElasticNet, LassoCV, LassoLarsCV
from sklearn.model_selection import cross_val_score
（二）定义均方根误差函数（评分指标）
cross_val_score 是一个函数，用于执行交叉验证并返回每个折叠的评分 scoring=‘neg_mean_squared_error’ 指定评分指标为负的均方误差（Negative Mean Squared Error）。由于 cross_val_score 返回的是负的均方误差，我们需要取负号来得到正的均方误差。 cv=5 指定使用 5 折交叉验证。
def rmse_cv(model):
rmse = np.sqrt(-cross_val_score(model, X_train, y, scoring='neg_mean_squared_error', cv=5))
return rmse
（三）建立 Ridge 回归模型
（1）模型最佳的 alpha 值的选取
model_ridge = Ridge() 创建了一个 Ridge 回归模型的实例，但并没有指定 alpha 值。alpha 值是 Ridge 回归中的正则化参数，用于控制模型的复杂度。 还定义了一个包含不同 alpha 值的列表。这些 alpha 值将用于评估 Ridge 回归模型的性能。 接着定义了一个列表推导式，对于 alphas 列表中的每个 alpha 值，创建一个 Ridge 模型实例，并指定该 alpha 值。调用 rmse_cv 函数计算该模型的 RMSE，rmse_cv 函数通过交叉验证返回每个折叠的 RMSE 值。对每个 alpha 值的 RMSE 值取平均，得到该 alpha 值对应的平均 RMSE。
model_ridge = Ridge()
alphas = [0.05, 0.1, 0.3, 1, 3, 5, 10, 15, 30, 50, 75]
cv_ridge = [rmse_cv(Ridge(alpha = alpha)).mean() for alpha in alphas]
cv_ridge = pd.Series(cv_ridge, index = alphas)
cv_ridge.plot(title = "Validation")
plt.xlabel("Alpha")
plt.ylabel("RMSE")
可以看到 alpha=10 时效果最好，我们就取 alpha=10
（2）训练模型+预测结果
fit 方法会根据输入数据调整模型的参数，使其能够对数据进行预测。训练后的模型存储在 ridge_model_after_fit 变量中。 predict 方法返回预测结果。由于在训练过程中对目标变量 y 进行了对数变换（np.log1p），这里使用 np.expm1 对预测结果进行逆变换，将其转换回原始的房价范围。np.expm1 是 np.exp(x) – 1 的简写，用于计算 exp(x) – 1。
chosen_alpha = 10
model_ridge = Ridge(alpha = chosen_alpha)
ridge_model_after_fit = model_ridge.fit(X_train, y)
ridge_preds = np.expm1(model_ridge.predict(X_test))
（3）输出结果
solution = pd.DataFrame({"id":test.Id, "SalePrice":ridge_preds})
solution.to_csv("ridge_sol_alpha10.csv", index=False)
（四）建立 Lasso 回归模型
步骤与前面类似，这里不再阐述
model_lasso = LassoCV(alphas = [20, 10, 1, 0.1, 0.01, 0.001, 0.0005]).fit(X_train, y)
lasso_preds = np.expm1(model_lasso.predict(X_test))
solution = pd.DataFrame({"id":test.Id, "SalePrice":lasso_preds})
solution.to_csv("lasso_sol.csv", index=False)
（五）建立XGBoost 回归模型
DMatrix 是 XGBoost 中用于存储数据的一种数据结构，它优化了内存使用和计算效率。 objective 指定了模型的目标函数为回归问题中的平方误差。colsample_bylevel 指定类每层的列采样比例 用交叉验证来训练 XGBoost 模型。xgb.cv 函数会在指定的 num_boost_round 轮迭代中训练模型，并在 early_stopping_rounds 轮内没有提升时提前停止训练 xgb.XGBRegressor 是 XGBoost 库中的一个类，用于创建一个梯度提升回归模型。n_estimators=360 指定了模型的迭代次数，即构建的树的数量。在这个例子中，模型将构建 360 棵树。max_depth=2 指定了每棵树的最大深度。树的深度控制了模型的复杂度，较小的深度可以防止过拟合。在这个例子中，每棵树的最大深度为 2。learning_rate=0.1 指定了学习率，也称为收缩因子（shrinkage factor）。学习率控制了每棵树对最终预测结果的贡献程度。较小的学习率可以防止过拟合，但可能需要更多的树来达到较好的性能。在这个例子中，学习率为 0.1。 model_xgb = xgb.XGBRegressor(n_estimators=360, max_depth=2, learning_rate=0.1) 和 model_xgb.fit(X_train, y) 用于创建和训练模型，而 model = xgb.cv(params, dtrain, num_boost_round=500, early_stopping_rounds=100) 用于通过交叉验证评估模型性能并选择最佳的迭代次数。这三行代码共同构成了一个完整的模型训练和评估流程。
import xgboost as xgb
dtrain = xgb.DMatrix(X_train, label=y)
dtest = xgb.DMatrix(X_test)
params = {"objective":"reg:squarederror",
"max_depth": 4,
"colsample_bylevel": 0.5,
"learning_rate": 0.1,
"random_state": 20}
model = xgb.cv(params, dtrain, num_boost_round=500, early_stopping_rounds=100)
model_xgb = xgb.XGBRegressor(n_estimators=360, max_depth=2, learning_rate=0.1)
model_xgb.fit(X_train, y)
xgb_preds = np.expm1(model_xgb.predict(X_test))
solution = pd.DataFrame({"id":test.Id, "SalePrice":xgb_preds})
solution.to_csv("xgb_sol.csv", index=False)
（六）基于前三种回归模型建立 集成学习 模型
（1）Ridge 为主 Lasso 为辅
创建了一个堆叠回归模型 model_stacked，它使用 model_ridge 和 model_lasso 作为基础回归模型，并使用 model_ridge 作为元回归模型。 use_features_in_secondary=True 元回归模型将训练阶段得到的特征信息应用到预测阶段。这种堆叠方法可以提高模型的性能，因为它结合了多个模型的优势。
from mlxtend.regressor import StackingCVRegressor
model_stacked = StackingCVRegressor(regressors=(model_ridge, model_lasso),
meta_regressor=model_ridge,
use_features_in_secondary=True)
rmse = rmse_cv(model_stacked)
print("model_stacked: {:.4f} ({:.4f})".format(rmse.mean(), rmse.std()))
rmse = rmse_cv(model_ridge)
print("model_ridge: {:.4f} ({:.4f})".format(rmse.mean(), rmse.std()))
rmse = rmse_cv(model_lasso)
print("model_lasso: {:.4f} ({:.4f})".format(rmse.mean(), rmse.std()))
rmse = rmse_cv(model_xgb)
print("model_xgb: {:.4f} ({:.4f})".format(rmse.mean(), rmse.std()))
分数不是很理想，以 Lasso 为主试一下
（2）Lasso 为主 Ridge 为辅
model_stacked = StackingCVRegressor(regressors=(model_ridge, model_lasso),
meta_regressor=model_lasso,
use_features_in_secondary=True)
rmse = rmse_cv(model_stacked)
print("model_stacked: {:.4f} ({:.4f})".format(rmse.mean(), rmse.std()))
rmse = rmse_cv(model_ridge)
print("model_ridge: {:.4f} ({:.4f})".format(rmse.mean(), rmse.std()))
rmse = rmse_cv(model_lasso)
print("model_lasso: {:.4f} ({:.4f})".format(rmse.mean(), rmse.std()))
rmse = rmse_cv(model_xgb)
print("model_xgb: {:.4f} ({:.4f})".format(rmse.mean(), rmse.std()))
好了点，再加上 XGboost 试一下
（3）Lasso 为主 Ridge、XGboost 为辅
model_stacked = StackingCVRegressor(regressors=(model_ridge, model_lasso, model_xgb),
meta_regressor=model_lasso,
use_features_in_secondary=True)
rmse = rmse_cv(model_stacked)
print("model_stacked: {:.4f} ({:.4f})".format(rmse.mean(), rmse.std()))
rmse = rmse_cv(model_ridge)
print("model_ridge: {:.4f} ({:.4f})".format(rmse.mean(), rmse.std()))
rmse = rmse_cv(model_lasso)
print("model_lasso: {:.4f} ({:.4f})".format(rmse.mean(), rmse.std()))
rmse = rmse_cv(model_xgb)
print("model_xgb: {:.4f} ({:.4f})".format(rmse.mean(), rmse.std()))
得分看起来挺好的，其他组合都可以试一下，但从单个模型的效果上来看，只有下面这种组合有预测提升的可能
（4）XGboost 为主 Ridge、Lasso 为辅
model_stacked = StackingCVRegressor(regressors=(model_ridge, model_lasso, model_xgb),
meta_regressor=model_xgb,
use_features_in_secondary=True)
rmse = rmse_cv(model_stacked)
print("model_stacked: {:.4f} ({:.4f})".format(rmse.mean(), rmse.std()))
rmse = rmse_cv(model_ridge)
print("model_ridge: {:.4f} ({:.4f})".format(rmse.mean(), rmse.std()))
rmse = rmse_cv(model_lasso)
print("model_lasso: {:.4f} ({:.4f})".format(rmse.mean(), rmse.std()))
rmse = rmse_cv(model_xgb)
print("model_xgb: {:.4f} ({:.4f})".format(rmse.mean(), rmse.std()))
（4）单 XGboost + 手动调参
xgb_params = dict(
max_depth=3,
learning_rate=0.05,
n_estimators=1000,
min_child_weight=1,
colsample_bytree=0.3,
subsample=0.4,
reg_alpha=0.5,
reg_lambda=0.1,
num_parallel_tree=1
)
model_xgb = xgb.XGBRegressor(**xgb_params)
rmse = rmse_cv(model_xgb)
print("model_xgb: {:.4f} ({:.4f})".format(rmse.mean(), rmse.std()))
得分不错
（5）尝试混合模型（自行设置比列）
from skimage.metrics import mean_squared_error
model_stacked.fit(X_train, y)
ridge_preds_train = model_ridge.predict(X_train)
lasso_preds_train = model_lasso.predict(X_train)
xgb_preds_train = model_xgb.predict(X_train)
stacked_preds_train = model_stacked.predict(X_train)
train_blended_predictions = (0.80 * xgb_preds_train) + \
(0.2 * stacked_preds_train)
print(np.sqrt(mean_squared_error(y, train_blended_predictions)))
ridge_preds_test = model_ridge.predict(X_test)
lasso_preds_test = model_lasso.predict(X_test)
xgb_preds_test = model_xgb.predict(X_test)
stacked_preds_test = model_stacked.predict(X_test)
blended_predictions = (0.20 * ridge_preds_test) + \
(0.70 * xgb_preds_test) + \
(0.10 * stacked_preds_test)
blended_predictions = np.floor(np.expm1(blended_predictions))
solution = pd.DataFrame({"id":test.Id, "SalePrice":blended_predictions})
solution.to_csv("blended_predictions.csv", index=False)
完作者：wanchen_Gabby
