Python使用Scikit-learn构建简单预测模型的完整教学

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

# 设置中文字体
plt.rcParams["font.sans-serif"] = ["SimHei", "Microsoft YaHei"]
plt.rcParams["axes.unicode_minus"] = False

# 生成一个回归任务的示例数据
# 场景：根据房屋的面积和房龄预测房价
np.random.seed(42)
n_samples = 200

area = np.random.uniform(50, 200, n_samples)       # 面积: 50-200 平方米
age = np.random.uniform(0, 30, n_samples)          # 房龄: 0-30 年

# 房价公式（加入随机噪声模拟真实情况）
# 面积越大越贵，房龄越老越便宜
price = (
    1.5 * area           # 每平米1.5万
    - 2 * age            # 每年折旧2万
    + 50                 # 基础价格
    + np.random.normal(0, 15, n_samples)  # 随机噪声
)

df = pd.DataFrame({
    "面积_平米": area,
    "房龄_年": age,
    "房价_万元": price
})

print("=== 示例数据：房价预测 ===")
print(df.head(10))
print(f"\n数据规模: {len(df)} 条")
print(df.describe().round(1))

from sklearn.model_selection import train_test_split

# 准备特征（X）和标签（y）
X = df[["面积_平米", "房龄_年"]]  # 特征：面积和房龄
y = df["房价_万元"]               # 标签：房价

# 划分数据集（80%训练，20%测试）
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

print("=== 数据集划分 ===")
print(f"训练集: {len(X_train)} 条 ({len(X_train)/len(df)*100:.0f}%)")
print(f"测试集: {len(X_test)} 条 ({len(X_test)/len(df)*100:.0f}%)")

print("\n训练集特征前5行:")
print(X_train.head())
print("\n训练集标签前5行:")
print(y_train.head())

from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score

# 创建模型
model = LinearRegression()

# 训练模型（这一步就是让模型从数据中学习）
model.fit(X_train, y_train)

# 查看学到的参数
print("=== 线性回归模型参数 ===")
print(f"系数 (w): 面积={model.coef_[0]:.2f}, 房龄={model.coef_[1]:.2f}")
print(f"截距 (b): {model.intercept_:.2f}")
print(f"\n解读:")
print(f"  - 面积每增加1平米，房价平均增加 {model.coef_[0]:.2f} 万元")
print(f"  - 房龄每增加1年，房价平均减少 {abs(model.coef_[1]):.2f} 万元")

# 用模型做预测
y_pred = model.predict(X_test)

# 对比预测值和真实值
comparison = pd.DataFrame({
    "真实房价": y_test.values,
    "预测房价": y_pred,
    "误差": y_test.values - y_pred
})
comparison["误差绝对值"] = comparison["误差"].abs()

print("\n=== 测试集预测结果对比（前10条） ===")
print(comparison.head(10).round(1))
print(f"\n平均绝对误差: {comparison['误差绝对值'].mean():.1f} 万元")

# 计算评估指标
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
mae = mean_absolute_error(y_test, y_pred)
r2 = r2_score(y_test, y_pred)

print("=" * 50)
print("线性回归模型评估结果")
print("=" * 50)
print(f"MSE（均方误差）:  {mse:.2f}")
print(f"RMSE（均方根误差）: {rmse:.2f} 万元")
print(f"MAE（平均绝对误差）: {mae:.2f} 万元")
print(f"R²（决定系数）:    {r2:.4f}")
print("=" * 50)

# 指标解释
print("\n指标解读:")
print(f"- RMSE={rmse:.1f}万: 预测房价平均偏离真实值约 {rmse:.1f} 万元")
print(f"- R²={r2:.2%}: 模型解释了 {r2:.0%} 的房价变化原因")
print("  （R²=1.0表示完美预测，R²=0表示预测不如猜平均值）")

# 可视化：预测值 vs 真实值
fig, axes = plt.subplots(1, 2, figsize=(14, 5))

# 左图：散点图
axes[0].scatter(y_test, y_pred, alpha=0.6, color="#3498db")
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--", label="完美预测线")
axes[0].set_xlabel("真实房价（万元）")
axes[0].set_ylabel("预测房价（万元）")
axes[0].set_title("预测值 vs 真实值", fontsize=13, fontweight="bold")
axes[0].legend()
axes[0].grid(True, alpha=0.3)

# 右图：残差图
residuals = y_test.values - y_pred
axes[1].scatter(y_pred, residuals, alpha=0.6, color="#e74c3c")
axes[1].axhline(y=0, color="gray", linestyle="--")
axes[1].set_xlabel("预测房价（万元）")
axes[1].set_ylabel("残差（真实-预测）")
axes[1].set_title("残差图", fontsize=13, fontweight="bold")
axes[1].grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

from sklearn.tree import DecisionTreeRegressor, plot_tree

# 训练决策树回归模型
dt_model = DecisionTreeRegressor(
    max_depth=4,          # 最大深度（防止过拟合）
    random_state=42
)
dt_model.fit(X_train, y_train)

# 预测
dt_pred = dt_model.predict(X_test)

# 评估
dt_mae = mean_absolute_error(y_test, dt_pred)
dt_r2 = r2_score(y_test, dt_pred)

print("=== 决策树回归模型评估 ===")
print(f"MAE: {dt_mae:.2f} 万元")
print(f"R²:  {dt_r2:.4f}")

# 与线性回归对比
print("\n=== 模型对比 ===")
print(f"{'模型':<15} {'MAE':>10} {'R²':>10}")
print("-" * 35)
print(f"{'线性回归':<15} {mae:>10.2f} {r2:>10.4f}")
print(f"{'决策树':<15} {dt_mae:>10.2f} {dt_r2:>10.4f}")

# 可视化决策树结构
fig, ax = plt.subplots(figsize=(12, 6))
plot_tree(
    dt_model,
    feature_names=["面积_平米", "房龄_年"],
    filled=True,
    rounded=True,
    fontsize=10,
    ax=ax
)
ax.set_title("决策树结构", fontsize=14, fontweight="bold")
plt.tight_layout()
plt.show()

# 使用Iris数据集演示分类任务
from sklearn.datasets import load_iris
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score, classification_report, confusion_matrix

# 加载数据
iris = load_iris()
X_iris = iris.data
y_iris = iris.target

print("=== Iris鸢尾花数据集 ===")
print(f"特征: {iris.feature_names}")
print(f"类别: {iris.target_names}")
print(f"样本数: {len(X_iris)}")

# 划分数据
X_train_ir, X_test_ir, y_train_ir, y_test_ir = train_test_split(
    X_iris, y_iris, test_size=0.3, random_state=42
)

# 训练决策树分类器
clf = DecisionTreeClassifier(max_depth=3, random_state=42)
clf.fit(X_train_ir, y_train_ir)

# 预测
y_pred_ir = clf.predict(X_test_ir)

# 评估
accuracy = accuracy_score(y_test_ir, y_pred_ir)
print(f"\n=== 分类模型评估 ===")
print(f"准确率: {accuracy:.2%}")
print(f"\n分类报告:")
print(classification_report(y_test_ir, y_pred_ir, target_names=iris.target_names))

# 混淆矩阵
cm = confusion_matrix(y_test_ir, y_pred_ir)
fig, ax = plt.subplots(figsize=(6, 5))
im = ax.imshow(cm, cmap="Blues")
ax.set_xticks(range(3))
ax.set_yticks(range(3))
ax.set_xticklabels(iris.target_names)
ax.set_yticklabels(iris.target_names)
ax.set_ylabel("真实标签")
ax.set_xlabel("预测标签")
ax.set_title("混淆矩阵", fontsize=13, fontweight="bold")

# 在每个格子中标注数字
for i in range(3):
    for j in range(3):
        ax.text(j, i, cm[i, j], ha="center", va="center", fontsize=14,
                color="white" if cm[i, j] > cm.max()/2 else "black")

plt.tight_layout()
plt.show()

# ========== 完整项目：电商用户购买预测 ==========

print("=" * 60)
print("项目：电商用户购买意愿预测模型")
print("=" * 60)

# Step 1: 创建模拟数据集
np.random.seed(42)
n_users = 1000

users = pd.DataFrame({
    "浏览时长_分钟": np.random.exponential(10, n_users),
    "浏览次数": np.random.poisson(8, n_users),
    "加入购物车": np.random.poisson(2, n_users),
    "收藏数": np.random.poisson(1, n_users),
    "历史购买次数": np.random.poisson(3, n_users),
    "距上次访问_天": np.random.exponential(7, n_users),
})

# 创建标签：是否购买（基于特征加上随机性）
buy_prob = (
    0.02 * users["浏览时长_分钟"] +
    0.05 * users["浏览次数"] +
    0.15 * users["加入购物车"] +
    0.1 * users["收藏数"] +
    0.08 * users["历史购买次数"] -
    0.03 * users["距上次访问_天"]
)
users["购买"] = (buy_prob + np.random.normal(0, 1, n_users) > 2).astype(int)

print(f"\n数据集: {len(users)} 个用户")
print(f"购买率: {users['购买'].mean():.1%}")
print(f"\n特征说明:")
for col in users.columns[:-1]:
    print(f"  - {col}: 均值={users[col].mean():.1f}")

# Step 2: 数据预处理
from sklearn.preprocessing import StandardScaler

X = users.drop("购买", axis=1)
y = users["购买"]

X_train_u, X_test_u, y_train_u, y_test_u = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

# 标准化（对某些模型有帮助）
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train_u)
X_test_scaled = scaler.transform(X_test_u)

# Step 3: 训练多个模型并比较
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier
from sklearn.neighbors import KNeighborsClassifier

models = {
    "逻辑回归": LogisticRegression(random_state=42, max_iter=1000),
    "决策树": DecisionTreeClassifier(max_depth=5, random_state=42),
    "随机森林": RandomForestClassifier(n_estimators=50, random_state=42),
    "K近邻": KNeighborsClassifier(n_neighbors=5)
}

results = {}
print("\n=== 模型训练与评估 ===")
for name, model in models.items():
    model.fit(X_train_scaled, y_train_u)
    pred = model.predict(X_test_scaled)
    acc = accuracy_score(y_test_u, pred)
    results[name] = {"accuracy": acc, "model": model}
    print(f"{name:>10}: 准确率 = {acc:.2%}")

# Step 4: 选择最佳模型并详细分析
best_name = max(results, key=lambda x: results[x]["accuracy"])
best_model = results[best_name]["model"]
best_pred = best_model.predict(X_test_scaled)

print(f"\n最佳模型: {best_name}")
print(f"\n详细评估:")
print(classification_report(y_test_u, best_pred, target_names=["未购买", "已购买"]))

# 混淆矩阵
cm = confusion_matrix(y_test_u, best_pred)
fig, ax = plt.subplots(figsize=(5, 4))
im = ax.imshow(cm, cmap="Greens")
ax.set_xticks([0, 1])
ax.set_yticks([0, 1])
ax.set_xticklabels(["未购买", "已购买"])
ax.set_yticklabels(["未购买", "已购买"])
ax.set_ylabel("真实")
ax.set_xlabel("预测")
ax.set_title(f"{best_name} - 混淆矩阵", fontweight="bold")
for i in range(2):
    for j in range(2):
        ax.text(j, i, cm[i, j], ha="center", va="center", fontsize=16,
                color="white" if cm[i, j] > cm.max()/2 else "black")
plt.tight_layout()
plt.show()

# Step 5: 特征重要性分析（使用随机森林）
rf_model = results["随机森林"]["model"]
importances = pd.DataFrame({
    "特征": X.columns,
    "重要性": rf_model.feature_importances_
}).sort_values("重要性", ascending=False)

fig, ax = plt.subplots(figsize=(8, 5))
bars = ax.barh(
    importances["特征"][::-1],
    importances["重要性"][::-1],
    color="#3498db"
)
for bar, val in zip(bars, importances["重要性"][::-1]):
    ax.text(val + 0.005, bar.get_y() + bar.get_height()/2,
            f"{val:.3f}", va="center", fontsize=10)
ax.set_xlabel("特征重要性")
ax.set_title("影响购买决策的关键因素", fontsize=13, fontweight="bold")
plt.tight_layout()
plt.show()

print("\n=== 特征重要性排名 ===")
for i, (_, row) in enumerate(importances.iterrows(), 1):
    print(f"  {i}. {row['特征']}: {row['重要性']:.3f}")

# Step 6: 使用模型做新用户的预测
print("\n=== 新用户预测示例 ===")
new_users = pd.DataFrame({
    "浏览时长_分钟": [15, 5, 30],
    "浏览次数": [10, 3, 20],
    "加入购物车": [3, 0, 5],
    "收藏数": [2, 0, 3],
    "历史购买次数": [5, 1, 10],
    "距上次访问_天": [2, 15, 1]
})

new_scaled = scaler.transform(new_users)
new_pred = best_model.predict(new_scaled)
new_prob = best_model.predict_proba(new_scaled)[:, 1]

for i in range(len(new_users)):
    label = "会购买" if new_pred[i] == 1 else "不会购买"
    print(f"  用户{i+1}: 预测结果={label}, 购买概率={new_prob[i]:.1%}")

print("\n" + "=" * 60)
print("项目完成！")
print("=" * 60)

from sklearn.model_selection import cross_val_score

# 交叉验证：把训练集分成多份，轮流用其中一份做验证
# 这能更可靠地评估模型性能
print("=== 交叉验证结果 ===")
for name, model in models.items():
    scores = cross_val_score(model, X_train_scaled, y_train_u, cv=5, scoring="accuracy")
    print(f"{name:>10}: {scores.mean():.2%} (+/- {scores.std():.2%})")

from sklearn.model_selection import GridSearchCV

# 网格搜索：尝试不同的参数组合，找到最优的
param_grid = {
    "max_depth": [3, 5, 7, 10],
    "min_samples_split": [2, 5, 10]
}

grid_search = GridSearchCV(
    DecisionTreeClassifier(random_state=42),
    param_grid,
    cv=5,
    scoring="accuracy"
)
grid_search.fit(X_train_scaled, y_train_u)

print("=== 网格搜索结果 ===")
print(f"最佳参数: {grid_search.best_params_}")
print(f"最佳准确率: {grid_search.best_score_:.2%}")

# 查看所有参数组合的结果
cv_results = pd.DataFrame(grid_search.cv_results_)
print("\n所有参数组合:")
for _, row in cv_results[["params", "mean_test_score"]].iterrows():
    print(f"  {row['params']}: {row['mean_test_score']:.4f}")

# 参考答案
np.random.seed(100)
n = 150

students = pd.DataFrame({
    "学习时间_小时": np.random.uniform(1, 10, n),
    "练习次数": np.random.poisson(20, n),
    "出勤率": np.random.uniform(0.5, 1.0, n),
})

# 成绩公式
students["成绩"] = (
    5 * students["学习时间_小时"] +
    1.5 * students["练习次数"] +
    30 * students["出勤率"] +
    np.random.normal(0, 5, n)
)
students["成绩"] = students["成绩"].clip(0, 100)

X_s = students[["学习时间_小时", "练习次数", "出勤率"]]
y_s = students["成绩"]

X_tr, X_te, y_tr, y_te = train_test_split(X_s, y_s, test_size=0.2, random_state=42)

# 线性回归
lr = LinearRegression()
lr.fit(X_tr, y_tr)
lr_pred = lr.predict(X_te)
print(f"线性回归 R² = {r2_score(y_te, lr_pred):.4f}")

# 决策树
dt = DecisionTreeRegressor(max_depth=4, random_state=42)
dt.fit(X_tr, y_tr)
dt_pred = dt.predict(X_te)
print(f"决策树   R² = {r2_score(y_te, dt_pred):.4f}")

print("\n线性回归系数:")
for feat, coef in zip(X_s.columns, lr.coef_):
    print(f"  {feat}: {coef:.2f}")

# 参考答案
np.random.seed(42)
n_emails = 500

emails = pd.DataFrame({
    "含免费字数": np.random.poisson(2, n_emails),
    "含中奖字数": np.random.poisson(1, n_emails),
    "含链接数": np.random.poisson(3, n_emails),
    "邮件长度": np.random.exponential(200, n_emails),
    "发件人是否已知": np.random.choice([0, 1], n_emails, p=[0.4, 0.6])
})

# 标签生成规则
spam_score = (
    2 * emails["含免费字数"] +
    3 * emails["含中奖字数"] +
    0.5 * emails["含链接数"] -
    0.01 * emails["邮件长度"] -
    1.5 * emails["发件人是否已知"]
)
emails["垃圾邮件"] = (spam_score + np.random.normal(0, 1, n_emails) > 3).astype(int)

X_e = emails.drop("垃圾邮件", axis=1)
y_e = emails["垃圾邮件"]
X_tr_e, X_te_e, y_tr_e, y_te_e = train_test_split(X_e, y_e, test_size=0.2, random_state=42)

clf_e = RandomForestClassifier(n_estimators=50, random_state=42)
clf_e.fit(X_tr_e, y_tr_e)
pred_e = clf_e.predict(X_te_e)
print(f"准确率: {accuracy_score(y_te_e, pred_e):.2%}")
print(f"\n分类报告:")
print(classification_report(y_te_e, pred_e, target_names=["正常邮件", "垃圾邮件"]))