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

最新推荐文章于 2025-07-03 15:30:53 发布
原创 最新推荐文章于 2025-07-03 15:30:53 发布 · 1.3k 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文详细介绍了卷积神经网络的基础概念及其在AlexNet、VGG和GoogLeNet中的应用。探讨了卷积操作、池化操作等核心原理，并深入分析了各网络的特点与创新之处。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

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

 

图像分类之AlexNet
weixin_45963617的博客
06-29 309
一、AlexNet使用的策略： 1.ReLU Nonlinearity ReLU函数：f(x)=max(0,x) 具有ReLUs的深卷积神经网络比具有tanh单元的深卷积神经网络训练速度快几倍。 2.Training on Multiple GPUs 一个GTX580GPU只有3GB的内存，这限制了可以在它上训练的网络的最大大小。事实证明，120万个训练实例足以训练出一个GPU无法容纳的网络。因此，我们在两个GPU上分布。当前的GPU特别适合于跨GPU并行化，因为它们能够直接读写彼此的内存，而不必经过主机内
【图像分类】实战——AlexNet实现图像分类（pytroch）
2301_81749759的博客
04-09 988
label = 1 if ‘dog’ in img_path.split(‘/’)[-1] else 0data = Image.open(img_path)data = self.transforms(data)return data, labeldef len(self):return len(self.imgs)然后我们在train.py调用DogCat读取数据dataset_train = DogCat(‘data/train’, transforms=transform, train=True)d
图像分类：从基础原理到前沿技术
最新发布
桃之夭夭的博客
07-03 1087
图像分类（Image Classification）是计算机视觉中的一项核心任务，其目标是将输入的图像自动分配到一个或多个预定义的类别标签中。简单来说，就是让计算机"看懂"图像内容并对其进行归类。技术定义：给定一个包含N个类别的分类系统，图像分类的任务是构建一个预测模型f，使得对于任意输入图像I，都能输出一个类别标签y∈{1,2,…,N}，或者输出一个概率分布p(y|I)，表示图像属于各个类别的可能性。图像分类作为计算机视觉的基础任务，在过去十年中取得了令人瞩目的进展。
卷积神经网络AlexNet-VGG-GoogLeNet详解
步步心愿的博客
02-24 929
文章目录深度卷积神经网络（AlexNet）AlexNet载入数据集训练使用重复元素的网络（VGG）VGG11的简单实现⽹络中的⽹络（NiN）GoogLeNetGoogLeNet模型 深度卷积神经网络（AlexNet） LeNet: 在大的真实数据集上的表现并不尽如⼈意。 1.神经网络计算复杂。 2.还没有⼤量深⼊研究参数初始化和⾮凸优化算法等诸多领域。 机器学习的特征提取:手工定义的特征提取函数...
pytorch图像分类实战:AlexNet 用于花朵分类
qq_51574420的博客
10-18 1185
随着训练的进行，模型受噪声影响大，模型过于精确。
【计算机视觉基础CV-图像分类】04 - 手把手教你实现AlexNet：卷积神经网络的里程碑及其实现，全面掌握图像分类的深度学习经典
weixin_41645791的博客
12-20 1337
在计算机视觉领域，深度学习的崛起是一个划时代的事件。回顾深度学习在图像识别方面的辉煌历程，就不能不提到AlexNet这座里程碑式的模型。2012年，Alex Krizhevsky等人提出的AlexNet在ImageNet竞赛中横空出世，将图像分类的Top-5错误率从近25%一下子拉低到16%左右，远超传统手工特征与浅层模型的表现。这一突破性进展引发了后续一系列深度卷积神经网络（CNN）的繁荣发展，从而开启了计算机视觉研究的新纪元。AlexNet架构图。
imagenet-vgg-verydeep-19.zip
08-20
《深度学习中的图像风格迁移：基于Tensorflow 1.14的VGG-19模型实践》 在当今的计算机视觉领域，图像风格迁移是一种备受关注的技术，它能够将一张图像的内容保留，同时赋予其另一张图像的艺术风格。在这个主题中，...
基于keras集成常见图像分类模型含VGG16-19、InceptionV3、Xception、MobileNet、AlexNet、LeNet、ZF-Net、ResNet、DenseNet.zip
12-04
基于keras集成多种图像分类模型含VGG16_19、InceptionV3、Xception、MobileNet、AlexNet、LeNet、ZF_Net、ResNet、DenseNet.zip 【项目介绍】 如下模型： VGG16 VGG19 InceptionV3 Xception MobileNet AlexNet LeNet...
imagenet-vgg-verydeep-19.mat
12-18
该资源为imagenet-vgg-verydeep-19.mat，可以在迁移学习的时候使用。必须要补充字数，我就再补两句。
Vgg deep network - 用于图像分类的 Matlab 代码 :Vgg deep network - 用于图像分类的 Matlab 代码 -(Visual Geometry Group)-matlab开发
05-29
视觉几何组 (VGG) - Matllab 代码 任何疑问请联系whatsapp - +91 9994444414 , josemebin@gmail.com
VGG-16.rar_vgg_vgg-16_vgg网络_图像识别_深度学习
09-24
在ILSVRC比赛中，VGG-16模型在图像分类和定位任务上都取得了当时的顶尖水平。 VGG-16模型的架构可以分为几个部分：输入层、卷积层、池化层、全连接层和输出层。输入层接收图像数据，卷积层用于提取特征，池化层则...
2024年最全【图像分类】 一文读懂AlexNet
2401_84692538的博客
05-01 1230
重叠最大池化（overlapping max pooling），即池化范围z与步长s存在关系z>s（如。pytorch的官方并没有严格按照AlexNet论文的实现，第一个卷积是64个卷积核，官方是96个。使用随机丢弃技术（dropout）选择性地忽略训练中的单个神经元，避免模型的过拟合。中核尺度为3×3/2），避免平均池化（average pooling）的平均效应。4、Pytorch官方实现。
深度学习图像分类实战——pytorch搭建卷积神经网络(AlexNet, LeNet, ResNet50)进行场景图像分类（详细）
m0_53328738的博客
12-19 6393
这个项目名称为“搭建卷积神经网络进行图像分类”，要求针对提供的场景图片数据集进行模型的训练，并对测试集进行场景类别的预测。 这个项目提供了 6700 张场景图像，包括了67种不同的场景。
经典的卷积神经网络(LeNet5 & AlexNet & VGG & GoogLeNet & InceptionNet & MobileNet)
hxxjxw的博客
05-17 615
LeNet5 AlexNet VGG GoogLeNet-1
现代神经网络总结(AlexNet VGG GoogleNet ResNet的区别与改进)
XXxia1XX的博客
04-28 1306
1.VGG，NIN，GoogleNet的块结构图对比(注意:无AlexNet)->神经网络越深,越复杂总能改进精度吗?在上面三层神经网络之后得到的疑惑。这些块带来的区别与细节。
鉴定AlexNet、ZFNet、VGG、GoogLeNet等热门卷积神经网络
qq_52952304的博客
09-22 572
本文旨在解析前几年部分经典神经网络的实现结构，需要一些优化算法、全神经网络等储备知识，有不明白的可以向我提问。
#Deep Learning回顾#之LeNet、AlexNet、GoogLeNet、VGG、ResNet
我爱机器学习
08-30 2636
Deep Learning一路走来，大家也慢慢意识到模型本身结构是Deep Learning研究的重中之重，而本文回顾的LeNet、AlexNet、GoogLeNet、VGG、ResNet又是经典中的经典。
CNN 常用的几个模型 LeNet5 AlexNet VGGNet Google Inception Net 微软ResNet残差神经网络
Dan的专栏
08-23 1万+
LeNet5 LeNet-5：是Yann LeCun在1998年设计的用于手写数字识别的卷积神经网络，当年美国大多数银行就是用它来识别支票上面的手写数字的，它是早期卷积神经网络中最有代表性的实验系统之一。 LenNet-5共有7层（不包括输入层），每层都包含不同数量的训练参数，如下图所示。  LeNet-5中主要有2个卷积层、2个下抽样层（池化层）、3个全连接层3种连接方式 卷积层  卷积...
【深度学习】经典的卷积神经网络模型介绍（LeNet、AlexNet、VGGNet、GoogLeNet、ResNet和MobileNet）
热门推荐
点赞的都能无bug通过！
03-17 5万+
经典的卷积神经网络模型介绍卷积神经网络简介一、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
TensorFlow与VGG-16融合实现高效图像分类
资源摘要信息:"基于 tensorflow+VGG-16 的图像分类识别算法" 1. 深入理解TensorFlow框架：TensorFlow是由Google开发的一个开源的机器学习库，用于进行数值计算和大规模机器学习，特别是在深度学习领域。它以数据流...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值