爸爸的乖女儿，打飞机，口交还让禸＃萝莉

序论

本文是使用pytorch对卷积神经相聚(Convolutional Neural Network， CNN)的代码达成，当作之前先容CNN旨趣的一个代码补充。

本文代码相干先容相对较为疑望，有失实的场所迎接指正。

本东谈主先容CNN旨趣的贯串:

[CNN旨趣先容1]

[ CNN旨趣先容2 ]

简述CNN结构

为浅近贯串，如下图所示(疑望先容看上方贯串)

图片

结构：一个卷积神经相聚由多少卷积层、Pooling层、全麇集层构成

历程庸俗贯串(卷积)：输入图片通过卷积核索求特征参数Feature Maps，此为卷积层的操作；

历程庸俗贯串(池化)：得到的特征参数经过池化层进行化简减少参数目，此为池化层的操作

历程庸俗贯串(全麇集)：将最终索求到的特征信息输入到全麇集神经相聚进行计较

情欲印象下载

上头图中一张图酿成了3张Feature Maps是因为Feature Maps数目跟图片通谈数关系，卷积核也相同是对应的，一个通谈对应一个卷积核

具体称呼的先容不错见:

竣工历程：step1 导入需要的包

import torch
import torch.nn as nn
import torch.utils.data as Data
from torch.autograd import Variable
import torchvision # pytorch的一个视觉处理器用包(需单独安设)

PyTorch中主要的包torch.nn ：包含用于构建神经相聚的模块和可推广类的子包。torch.autograd ：搭救PyTorch中通盘的可微张量运算的子包torch.nn.functional ：一种功能接口，包含用于构建神经相聚的典型操作，如耗费函数、激活函数和卷积运算torch.optim ：包含措施优化操作（如SGD和Adam）的子包。torch.utils ：器用包，包含数据集和数据加载措施等实用措施类的子包，使数据预处理更容易torchvision ：一个提供对流行数据集、模子架构和计较机视觉图像调理的探询的软件包

这些包可能代码中并未用到；

step2 数据预处理最初是对于将数据调理成tensor的原因

Tensor的意旨：Tensor之于PyTorch就好比是array之于Numpy粗略DataFrame之于Pandas，齐是构建了统共框架中最为底层的数据结构；

Tensor的离别：Tensor又与闲居的数据结构不同，具有一个极为关节的特质——自动求导况且它暗意一个多维矩阵，在计较方面还不错在GPU上使用以加快计较.

PyTorch中对于数据集的处理有三个相配进击的类：Dataset、Dataloader、Sampler，它们均是 torch.utils.data 包下的模块（类）Dataloader是数据的加载类爸爸的乖女儿，打飞机，口交还让禸＃萝莉，它是对于Dataset和Sampler的进一步包装，用于骨子读取数据，不错贯串为它是这个使命的真的施行者。

对于torchvision中的数据集

torchvision中datasets中通盘封装的数据集齐是torch.utils.data.Dataset的子类，它们齐不错用torch.utils.data.DataLoader进行数据加载。以datasets.MNIST类为例，具体参数和用法如下所示：

CLASS torchvision.datasets.MNIST(
          root: str， 
          train: bool = True， 
          transform: Optional[Callable] = None， 
          target_transform: Optional[Callable] = None， 
          download: bool = False
)

root (string)： 暗意数据集的根目次，其中根目次存在MNIST/processed/training.pt和MNIST/processed/test.pt的子目次(其实即是对下载的文献指定位置)

train (bool， optional)： 如果为True，则从training.pt创建数据集，不然从test.pt创建数据集

download (bool， optional)： 如果为True，则从internet下载数据集并将其放入根目次。如果数据集已下载，则不会再次下载

transform (callable， optional)： 接受PIL图片并复返调理后版块图片的调理函数(即是把图片粗略numpy中的数组调理成tensor)

target_transform (callable， optional)： 接受PIL接受方针并对其进行变换的调理函数

具体参考：

什么是Variable？

variable是tensor的封装，在神经采会聚，常需要反向传播这些的，是以需要各个节点是麇集在通盘的，是个计较图，tensor的数据口头就好比星星之火，然则无法汇聚通盘；等酿成variable之后就不错逐步燎原了。

代码分析

图片

Data.DataLoader：加载数据; shuffle：暗意打乱数据规章

torch.unsqueeze：个东谈主贯串即是转换数据shape，此处即是把检修数据蓝本是一维的给"竖"起来当作一条一条数据进行检修(等以后我念念起来更庸俗的再修改，具体函数用法看底下参考而已)

确定先容：

图像尺寸是28*28的，具体考证可见最底下我jupyter转成的html成果

step3 界说相聚结构

图片

Net需要剿袭自nn.Module，通过super（python中的超类）完成父类的开动化，个东谈主贯串类比于python中界说类要剿袭Object类，这么好多基础界说就不错略去了。

nn.Module是nn中十分进击的类，包含相聚各层的界说及forward方法。

nn.Sequential复返的是一个序列容器用于搭建神经相聚的模块，按照被传入构造器的规章添加到nn.Sequential()容器中，比如con1中即是进行封装先进行第一层的卷积和池化，conv2同理，然后界说前向传播(驻防是卷积两次) 。

nn.Conv2d： 在Pytorch的nn模块中，封装了nn.Conv2d()类当作二维卷积的达成，二维卷积应该是最常用的卷积相貌了。

对于相聚结构中历程梳理

对于卷积层nn.Conv2d中的参数先容：in_channels 输入图片的通谈数，同理out_channels为输出图片的通谈数(齐为自界说的，我征集而已看到有1，3，16，32等等)；kernel_size为卷积核大小，5 * 5不错径直简写，如果是3 * 5就要写成元组的体式；stride为卷积核迁移的步长；padding为填充的大小，具体意旨可见著述顶部旨趣先容

nn.ReLU()为激活函数，使用ReLU激活函数有经管梯度隐藏的作用(具体作用看著述顶部旨趣中有先容)

nn.MaxPool2d：maxpooling有局部不变性况且不错索求显赫特征的同期裁减模子的参数，从而裁减模子的过拟合，具体操作看下图，除了最大值，还不错取平均值

nn.Linear主淌若用于全麇集层

x.view()即是对tensor进行reshape：

对于卷积时候图片size的变化

最初输入通谈为1，尺寸大小为28 * 28，即(1，28，28)

经过卷积后因为自界说输出通谈为16，那么尺寸为(16，28，28)

经过池化层，因为卷积核是2 * 2的，是以尺寸裁减为(16，14，14)

不绝conv2卷积，池化后就尺寸酿成了(32，7，7)

nn.Linear具体用法(10是因为这个识别成果是0-9，为10个类别)：

对于输出尺寸的计较公式

O = （I - K + 2P）/ S +1

I输入尺寸，K是卷积核大小，P是padding大小，S是步长

step4 检修模子

图片

对于优化器torch.optim.Adam，个东谈主也还不是很是贯串注方针作用，此处待补充贯串

optimizer.zero_grad()对于优化器清空表层的梯度有先容是为了优化内存的 ：

有先容是一种tips特等不清零来进行梯度优化的总之照旧那句，优化器我搞懂了再补上...其实单纯论反向传播得时候梯度的更新貌似莫得说起是否需要清空表层梯度:

loss.backward()反向传播上头先容Variable的时候照旧讲过，照旧封装好了(看CNN旨趣部分反向传播求各个参数不同层级参数的偏导求得相似，成果在这里只需要调用api...)

torch.max 庸俗讲即是复返列表中最大的数，具体用法不错见最下方html文献

竣工代码

import torch
import torch.nn as nn
import torchvision 
import torch.utils.data as Data
 
torch.manual_seed(1)  # 设立当场种子， 用于复现
 
# 超参数
EPOCH = 1       # 前向后向传播迭代次数
LR = 0.001      # 学习率 learning rate 
BATCH_SIZE = 50 # 批量检修时候一次送入数据的size
DOWNLOAD_MNIST = True 
 
# 下载mnist手写数据集
# 检修集
train_data = torchvision.datasets.MNIST(  
    root = './MNIST/'，                      
    train = True，                            
    transform = torchvision.transforms.ToTensor()，                                                
    download=DOWNLOAD_MNIST 
)
 
# 测试集
test_data = torchvision.datasets.MNIST(root='./MNIST/'， train=False)  # train设立为False暗意赢得测试集
 
# 一个批检修 50个样本， 1 channel通谈， 图片尺寸 28x28 size:(50， 1， 28， 28)
train_loader = Data.DataLoader(
    dataset = train_data，
    batch_size=BATCH_SIZE，
    shuffle=True
) 
#  测试数据预处理；只测试前2000个
test_x = torch.unsqueeze(test_data.data，dim=1).float()[:2000] / 255.0
# shape from (2000， 28， 28) to (2000， 1， 28， 28)
test_y = test_data.targets[:2000]
 
class CNN(nn.Module):
    def __init__(self):
        super(CNN，self).__init__()
 
        self.conv1 = nn.Sequential(
            nn.Conv2d(                      # 输入的图片 （1，28，28）
                in_channels=1，
                out_channels=16，            # 经过一个卷积层之后 （16，28，28）
                kernel_size=5，
                stride=1，                    # 如果念念要 con2d 出来的图片长宽莫得变化， padding=(kernel_size-1)/2 当 stride=1
                padding=2
            )，
            nn.ReLU()，
            nn.MaxPool2d(kernel_size=2)      # 经过池化层处理，维度为（16，14，14）
        )
 
        self.conv2 = nn.Sequential(
            nn.Conv2d(                         # 输入（16，14，14）
                in_channels=16，
                out_channels=32，
                kernel_size=5，
                stride=1，
                padding=2
            )，                                 # 输出（32，14，14）
            nn.ReLU()，
            nn.MaxPool2d(kernel_size=2)        # 输出（32，7，7）
        )
 
        self.out = nn.Linear(32*7*7，10)
 
    def forward(self， x):
        x = self.conv1(x)                     #（batch_size，16，14，14）
        x = self.conv2(x)                     # 输出（batch_size，32，7，7）
        x = x.view(x.size(0)，-1)              # (batch_size，32*7*7)
        out = self.out(x)                     # (batch_size，10)
        return out
 
cnn = CNN()
optimizer = torch.optim.Adam(cnn.parameters()，lr=LR) # 界说优化器
loss_func = nn.CrossEntropyLoss() # 界说耗费函数
 
for epoch in range(EPOCH):
 
    for step，(batch_x，batch_y) in enumerate(train_loader):
        pred_y = cnn(batch_x)
        loss = loss_func(pred_y，batch_y)
        optimizer.zero_grad() # 清空上一层梯度
        loss.backward() # 反向传播
        optimizer.step() # 更新优化器的学习率，一般按照epoch为单元进行更新
 
        if step % 50 == 0:
            test_output = cnn(test_x)
            pred_y = torch.max(test_output， 1)[1].numpy()  # torch.max(test_out，1)复返的是test_out中每一瞥最大的数)
                                                                # 复返的体式为torch.return_types.max(
                                                                #           values=tensor([0.7000， 0.9000])，
                                                                #           indices=tensor([2， 2]))
                                                                # 背面的[1]代表赢得indices
            print('Epoch: '， epoch， '| train loss: %.4f' % loss.data.numpy())
 
 
# 打印前十个测试成果和真的成果进行对比
test_output = cnn(test_x[:10])
pred_y = torch.max(test_output， 1)[1].numpy()
print(pred_y， 'prediction number')
print(test_y[:10].numpy()， 'real number')

补充一个测试过程掌合手的小tips

比如使用anaconda中的jupyter测试，然则anaconda中又好多杜撰环境，若何将jupyter切换到测试用的杜撰环境呢需要注册，具体参考: 参考而已14比如我创建CNN测试环境是称呼是python36，而默许是python3也即是base环境，按照上述安设并注册后就不错切换啦

图片

附件

测试CNN代码的疑望要领html文献：爸爸的乖女儿，打飞机，口交还让禸＃萝莉

本站仅提供存储干事，通盘内容均由用户发布，如发现存害或侵权内容，请点击举报。