机器学习——房屋价格预测【回归问题】

机器学习——房屋价格预测【回归问题】"/>

机器学习——房屋价格预测【回归问题】

机器学习——房屋价格预测【回归问题】

1. 导工具包

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
import warnings
warnings.filterwarnings('ignore')  #过滤所有警告

2. 读取数据

# 读取数据集
train = pd.read_csv("train.csv")
test = pd.read_csv("test.csv")

3. EDA探索分析

#1.数据查看
train.shape  #查看训练集形状
test.shape  #查看验证集形状
train.info()  #查看训练集info：Column代表列明， Non-Null Count代表不为空的数目，Dtype代表数据类型（object代表字符串）
train.describe() # 数据描述（只针对非object的数据列）mean	代表均值，std代表方差，25%：排在第25%位置的数据
train.isnull().sum().sort_values(ascending=False)  # 统计每一列NaN的数量，将结果按照降序排序
train.isnull().sum().sort_values(ascending=False) / train.shape[0]  # 计算NaN的占比，将结果按照降序排序
test.isnull().sum().sort_values(ascending=False) / test.shape[0] # 每一列中，NaN所占比例#2.数据清洗
train.drop(columns=['PoolQC','MiscFeature','Alley','Fence'], axis=1, inplace=True)# 对于NaN占比较高的PoolQC，MiscFeature，Alley，Fence 列删除
test.drop(columns=['PoolQC','MiscFeature','Alley','Fence'], axis=1, inplace=True)
number_columns = [ col for col in train.columns if train[col].dtype != 'object']  # 统计train,test所有列中的：数值类型的列 和 分类类型的列
category_columns = [col for col in train.columns if train[col].dtype == 'object']#3.数据分析——绘制显示数值类型列的数据分布
fig, axes = plt.subplots(nrows=13, ncols=3, figsize=(20, 18)) 
axes = axes.flatten()
for i, col in zip(range(len(number_columns)), number_columns):sns.distplot(train[col], ax=axes[i])plt.tight_layout()
# 建造年份YearBuilt 与 售价SalePrice 的关系（散点图）
plt.figure(figsize=(16, 8)) # 画布大小
plt.title("YearBuilt vs SalePrice")  # 画布标题
#sns.scatterplot(x='YearBuilt', y='SalePrice', data=train) # 写法一
sns.scatterplot(train.YearBuilt, train.SalePrice) # 写法二
plt.show()
# 楼层面积1stFlrSF 与 售价SalePrice 的关系（散点图）
plt.figure(figsize=(16, 8))
sns.scatterplot(x='1stFlrSF', y='SalePrice', data=train)
plt.show()#4.数据分析——绘制显示分类类型列的数据分布
fig, axes = plt.subplots(13, 3, figsize=(25, 20))
axes = axes.flatten()
for i, col in enumerate(category_columns):sns.stripplot(x=col, y='SalePrice', data=train, ax=axes[i])
plt.tight_layout()
plt.show()

4. Feature Engineering 特征工程

#1.统计 train中有哪些列包含NaN
train_nan_num = [] # train中数值类型的列
train_nan_cat = [] # train中分类类型的列for col in number_columns:if train[col].isnull().sum() > 0:train_nan_num.append(col)for col in category_columns:if train[col].isnull().sum() > 0:train_nan_cat.append(col)#2.统计 test中有哪些列包含NaN
test_nan_num = [] # test中数值类型的列
test_nan_cat = [] # test中分类类型的列# 注意：需要将SalePrice清理，因为test中没有SalePrice（标签）
number_columns.remove('SalePrice')for col in number_columns:if test[col].isnull().sum() > 0:test_nan_num.append(col)for col in category_columns:if test[col].isnull().sum() > 0:test_nan_cat.append(col)

5. 针对 空缺值 的处理方式

方案一：简单粗暴：直接删除

train_one = train.dropna(axis=0)
test_one = test.dropna(axis=0)
print(train_one.shape)
print(test_one.shape)

方案二：折中法：对于数值类型列，取中位数；对于分类类型列，取None；

# train
for col in train_nan_num:# inplace=True代表在原来数据集上操作，不会返回新的DataFrame对象train[col].fillna(train[col].median(), inplace=True) # 中位数替代
for col in train_nan_cat:train[col].fillna('None', inplace=True)# test
for col in test_nan_num:test[col].fillna(test[col].median(), inplace=True) # 中位数for col in test_nan_cat:test[col].fillna('None', inplace=True)

6. 算法建模、训练、验证

数据集分类

#1.处理分类型数据
# 对 分类类型 列进行LabelEncoding
# 举例：A, B, C, D, E  --LabelEncoding--> 0, 1, 2, 3, 4
from sklearn.preprocessing import LabelEncoder
LE = LabelEncoder()
for col in category_columns:train[col] = LE.fit_transform(train[col])test[col] = LE.fit_transform(test[col])#2.构建训练集和验证集
X = train.drop(columns=['Id', 'SalePrice'], axis=1).values # 说明：Id不是特征，SalePrice是标签，需要屏蔽
y = train['SalePrice'].values # 标签 SalePrice#3.数据集分离
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, shuffle=True) # 验证集占比30%，打乱顺序

创建回归模型

方案一：线性回归+随机训练集与测试集

# 1 线性回归
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_absolute_error
'''
MSE: Mean Squared Error
均方误差是指参数估计值与参数真值之差平方的期望值;
MSE可以评价数据的变化程度，MSE的值越小，说明预测模型描述实验数据具有更好的精确度。'''LR = LinearRegression()  # 模型
LR.fit(X_train, y_train) # 训练
y_pred = LR.predict(X_test) # 预测print(f'Root Mean Squared Error : {np.sqrt(mean_absolute_error(np.log(y_test), np.log(y_pred)))}')

方案二：线性回归+K折交叉验证

# K折交叉验证
from sklearn.model_selection import KFoldkf = KFold(n_splits=10) # 10折rmse_scores = [] # 保存10折运行的结果for train_indices, test_indices in kf.split(X): # 分割元数据，生成索引列表X_train, X_test = X[train_indices], X[test_indices] # 训练集和验证集y_train, y_test = y[train_indices], y[test_indices] # 训练标签集和验证标签集# 初始化线性回归模型对象LR = LinearRegression(normalize=True)LR.fit(X_train, y_train) # 训练y_pred = LR.predict(X_test) # 预测rmse = np.sqrt(mean_absolute_error(np.log(y_test), np.log(abs(y_pred)))) # 评估rmse_scores.append(rmse) # 累计每一轮的验证结果print("rmse scores : ", rmse_scores)
print(f'average rmse score : {np.mean(rmse_scores)}')

方案三：随机森林+K折交叉验证

# 2 随机森林（回归）
from sklearn.ensemble import RandomForestRegressor# K折交叉验证
kf = KFold(n_splits=10)rmse_scores = [] for train_indices, test_indices in kf.split(X):X_train, X_test = X[train_indices], X[test_indices]y_train, y_test = y[train_indices], y[test_indices]# 初始化模型RFR = RandomForestRegressor() # 基模型# 训练/fit拟合RFR.fit(X_train, y_train)# 预测y_pred = RFR.predict(X_test)# 评估rmse = mean_absolute_error(y_test, y_pred)# 累计结果rmse_scores.append(rmse)print("rmse scores : ", rmse_scores)
print(f'average rmse scores : {np.mean(rmse_scores)}')

方案四：LightGBM+K折交叉验证

# 3 lightGBM（回归）
import lightgbm as lgb# K折交叉验证
kf = KFold(n_splits=10)rmse_scores = [] for train_indices, test_indices in kf.split(X):X_train, X_test = X[train_indices], X[test_indices]y_train, y_test = y[train_indices], y[test_indices]# 初始化模型LGBR = lgb.LGBMRegressor() # 基模型# 训练/fit拟合LGBR.fit(X_train, y_train)# 预测y_pred = LGBR.predict(X_test)# 评估rmse = mean_absolute_error(y_test, y_pred)# 累计结果rmse_scores.append(rmse)print("rmse scores : ", rmse_scores)
print(f'average rmse scores : {np.mean(rmse_scores)}')

方案四：xgboost+K折交叉验证

# xgboostimport xgboost as xgb# K折交叉验证
kf = KFold(n_splits=10)rmse_scores = [] for train_indices, test_indices in kf.split(X):X_train, X_test = X[train_indices], X[test_indices]y_train, y_test = y[train_indices], y[test_indices]# 初始化模型XGBR = xgb.XGBRegressor() # 基模型# 训练/fit拟合XGBR.fit(X_train, y_train)# 预测y_pred = XGBR.predict(X_test)# 评估rmse = mean_absolute_error(y_test, y_pred)# 累计结果rmse_scores.append(rmse)print("rmse scores : ", rmse_scores)
print(f'average rmse scores : {np.mean(rmse_scores)}')

7. 模型预测

# 1 选取 lightGBM 算法
LGBR.fit(X, y) # 在整个数据集上训练test_pred = LGBR.predict(test.drop('Id',axis=1).values)result_df = pd.DataFrame(columns=['SalePrice'])result_df['SalePrice'] = test_predresult_df.to_csv('LGBR_base_model.csv', index=None, header=True)
#绘制预测结果图：x为下标，y为SalePrice预测值
result_df['SalePrice'].plot(figsize=(16,8))

8. LightGBM算法调参

train_data = lgb.Dataset(X_train, label=y_train) # 训练集
test_data = lgb.Dataset(X_test, label=y_test, reference=train_data) # 验证集# 参数
params = {'objective':'regression', # 目标任务'metric':'rmse', # 评估指标'learning_rate':0.1, # 学习率'max_depth':15, # 树的深度'num_leaves':20, # 叶子数
}# 创建模型对象
model = lgb.train(params=params,train_set=train_data,num_boost_round=300,early_stopping_rounds=30,valid_names=['test'],valid_sets=[test_data])
# 模型评估
score = model.best_score['test']['rmse']# 模型预测
test_pred = model.predict(test.drop('Id',axis=1).values)
result_df2 = pd.DataFrame(columns=['SalePrice'])
result_df2['SalePrice'] = test_pred
result_df2.to_csv('LGBR_model2.csv', index=None, header=True)
result_df2['SalePrice'].plot(figsize=(16,8))

实例源代码链接