机器学习课程总结2--卷积神经网络基础

最新推荐文章于 2024-06-14 10:39:52 发布

GEMSarah

最新推荐文章于 2024-06-14 10:39:52 发布

阅读量147

点赞数 1

文章标签：机器学习 python 人工智能神经网络

本文链接：https://blog.csdn.net/weixin_41968829/article/details/129734565

版权

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

一、深度学习平台介绍

随着人工智能的蓬勃发展，诸多深度学习平台被开发和广泛应用，下图介绍以Tensorflow和Pytorch为主流的多种深度学习平台。

二、卷积神经网络基础

1. 进化史

下图呈现了卷积神经网络的进化过程，起点是神经认知机模型，此时已经出现了卷积结构，经典的LeNet诞生于1998年。然而之后CNN的锋芒开始被SVM等手工设计的特征盖过。随着ReLU和dropout的提出以及GPU和大数据带来的历史机遇，CNN在2012年迎来了历史突破--AlexNet. 更多详细分析可参考: 卷积神经网络-进化史 | 从LeNet到AlexNet - 腾讯云开发者社区-腾讯云

2. 基本概念

<1> 全连接网络：链接权过多，难算难收敛，同时可能进入局部极小值，也容易产生过拟合问题 (e.g. 输入为96x96图像，要学习100个特征)

<2> 局部连接网络：顾名思义，只有一部分权值连接。部分输入和权值卷积

<3> 特征提取：特征提取是计算机视觉和图像处理中的一个概念。它指的是使用计算机提取图像信息，决定每个图像的点是否属于一个图像特征。特征提取的结果是把图像上的点分为不同的子集，这些子集往往属于孤立的点、连续的曲线或者连续的区域。

<4> 填充(Padding)：在矩阵的边界上填充一些值，以增加矩阵的大小，通常用0或者复制边界像素来进行填充。

<5> 步长(Stride)：卷积核移动的长度。

<6> 多通道卷积：输入彩色图像，一般都是RGB三个通道(channel)的，因此输入数据的维度一般有三个(长，宽，通道) 内容详细解析: http://t.csdn.cn/6kQbr

3. 卷积神经网络结构

卷积神经网络(Convolutional Neural Networks，CNN)是由纽约大学的Yann Lecun于1998年提出的，其本质是一个多层感知机，它是一类包含卷积计算且具有深度结构的前馈神经网络(Feedforward Neural Networks)，是深度学习(Deep Learning)的代表算法之一。卷积神经网络是一种特殊的多层神经网络，像其它的神经网络一样，卷积神经网络也使用一种反向传播算法来进行训练，不同之处在于网络的结构。

学习算法简介如下:

4. LeNet-5网络

LeNet-5由LeCun等人提出于1998年提出，是一种用于手写体字符识别的非常高效的卷积神经网络。出自论文《Gradient-Based Learning Applied to Document Recognition》

LetNet-5是一个较简单的卷积神经网络。上图显示了其结构：输入的二维图像（单通道），先经过两次卷积层到池化层，再经过全连接层，最后为输出层。整体上是：input layer->convulational layer->pooling layer->activation function->convulational layer->pooling layer->activation function->convulational layer->fully connect layer->fully connect layer->output layer.

整个 LeNet-5 网络总共包括7层（不含输入层），分别是：C1、S2、C3、S4、C5、F6、OUTPUT。具体每个层的详细介绍可参考: http://t.csdn.cn/WtwiI

LeNet5代码实现如下：

import torch
from torch import nn
from d2l import torch as d2l


class Reshape(torch.nn.Module):
    def forward(self, x):
        return x.view(-1, 1, 28, 28)

net = torch.nn.Sequential(
    Reshape(),
    nn.Conv2d(1, 6, kernel_size=5, padding=2), nn.Sigmoid(),
    nn.AvgPool2d(kernel_size=2, stride=2),
    nn.Conv2d(6, 16, kernel_size=5), nn.Sigmoid(),
    nn.AvgPool2d(kernel_size=2, stride=2),
    nn.Flatten(),
    nn.Linear(16 * 5 * 5, 120), nn.Sigmoid(),
    nn.Linear(120, 84), nn.Sigmoid(),
    nn.Linear(84, 10))

三、基本卷积神经网络

1. AlexNet

AlexNet网络结构相对简单，使用了8层卷积神经网络，前5层是卷积层，剩下的3层是全连接层，具体如下所示：

特点: (1) 池化层均采用最大池化; (2) 选用ReLU作为非线性环节激活函数; (3) 网络规模扩大，参数数量接近6000万; (4) 出现“多个卷积层+一个池化层”的结构。

AlexNet代码复现如下：

import time
import torch
from torch import nn, optim
import torchvision
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

class AlexNet(nn.Module):
    def __init__(self):
        super(AlexNet, self).__init__()
        self.conv = nn.Sequential(
            nn.Conv2d(1, 96, 11, 4), # in_channels, out_channels, kernel_size, stride, padding
            nn.ReLU(),
            nn.MaxPool2d(3, 2), # kernel_size, stride
            # 减小卷积窗口，使用填充为2来使得输入与输出的高和宽一致，且增大输出通道数
            nn.Conv2d(96, 256, 5, 1, 2),
            nn.ReLU(),
            nn.MaxPool2d(3, 2),
            # 连续3个卷积层，且使用更小的卷积窗口。除了最后的卷积层外，进一步增大了输出通道数。
            # 前两个卷积层后不使用池化层来减小输入的高和宽
            nn.Conv2d(256, 384, 3, 1, 1),
            nn.ReLU(),
            nn.Conv2d(384, 384, 3, 1, 1),
            nn.ReLU(),
            nn.Conv2d(384, 256, 3, 1, 1),
            nn.ReLU(),
            nn.MaxPool2d(3, 2)
        )
         # 这里全连接层的输出个数比LeNet中的大数倍。使用丢弃层来缓解过拟合
        self.fc = nn.Sequential(
            nn.Linear(256*5*5, 4096),
            nn.ReLU(),
            nn.Dropout(0.5),
            nn.Linear(4096, 4096),
            nn.ReLU(),
            nn.Dropout(0.5),
            # 输出层。由于这里使用Fashion-MNIST，所以用类别数为10，而非论文中的1000
            nn.Linear(4096, 10),
        )

    def forward(self, img):
        feature = self.conv(img)
        output = self.fc(feature.view(img.shape[0], -1))
        return output

2. VGG-16

vgg16总共有16层，13个卷积层和3个全连接层，第一次经过64个卷积核的两次卷积后，采用一次pooling，第二次经过两次128个卷积核卷积后，再采用pooling，再重复两次三个512个卷积核卷积后，再pooling，最后经过三次全连接。

特点: 网络规模进一步增大，参数数量约为1.38亿。由于各卷积层、池化层的超参数基本相同，整体结构呈现出规整的特点。随网络深入，高和宽衰减，通道数增多。代码实现如下所示：

from torch import nn

class Vgg16_net(nn.Module):
    def __init__(self):
        super(Vgg16_net, self).__init__()


        self.layer1=nn.Sequential(
            nn.Conv2d(in_channels=3,out_channels=64,kernel_size=3,stride=1,padding=1), #(32-3+2)/1+1=32   32*32*64
            nn.BatchNorm2d(64),
            #inplace-选择是否进行覆盖运算
            #意思是是否将计算得到的值覆盖之前的值，比如
            nn.ReLU(inplace=True),
            #意思就是对从上层网络Conv2d中传递下来的tensor直接进行修改，
            #这样能够节省运算内存，不用多存储其他变量

            nn.Conv2d(in_channels=64,out_channels=64,kernel_size=3,stride=1,padding=1), #(32-3+2)/1+1=32    32*32*64
            #Batch Normalization强行将数据拉回到均值为0，方差为1的正太分布上，
            # 一方面使得数据分布一致，另一方面避免梯度消失。
            nn.BatchNorm2d(64),
            nn.ReLU(inplace=True),

            nn.MaxPool2d(kernel_size=2,stride=2)   #(32-2)/2+1=16         16*16*64
        )


        self.layer2=nn.Sequential(
            nn.Conv2d(in_channels=64,out_channels=128,kernel_size=3,stride=1,padding=1),  #(16-3+2)/1+1=16  16*16*128
            nn.BatchNorm2d(128),
            nn.ReLU(inplace=True),

            nn.Conv2d(in_channels=128,out_channels=128,kernel_size=3,stride=1,padding=1), #(16-3+2)/1+1=16   16*16*128
            nn.BatchNorm2d(128),
            nn.ReLU(inplace=True),

            nn.MaxPool2d(2,2)    #(16-2)/2+1=8     8*8*128
        )

        self.layer3=nn.Sequential(
            nn.Conv2d(in_channels=128,out_channels=256,kernel_size=3,stride=1,padding=1),  #(8-3+2)/1+1=8   8*8*256
            nn.BatchNorm2d(256),
            nn.ReLU(inplace=True),


            nn.Conv2d(in_channels=256,out_channels=256,kernel_size=3,stride=1,padding=1),  #(8-3+2)/1+1=8   8*8*256
            nn.BatchNorm2d(256),
            nn.ReLU(inplace=True),

            nn.Conv2d(in_channels=256,out_channels=256,kernel_size=3,stride=1,padding=1),  #(8-3+2)/1+1=8   8*8*256
            nn.BatchNorm2d(256),
            nn.ReLU(inplace=True),

            nn.MaxPool2d(2,2)     #(8-2)/2+1=4      4*4*256
        )

        self.layer4=nn.Sequential(
            nn.Conv2d(in_channels=256,out_channels=512,kernel_size=3,stride=1,padding=1),  #(4-3+2)/1+1=4    4*4*512
            nn.BatchNorm2d(512),
            nn.ReLU(inplace=True),

            nn.Conv2d(in_channels=512,out_channels=512,kernel_size=3,stride=1,padding=1),   #(4-3+2)/1+1=4    4*4*512
            nn.BatchNorm2d(512),
            nn.ReLU(inplace=True),

            nn.Conv2d(in_channels=512,out_channels=512,kernel_size=3,stride=1,padding=1),   #(4-3+2)/1+1=4    4*4*512
            nn.BatchNorm2d(512),
            nn.ReLU(inplace=True),

            nn.MaxPool2d(2,2)    #(4-2)/2+1=2     2*2*512
        )

        self.layer5=nn.Sequential(
            nn.Conv2d(in_channels=512,out_channels=512,kernel_size=3,stride=1,padding=1),   #(2-3+2)/1+1=2    2*2*512
            nn.BatchNorm2d(512),
            nn.ReLU(inplace=True),

            nn.Conv2d(in_channels=512,out_channels=512,kernel_size=3,stride=1,padding=1),  #(2-3+2)/1+1=2     2*2*512
            nn.BatchNorm2d(512),
            nn.ReLU(inplace=True),

            nn.Conv2d(in_channels=512,out_channels=512,kernel_size=3,stride=1,padding=1),  #(2-3+2)/1+1=2      2*2*512
            nn.BatchNorm2d(512),
            nn.ReLU(inplace=True),

            nn.MaxPool2d(2,2)   #(2-2)/2+1=1      1*1*512
        )


        self.conv=nn.Sequential(
            self.layer1,
            self.layer2,
            self.layer3,
            self.layer4,
            self.layer5
        )

        self.fc=nn.Sequential(
            #y=xA^T+b  x是输入,A是权值,b是偏执,y是输出
            #nn.Liner(in_features,out_features,bias)
            #in_features:输入x的列数  输入数据:[batchsize,in_features]
            #out_freatures:线性变换后输出的y的列数,输出数据的大小是:[batchsize,out_features]
            #bias: bool  默认为True
            #线性变换不改变输入矩阵x的行数,仅改变列数
            nn.Linear(512,512),
            nn.ReLU(inplace=True),
            nn.Dropout(0.5),

            nn.Linear(512,256),
            nn.ReLU(inplace=True),
            nn.Dropout(0.5),

            nn.Linear(256,10)
        )


    def forward(self,x):
        x=self.conv(x)
        #这里-1表示一个不确定的数，就是你如果不确定你想要reshape成几行，但是你很肯定要reshape成512列
        # 那不确定的地方就可以写成-1

        #如果出现x.size(0)表示的是batchsize的值
        # x=x.view(x.size(0),-1)
        x = x.view(-1, 512)
        x=self.fc(x)
        return x

3. 残差网络

在VGG中，卷积网络达到了19层，在GoogLeNet中，网络史无前例的达到了22层。那么，网络的精度会随着网络的层数增多而增多吗？在深度学习中，网络层数增多一般会伴着下面几个问题：计算资源的消耗；模型容易过拟合；梯度消失/梯度爆炸问题的产生；因此残差网络被提出以解决此类问题。

残差网络是由一系列残差块组成。残差网络的搭建分为两步：1. 使用VGG公式搭建Plain VGG网络；2. 在Plain VGG的卷积网络之间插入Identity Mapping，注意需要升维或者降维的时候加入 1×1 卷积。详细介绍可参考：http://t.csdn.cn/sBUTh

四、常用数据集

在卷积神经网络训练中，比较经典且常用的数据集包括: MNIST, Fashion-MNIST, PASCAL VOC, MS COCO, 和ImageNet等.

请添加图片描述

总结

以上就是今天要讲的内容，本文简单介绍了Tensorflow, PyTorch等深度学习平台，卷积神经网络基础，LeNet-5网络，以及AlexNet, VGG-16等基本卷积神经网络，并了解训练卷积神经网络的常用数据集。

GEMSarah

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
机器学习课程总结2--卷积神经网络基础

随着人工智能的蓬勃发展，诸多深度学习平台被开发和广泛应用，下图介绍以Tensorflow和Pytorch为主流的多种深度学习平台。二、卷积神经网络基础以上就是今天要讲的内容，本文简单介绍了Tensorflow, PyTorch等深度学习平台，卷积神经网络基础，LeNet-5网络，以及AlexNet, VGG-16等基本卷积神经网络，并了解训练卷积神经网络的常用数据集。
复制链接

扫一扫