pytorch实现cnn&图像分类器

1 pytorch实现神经网络

1.1 定义网络

从基类 nn.Module 继承过来，必须重载 def __init__() 和 def forward()

class Net(nn.Module):

    def __init__(self): #网络结构
        super(Net, self).__init__()
        # 1 input image channel, 6 output channels, 5x5 square convolution
        # kernel
        self.conv1 = nn.Conv2d(1, 6, 5)
        self.conv2 = nn.Conv2d(6, 16, 5)
        # an affine operation: 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): #前向传播
        # Max pooling over a (2, 2) window
        # 经过relu激活函数，再经过max_pool池化
        x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))
        # If the size is a square you can only specify a single number
        x = F.max_pool2d(F.relu(self.conv2(x)), 2)
        # 铺平
        x = x.view(-1, self.num_flat_features(x))

        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x

    def num_flat_features(self, x):
        size = x.size()[1:]  # all dimensions except the batch dimension
        num_features = 1
        for s in size:
            num_features *= s
        return num_features

1.2 parameters

Parameter - A kind of Tensor, that is automatically registered as a parameter when assigned as an attribute to a Module.

可以认为是一个 tensor，里面存的是每一层的参数

params = list(net.parameters())
print(len(params))
print(params[0].size())  # conv1's .weight

1.3 调用反向传播

其实就是一个自动求导的过程

input = torch.randn(1, 1, 32, 32)
out = net(input)
net.zero_grad() # 梯度清零
out.backward(torch.randn(1, 10)) #调用反向传播，括号里面的是贡献系数

1.4 损失函数

一个简单常用的损失函数，均方误差，nn.MSELoss

output = net(input)
target = torch.randn(10)  # a dummy target, for example
target = target.view(1, -1)  # make it the same shape as output
criterion = nn.MSELoss()

loss = criterion(output, target)
print(loss)

1.5 更改权重

反向传播应该从损失函数开始一层一层求导回去，然后更改权重

考虑正向传播

input -> conv2d -> relu -> maxpool2d -> conv2d -> relu -> maxpool2d
      -> view -> linear -> relu -> linear -> relu -> linear
      -> MSELoss
      -> loss

之前用c++实现过反向传播，底层其实很简单，就链式法则求导求回去然后更改权重就好了

而 pytorch 里面自动给你求导了

所以直接调用 loss.backward() 即可

net.zero_grad()     # zeroes the gradient buffers of all parameters

print('conv1.bias.grad before backward')
print(net.conv1.bias.grad)

loss.backward()

print('conv1.bias.grad after backward')
print(net.conv1.bias.grad)

输出：

conv1.bias.grad before backward
tensor([0., 0., 0., 0., 0., 0.])
conv1.bias.grad after backward
tensor([-0.0054,  0.0011,  0.0012,  0.0148, -0.0186,  0.0087])

最后就是更新神经网络的参数，更新规则有很多，类似于 SGD, Nesterov-SGD, Adam, RMSProp, 等。torch.optim 中实现了所有的方法。只需要会调库

import torch.optim as optim
#创建并定义一个optimizer
optimizer=optim.SGD(net.parameters(),lr=0.01)

#在训练过程中：
optimizer.zero_grad()   # 清空梯度
output = net(input)
loss = criterion(output, target)
loss.backward()
optimizer.step()    # 更新权重

2 pytorch 实现图像分类

图像分类器的实现步骤：

• 载入图像与预处理，变成我们愿意看到的 tensor
• 定义卷积神经网络以及损失函数
• 训练
• 测试

2.1 数据加载和预处理 Dataset & DataLoader

这部分东西还挺多的，特别是之后要会加载自己的数据集，细学一下

2.1.1 Dataset & DataLoader

在深度学习中训练模型都是小批量小批量地优化训练的，即每次都会从原数据集中取出一小批量进行训练，完成一次权重更新后，再从原数据集中取下一个小批量数据，然后再训练再更新。比如最常用的小批量随机梯度下降(Mini-Batch Gradient Descent,MBGD)。

毕竟原数据集往往很大，不可能一次性的全部载入模型，只能一小批一小批地载入。训练完了就扔了，再加载下一小批。

在PyTorch的torch.utils.data包中定义了两个类Dataset和DataLoader，这两个类就是用来批量地加载数据的。

看看其用法：

2.1.2 准备数据

在使用Dataset和DataLoader之前需要先准备好数据，这里随即构造了一段数据：

# 自己编造一个数据集
import pandas as pd
import numpy as np

data = np.random.rand(128,3)
data = pd.DataFrame(data, columns=['feature_1', 'feature_2', 'label'])

数据形式如下：

或者，如果有数据，也可以这样读取：

data = pd.read_csv('data/diabetes.csv')  # 'data/diabetes.csv' 是我的数据的路径

2.1.3 写一个简单的数据加载器

import numpy as np
import pandas as pd
import torch 
# utils是工具包
from torch.utils.data import Dataset  # Dataset是个抽象类，只能用于继承
from torch.utils.data import DataLoader # DataLoader需实例化，用于加载数据


class MyDataset(Dataset):   # 继承Dataset类
    def __init__(self, df): 
        # 把数据和标签拿出来
        # value返回为np的arry, 转化成tensor
        self.x_data = torch.tensor(df.iloc[:,:2].values) 
        #等价于 self.x_data = torch.tensor(df[['feature_1', 'feature_2']].values)
        self.y_data = torch.tensor(df.iloc[:,2].values) 
        # 等价于 self.y_data = torch.tensor(df[['label']].values)

        # 数据集的长度
        self.length = len(self.y_data)
        
    # 下面两个魔术方法比较好写，直接照着这个格式写就行了 
    def __getitem__(self, index): # 参数index必写
        return self.x_data[index], self.y_data[index]
    
    def __len__(self): 
        return self.length # 只需返回数据集的长度即可

# 实例化
my_dataset = MyDataset(data) 
train_loader = DataLoader(dataset=my_dataset, # 要传递的数据集
                          batch_size=32, #一个小批量数据的大小是多少
                          shuffle=True, # 数据集顺序是否要打乱，一般是要的。测试数据集一般没必要
                          num_workers=0) # 需要几个进程来一次性读取这个小批量数据，默认0，一般用0就够了，多了有时会出一些底层错误。

2.1.4 使用数据加载器来训练模型

for epoch in range(100): 
	
	# ---------------主要看这两行代码------------------
    for i, data in enumerate(train_loader): 
        # 1. 数据准备
        inputs, labels = data 
    # ---------------主要看这两行代码------------------
        
        # 2. 前向传播 
        y_pred = model(inputs) 
        loss = criterion(y_pred, labels)
        # 3. 反向传播
        loss.backward() 
        # 4. 权重/模型更新 
        optimizer.step()
        # 5. 梯度清零
        optimizer.zero_grad() 

2.1.5 展示一些训练图片

挖个坑，还不太会

2.2 加载并归一化 CIFAR10

使用 torchvision ,用它来加载 CIFAR10 数据非常简单。

import torch
import torchvision
import torchvision.transforms as transforms

torchvision 数据集的输出是范围在[0,1]之间的 PILImage，我们将他们转换成归一化范围为[-1,1]之间的张量 Tensors。

transform = transforms.Compose(
    [transforms.ToTensor(),
     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])

trainset = torchvision.datasets.CIFAR10(root='./data', train=True,
                                        download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,
                                          shuffle=True, num_workers=2)

testset = torchvision.datasets.CIFAR10(root='./data', train=False,
                                       download=True, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=4,
                                         shuffle=False, num_workers=2)

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

2.3 定义一个神经网络

现在我们想写一个网络来训练出一个分类器，然后实现 CIFAR10 数据的分类

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

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(3, 6, 5) #3通道 6个卷积核 核大小为5*5
        self.pool = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(6, 16, 5)
        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 = self.pool(F.relu(self.conv1(x)))
        x = self.pool(F.relu(self.conv2(x)))
        x = x.view(-1, 16 * 5 * 5) #这里需要铺平
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x

net = Net() #实例化

2.4 定义损失函数和优化器

损失函数选择分类交叉熵Cross-Entropy

优化器选择 SGD

import torch.optim as optim

criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)

2.5 训练网络

for epoch in range(2):  # loop over the dataset multiple times

    running_loss = 0.0
    for i, data in enumerate(trainloader, 0):
        # 取 1 batch的数据来训练
        inputs, labels = data

        # 优化器中的梯度清零
        optimizer.zero_grad()

        # forward + backward + optimize
        outputs = net(inputs) #前向传播
        loss = criterion(outputs, labels) #损失函数
        loss.backward() #反向传播
        optimizer.step() #更修权重

        # print statistics
        running_loss += loss.item()
        if i % 2000 == 1999:    # print every 2000 mini-batches
            print('[%d, %5d] loss: %.3f' %
                  (epoch + 1, i + 1, running_loss / 2000))
            running_loss = 0.0

print('Finished Training')

2.6 测试网络

（之前程设课手搓的cnn在测试这一部分做的就挺烂的23333

测试就是在测试集上跑前向传播，然后看看表现

correct = 0
total = 0
with torch.no_grad(): 
    for data in testloader:
        images, labels = data
        outputs = net(images)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

print('Accuracy of the network on the 10000 test images: %d %%' % (
    100 * correct / total))