目标是使用Pytorch来完成CNN的训练和验证过程，CNN网络结构。需要完成的逻辑结构如下：

构造训练集和验证集；

每轮进行训练和验证，并根据最优验证集精度保存模型。

# 将自定义的Dataset封装成一个Batch Size大小的Tensor，用于后面的训练。
# 训练集封装 批量处理数据
train_loader = torch.utils.data.DataLoader(
train_dataset,    # 数据加载
batch_size=10,     # 批处理大小设置
shuffle=True,     # 是否进项洗牌操作
num_workers=10,   # 是否进行多进程加载数据设置
)
# 验证集封装
val_loader = torch.utils.data.DataLoader(
val_dataset,
batch_size=10,
shuffle=False,
num_workers=10,
)
model = SVHN_Model1()
criterion = nn.CrossEntropyLoss (size_average=False) # 计算交叉熵(交叉熵损失函数
optimizer = torch.optim.Adam(model.parameters())  # Adam优化算法
best_loss = 1000.0
for epoch in range(20):
	train(train_loader, model, criterion, optimizer, epoch)
	val_loss = validate(val_loader, model, criterion)
	# 保存验证集精度
	if val_loss < best_loss:
		best_loss = val_loss
	torch.save(model.state_dict(), './model.pt')  
	print('Epoch: ', epoch)

train()、validate()与predict()代码如下：

# 训练函数
def train(train_loader, model, criterion, optimizer, epoch):
    # 切换模型为训练模式
    model.train()
    for i, (input, target) in enumerate(train_loader):
        c0, c1, c2, c3, c4, c5 = model(data[0])
        loss = criterion(c0, data[1][:, 0]) + \
                criterion(c1, data[1][:, 1]) + \
                criterion(c2, data[1][:, 2]) + \
                criterion(c3, data[1][:, 3]) + \
                criterion(c4, data[1][:, 4]) + \
                criterion(c5, data[1][:, 5])
        loss /= 6
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

# 验证函数
def validate(val_loader, model, criterion):
    # 切换模型为预测模型
    model.eval()
    val_loss = []
    # 不记录模型梯度信息
    with torch.no_grad():
        for i, (input, target) in enumerate(val_loader):
            c0, c1, c2, c3, c4, c5 = model(data[0])
            loss = criterion(c0, data[1][:, 0]) + \
                criterion(c1, data[1][:, 1]) + \
                    criterion(c2, data[1][:, 2]) + \
                    criterion(c3, data[1][:, 3]) + \
                    criterion(c4, data[1][:, 4]) + \
                    criterion(c5, data[1][:, 5])
            loss /= 6
            val_loss.append(loss.item())
    return np.mean(val_loss)

# 预测函数
def predict(test_loader, model, tta=10):
    model.eval()
    test_pred_tta = None

    # TTA 次数
    for _ in range(tta):
        test_pred = []

        with torch.no_grad():
            for i, (input, target) in enumerate(test_loader):
                # if use_cuda:
                # input = input.cuda()

                c0, c1, c2, c3, c4, c5 = model(input)
                output = np.concatenate([
                    c0.data.numpy(),
                    c1.data.numpy(),
                    c2.data.numpy(),
                    c3.data.numpy(),
                    c4.data.numpy()], axis=1)
                test_pred.append(output)

        test_pred = np.vstack(test_pred)
        if test_pred_tta is None:
            test_pred_tta = test_pred
        else:
            test_pred_tta += test_pred
    return test_pred_tta

模型保存与加载:

# 保存模型为文件model.pt
torch.save(model_object.state_dict(), 'model.pt')

# 读取文件model.pt载入模型
model.load_state_dict(torch.load(' model.pt'))

模型调参