神经网络模型及卷积神经网络模型汇总

最新推荐文章于 2024-05-02 04:17:25 发布

mbws__

最新推荐文章于 2024-05-02 04:17:25 发布

阅读量996

点赞数

文章标签：神经网络 cnn 深度学习 Powered by 金山文档

本文链接：https://blog.csdn.net/mbws__/article/details/129147859

版权

神经网络

神经网络属于机器学习的一种算法，机器学习是我们解决人工智能领域很多问题所用到的一种手段。神经网络其实是属于深度学习技术的基础。

神经网络，就是一个由大量神经元组成，并且能够自动进行学习和计算过程，它可以通过模仿人类大脑，从而获得更加精准、快速、准确判断。

神经网络结构如下：

有哪些神经网络模型？

常见的深度学习算法主要有哪些？

卷积神经网络(ConvolutionalNeuralNetworks,CNN)是一类包含卷积计算且具有深度结构的前馈神经网络(FeedforwardNeuralNetworks)，是深度学习的代表算法之一。

循环神经网络(RecurrentNeuralNetwork,RNN)是一类以序列数据为输入，在序列的演进方向进行递归且所有节点(循环单元)按链式连接的递归神经网络。

生成对抗网络(GAN,GenerativeAdversarialNetworks)是一种深度学习模型，是最近两年十分热门的一种无监督学习算法。

有哪些卷积神经网络（CNN）模型？

对卷积神经网络的初步认识，可以点击http://t.csdn.cn/KWzHo进行了解。

卷积神经网络（LeNet)

模型结构：卷积层块，全链接层块

卷积层块：2个卷积层 + 最大池化层的结构组成。由于LeNet是较早的CNN，在每个卷积层 + 池化层后多会跟一个sigmod层来修正输出结果。而现在用的较多的是Relu。

全连接层块：输入为二维向量。单卷积层块的输出传入全连接层的时候会对小批量对每个样本进行扁平化（flatten）

LeNet 会随着网络的加深，宽度逐渐降低，通道逐渐增多。

import torch
from torch import nn


class LeNet(nn.Module):
    def __init__(self):
        self(LeNet, self).__init__()
        self.model = nn.Sequential(
            nn.Conv2d(3, 32, kernel_size=5, stride=1, padding=2),
            nn.MaxPool2d(2),
            nn.Conv2d(32, 32, kernel_size=5, stride=1, padding=2),
            nn.MaxPool2d(2),
            nn.Conv2d(32, 64, kernel_size=5, stride=1, padding=2),
            nn.MaxPool2d(2),
            nn.Flatten(),
            nn.Linear(64 * 4 * 4, 64),
            nn.Linear(64, 10)
        )

    def forward(self, x):
        x = self.model(x)
        return x

深度卷积神经网络（AlexNet）

模型结构：5层卷积 + 2层全连接隐藏层 + 1层全连接输出层

卷积层：前2个用的分别是11x11和5x5的卷积核，其余的都是3x3的卷积核。第一，第二，第五个卷积层后都使用了3x3，步幅为2 的最大池化层。

全连接层：2个输出个数为4096的全连接层携带着将近1GB的模型参数。

激活函数：AlexNet使用了Relu激活函数。相比于sigmod，Relu有着更简单的计算并且在不同初始化的情况下更容易训练。例如在一些特殊初始化下， sigmod在正区间的输出极度接近0，这会导致模型很难继续更新，而Relu在正区间的值恒为1。

过拟合：AlexNet使用了丢弃法来控制模型复杂度和防止过拟合。并且它用了大量的图象增广，包括翻转，裁剪，改变颜色等，来进一步防止过拟合。

网络中的网络（NiN）

模型结构： NiN块

NiN块：AlexNet是用多个卷积层 + 全连接层输出的结构，NiN提出了另一种思路，它通过将小块卷积层+“全连接”层串联组成网络。由于全连接层是二维而卷积层通常来说是四维的，所以NiN块使用1x1的卷积层代替全连接层（期中空间维度（高宽）上的每一个元素相当于样本，通道相当于特征）。每个卷积层与AlexNet类似，都是11x11， 5x5， 3x3.并且每个NiN块后接一个步幅为2，窗口大小为3x3的最大池化层。

相比AlexNet，NiN去掉了最后3个全连接层，使用输出通道等于标签类别的NiN块，然后使用全局平局池化层对每个通道中所有元素求平均并直接用于分类。这个好处是可以显著减小模型参数尺寸，但会造成训练时间的增加。

含有并行连接的网络（GoogLeNet）

Inception块：GoogLeNet的基础块，它借鉴NiN的网络串联网络的思路。在每个Inception块中包含4条并行线路。前3条分别使用1x1， 3x3， 5x5的卷积层来抽取不通空间尺度下的特征信息，期中第二三条线中先使用了1x1的卷积层来减少输入通道数，以降低模型复杂度。最后一条使用3x3的最大池化层接1x1的卷积层来改变通道数。4条线都适用合适的填充来保证输入和输出的高宽一致。

残差网络（ResNet)

残差块：一般来说对于激活函数的输入是神经网络一层层的计算的输出结果，但是由于网络的不断加深容易出现梯度不稳定（梯度爆炸，梯度消失）。随着网络的逐渐加深，误差并不会越来越小残差块的目的就是为了解决梯度不稳定。它通过一种跳跃的连接方式让输出结果需要参考输入结果。

使用重复元素的网络（VGG）

模型结构：VGG块 + 全连接层块

VGG块：卷积层 + 池化层，卷积层都是用相通的填充为1，3x3的卷积核接上一个步幅为2 ，窗口为2x2的最大池化层

全连接层块：输入为二维向量。单卷积层块的输出传入全连接层的时候会对小批量对每个样本进行扁平化（flatten）

VGG是个十分对称的网络，每层都成倍的增加或者减少。VGG将多个卷积层和其后的汇聚层打包起来，称作块。网络设计者在设计时可以自由选取块，像搭积木一样用各种块搭出一个网络。这样的思想在计算机领域非常常见，如底层的晶体管、逻辑门，编程语言中的函数、类、框架。

原始VGG网络有5个卷积块，其中前两个块各有⼀个卷积层，后三个块各包含两个卷积层。第⼀个模块有64个输出通道，每个后续模块将输出通道数量翻倍，直到该数字达到512。由于该网络使用8个卷积层和3个全连接层，因此它通常被称为VGG-11。

样例代码：

import torch
import torch.nn as nn
import torch.nn.functional
from torch import nn

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

        #3 * 28 * 28(crop-->32,28)
        self.conv1 = nn.Sequential(
            nn.Conv2d (2, 64, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU()
        )
        self.max_pooling1 = nn.MaxPool2d(kernel_size=3, stride=2)

        # 14* 14
        self.conv2 = nn.Sequential(
            nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(128),
            nn.ReLU()
        )
        self.conv2_2 = nn.Sequential(
            nn.Conv2d(128, 128, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(128),
            nn.ReLU()
        )

        self.max_pooling2 = nn.MaxPool2d(kernel_size=2, stride=2)

        #7*7
        self.conv3_1 = nn.Sequential(
            nn.Conv2d(128, 256, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(128),
            nn.ReLU()
        )
        self.conv3_2 = nn.Sequential(
            nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(256),
            nn.ReLU()
        )

        self.max_pooling3 = nn.MaxPool2d(kernel_size=2, stride=2, padding=1)

        #4*4
        self.conv4_1 = nn.Sequential(
            nn.Conv2d(256, 512, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(512),
            nn.ReLU()
        )
        self.conv4_2 = nn.Sequential(
            nn.Conv2d(256, 512, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(512),
            nn.ReLU()
        )

        self.max_pooling4 = nn.MaxPool2d(kernel_size=2, stride=2, padding=1)

        #batchzise*512*2*2-->batchsize *(512*4)
        self.fc = nn.Linear(512 * 4, 10)


    def forward(self, x):
        batchsize = x.size(0)
        out = self.conv1(x)
        out = self.max_pooling1(x)
        out =  self.conv2_1(out)
        out = self.conv2_2(out)
        out = self.max_pooling2(out)

        out = self.conv3_1(out)
        out = self.conv3_2(out)
        out = self.max_pooling3(out)

        out = self.conv4_1(out)
        out = self.conv4_2(out)
        out = self.max_pooling4(out)


        out = out.view(batchsize, -1)
        #转化为batchsize*n, 通过view来实现，-1自定义转化
        #batchsize*c * h * w-->batchsize * n

        out = self.fc(out)
        out = torch.nn.functional.log_softmax(out, dim=1)
        return out

def VGGNet():
    return VGGbase()