9.2 模型评估
模型评估是指对训练完成的机器学习或深度学习模型进行性能分析和测试，以确定模型在新数据上的表现如何。
9.2.1 模型评估的方法和指标
在模型评估过程中，选择适当的指标取决于问题类型和数据特点。通常，应当综合考虑多个指标，以便全面了解模型的性能和优缺点。下面是一些常见的模型评估方法和指标：
- 测试集评估：在训练和验证过程中，通常会将数据集分为训练集和验证集。测试集是模型从未见过的数据，用于评估其在真实场景中的性能。将测试集输入模型，根据预测结果与真实标签进行比较，可以计算出测试集上的准确性、精确度、召回率等指标。
- 准确性（Accuracy）：是模型正确预测的样本数量与总样本数量之比。对于二分类问题，准确性计算公式为：(TP + TN) / (TP + TN + FP + FN)，其中TP表示真正例，TN表示真负例，FP表示假正例，FN表示假负例。
- 精确度（Precision）和召回率（Recall）：在不平衡类别数据集中，精确度和召回率是重要的指标。精确度是正确预测为正类的样本数与所有预测为正类的样本数之比，计算公式为：TP / (TP + FP)。召回率是正确预测为正类的样本数与真实正类的样本数之比，计算公式为：TP / (TP + FN)。
- F1-Score：F1-Score综合考虑了精确度和召回率，是一个平衡指标，特别适用于不平衡类别问题。它的计算公式为：2 * (精确度 * 召回率) / (精确度 + 召回率)。
- 混淆矩阵：混淆矩阵是一个表格，展示了模型的分类结果与真实标签之间的对应关系。它将预测结果分为真正例（True Positive, TP）、真负例（True Negative, TN）、假正例（False Positive, FP）和假负例（False Negative, FN）四类情况。
- ROC曲线和AUC：ROC曲线（Receiver Operating Characteristic Curve）是一个用于评估二分类模型性能的工具。它以假正例率（False Positive Rate, FPR）为横轴，真正例率（True Positive Rate, TPR）为纵轴，展示了不同阈值下模型的性能。AUC（Area Under the Curve）是ROC曲线下的面积，通常用于比较不同模型的性能。
- 平均绝对误差（MAE）和均方误差（MSE）：在回归问题中，MAE计算预测值与真实值之间的绝对差值的平均值，MSE计算预测值与真实值之间的差值的平方的平均值。
- 交叉验证：交叉验证是将数据集分为多个子集，然后多次训练和测试模型，以便更好地估计模型的性能。常见的交叉验证方法包括k折交叉验证。
- 泛化误差：泛化误差是指模型在新数据上的误差，它反映了模型的泛化能力。评估模型的泛化误差可以帮助判断模型是否过拟合或欠拟合。
例如下面是一个TensorFlow使用ROC曲线来评估一个二分类模型的性能的例子，在这个例子中，将使用TensorFlow和Scikit-learn库来构建和评估一个简单的二分类模型，并绘制ROC曲线。
实例9-1：TensorFlow使用ROC曲线来评估一个二分类模型的性能（源码路径：daima\9\roc.py）
实例文件roc.py的具体实现代码如下所示。
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras.optimizers import Adam
from sklearn.model_selection import train_test_split
from sklearn.metrics import roc_curve, auc
import matplotlib.pyplot as plt
import numpy as np
# 生成示例数据
np.random.seed(0)
X = np.random.rand(1000, 10)
y = np.random.randint(2, size=1000)
# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
# 构建简单的二分类模型
model = Sequential([
Dense(16, activation='relu', input_shape=(10,)),
Dense(1, activation='sigmoid')
])
model.compile(loss='binary_crossentropy', optimizer=Adam(lr=0.001), metrics=['accuracy'])
# 训练模型
model.fit(X_train, y_train, epochs=10, batch_size=32, validation_data=(X_test, y_test))
# 获取模型在测试集上的预测概率
y_pred_prob = model.predict(X_test)
# 计算ROC曲线
fpr, tpr, thresholds = roc_curve(y_test, y_pred_prob)
roc_auc = auc(fpr, tpr)
# 绘制ROC曲线
plt.figure()
plt.plot(fpr, tpr, color='darkorange', lw=2, label='ROC curve (area = %0.2f)' % roc_auc)
plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('Receiver Operating Characteristic')
plt.legend(loc="lower right")
plt.show()在上述代码中，首先生成了一个随机的二分类数据集，然后构建了一个包含一个隐藏层的简单神经网络模型。在模型训练完成后，使用predict方法获取模型在测试集上的预测概率，然后使用roc_curve函数计算FPR（假正例率）和TPR（真正例率），最后使用Matplotlib绘制ROC曲线。如图9-8所示。
图9-8 绘制的ROC曲线
下面是一个使用PyTorch进行模型评估并绘制ROC曲线的例子，在这个例子中，将使用PyTorch和Scikit-learn库来构建和评估一个二分类模型，并绘制ROC曲线。
实例9-2：PyTorch使用ROC曲线来评估一个二分类模型的性能（源码路径：daima\9\pyroc.py）
实例文件pyroc.py的具体实现代码如下所示。
import torch
import torch.nn as nn
import torch.optim as optim
from sklearn.metrics import roc_curve, auc
import matplotlib.pyplot as plt
import numpy as np
# 生成示例数据
np.random.seed(0)
X = np.random.rand(1000, 10)
y = np.random.randint(2, size=1000)
# 划分训练集和测试集
X_train, X_test = X[:700], X[700:]
y_train, y_test = y[:700], y[700:]
# 定义简单的神经网络模型
class SimpleNet(nn.Module):
def __init__(self):
super(SimpleNet, self).__init__()
self.fc1 = nn.Linear(10, 16)
self.fc2 = nn.Linear(16, 1)
self.sigmoid = nn.Sigmoid()
def forward(self, x):
x = torch.relu(self.fc1(x))
x = self.fc2(x)
x = self.sigmoid(x)
return x
# 创建模型实例
model = SimpleNet()
# 定义损失函数和优化器
criterion = nn.BCELoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)
# 将数据转换为PyTorch张量
X_train_tensor = torch.FloatTensor(X_train)
y_train_tensor = torch.FloatTensor(y_train)
X_test_tensor = torch.FloatTensor(X_test)
# 训练模型
for epoch in range(50):
optimizer.zero_grad()
outputs = model(X_train_tensor)
loss = criterion(outputs, y_train_tensor.view(-1, 1))
loss.backward()
optimizer.step()
# 获取模型在测试集上的预测概率
model.eval()
with torch.no_grad():
y_pred_prob = model(X_test_tensor).numpy()
# 计算ROC曲线
fpr, tpr, thresholds = roc_curve(y_test, y_pred_prob)
roc_auc = auc(fpr, tpr)
# 绘制ROC曲线
plt.figure()
plt.plot(fpr, tpr, color='darkorange', lw=2, label='ROC curve (area = %0.2f)' % roc_auc)
plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('Receiver Operating Characteristic')
plt.legend(loc="lower right")
plt.show()在这个例子中，首先定义了一个简单的神经网络模型 SimpleNet，然后通过PyTorch进行模型训练。在训练完成后，使用模型在测试集上的预测概率，并使用Scikit-learn的 roc_curve 和 auc 函数计算和绘制ROC曲线。如图9-8所示。
图9-8 绘制的ROC曲线
9.2.2 交叉验证和统计显著性测试的应用
交叉验证和统计显著性测试是在机器学习和统计学中常用的两种技术，用于评估模型性能和确定结果的可靠性。它们在模型评估和比较、特征选择和超参数调优等方面都有广泛的应用。
1. 交叉验证的应用
交叉验证是一种通过多次划分训练集和验证集的方法，来评估模型性能和提高泛化能力的技术。常见的交叉验证方法包括k折交叉验证、留一交叉验证等。交叉验证的应用包括：
- 模型性能评估：在训练和验证过程中，将数据分为多个子集，多次训练和验证模型，得到平均性能，更准确地评估模型的泛化能力。
- 模型选择：通过交叉验证，可以比较不同模型的性能，选择最优模型。选择过程不仅考虑训练集上的性能，还考虑了验证集上的性能，避免了过拟合。
- 超参数调优：交叉验证可用于选择最优的超参数，比如学习率、正则化参数等。通过在不同的训练集和验证集上训练模型，找到在验证集上性能最佳的超参数组合。
2. 统计显著性测试的应用
统计显著性测试用于确定实验结果是否具有统计上的显著性，即结果是否因随机性而产生。它在模型比较、特征选择和实验结果的解释方面有广泛应用。常见的显著性测试包括t检验、ANOVA、卡方检验等。统计显著性测试的应用包括：
- 模型比较：当比较两个或多个模型时，可以使用显著性测试来判断它们之间的性能差异是否显著。例如，通过比较模型的准确性是否显著不同来确定哪个模型更好。
- 特征选择：在特征选择过程中，可以使用显著性测试来判断特征与目标变量之间的关系是否显著。从而选择对目标变量有显著影响的特征。
- 实验结果解释：在实验设计中，显著性测试可以帮助你判断实验结果是否因为干预而产生，还是因为随机性而产生。这有助于解释实验结果的可靠性。
- 需要注意的是，统计显著性测试并不是万能的，它在设计和执行上都需要遵循严格的原则。同时，显著性测试的结果需要综合考虑，不应孤立地用于做决策。在应用这些技术时，理解其原理和局限性非常重要。
下面是一个使用Scikit-learn的支持向量机（SVM）模型进行交叉验证和统计显著性测试的例子。
实例9-1：Scikit-learn对SVM模型进行交叉验证和统计显著性测试（源码路径：daima\9\jiaoxian.py）
实例文件jiaoxian.py的具体实现代码如下所示。
from sklearn.datasets import load_iris
from sklearn.model_selection import cross_val_score
from sklearn.svm import SVC
from scipy.stats import ttest_rel
# 加载鸢尾花数据集
data = load_iris()
X = data.data
y = data.target
# 创建支持向量机模型
model_A = SVC(kernel='linear', C=1.0)
model_B = SVC(kernel='rbf', C=1.0)
# 进行交叉验证
results = []
models = [model_A, model_B]
for model in models:
model_results = cross_val_score(model, X, y, cv=5, scoring='accuracy')
results.append(model_results)
# 打印交叉验证结果
for i, model_results in enumerate(results):
print(f"Model {i+1} Cross-Validation Accuracies: {model_results}")
print(f"Mean Accuracy: {model_results.mean():.4f}")
# 进行配对t检验
t_statistic, p_value = ttest_rel(results[0], results[1])
# 打印显著性测试结果
print(f"T-Statistic: {t_statistic:.4f}")
print(f"P-Value: {p_value:.4f}")
# 判断显著性
alpha = 0.05
if p_value < alpha:
print("There is a significant difference between the models.")
else:
print("There is no significant difference between the models.")在上述代码中，加载了鸢尾花数据集，并创建了两个支持向量机模型：一个使用线性核（model_A），另一个使用径向基函数（RBF）核（model_B）。然后，使用cross_val_score函数对这两个模型进行交叉验证，计算每个模型在不同交叉验证折叠上的准确性。最后，我们使用配对t检验来进行统计显著性测试，以确定这两个模型的性能是否存在显著差异。执行后会输出：
Model 1 Cross-Validation Accuracies: [0.96666667 1. 0.96666667 0.96666667 1. ]
Mean Accuracy: 0.9800
Model 2 Cross-Validation Accuracies: [0.96666667 0.96666667 0.96666667 0.93333333 1. ]
Mean Accuracy: 0.9667
T-Statistic: 1.6330
P-Value: 0.1778
There is no significant difference between the models.根据上述输出结果可以看出，两个支持向量机模型的平均准确性在不同的交叉验证折叠上略有不同，但通过配对t检验得出的p-value大于显著性水平0.05，因此我们得出结论：这两个模型之间没有显著差异。
使用TensorFlow进行交叉验证和统计显著性测试时，情况会稍微复杂一些，因为TensorFlow不像Scikit-learn那样有现成的交叉验证函数，此时可以考虑使用类似的方法进行操作。请看下面的例子，使用TensorFlow来训练神经网络，并使用Scikit-learn来进行交叉验证和统计显著性测试。
实例9-1：在TensorFlow中实现交叉验证和统计显著性测试（源码路径：daima\9\tfjiao.py）
实例文件tfjiao.py的具体实现代码如下所示。
import numpy as np
import tensorflow as tf
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import StratifiedKFold
from scipy.stats import ttest_ind
# 创建一个简单的神经网络模型
def create_neural_network():
model = tf.keras.Sequential([
tf.keras.layers.Dense(64, activation='relu', input_shape=(4,)),
tf.keras.layers.Dense(3, activation='softmax')
])
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
return model
# 加载鸢尾花数据集
from sklearn.datasets import load_iris
data = load_iris()
X = data.data
y = data.target
# 创建神经网络模型
model = create_neural_network()
# 使用分层K折交叉验证进行训练和评估
num_folds = 5
kfold = StratifiedKFold(n_splits=num_folds, shuffle=True, random_state=42)
results = []
for train_idx, test_idx in kfold.split(X, y):
X_train, X_test = X[train_idx], X[test_idx]
y_train, y_test = y[train_idx], y[test_idx]
model.fit(X_train, y_train, epochs=10, batch_size=32, verbose=0)
_, accuracy = model.evaluate(X_test, y_test, verbose=0)
results.append(accuracy)
# 打印交叉验证结果
for i, accuracy in enumerate(results):
print(f"Fold {i+1} Accuracy: {accuracy:.4f}")
print(f"Mean Accuracy: {np.mean(results):.4f}")
# 进行独立样本t检验
midpoint = len(results) // 2
first_half_results = results[:midpoint]
second_half_results = results[midpoint:]
t_statistic, p_value = ttest_ind(first_half_results, second_half_results)
# 打印显著性测试结果
print(f"T-Statistic: {t_statistic:.4f}")
print(f"P-Value: {p_value:.4f}")
# 判断显著性
alpha = 0.05
if p_value < alpha:
print("There is a significant difference between the folds.")
else:
print("There is no significant difference between the folds.")上述代码的实现流程如下：
- 定义了一个简单的神经网络模型 create_neural_network()，该模型由两个密集层组成，其中一个使用ReLU激活函数，另一个使用Softmax激活函数。该模型使用Adam优化器和稀疏分类交叉熵损失函数进行编译。
- 加载了鸢尾花数据集，并将特征数据（X）和目标标签（y）分别赋值给变量。
- 创建了神经网络模型 model，通过调用 create_neural_network() 函数。
- 使用分层K折交叉验证 StratifiedKFold 对数据进行划分和交叉验证。num_folds 变量定义了折叠的数量。在每个折叠中，训练数据和测试数据会被划分，并使用神经网络模型在训练数据上进行训练，然后在测试数据上评估准确性。评估结果会被存储在 results 列表中。
- 打印每个折叠的准确性和平均准确性。
- 将 results 列表分成两个子集，分别代表交叉验证的前半部分和后半部分。
- 使用 ttest_ind 函数进行独立样本t检验，比较两个子集的结果。计算得到t统计值和p值。
- 打印t检验的统计值和p值。
- 根据显著性水平alpha（通常设置为0.05），判断是否存在显著性差异。如果p值小于alpha，说明有显著性差异，否则说明两组数据之间没有显著性差异。
执行后会输出下面的结果，根据输出结果可知，显著性测试的p值略高于显著性水平0.05，这意味着我们不能拒绝“两组折叠之间没有显著差异”的原假设。
Fold 1 Accuracy: 0.6667
Fold 2 Accuracy: 0.7667
Fold 3 Accuracy: 0.8333
Fold 4 Accuracy: 0.9000
Fold 5 Accuracy: 0.9667
Mean Accuracy: 0.8267
T-Statistic: -2.9516
P-Value: 0.0599
There is no significant difference between the folds.当涉及到使用PyTorch进行交叉验证和统计显著性测试时，也会采用和Tensorflow类似的方法。请看下面的例子，首先使用PyTorch来训练神经网络，然后使用Scikit-learn进行交叉验证和统计显著性测试功能。
实例9-1：在PyTorch中实现交叉验证和统计显著性测试（源码路径：daima\9\pyjiao.py）
实例文件pyjiao.py的具体实现代码如下所示。
import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import StratifiedKFold
from scipy.stats import ttest_ind
# 创建一个简单的神经网络模型
class SimpleNN(nn.Module):
def __init__(self):
super(SimpleNN, self).__init__()
self.fc1 = nn.Linear(4, 64)
self.fc2 = nn.Linear(64, 3)
def forward(self, x):
x = torch.relu(self.fc1(x))
x = self.fc2(x)
return x
# 加载鸢尾花数据集
from sklearn.datasets import load_iris
data = load_iris()
X = data.data
y = data.target
# 转换为PyTorch的Tensor
X_tensor = torch.tensor(X, dtype=torch.float32)
y_tensor = torch.tensor(y, dtype=torch.long)
# 创建神经网络模型
model = SimpleNN()
# 使用分层K折交叉验证进行训练和评估
num_folds = 5
kfold = StratifiedKFold(n_splits=num_folds, shuffle=True, random_state=42)
results = []
for train_idx, test_idx in kfold.split(X, y):
X_train, X_test = X_tensor[train_idx], X_tensor[test_idx]
y_train, y_test = y_tensor[train_idx], y_tensor[test_idx]
optimizer = optim.Adam(model.parameters(), lr=0.001)
criterion = nn.CrossEntropyLoss()
for epoch in range(10):
optimizer.zero_grad()
outputs = model(X_train)
loss = criterion(outputs, y_train)
loss.backward()
optimizer.step()
with torch.no_grad():
outputs = model(X_test)
_, predicted = torch.max(outputs, 1)
accuracy = (predicted == y_test).sum().item() / y_test.size(0)
results.append(accuracy)
# 打印交叉验证结果
for i, accuracy in enumerate(results):
print(f"Fold {i+1} Accuracy: {accuracy:.4f}")
print(f"Mean Accuracy: {np.mean(results):.4f}")
# 进行独立样本t检验
midpoint = len(results) // 2
first_half_results = results[:midpoint]
second_half_results = results[midpoint:]
t_statistic, p_value = ttest_ind(first_half_results, second_half_results)
# 打印显著性测试结果
print(f"T-Statistic: {t_statistic:.4f}")
print(f"P-Value: {p_value:.4f}")
# 判断显著性
alpha = 0.05
if p_value < alpha:
print("There is a significant difference between the folds.")
else:
print("There is no significant difference between the folds.")在上述代码中，首先定义了一个简单的神经网络模型 SimpleNN，然后使用PyTorch的张量将鸢尾花数据集转换为模型所需的格式。然后，使用分层K折交叉验证来训练和评估模型，每个折叠都会计算准确性并存储在 results 列表中。接着，使用 ttest_ind 函数进行独立样本t检验，比较交叉验证的前半部分和后半部分的结果，计算得到t统计值和p值。最后，根据显著性水平alpha判断是否存在显著性差异。
执行后会输出：
Fold 1 Accuracy: 0.6667
Fold 2 Accuracy: 0.6667
Fold 3 Accuracy: 0.7333
Fold 4 Accuracy: 0.7667
Fold 5 Accuracy: 0.9333
Mean Accuracy: 0.7533
T-Statistic: -1.8086
P-Value: 0.1682
There is no significant difference between the folds.
2164
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
