alexnet 订阅
AlexNet是2012年ImageNet竞赛冠军获得者Hinton和他的学生Alex Krizhevsky设计的。也是在那年之后,更多的更深的神经网络被提出,比如优秀的vgg,GoogLeNet。 这对于传统的机器学习分类算法而言,已经相当的出色。 展开全文
AlexNet是2012年ImageNet竞赛冠军获得者Hinton和他的学生Alex Krizhevsky设计的。也是在那年之后,更多的更深的神经网络被提出,比如优秀的vgg,GoogLeNet。 这对于传统的机器学习分类算法而言,已经相当的出色。
信息
提出者
Hinton及其学生
类    型
神经网络
外文名
AlexNet
提出时间
2012
AlexNet模型简介
AlexNet中包含了几个比较新的技术点,也首次在CNN中成功应用了ReLU、Dropout和LRN等Trick。同时AlexNet也使用了GPU进行运算加速。AlexNet将LeNet的思想发扬光大,把CNN的基本原理应用到了很深很宽的网络中。AlexNet主要使用到的新技术点如下:(1)成功使用ReLU作为CNN的激活函数,并验证其效果在较深的网络超过了Sigmoid,成功解决了Sigmoid在网络较深时的梯度弥散问题。虽然ReLU激活函数在很久之前就被提出了,但是直到AlexNet的出现才将其发扬光大。(2)训练时使用Dropout随机忽略一部分神经元,以避免模型过拟合。Dropout虽有单独的论文论述,但是AlexNet将其实用化,通过实践证实了它的效果。在AlexNet中主要是最后几个全连接层使用了Dropout。(3)在CNN中使用重叠的最大池化。此前CNN中普遍使用平均池化,AlexNet全部使用最大池化,避免平均池化的模糊化效果。并且AlexNet中提出让步长比池化核的尺寸小,这样池化层的输出之间会有重叠和覆盖,提升了特征的丰富性。(4)提出了LRN层,对局部神经元的活动创建竞争机制,使得其中响应比较大的值变得相对更大,并抑制其他反馈较小的神经元,增强了模型的泛化能力。(5)使用CUDA加速深度卷积网络的训练,利用GPU强大的并行计算能力,处理神经网络训练时大量的矩阵运算。AlexNet使用了两块GTX 580 GPU进行训练,单个GTX 580只有3GB显存,这限制了可训练的网络的最大规模。因此作者将AlexNet分布在两个GPU上,在每个GPU的显存中储存一半的神经元的参数。因为GPU之间通信方便,可以互相访问显存,而不需要通过主机内存,所以同时使用多块GPU也是非常高效的。同时,AlexNet的设计让GPU之间的通信只在网络的某些层进行,控制了通信的性能损耗。 (6)数据增强,随机地从256*256的原始图像中截取224*224大小的区域(以及水平翻转的镜像),相当于增加了2*(256-224)^2=2048倍的数据量。如果没有数据增强,仅靠原始的数据量,参数众多的CNN会陷入过拟合中,使用了数据增强后可以大大减轻过拟合,提升泛化能力。进行预测时,则是取图片的四个角加中间共5个位置,并进行左右翻转,一共获得10张图片,对他们进行预测并对10次结果求均值。同时,AlexNet论文中提到了会对图像的RGB数据进行PCA处理,并对主成分做一个标准差为0.1的高斯扰动,增加一些噪声,这个Trick可以让错误率再下降1%。 [1]  AlexNet结构图(3张)
收起全文
精华内容
下载资源
问答
  • Alexnet培训师-MATLAB-AppDesigner-GUI 使用MATLAB创建和训练Alexnet神经网络数据集的GUI 描述 AlexNet是一个卷积神经网络,可以对来自ImageNet数据库的一百万张图像进行训练。 该网络深达8层,可以将图像分类为...
  • AlexNet在表情识别中准确率不高,对输入图像尺寸有限制,针对这些问题,提出了改进AlexNet网络的人脸表情识别算法。在AlexNet网络中引入多尺度卷积更加适用于小尺寸的表情图像,提取出不同尺度的特征信息,并在把多个低...
  • 通过这个演示,您可以学习从重新训练模型 (AlexNet) 到在其上应用 Grad-CAM 的工作流程。 [日本人] 使用CNN进行深度学习的分类判断准确率极高,被用于很多领域的自动图像判断。另一方面,也有人担心里面是一个黑...
  • AlexNet

    2021-08-08 15:03:32
    本文使用飞桨(PaddlePaddle)复现卷积神经网络AlexNet。 本人全部文章请参见:博客文章导航目录 本文归属于:经典CNN复现系列 2. AlexNet模型结构 2012年,Alex Krizhevsky等人提出的AlexNet以很大优势获得了...

    1. 前言

    本文使用飞桨(PaddlePaddle)复现卷积神经网络AlexNet。
    本人全部文章请参见:博客文章导航目录
    本文归属于:卷积神经网络复现系列

    2. AlexNet模型结构

    2012年,Alex Krizhevsky等人提出的AlexNet以很大优势获得了ImageNet比赛的冠军。这一成果极大的激发了产业界对神经网络的兴趣,开创了使用深度神经网络解决图像问题的途径。
    AlexNet包含5层卷积、2层LRN(Local Response Normalization)和3个全连接层。除最后一个全连接层外,每个卷积层和全连接层激活函数均为ReLU。同时,AlexNet使用了Dropout抑制过拟合,模型具体结构如下图所示。(示意图图中不包含LRN层,具体参见模型复现代码)
    图一
    AlexNet共包含8个模块,对输入227x227x3的图片依次进行如下处理:

    1. 11x11的96通道步长为4的卷积 + local_size为5的LRN +步长为2的3x3池化;
    2. 5x5的256通道padding为2group为2步长为1的卷积 + local_size为5的LRN + 步长为2的3x3池化;
    3. 3x3的384通道padding为1步长为1的卷积;
    4. 3x3的384通道padding为1步长为1的卷积;
    5. 3x3的256通道padding为1步长为1的卷积 + 步长为2的3x3池化;
    6. 4096个节点的全连接层 + 概率为0.5的Dropout;
    7. 4096个节点的全连接层 + 概率为0.5的Dropout;
    8. 节点数等于输出类别数的全连接输出层。

    其中除输出层外,所有卷积层和全链接层激活函数均为ReLU。

    3. AlexNet中的结构组件

    3.1 ReLU激活函数

    线性整流函数(Rectified Linear Unit, ReLU),又称修正线性单元,是一种人工神经网络中常用的激活函数。其数学表达式如下:
    f ( x ) = m a x ( 0 , x ) f(x) = max(0, x) f(x)=max(0,x)
    ReLU函数的导数在 x x x小于或等于0时等于0,在 x x x大于0时等于1.因此在自变量 x x x大于0时,神经网络上一层的梯度能够直接传导到下一层,避免了梯度消失现象。
    ReLU函数把自变量小于0时的函数值置为0,假设某一层神经元的输出中大于0和小于0的个数差不多,则使用ReLU函数作为激活函数可以关闭一半左右的神经元,使之处于非激活状态。因此ReLU函数保证了每一次网络中只有少部分神经元的参数被更新,这样做可以促进深度神经网络的收敛。

    3.2 最大池化(MaxPooling)

    池化(Pooling):把邻近的像素作为一个“池子”来重新考虑。
    最大池化(Max Pooling):对每一个邻近的像素组成的池子,选取最大值作为输出。
    实践证明,相比平均池化(Average Pooling,将每一个邻近的像素组成的池子,将池子中所有像素点的平均值作为输出),最大池化能够促进网络收敛。原因是在最大池化下,梯度直接传到到最大值,而不是平均分布到池子中的每一个元素,这样每次更新的参数将会进一步减少。
    深度学习实践发现有重叠的最大池化能够很好的克服过拟合问题,提升深度学习模型性能。可能的原因有两个:1. 最大池化相当于同时做了降采样和非线性操作;2. 池化层激活的神经元变少。

    3.3 随机丢弃(Dropout)

    为了避免系统参数更新过快导致过拟合,在利用训练样本更新参数时候,随机“丢弃”一定比例的神经元。被丢弃的神经元将不参加训练过程,这些神经元的输入和输出权重系数也不做更新,这样每次训练时,训练的网络架构都不一样,而这些不同的网络架构分享共通的权重系数。
    假设每个不同的网络均存在一定的过拟合情况,而这些过拟合方向基本是随机的。综合多个网络结构,可以使得整体网络的过拟合情况在一定程度上相互抵消,是的整体网络效果更好。

    3.4 局部响应归一化(LRN)

    LRN对局部神经元的活动创建竞争机制,使得其中响应比较大的值变得相对更大,并抑制其他反馈较小的神经元,增强了模型的泛化能力。LRN通过在相邻卷积核生成的特征图之间引入竞争,从而有些本来在特征图中显著的特征更显著,而在相邻的其他特征图中的特征被抑制,这样让不同卷积核产生的特征之间的相关性变小。
    深度学习实践确实证明LRN可以提高模型的泛化能力,但是提升的很少,甚至有一些研究者觉得LRN是一个“伪命题”,因而饱受争议,以至于后面不再使用。在PddlePaddle框架并没有实现LRN层(2021年11月3日更新:PaddlePaddle框架实现了LRN层,使用paddle.nn.LocalResponseNorm()即可创建LRN层,具体参见链接),本文为了还原AlexNet论文中提出的模型,参考了资料链接[4]中的实现方法。

    4. AlexNet模型复现

    使用飞桨(PaddlePaddle)复现AlexNet,首先实现LRN层。定义继承自paddle.nn.LayerLRN类,在__init__方法中初始化各模块,并在forward函数中实现LRN层计算流程。具体代码如下:

    # -*- coding: utf-8 -*-
    # @Time    : 2021/8/8 10:51
    # @Author  : He Ruizhi
    # @File    : alexnet.py
    # @Software: PyCharm
    
    import paddle
    
    
    class LRN(paddle.nn.Layer):
        """
        目前该网络已经很少使用了,这里为了原生的AlexNet而实现
        LRN实现参考链接:https://github.com/sloth2012/AlexNet/blob/master/AlexNet.ipynb
        """
        def __init__(self, local_size=1, alpha=1.0, beta=0.75, bias=1.0, ACROSS_CHANNELS=False):
            super(LRN, self).__init__()
            self.alpha = paddle.to_tensor(alpha)
            self.beta = paddle.to_tensor(beta)
            self.bias = paddle.to_tensor(bias)
            self.ACROSS_CHANNELS = ACROSS_CHANNELS
    
            if self.ACROSS_CHANNELS:
                self.average = paddle.nn.AvgPool3D(kernel_size=(local_size, 1, 1), stride=1,
                                                   padding=(int((local_size - 1.0) / 2), 0, 0))
            else:
                self.average = paddle.nn.AvgPool3D(kernel_size=local_size, stride=1,
                                                   padding=int((local_size - 1.0) / 2))
    
        def forward(self, x):
            if self.ACROSS_CHANNELS:
                div = x.pow(2).unsqueeze(1)
                div = self.average(div).squeeze(1)
                div = div.multiply(self.alpha).add(self.bias).pow(self.beta)
            else:
                div = x.pow(2)
                div = self.average(div)
                div = div.multiply(self.alpha).add(self.bias).pow(self.beta)
            x = x.divide(div)
            return x
    

    搭建AlexNet,定义继承自paddle.nn.LayerAlexNet类,在__init__方法中定义各卷积、池化、LRN和全连接层,在forward函数中实现网络前向计算流程。具体代码如下:

    class AlexNet(paddle.nn.Layer):
        """AlexNet模型搭建"""
        def __init__(self, num_classes=1000):
            super(AlexNet, self).__init__()
            # 第一个模块:11x11的96通道步长为4的卷积 + local_size为5的LRN +步长为2的3x3池化
            self.block1 = paddle.nn.Sequential(
                paddle.nn.Conv2D(in_channels=3, out_channels=96, kernel_size=11, stride=4),
                paddle.nn.ReLU(),
                LRN(local_size=5, alpha=1e-4, beta=0.75, ACROSS_CHANNELS=True),
                paddle.nn.MaxPool2D(kernel_size=3, stride=2)
            )
    
            # 第二个模块:5x5的256通道padding为2group为2步长为1的卷积 + local_size为5的LRN + 步长为2的3x3池化
            self.block2 = paddle.nn.Sequential(
                paddle.nn.Conv2D(in_channels=96, out_channels=256, kernel_size=5, groups=2, stride=1, padding=2),
                paddle.nn.ReLU(),
                LRN(local_size=5, alpha=1e-4, beta=0.75, ACROSS_CHANNELS=True),
                paddle.nn.MaxPool2D(kernel_size=3, stride=2)
            )
    
            # 第三个模块:3x3的384通道padding为1步长为1的卷积
            self.block3 = paddle.nn.Sequential(
                paddle.nn.Conv2D(in_channels=256, out_channels=384, kernel_size=3, stride=1, padding=1),
                paddle.nn.ReLU()
            )
    
            # 第四个模块:3x3的384通道padding为1步长为1的卷积
            self.block4 = paddle.nn.Sequential(
                paddle.nn.Conv2D(in_channels=384, out_channels=384, kernel_size=3, stride=1, padding=1),
                paddle.nn.ReLU()
            )
    
            # 第五个模块:33x3的256通道padding为1步长为1的卷积 + 步长为2的3x3池化
            self.block5 = paddle.nn.Sequential(
                paddle.nn.Conv2D(in_channels=384, out_channels=256, kernel_size=3, stride=1, padding=1),
                paddle.nn.ReLU(),
                paddle.nn.MaxPool2D(kernel_size=3, stride=2)
            )
    
            self.flatten = paddle.nn.Flatten()
    
            # 全连接层1
            self.block6 = paddle.nn.Sequential(
                paddle.nn.Linear(in_features=6*6*256, out_features=4096),
                paddle.nn.ReLU(),
                paddle.nn.Dropout(0.5)
            )
    
            # 全连接层2
            self.block7 = paddle.nn.Sequential(
                paddle.nn.Linear(in_features=4096, out_features=4096),
                paddle.nn.ReLU(),
                paddle.nn.Dropout(0.5)
            )
    
            # 输出层
            self.out_fc = paddle.nn.Linear(in_features=4096, out_features=num_classes)
    
        def forward(self, x):
            # 实现前向计算流程
            x = self.block1(x)
            x = self.block2(x)
            x = self.block3(x)
            x = self.block4(x)
            x = self.block5(x)
            x = self.flatten(x)
            x = self.block6(x)
            x = self.block7(x)
            self.out_fc(x)
            return x
    
    • 你也许会问我,搭建AlexNet为什么不在一个paddle.nn.Sequential中堆到底。原因有二:
    1. 将各个模块用paddle.nn.Sequential打包起来,而不将整个网络如此堆叠,可以更加清晰地查看和理解AlexNet网络结构;
    2. 建议使用这种在__init__方法中初始化各模块,在forward方法中实现前向计算流程的方式搭建神经网络,而不建议使用在paddle.nn.Sequential中堆叠网络,因为第一种方法网络搭建灵活度更高。
    • 类似ReLUMaxPool2D等无训练参数,且完全相同的模块可以只初始化一次,然后多次复用。甚至可以不用初始化,直接在forward前向计算函数中通过paddle.nn.functional.*调用相关函数。但是如果不在__init__函数中多次显式地定义出来,则在paddle.summary中无法清晰地看到模型结构。为了清晰地在paddle.summary中清晰地看到模型结构,本系列文章均会多次显式地初始化ReLUMaxPool2D等模块。

    实例化AlexNet,使用paddle.summary函数打印模型结构信息:

    if __name__ == '__main__':
        model = AlexNet()
        paddle.summary(model, input_size=(None, 3, 227, 227))
    

    模型结构信息如下:

    ----------------------------------------------------------------------------
     Layer (type)        Input Shape          Output Shape         Param #    
    ============================================================================
       Conv2D-1      [[1, 3, 227, 227]]     [1, 96, 55, 55]        34,944     
        ReLU-1        [[1, 96, 55, 55]]     [1, 96, 55, 55]           0       
      AvgPool3D-1   [[1, 1, 96, 55, 55]]   [1, 1, 96, 55, 55]         0       
         LRN-1        [[1, 96, 55, 55]]     [1, 96, 55, 55]           0       
      MaxPool2D-1     [[1, 96, 55, 55]]     [1, 96, 27, 27]           0       
       Conv2D-2       [[1, 96, 27, 27]]     [1, 256, 27, 27]       307,456    
        ReLU-2       [[1, 256, 27, 27]]     [1, 256, 27, 27]          0       
      AvgPool3D-2   [[1, 1, 256, 27, 27]] [1, 1, 256, 27, 27]         0       
         LRN-2       [[1, 256, 27, 27]]     [1, 256, 27, 27]          0       
      MaxPool2D-2    [[1, 256, 27, 27]]     [1, 256, 13, 13]          0       
       Conv2D-3      [[1, 256, 13, 13]]     [1, 384, 13, 13]       885,120    
        ReLU-3       [[1, 384, 13, 13]]     [1, 384, 13, 13]          0       
       Conv2D-4      [[1, 384, 13, 13]]     [1, 384, 13, 13]      1,327,488   
        ReLU-4       [[1, 384, 13, 13]]     [1, 384, 13, 13]          0       
       Conv2D-5      [[1, 384, 13, 13]]     [1, 256, 13, 13]       884,992    
        ReLU-5       [[1, 256, 13, 13]]     [1, 256, 13, 13]          0       
      MaxPool2D-3    [[1, 256, 13, 13]]      [1, 256, 6, 6]           0       
       Flatten-1      [[1, 256, 6, 6]]         [1, 9216]              0       
       Linear-1          [[1, 9216]]           [1, 4096]         37,752,832   
        ReLU-6           [[1, 4096]]           [1, 4096]              0       
       Dropout-1         [[1, 4096]]           [1, 4096]              0       
       Linear-2          [[1, 4096]]           [1, 4096]         16,781,312   
        ReLU-7           [[1, 4096]]           [1, 4096]              0       
       Dropout-2         [[1, 4096]]           [1, 4096]              0       
       Linear-3          [[1, 4096]]           [1, 1000]          4,097,000   
    ============================================================================
    Total params: 62,071,144
    Trainable params: 62,071,144
    Non-trainable params: 0
    ----------------------------------------------------------------------------
    Input size (MB): 0.59
    Forward/backward pass size (MB): 18.40
    Params size (MB): 236.78
    Estimated Total Size (MB): 255.77
    ----------------------------------------------------------------------------
    

    5. 参考资料链接

    1. https://aistudio.baidu.com/aistudio/projectdetail/2169490
    2. https://www.icourse163.org/learn/ZJU-1206573810?tid=1206902211#/learn/content?type=detail&id=1235286004&cid=1254982007
    3. https://papers.nips.cc/paper/2012/file/c399862d3b9d6b76c8436e924a68c45b-Paper.pdf
    4. https://github.com/sloth2012/AlexNet/blob/master/AlexNet.ipynb
    5. https://blog.csdn.net/qq_27825451/article/details/88745034
    6. https://zhuanlan.zhihu.com/p/29786939
    7. https://blog.csdn.net/sunbaigui/article/details/39938097
    展开全文
  • 本文介绍了如何在pytorch下搭建AlexNet,使用了两种方法,一种是直接加载预训练模型,并根据自己的需要微调(将最后一层全连接层输出由1000改为10),另一种是手动搭建。 构建模型类的时候需要继承自torch.nn.Module...
  • AlexNet模型介绍1.1 AlexNet的特点1.2 AlexNet的结构1.3 AlexNet参数数量2. AlexNet的PyTorch实现2.1 导入相应的包2.2 构建AlexNet网络2.3 加载数据集2.4 训练网络 1. AlexNet模型介绍 由于受到计算机性能的影响,...
  • AlexNet imagenet

    2018-11-07 14:28:42
    李飞飞的imagenet数据库下构建的AlexNet代码,可以实现针对任意图片的准确率判别和目标的检测
  • alexnet模型搭建,供初学者参考,本人小白,望有错指正
  • bvlc_alexnet.zip

    2020-02-11 12:17:24
    官方原版alexnet模型文件(包含部署描述文件),方便快速下载官方链接为https://github.com/BVLC/caffe/tree/master/models/bvlc_alexnet
  • pytorch预训练模型alexnet,pytorch预训练模型alexnet,pytorch预训练模型alexnet,pytorch预训练模型alexnet,pytorch预训练模型alexnet,pytorch预训练模型alexnet,pytorch预训练模型alexnet
  • AlexNet笔记

    2018-11-17 09:04:37
    AlexNet 是 Alex Krizhevsky、Ilya Sutskever 和 Geoffrey Hinton 创造了一个“大型的深 度卷积神经网络”,赢得了 2010 和 2012 ILSVRC(2012 年 ImageNet 大规模视觉识别挑战 赛)。2012 年是 CNN 首次实现 Top 5 ...
  • 【图像分类】实战——AlexNet实现图像分类(pytroch)用到的源码
  • Alexnet鲜花分类

    2018-08-03 15:15:14
    使用tflearn高层封装,用alexnet对鲜花数据集进行训练
  • pytorch 实现 alexnet

    2018-05-05 15:18:40
    =================pytorch 实现 alexnet ,图片集太大就不上传了
  • alexnet 网络搭建 tensorflow框架
  • alexnet工具箱

    2018-05-20 12:05:42
    alexnet工具箱下载,需在打开Matlab 找到alexnet所在路径
  • ALEXNET的实现代码

    2018-10-31 12:33:51
    根据validate_alexnet_on_imagenet.ipynb的内容即可实现
  • AlexNet 论文总结

    2021-01-06 18:13:25
    AlexNet 论文总结一、论文翻译摘要(一)引言(二)数据集(三)架构1. ReLU非线性2. 多GPU训练3. 局部响应归一化(LRN)4. 重叠池化5. 整体架构(四)减少过拟合1. 数据增强2. Dropout(五)学习细节(六)结果1. ...
  • alexnet-owt-4df8aa71.pth

    2020-05-27 17:55:57
    pytorch alexnet预训练模型,对应torchvision中的alexnet。有时候服务器下载会受到限制,可以下载到本地在转移到服务器上
  • alexnet-owt-4df8aa71.zip

    2020-03-15 10:01:07
    alexnet-owt-4df8aa71.pth pytorch分类alexnet预训练模型,可用于迁移学习
  • TensorFlow实现AlexNet.py

    2020-04-03 15:53:02
    AlexNet模型是Hinton的学生Alex Krizhevsky在2012年提出来的。AlexNet包含了几个比较新的技术点,也首次在CNN中成功应用了ReLU、Dropout和LRN等Trick。 AlexNet主要使用的新技术点如下: (1)成功使用ReLU作为CNN的...
  • 深度学习,神经网络,基于alexnet架构的神经网络训练以及测试代码,里面还有orl人脸数据库,本人自己写的,确定能用,可直接下载。要五十个字,废话不多说,就这样。
  • Alexnet_pytorch_单GPU

    2018-10-20 12:47:40
    使用Alexnet 网络,识别猫狗图片的分类。机子性能原因,只使用了22张图片,epoch 只迭代了10次,只实现了训练代码,纯学习pytorch,Alexnet用的
  • 预训练AlexNet模型参数

    2018-09-13 13:35:02
    深度学习AlexNet模型预训练参数,.npy格式,深度学习入门可尝试练习
  • Tensorflow实现AlexNet

    2017-12-28 16:07:57
    Tensorflow实现AlexNet,但是做了点修改,将最后一层的relu激活函数改成了sigmoid函数,主要是为了实现深度哈希
  • AlexNet翻译及原文

    2018-08-19 17:20:58
    本人翻译的AlexNet的翻译及原文。本人也是刚开始学习AlexNet的小白。翻译的不好请指教。
  • AlexNet的实现 ! ! ! 需要在ImageNet上进行评估 根据Alex Krizhevsky等人的论文“具有深卷积神经网络的ImageNet分类”,该项目是AlexNet的非官方实现,使用不带任何第3个库的C程序语言。 现在仅支持CPU 平台支援...
  • 1. AlexNet网络结构详解视频 2. 使用pytorch搭建AlexNet并针对花分类数据集进行训练 3. 使用tensorflow搭建AlexNet并针对花分类数据集进行训练 AlexNet是2012年ILSVRC 2012(ImageNet Large Scale Visual ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 31,252
精华内容 12,500
关键字:

alexnet

友情链接: simple-redis.zip