在机器学习的世界里，模型评估指标是判断算法好坏的“裁判”。但面对准确率、召回率、MAE、ROC-AUC等数十个指标，很多小白直接懵圈——到底该用哪个？怎么计算？有啥坑？

今天，我们就来一次保姆级拆解，从分类、回归、排序三大场景，把每个指标的原理、公式、代码、优缺点和适用场景讲透，还附赠两个贴近真实业务的实战项目（电商销量预测+客户流失预警），让你看完就能上手！

原文 资料 这里！

一、分类任务：分辨“是”与“否”的艺术

分类任务是机器学习最常见的场景（比如判断邮件是否垃圾、客户是否流失）。下面是核心指标的“解剖式”分析：

1. 混淆矩阵（Confusion Matrix）

通俗理解：把模型的预测结果和真实标签放在一个表格里，看“猜中”和“猜错”的分布。

	预测正类	预测负类
真实正类	TP（真阳性）	FN（假阴性）
真实负类	FP（假阳性）	TN（真阴性）

代码实战：

from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay
cm = confusion_matrix(y_true, y_pred)
disp = ConfusionMatrixDisplay(cm, display_labels=["Negative", "Positive"])
disp.plot()

优缺点：

• 优点：直观展示各类别预测情况，是所有分类指标的基础。
• 缺点：仅看矩阵不够量化，需结合其他指标。

2. 准确率（Accuracy）

通俗理解：模型“猜中”的比例。
公式：
$$\text{Accuracy}=\frac{TP+TN}{TP+TN+FP+FN}$$
代码：from sklearn.metrics import accuracy_score; accuracy = accuracy_score(y_true, y_pred)
优缺点：

• 优点：简单易懂。
• 缺点：类别不平衡时完全失效（比如99个负类、1个正类，模型全猜负类，准确率也有99%）。

3. 精确率（Precision）

通俗理解：模型预测的“正类”中，真正是正类的比例（“猜的正类里有多少是对的”）。
公式：
$$\text{Precision}=\frac{TP}{TP+FP}$$
代码：from sklearn.metrics import precision_score; precision = precision_score(y_true, y_pred)
适用场景：关注“少犯假阳性错误”的场景（比如疾病诊断，不能把健康人误诊为病人）。

4. 召回率（Recall/Sensitivity）

通俗理解：真实的“正类”中，被模型正确识别的比例（“所有真阳性里抓对了多少”）。
公式：
$$\text{Recall}=\frac{TP}{TP+FN}$$
代码：from sklearn.metrics import recall_score; recall = recall_score(y_true, y_pred)
适用场景：关注“别漏掉真阳性”的场景（比如癌症筛查，不能漏掉真正的癌症患者）。

原文 资料 这里！

5. F1分数（F1-Score）

通俗理解：精确率和召回率的调和平均，平衡二者的指标。
公式：
$$\text{F1}=2\times \frac{\text{Precision}\times \text{Recall}}{\text{Precision}+\text{Recall}}$$
宏平均（Macro-F1）：对每个类别单独算F1，再取平均（关注“每类都好”）。
微平均（Micro-F1）：先算全局的TP、FP、FN，再代入F1公式（关注“整体效果”，适合类别不平衡）。
代码：

from sklearn.metrics import f1_score
macro_f1 = f1_score(y_true, y_pred, average='macro')
micro_f1 = f1_score(y_true, y_pred, average='micro')

6. ROC-AUC

通俗理解：ROC曲线下的面积，衡量模型对“正类”和“负类”的区分能力。

• ROC曲线的横轴是假阳性率（FPR）：$$\text{FPR}=\frac{FP}{FP+TN}$$
• 纵轴是真阳性率（TPR，即召回率）：$$\text{TPR}=\frac{TP}{TP+FN}$$
  AUC（Area Under Curve）：ROC曲线下的面积，取值0~1。AUC越接近1，模型区分能力越强。
  代码：

from sklearn.metrics import roc_auc_score, roc_curve
roc_auc = roc_auc_score(y_true, y_pred_proba)  # y_pred_proba是正类概率
fpr, tpr, _ = roc_curve(y_true, y_pred_proba)
plt.plot(fpr, tpr, label=f"ROC-AUC = {roc_auc:.3f}")

优缺点：

• 优点：对类别不平衡不敏感，能反映模型在所有阈值下的表现。
• 缺点：当正负样本分布极不均衡时，PR-AUC有时更可靠。

7. PR-AUC（Precision-Recall AUC）

通俗理解：Precision-Recall曲线下的面积，专注于正类的识别能力（尤其适合类别不平衡场景）。
代码：

from sklearn.metrics import average_precision_score, precision_recall_curve
pr_auc = average_precision_score(y_true, y_pred_proba)
precision, recall, _ = precision_recall_curve(y_true, y_pred_proba)
plt.plot(recall, precision, label=f"PR-AUC = {pr_auc:.3f}")

8. Kappa系数（Cohen’s Kappa）

通俗理解：衡量模型预测与真实标签的一致性，同时排除“随机猜测”的影响。
公式：
$$\text{Kappa}=\frac{p_o-p_e}{1-p_e}$$
其中，$p_o$是观测准确率（即Accuracy），$p_e$是随机猜测的期望准确率。
代码：from sklearn.metrics import cohen_kappa_score; kappa = cohen_kappa_score(y_true, y_pred)
适用场景：需要排除“瞎蒙对了”的情况，比如医疗诊断、标注一致性校验。

二、回归任务：预测“数值”的精度之战

回归任务是预测连续值的场景（比如房价、销量、温度）。核心指标如下：

1. 平均绝对误差（MAE）

通俗理解：预测值与真实值的绝对误差的平均值，反映“平均偏差有多大”。
公式：
$$\text{MAE}=\frac{1}{n}\sum _{i=1}^n|y_i-{\hat{y}}_i|$$
代码：from sklearn.metrics import mean_absolute_error; mae = mean_absolute_error(y_true, y_pred)
优缺点：

• 优点：对异常值不敏感，结果易解释（比如“平均每天预测错20件”）。
• 缺点：没考虑误差的平方，对“大误差”的惩罚不够。

2. 均方误差（MSE）与根均方误差（RMSE）

通俗理解：

• MSE：预测值与真实值误差的平方的平均值，对大误差惩罚更重。
• RMSE：MSE的平方根，单位和真实值一致，更易理解。
  公式：
  $$\text{MSE}=\frac{1}{n}\sum _{i=1}^n(y_i-{\hat{y}}_i{)}^2$$
  $$\text{RMSE}=\sqrt{\text{MSE}}$$
  代码：

from sklearn.metrics import mean_squared_error
mse = mean_squared_error(y_true, y_pred)
rmse = np.sqrt(mse)

优缺点：

• 优点：对大误差敏感，能有效惩罚极端错误。
• 缺点：受异常值影响大，结果单位是“平方单位”（RMSE解决了这个问题）。

3. 决定系数（R²）

通俗理解：模型能解释的方差比例，反映模型拟合效果（取值0~1，越接近1越好）。
公式：
$$R^2=1-\frac{{\sum }_{i=1}^n(y_i-{\hat{y}}_i{)}^2}{{\sum }_{i=1}^n(y_i-\bar{y}{)}^2}$$
其中，$\bar{y}$是真实值的均值。
代码：from sklearn.metrics import r2_score; r2 = r2_score(y_true, y_pred)
优缺点：

• 优点：直观反映模型对数据的解释能力。
• 缺点：当特征过多时可能“虚高”（需结合调整后R²）。

4. 平均绝对百分比误差（MAPE）与对称平均绝对百分比误差（SMAPE）

通俗理解：

• MAPE：相对误差的平均值，适合比较“不同量级”的预测（比如预测100和预测10000的误差）。
• SMAPE：对称版MAPE，解决了“真实值为0时分母为0”的问题。
  公式：
  $$\text{MAPE}=\frac{1}{n}\sum _{i=1}^n\left|\frac{y_i-{\hat{y}}_i}{y_i}\right|\times 100\%$$
  $$\text{SMAPE}=\frac{100\%}{n}\sum _{i=1}^n\frac{|y_i-{\hat{y}}_i|}{(|y_i|+|{\hat{y}}_i|)/2}$$
  代码：

from sklearn.metrics import mean_absolute_percentage_error
mape = mean_absolute_percentage_error(y_true, y_pred) * 100
smape = 100 * np.mean(2 * np.abs(y_true - y_pred) / (np.abs(y_true) + np.abs(y_pred) + 1e-10))

适用场景：电商销量、销售额预测等“关注相对误差”的场景。

三、排序任务：从“推荐列表”里找门道

排序任务常见于推荐系统（比如“猜你喜欢”的商品排序），核心指标关注“相关物品是否排在前面”。

1. 归一化折损累计增益（NDCG）

通俗理解：衡量“推荐列表中，相关物品的位置是否够靠前”，位置越后“折损”越大。

• 累计增益（CG）：$$\text{CG}=\sum _{i=1}^k{\text{rel}}_i$$（${\text{rel}}_i$是第$i$个物品的相关性分数）
• 折损累计增益（DCG）：$$\text{DCG}=\sum _{i=1}^k\frac{{\text{rel}}_i}{{\log }_2(i+1)}$$
• 归一化折损累计增益（NDCG）：$$\text{NDCG}=\frac{\text{DCG}}{\text{IDCG}}$$（IDCG是“理想情况下的DCG”，即相关物品全排在最前的DCG）
  代码：需自定义实现或使用ndcg_score库，核心逻辑是给相关物品高分、无关物品低分，再计算排名折损。

2. 平均准确率（MAP）

通俗理解：对每个查询，计算“前k个结果中，每次命中相关物品时的准确率的平均值”，再对所有查询取平均。
公式：
$$\text{MAP}=\frac{1}{Q}\sum _{q=1}^Q\frac{1}{|R_q|}\sum _{k=1}^{|R_q|}\text{Precision}(q,k)$$
其中，$Q$是查询数，$|R_q|$是查询$q$的相关物品数，$\text{Precision}(q,k)$是前$k$个结果的准确率。
适用场景：信息检索、多标签推荐（比如“找相关论文”）。

3. 平均 reciprocal 排名（MRR）

通俗理解：对每个查询，取“第一个相关物品的排名的倒数”，再对所有查询取平均。
公式：
$$\text{MRR}=\frac{1}{Q}\sum _{q=1}^Q\frac{1}{{\text{rank}}_q}$$
（${\text{rank}}_q$是查询$q$中第一个相关物品的排名）
适用场景：“只需要找到第一个相关结果”的场景（比如问答系统找最佳答案）。

四、实战项目：从“理论”到“代码”的跨越

下面我们结合电商商品销量预测(回归) 和 客户流失预警(分类) 两个真实业务场景，完整演示指标的计算与可视化。

实战一：电商商品销量预测（回归任务）

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import Ridge
from sklearn.metrics import (
    mean_absolute_error, mean_squared_error, r2_score,
    mean_absolute_percentage_error
)

# 适配服务器字体环境
plt.rcParams["font.family"] = ["DejaVu Sans", "Arial", "Helvetica", "sans-serif"]
plt.rcParams["axes.unicode_minus"] = False
np.random.seed(42)  # 固定随机种子

# 1. 模拟生成电商商品销量数据集
print("生成模拟电商商品销量数据集...")
n_samples = 2000

# 特征：价格、促销力度、好评率、上架天数、类目热度
price = np.exp(np.random.normal(loc=5.5, scale=0.5, size=n_samples)).clip(50, 500)
promotion = np.random.choice(
    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
    size=n_samples,
    p=[0.3, 0.2, 0.15, 0.1, 0.08, 0.05, 0.04, 0.03, 0.02, 0.015, 0.015]
)
rating = np.random.normal(loc=88, scale=5, size=n_samples).clip(60, 100)
days_on_shelf = np.where(
    np.random.random(n_samples) < 0.3,
    np.random.randint(1, 30, size=n_samples),
    np.where(
        np.random.random(n_samples) < 0.5,
        np.random.randint(180, 366, size=n_samples),
        np.random.randint(30, 180, size=n_samples)
    )
)
category_popularity = np.random.choice(
    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
    size=n_samples,
    p=[0.05, 0.08, 0.1, 0.15, 0.2, 0.15, 0.1, 0.08, 0.05, 0.03, 0.01]
)

X = np.column_stack([price, promotion, rating, days_on_shelf, category_popularity])
feature_names = ["Price(Yuan)", "Promotion", "Rating(%)", "Days_on_Shelf", "Category_Popularity"]

# 生成销量（加入非线性关系和随机波动）
sales = (
    500 
    - 0.8 * price 
    + 25 * promotion 
    + 4 * rating 
    + 0.2 * days_on_shelf 
    + 20 * category_popularity 
    + 0.001 * price * promotion 
    + np.random.normal(0, 40, n_samples)
).clip(50, None)

# 2. 数据预处理
X_train, X_test, y_train, y_test = train_test_split(
    X, sales, test_size=0.3, random_state=42
)

scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# 3. 模型训练与预测
print("\n训练Ridge回归模型...")
reg = Ridge(alpha=5, random_state=42)
reg.fit(X_train_scaled, y_train)
y_pred = reg.predict(X_test_scaled)

# 4. 计算回归指标
mae = mean_absolute_error(y_test, y_pred)
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
r2 = r2_score(y_test, y_pred)
mape = mean_absolute_percentage_error(y_test, y_pred) * 100
smape = 100 * np.mean(2 * np.abs(y_test - y_pred) / (np.abs(y_test) + np.abs(y_pred) + 1e-10))

print("\n=== 电商商品销量预测评估指标 ===")
print(f"MAE：{mae:.2f} → 平均每天预测偏差{mae:.0f}件")
print(f"RMSE：{rmse:.2f} → 极端误差的衡量")
print(f"R²：{r2:.4f} → 模型解释了{r2:.1%}的销量变化")
print(f"MAPE：{mape:.2f}% → 相对误差")
print(f"SMAPE：{smape:.2f}% → 对称相对误差")

# 5. 结果可视化（多图合并）
fig, axes = plt.subplots(2, 2, figsize=(14, 12))
fig.suptitle("E-commerce Product Sales Prediction Evaluation", fontsize=18, y=0.99)

# 图1：真实vs预测销量
axes[0, 0].scatter(y_test, y_pred, alpha=0.4, s=15, color='royalblue')
axes[0, 0].plot([y_test.min(), y_test.max()], [y_test.min(), y_test.max()], 'r--', lw=2)
axes[0, 0].set_xlabel("True Daily Sales", fontsize=10)
axes[0, 0].set_ylabel("Predicted Daily Sales", fontsize=10)
axes[0, 0].set_title("True vs Predicted Sales", fontsize=12)
axes[0, 0].grid(alpha=0.3)
corr = np.corrcoef(y_test, y_pred)[0, 1]
axes[0, 0].text(0.05, 0.95, f"Correlation: {corr:.3f}", 
                transform=axes[0, 0].transAxes, 
                bbox=dict(facecolor='white', alpha=0.8))

# 图2：误差分布
errors = y_pred - y_test
axes[0, 1].hist(errors, bins=30, edgecolor='black', color='lightgreen')
axes[0, 1].axvline(x=0, color='red', linestyle='--', lw=2)
axes[0, 1].set_xlabel("Prediction Error (Pred - True)", fontsize=10)
axes[0, 1].set_ylabel("Frequency", fontsize=10)
axes[0, 1].set_title("Distribution of Errors", fontsize=12)
axes[0, 1].grid(alpha=0.3, axis='y')
axes[0, 1].text(0.05, 0.95, 
                f"Mean Error: {errors.mean():.2f}\nMAE: {mae:.2f}", 
                transform=axes[0, 1].transAxes, 
                bbox=dict(facecolor='white', alpha=0.8))

# 图3：促销力度 vs 销量&误差
test_df = pd.DataFrame(X_test, columns=feature_names)
test_df["True_Sales"] = y_test
test_df["Pred_Sales"] = y_pred
test_df["Error"] = np.abs(errors)

promo_group = test_df.groupby("Promotion").agg({
    "True_Sales": "mean",
    "Error": "mean"
}).reset_index()

ax3 = axes[1, 0]
ax3_twin = ax3.twinx()
ax3.plot(promo_group["Promotion"], promo_group["True_Sales"], 
         color='darkred', marker='o', label="Average Sales")
ax3.set_xlabel("Promotion Level (0-10)", fontsize=10)
ax3.set_ylabel("Average Daily Sales", fontsize=10, color='darkred')
ax3.tick_params(axis='y', labelcolor='darkred')

ax3_twin.bar(promo_group["Promotion"], promo_group["Error"], 
             color='gray', alpha=0.5, label="Average Error")
ax3_twin.set_ylabel("Average Prediction Error", fontsize=10, color='black')
ax3_twin.tick_params(axis='y', labelcolor='black')

ax3.set_title("Sales and Error by Promotion Level", fontsize=12)
ax3.grid(alpha=0.3)
lines, labels = ax3.get_legend_handles_labels()
lines2, labels2 = ax3_twin.get_legend_handles_labels()
ax3.legend(lines + lines2, labels + labels2, loc='upper left')

# 图4：特征重要性
feature_importance = np.abs(reg.coef_)
sorted_idx = np.argsort(feature_importance)[::-1]
sorted_names = np.array(feature_names)[sorted_idx]
sorted_importance = feature_importance[sorted_idx]

bars = axes[1, 1].barh(sorted_names, sorted_importance, color='salmon')
axes[1, 1].set_xlabel("Feature Importance (Absolute Coefficient)", fontsize=10)
axes[1, 1].set_title("Feature Importance for Sales Prediction", fontsize=12)
axes[1, 1].grid(alpha=0.3, axis='x')

for bar, value in zip(bars, sorted_importance):
    width = bar.get_width()
    axes[1, 1].text(width + 0.1, bar.get_y() + bar.get_height()/2,
                    f"{value:.2f}", va='center', fontsize=9)

plt.tight_layout(rect=[0, 0, 1, 0.97])
plt.savefig("ecommerce_sales_evaluation.png", dpi=400, bbox_inches="tight")
print("\n结果图已保存为 'ecommerce_sales_evaluation.png'")

要分析该电商商品销量预测的回归任务结果，可从预测相关性、误差分布、促销与销量/误差的关系、特征重要性等维度展开：

1. 真实 vs 预测销量（相关性）

左上角图中，真实销量与预测销量的相关系数为0.950，说明两者线性关系极强，模型对销量的整体预测趋势非常准确。

2. 误差分布

右上角图显示，预测误差的均值为-0.10（接近0，无明显偏倚），MAE（平均绝对误差）为31.39，说明模型预测的平均偏差约为31.39件，误差分布集中在0附近，大误差情况较少，模型稳定性较好。

3. 促销力度与销量、误差的关系

左下角图中，平均销量随促销力度提升而显著增长（促销力度10时销量接近1100）；同时，促销力度中等时（如6-7）预测误差较高，而低促销或高促销（如10）时误差相对可控，说明促销策略的复杂度会影响预测精度。

4. 特征重要性

右下角图中，Price(Yuan)（价格）是最关键的特征（重要性93.91），其次是Promotion（促销）（61.67）和Category_Popularity（类目热度）（45.35）。这表明价格是影响销量的核心因素，促销和类目热度的业务杠杆作用也很明显，而Rating(%)（好评率）和Days_on_Shelf（上架天数）的影响相对较小。

综合结论

该回归模型表现优秀：真实与预测销量相关性极高（0.950），误差分布集中且MAE可控；价格、促销、类目热度是驱动销量的核心因素，可通过优化这些维度的策略来进一步提升销量预测和业务决策的精准性。

实战二：客户流失预警（分类任务）

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import (
    accuracy_score, precision_score, recall_score, f1_score,
    roc_auc_score, precision_recall_curve, roc_curve,
    confusion_matrix, ConfusionMatrixDisplay, cohen_kappa_score,
    average_precision_score
)

# 适配服务器字体环境
plt.rcParams["font.family"] = ["Arial"]
plt.rcParams["axes.unicode_minus"] = False
np.random.seed(42)  # 固定随机种子

# 1. 模拟生成客户流失数据集（电信场景）
print("生成模拟客户流失数据集...")
n_samples = 2000

# 特征：在网时长、月消费、增值服务、年龄、投诉次数
tenure = np.random.normal(loc=30, scale=15, size=n_samples).clip(0, 60)
monthly_fee = np.random.normal(loc=200, scale=80, size=n_samples).clip(50, 500)
addon_service = np.random.binomial(n=1, p=0.4, size=n_samples)
age = np.random.normal(loc=40, scale=12, size=n_samples).clip(18, 65).astype(int)
complaints = np.random.poisson(lam=0.3, size=n_samples).clip(0, 3)

X = np.column_stack([tenure, monthly_fee, addon_service, age, complaints])
feature_names = ["Tenure(Months)", "Monthly_Fee(Yuan)", "Addon_Service", "Age", "Complaints"]

# 生成流失标签（基于逻辑回归概率）
logit = (-0.05 * tenure) + (-0.002 * monthly_fee) + (-1.2 * addon_service) + (0.01 * age) + (1.5 * complaints)
churn_prob = 1 / (1 + np.exp(-logit))
y = np.random.binomial(n=1, p=churn_prob, size=n_samples)

# 2. 数据预处理
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, random_state=42, stratify=y
)

scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# 3. 模型训练与预测
print("\n训练逻辑回归模型...")
clf = LogisticRegression(random_state=42, max_iter=200)
clf.fit(X_train_scaled, y_train)

y_pred = clf.predict(X_test_scaled)
y_pred_proba = clf.predict_proba(X_test_scaled)[:, 1]

# 4. 计算分类指标
accuracy = accuracy_score(y_test, y_pred)
precision = precision_score(y_test, y_pred)
recall = recall_score(y_test, y_pred)
f1 = f1_score(y_test, y_pred)
kappa = cohen_kappa_score(y_test, y_pred)
roc_auc = roc_auc_score(y_test, y_pred_proba)
pr_auc = average_precision_score(y_test, y_pred_proba)

print("\n=== 客户流失预测评估指标 ===")
print(f"准确率（Accuracy）：{accuracy:.4f}")
print(f"精确率（Precision）：{precision:.4f} → 预测流失中真流失的比例")
print(f"召回率（Recall）：{recall:.4f} → 真流失中被识别的比例")
print(f"F1分数：{f1:.4f} → 精确率和召回率的平衡")
print(f"Kappa系数：{kappa:.4f} → 排除随机猜测的一致性")
print(f"ROC-AUC：{roc_auc:.4f} → 类别区分能力")
print(f"PR-AUC：{pr_auc:.4f} → 对流失客户的识别能力")

# 5. 结果可视化（多图合并）
fig, axes = plt.subplots(2, 2, figsize=(12, 10))
fig.suptitle("Customer Churn Prediction Evaluation", fontsize=16)

# 图1：混淆矩阵
cm = confusion_matrix(y_test, y_pred)
disp = ConfusionMatrixDisplay(cm, display_labels=["Retained", "Churned"])
disp.plot(ax=axes[0, 0], cmap=plt.cm.Blues, xticks_rotation=0)
axes[0, 0].set_title("Confusion Matrix")

# 图2：ROC曲线
fpr, tpr, _ = roc_curve(y_test, y_pred_proba)
axes[0, 1].plot(fpr, tpr, color='darkorange', lw=2, label=f"ROC-AUC = {roc_auc:.3f}")
axes[0, 1].plot([0, 1], [0, 1], 'k--', lw=2, label="Random Guess")
axes[0, 1].set_xlabel("False Positive Rate")
axes[0, 1].set_ylabel("True Positive Rate")
axes[0, 1].set_title("ROC Curve")
axes[0, 1].legend(loc="lower right")

# 图3：PR曲线
precision_curve, recall_curve, _ = precision_recall_curve(y_test, y_pred_proba)
axes[1, 0].plot(recall_curve, precision_curve, color='green', lw=2, label=f"PR-AUC = {pr_auc:.3f}")
axes[1, 0].axhline(y=y_test.mean(), color='red', linestyle='--', label=f"Random Guess (Churn Rate={y_test.mean():.3f})")
axes[1, 0].set_xlabel("Recall")
axes[1, 0].set_ylabel("Precision")
axes[1, 0].set_title("Precision-Recall Curve")
axes[1, 0].legend()

# 图4：特征重要性
feature_importance = np.abs(clf.coef_[0])
sorted_idx = np.argsort(feature_importance)
axes[1, 1].barh(np.array(feature_names)[sorted_idx], feature_importance[sorted_idx], color='skyblue')
axes[1, 1].set_xlabel("Feature Importance (Absolute Coefficient)")
axes[1, 1].set_title("Feature Importance for Churn Prediction")

plt.tight_layout(rect=[0, 0, 1, 0.96])
plt.savefig("customer_churn_evaluation.png", dpi=300, bbox_inches="tight")
print("\n结果图已保存为 'customer_churn_evaluation.png'")

要分析这个客户流失预测（分类任务）的结果指标，我们可以从混淆矩阵、分类性能指标（准确率、精确率、召回率、F1）、ROC-AUC、PR-AUC、特征重要性等维度逐一拆解：

1. 混淆矩阵（Confusion Matrix）

混淆矩阵是分类任务的基础，它展示了模型预测与真实标签的匹配情况：

• True Retained（真留存）：442 → 真实留存且模型预测留存的客户数。
• False Churned（假流失）：16 → 真实留存但模型预测流失的客户数。
• False Retained（假留存）：91 → 真实流失但模型预测留存的客户数。
• True Churned（真流失）：51 → 真实流失且模型预测流失的客户数。

从矩阵可见，模型对“留存客户”的识别准确性较高（442远大于16），但对“流失客户”的误判较多（91大于51），说明模型在识别流失客户时存在一定不足。

2. 核心分类性能指标计算

我们基于混淆矩阵的四个值（TP=51, FP=16, FN=91, TN=442）计算关键指标：

• 准确率（Accuracy）：
  所有预测正确的比例，公式为 (\text{Accuracy} = \frac{TP + TN}{TP + TN + FP + FN})
  代入得：(\frac{51 + 442}{51 + 442 + 16 + 91} = \frac{493}{600} \approx 0.8217) → 模型整体预测正确率约82.17%，表现尚可。

• 精确率（Precision）：
  预测为“流失”的客户中，真实流失的比例，公式为 (\text{Precision} = \frac{TP}{TP + FP})
  代入得：(\frac{51}{51 + 16} = \frac{51}{67} \approx 0.7612) → 模型预测的“流失客户”中，约76.12%是真流失，误判率较低。

• 召回率（Recall）：
  真实“流失”的客户中，被模型识别出的比例，公式为 (\text{Recall} = \frac{TP}{TP + FN})
  代入得：(\frac{51}{51 + 91} = \frac{51}{142} \approx 0.3592) → 真实流失的客户中，仅约35.92%被模型识别，召回率较低，说明模型漏判了大量流失客户。

• F1分数：
  精确率和召回率的调和平均，公式为 (\text{F1} = 2 \times \frac{\text{Precision} \times \text{Recall}}{\text{Precision} + \text{Recall}})
  代入得：(2 \times \frac{0.7612 \times 0.3592}{0.7612 + 0.3592} \approx 0.484) → 由于召回率偏低，F1分数表现一般，说明模型在“流失客户”的识别上存在明显短板。

3. ROC-AUC

ROC曲线展示了“真阳性率（TPR，即召回率）”与“假阳性率（FPR）”的 trade-off，AUC是曲线下的面积（取值0~1，越接近1越好）。
从图中可知，ROC-AUC=0.794，说明模型对“流失”和“留存”两类的区分能力处于“良好”水平（一般认为AUC>0.7为可接受，>0.8为优秀）。

4. PR-AUC（Precision-Recall AUC）

PR曲线展示了“精确率”与“召回率”的 trade-off，AUC是曲线下的面积（对类别不平衡场景更敏感）。
从图中可知，PR-AUC=0.642，结合之前的低召回率，说明模型在识别“流失”这类少数类时，性能一般，漏判较多。

5. 特征重要性

从“Feature Importance for Churn Prediction”图可见：

• Complaints（投诉次数）：重要性最高 → 客户投诉越多，越容易流失，符合业务直觉。
• Tenure(Months)（在网时长）：重要性次之 → 在网时间越短，流失风险越高（新客户稳定性差）。
• Addon_Service（增值服务）：重要性较高 → 开通增值服务的客户流失率低（绑定服务提升粘性）。
• Age（年龄）和Monthly_Fee(Yuan)（月消费）：重要性较低 → 对流失的直接影响较小。

综合结论

• 模型整体准确率不错，但漏判了大量真实流失的客户。
• ROC-AUC（0.794）表明模型对两类的区分能力尚可，但PR-AUC（0.642）暴露了在少数类（流失客户）识别上的短板。
• 特征重要性分析为业务行动提供了方向：可通过减少客户投诉、针对新客户提供留存激励、推广增值服务等方式降低流失率。

若要提升模型性能，可考虑优化分类阈值（平衡精确率和召回率）、增加流失客户的样本权重（缓解类别不平衡）或更换模型（如集成学习模型）。

实战三：电商商品推荐排序（排序任务）

排序任务的核心是“让相关商品排在前面”，本项目模拟电商“猜你喜欢”场景——基于用户行为（浏览、收藏、购买）和商品特征，构建推荐列表并通过NDCG、MAP、MRR三大核心指标评估排序效果，小白可直接复制运行。

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import GradientBoostingRegressor
from sklearn.metrics import ndcg_score  # 直接调用NDCG
import warnings
warnings.filterwarnings('ignore')

# 适配服务器环境
plt.rcParams["font.family"] = ["DejaVu Sans", "Arial", "Helvetica", "sans-serif"]
plt.rcParams["axes.unicode_minus"] = False
np.random.seed(42)  # 固定随机种子

# --------------------------
# 1. 模拟生成电商推荐排序数据集（贴近真实业务）
# --------------------------
print("生成电商商品推荐排序数据集...")
n_users = 500  # 用户数
n_items_per_user = 20  # 每个用户候选商品数
n_samples = n_users * n_items_per_user  # 总样本数

# 特征定义（用户+商品双维度）
# 1. 用户特征
user_activity = np.random.normal(loc=5, scale=2, size=n_users).clip(1, 10).repeat(n_items_per_user)  # 用户活跃度（1-10）
user_prefer_price = np.random.normal(loc=200, scale=80, size=n_users).clip(50, 500).repeat(n_items_per_user)  # 用户偏好价格
user_category_prefer = np.random.randint(0, 10, size=n_users).repeat(n_items_per_user)  # 用户偏好类目（0-9）

# 2. 商品特征
item_price = np.random.normal(loc=220, scale=90, size=n_samples).clip(50, 500)  # 商品价格
item_category = np.random.randint(0, 10, size=n_samples)  # 商品类目（0-9）
item_sales = np.random.poisson(lam=50, size=n_samples).clip(10, 200)  # 商品销量
item_rating = np.random.normal(loc=4.2, scale=0.5, size=n_samples).clip(3.0, 5.0)  # 商品评分
item_click_rate = np.random.uniform(0.01, 0.3, size=n_samples)  # 商品点击率

# 3. 用户-商品交互特征（关键！影响排序相关性）
price_diff = np.abs(user_prefer_price - item_price)  # 价格差异（越小越相关）
category_match = (user_category_prefer == item_category).astype(int)  # 类目匹配（1=匹配，0=不匹配）

# 构造特征矩阵
X = np.column_stack([
    user_activity, user_prefer_price, user_category_prefer,
    item_price, item_category, item_sales, item_rating, item_click_rate,
    price_diff, category_match
])
feature_names = [
    "User_Activity", "User_Prefer_Price", "User_Category_Prefer",
    "Item_Price", "Item_Category", "Item_Sales", "Item_Rating", "Item_Click_Rate",
    "Price_Diff", "Category_Match"
]

# 生成相关性标签（1-5分，5分最相关，用于排序评估）
relevance = (
    0.8 * category_match  # 类目匹配权重最高
    + 0.5 * (1 - price_diff / 500)  # 价格越接近得分越高
    + 0.3 * (item_rating / 5.0)  # 商品评分正向影响
    + 0.2 * (item_sales / 200)  # 销量正向影响
    + 0.2 * (item_click_rate / 0.3)  # 点击率正向影响
    + 0.1 * (user_activity / 10)  # 用户活跃度正向影响
    + np.random.normal(0, 0.1, size=n_samples)
).clip(1.0, 5.0).round(1)  # 1-5分，保留1位小数

# 构造用户-商品映射表（用于按用户分组计算排序指标）
user_ids = np.repeat(np.arange(n_users), n_items_per_user)
df = pd.DataFrame(X, columns=feature_names)
df["User_ID"] = user_ids
df["Relevance"] = relevance

print(f"数据集规模：{X.shape}")
print(f"相关性标签分布：1分={sum(relevance==1.0)}, 2分={sum(relevance==2.0)}, 3分={sum(relevance==3.0)}, 4分={sum(relevance==4.0)}, 5分={sum(relevance==5.0)}")
print("\n数据前5行：")
print(df[["User_ID", "Category_Match", "Price_Diff", "Relevance"] + feature_names[:3]].head().round(2))

# --------------------------
# 2. 数据预处理（按用户分组划分训练/测试集）
# --------------------------
# 按用户ID分组，确保同一用户的所有商品要么在训练集，要么在测试集
user_ids_unique = df["User_ID"].unique()
train_users, test_users = train_test_split(user_ids_unique, test_size=0.3, random_state=42)

train_df = df[df["User_ID"].isin(train_users)].reset_index(drop=True)
test_df = df[df["User_ID"].isin(test_users)].reset_index(drop=True)

X_train = train_df[feature_names].values
y_train = train_df["Relevance"].values
X_test = test_df[feature_names].values
y_test = test_df["Relevance"].values

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

# --------------------------
# 3. 模型训练（用回归模型预测相关性得分，按得分排序）
# --------------------------
print("\n训练梯度提升回归模型（预测商品相关性得分）...")
model = GradientBoostingRegressor(n_estimators=100, max_depth=3, random_state=42)
model.fit(X_train_scaled, y_train)

# 预测相关性得分（得分越高，排序越靠前）
y_pred = model.predict(X_test_scaled)

# 按用户分组整理真实标签和预测得分（排序指标要求输入格式：[用户1的标签列表, 用户2的标签列表,...]）
test_df["Pred_Relevance"] = y_pred
true_relevance_list = []
pred_relevance_list = []

for user_id in test_users:
    user_data = test_df[test_df["User_ID"] == user_id]
    true_relevance_list.append(user_data["Relevance"].values)
    pred_relevance_list.append(user_data["Pred_Relevance"].values)

# --------------------------
# 4. 计算排序核心指标（NDCG、MAP、MRR）
# --------------------------
# 1. NDCG（归一化折损累计增益，越大越好，0-1）
ndcg_5 = ndcg_score(true_relevance_list, pred_relevance_list, k=5)  # 前5个商品的NDCG
ndcg_10 = ndcg_score(true_relevance_list, pred_relevance_list, k=10)  # 前10个商品的NDCG
ndcg_all = ndcg_score(true_relevance_list, pred_relevance_list, k=n_items_per_user)  # 全部商品的NDCG

# 2. MAP（平均准确率，越大越好，0-1）
def calculate_map(true_list, pred_list):
    map_score = 0.0
    valid_users = 0
    for true_rel, pred_rel in zip(true_list, pred_list):
        # 按预测得分降序排序，获取真实相关性
        sorted_indices = np.argsort(pred_rel)[::-1]
        sorted_true = true_rel[sorted_indices]
        # 只考虑相关商品（>=3分）
        relevant_mask = sorted_true >= 3.0
        if not np.any(relevant_mask):
            continue
        # 计算该用户的准确率
        precision_list = []
        hit_count = 0
        for i, is_relevant in enumerate(relevant_mask):
            if is_relevant:
                hit_count += 1
                precision_list.append(hit_count / (i + 1))
        map_score += np.mean(precision_list)
        valid_users += 1
    return map_score / valid_users if valid_users > 0 else 0.0

map_score = calculate_map(true_relevance_list, pred_relevance_list)

# 3. MRR（平均 reciprocal 排名，越大越好，0-1）
def calculate_mrr(true_list, pred_list):
    mrr_score = 0.0
    valid_users = 0
    for true_rel, pred_rel in zip(true_list, pred_list):
        # 按预测得分降序排序，获取真实相关性
        sorted_indices = np.argsort(pred_rel)[::-1]
        sorted_true = true_rel[sorted_indices]
        # 找第一个相关商品（>=4分，高相关）的位置
        high_relevant_mask = sorted_true >= 4.0
        if not np.any(high_relevant_mask):
            continue
        first_high_rel_rank = np.argmax(high_relevant_mask) + 1  # 排名从1开始
        mrr_score += 1 / first_high_rel_rank
        valid_users += 1
    return mrr_score / valid_users if valid_users > 0 else 0.0

mrr_score = calculate_mrr(true_relevance_list, pred_relevance_list)

# 打印指标（带业务解释）
print("\n=== 电商商品推荐排序评估指标 ===")
print(f"NDCG@5：{ndcg_5:.4f} → 前5个推荐商品的排序质量（>0.7为良好）")
print(f"NDCG@10：{ndcg_10:.4f} → 前10个推荐商品的排序质量")
print(f"NDCG@all：{ndcg_all:.4f} → 全部候选商品的排序质量")
print(f"MAP：{map_score:.4f} → 整体推荐列表的平均准确率（>0.6为良好）")
print(f"MRR：{mrr_score:.4f} → 高相关商品的首屏命中能力（>0.5为良好）")

# --------------------------
# 5. 结果可视化（多图合并，直观分析排序效果）
# --------------------------
fig, axes = plt.subplots(2, 2, figsize=(14, 12))
fig.suptitle("E-commerce Product Recommendation Ranking Evaluation", fontsize=18, y=0.99)

# 图1：真实相关性 vs 预测相关性（散点图）
axes[0, 0].scatter(y_test, y_pred, alpha=0.4, s=15, color='darkblue')
axes[0, 0].set_xlabel("True Relevance Score (1-5)", fontsize=10)
axes[0, 0].set_ylabel("Predicted Relevance Score", fontsize=10)
axes[0, 0].set_title("True vs Predicted Relevance", fontsize=12)
axes[0, 0].grid(alpha=0.3)
# 标注相关系数
corr = np.corrcoef(y_test, y_pred)[0, 1]
axes[0, 0].text(0.05, 0.95, f"Correlation: {corr:.3f}", 
                transform=axes[0, 0].transAxes, 
                bbox=dict(facecolor='white', alpha=0.8))

# 图2：NDCG@k 曲线（不同k值的NDCG变化）
k_values = [1, 3, 5, 8, 10, 15, 20]
ndcg_scores = [ndcg_score(true_relevance_list, pred_relevance_list, k=k) for k in k_values]
axes[0, 1].plot(k_values, ndcg_scores, marker='o', linewidth=2, color='darkred', markersize=6)
axes[0, 1].set_xlabel("Top-k Recommendations", fontsize=10)
axes[0, 1].set_ylabel("NDCG Score", fontsize=10)
axes[0, 1].set_title("NDCG@k Curve", fontsize=12)
axes[0, 1].grid(alpha=0.3)
axes[0, 1].set_ylim(0.5, 1.0)  # 限定y轴范围，更清晰

# 图3：特征重要性（影响排序的关键因素）
feature_importance = model.feature_importances_
sorted_idx = np.argsort(feature_importance)[::-1]
sorted_names = np.array(feature_names)[sorted_idx]
sorted_importance = feature_importance[sorted_idx]

bars = axes[1, 0].barh(sorted_names[:8], sorted_importance[:8], color='orange')  # 显示前8个重要特征
axes[1, 0].set_xlabel("Feature Importance", fontsize=10)
axes[1, 0].set_title("Top 8 Feature Importance for Ranking", fontsize=12)
axes[1, 0].grid(alpha=0.3, axis='x')
# 标注数值
for bar, value in zip(bars, sorted_importance[:8]):
    width = bar.get_width()
    axes[1, 0].text(width + 0.005, bar.get_y() + bar.get_height()/2,
                    f"{value:.3f}", va='center', fontsize=9)

# 图4：真实vs预测的排序分布（以随机1个用户为例）
random_user_id = np.random.choice(test_users)
user_data = test_df[test_df["User_ID"] == random_user_id]
# 按真实相关性排序
true_sorted = user_data.sort_values("Relevance", ascending=False)["Relevance"].values
# 按预测相关性排序
pred_sorted = user_data.sort_values("Pred_Relevance", ascending=False)["Relevance"].values
x_pos = np.arange(len(true_sorted))

axes[1, 1].plot(x_pos, true_sorted, label="True Relevance (Sorted)", linewidth=2, color='green')
axes[1, 1].plot(x_pos, pred_sorted, label="Predicted Relevance (Sorted)", linewidth=2, color='purple', linestyle='--')
axes[1, 1].set_xlabel("Item Rank (Top to Bottom)", fontsize=10)
axes[1, 1].set_ylabel("Relevance Score (1-5)", fontsize=10)
axes[1, 1].set_title(f"Ranking Distribution (User ID: {random_user_id})", fontsize=12)
axes[1, 1].legend()
axes[1, 1].grid(alpha=0.3)

# 调整布局并保存图片
plt.tight_layout(rect=[0, 0, 1, 0.97])
plt.savefig("ecommerce_recommendation_ranking_evaluation.png", dpi=400, bbox_inches="tight")
print("\n结果图已保存为 'ecommerce_recommendation_ranking_evaluation.png'")

要分析该电商推荐排序回归任务的结果指标，我们可以从模型预测能力、排序质量、特征重要性三个维度展开：

1. 模型预测能力（真实 vs 预测相关性散点图）

从左上角的散点图可以看到：

• 真实相关性（横轴）与预测相关性（纵轴）的相关系数高达0.973，说明模型对“商品与用户的相关性得分”预测非常准确，拟合效果极佳。
• 散点的分布也较为集中，进一步验证了模型预测的稳定性。

2. 排序质量指标（NDCG、MAP、MRR）

结合代码中对指标的定义和业务解释：

• NDCG（归一化折损累计增益）：
  • NDCG@5、NDCG@10、NDCG@all 均接近1.0（从右上角NDCG@k曲线也能看出，k从1到20时NDCG几乎满值）。这说明模型对商品的排序极其精准——前5、前10乃至全部候选商品的排序，都几乎完全匹配“真实相关性”的最优排序，用户能在推荐列表前序位置看到最相关的商品。
• MAP（平均准确率）：
  衡量推荐列表中“相关商品”的整体准确率。若按照合理的相关阈值（如≥2.5分），模型能有效识别相关商品并在列表中合理排布，确保用户浏览时的准确率。
• MRR（平均 reciprocal 排名）：
  衡量“高相关商品”的首屏命中能力。若高相关阈值（如≥3.5分）设置合理，模型能让高相关商品出现在推荐列表的极靠前位置，用户无需翻页即可快速找到最匹配的商品。

3. 特征重要性（排序的关键驱动因素）

从左下角的特征重要性图可见：

• Category_Match（类目匹配） 是绝对的核心特征（重要性达0.970），说明“商品类目是否与用户偏好类目匹配”是决定推荐相关性的最关键因素。
• 其次是 Item_Click_Rate（商品点击率）、Price_Diff（价格差异） 等特征，也在排序中起到了重要作用。
• 这一结果符合电商推荐的业务逻辑：用户首先关注“类目是否对口”，其次才是价格、点击率等维度。

综上，该回归模型在电商推荐排序任务中表现非常优异——既精准预测了商品与用户的相关性得分，又通过极高的NDCG验证了排序的合理性，同时特征重要性的分布也契合业务直觉，具备很强的可解释性和实用价值。

五、指标选择的“避坑指南”

• 分类任务：

  • 类别平衡 → 用Accuracy、F1；
  • 类别不平衡 → 用ROC-AUC、PR-AUC、Recall（看业务侧重“抓对”还是“抓全”）；
  • 需排除随机 → 用Kappa系数。

• 回归任务：

  • 关注“平均偏差” → MAE；
  • 关注“极端误差” → RMSE；
  • 关注“相对误差” → MAPE、SMAPE；
  • 关注“模型解释力” → R²。

• 排序任务：

  • 推荐系统 → NDCG、MAP；
  • 问答系统 → MRR。

至此，你已经掌握了机器学习评估指标的“底层逻辑”和“实战技巧”。下次再面对模型评估时，就不会再迷茫——选对指标，才能让你的算法“精准发力”！

原文 资料 这里！