深度学习总结（lecture 9）Residual Network （ResNet）

最新推荐文章于 2024-10-08 00:09:18 发布
最新推荐文章于 2024-10-08 00:09:18 发布
阅读量2.4k 收藏 9
点赞数 4
分类专栏： 深度学习总结
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/malele4th/article/details/79405510
版权

lecture 9：Residual Network （ResNet）

目录

1、残差网络基础

这里写图片描述
这里写图片描述
这里写图片描述

1.1 VGG19、ResNet34结构图

这里写图片描述

1.2 ResNet残差块

考虑计算成本，对残差块做了计算优化，即将两个3x3的卷积层替换为1x1 + 3x3 + 1x1。

新结构中的中间3x3的卷积层首先在一个降维1x1卷积层下减少了计算，然后在另一个1x1的卷积层下做了还原，既保持了精度又减少了计算量。

ResNet在ImageNet2015夺得冠军
这里写图片描述

1.3 梯度弥散和网络退化

这里写图片描述
这里写图片描述
这里写图片描述
这里写图片描述

1.4 残差块变体

自AlexNet以来，state-of-the-art的CNN结构都在不断地变深。VGG和GoogLeNet分别有19个和22个卷积层，而AlexNet只有5个。

ResNet基本思想：引入跳过一层或多层的shortcut connection。

这里写图片描述

1.5 ResNet模型变体

（1）ResNeXt
这里写图片描述
这里写图片描述
（2）DenseNet
这里写图片描述
这里写图片描述
这里写图片描述

1.6 Residual Network补充

（1）short connect/skip connect
这里写图片描述
（2）残差网络表现好的原因
这里写图片描述
这里写图片描述

1.7 1*1卷积核

1*1的卷积核相当于对一个切片上的nc个单元，都应用了一个全连接的神经网络
这里写图片描述
这里写图片描述
这里写图片描述

2、ResNet（何凯明PPT）

这里写图片描述
这里写图片描述
这里写图片描述
这里写图片描述

3、ResNet-50（Ng）

3.1 非常深的神经网络问题

这里写图片描述
这里写图片描述

3.2 建立一个残差网络

使用 short connect的残差块，能很容易的学习标识功能。在其他ResNet块上进行堆栈，不会损害训练集的性能。

  • 残差块：主路径 + short connect
  • 残差块：indentity block & convolutional block，取决于输入/输出的尺寸是否相同

（1）identity block （标准块）
这里写图片描述
这里写图片描述
卷积层滤波器:

Filter1 : shape=[1,1], strides=[1,1], padding=’valid’, name=’2a’
Filter2: shape=[f,f], strides=[1,1], padding=’same’, name=’2b’
Filter3: shape=[1,1], strides=[1,1], padding=’valid’, name=’2c’

BatchNorm 归一化 channels axis

（2）convolutional block
当输入和输出的尺寸不匹配时，使用
这里写图片描述
Short connect 中的卷积层用于调整X的尺寸，使得匹配后面的加法。

Filter1 : shape=[1,1], strides=[s,s], padding=’valid’, name=’2a’
Filter2: shape=[f,f], strides=[1,1], padding=’same’, name=’2b’
Filter3: shape=[1,1], strides=[1,1], padding=’valid’, name=’2c’

Short connect Filter: shape=[1,1], strides=[s,s], ‘valid’, name=’1’

3.3 first ResNet model（50layers）

这里写图片描述
这里写图片描述

ResNet-50 每一层输出shape

卷积/池化前后图像大小：(n+2p-f)/s+1
这里写图片描述
这里写图片描述

3.4 代码

def identity_block(X, f, filters, stage, block):
    """
    X       -- 输入tensor, shape=(m, n_H_prev, n_W_prev, n_C_prev)
    f       -- identity block主路径，中间卷积层的滤波器大小
    filters -- [f1,f2,f3]对应主路径中三个卷积层的滤波器个数
    stage   -- 用于命名层，阶段（数字表示:1/2/3/4/5...）
    block   -- 用于命名层，每个阶段中的残差块（字符表示：a/b/c/d/e/f...）

    Return   X  -- identity block 输出tensor  shape=(m, n_H, n_W, n_C)    
    """

    "define name basis"
    conv_name_base = 'res' + str(stage) + block + '_branch'
    bn_name_base   = 'bn'  + str(stage) + block + '_branch'

    "get filter number"
    F1, F2, F3 = filters

    "save the input value"
    X_shortcut = X

    "主路径的第一层：conv-bn-relu"
    X = Conv2D(filters=F1, kernel_size=(1,1), strides=(1,1), padding='valid',
               name=conv_name_base+'2a', kernel_initializer=glorot_uniform(seed=0))(X)
    X = BatchNormalization(axis=3, name=bn_name_base+'2a')(X)
    X = Activation('relu')(X)

    "主路径的第二层：conv-bn-relu"
    X = Conv2D(filters=F2, kernel_size=(f,f), strides=(1,1), padding='same',
               name=conv_name_base+'2b', kernel_initializer=glorot_uniform(seed=0))(X)
    X = BatchNormalization(axis=3, name=bn_name_base+'2b')(X)
    X = Activation('relu')(X)

    "主路径的第三层：conv-bn"
    X = Conv2D(filters=F3, kernel_size=(1,1), strides=(1,1), padding='valid',
               name=conv_name_base+'2c', kernel_initializer=glorot_uniform(seed=0))(X)
    X = BatchNormalization(axis=3, name=bn_name_base+'2c')(X)

    "add shortcut and relu"
    X = Add()([X, X_shortcut])
    X = Activation('relu')(X)

    return X

"""s -- convolutional block中，主路径第一个卷积层和shortcut卷积层，滤波器滑动步长，s=2，用来降低图片大小"""
def convolutional_block(X, f, filters, stage, block, s=2):

    conv_name_base = 'res' + str(stage) + block + '_branch'
    bn_name_base   = 'bn'  + str(stage) + block + '_branch'

    F1, F2, F3 = filters

    X_shortcut = X

    "1st layer"
    X = Conv2D(filters=F1, kernel_size=(1,1), strides=(s,s), padding='valid',
               name=conv_name_base+'2a', kernel_initializer=glorot_uniform(seed=0))(X)
    X = BatchNormalization(axis=3, name=bn_name_base+'2a')(X)
    X = Activation('relu')(X)

    "2nd layer"
    X = Conv2D(filters=F2, kernel_size=(f,f), strides=(1,1), padding='same',
               name=conv_name_base+'2b', kernel_initializer=glorot_uniform(seed=0))(X)
    X = BatchNormalization(axis=3, name=bn_name_base+'2b')(X)
    X = Activation('relu')(X)

    "3rd layer"
    X = Conv2D(filters=F3, kernel_size=(1,1), strides=(1,1), padding='valid',
               name=conv_name_base+'2c', kernel_initializer=glorot_uniform(seed=0))(X)
    X = BatchNormalization(axis=3, name=bn_name_base+'2c')(X)

    "shortcut path"
    X_shortcut = Conv2D(filters=F3, kernel_size=(1,1), strides=(s,s), padding='valid',
            name=conv_name_base+'1', kernel_initializer=glorot_uniform(seed=0))(X_shortcut)
    X_shortcut = BatchNormalization(axis=3, name=bn_name_base+'1')(X_shortcut)

    X = Add()([X, X_shortcut])
    X = Activation('relu')(X)

    return X


def ResNet50(input_shape=(64,64,3), classes=6):
    """
    input - zero padding 
    stage1：conv - BatchNorm - relu - maxpool
    stage2: conv block - identity block *2
    stage3: conv block - identity block *3
    stage4: conv block - identity block *5
    stage5: conv block - identity block *2
    avgpool - flatten - fully connect

    input_shape  -- 输入图像的shape
    classes      -- 类别数

    Return： a model() instance in Keras
    """

    "用input_shape定义一个输入tensor"
    X_input = Input(input_shape)

    "zero padding"
    X = ZeroPadding2D((3,3))(X_input)

    "stage 1"
    X = Conv2D(filters=64, kernel_size=(7,7), strides=(2,2), padding='valid',
            name='conv1', kernel_initializer=glorot_uniform(seed=0))(X)
    X = BatchNormalization(axis=3, name='bn_conv1')(X)
    X = MaxPooling2D((3,3), strides=(2,2))(X)

    "stage 2"
    X = convolutional_block(X, f=3, filters=[64,64,256], stage=2, block='a', s=1)
    X = identity_block(X,f=3, filters=[64,64,256], stage=2, block='b')
    X = identity_block(X,f=3, filters=[64,64,256], stage=2, block='c')

    "stage 3"
    X = convolutional_block(X, f=3, filters=[128,128,512], stage=3, block='a', s=2)
    X = identity_block(X, f=3, filters=[128,128,512], stage=3, block='b')
    X = identity_block(X, f=3, filters=[128,128,512], stage=3, block='c')
    X = identity_block(X, f=3, filters=[128,128,512], stage=3, block='d')

    "stage 4"
    X = convolutional_block(X, f=3, filters=[256,256,1024], stage=4, block='a', s=2)
    X = identity_block(X, f=3, filters=[256,256,1024], stage=4, block='b')
    X = identity_block(X, f=3, filters=[256,256,1024], stage=4, block='c')
    X = identity_block(X, f=3, filters=[256,256,1024], stage=4, block='d')
    X = identity_block(X, f=3, filters=[256,256,1024], stage=4, block='e')
    X = identity_block(X, f=3, filters=[256,256,1024], stage=4, block='f')

    "stage 5"
    X = convolutional_block(X, f=3, filters=[512,512,2048], stage=5, block='a', s=2)
    X = identity_block(X, f=3, filters=[512,512,2048], stage=5, block='b')
    X = identity_block(X, f=3, filters=[512,512,2048], stage=5, block='c')

    "fully connect"
    X = AveragePooling2D((2,2), name='avg_pool')(X)
    X = Flatten()(X)
    X = Dense(classes, activation='softmax', name='fc'+str(classes),
              kernel_initializer=glorot_uniform(seed=0))(X)

    "a model() instance in Keras"
    model = Model(inputs=X_input, outputs=X, name='ResNet50')

    return model

4、ResNet 100-1000层

这里写图片描述

4.1 152层

这里写图片描述
这里写图片描述
这里写图片描述

4.2 1000层

这里写图片描述

4.3 何凯明paper

这里写图片描述
这里写图片描述
这里写图片描述

4.4代码

def ResNet101(input_shape=(64,64,3), classes=6):
    """
    input - zero padding 
    stage1：conv - BatchNorm - relu - maxpool
    stage2: conv block - identity block *2
    stage3: conv block - identity block *3
    stage4: conv block - identity block *22
    stage5: conv block - identity block *2
    avgpool - flatten - fully connect

    input_shape  -- 输入图像的shape
    classes      -- 类别数

    Return： a model() instance in Keras
    """

    "用input_shape定义一个输入tensor"
    X_input = Input(input_shape)

    "zero padding"
    X = ZeroPadding2D((3,3))(X_input)

    "stage 1"
    X = Conv2D(filters=64, kernel_size=(7,7), strides=(2,2), padding='valid',
            name='conv1', kernel_initializer=glorot_uniform(seed=0))(X)
    X = BatchNormalization(axis=3, name='bn_conv1')(X)
    X = MaxPooling2D((3,3), strides=(2,2))(X)

    "stage 2"
    X = convolutional_block(X, f=3, filters=[4,4,16], stage=2, block='a', s=1)
    X = identity_block(X,f=3, filters=[4,4,16], stage=2, block='b')
    X = identity_block(X,f=3, filters=[4,4,16], stage=2, block='c')

    "stage 3"
    X = convolutional_block(X, f=3, filters=[8,8,32], stage=3, block='a', s=2)
    X = identity_block(X, f=3, filters=[8,8,32], stage=3, block='b')
    X = identity_block(X, f=3, filters=[8,8,32], stage=3, block='c')
    X = identity_block(X, f=3, filters=[8,8,32], stage=3, block='d')

    "stage 4"
    "identity block from 5(50 layers) to 22(101 layers)"
    X = convolutional_block(X, f=3, filters=[16,16,64], stage=4, block='a', s=2)
    X = identity_block(X, f=3, filters=[16,16,64], stage=4, block='b')
    X = identity_block(X, f=3, filters=[16,16,64], stage=4, block='c')
    X = identity_block(X, f=3, filters=[16,16,64], stage=4, block='d')
    X = identity_block(X, f=3, filters=[16,16,64], stage=4, block='e')
    X = identity_block(X, f=3, filters=[16,16,64], stage=4, block='f')
    X = identity_block(X, f=3, filters=[16,16,64], stage=4, block='g')
    X = identity_block(X, f=3, filters=[16,16,64], stage=4, block='h')
    X = identity_block(X, f=3, filters=[16,16,64], stage=4, block='i')
    X = identity_block(X, f=3, filters=[16,16,64], stage=4, block='j')
    X = identity_block(X, f=3, filters=[16,16,64], stage=4, block='k')
    X = identity_block(X, f=3, filters=[16,16,64], stage=4, block='l')
    X = identity_block(X, f=3, filters=[16,16,64], stage=4, block='m')
    X = identity_block(X, f=3, filters=[16,16,64], stage=4, block='n')
    X = identity_block(X, f=3, filters=[16,16,64], stage=4, block='o')
    X = identity_block(X, f=3, filters=[16,16,64], stage=4, block='p')
    X = identity_block(X, f=3, filters=[16,16,64], stage=4, block='q')
    X = identity_block(X, f=3, filters=[16,16,64], stage=4, block='r')
    X = identity_block(X, f=3, filters=[16,16,64], stage=4, block='s')
    X = identity_block(X, f=3, filters=[16,16,64], stage=4, block='t')
    X = identity_block(X, f=3, filters=[16,16,64], stage=4, block='u')
    X = identity_block(X, f=3, filters=[16,16,64], stage=4, block='v')
    X = identity_block(X, f=3, filters=[16,16,64], stage=4, block='w')


    "stage 5"
    X = convolutional_block(X, f=3, filters=[32,32,128], stage=5, block='a', s=2)
    X = identity_block(X, f=3, filters=[32,32,128], stage=5, block='b')
    X = identity_block(X, f=3, filters=[32,32,128], stage=5, block='c')

    "fully connect"
    X = AveragePooling2D((2,2), name='avg_pool')(X)
    X = Flatten()(X)
    X = Dense(classes, activation='softmax', name='fc'+str(classes),
              kernel_initializer=glorot_uniform(seed=0))(X)

    "a model() instance in Keras"
    model = Model(inputs=X_input, outputs=X, name='ResNet101')

    return model


def ResNet152(input_shape=(64,64,3), classes=6):
    """
    input - zero padding 
    stage1：conv - BatchNorm - relu - maxpool
    stage2: conv block - identity block *2
    stage3: conv block - identity block *7
    stage4: conv block - identity block *35
    stage5: conv block - identity block *2
    avgpool - flatten - fully connect

    input_shape  -- 输入图像的shape
    classes      -- 类别数

    Return： a model() instance in Keras
    """

    "用input_shape定义一个输入tensor"
    X_input = Input(input_shape)

    "zero padding"
    X = ZeroPadding2D((3,3))(X_input)

    "stage 1"
    X = Conv2D(filters=64, kernel_size=(7,7), strides=(2,2), padding='valid',
            name='conv1', kernel_initializer=glorot_uniform(seed=0))(X)
    X = BatchNormalization(axis=3, name='bn_conv1')(X)
    X = MaxPooling2D((3,3), strides=(2,2))(X)

    "stage 2"
    X = convolutional_block(X, f=3, filters=[64,64,256], stage=2, block='a', s=1)
    X = identity_block(X,f=3, filters=[64,64,256], stage=2, block='b')
    X = identity_block(X,f=3, filters=[64,64,256], stage=2, block='c')

    "stage 3"
    "identity block from 3(101 layers) to 7(152 layers)"
    X = convolutional_block(X, f=3, filters=[128,128,512], stage=3, block='a', s=2)
    X = identity_block(X, f=3, filters=[128,128,512], stage=3, block='b')
    X = identity_block(X, f=3, filters=[128,128,512], stage=3, block='c')
    X = identity_block(X, f=3, filters=[128,128,512], stage=3, block='d')
    X = identity_block(X, f=3, filters=[128,128,512], stage=3, block='e')
    X = identity_block(X, f=3, filters=[128,128,512], stage=3, block='f')
    X = identity_block(X, f=3, filters=[128,128,512], stage=3, block='g')
    X = identity_block(X, f=3, filters=[128,128,512], stage=3, block='h')


    "stage 4"
    "identity block from 22(101 layers) to 35(152 layers)"
    X = convolutional_block(X, f=3, filters=[256,256,1024], stage=4, block='a', s=2)
    X = identity_block(X, f=3, filters=[256,256,1024], stage=4, block='b')
    X = identity_block(X, f=3, filters=[256,256,1024], stage=4, block='c')
    X = identity_block(X, f=3, filters=[256,256,1024], stage=4, block='d')
    X = identity_block(X, f=3, filters=[256,256,1024], stage=4, block='e')
    X = identity_block(X, f=3, filters=[256,256,1024], stage=4, block='f')
    X = identity_block(X, f=3, filters=[256,256,1024], stage=4, block='g')
    X = identity_block(X, f=3, filters=[256,256,1024], stage=4, block='h')
    X = identity_block(X, f=3, filters=[256,256,1024], stage=4, block='i')
    X = identity_block(X, f=3, filters=[256,256,1024], stage=4, block='j')
    X = identity_block(X, f=3, filters=[256,256,1024], stage=4, block='k')
    X = identity_block(X, f=3, filters=[256,256,1024], stage=4, block='l')
    X = identity_block(X, f=3, filters=[256,256,1024], stage=4, block='m')
    X = identity_block(X, f=3, filters=[256,256,1024], stage=4, block='n')
    X = identity_block(X, f=3, filters=[256,256,1024], stage=4, block='o')
    X = identity_block(X, f=3, filters=[256,256,1024], stage=4, block='p')
    X = identity_block(X, f=3, filters=[256,256,1024], stage=4, block='q')
    X = identity_block(X, f=3, filters=[256,256,1024], stage=4, block='r')
    X = identity_block(X, f=3, filters=[256,256,1024], stage=4, block='s')
    X = identity_block(X, f=3, filters=[256,256,1024], stage=4, block='t')
    X = identity_block(X, f=3, filters=[256,256,1024], stage=4, block='u')
    X = identity_block(X, f=3, filters=[256,256,1024], stage=4, block='v')
    X = identity_block(X, f=3, filters=[256,256,1024], stage=4, block='w')
    X = identity_block(X, f=3, filters=[256,256,1024], stage=4, block='x')
    X = identity_block(X, f=3, filters=[256,256,1024], stage=4, block='y')
    X = identity_block(X, f=3, filters=[256,256,1024], stage=4, block='z')
    X = identity_block(X, f=3, filters=[256,256,1024], stage=4, block='z1')
    X = identity_block(X, f=3, filters=[256,256,1024], stage=4, block='z2')
    X = identity_block(X, f=3, filters=[256,256,1024], stage=4, block='z3')
    X = identity_block(X, f=3, filters=[256,256,1024], stage=4, block='z4')
    X = identity_block(X, f=3, filters=[256,256,1024], stage=4, block='z5')
    X = identity_block(X, f=3, filters=[256,256,1024], stage=4, block='z6')
    X = identity_block(X, f=3, filters=[256,256,1024], stage=4, block='z7')
    X = identity_block(X, f=3, filters=[256,256,1024], stage=4, block='z8')
    X = identity_block(X, f=3, filters=[256,256,1024], stage=4, block='z9')
    X = identity_block(X, f=3, filters=[256,256,1024], stage=4, block='z10')

    "stage 5"
    X = convolutional_block(X, f=3, filters=[512,512,2048], stage=5, block='a', s=2)
    X = identity_block(X, f=3, filters=[512,512,2048], stage=5, block='b')
    X = identity_block(X, f=3, filters=[512,512,2048], stage=5, block='c')

    "fully connect"
    X = AveragePooling2D((2,2), name='avg_pool')(X)
    X = Flatten()(X)
    X = Dense(classes, activation='softmax', name='fc'+str(classes),
              kernel_initializer=glorot_uniform(seed=0))(X)

    "a model() instance in Keras"
    model = Model(inputs=X_input, outputs=X, name='ResNet152')

    return model
九方先生
关注
专栏目录
[nlp] 深度残差网络 ResNet（Residual Network）
心宝的博客
03-03 2014
在 AlexNet 取得 LSVRC 2012 分类竞赛冠军之后，深度残差网络（Residual Network, 下文简写为 ResNet）可以说是过去几年中计算机视觉和深度学习领域最具开创性的工作。ResNet 使训练数百甚至数千层成为可能，且在这种情况下仍能展现出优越的性能。 因其强大的表征能力，除图像分类以外，包括目标检测和人脸识别在内的许多计算机视觉应用都得到了性能提升。 ...
【DL】深度残差网络 Residual Network， ResNet
北境の守望者
05-29 614
Backto Model Zoo 缘起 直觉上：越深的网络representation能力越好，精度越高 理论上：深层网络应该达到至少不差于浅层网络的精度表现，因为让深层网络一部分与浅层网络等同，多余部分变成恒等 identity，二者效果就等同了。 实践中：随着深度的逐步增大，训练误差和测试误差反而会增大 思路 why？： 首先，不是 over-fitting 问题，因为训练误差也变...
ResNet 09
darren_pty
09-08 387
1989年，Yann LeCun提出了一种用反向传导进行更新的卷积神经网络，称为LeNet。1998年，Yann LeCun提出了一种用反向传导进行更新的卷积神经网络，称为LeNet-5AlexNet是2012年ISLVRC 2012（ImageNet Large Scale Visual Recognition Challenge）竞赛的冠军网络，分类准确率由传统的 70%+提升到 80%+。它是由Hinton和他的学生Alex Krizhevsky设计的。也是在那年之后，深度学习开始迅速发展。
【AI知识点】残差网络（ResNet，Residual Networks）
最新发布
虾米记的博客
10-08 1226
残差网络（ResNet，Residual Networks） 是由微软研究院的何凯明等人在 2015 年提出的一种深度神经网络架构，在深度学习领域取得了巨大的成功。它通过引入残差连接（Residual Connection） 解决了深层神经网络中的梯度消失（Vanishing Gradient） 问题，从而实现了对非常深层网络的有效训练。
Github项目-CNNResnet9-残差神经网络水果多分类项目
qq_29487479的博客
12-01 1203
【代码】Github项目-CNNResnet9-残差神经网络水果多分类项目。
Deep Residual Network学习(一)
fish的专栏
08-18 1万+
对ResNet的初步解读和实验结果在cifar10上复现
吴恩达 深度学习 编程作业（4-2）- Keras tutorial - the Happy House & Residual Networks
大树先生的博客
11-20 1万+
Part 1：Keras tutorial - the Happy House、 Part 2：Residual Networks
深度学习期末复习
weixin_44801852的博客
07-04 5722
学期内容回顾 一、人工智能的概念，发展历程及每个历程的特点和代表性理论或算法，或主要驱动力 二、人工神经网络ANN的前向传播计算和误差反向回传原理 三、卷积神经网络CNN的前向传播计算和误差反向回传原理 注意对比分析ANN与CNN的相同之处和不同之处，深入理解卷积运算的概念和本质 掌握卷积后的特征图尺寸的计算方法 四、神经网络优化 掌握常见激活函数 了解权值初始化的技术 理解训练神经网络的优化技术：SGD，Momentum，Adagrad， RMSProp，Adam等 五、深入理解各种类型的卷积操作 NiN
什么是深度学习？45分钟理解深度神经网络和深度学习 刘利刚教授
liinux-Talk is cheap,show me the code.
01-16 2507
什么是深度学习？ -45分钟理解深度神经网络和深度学习 刘利刚 中国科学技术大学图形与几何计算实验室 http://staff.ustc.edu.cn/~lgliu 【绪言】 近年来，人工智能（Artificial Intelligence, AI）和深度学习（Deep Learning, DL）非常火爆，在各个领域得到了广泛的应用。在笔者所从事的计算机图形学领域，也出现...
深度学习VGG模型核心拆解
热门推荐
CSDN人工智能
01-09 3万+
如今深度学习发展火热，但很多优秀的文章都是基于经典文章，经典文章中的一句一词都值得推敲和分析。此外，深度学习虽然一直被人诟病缺乏足够令人信服的理论，但不代表我们不能感性分析理解，下面我们将对2014年夺得ImageNet的定位第一和分类第二的VGG网络进行分析，在此过程中更多的是对这篇经典文章的感性分析，希望和大家共同交流产生共鸣，如果有理解不到位的也真诚期待指出错误。 Simonyan,
CS224N深度学习NLP笔记（持续更新）
Eveningtidenaf的博客
06-01 828
(2019)斯坦福CS224n深度学习自然语言处理课程笔记与参考资料
Cifar10-using-Resnet9-arch
03-21
Cifar10-using-Resnet9-arch 下载数据集的链接，请单击下面的链接： : 在此模型中，我使用Resnet9架构来创建图像分类模型，在此模型中，我还使用了卷积神经网络，该网络在图像分类模型上非常有用，我使用Pytorch语言与该项目一起工作。 首先，我们对数据集进行规范化，以便我们可以在0到1之间调整值。然后，我们使用卷积神经网络训练模型，以便能够正确预测图像的标签。
keras resnet 训练自己的数据
04-30
keras resnet 迁移训练数据 和 读取数据
ResNet的Keras实现
01-22
VGGNet和GoogLeNet等网络都表明有足够的深度是模型表现良好的前提，但是在网络深度增加到一定程度时，更深的网络意味着更高的训练误差。误差升高的原因是网络越深，梯度弥散[还有梯度爆炸的可能性]的现象就越明显，所以在后向传播的时候，无法有效的把梯度更新到前面的网络层，靠前的网络层参数无法更新，导致训练和测试效果变差。所以ResNet面临的问题是怎样在增加网络深度的情况下有可以有效解决梯度消失的问题。ResNet中解决深层网络梯度消失的问题的核心结构是残差网络。
【深度学习】浅显易懂的残差网络（Residual Network）
柠檬的博客~~~
08-27 2891
深度学习之残差网络的介绍，带你五分钟理解残差网络
TensorFlow笔记（9） ResNet
氢键H-H
07-05 1万+
残差网络分类问题、数据读取、构建模型、训练模型、评估模型、模型预测
残差网络(ResNet) -深度学习（Residual Networks (ResNet) – Deep Learning）
weixin_51141489的博客
07-09 3579
在ImageNet数据集上，作者使用了152层的ResNet，其深度是VGG19的8倍，但参数仍然较少。在ImageNet测试集上，这些ResNets的集合产生的错误率仅为3.7%，这一结果赢得了ILSVRC 2015竞赛。在COCO对象检测数据集上，由于它的深度表示，也产生了28%的相对改进。上面的结果表明，快捷连接将能够解决增加层数所带来的问题，因为当我们将层数从18层增加到34层时，ImageNet验证集上的错误率也会与普通网络不同而降低。下面是ImageNet测试集的结果。
深度学习（9）---ResNet详解
m0_62881487的博客
08-17 1326
5. ResNet后面跟的数字，如ResNet18、ResNet50、ResNet101等，代表的是该网络结构中特定层的总数，具体来说，这个数字通常指的是卷积层与全连接层的和，而不包括池化层、批量归一化（BN）层等其他类型的层。这些数字反映了网络的深度，即网络的复杂度。3. 解决上述问题（模型走偏）的方法：每一次增加函数复杂度之后的函数所覆盖的区域会包含原来函数所在的区域（嵌套函数（nested function）），只有当较复杂的函数包含复杂度较小的函数时，才能确保提高它的性能，如下图所示。
cnn stride and padding_9 大主题卷积神经网络（CNN）的 PyTorch 实现
weixin_39860166的博客
11-19 187
红色石头的个人网站：红色石头的个人博客-机器学习、深度学习之路​www.redstonewill.com大家还记得这张图吗？之前，红色石头发文介绍过一份很不错的资源：52 个深度学习目标检测模型汇总，论文、源码一应俱全！深度系统介绍了 52 个目标检测模型，纵观 2013 年到 2020 年，从最早的 R-CNN、OverFeat 到后来的 SSD、YOLO v3 再到去年的 M2Det，新模型层...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值