[模型构建] 3. 模型评估-CSDN博客

本文链接：https://blog.csdn.net/ayiya_Oese/article/details/147913991

👋 你好！这里有实用干货与深度分享✨✨ 若有帮助，欢迎：
👍 点赞 | ⭐ 收藏 | 💬 评论 | ➕ 关注，解锁更多精彩！
📁 收藏专栏即可第一时间获取最新推送🔔。
📖后续我将持续带来更多优质内容，期待与你一同探索知识，携手前行，共同进步🚀。

人工智能

模型评估

本文将详细介绍深度学习模型的评估方法，包括评估指标的选择、性能分析、过拟合检测等内容。

1. 评估指标选择

1.1 分类任务指标

准确率(Accuracy)
$\frac{TP + TN}{TP + TN + FP + FN}$
- 正确预测的样本比例
- 适用于类别平衡的数据集
精确率(Precision)
$\frac{TP}{TP + FP}$
- 预测为正例中真实正例的比例
- 关注假阳性错误
召回率(Recall)
$\frac{TP}{TP + FN}$
- 真实正例中被正确预测的比例
- 关注假阴性错误
F1分数
$\times \frac{Precision \times Recall}{Precision + Recall}$
- 精确率和召回率的调和平均
- 平衡两个指标
混淆矩阵
$\begin{array}{c|c|c} & \text{Predicted Positive} & \text{Predicted Negative} \\ \hline \text{Actual Positive} & TP & FN \\ \text{Actual Negative} & FP & TN \\ \end{array}$
- 展示预测结果与真实结果的分布
- 帮助诊断分类错误

其中：
TP(True Positive)表示被正确分类为正例的样本数，
FP(False Positive)表示被错误分类为正例的样本数，
FN(False Negative)表示被错误分类为负例的样本数，
TN(True Negative)表示被正确分类为负例的样本数。

from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, classification_report

def classification_metrics(y_true, y_pred):
    accuracy = accuracy_score(y_true, y_pred)
    precision = precision_score(y_true, y_pred, average='macro')
    recall = recall_score(y_true, y_pred, average='macro')
    f1 = f1_score(y_true, y_pred, average='macro')
    
    return {
        'accuracy': accuracy,
        'precision': precision,
        'recall': recall,
        'f1': f1
    }

y_true = [0, 1, 2, 2, 2]
y_pred = [0, 0, 2, 2, 1]
print(classification_metrics(y_true, y_pred))
print(classification_report(y_true, y_pred))

import seaborn as sns

def plot_confusion_matrix(cm, classes):
    plt.figure(figsize=(10,8))
    sns.heatmap(cm, annot=True, fmt='d', cmap='Blues')
    plt.xlabel('Predicted')
    plt.ylabel('Actual')
    plt.xticks(ticks=np.arange(len(classes))+0.5, labels=classes)
    plt.yticks(ticks=np.arange(len(classes))+0.5, labels=classes)
    plt.title('Confusion Matrix')

1.2 回归任务指标

均方误差(MSE)：
$\frac{1}{n}\sum_{i=1}^n (y_i - \hat{y}_i)^2$
- 预测值与真实值差的平方和平均
- 对异常值敏感
平均绝对误差(MAE)：
$\frac{1}{n}\sum_{i=1}^n |y_i - \hat{y}_i|$
- 预测值与真实值差的绝对值平均
- 更稳健的度量
R方系数：
$R^2 = 1 - \frac{\sum(y_i - \hat{y}_i)^2}{\sum(y_i - \bar{y})^2}$
- 模型解释的方差比例
- 值域在[0,1]之间

from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score

def regression_metrics(y_true, y_pred):
    mse = mean_squared_error(y_true, y_pred)
    mae = mean_absolute_error(y_true, y_pred)
    r2 = r2_score(y_true, y_pred)
    
    return {
        'mse': mse,
        'mae': mae,
        'r2': r2
    }

1.3 多标签分类指标

宏平均(F1-macro)：
$F1_{macro} = \frac{1}{C}\sum_{c=1}^C F1_c$
- 对每个标签分别计算F1，然后求平均值
- 不考虑标签不平衡
- 适用于不平衡数据集
微平均(F1-micro)：
$F1_{micro} = \frac{TP}{\sum TP + \frac{1}{2}(FP + FN)}$
- 对所有标签的预测结果进行汇总
- 考虑所有样本的贡献
- 适用于不平衡数据集

from sklearn.metrics import f1_score

def multilabel_classification_metrics(y_true, y_pred):
    f1_macro = f1_score(y_true, y_pred, average='macro')
    f1_micro = f1_score(y_true, y_pred, average='micro')

    return {
       'f1_macro': f1_macro,
       'f1_micro': f1_micro
    }

1.4 其他指标

对数损失(Log Loss)：
$-\frac{1}{n}\sum_{i=1}^n \left[y_i \log(\hat{y}_i) + (1 - y_i) \log(1 - \hat{y}_i)\right]$
- 用于二分类问题
- 对预测概率进行惩罚
AUC(Area Under the Curve)：
$\frac{\sum_{i=1}^{n-1} \text{TP}_i \times \text{FP}_i}{\sum_{i=1}^{n-1} \text{TP}_i \times \text{FP}_i + \sum_{i=1}^{n-1} \text{FN}_i \times \text{FP}_i}$
- 用于二分类问题
- 对分类器的排序能力进行评估

from sklearn.metrics import log_loss, roc_auc_score

def binary_classification_metrics(y_true, y_pred_proba):
    log_loss_value = log_loss(y_true, y_pred_proba)
    auc_value = roc_auc_score(y_true, y_pred_proba)

    return {
       'log_loss': log_loss_value,
       'auc': auc_value
    }

# 示例数据
y_true = np.array([0, 1, 0, 1])
y_pred = np.array([0.1, 0.9, 0.2, 0.8])

print(binary_classification_metrics(y_true, y_pred))

2. 模型性能分析

2.1 训练过程分析

class ModelAnalyzer:
    def __init__(self):
        self.train_losses = []
        self.val_losses = []
        self.metrics = []
    
    def update(self, train_loss, val_loss, metric):
        self.train_losses.append(train_loss)
        self.val_losses.append(val_loss)
        self.metrics.append(metric)
    
    def plot_learning_curves(self):
        plt.figure(figsize=(10, 5))
        plt.subplot(1, 2, 1)
        plt.plot(self.train_losses, label='Train Loss')
        plt.plot(self.val_losses, label='Val Loss')
        plt.legend()
        plt.title('Learning Curves')
        
        plt.subplot(1, 2, 2)
        plt.plot(self.metrics, label='Metric')
        plt.legend()
        plt.title('Metric Progress')
        plt.show()

2.2 计算效率分析

import time
import torch

def measure_inference_time(model, input_data, num_runs=100):
    model.eval()
    times = []
    
    with torch.no_grad():
        for _ in range(num_runs):
            start_time = time.time()
            _ = model(input_data)
            end_time = time.time()
            times.append(end_time - start_time)
    
    return {
        'mean_time': np.mean(times),
        'std_time': np.std(times)
    }

3. 过拟合检测

3.1 验证集评估

def check_overfitting(train_losses, val_losses, threshold=1.5):
    train_loss = np.mean(train_losses[-5:])
    val_loss = np.mean(val_losses[-5:])
    
    if val_loss > train_loss * threshold:
        return True, val_loss / train_loss
    return False, val_loss / train_loss

3.2 正则化方法

L1/L2正则化

# L2正则化
optimizer = torch.optim.Adam(model.parameters(), weight_decay=1e-4)

Dropout
```
self.dropout = nn.Dropout(p=0.5)
```

早停

class EarlyStopping:
    def __init__(self, patience=7, min_delta=0):
        self.patience = patience
        self.min_delta = min_delta
        self.counter = 0
        self.best_loss = None
        self.early_stop = False
    
    def __call__(self, val_loss):
        if self.best_loss is None:
            self.best_loss = val_loss
        elif val_loss > self.best_loss - self.min_delta:
            self.counter += 1
            if self.counter >= self.patience:
                self.early_stop = True
        else:
            self.best_loss = val_loss
            self.counter = 0

4. 欠拟合诊断

4.1 诊断方法

训练集性能
- 检查训练集上的损失是否收敛
- 评估训练集上的指标
模型复杂度分析
- 检查模型参数量
- 评估模型表达能力

4.2 解决方案

增加模型复杂度
- 添加更多层
- 增加神经元数量
调整学习率
- 使用学习率调度器
- 尝试不同的优化器

5. 模型可解释性

5.1 特征重要性分析

def feature_importance(model, input_data):
    model.eval()
    baseline = torch.zeros_like(input_data)
    importance = []
    
    with torch.no_grad():
        for i in range(input_data.shape[1]):
            temp_data = baseline.clone()
            temp_data[:, i] = input_data[:, i]
            output_diff = model(temp_data) - model(baseline)
            importance.append(output_diff.abs().mean().item())
    
    return importance

5.2 可视化分析

特征图可视化

def visualize_feature_maps(model, input_data):
    activation = {}
    
    def get_activation(name):
        def hook(model, input, output):
            activation[name] = output.detach()
        return hook
    
    # 注册钩子
    model.conv1.register_forward_hook(get_activation('conv1'))
    
    # 前向传播
    _ = model(input_data)
    
    # 可视化
    act = activation['conv1']
    plt.imshow(act[0, 0].numpy())
    plt.show()