┌──────────┐   ┌──────────┐   ┌──────────┐   ┌──────────┐
│ 数据加载  │ → │ 数据探索  │ → │ 数据清洗  │ → │ 特征工程  │
└──────────┘   └──────────┘   └──────────┘   └──────────┘
                                                    ↓
┌──────────┐   ┌──────────┐   ┌──────────┐   ┌──────────┐
│ 最终预测  │ ← │ 模型调优  │ ← │ 模型评估  │ ← │ 模型训练  │
└──────────┘   └──────────┘   └──────────┘   └──────────┘

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import warnings
warnings.filterwarnings('ignore')

np.random.seed(42)
n = 1000

# 生成房屋数据
data = {
    '面积': np.random.lognormal(mean=4.5, sigma=0.4, size=n).astype(int).clip(30, 500),
    '卧室数': np.random.choice([1, 2, 3, 4, 5], size=n, p=[0.1, 0.25, 0.35, 0.2, 0.1]),
    '楼层': np.random.randint(1, 33, n),
    '总楼层': np.random.choice([6, 11, 18, 26, 33], size=n, p=[0.2, 0.25, 0.25, 0.2, 0.1]),
    '房龄': np.random.exponential(10, n).astype(int).clip(0, 30),
    '装修': np.random.choice(['毛坯', '简装', '精装', '豪装'], size=n, p=[0.15, 0.35, 0.35, 0.15]),
    '朝向': np.random.choice(['东', '南', '西', '北', '南北通透'], size=n, p=[0.1, 0.3, 0.1, 0.1, 0.4]),
    '有电梯': np.random.choice([0, 1], size=n, p=[0.3, 0.7]),
    '学区': np.random.choice([0, 1], size=n, p=[0.6, 0.4]),
    '地铁距离_km': np.random.exponential(1.5, n).round(2),
}

# 计算房价（带噪声的模拟公式）
price = (
    data['面积'] * 2.8
    + data['卧室数'] * 15
    - data['房龄'] * 3
    + data['有电梯'] * 30
    + data['学区'] * 50
    - data['地铁距离_km'] * 10
    + np.where(data['装修'] == '豪装', 40, np.where(data['装修'] == '精装', 20, 0))
    + np.where(data['朝向'] == '南北通透', 15, 0)
    + np.random.randn(n) * 20
)

data['房价_万'] = price.clip(50, 2000).round(1)
df = pd.DataFrame(data)

print(f"数据集: {df.shape[0]} 行 × {df.shape[1]} 列")
print(f"\n前5行:")
print(df.head())

# 基本统计
print("=" * 60)
print("数据概况")
print("=" * 60)
print(f"样本数: {len(df)}")
print(f"特征数: {df.shape[1] - 1}")
print(f"\n房价统计:")
print(df['房价_万'].describe().round(1))

# 数据类型
print(f"\n数据类型:")
for col in df.columns:
    dtype = df[col].dtype
    nunique = df[col].nunique()
    print(f"  {col:>12s}: {str(dtype):>8s}  唯一值: {nunique}")

fig, axes = plt.subplots(2, 3, figsize=(16, 10))

# 1. 房价分布
axes[0, 0].hist(df['房价_万'], bins=30, color='#07c160', alpha=0.7, edgecolor='white')
axes[0, 0].set_xlabel('房价 (万元)')
axes[0, 0].set_ylabel('频次')
axes[0, 0].set_title('房价分布')
axes[0, 0].axvline(df['房价_万'].mean(), color='red', linestyle='--', label=f"均值: {df['房价_万'].mean():.0f}万")
axes[0, 0].legend()

# 2. 面积 vs 房价
axes[0, 1].scatter(df['面积'], df['房价_万'], alpha=0.3, s=10, color='#1890ff')
axes[0, 1].set_xlabel('面积 (㎡)')
axes[0, 1].set_ylabel('房价 (万元)')
axes[0, 1].set_title('面积 vs 房价')

# 3. 卧室数 vs 房价
df.boxplot(column='房价_万', by='卧室数', ax=axes[0, 2])
axes[0, 2].set_xlabel('卧室数')
axes[0, 2].set_ylabel('房价 (万元)')
axes[0, 2].set_title('卧室数 vs 房价')

# 4. 装修 vs 房价
df.boxplot(column='房价_万', by='装修', ax=axes[1, 0])
axes[1, 0].set_xlabel('装修')
axes[1, 0].set_ylabel('房价 (万元)')
axes[1, 0].set_title('装修 vs 房价')

# 5. 学区 vs 房价
df.boxplot(column='房价_万', by='学区', ax=axes[1, 1])
axes[1, 1].set_xlabel('学区 (0=否, 1=是)')
axes[1, 1].set_ylabel('房价 (万元)')
axes[1, 1].set_title('学区 vs 房价')

# 6. 地铁距离 vs 房价
axes[1, 2].scatter(df['地铁距离_km'], df['房价_万'], alpha=0.3, s=10, color='#722ed1')
axes[1, 2].set_xlabel('地铁距离 (km)')
axes[1, 2].set_ylabel('房价 (万元)')
axes[1, 2].set_title('地铁距离 vs 房价')

plt.suptitle('房价数据探索', fontsize=16, fontweight='bold')
plt.tight_layout()
plt.savefig('eda_plots.png', dpi=150)
plt.show()

2.4 相关性分析

# 只看数值列的相关性
numeric_cols = df.select_dtypes(include=[np.number]).columns
corr = df[numeric_cols].corr()['房价_万'].sort_values(ascending=False)
print("与房价的相关性:")
for col, val in corr.items():
    if col != '房价_万':
        bar = "█" * int(abs(val) * 20)
        sign = "+" if val > 0 else "-"
        print(f"  {col:>15s}: {sign}{abs(val):.3f} {bar}")

# 相关性热力图（需要先安装：pip install seaborn）
import seaborn as sns
plt.figure(figsize=(10, 8))
sns.heatmap(df[numeric_cols].corr(), annot=True, fmt='.2f', cmap='RdYlGn', center=0)
plt.title('特征相关性热力图')
plt.tight_layout()
plt.savefig('correlation_heatmap.png', dpi=150)
plt.show()

3. 数据清洗

# 检查缺失值
print("缺失值统计:")
missing = df.isnull().sum()
print(missing[missing > 0] if missing.sum() > 0 else "  ✅ 无缺失值")

# 检查异常值
print("\n异常值检查:")
for col in ['面积', '房价_万', '地铁距离_km']:
    Q1 = df[col].quantile(0.25)
    Q3 = df[col].quantile(0.75)
    IQR = Q3 - Q1
    lower = Q1 - 1.5 * IQR
    upper = Q3 + 1.5 * IQR
    outliers = ((df[col] < lower) | (df[col] > upper)).sum()
    print(f"  {col}: {outliers} 个异常值 (范围: {lower:.1f} ~ {upper:.1f})")

# 删除异常值（可选）
df_clean = df[
    (df['面积'] >= 30) & (df['面积'] <= 500) &
    (df['房价_万'] >= 50) & (df['房价_万'] <= 2000)
].copy()
print(f"\n清洗后: {len(df_clean)} 行 (删除了 {len(df) - len(df_clean)} 行)")

4. 特征工程

特征工程是机器学习中最花时间但最重要的环节。好的特征 = 好的模型。

4.1 编码分类特征

from sklearn.preprocessing import LabelEncoder

# 装修：有序编码（毛坯 < 简装 < 精装 < 豪装）
装修顺序 = {'毛坯': 0, '简装': 1, '精装': 2, '豪装': 3}
df_clean['装修_编码'] = df_clean['装修'].map(装修顺序)

# 朝向：独热编码
朝向_dummies = pd.get_dummies(df_clean['朝向'], prefix='朝向')
df_clean = pd.concat([df_clean, 朝向_dummies], axis=1)

print("编码后新增列:")
print(df_clean.columns.tolist()[-6:])

4.2 特征衍生

# 创建新特征
df_clean['单价'] = df_clean['房价_万'] / df_clean['面积']  # 每平米价格
df_clean['楼层比'] = df_clean['楼层'] / df_clean['总楼层']  # 楼层位置
df_clean['是否高层'] = (df_clean['楼层'] > df_clean['总楼层'] * 0.7).astype(int)
df_clean['面积_卧室比'] = df_clean['面积'] / df_clean['卧室数']  # 每间卧室面积

print("衍生特征:")
print(df_clean[['面积', '卧室数', '楼层', '总楼层', '楼层比', '是否高层', '面积_卧室比']].head())

🚫 数据泄露警告：上面的 单价 = 房价 / 面积 用到了目标变量 房价_万，千万不能把它作为预测特征！否则模型等于"用答案猜答案"，训练时 R² 接近 1.0，上线后完全失效。后续 feature_cols 中已排除该特征。记住：衍生特征只能用非目标信息（如面积、楼层等）。

4.3 选择最终特征

# 选择用于建模的特征
feature_cols = [
    '面积', '卧室数', '楼层', '总楼层', '房龄', '有电梯', '学区', '地铁距离_km',
    '装修_编码', '楼层比', '是否高层', '面积_卧室比',
    '朝向_东', '朝向_南', '朝向_西', '朝向_北', '朝向_南北通透'
]

X = df_clean[feature_cols]
y = df_clean['房价_万']

print(f"特征矩阵: {X.shape}")
print(f"目标变量: {y.shape}")

5. 模型训练

from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression, Ridge, Lasso
from sklearn.tree import DecisionTreeRegressor
from sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor
from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score

# 拆分数据
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 标准化
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

print(f"训练集: {X_train_scaled.shape[0]} 样本")
print(f"测试集: {X_test_scaled.shape[0]} 样本")

# ========== 训练多个模型对比 ==========
models = {
    '线性回归': LinearRegression(),
    'Ridge回归': Ridge(alpha=1.0),
    'Lasso回归': Lasso(alpha=1.0),
    '决策树(depth=5)': DecisionTreeRegressor(max_depth=5, random_state=42),
    '决策树(depth=10)': DecisionTreeRegressor(max_depth=10, random_state=42),
    '随机森林(100)': RandomForestRegressor(n_estimators=100, random_state=42),
    '梯度提升(100)': GradientBoostingRegressor(n_estimators=100, random_state=42),
}

print("\n" + "=" * 70)
print(f"{'模型':>20s} | {'R²':>8s} | {'RMSE':>10s} | {'MAE':>10s}")
print("-" * 70)

results = {}
for name, model in models.items():
    model.fit(X_train_scaled, y_train)
    y_pred = model.predict(X_test_scaled)

    r2 = r2_score(y_test, y_pred)
    rmse = np.sqrt(mean_squared_error(y_test, y_pred))
    mae = mean_absolute_error(y_test, y_pred)

    results[name] = {'r2': r2, 'rmse': rmse, 'mae': mae, 'model': model}
    print(f"{name:>20s} | {r2:>7.4f} | {rmse:>9.2f} | {mae:>9.2f}")

print("=" * 70)

best_name = max(results, key=lambda k: results[k]['r2'])
print(f"\n🏆 最佳模型: {best_name} (R² = {results[best_name]['r2']:.4f})")

6. 模型评估

6.1 预测 vs 真实值散点图

# 用最佳模型预测
best_model = results[best_name]['model']
y_pred = best_model.predict(X_test_scaled)

fig, axes = plt.subplots(1, 2, figsize=(14, 5))

# 散点图
axes[0].scatter(y_test, y_pred, alpha=0.4, s=15, color='#07c160')
min_val = min(y_test.min(), y_pred.min())
max_val = max(y_test.max(), y_pred.max())
axes[0].plot([min_val, max_val], [min_val, max_val], 'r--', linewidth=2)
axes[0].set_xlabel('真实房价 (万元)')
axes[0].set_ylabel('预测房价 (万元)')
axes[0].set_title(f'{best_name} — 真实 vs 预测 (R²={results[best_name]["r2"]:.4f})')

# 残差图
residuals = y_test.values - y_pred
axes[1].scatter(y_pred, residuals, alpha=0.4, s=15, color='#1890ff')
axes[1].axhline(y=0, color='r', linestyle='--')
axes[1].set_xlabel('预测房价 (万元)')
axes[1].set_ylabel('残差 (万元)')
axes[1].set_title('残差分布')

plt.tight_layout()
plt.savefig('model_evaluation.png', dpi=150)
plt.show()

6.2 特征重要性

# 随机森林的特征重要性
if hasattr(best_model, 'feature_importances_'):
    importances = best_model.feature_importances_
    sorted_idx = np.argsort(importances)[::-1]

    plt.figure(figsize=(10, 6))
    plt.barh(range(len(feature_cols)), importances[sorted_idx], color='#07c160')
    plt.yticks(range(len(feature_cols)), [feature_cols[i] for i in sorted_idx])
    plt.xlabel('重要性')
    plt.title(f'{best_name} — 特征重要性')
    plt.gca().invert_yaxis()
    plt.tight_layout()
    plt.savefig('feature_importance.png', dpi=150)
    plt.show()

    print("特征重要性排名:")
    for i, idx in enumerate(sorted_idx):
        print(f"  {i+1}. {feature_cols[idx]}: {importances[idx]:.4f}")

7. 模型调优

7.1 网格搜索

from sklearn.model_selection import GridSearchCV

# 对随机森林进行网格搜索
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15, None],
    'min_samples_split': [2, 5, 10],
}

rf = RandomForestRegressor(random_state=42)
grid_search = GridSearchCV(rf, param_grid, cv=5, scoring='r2', n_jobs=-1, verbose=1)
grid_search.fit(X_train_scaled, y_train)

print(f"\n最佳参数: {grid_search.best_params_}")
print(f"最佳 R² (交叉验证): {grid_search.best_score_:.4f}")

# 用最佳参数评估测试集
best_rf = grid_search.best_estimator_
y_pred_tuned = best_rf.predict(X_test_scaled)
r2_tuned = r2_score(y_test, y_pred_tuned)
rmse_tuned = np.sqrt(mean_squared_error(y_test, y_pred_tuned))
print(f"测试集 R²: {r2_tuned:.4f}")
print(f"测试集 RMSE: {rmse_tuned:.2f} 万元")

7.2 学习曲线

from sklearn.model_selection import learning_curve

train_sizes, train_scores, val_scores = learning_curve(
    best_rf, X_train_scaled, y_train,
    train_sizes=np.linspace(0.1, 1.0, 10),
    cv=5, scoring='r2', n_jobs=-1
)

plt.figure(figsize=(10, 6))
plt.plot(train_sizes, train_scores.mean(axis=1), 'o-', color='#07c160', label='训练集')
plt.plot(train_sizes, val_scores.mean(axis=1), 'o-', color='#1890ff', label='验证集')
plt.fill_between(train_sizes,
                 train_scores.mean(axis=1) - train_scores.std(axis=1),
                 train_scores.mean(axis=1) + train_scores.std(axis=1), alpha=0.1, color='#07c160')
plt.fill_between(train_sizes,
                 val_scores.mean(axis=1) - val_scores.std(axis=1),
                 val_scores.mean(axis=1) + val_scores.std(axis=1), alpha=0.1, color='#1890ff')
plt.xlabel('训练样本数')
plt.ylabel('R² 分数')
plt.title('学习曲线')
plt.legend()
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.savefig('learning_curve.png', dpi=150)
plt.show()

8. 最终预测

# 用调优后的模型做实际预测
new_houses = pd.DataFrame({
    '面积': [89, 120, 150, 200, 65],
    '卧室数': [2, 3, 3, 4, 1],
    '楼层': [15, 8, 22, 5, 30],
    '总楼层': [33, 18, 33, 6, 33],
    '房龄': [3, 10, 5, 20, 1],
    '有电梯': [1, 1, 1, 0, 1],
    '学区': [1, 0, 1, 0, 0],
    '地铁距离_km': [0.3, 1.2, 0.5, 2.0, 0.1],
    '装修_编码': [2, 1, 3, 1, 2],  # 精装/简装/豪装/简装/精装
    '楼层比': [15/33, 8/18, 22/33, 5/6, 30/33],
    '是否高层': [0, 0, 1, 0, 1],
    '面积_卧室比': [89/2, 120/3, 150/3, 200/4, 65/1],
    '朝向_东': [0, 0, 0, 0, 0],
    '朝向_南': [0, 0, 0, 0, 1],
    '朝向_西': [0, 0, 0, 0, 0],
    '朝向_北': [0, 0, 0, 0, 0],
    '朝向_南北通透': [1, 1, 1, 1, 0],
})

new_scaled = scaler.transform(new_houses)
predictions = best_rf.predict(new_scaled)

print("=" * 65)
print("🏠 房价预测结果")
print("=" * 65)
descs = ['89㎡ 2室 精装 学区房', '120㎡ 3室 简装', '150㎡ 3室 豪装 学区房',
         '200㎡ 4室 简装 老房', '65㎡ 1室 精装 地铁口']
for i, (desc, pred) in enumerate(zip(descs, predictions)):
    print(f"  房子{i+1}: {desc}")
    print(f"         → 预测房价: {pred:.1f} 万元")
print("=" * 65)

9. 今日小结

🎯 一句话总结：机器学习项目的 80% 时间花在数据处理和特征工程上，真正训练模型只占 20%。好数据比好算法更重要！

🔮 明天预告：Day89 我们将跳出数据科学，学习设计模式——写出更优雅、更可维护的 Python 代码。单例模式、工厂模式、观察者模式...这些"编程套路"将让你的代码质量上一个台阶！