pytorch10实践(刘二大人)

今天来谈谈刘老师视频的第十讲，关于卷积神经网络的基础篇

mnist数据集是28*28的黑白图像，而图像可以用0~255的矩阵来表示，而卷积操作就是对矩阵进行对应数乘然后相加。

例如输入是5*5的矩阵，经过3*3卷积核卷积操作，得出一个3*3的输出矩阵。

而整个过程其实分为两大部分：

一、特征提取（Feature Extraction）

二、分类器（Classification）

特征提取又包含卷积和池化操作，分类器主要就是用全连接，再进行softmax操作得出概率分布。

 上图可以看出卷积核是一个四维张量（m(输入图像通道数),n(输出图像通道数),w(卷积核宽度),h(卷积核高度)），卷集层卷积核的宽度和高度一般取奇数，而池化层卷积核的宽度和高度一般取偶数。

然后还讲了两个变量padding和stride，padding代表是否在边界补充0,补充几层0，而stride代表卷积核移动步长。

最后讲了关于使用GPU加速的问题，需要注意的是先判断能否用GPU加速，然后将需要运算的张量都部署在同一块显卡上，这样不会报错

使用卷积神经网络来训练和验证MNIST数据集代码如下：

import torch
import matplotlib.pyplot as plt
from torchvision import datasets, transforms
from torch.utils.data import DataLoader

# 准备数据集
transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,))])
train_dataset = datasets.MNIST(root='../dataset/mnist/', train=True, transform=transform, download=True)
train_loader = DataLoader(dataset=train_dataset, batch_size=64, shuffle=True)
test_dataset = datasets.MNIST(root='../dataset/mnist/', train=False, transform=transform, download=True)
test_loader = DataLoader(dataset=test_dataset, batch_size=64, shuffle=False)


# 构建网络模型
class Net(torch.nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = torch.nn.Conv2d(in_channels=1, out_channels=10, kernel_size=(5, 5))
        self.conv2 = torch.nn.Conv2d(in_channels=10, out_channels=20, kernel_size=(5, 5))
        self.pool = torch.nn.MaxPool2d(kernel_size=(2, 2))
        self.linear = torch.nn.Linear(320, 10)
        self.relu = torch.nn.ReLU()

    def forward(self, x):
        batch_size = x.size(0)
        x = self.relu(self.pool(self.conv1(x)))
        x = self.relu(self.pool(self.conv2(x)))
        x = x.view(batch_size, -1)
        x = self.linear(x)
        return x


model = Net()
#判断能否使用GPU加速
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
model.to(device)

# 构建损失函数和优化器
Loss = torch.nn.CrossEntropyLoss()
Optim = torch.optim.SGD(model.parameters(), lr=0.01, momentum=0.5)


# 训练和测试
def train(epoch):
    running_loss = 0
    for batch_idx, data in enumerate(train_loader, 0):
        inputs, targets = data
        inputs = inputs.to(device)
        targets = targets.to(device)
        Optim.zero_grad()
        y_pred = model(inputs)
        loss = Loss(y_pred, targets)
        loss.backward()
        Optim.step()
        running_loss += loss.item()
        if batch_idx % 300 == 299:
            print('epoch:{},batch_idx:{},loss:{}'.format(epoch, batch_idx + 1, running_loss))
            running_loss = 0


def test():
    correct = 0
    total = 0
    with torch.no_grad():
        for data in test_loader:
            images, targets = data
            images = images.to(device)
            targets = targets.to(device)
            outputs = model(images)
            _,predict = torch.max(outputs.data,dim=1)
            total += targets.size(0)
            correct += (predict == targets).sum().item()
            acc = correct / total
    print('test acc : {} %'.format(100 * acc))
    return acc


if __name__ == '__main__':
    acc_list = []
    for epoch in range(20):
        train(epoch)
        acc = test()
        acc_list.append(acc)
    plt.plot(acc_list,color = (0,0.5,0.5))
    plt.xlabel('epoch')
    plt.ylabel('acc')
    plt.show()

 验证集上的准确率可视化结果为：

 

课后老师还留了练习：

 使用三层卷积层、池化层和全连接层，我所做的代码如下（我只用了一层全连接层）：在

import torch
import matplotlib.pyplot as plt
from torchvision import datasets,transforms
from torch.utils.data import DataLoader

#准备数据集
transform = transforms.Compose([transforms.ToTensor(),transforms.Normalize((0.1307,),(0.3081,))])
train_data = datasets.MNIST(root='../dataset/mnist/',train=True,transform=transform,download=True)
train_loader = DataLoader(dataset=train_data,batch_size=64,shuffle=True)
test_data = datasets.MNIST(root='../dataset/mnist/',train=False,transform=transform,download=True)
test_loader = DataLoader(dataset=test_data,batch_size=64,shuffle=False)


#构建模型
class Net(torch.nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = torch.nn.Conv2d(in_channels=1,out_channels=10,kernel_size=(3,3))
        self.conv2 = torch.nn.Conv2d(in_channels=10,out_channels=20,kernel_size=(3,3),padding=1)
        self.conv3 = torch.nn.Conv2d(in_channels=20,out_channels=30,kernel_size=(3,3))
        self.pooling = torch.nn.MaxPool2d(kernel_size=(2,2))
        self.relu = torch.nn.ReLU()
        self.linear = torch.nn.Linear(120,10)

    def forward(self,x):
        batch_size = x.size(0)
        x = self.relu(self.pooling(self.conv1(x)))
        x = self.relu(self.pooling(self.conv2(x)))
        x = self.relu(self.pooling(self.conv3(x)))
        x = x.view(batch_size,-1)
        x = self.linear(x)
        return x

model = Net()
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
model.to(device)

#损失函数和优化器
Loss = torch.nn.CrossEntropyLoss()
Optim = torch.optim.SGD(model.parameters(),lr=0.01,momentum=0.5)

#训练和测试
def train(epoch):
    running_loss = 0
    for batch_idx , data in enumerate(train_loader,0):
        inputs,outputs = data
        inputs,outputs = inputs.to(device),outputs.to(device)
        Optim.zero_grad()
        y_pred = model(inputs)
        loss = Loss(y_pred,outputs)
        loss.backward()
        Optim.step()
        running_loss += loss.item()
        if batch_idx%300==299:
            print('epoch:{},batch_idx:{},loss:{}'.format(epoch, batch_idx + 1, running_loss))
            running_loss = 0


def test():
    correct = 0
    total = 0
    with torch.no_grad():
        for data in test_loader:
            images,labels = data
            images,labels = images.to(device),labels.to(device)
            outputs = model(images)
            _,predict = torch.max(outputs.data,dim=1)
            total += labels.size(0)
            correct += (predict==labels).sum().item()
            acc = correct/total
        print('acc:',100*acc)
    return acc

if __name__ == '__main__':
    acc_list = []
    for epoch in range(20):
        train(epoch)
        acc = test()
        acc_list.append(acc)
    plt.plot(acc_list,color = (0,0.5,0.5))
    plt.xlabel('epoch')
    plt.ylabel('acc')
    plt.show()

在验证集上准确率可视化结果为：

对比两种网络结果结果差别不是很大。