02-0.1到0.2——用“房价预测”入门机器学习全流程

import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

# 加载训练集和测试集
train = pd.read_csv('data/raw/train.csv')
test = pd.read_csv('data/raw/test.csv')

# 数据初探：查看前5行数据，了解特征格式和内容
print("训练集前5行数据：")
print(train.head())
print("\n" + "="*50 + "\n")  # 分隔线，增强输出可读性

# 基本统计分析：查看数值型特征的分布特征（均值、标准差、分位数等）
print("训练集数值特征统计信息：")
print(train.describe())
print("\n" + "="*50 + "\n")

# 数据集整体信息：数据类型、非空值数量，判断特征类型和缺失情况
print("训练集基本信息：")
print(train.info())
print("\n" + "="*50 + "\n")

# 缺失值统计：仅显示存在缺失值的特征及其缺失数量
missing_values = train.isnull().sum()
print("存在缺失值的特征及缺失数量：")
print(missing_values[missing_values > 0].sort_values(ascending=False))  # 按缺失值数量降序排列
print("\n" + "="*50 + "\n")

# 设置中文字体，确保可视化中中文正常显示
plt.rcParams["font.family"] = ["SimHei", "WenQuanYi Micro Hei", "Heiti TC"]
plt.rcParams["axes.unicode_minus"] = False  # 解决负号显示问题

# 1. 可视化目标变量（房价）的分布
plt.figure(figsize=(10, 6))
sns.histplot(
    data=train, 
    x='SalePrice', 
    kde=True,  # 叠加核密度曲线，更直观展示分布形态
    color='blue', 
    edgecolor='white'  # 直方图边框为白色，增强区间区分度
)
plt.title('房价分布直方图', fontsize=14)
plt.xlabel('房价', fontsize=12)
plt.ylabel('频数', fontsize=12)
plt.grid(alpha=0.3)  # 轻微网格线，便于读取大致数值
plt.show()

# 2. 可视化房价与关键特征（居住面积）的关系
plt.figure(figsize=(10, 6))
sns.scatterplot(
    data=train,
    x='GrLivArea',  # 地面以上居住面积
    y='SalePrice',
    color='green',
    alpha=0.6  # 点透明度，避免数据重叠时看不清密度
)
plt.title('房价与居住面积的散点图', fontsize=14)
plt.xlabel('居住面积（平方英尺）', fontsize=12)
plt.ylabel('房价', fontsize=12)
plt.grid(alpha=0.3)
plt.show()

from sklearn.model_selection import train_test_split

# 分离特征和目标变量（标签）
X = train.drop(['SalePrice', 'Id'], axis=1) # 特征矩阵
y = train['SalePrice'] # 目标变量

# 划分训练集和验证集
X_train, X_val, y_train, y_val = train_test_split(    
  X, y, test_size=0.2, random_state=42
)

print(f'训练集大小: {X_train.shape}')
print(f'验证集大小: {X_val.shape}')

# 复制训练集和验证集，避免修改原始数据
X_train_fe = X_train.copy()
X_val_fe = X_val.copy()

# 处理缺失值
for dataset in [X_train_fe, X_val_fe]:
    for column in dataset.columns:
        if dataset[column].dtype == 'object':
            # 类别型变量用众数填充
            dataset[column].fillna(dataset[column].mode()[0], inplace=True)
        else:
            # 数值型变量用中位数填充
            dataset[column].fillna(dataset[column].median(), inplace=True)

# 验证缺失值处理结果（确保无缺失值）
print(X_train_fe.isnull().sum().max())  # 输出：0
print(X_val_fe.isnull().sum().max())    # 输出：0

# 对类别型变量进行One-Hot编码
X_train_fe = pd.get_dummies(X_train_fe)
X_val_fe = pd.get_dummies(X_val_fe)

# 对齐训练集和验证集的特征（保证特征数量一致）
X_train_fe, X_val_fe = X_train_fe.align(
    X_val_fe, 
    join='left',  # 以训练集特征为基准
    axis=1, 
    fill_value=0  # 缺失特征用0填充
)

# 特征缩放（标准化）
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train_fe)  # 用训练集拟合并转换
X_val_scaled = scaler.transform(X_val_fe)          # 用训练集的缩放参数转换验证集

# 输出缩放后的数据集形状
print(f'特征缩放后，训练集大小: {X_train_scaled.shape}')
print(f'特征缩放后，验证集大小: {X_val_scaled.shape}')

from sklearn.linear_model import LinearRegression, Ridge
from sklearn.ensemble import RandomForestRegressor

# 初始化线性回归模型（无正则化）
lr = LinearRegression()
# 初始化岭回归模型（L2正则化，缓解过拟合）
ridge = Ridge(
    alpha=1.0,  # 正则化强度，值越大正则化越强
    random_state=42  # 可选：添加随机种子确保结果可复现
)
# 初始化随机森林回归模型（集成树模型）
rf = RandomForestRegressor(
    n_estimators=100,  # 树的数量，越多通常性能越好但计算成本越高
    random_state=42,   # 随机种子，保证结果可复现
    n_jobs=-1          # 可选：使用所有CPU核心加速训练
)

from sklearn.metrics import mean_squared_error
from sklearn.model_selection import GridSearchCV

# 训练线性回归模型
lr.fit(X_train_scaled, y_train)
lr_preds = lr.predict(X_val_scaled)
lr_mse = mean_squared_error(y_val, lr_preds)
print(f'线性回归验证集MSE: {lr_mse}')

# 训练岭回归模型
ridge.fit(X_train_scaled, y_train)
ridge_preds = ridge.predict(X_val_scaled)
ridge_mse = mean_squared_error(y_val, ridge_preds)
print(f'岭回归验证集MSE: {ridge_mse}')

# 训练随机森林模型（注意：随机森林无需特征缩放，直接使用原始编码特征）
rf.fit(X_train_fe, y_train)
rf_preds = rf.predict(X_val_fe)
rf_mse = mean_squared_error(y_val, rf_preds)
print(f'随机森林验证集MSE: {rf_mse}')

# 超参数调优：使用网格搜索优化随机森林
param_grid = {
    'n_estimators': [100, 200],  # 树的数量
    'max_depth': [None, 10, 20],  # 树的最大深度（None表示不限制）
    'min_samples_split': [2, 5]   # 节点分裂的最小样本数
}

# 网格搜索配置
grid_search = GridSearchCV(
    estimator=RandomForestRegressor(random_state=42),  # 基础模型
    param_grid=param_grid,  # 待搜索的参数网格
    cv=5,  # 5折交叉验证
    scoring='neg_mean_squared_error',  # 评估指标（负MSE，值越大越好）
    n_jobs=-1  # 并行计算（使用所有CPU核心）
)

# 执行网格搜索
grid_search.fit(X_train_fe, y_train)

# 输出调优结果
print(f'最佳参数: {grid_search.best_params_}')
print(f'最佳交叉验证MSE: {-grid_search.best_score_}')  # 转换为正MSE值

# 使用最佳参数的模型重新训练并评估
best_rf = grid_search.best_estimator_  # 获取最优模型
best_rf.fit(X_train_fe, y_train)
best_rf_preds = best_rf.predict(X_val_fe)
best_rf_mse = mean_squared_error(y_val, best_rf_preds)
print(f'优化后的随机森林验证集MSE: {best_rf_mse}')

import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from math import sqrt  # 或使用numpy.sqrt

# 计算最终RMSE（均方根误差）
final_rmse = sqrt(best_rf_mse)  # 或 np.sqrt(best_rf_mse)
print(f'最终随机森林验证集RMSE: {final_rmse}')

# 误差分析：计算预测误差（实际值 - 预测值）
errors = y_val - best_rf_preds

# 设置中文字体，确保中文正常显示
plt.rcParams["font.family"] = ["SimHei", "WenQuanYi Micro Hei", "Heiti TC"]
plt.rcParams["axes.unicode_minus"] = False  # 解决负号显示问题

# 绘制预测误差分布直方图
plt.figure(figsize=(10, 6))
sns.histplot(errors, bins=30, kde=True, color='red', edgecolor='white')
plt.title('预测误差分布')
plt.xlabel('误差（实际值 - 预测值）')
plt.ylabel('频数')
plt.grid(alpha=0.3)  # 增加网格线，提升可读性
plt.show()

# 绘制实际值与预测值对比散点图
plt.figure(figsize=(10, 6))
sns.scatterplot(x=y_val, y=best_rf_preds, alpha=0.6)  # 增加透明度，避免点重叠
# 绘制参考线：y=x（完美预测线）
plt.plot(
    [y_val.min(), y_val.max()], 
    [y_val.min(), y_val.max()], 
    color='black', 
    linestyle='--', 
    linewidth=2
)
plt.title('实际房价 vs 预测房价')
plt.xlabel('实际房价（美元）')
plt.ylabel('预测房价（美元）')
plt.grid(alpha=0.3)
plt.show()

# 生成新特征：总房间面积（地下室+一层+二层面积之和）
X_train_fe['TotalRooms'] = X_train_fe['TotalBsmtSF'] + X_train_fe['1stFlrSF'] + X_train_fe['2ndFlrSF']
X_val_fe['TotalRooms'] = X_val_fe['TotalBsmtSF'] + X_val_fe['1stFlrSF'] + X_val_fe['2ndFlrSF']

# 特征选择：基于与目标变量的相关性筛选特征
# 计算数值型特征与目标变量的相关系数矩阵
corr_matrix = train.corr(numeric_only=True)

# 筛选与SalePrice相关性绝对值大于0.12的特征（阈值通过实验确定）
high_corr_features = corr_matrix['SalePrice'][
    corr_matrix['SalePrice'].abs() > 0.12
].index
high_corr_features = high_corr_features.drop(['SalePrice'])  # 排除目标变量本身

# 根据筛选结果重建训练集和验证集特征
X_train_selected = X_train_fe[high_corr_features]
X_val_selected = X_val_fe[high_corr_features]

# 对筛选后的特征重新进行标准化处理
X_train_selected_scaled = scaler.fit_transform(X_train_selected)
X_val_selected_scaled = scaler.transform(X_val_selected)

# 使用筛选后的特征重新训练优化后的随机森林模型
best_rf.fit(X_train_selected, y_train)
new_rf_preds = best_rf.predict(X_val_selected)
new_rf_mse = mean_squared_error(y_val, new_rf_preds)
print(f'优化后随机森林验证集MSE: {new_rf_mse}')

import joblib
# 保存最佳模型和 
Scalerjoblib.dump(best_rf, 'best_rf_model.joblib')
joblib.dump(scaler, 'scaler.joblib')

from flask import Flask, request, jsonify
import joblib
import numpy as np
import pandas as pd

app = Flask(__name__)

# 加载模型和预处理组件
model = joblib.load('best_rf_model.joblib')
scaler = joblib.load('scaler.joblib')
# 假设保存了特征列表，确保输入特征一致性
with open('feature_columns.pkl', 'rb') as f:
    feature_columns = joblib.load(f)

def preprocess_features(features):
    """对输入特征进行预处理，与训练流程保持一致"""
    # 1. 生成新特征：总房间面积
    if all(col in features.columns for col in ['TotalBsmtSF', '1stFlrSF', '2ndFlrSF']):
        features['TotalRooms'] = features['TotalBsmtSF'] + features['1stFlrSF'] + features['2ndFlrSF']
    
    # 2. 处理缺失值
    for column in features.columns:
        if features[column].dtype == 'object':
            # 类别型变量用众数填充（实际应用中建议使用训练集众数）
            features[column].fillna(features[column].mode()[0] if not features[column].mode().empty else '', inplace=True)
        else:
            # 数值型变量用中位数填充（实际应用中建议使用训练集中位数）
            features[column].fillna(features[column].median(), inplace=True)
    
    # 3. 确保特征与训练集一致
    missing_cols = set(feature_columns) - set(features.columns)
    for col in missing_cols:
        features[col] = 0  # 缺失特征补0
    features = features[feature_columns]  # 按训练集特征顺序排序
    
    # 4. 特征缩放（如果模型需要）
    if scaler is not None:
        features = scaler.transform(features)
    
    return features

@app.route('/predict', methods=['POST'])
def predict():
    try:
        # 获取输入数据
        data = request.get_json()
        if not data or 'features' not in data:
            return jsonify({'error': '请求数据格式错误，需包含"features"字段'}), 400
        
        # 转换为DataFrame
        features = pd.DataFrame(data['features'])
        
        # 预处理
        processed_features = preprocess_features(features)
        
        # 模型预测
        prediction = model.predict(processed_features)
        
        # 返回结果
        return jsonify({
            'prediction': prediction.tolist(),
            'sample_count': len(prediction)
        })
    
    except Exception as e:
        return jsonify({'error': str(e)}), 500

if __name__ == '__main__':
    # 生产环境建议关闭debug，使用合适的端口
    app.run(host='0.0.0.0', port=5000, debug=False)

# 生成新特征：判断是否为小地块（地块面积小于5000）
X_train_fe['Is_Small_Lot'] = X_train_fe['LotArea'] < 5000
X_val_fe['Is_Small_Lot'] = X_val_fe['LotArea'] < 5000

# 调整特征选择阈值：提高相关性筛选标准（绝对值>0.5）
high_corr_features = corr_matrix['SalePrice'][
    corr_matrix['SalePrice'].abs() > 0.5
].index
high_corr_features = high_corr_features.drop(['SalePrice'])  # 排除目标变量

# 根据新筛选的特征重建训练集和验证集
X_train_selected = X_train_fe[high_corr_features]
X_val_selected = X_val_fe[high_corr_features]

# 对新特征集重新进行标准化处理
X_train_selected_scaled = scaler.fit_transform(X_train_selected)
X_val_selected_scaled = scaler.transform(X_val_selected)

# 使用调整后的特征集重新训练最优随机森林模型
best_rf.fit(X_train_selected, y_train)
new_rf_preds = best_rf.predict(X_val_selected)
new_rf_mse = mean_squared_error(y_val, new_rf_preds)
print(f'优化后随机森林验证集MSE: {new_rf_mse}')