Pytorch学习（1）

首先是开发环境的配置，python37+windows+pycharm，之前想试着弄jupty notebook,但是cuda太慢了.

使用了清华源，还是无法加载torchvision，所以我放弃了，从而使用pycharm.

通过一个例子（CIFAR-10）来入门

• 使用torchvision加载并预处理CIFAR-10数据集
• 定义网络
• 定义损失函数和优化器
• 训练网络并更新网络参数
• 测试网络

    1.1、CIFAR-10数据加载及预处理

  首先要了解CIFAR-10数据集，它是一个常用的彩色图片数据集，有十个类别。每张图片都是3*32*32，也就是3通道彩色图片，分辨率32*32.

import torchvision as tv
import torchvision.transforms as transforms
from torchvision.transforms import ToPILImage
import matplotlib.pyplot as plt


# 可以把Tensor转成Image方便可视化
show = ToPILImage()

# 第一次运行程序会自动下载该数据集，但是很慢。
# 如果已经下载了，那么通过root来指定该数据集所在的绝对路径

# 定义对数据的预处理
transform = transforms.Compose([
    transforms.ToTensor(), # 转为Tensor
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),
])

# 训练集
trainset = tv.datasets.CIFAR10(
    root='D:/Pycharm/Project/BYSJ/data',
    train=True,
    download=True,
    transform=transform)

trainloader = t.utils.data.DataLoader(
    trainset,
    batch_size=4,
    shuffle=True,
    num_workers=2
)

# 测试集
testset = tv.datasets.CIFAR10(
    'D:/Pycharm/Project/BYSJ/data',
    train=False,
    download=True,
    transform=transform
)

testloader = t.utils.data.DataLoader(
    testset,
    batch_size=4,
    shuffle=False,
    num_workers=2
)

classes = ('plane', 'car', 'bird', 'cat',
           'deer', 'dog', 'frog', 'horse', 'ship', 'truck')

1.2、定义网络

   使用LeNet网络，但是由于数据集是3通道的，所以将self.conv1中的第一个参数改为3通道。

import torch.nn as nn
import torch.nn.functional as F

# 定义LeNet网络
class Net(nn.Module):
    def __init__(self):
        # nn.Moudle子类的函数必须在构造函数中执行父类的构造函数
        # 下式等价与nn.Moudle.__init__(self)
        super(Net, self).__init__()

        # 卷积层‘1’表示输入图片为单通道，‘6’表示输出通道数
        # ‘5’表示卷积核为5*5
        self.conv1 = nn.Conv2d(3, 6, 5)
        # 卷积层
        self.conv2 = nn.Conv2d(6, 16, 5)
        # 仿射层/全连接层，y = Wx + b
        self.fc1 = nn.Linear(16*5*5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
        # 卷积->激活->池化
        x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))
        x = F.max_pool2d(F.relu(self.conv2(x)), 2)
        # reshape, '-1'表示自适应
        x = x.view(x.size()[0], -1)
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x

net = Net()
print(net)  # 可以看到整个网络

1.3、定义损失函数和优化器（loss和optimizer）

# 定义损失函数
criterion = nn.CrossEntropyLoss()  # 交叉熵损失函数

# 定义优化器
# 在反向传播计算完所有参数的梯度后
# 还需要使用优化方法更新网络的权重和参数
# torch.optim中实现了深度学习中绝大多数的优化方法
# 例如：RMSProp、Adam、SGD
# 新建一个优化器，指定要调整的参数和学习率
optimizer = optim.SGD(net.parameters(), lr=0.01, momentum=0.9)

1.4、训练网络并更新网络参数

所以网络的训练流程都是类似的，不断地执行如下流程。

• 输入数据
• 前向传播 + 反向传播
• 更新参数

# 训练网络
# 记得放在main中，不然会报错。
if __name__ == '__main__':
    for epoch in range(2):
        running_loss = 0.0
        for i, data in enumerate(trainloader, 0):
            # 输入数据
            inputs, labels = data
            inputs, labels = Variable(inputs), Variable(labels)

            # 梯度清零
            optimizer.zero_grad()

            # 前向和反向传播 forward + backward
            outputs = net(inputs)
            loss = criterion(outputs, labels)
            loss.backward()

            # 更新参数
            optimizer.step()

            # 打印log信息
            running_loss += loss.item()
            # 每2000个batch打印一次训练状态
            if i % 2000 == 1999:
                print('[%d, %5d] loss: %.3f' \
                      % (epoch + 1, i + 1, running_loss / 2000))
                running_loss = 0.0
    print('Finished Training')

1.5、测试网络

  1.5.1、由于1.4只训练了2个epoch(遍历完一遍数据集称为一个epoch)。

将测试图片输入网络，计算它的label，然后与实际label相比较。

•  首先显示实际的label

    # 将测试图片输入网络，计算它的label，然后与实际的label进行比较
    dataiter = iter(testloader)
    images, labels = dataiter.next()  # 返回4张图片及标签，如图
    print('实际的label：', ''.join(\
        '%08s' % classes[labels[j]] for j in range(4)))
    image1 = show(tv.utils.make_grid(images / 2 - 0.5)).resize((400, 100))
    
    # 显示图片
    plt.imshow(image1)
    plt.show()

•    其次，计算网络预测的label（先在一部分图片上预测，再看整个测试集上的效果）

    # 在部分图片上的预测
    # 计算图片在每个类别上的分数
    outputs = net(Variable(images))
    # 得分最高的那个类
    _, predicted = t.max(outputs.data, 1)

    # 输出预测结果
    print('预测结果:', ' '.join('%5s' % classes[predicted[j]] for j in range(4)))

   

    # 在整个数据集上
    # 预测正确的图片数
    correct = 0
    # 总共的图片数
    total = 0
    for data in testloader:
        images, labels = data
        # 计算图片在每个类别上的分数
        outputs = net(Variable(images))
        # 得分最高的那个类
        _, predicted = t.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum()
    print('10000张测试集中的准确率为：%d %%' % (100 * correct / total))

最后，在GPU上训练

就像把Tensor从CPU转到GPU一样，模型也可以类似地从CPU转到GPU

if t.cuda.is_available():
    net.cuda()
    images = images.cuda()
    labels = labels.cuda()
    output = net(Variable(images))
    loss = criterion(output, Variable(labels))

 

总结：

• Tensor：类似numpy数组的数据结构，与numpy接口类似，可方便地相互转换。
• autograd/Variable：Variable封装了Tensor，并提供了自动求导功能
• nn：专门为神经网络设计的接口，提供了很多有用的功能（神经网络层，损失函数，优化器等）
• 神经网络训练：以CIFAR-10分类为例演示了神经网络的训练流程，包括数据加载、网络搭建、训练及测试。