用Pytorch搭建第一个神经网络且进行优化

最近一直在学习pytorch，这次自己跟着教程搭了一个神经网络，用的最经典的CIFAR10，先看一下原理

输入3通道32*32，最后经过3个卷积，3个最大池化，还有1个flatten，和两个线性化，得到十个输出

程序如下：

from torch import nn
from torch.nn import Conv2d, MaxPool2d, Flatten, Linear


class NetWork(nn.Module):
    def __init__(self):
        super(NetWork, self).__init__()
        self.conv1=Conv2d(3,32,5,padding=2)
        self.maxpool1=MaxPool2d(2)
        self.conv2=Conv2d(32,32,5,padding=2)
        self.maxpool2=MaxPool2d(2)
        self.conv3=Conv2d(32,64,5,padding=2)
        self.maxpool3=MaxPool2d(2)
        self.flatten=Flatten()
        self.linear1=Linear(1024,64)#1024=64*4*4
        self.linear2=Linear(64,10)


    def forward(self,x):
        x=self.conv1(x)
        x=self.maxpool1(x)
        x=self.conv2(x)
        x=self.maxpool2(x)
        x=self.conv3(x)
        x=self.maxpool3(x)
        x=self.flatten(x)
        x=self.linear1(x)
        x=self.linear2(x)
        return x


network=NetWork()
print(network)

这里我们还可以用tensorboard看一看，记得import

input=torch.ones((64,3,32,32))
output=network(input)


writer=SummaryWriter("logs_seq")
writer.add_graph(network,input)
writer.close()

在tensorboard中是这样的

打开NetWork

可以放大查看

神经网络都是有误差的，所以我们采用梯度下降来减少误差
代码如下

import torchvision.datasets
from torch import nn
from torch.nn import Sequential,Conv2d,MaxPool2d,Flatten,Linear
from torch.utils.data import DataLoader
import torch

dataset=torchvision.datasets.CIFAR10("./dataset2",train=False,transform=torchvision.transforms.ToTensor(),
                                     download=True)


dataloader=DataLoader(dataset,batch_size=1)

class NetWork(nn.Module):
    def __init__(self):
        super(NetWork, self).__init__()
        self.conv1=Conv2d(3,32,5,padding=2)
        self.maxpool1=MaxPool2d(2)
        self.conv2=Conv2d(32,32,5,padding=2)
        self.maxpool2=MaxPool2d(2)
        self.conv3=Conv2d(32,64,5,padding=2)
        self.maxpool3=MaxPool2d(2)
        self.flatten=Flatten()
        self.linear1=Linear(1024,64)#1024=64*4*4
        self.linear2=Linear(64,10)


        self.model1=Sequential(
            Conv2d(3,32,5,padding=2),
            MaxPool2d(2),
            Conv2d(32,32,5,padding=2),
            MaxPool2d(2),
            Conv2d(32, 64, 5, padding=2),
            MaxPool2d(2),
            Flatten(),
            Linear(1024, 64),
            Linear(64, 10)
        )

    def forward(self,x):
        # x=self.conv1(x)
        # x=self.maxpool1(x)
        # x=self.conv2(x)
        # x=self.maxpool2(x)
        # x=self.conv3(x)
        # x=self.maxpool3(x)
        # x=self.flatten(x)
        # x=self.linear1(x)
        # x=self.linear2(x)
        x=self.model1(x)
        return x


loss=nn.CrossEntropyLoss()
network=NetWork()
optim=torch.optim.SGD(network.parameters(),lr=0.01)##利用梯度下降作为优化器
for epoch in range(20):##循环20次
    running_loss=0.0
    for data in dataloader:
        imgs, targets=data
        outputs=network(imgs)
        result_loss=loss(outputs, targets)
        optim.zero_grad()##把每一次的下降值归零
        result_loss.backward()
        optim.step()
        running_loss=running_loss+result_loss
    	print(running_loss)

我电脑的GPU是RTX2060属于比较老的了，跑了三遍大概花了1分钟，实在太慢我就结束运行了
输出结果：

tensor(18733.7539, grad_fn=<AddBackward0>)
tensor(16142.7451, grad_fn=<AddBackward0>)
tensor(15420.9199, grad_fn=<AddBackward0>)

可以看出误差是在越来越小的，但是在应用中跑20层实在太少了，等我新电脑到了我跑100层