PyTorch深度学习实践——多分类问题

参考资料

参考资料1：https://blog.csdn.net/bit452/article/details/109686936
参考资料2：http://biranda.top/pytorch%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0010%E2%80%94%E2%80%94%E5%A4%9A%E5%88%86%E7%B1%BB%E9%97%AE%E9%A2%98/

多分类问题

数据导入

pycharm显示

只需要云盘中这四个就行

百度云盘地址
链接：https://pan.baidu.com/s/1DmccXT0S1KN5Vhh9msdOFw?pwd=1895
提取码：1895

代码

import torch
#组建DataLoader
from torchvision import transforms #对图像进行原始处理的工具
from torchvision import datasets
from torch.utils.data import DataLoader
#激活函数和优化器
import torch.nn.functional as F #for using function relu（）
import torch.optim as optim

#在Pytorch中，一个约定俗成的方法是使用.pt扩展的文件格式来保存张量

#Dataset&Dataloader必备
Batch_Size = 64
#pillow（PIL）读的原图像格式为W*H*C，原值较大，c是channal，h是high，w是width
# 转为格式为C*W*H值为0-1的Tensor
transform = transforms.Compose([
    # 变为格式为C*W*H的Tensor
    #Convert the PIL Image to Tensor.  28×28 → 1×28×28
    transforms.ToTensor(),
    #第一个是均值，第二个是标准差，变值为0-1
    transforms.Normalize((0.1307,), (0.3081,))
])

train_dataset = datasets.MNIST(root='./dataset/mnist/',
                               train=True,
                               download=True,
                               transform = transform)#train=True,创建训练集

train_loader = DataLoader(train_dataset,shuffle=True,batch_size=Batch_Size)

#datasets.MNIST是Pytorch的内置函数torchvision.datasets.MNIST，通过这个可以导入数据集。
#train=True 代表我们读入的数据作为训练集（如果为true则从training.pt创建数据集，否则从test.pt创建数据集）
#transform则是读入我们自己定义的数据预处理操作
#download=True则是当我们的根目录（root）下没有数据集时，便自动下载。
test_dataset = datasets.MNIST(root='./dataset/mnist/',
                               train=False,
                               download=True,
                               transform = transform)
test_loader = DataLoader(test_dataset, shuffle=False, batch_size=Batch_Size)

class Net(torch.nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        # 线性层1，input784维 output512维
        self.l1 = torch.nn.Linear(784, 512)
        # 线性层2，input512维 output256维
        self.l2 = torch.nn.Linear(512, 256)
        # 线性层3，input256维 output128维
        self.l3 = torch.nn.Linear(256, 128)
        # 线性层4，input128维 output64维
        self.l4 = torch.nn.Linear(128, 64)
        # 线性层5，input64维 output10维
        self.l5 = torch.nn.Linear(64, 10)

    def forward(self, x):
        # 改变张量形状用 方法view\reshape
        # view 只能用于内存中连续存储的Tensor，transpose\permute之后的不能用
        # 变为二阶张量（矩阵），-1用于计算填充batch_size

        #比如输出N×1×28×28，比如64×1×28×28，其中把1×28×28变成一个784个长度的，使之列长为784。
        # 第一个变量填-1，函数会自动计算出-1处应该是多少，上述例子会自动算出-1处应该是N，是64.
        x = x.view(-1, 784)#x此时形状 行是N行（N为样本数），列是784列。
        # relu 激活函数
        x = F.relu(self.l1(x))
        x = F.relu(self.l2(x))
        x = F.relu(self.l3(x))
        x = F.relu(self.l4(x))
        # 第五层不再进行relu激活
        return self.l5(x)

model = Net()

#交叉熵损失
criterion = torch.nn.CrossEntropyLoss()
#随机梯度下降，momentum表冲量，在更新时一定程度上保留原方向
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.5)

def train(epoch):
    running_loss = 0.0
    # 提取数据 batch_idx=0,1...,从0开始
    for batch_idx, data in enumerate(train_loader, 0):
        #inputs={Tensor：(64,1,28,28)} , target={Tensor:(64,)}
        inputs, target = data
        # 优化器清零
        optimizer.zero_grad()
        # 前馈+反馈+更新
        # outputs={Tensor：(64,10)},target={Tensor:(64,)}
        outputs = model(inputs)
        #loss 等于一个值
        loss = criterion(outputs, target)
        loss.backward()
        optimizer.step()
        # 累计loss
        running_loss += loss.item()

        if batch_idx % 300 == 299:
            print('[%d, %5d] loss: %.3f' % (epoch + 1, batch_idx + 1, running_loss / 300))
            running_loss = 0.0


def test():
    correct = 0
    total = 0
    # 避免计算梯度
    with torch.no_grad():
        for data in test_loader:
            # images={Tensor：(64,1,28,28)} , labels={Tensor:(64,)}
            images, labels = data
            outputs = model(images)
            # 取每一行（dim=1表第一个维度）最大值（max）的下标(predicted)及最大值(_)
            #outputs.data={tensor:(64,10)}  predicted={tensor:(64,)}
            _, predicted = torch.max(outputs.data, dim=1)
            # 加上这一个批量的总数（batch_size），labels的形式为[N,1]，labels.size(0)等于N
            #labels={Tensor:(64,)}
            total += labels.size(0)
            correct += (predicted == labels).sum().item()
        print('Accuracy on test set: %d %%' % (100 * correct / total))


if __name__ == '__main__':
    for epoch in range(10):
        train(epoch)
        test()

结果