image.png

    实例：

    1. # 导入模块
    2. import numpy as np
    3. import random
    4. import torch
    5. import torch.nn as nn
    6. import torch.nn.functional as F
    7. from torch.utils.data import DataLoader, Dataset, TensorDataset
    8. from torchvision import models
    9. net = models.resnet18(pretrained=True)
    10. # 创建一个数据集
    11. X = torch.rand(500,3, 32, 32)
    12. Y = torch.rand(500, 1)
    13. # random shuffle
    14. index = [i for i in range(len(X))]
    15. random.shuffle(index)
    16. X = X[index]
    17. Y = Y[index]
    20. def get_kfold_data(k, i, X, y):
    21.     # 返回第 i+1 折 (i = 0 -> k-1) 交叉验证时所需要的训练和验证数据，X_train为训练集，X_valid为验证集
    22.     fold_size = X.shape[0] // k  # 每份的个数:数据总条数/折数（组数）
    24.     val_start = i * fold_size
    25.     if i != k - 1:
    26.         val_end = (i + 1) * fold_size
    27.         X_valid, y_valid = X[val_start:val_end], y[val_start:val_end]
    28.         X_train = torch.cat((X[0:val_start], X[val_end:]), dim=0)
    29.         y_train = torch.cat((y[0:val_start], y[val_end:]), dim=0)
    30.     else:  # 若是最后一折交叉验证
    31.         X_valid, y_valid = X[val_start:], y[val_start:]  # 若不能整除，将多的case放在最后一折里
    32.         X_train = X[0:val_start]
    33.         y_train = y[0:val_start]
    35.     return X_train, y_train, X_valid, y_valid
    38. def traink(model, X_train, y_train, X_val, y_val, BATCH_SIZE, learning_rate, TOTAL_EPOCHS):
    39.     train_loader = DataLoader(TensorDataset(X_train, y_train), BATCH_SIZE, shuffle=True)
    40.     val_loader = DataLoader(TensorDataset(X_val, y_val), BATCH_SIZE, shuffle=True)
    42.     criterion = nn.CrossEntropyLoss()
    43.     optimizer = torch.optim.Adam(params=model.parameters(), lr=learning_rate)
    45.     losses = []
    46.     val_losses = []
    47.     train_acc = []
    48.     val_acc = []
    50.     for epoch in range(TOTAL_EPOCHS):
    51.         model.train()
    52.         correct = 0  # 记录正确的个数，每个epoch训练完成之后打印accuracy
    53.         for i, (images, labels) in enumerate(train_loader):
    54.             images = images.float()
    55.             labels = torch.squeeze(labels.type(torch.LongTensor))
    56.             optimizer.zero_grad()  # 清零
    57.             outputs = model(images)
    58.             # 计算损失函数
    59.             loss = criterion(outputs, labels)
    60.             loss.backward()
    61.             optimizer.step()
    62.             losses.append(loss.item())
    63.             # 计算正确率
    64.             y_hat = model(images)
    65.             pred = y_hat.max(1, keepdim=True)[1]
    66.             correct += pred.eq(labels.view_as(pred)).sum().item()
    68.             if (i + 1) % 10 == 0:
    69.                 # 每10个batches打印一次loss
    70.                 print('Epoch : %d/%d, Iter : %d/%d,  Loss: %.4f' % (epoch + 1, TOTAL_EPOCHS,
    71.                                                                     i + 1, len(X_train) // BATCH_SIZE,
    72.                                                                     loss.item()))
    73.         accuracy = 100. * correct / len(X_train)
    74.         print('Epoch: {}, Loss: {:.5f}, Training set accuracy: {}/{} ({:.3f}%)'.format(
    75.             epoch + 1, loss.item(), correct, len(X_train), accuracy))
    76.         train_acc.append(accuracy)
    78.         # 每个epoch计算测试集accuracy
    79.         model.eval()
    80.         val_loss = 0
    81.         correct = 0
    82.         with torch.no_grad():
    83.             for i, (images, labels) in enumerate(val_loader):
    84.                 images = images.float()
    85.                 labels = torch.squeeze(labels.type(torch.LongTensor))
    86.                 optimizer.zero_grad()
    87.                 y_hat = model(images)
    88.                 loss = criterion(y_hat, labels).item()  # batch average loss
    89.                 val_loss += loss * len(labels)  # sum up batch loss
    90.                 pred = y_hat.max(1, keepdim=True)[1]  # get the index of the max log-probability
    91.                 correct += pred.eq(labels.view_as(pred)).sum().item()
    93.         val_losses.append(val_loss / len(X_val))
    94.         accuracy = 100. * correct / len(X_val)
    95.         print('Test set: Average loss: {:.4f}, Accuracy: {}/{} ({:.3f}%)\n'.format(
    96.             val_loss, correct, len(X_val), accuracy))
    97.         val_acc.append(accuracy)
    99.     return losses, val_losses, train_acc, val_acc
    102. def k_fold(k, X_train, y_train, num_epochs=3, learning_rate=0.0001, batch_size=16):
    103.     train_loss_sum, valid_loss_sum = 0, 0
    104.     train_acc_sum, valid_acc_sum = 0, 0
    106.     for i in range(k):
    107.         print('*' * 25, '第', i + 1, '折', '*' * 25)
    108.         data = get_kfold_data(k, i, X_train, y_train)  # 获取k折交叉验证的训练和验证数据
    109.         #net = net()  # 实例化模型（某已经定义好的模型）
    110.         # 每份数据进行训练
    111.         train_loss, val_loss, train_acc, val_acc = traink(net, *data, batch_size, learning_rate, num_epochs)
    113.         print('train_loss:{:.5f}, train_acc:{:.3f}%'.format(train_loss[-1], train_acc[-1]))
    114.         print('valid loss:{:.5f}, valid_acc:{:.3f}%\n'.format(val_loss[-1], val_acc[-1]))
    116.         train_loss_sum += train_loss[-1]
    117.         valid_loss_sum += val_loss[-1]
    118.         train_acc_sum += train_acc[-1]
    119.         valid_acc_sum += val_acc[-1]
    121.     print('\n', '#' * 10, '最终k折交叉验证结果', '#' * 10)
    123.     print('average train loss:{:.4f}, average train accuracy:{:.3f}%'.format(train_loss_sum / k, train_acc_sum / k))
    124.     print('average valid loss:{:.4f}, average valid accuracy:{:.3f}%'.format(valid_loss_sum / k, valid_acc_sum / k))
    126.     return
    128. k_fold(10, X, Y, num_epochs=3, learning_rate=0.0001, batch_size=16)