PyTorch基础(part5)--交叉熵

学习笔记，仅供参考，有错必纠

文章目录

• ​​原理​​
• ​​代码​​

• ​​初始设置​​
• ​​导包​​
• ​​载入数据​​
• ​​模型​​

原理

• 交叉熵（Cross-Entropy）

代码

初始设置

# 支持多行输出
from IPython.core.interactiveshell import InteractiveShell
InteractiveShell.ast_node_interactivity = 'all' #默认为'last'

导包

# 导入常用的包
import numpy as np
from torch import nn,optim
from torch.autograd import Variable
from torchvision import datasets, transforms
from torch.utils.data import DataLoader
import torch

载入数据

# 载入数据
train_dataset = datasets.MNIST(root = './data/', # 载入的数据存放的位置
                               train = True, # 载入训练集数据
                               transform = transforms.ToTensor(), # 将载入进来的数据变成Tensor
                               download = True) # 是否下载数据
test_dataset = datasets.MNIST(root = './data/', # 载入的数据存放的位置
                               train = False, # 载入测试集数据
                               transform = transforms.ToTensor(), # 将载入进来的数据变成Tensor
                               download = True) # 是否下载数据

# 批次大小
batch_size = 64

# 装载训练集
train_loader = DataLoader(dataset=train_dataset,
                         batch_size=batch_size,
                         shuffle=True)

# 装载训练集
test_loader = DataLoader(dataset=test_dataset,
                         batch_size=batch_size,
                         shuffle=True)

模型

# 定义网络结构
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.fc1 = nn.Linear(784,10)
        self.softmax = nn.Softmax(dim=1)
        
    def forward(self,x):
        # ([64, 1, 28, 28])->(64,784)
        x = x.view(x.size()[0], -1)
        x = self.fc1(x)
        x = self.softmax(x)
        return x

LR = 0.5
# 定义模型
model = Net()
# 定义代价函数为交叉熵代价函数
mse_loss = nn.CrossEntropyLoss()
# 定义优化器
optimizer = optim.SGD(model.parameters(), LR)

相比于PyTorch基础(part4)中的MSELoss()，这里我们改用CrossEntropyLoss().

同时，在下面的训练过程中，我们也不需要把标签该为独热编码的形式.

def train():
    for i,data in enumerate(train_loader):
        # 获得一个批次的数据和标签
        inputs, labels = data
        # 获得模型预测结果（64,10）
        out = model(inputs)
        # 计算loss,交叉熵代价函数out(batch,C), labels(batch)
        loss = mse_loss(out, labels)
        # 梯度清0
        optimizer.zero_grad()
        # 计算梯度
        loss.backward()
        # 修改权值
        optimizer.step()

def test():
    correct = 0
    for i,data in enumerate(test_loader):
        # 获得一个批次的数据和标签
        inputs, labels = data
        # 获得模型预测结果（64,10）
        out = model(inputs)
        # 获得最大值，以及最大值所在的位置
        _, predicted = torch.max(out, 1)
        # 预测正确的数量
        correct += (predicted == labels).sum()
    print("Test acc:{0}".format(correct.item()/len(test_dataset)))

for epoch in range(10):
    print('epoch:',epoch)
    train()
    test()

epoch: 0
Test acc:0.9064
epoch: 1
Test acc:0.9138
epoch: 2
Test acc:0.9172
epoch: 3
Test acc:0.9206
epoch: 4
Test acc:0.92
epoch: 5
Test acc:0.9215
epoch: 6
Test acc:0.9208
epoch: 7
Test acc:0.9243
epoch: 8
Test acc:0.9237
epoch: 9
Test acc:0.9237

对比上一篇blog中的训练准确率，在训练相同次数的情况下，使用交叉熵代价函数的效果会更好一些.