【CNN感受野计算】python 示例含盖 vgg alexnet rtpose等

博客主要介绍了感受野的计算方法。以多层卷积层为例,详细说明了每层感受野大小的计算过程,如第一层感受野为卷积核大小,后续层根据前层感受野和当前层卷积核、步长计算。还提到pool层按卷积层同理计算,并给出了计算感受野的公式,最后涉及Python代码实现。

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

一、感受野

      layer 1 : kernel size:3*3 stride:1

      layer2 :kernel size:3*3 stride:1

      第一层的感受野就是卷积核大小 3*3 ,第二层感受野是5*5

      这个也比较好理解,对于第一层计算之后的feature map而言,每一个pixel都对应了layer1的input的3*3大小的区域;

      第二层的输出也是同理,但是第二层的输入本身携带了3*3的感受野,那么在第二层这个3*3的最中心那个位置就是上一次感受野的区域结果,相当于向外扩展(上下左右)了1个pixel,因此为5*5

      如果这个时候,再来一个layer3:kernel size:5*5 stride:2

      再来个layer4:kernel size:3*3 stride:1

      那么此时第三层的感受野就是5+(5-1)*1=9,第四层为9+(3-1)*2=13

      ***pool层也按照卷积层同理计算就行了

二、公式

                                             

                   其中l_k-1是第k-1层的感受野大小,而f_k是当前层的卷积核大小,s_i是第i层的步长。

三、python代码

alexnet=[
    [[3, 96, 11, 4, 0],
    [3,2,0],
    [96, 256, 5, 1, 2],
    [3,2,0],
    [256,384, 3, 1, 1],
    [384,384, 3, 1, 1],
    [384,256, 3, 1, 1],
    [3,2,0]]


]
vgg16=[
    [[3, 64, 3, 1, 1],
     [64, 64, 3, 1, 1],
    [2,2,0],
    [64, 128, 3, 1, 1],
[128, 128, 3, 1, 1],
    [2,2,0],
    [128,256, 3, 1, 1],
[256,256, 3, 1, 1],
[256,256, 3, 1, 1],
[2,2,0],
[256,512, 3, 1, 1],
[512,512, 3, 1, 1],
[512,512, 3, 1, 1],
[2,2,0],
[512,512, 3, 1, 1],
[512,512, 3, 1, 1],
[512,512, 3, 1, 1],
[2,2,0]]
]
net = [[ [3, 64, 3, 1, 1],
               [64, 64, 3, 1, 1],
               [2, 2, 0],
               [64, 128, 3, 1, 1],
               [128, 128, 3, 1, 1],
               [2, 2, 0],
               [128, 256, 3, 1, 1],
               [256, 256, 3, 1, 1],
               [256, 256, 3, 1, 1],
               [256, 256, 3, 1, 1],
               [2, 2, 0],
               [256, 512, 3, 1, 1],
               [512, 512, 3, 1, 1],
               [512, 256, 3, 1, 1],
               [256, 128, 3, 1, 1]]]

net.append( [[128, 128, 3, 1, 1],
                      [128, 128, 3, 1, 1],
                      [128, 128, 3, 1, 1],
                      [128, 512, 1, 1, 0],
                      [512, 38, 1, 1, 0]])

for i in range(2, 7):
    net.append([
        [185, 128, 7, 1, 3],
        [128, 128, 7, 1, 3],
        [128, 128, 7, 1, 3],
         [128, 128, 7, 1, 3],
        [128, 128, 7, 1, 3],
        [128, 128, 1, 1, 0],
        [128, 38, 1, 1, 0]
    ])

#!!!!!这里的rf_k_1每次根据需要的网络换成第一层的卷积核大小!!!!!!
stride_all_k_1=1
rf_k_1=3
flag=0
count=0
net_to_caculated=vgg16
for stage in range(len(net_to_caculated)):
    #print(net[stage])
    print("stage: ",stage)
    for layer in net_to_caculated[stage]:
        if flag==0:
            if len(layer)==5:
                rf=rf_k_1
                stride_all_k_1=stride_all_k_1*layer[3]
            else:
                rf = rf_k_1
                stride_all_k_1 = stride_all_k_1 * layer[1]
            flag=1
        else:
            if len(layer) == 5:
                rf=rf_k_1+(layer[2]-1)*stride_all_k_1
                stride_all_k_1=stride_all_k_1*layer[3]
            else:
                rf = rf_k_1 + (layer[0] - 1) * stride_all_k_1
                stride_all_k_1 = stride_all_k_1 * layer[1]
            rf_k_1=rf
        print("layer ",count," receptive field: ",rf)
    print("stage ",stage," receptive field:",rf)

 

<think>嗯,用户现在想了解AlexNetVGG和ResNet的优势和缺点。我需要先回顾一下这些经典CNN模型的结构和特点,然后比较它们的优缺点。 首先,用户之前问过关于代码解析的问题,现在转向了模型比较,可能是在学习深度学习中的卷积神经网络,想要了解不同模型的演变。用户可能是学生或者刚入门的研究者,需要清晰的对比来帮助理解这些模型的差异。 接下来,我得分别分析每个模型。AlexNet是早期的成功模型,2012年ImageNet冠军,使用了ReLU和Dropout,但结构相对简单,参数量大,可能过拟合。VGG则通过小卷积堆叠加深网络,结构统一但参数量更大,计算成本高。ResNet引入了残差连接,解决了深网络梯度消失的问题,允许训练非常深的网络,结构也更复杂。 要比较它们的优缺点,需要从网络深度、参数效率、创新点等方面展开。同时要注意用户可能需要知道为什么ResNet比VGG好,或者为什么这些模型会被后来的结构取代。可能还需要提到计算资源的需求,因为VGG参数量大,在实际应用中可能不高效。 另外,用户可能想知道这些模型的应用场景,比如AlexNet在早期图像分类的效果,VGG在特征提取上的优势,ResNet在深度上的突破。还要提到各自的缺点,比如AlexNet的过拟合问题,VGG计算成本,ResNet虽然深但可能在某些情况下冗余。 需要确保用中文解释清楚,结构清晰,分点列出优缺点,可能用表格对比更直观。同时,要避免使用太多专业术语,或者如果使用的话,要简单解释一下,比如残差连接、梯度消失等概念。 最后,总结它们的演变,说明如何互相改进,以及后续的影响,比如ResNet对后续模型如DenseNet的启发。这样用户能有一个整体的认识,理解为什么这些模型在深度学习发展中重要。</think>以下是AlexNetVGG和ResNet的对比分析,按技术演进顺序展开: --- ### **1. AlexNet (2012)** **🔍 核心创新** - 首个成功实践GPU加速的CNN(ImageNet 2012冠军) - 使用ReLU激活函数替代Sigmoid(缓解梯度消失) - 提出Dropout正则化(在FC应用) **✅ 优势** ```python # 结构示例(简化版) nn.Sequential( nn.Conv2d(3,96,kernel_size=11,stride=4), # 大卷积核捕捉全局特征 nn.MaxPool2d(3,2), nn.Conv2d(96,256,kernel_size=5,padding=2), nn.MaxPool2d(3,2), nn.Conv2d(256,384,kernel_size=3,padding=1), nn.Conv2d(384,384,kernel_size=3,padding=1), nn.Conv2d(384,256,kernel_size=3,padding=1), nn.MaxPool2d(3,2), nn.Flatten(), nn.Linear(9216,4096), # 参数量爆炸点 nn.Dropout(0.5), nn.Linear(4096,4096), nn.Dropout(0.5), nn.Linear(4096,1000) ) ``` - 突破传统方法的性能瓶颈 - 奠定CNN基础设计范式 **❌ 缺点** - 参数量过大(如FC占模型总参数量的95%+) - 大卷积核(11x11)导致计算效率低 - 网络深度有限(仅8) --- ### **2. VGGNet (2014)** **🔍 核心创新** - 统一使用3x3小卷积核堆叠(参数量更少,感受野等效大卷积核) - 标准化网络结构(VGG16/VGG19) **✅ 优势** $$ \text{参数量优化} = \frac{(3\times3\times C_{in}\times C_{out})}{(5\times5\times C_{in}\times C_{out})} = \frac{9}{25} $$ - 更深的网络(16-19)提升特征抽象能力 - 小卷积核堆叠实现高效局部特征提取 **❌ 缺点** ```python # VGG16参数量计算(部分) Conv2d(3,64,kernel_size=3,padding=1): 3*3*3*64 = 1,728 Conv2d(64,64,kernel_size=3,padding=1): 3*3*64*64 = 36,864 ... Linear(4096,4096): 4096*4096 = 16,777,216 # 仍存在FC参数冗余 ``` - 参数量仍较大(VGG16约1.38亿参数) - 深网络梯度消失问题未解决 - 计算成本高(FLOPs是AlexNet3倍) --- ### **3. ResNet (2015)** **🔍 核心创新** - 提出残差连接(Residual Connection) $$ \text{输出} = F(x) + x $$ - 使用Bottleneck结构(1x1卷积降维/升维) **✅ 优势** ```python # 残差块结构(PyTorch实现) class ResidualBlock(nn.Module): def __init__(self, in_channels, out_channels, stride=1): super().__init__() self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=stride, padding=1) self.bn1 = nn.BatchNorm2d(out_channels) self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size=3, padding=1) self.bn2 = nn.BatchNorm2d(out_channels) self.shortcut = nn.Sequential() if stride !=1 or in_channels != out_channels: self.shortcut = nn.Sequential( nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=stride), nn.BatchNorm2d(out_channels) ) def forward(self, x): out = F.relu(self.bn1(self.conv1(x))) out = self.bn2(self.conv2(out)) out += self.shortcut(x) # 残差连接 return F.relu(out) ``` - 解决深度网络梯度消失问题(可训练1000+网络) - 参数量显著优化(ResNet50仅约2500万参数) - 性能显著提升(ImageNet top-5错误率3.57%) **❌ 缺点** - 残差连接引入恒等映射可能造成信息冗余 - 极端深度时出现特征"稀释"现象(后被DenseNet改进) --- ### **📊 对比总结** | 指标 | AlexNet | VGG | ResNet | |-------------|------------------|------------------|------------------| | **深度** | 8 | 16-19 | 18-152(可扩展至1000+) | | **参数量** | ~6000万 | ~1.38亿(VGG16) | ~2500万(ResNet50)| | **创新点** | ReLU/Dropout | 小卷积核堆叠 | 残差连接 | | **训练难度**| 易过拟合 | 梯度消失 | 稳定训练深度网络 | | **计算效率**| 较低(大卷积核) | 低(全连接冗余) | 高(Bottleneck设计)| --- ### **🔧 技术演进启示** 1. **AlexNetVGG**:通过小卷积核堆叠实现更深网络,但未解决梯度问题 2. **VGG → ResNet**:残差连接突破深度限制,BatchNorm提升训练稳定性 3. **后续发展**:ResNet启发了DenseNet(密集连接)、ResNeXt(分组卷积)等变体 这些模型体现了CNN设计的核心思路演变:从追求特征提取效率(AlexNet/VGG)到解决深度训练难题(ResNet),最终实现精度与效率的平衡。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值