（8-4 -1）模型验证和调优：验证集、验证集和测试集

8.4.1  验证集、验证集和测试集

在机器学习和深度学习中，数据集通常被分为三个主要部分：训练集、验证集和测试集。这种划分有助于评估模型的性能并进行调优，以确保模型在未见过的数据上表现良好。

1. 训练集（Training Set）： 训练集是用于训练模型的数据集。模型通过观察训练集中的样本来学习数据的模式和特征。训练集通常是数据量最大的部分，模型根据训练集调整参数，以尽量准确地拟合训练数据。
2. 验证集（Validation Set）： 验证集用于调优模型的超参数和模型结构。模型在训练过程中可以观察验证集的性能，根据验证集的表现来选择最佳的超参数设置，避免过拟合。验证集在训练过程中没有直接参与参数更新，它只是用于评估模型在未见过数据上的性能。在模型选择和调优结束后，最终的性能评估应该使用测试集。
3. 测试集（Test Set）： 测试集用于最终评估模型在未见过的数据上的性能。模型在训练和验证过程中没有接触过测试集，因此，测试集可以有效地衡量模型在现实应用中的泛化能力。测试集的目的是模拟模型在实际应用中的表现，以便了解模型是否过拟合或欠拟合，以及在不同数据分布上的性能。

在实际应用中，通常将上述三者（训练集：验证集：测试集）的划分比例设置为：70%：15%：15% 或 80%：10%：10%。在不同的项目中，这些比例可以根据问题的复杂性和数据量的大小进行调整。

在实际应用中，应该遵循以下步骤进行操作：

1. 使用训练集来训练模型的参数。
2. 使用验证集来选择最佳的超参数设置和模型结构。
3. 使用测试集来最终评估模型的性能。
4. 通过合理划分数据集和使用验证集和测试集，可以更好地了解模型的表现，避免过拟合，以及选择最佳的模型和超参数。

请看下面的例子，演示了在 TensorFlow 中划分数据集并进行模型训练、验证和测试的过程。

实例8-1：TensorFlow划分数据集并进行模型训练、验证和测试（源码路径：daima/8/ji.py）

实例文件ji.py的主要实现代码如下所示。

import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense

# 生成示例数据
num_samples = 1000
input_dim = 10
output_dim = 1

X = np.random.rand(num_samples, input_dim)
y = np.random.randint(2, size=(num_samples, output_dim))  # 模拟二分类标签

# 划分数据集：训练集、验证集和测试集
X_train, X_temp, y_train, y_temp = train_test_split(X, y, test_size=0.3, random_state=42)
X_val, X_test, y_val, y_test = train_test_split(X_temp, y_temp, test_size=0.5, random_state=42)

# 构建神经网络模型
model = Sequential([
    Dense(32, activation='relu', input_shape=(input_dim,)),
    Dense(16, activation='relu'),
    Dense(output_dim, activation='sigmoid')
])

# 编译模型
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

# 训练模型
batch_size = 32
num_epochs = 50

model.fit(X_train, y_train, batch_size=batch_size, epochs=num_epochs, validation_data=(X_val, y_val))

# 使用验证集评估模型性能
val_loss, val_accuracy = model.evaluate(X_val, y_val)
print(f"Validation Loss: {val_loss:.4f}, Validation Accuracy: {val_accuracy:.4f}")

# 使用测试集评估模型性能
test_loss, test_accuracy = model.evaluate(X_test, y_test)
print(f"Test Loss: {test_loss:.4f}, Test Accuracy: {test_accuracy:.4f}")

对上述代码的具体说明如下：

1. 生成示例数据，并使用 train_test_split 函数将数据划分为训练集、验证集和测试集。
2. 构建一个简单的神经网络模型，包括输入层、隐藏层和输出层。
3. 编译模型，指定优化器、损失函数和评价指标。
4. 使用 model.fit 方法进行模型训练，传入训练数据和验证数据。
5. 使用 model.evaluate 方法分别在验证集和测试集上评估模型的性能，并输出损失和准确率。

执行后会输出：

Epoch 1/30
22/22 [==============================] - 7s 92ms/step - loss: 0.6956 - accuracy: 0.5129 - val_loss: 0.6955 - val_accuracy: 0.5000
Epoch 2/30
22/22 [==============================] - 0s 12ms/step - loss: 0.6924 - accuracy: 0.5243 - val_loss: 0.6945 - val_accuracy: 0.4867
Epoch 3/30
……
Epoch 30/30
22/22 [==============================] - 0s 19ms/step - loss: 0.6670 - accuracy: 0.6000 - val_loss: 0.7166 - val_accuracy: 0.4467
5/5 [==============================] - 0s 13ms/step - loss: 0.7166 - accuracy: 0.4467
Validation Loss: 0.7166, Validation Accuracy: 0.4467
5/5 [==============================] - 0s 5ms/step - loss: 0.7203 - accuracy: 0.4867
Test Loss: 0.7203, Test Accuracy: 0.4867

请看下面的例子，演示了在PyTorch中划分数据集并进行模型训练、验证和测试的过程。

实例8-2：PyTorch划分数据集并进行模型训练、验证和测试（源码路径：daima/8/pyji.py）

实例文件pyji.py的主要实现代码如下所示。

import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import transforms, datasets
from torch.utils.data import DataLoader, random_split

# 数据预处理
transform = transforms.Compose([
    transforms.Resize((32, 32)),
    transforms.ToTensor(),
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))  # 图像归一化
])

# 加载CIFAR-10数据集
dataset = datasets.CIFAR10(root='./data', train=True, transform=transform, download=True)
train_size = int(0.8 * len(dataset))
val_size = len(dataset) - train_size
train_dataset, val_dataset = random_split(dataset, [train_size, val_size])

test_dataset = datasets.CIFAR10(root='./data', train=False, transform=transform, download=True)

# 定义数据加载器
batch_size = 32
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=False)
test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)

# 定义模型
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(3, 64, kernel_size=3, padding=1)
        self.pool = nn.MaxPool2d(kernel_size=2, stride=2)
        self.fc1 = nn.Linear(64 * 16 * 16, 256)
        self.fc2 = nn.Linear(256, 10)

    def forward(self, x):
        x = self.pool(nn.functional.relu(self.conv1(x)))
        x = x.view(x.size(0), -1)
        x = nn.functional.relu(self.fc1(x))
        x = self.fc2(x)
        return x

model = Net()

# 定义损失函数和优化器
criterion = nn.CrossEntropyLoss()  # 交叉熵损失函数
optimizer = optim.Adam(model.parameters(), lr=0.001)  # Adam优化算法

# 训练模型
num_epochs = 10
for epoch in range(num_epochs):
    model.train()  # 设置为训练模式
    for inputs, labels in train_loader:
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

    # 在验证集上评估模型
    model.eval()  # 设置为评估模式
    val_loss = 0.0
    correct = 0
    total = 0
    with torch.no_grad():
        for inputs, labels in val_loader:
            outputs = model(inputs)
            val_loss += criterion(outputs, labels).item()
            _, predicted = torch.max(outputs.data, 1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()

    print(f"Epoch [{epoch+1}/{num_epochs}] - Validation Loss: {val_loss/len(val_loader):.4f} - Validation Accuracy: {100*correct/total:.2f}%")

print("Training complete!")

# 在测试集上评估模型
model.eval()
test_loss = 0.0
correct = 0
total = 0
with torch.no_grad():
    for inputs, labels in test_loader:
        outputs = model(inputs)
        test_loss += criterion(outputs, labels).item()
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

print(f"Test Loss: {test_loss/len(test_loader):.4f} - Test Accuracy: {100*correct/total:.2f}%")

在这个例子中使用了CIFAR-10数据集，并将其划分为训练集、验证集和测试集。我们定义了一个卷积神经网络模型，并使用训练集进行模型训练。在每个训练迭代后，我们在验证集上评估模型性能，以便在训练过程中进行监控和调优。最后，我们在测试集上对训练好的模型进行性能评估。