图像分类（AlexNet、Vgg、GoogLeNetV1-V3）

最新推荐文章于 2024-06-05 07:00:43 发布
最新推荐文章于 2024-06-05 07:00:43 发布
阅读量1.2k 收藏 2
点赞数 2
分类专栏： Python 机器学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hqh131360239/article/details/96965118
版权

1、预备知识

①卷积操作（卷积核其实是一个立方体，64*64*3通过100个3*3的卷积核得到64*64*100，再通过一个3*3的卷积得到64*64*1，这里padding=1，stride=1卷积后图像长宽不变）

我想表达的是，卷积核的默认维度是输入图像的通道数。

②池化操作（降维）

2、AlexNet网络

①5个卷积层+3个全连接层（5个卷积跟5个激活）

②ReLu非线性激活

③Max Pooling池化（一二五层有池化）

④Dropout regularization（丢弃正则化，Fc1，Fc2）

提速，防止过拟合，提高模型泛化能力

⑤LRN（局部响应归一化，一二层用）

举个例子：k,α，β都是超参数，i=10，N=96，n=5（邻域），第i=10卷积核处理结果（也就是通道）在x，y处的特征为a，归一化是其值与第8,9,10,11,12在该对应位置的特征值和有关。

流程输入卷积核卷积结果激活池化（3*3，s=2）LRN
Conv1224*224*348个11*11，s=4（2组）

55*55*48

（单核）

ReLu27*27*48YES
Conv227*27*48128个5*5，s=1，p=2

27*27*128

（单核）

ReLu13*13*128YES

Conv3

(交互)

13*13*256192个3*3，s=1，p=1

13*13*192

（单核）

ReLu  
Conv413*13*192

192个3*3，

s=1，p=1

13*13*192

（单核）

ReLu  
Conv513*13*192

128个3*3，

s=1，p=1

13*13*128

（单核）

ReLu6*6*128 

Fc1

6*6*128*2输出:4096    
Fc24096输出:4096    
Fc34096输出:1000    
SoftMax1000输出:1000    

3、VGG（核分解，5*5->2个3*3，7*7->3个3*3）

①vgg主要是核分解，大的卷积核全部分解成3*3的卷积核

vgg16vgg19
卷积-卷积-池化卷积-卷积-池化
卷积-卷积-池化卷积-卷积-池化
卷积-卷积-卷积-池化卷积-卷积--卷积-卷积-池化
卷积-卷积-卷积-池化卷积-卷积--卷积-卷积-池化
卷积-卷积-卷积-池化卷积-卷积--卷积-卷积-池化
全连接-全连接-全连接全连接-全连接-全连接

4、GoogLeNet

①Inception V1

思想：多尺度卷积核，增加网络宽度，引入1*1卷积降维，引入辅助分类器，取消主分类器全连接层

理解：9个inception组件，2个辅助分类器，1个主分类器，分别在第三个第六个第九个组件后，主分类器没有全连接层，预处理还用到LRN局部相应归一化。

补充：以前接触的都是2*2/2最大池化，没有接触过重叠池化，3*3/2，搞不清楚怎么padding的，有两种参数，SAME和VALID，第一种是不够除，补0，第二种是舍去（这里都是用SAME）例如：3*3--->2*2/s=2池化（SAME：2*2，VALID：1*1），3*3--->2*2/s=1池化（SAME：3*3，VALID：1*1）

输入图片：224*224*3--->通过64个卷积核7*7/s=2/p=3--->112*112*64--->池化---->56*56*64--->LRN---->64个1*1/s=1降维---->56*56*64---->192个3*3/s=1/p=1卷积--->56*56*192--->池化---->28*28*192（到此预处理结束，下面开始第一个Inception模块）输入：28*28*192 

64个1*1卷积--->28*28*64

96个1*1卷积（3*3的卷积预处理）--->28*28*96--->128个3*3的卷积--->28*28*128(p=1)

16个1*1卷积（5*5的卷积预处理）--->28*28*16--->32个5*5的卷积--->28*28*32(p=2)

3*3/s=1池化--->28*28*192---->32个1*1的卷积---->28*28*32（步长是1，SAME，池化后大小不变）

输出：28*28*256

②InceptionV2

思想：在V1的基础上增加了核分解（5*5分解成两个3*3的卷积核），增加了BN批归一化操作

BN(Batch Normalization)批归一化

在深度神经网络训练过程中使输入保存相同的分布，让其分布固定，提高收敛效率。白化操作，使每一层的输出都规范化到N(0,1),正态分布。

比如：Batch=32，64个卷积核，64次批归一化操作，每个卷积核对32张图片得到的结果进行一次批归一化操作。

②InceptionV3

思路：这个变化是最大的，V1-V2基本没怎么变，V3提出来3种Inception组件，非对称分解卷积核。同时取消了2个辅助分类器，添加一个新的辅助分类器（位置不同，具体这个论文中的参数表和实际代码不符，总共11个Inception组件，每个组件的输入输出代码中注释的很全）在V3中优化了池化操作，在降维的时候同时增加通道数（一般是卷积和池化串连，这里用一个Inception组件替代池化操作，第4个和第9个）

类型输入卷积核输出
Conv299*299*332个3*3/s=2149*149*32
Conv149*149*3232个3*3/s=1147*147*32
Conv 147*147*3264个3*3/s=1，p=1147*147*64
Pool（池化）147*147*643*3/s=273*73*64
Conv73*73*6480个1*173*73*80
Conv73*73*80192个3*3/s=171*71*192
Pool71*71*1923*3/s=235*35*192
3*Inception35*35*192

见代码

35*35*288
5*Inception35*35*288

见代码

17*17*768
2*Inception17*17*768见代码8*8*2048
Pool8*8*20488*81*1*2048
linear1*1*2048 1*1*1000
softmax1*1*1000 1*1*1000
def inception_v3_base(inputs, scope=None):
    end_points = {}  # 定义一个字典表保存某些关键节点供之后使用
    with tf.variable_scope(scope, 'InceptionV3', [inputs]):
        # 对三个参数设置默认值
        with slim.arg_scope([slim.conv2d, slim.max_pool2d, slim.avg_pool2d], stride=1, padding='VALID'):
            # 正式定义Inception V3的网络结构。
            # 输入299 x 299 x 3
            net = slim.conv2d(inputs, 32, [3, 3], stride=2, scope='Conv2d_1a_3x3')
            # 输出149 x 149 x 32
            net = slim.conv2d(net, 32, [3, 3], scope='Conv2d_2a_3x3')
            # 输出147 x 147 x 32
            net = slim.conv2d(net, 64, [3, 3], padding='SAME', scope='Conv2d_2b_3x3')
            # 输出147 x 147 x 64
            net = slim.max_pool2d(net, [3, 3], stride=2, scope='MaxPool_3a_3x3')
            # 输出73 x 73 x 64
            net = slim.conv2d(net, 80, [1, 1], scope='Conv2d_3b_1x1')
            # 输出73 x 73 x 80.
            net = slim.conv2d(net, 192, [3, 3], scope='Conv2d_4a_3x3')
            # 输出71 x 71 x 192.
            net = slim.max_pool2d(net, [3, 3], stride=2, scope='MaxPool_5a_3x3')
        # 输出35 x 35 x 192.
        '''上面部分代码一共有5个卷积层，2个池化层，实现了对图片数据的尺寸压缩，
        我看论文发现给出的框架图流程与源码不符？依源码为准！！！！
        InceptionV3提出了3个组件，但源码中不是完全相同，只是非常结构相似，卷积核数量不同
        '''
        # Inception模块
        with slim.arg_scope([slim.conv2d, slim.max_pool2d, slim.avg_pool2d], stride=1, padding='SAME'):
            # 第一种类型模块（第一个，4个分支，输入：35*35*192）
            with tf.variable_scope('Mixed_5b'):
                with tf.variable_scope('Branch_0'):
                    branch_0 = slim.conv2d(net, 64, [1, 1], scope='Conv2d_0a_1x1')
                # 输出尺寸35*35*64
                with tf.variable_scope('Branch_1'):
                    branch_1 = slim.conv2d(net, 48, [1, 1], scope='Conv2d_0a_1x1')
                    # 输出尺寸35*35*48
                    branch_1 = slim.conv2d(branch_1, 64, [5, 5], scope='Conv2d_0b_5x5')
                # 输出尺寸35*35*64
                with tf.variable_scope('Branch_2'):
                    branch_2 = slim.conv2d(net, 64, [1, 1], scope='Conv2d_0a_1x1')
                    # 输出尺寸35*35*64
                    branch_2 = slim.conv2d(branch_2, 96, [3, 3], scope='Conv2d_0b_3x3')
                    # 输出尺寸35*35*96
                    branch_2 = slim.conv2d(branch_2, 96, [3, 3], scope='Conv2d_0c_3x3')
                # 输出尺寸35*35*96
                with tf.variable_scope('Branch_3'):
                    branch_3 = slim.avg_pool2d(net, [3, 3], scope='AvgPool_0a_3x3')
                    # 输出尺寸35*35*192
                    branch_3 = slim.conv2d(branch_3, 32, [1, 1], scope='Conv2d_0b_1x1')
                # 输出尺寸35*35*32
                net = tf.concat([branch_0, branch_1, branch_2, branch_3], 3)
            # 输出尺寸35*35*256（64+64+96+32）
            # 第一种类型模块（第二个，4个分支，输入：35*35*256）
            with tf.variable_scope('Mixed_5c'):
                with tf.variable_scope('Branch_0'):
                    branch_0 = slim.conv2d(net, 64, [1, 1], scope='Conv2d_0a_1x1')
                # 输出尺寸35*35*64
                with tf.variable_scope('Branch_1'):
                    branch_1 = slim.conv2d(net, 48, [1, 1], scope='Conv2d_0b_1x1')
                    # 输出尺寸35*35*48
                    branch_1 = slim.conv2d(branch_1, 64, [5, 5], scope='Conv_1_0c_5x5')
                # 输出尺寸35*35*64
                with tf.variable_scope('Branch_2'):
                    branch_2 = slim.conv2d(net, 64, [1, 1], scope='Conv2d_0a_1x1')
                    # 输出尺寸35*35*64
                    branch_2 = slim.conv2d(branch_2, 96, [3, 3], scope='Conv2d_0b_3x3')
                    # 输出尺寸35*35*96
                    branch_2 = slim.conv2d(branch_2, 96, [3, 3], scope='Conv2d_0c_3x3')
                # 输出尺寸35*35*96
                with tf.variable_scope('Branch_3'):
                    branch_3 = slim.avg_pool2d(net, [3, 3], scope='AvgPool_0a_3x3')
                    # 输出尺寸35*35*192
                    branch_3 = slim.conv2d(branch_3, 64, [1, 1], scope='Conv2d_0b_1x1')
                # 输出尺寸35*35*64
                net = tf.concat([branch_0, branch_1, branch_2, branch_3], 3)
            # 输出35*35*288（64+64+96+64）
            # 第一种类型模块（第三个，4个分支，输入：35*35*288）
            with tf.variable_scope('Mixed_5d'):
                with tf.variable_scope('Branch_0'):
                    branch_0 = slim.conv2d(net, 64, [1, 1], scope='Conv2d_0a_1x1')
                with tf.variable_scope('Branch_1'):
                    branch_1 = slim.conv2d(net, 48, [1, 1], scope='Conv2d_0a_1x1')
                    branch_1 = slim.conv2d(branch_1, 64, [5, 5], scope='Conv2d_0b_5x5')
                with tf.variable_scope('Branch_2'):
                    branch_2 = slim.conv2d(net, 64, [1, 1], scope='Conv2d_0a_1x1')
                    branch_2 = slim.conv2d(branch_2, 96, [3, 3], scope='Conv2d_0b_3x3')
                    branch_2 = slim.conv2d(branch_2, 96, [3, 3], scope='Conv2d_0c_3x3')
                with tf.variable_scope('Branch_3'):
                    branch_3 = slim.avg_pool2d(net, [3, 3], scope='AvgPool_0a_3x3')
                    branch_3 = slim.conv2d(branch_3, 64, [1, 1], scope='Conv2d_0b_1x1')
                net = tf.concat([branch_0, branch_1, branch_2, branch_3], 3)
            # 输出35*35*288（64+64+96+64）

            # 第二种类型模块（第一个，3个分支，输入：35*35*288）（相当于一个池化操作）
            with tf.variable_scope('Mixed_6a'):
                with tf.variable_scope('Branch_0'):
                    branch_0 = slim.conv2d(net, 384, [3, 3], stride=2, padding='VALID', scope='Conv2d_1a_1x1')
                with tf.variable_scope('Branch_1'):
                    branch_1 = slim.conv2d(net, 64, [1, 1], scope='Conv2d_0a_1x1')
                    branch_1 = slim.conv2d(branch_1, 96, [3, 3], scope='Conv2d_0b_3x3')
                    branch_1 = slim.conv2d(branch_1, 96, [3, 3], stride=2, padding='VALID', scope='Conv2d_1a_1x1')
                with tf.variable_scope('Branch_2'):
                    branch_2 = slim.max_pool2d(net, [3, 3], stride=2, padding='VALID', scope='MaxPool_1a_3x3')
                net = tf.concat([branch_0, branch_1, branch_2], 3)
            # 输出17 x 17 x 768（384+96+288）
            # 第二种类型模块（第二个，4个分支，输入：17*17*768）
            with tf.variable_scope('Mixed_6b'):
                with tf.variable_scope('Branch_0'):
                    branch_0 = slim.conv2d(net, 192, [1, 1], scope='Conv2d_0a_1x1')
                with tf.variable_scope('Branch_1'):
                    branch_1 = slim.conv2d(net, 128, [1, 1], scope='Conv2d_0a_1x1')
                    branch_1 = slim.conv2d(branch_1, 128, [1, 7], scope='Conv2d_0b_1x7')
                    branch_1 = slim.conv2d(branch_1, 192, [7, 1], scope='Conv2d_0c_7x1')
                with tf.variable_scope('Branch_2'):
                    branch_2 = slim.conv2d(net, 128, [1, 1], scope='Conv2d_0a_1x1')
                    branch_2 = slim.conv2d(branch_2, 128, [7, 1], scope='Conv2d_0b_7x1')
                    branch_2 = slim.conv2d(branch_2, 128, [1, 7], scope='Conv2d_0c_1x7')
                    branch_2 = slim.conv2d(branch_2, 128, [7, 1], scope='Conv2d_0d_7x1')
                    branch_2 = slim.conv2d(branch_2, 192, [1, 7], scope='Conv2d_0e_1x7')
                with tf.variable_scope('Branch_3'):
                    branch_3 = slim.avg_pool2d(net, [3, 3], scope='AvgPool_0a_3x3')
                    branch_3 = slim.conv2d(branch_3, 192, [1, 1], scope='Conv2d_0b_1x1')
                net = tf.concat([branch_0, branch_1, branch_2, branch_3], 3)
            # 输出17*17*768（192+192+192+192，注意这里使用平均池化）
            # 第二种类型模块（第三个，4个分支，输入：17*17*768）
            with tf.variable_scope('Mixed_6c'):
                with tf.variable_scope('Branch_0'):
                    branch_0 = slim.conv2d(net, 192, [1, 1], scope='Conv2d_0a_1x1')
                with tf.variable_scope('Branch_1'):
                    branch_1 = slim.conv2d(net, 160, [1, 1], scope='Conv2d_0a_1x1')
                    branch_1 = slim.conv2d(branch_1, 160, [1, 7], scope='Conv2d_0b_1x7')
                    branch_1 = slim.conv2d(branch_1, 192, [7, 1], scope='Conv2d_0c_7x1')
                with tf.variable_scope('Branch_2'):
                    branch_2 = slim.conv2d(net, 160, [1, 1], scope='Conv2d_0a_1x1')
                    branch_2 = slim.conv2d(branch_2, 160, [7, 1], scope='Conv2d_0b_7x1')
                    branch_2 = slim.conv2d(branch_2, 160, [1, 7], scope='Conv2d_0c_1x7')
                    branch_2 = slim.conv2d(branch_2, 160, [7, 1], scope='Conv2d_0d_7x1')
                    branch_2 = slim.conv2d(branch_2, 192, [1, 7], scope='Conv2d_0e_1x7')
                with tf.variable_scope('Branch_3'):
                    branch_3 = slim.avg_pool2d(net, [3, 3], scope='AvgPool_0a_3x3')
                    branch_3 = slim.conv2d(branch_3, 192, [1, 1], scope='Conv2d_0b_1x1')
                net = tf.concat([branch_0, branch_1, branch_2, branch_3], 3)
            # 输出17*17*768
            # 第二种类型模块（第四个，4个分支，输入：17*17*768）
            with tf.variable_scope('Mixed_6d'):
                with tf.variable_scope('Branch_0'):
                    branch_0 = slim.conv2d(net, 192, [1, 1], scope='Conv2d_0a_1x1')
                with tf.variable_scope('Branch_1'):
                    branch_1 = slim.conv2d(net, 160, [1, 1], scope='Conv2d_0a_1x1')
                    branch_1 = slim.conv2d(branch_1, 160, [1, 7], scope='Conv2d_0b_1x7')
                    branch_1 = slim.conv2d(branch_1, 192, [7, 1], scope='Conv2d_0c_7x1')
                with tf.variable_scope('Branch_2'):
                    branch_2 = slim.conv2d(net, 160, [1, 1], scope='Conv2d_0a_1x1')
                    branch_2 = slim.conv2d(branch_2, 160, [7, 1], scope='Conv2d_0b_7x1')
                    branch_2 = slim.conv2d(branch_2, 160, [1, 7], scope='Conv2d_0c_1x7')
                    branch_2 = slim.conv2d(branch_2, 160, [7, 1], scope='Conv2d_0d_7x1')
                    branch_2 = slim.conv2d(branch_2, 192, [1, 7], scope='Conv2d_0e_1x7')
                with tf.variable_scope('Branch_3'):
                    branch_3 = slim.avg_pool2d(net, [3, 3], scope='AvgPool_0a_3x3')
                    branch_3 = slim.conv2d(branch_3, 192, [1, 1], scope='Conv2d_0b_1x1')
                net = tf.concat([branch_0, branch_1, branch_2, branch_3], 3)
            # 输出17*17*768
            # 第二种类型模块（第五个，4个分支，输入：17*17*768）
            with tf.variable_scope('Mixed_6e'):
                with tf.variable_scope('Branch_0'):
                    branch_0 = slim.conv2d(net, 192, [1, 1], scope='Conv2d_0a_1x1')
                with tf.variable_scope('Branch_1'):
                    branch_1 = slim.conv2d(net, 192, [1, 1], scope='Conv2d_0a_1x1')
                    branch_1 = slim.conv2d(branch_1, 192, [1, 7], scope='Conv2d_0b_1x7')
                    branch_1 = slim.conv2d(branch_1, 192, [7, 1], scope='Conv2d_0c_7x1')
                with tf.variable_scope('Branch_2'):
                    branch_2 = slim.conv2d(net, 192, [1, 1], scope='Conv2d_0a_1x1')
                    branch_2 = slim.conv2d(branch_2, 192, [7, 1], scope='Conv2d_0b_7x1')
                    branch_2 = slim.conv2d(branch_2, 192, [1, 7], scope='Conv2d_0c_1x7')
                    branch_2 = slim.conv2d(branch_2, 192, [7, 1], scope='Conv2d_0d_7x1')
                    branch_2 = slim.conv2d(branch_2, 192, [1, 7], scope='Conv2d_0e_1x7')
                with tf.variable_scope('Branch_3'):
                    branch_3 = slim.avg_pool2d(net, [3, 3], scope='AvgPool_0a_3x3')
                    branch_3 = slim.conv2d(branch_3, 192, [1, 1], scope='Conv2d_0b_1x1')
                net = tf.concat([branch_0, branch_1, branch_2, branch_3], 3)
                # 输出17*17*768
                end_points['Mixed_6e'] = net
            # 辅助模型的分类
            # 第三种类型模块（第一个，3个分支，输入：17*17*768）（相当于一个池化操作）
            with tf.variable_scope('Mixed_7a'):
                with tf.variable_scope('Branch_0'):
                    branch_0 = slim.conv2d(net, 192, [1, 1], scope='Conv2d_0a_1x1')
                    branch_0 = slim.conv2d(branch_0, 320, [3, 3], stride=2,
                                           padding='VALID', scope='Conv2d_1a_3x3')
                with tf.variable_scope('Branch_1'):
                    branch_1 = slim.conv2d(net, 192, [1, 1], scope='Conv2d_0a_1x1')
                    branch_1 = slim.conv2d(branch_1, 192, [1, 7], scope='Conv2d_0b_1x7')
                    branch_1 = slim.conv2d(branch_1, 192, [7, 1], scope='Conv2d_0c_7x1')
                    branch_1 = slim.conv2d(branch_1, 192, [3, 3], stride=2, padding='VALID', scope='Conv2d_1a_3x3')
                with tf.variable_scope('Branch_2'):
                    branch_2 = slim.max_pool2d(net, [3, 3], stride=2, padding='VALID', scope='MaxPool_1a_3x3')
                net = tf.concat([branch_0, branch_1, branch_2], 3)
            # 输出尺寸8*8*（320+192+768）=8*8*1280
            # 第三种类型模块（第二个，4个分支，输入：8*8*1280）区别分支内又有分支
            with tf.variable_scope('Mixed_7b'):
                with tf.variable_scope('Branch_0'):
                    branch_0 = slim.conv2d(net, 320, [1, 1], scope='Conv2d_0a_1x1')
                with tf.variable_scope('Branch_1'):  # 第二个分支里还有分支
                    branch_1 = slim.conv2d(net, 384, [1, 1], scope='Conv2d_0a_1x1')
                    branch_1 = tf.concat([
                        slim.conv2d(branch_1, 384, [1, 3], scope='Conv2d_0b_1x3'),
                        slim.conv2d(branch_1, 384, [3, 1], scope='Conv2d_0b_3x1')], 3)
                with tf.variable_scope('Branch_2'):
                    branch_2 = slim.conv2d(net, 448, [1, 1], scope='Conv2d_0a_1x1')
                    branch_2 = slim.conv2d(
                        branch_2, 384, [3, 3], scope='Conv2d_0b_3x3')
                    branch_2 = tf.concat([
                        slim.conv2d(branch_2, 384, [1, 3], scope='Conv2d_0c_1x3'),
                        slim.conv2d(branch_2, 384, [3, 1], scope='Conv2d_0d_3x1')], 3)
                with tf.variable_scope('Branch_3'):
                    branch_3 = slim.avg_pool2d(net, [3, 3], scope='AvgPool_0a_3x3')
                    branch_3 = slim.conv2d(branch_3, 192, [1, 1], scope='Conv2d_0b_1x1')
                net = tf.concat([branch_0, branch_1, branch_2, branch_3], 3)
            # 输出8*8*2048（320+（384+384）+（384+384）+192）
            # 第三种类型模块（第三个，4个分支，输入：8*8*2048）
            with tf.variable_scope('Mixed_7c'):
                with tf.variable_scope('Branch_0'):
                    branch_0 = slim.conv2d(net, 320, [1, 1], scope='Conv2d_0a_1x1')
                with tf.variable_scope('Branch_1'):
                    branch_1 = slim.conv2d(net, 384, [1, 1], scope='Conv2d_0a_1x1')
                    branch_1 = tf.concat([
                        slim.conv2d(branch_1, 384, [1, 3], scope='Conv2d_0b_1x3'),
                        slim.conv2d(branch_1, 384, [3, 1], scope='Conv2d_0c_3x1')], 3)
                with tf.variable_scope('Branch_2'):
                    branch_2 = slim.conv2d(net, 448, [1, 1], scope='Conv2d_0a_1x1')
                    branch_2 = slim.conv2d(
                        branch_2, 384, [3, 3], scope='Conv2d_0b_3x3')
                    branch_2 = tf.concat([
                        slim.conv2d(branch_2, 384, [1, 3], scope='Conv2d_0c_1x3'),
                        slim.conv2d(branch_2, 384, [3, 1], scope='Conv2d_0d_3x1')], 3)
                with tf.variable_scope('Branch_3'):
                    branch_3 = slim.avg_pool2d(net, [3, 3], scope='AvgPool_0a_3x3')
                    branch_3 = slim.conv2d(
                        branch_3, 192, [1, 1], scope='Conv2d_0b_1x1')
                net = tf.concat([branch_0, branch_1, branch_2, branch_3], 3)
            # 输出8*8*2048（320+768+768+192）
            return net, end_points

 

AQH~
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
图像分类之AlexNet
weixin_45963617的博客
06-29 239
一、AlexNet使用的策略： 1.ReLU Nonlinearity ReLU函数：f(x)=max(0,x) 具有ReLUs的深卷积神经网络比具有tanh单元的深卷积神经网络训练速度快几倍。 2.Training on Multiple GPUs 一个GTX580GPU只有3GB的内存，这限制了可以在它上训练的网络的最大大小。事实证明，120万个训练实例足以训练出一个GPU无法容纳的网络。因此，我们在两个GPU上分布。当前的GPU特别适合于跨GPU并行化，因为它们能够直接读写彼此的内存，而不必经过主机内
imagenet-vgg-verydeep-19.zip
08-20
《深度学习中的图像风格迁移：基于Tensorflow 1.14的VGG-19模型实践》 在当今的计算机视觉领域，图像风格迁移是一种备受关注的技术，它能够将一张图像的内容保留，同时赋予其另一张图像的艺术风格。在这个主题中，...
卷积神经网络AlexNet-VGG-GoogLeNet详解
步步心愿的博客
02-24 780
文章目录深度卷积神经网络（AlexNet）AlexNet载入数据集训练使用重复元素的网络（VGG）VGG11的简单实现⽹络中的⽹络（NiN）GoogLeNetGoogLeNet模型 深度卷积神经网络（AlexNet） LeNet: 在大的真实数据集上的表现并不尽如⼈意。 1.神经网络计算复杂。 2.还没有⼤量深⼊研究参数初始化和⾮凸优化算法等诸多领域。 机器学习的特征提取:手工定义的特征提取函数...
[数据集][图像分类]茶叶叶子病害分类数据集304张4类别
最新发布
FL1623863129的博客
06-05 216
类别名称:[“anthracnose”,“bird_eye_spot”,“brown_blight”,“healthy”]特别声明：本数据集不对训练的模型或者权重文件精度作任何保证，数据集只提供准确且合理分类存放。数据集格式：仅仅包含jpg图片，每个类别文件夹下面存放着对应图片。数据集类型：图像分类用，不可用于目标检测无标注文件。图片数量(jpg文件个数)：304。重要说明：图片都是单个叶子。
经典的卷积神经网络(LeNet5 & AlexNet & VGG & GoogLeNet & InceptionNet & MobileNet)
hxxjxw的博客
05-17 557
LeNet5 AlexNet VGG GoogLeNet-1
鉴定AlexNet、ZFNet、VGG、GoogLeNet等热门卷积神经网络
qq_52952304的博客
09-22 485
本文旨在解析前几年部分经典神经网络的实现结构，需要一些优化算法、全神经网络等储备知识，有不明白的可以向我提问。
【深度学习】经典的卷积神经网络模型介绍（LeNet、AlexNet、VGGNet、GoogLeNet、ResNet和MobileNet）
热门推荐
点赞的都能无bug通过！
03-17 4万+
经典的卷积神经网络模型介绍卷积神经网络简介一、LeNet1、INPUT层-输入层2、C1层-卷积层3、S2层-池化层（下采样层）4、C3层-卷积层5、S4层-池化层（下采样层）6、C5层-卷积层7、F6层-全连接层二、AlexNet1、AlexNet特点2、ReLu作为激活函数3、数据增强4、层叠池化5、局部相应归一化6、Dropout7、Alex网络结构8、AlexNet参数数量三、VGG net1、VGG的特点2、VGG网络结构3、VGG优缺点四、GoogLeNet1、GoogLeNet Incepet
imagenet-vgg-verydeep-19.mat
12-18
该资源为imagenet-vgg-verydeep-19.mat，可以在迁移学习的时候使用。必须要补充字数，我就再补两句。
基于 tensorflow+VGG-16 的图像分类识别算法
12-03
本次图像的分类识别实验采用的是基于 tensorflow+VGG-16 的图像分类识别模型。vgg是由 Simonyan 和 Zisserman 在文献《Very Deep Convolutional Networks for Large-Scale ImageRecognition》上提出的卷积神经网络...
VGG-图像分类.zip
04-16
利用keras实现VGG16模型，对猫狗图片进行二分类，附有24000张图片作为训练测试
VGG-16.rar_vgg_vgg-16_vgg网络_图像识别_深度学习
09-24
在ILSVRC比赛中，VGG-16模型在图像分类和定位任务上都取得了当时的顶尖水平。 VGG-16模型的架构可以分为几个部分：输入层、卷积层、池化层、全连接层和输出层。输入层接收图像数据，卷积层用于提取特征，池化层则...
【TensorFlow】使用AlexNet网络对图片进行识别分类
秋天
07-15 9490
AlexNet是2012年ImageNet竞赛冠军获得者Hinton和他的学生Alex Krizhevsky设计的。也是在那年之后，更多的更深的神经网络被提出，比如优秀的vgg，GoogLeNet。虽然时隔多年，但AlexNet经典依旧，本文就简单回顾一下AlexNet的网络结构。 一、AlexNet网络结构 由于当时硬件资源的限制，Hinton使用了两块GPU对AlexNet训练，即把输...
20210915 经典CNN结构简析：AlexNet、VGG、NIN、GoogLeNet、ResNet etc.
GAOSHIQI5322688的博客
09-15 139
经典CNN结构简析：AlexNet、VGG、NIN、GoogLeNet、ResNet etc. - 知乎
【学习笔记：AlexNet网络进行图像分类】
weixin_43431343的博客
11-20 2826
AlexNet论文下载： https://wmathor.com/usr/uploads/2019/05/3327542327.pdf AlexNet介绍： AlexNet是2012年ISLVRC2012竞赛的冠军网络，分类准确率由传统的70%+提升到80%+。它是由Hinton和他的学生Alex Krizhevsky设计的，在此之后，深度学习开始快速发展。 AlexNet网络结构及改进： 该网络的亮点在于： （1）首次利用 GPU 进行网络加速训练。 （2）使用了 ReLU 激活函数，而不是传统的 Si
深度学习pytorch实战二：AlexNet图像分类篇且官网提供花数据集分五类
qq_55433305的博客
11-08 2812
AlexNet图像分类篇且官网提供花数据集分五类， 5 种类型（雏菊，蒲公英，玫瑰，向日葵，郁金香）的花，先定义AlexNet网络模型，加载数据集并训练，训练集计算损失值loss，测试集计算accuracy，保存训练好的网络参数，利用训练好的网络参数后，用自己找的图像进行分类测试
VGG 与 GoogLeNet
milk_and_bread的博客
08-22 297
文章目录问题VGGGoogLeNetGoogleNet-Inceptionv1GoogLeNet家族网络退化原因 问题 VGG GoogLeNet GoogleNet-Inceptionv1 GoogLeNet家族 网络退化原因
深度学习-图像分类篇 P3.1AlexNet网络-pytorch
qq_44629163的博客
04-03 2694
哔哩哔哩视频链接 up主附的代码链接 （一）AlexNet网络介绍 1.1 简介 1、该网络的亮点： （1）使用传统的Sigmoid激活函数求导比较麻烦，而且在较深的网络中容易导致梯度消失现象，而ReLu函数能解决这两个问题。 （2）过拟合是指特征维度过多或模型设计过于复杂时训练的拟合函数，它能完美的预测几乎所有训练集，但对新数据的泛化能力差。 而该作者提出的Dropout能在网络正向传播过程中随机失活一部分神经元，相当于随机放弃了一部分参数，从而达到过拟合的状态。 （3）回顾公式： 1.2 网络结构介绍
深度学习经典网络解析图像分类篇（二）：AlexNet
与君共勉，一起学习
03-20 4928
深度学习经典网络解析（二）：AlexNet1.背景介绍2.ImageNet3.AlexNet3.1AlexNet简介3.2AlexNet网络架构3.2.1第一层（CONV1）3.2.2 MAX POOL1+NORM1层3.2.3第三层（CONV2）3.2.4 MAX POOL2+NORM2层3.2.5第三、四层（CONV3、CONV4）3.2.6第五层（CONV5）3.2.7MAX POOL3层3.2.8第六七八层—全连接层3.3AlexNet创新点3.3.1数据增强3.3.2 Dropout随机失活3.3
googlenet 和 VGG 比较
张洁的笔记
05-20 7829
googlenet 是2014年imagenet的冠军，同年还有VGG。因此在说googlenet之前，先回顾下VGG。 之前介绍过faster RCNN， faster RCNN底层的模型官方支持了VGG和ZF，同样在K80下，ZF大概是8fps的速度，而VGG大概是3fps，这无疑就说明了VGG有些重。再给个直观的感受，通常我们VGG的faster RCNN模型大概是400M左右，而goog...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值