J7 - 对于ResNeXt-50算法的思考

已于 2024-02-23 22:05:52 修改
阅读量518 收藏 10
点赞数 4
CC 4.0 BY-SA版权
分类专栏： 深度学习 ResNet 文章标签： 深度学习 计算机视觉
于 2024-02-23 22:03:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/chen_blog/article/details/136263871

J6周有一段代码如下
Question

思考过程

  1. 首先看到这个问题的描述，想到的是可能使用了向量操作的广播机制
  2. 然后就想想办法验证一下，想到直接把J6的tensorflow代码跑一遍
  3. 通过model.summary打印了模型的所有层的信息，并把信息处理成方便查看（去掉分组卷积的一大堆层）
  4. 发现通道数一致，并不是使用了广播机制
  5. 仔细分析模型的过程，得出解释

验证过程

summary直接打印的内容，（太大只能贴出部分）

Model: "model"
__________________________________________________________________________________________________
 Layer (type)                Output Shape                 Param #   Connected to                  
==================================================================================================
 input_4 (InputLayer)        [(None, 224, 224, 3)]        0         []                            
                                                                                                  
 zero_padding2d_6 (ZeroPadd  (None, 230, 230, 3)          0         ['input_4[0][0]']             
 ing2D)                                                                                           
                                                                                                  
 conv2d_555 (Conv2D)         (None, 112, 112, 64)         9472      ['zero_padding2d_6[0][0]']    
                                                                                                  
 batch_normalization_59 (Ba  (None, 112, 112, 64)         256       ['conv2d_555[0][0]']          
 tchNormalization)                                                                                
                                                                                                  
 re_lu_53 (ReLU)             (None, 112, 112, 64)         0         ['batch_normalization_59[0][0]
                                                                    ']                            
                                                                                                  
 zero_padding2d_7 (ZeroPadd  (None, 114, 114, 64)         0         ['re_lu_53[0][0]']            
 ing2D)                                                                                           
                                                                                                  
 max_pooling2d_3 (MaxPoolin  (None, 56, 56, 64)           0         ['zero_padding2d_7[0][0]']    
 g2D)                                                                                             
                                                                                                  
 conv2d_557 (Conv2D)         (None, 56, 56, 128)          8192      ['max_pooling2d_3[0][0]']     
                                                                                                  
 batch_normalization_61 (Ba  (None, 56, 56, 128)          512       ['conv2d_557[0][0]']          
 tchNormalization)                                                                                
                                                                                                  
 re_lu_54 (ReLU)             (None, 56, 56, 128)          0         ['batch_normalization_61[0][0]
                                                                    ']                            
                                                                                                  
 lambda_514 (Lambda)         (None, 56, 56, 4)            0         ['re_lu_54[0][0]']            
                                                                                                  
 lambda_515 (Lambda)         (None, 56, 56, 4)            0         ['re_lu_54[0][0]']            
                                                                                                  
 lambda_516 (Lambda)         (None, 56, 56, 4)            0         ['re_lu_54[0][0]']            
                                                                                                  
 lambda_517 (Lambda)         (None, 56, 56, 4)            0         ['re_lu_54[0][0]']            
                                                                                                  
 lambda_518 (Lambda)         (None, 56, 56, 4)            0         ['re_lu_54[0][0]']            
                                                                                                  
 lambda_519 (Lambda)         (None, 56, 56, 4)            0         ['re_lu_54[0][0]']            
                                                                                                  
 lambda_520 (Lambda)         (None, 56, 56, 4)            0         ['re_lu_54[0][0]']            
                                                                                                  
 lambda_521 (Lambda)         (None, 56, 56, 4)            0         ['re_lu_54[0][0]']            
                                                                                                  
 lambda_522 (Lambda)         (None, 56, 56, 4)            0         ['re_lu_54[0][0]']            
                                                                                                  
 lambda_523 (Lambda)         (None, 56, 56, 4)            0         ['re_lu_54[0][0]']            
                                                                                                  
 lambda_524 (Lambda)         (None, 56, 56, 4)            0         ['re_lu_54[0][0]']            
                                                                                                  
 lambda_525 (Lambda)         (None, 56, 56, 4)            0         ['re_lu_54[0][0]']            
                                                                                                  
 lambda_526 (Lambda)         (None, 56, 56, 4)            0         ['re_lu_54[0][0]']            
                                                                                                  
 lambda_527 (Lambda)         (None, 56, 56, 4)            0         ['re_lu_54[0][0]']            
                                                                                                  
 lambda_528 (Lambda)         (None, 56, 56, 4)            0         ['re_lu_54[0][0]']            
                                                                                                  
 lambda_529 (Lambda)         (None, 56, 56, 4)            0         ['re_lu_54[0][0]']            
                                                                                                  
 lambda_530 (Lambda)         (None, 56, 56, 4)            0         ['re_lu_54[0][0]']            
                                                                                                  
 lambda_531 (Lambda)         (None, 56, 56, 4)            0         ['re_lu_54[0][0]']            
                                                                                                  
 lambda_532 (Lambda)         (None, 56, 56, 4)            0         ['re_lu_54[0][0]']            
                                                                                                  
 lambda_533 (Lambda)         (None, 56, 56, 4)            0         ['re_lu_54[0][0]']            
                                                                                                  
 lambda_534 (Lambda)         (None, 56, 56, 4)            0         ['re_lu_54[0][0]']            
                                                                                                  
 lambda_535 (Lambda)         (None, 56, 56, 4)            0         ['re_lu_54[0][0]']            
                                                                                                  
 lambda_536 (Lambda)         (None, 56, 56, 4)            0         ['re_lu_54[0][0]']            
                                                                                                  
 lambda_537 (Lambda)         (None, 56, 56, 4)            0         ['re_lu_54[0][0]']            
                                                                                                  
 lambda_538 (Lambda)         (None, 56, 56, 4)            0         ['re_lu_54[0][0]']            
                                                                                                  
 lambda_539 (Lambda)         (None, 56, 56, 4)            0         ['re_lu_54[0][0]']            
                                                                                                  
 lambda_540 (Lambda)         (None, 56, 56, 4)            0         ['re_lu_54[0][0]']            
                                                                                                  
 lambda_541 (Lambda)         (None, 56, 56, 4)            0         ['re_lu_54[0][0]']            
                                                                                                  
 lambda_542 (Lambda)         (None, 56, 56, 4)            0         ['re_lu_54[0][0]']            
                                                                                                  
 lambda_543 (Lambda)         (None, 56, 56, 4)            0         ['re_lu_54[0][0]']            
                                                                                                  
 lambda_544 (Lambda)         (None, 56, 56, 4)            0         ['re_lu_54[0][0]']            
                                                                                                  
 lambda_545 (Lambda)         (None, 56, 56, 4)            0         ['re_lu_54[0][0]']            
                                                                                                  
 conv2d_558 (Conv2D)         (None, 56, 56, 4)            144       ['lambda_514[0][0]']          
                                                                                                  
 conv2d_559 (Conv2D)         (None, 56, 56, 4)            144       ['lambda_515[0][0]']          
                                                                                                  
 conv2d_560 (Conv2D)         (None, 56, 56, 4)            144       ['lambda_516[0][0]']          
                                                                                                  
 conv2d_561 (Conv2D)         (None, 56, 56, 4)            144       ['lambda_517[0][0]']          
                                                                                                  
 conv2d_562 (Conv2D)         (None, 56, 56, 4)            144       ['lambda_518[0][0]']          
                                                                                                  
 conv2d_563 (Conv2D)         (None, 56, 56, 4)            144       ['lambda_519[0][0]']          
                                                                                                  
 conv2d_564 (Conv2D)         (None, 56, 56, 4)            144       ['lambda_520[0][0]']          
                                                                                                  
 conv2d_565 (Conv2D)         (None, 56, 56, 4)            144       ['lambda_521[0][0]']          
                                                                                                  
 conv2d_566 (Conv2D)         (None, 56, 56, 4)            144       ['lambda_522[0][0]']          
                                                                                                  
 conv2d_567 (Conv2D)         (None, 56, 56, 4)            144       ['lambda_523[0][0]']          
                                                                                                  
 conv2d_568 (Conv2D)         (None, 56, 56, 4)            144       ['lambda_524[0][0]']          
                                                                                                  
 conv2d_569 (Conv2D)         (None, 56, 56, 4)            144       ['lambda_525[0][0]']          
                                                                                                  
 conv2d_570 (Conv2D)         (None, 56, 56, 4)            144       ['lambda_526[0][0]']          
                                                                                                  
 conv2d_571 (Conv2D)         (None, 56, 56, 4)            144       ['lambda_527[0][0]']          
                                                                                                  
 conv2d_572 (Conv2D)         (None, 56, 56, 4)            144       ['lambda_528[0][0]']          
                                                                                                  
 conv2d_573 (Conv2D)         (None, 56, 56, 4)            144       ['lambda_529[0][0]']          
                                                                                                  
 conv2d_574 (Conv2D)         (None, 56, 56, 4)            144       ['lambda_530[0][0]']          
                                                                                                  
 conv2d_575 (Conv2D)         (None, 56, 56, 4)            144       ['lambda_531[0][0]']          
                                                                                                  
 conv2d_576 (Conv2D)         (None, 56, 56, 4)            144       ['lambda_532[0][0]']          
                                                                                                  
 conv2d_577 (Conv2D)         (None, 56, 56, 4)            144       ['lambda_533[0][0]']          
                                                                                                  
 conv2d_578 (Conv2D)         (None, 56, 56, 4)
最低0.47元/天 解锁文章

200万优质内容无限畅学
进击J7：对于ResNeXt-50算法的思考
u012249506的博客
09-19 1848
第一段代码定义了一个名为block的函数，该函数用于构建ResNeXt网络中的残差单元（Residual Block）。残差单元的主要目的是通过残差连接（shortcut connection）解决深度神经网络训练中的梯度消失和梯度爆炸问题，同时提高网络的表示能力。第二段代码则定义了stack函数，用于堆叠多个残差单元（block）来构建ResNeXt网络的一部分。通过堆叠残差单元，可以逐步增加网络的深度和复杂度，从而提高网络对数据特征的提取和表示能力。
J7打卡：ResNeXt-50算法思考
m0_46482112的博客
07-11 395
本文分析了深度学习训练营中关于残差网络（ResNet）代码的正确性问题。重点探讨了残差单元block模块中Add()层的通道数匹配机制：当conv_shortcut为False时，快捷连接(shortcut)会直接传递输入x，导致与主路径通道数不一致。研究发现，虽然存在通道数差异，但Add()层会自动进行零填充处理，这种操作既不会引发尺寸错误，也不会影响梯度更新。因此代码设计是合理的，通道数不匹配问题已被TensorFlow框架内置机制妥善解决。
深度学习 Day28——J7对于ResNeXt-50算法的思考
LittleRuby的博客
03-15 527
关键问题：ResNeXt-50中conv_shortcut=False时，block函数中ADD()的两个输入通道不同为什么不报错
深度学习每周学习总结J7（对ResNeXt-50 算法的思考）
qq_33489955的博客
11-29 1255
当时，代码中未对通道数进行显式对齐，存在潜在问题。如果通道数确实一致，可能是前面的代码已经对输入通道数做了隐式约束。最好在代码中显式处理通道对齐问题，确保逻辑自洽，避免因意外输入导致错误。在else:如果shortcut使用一个 1x1 卷积升维（或降维）来使通道数从变为。如果shortcut是，即直接复制输入数据，不会对输入张量的通道数进行任何修改。这意味着当时，shortcut的通道数与输入x的通道数是完全相同的。TensorFlow 版本存在潜在问题：未显式保证残差连接中。
浙大公开课—基于深度学习的特征匹配与姿态估计
xiaoxu的博客
07-27 764
本文探讨了基于深度学习的特征匹配与位姿估计方法。传统SIFT等手工特征在光照变化场景下表现不佳，而深度学习通过CNN网络提取语义信息，在特征匹配上展现出更好的鲁棒性。文章详细分析了深度学习特征提取流程，包括特征检测、描述子生成和匹配优化，并介绍了利用SfM数据集进行监督训练的策略。同时指出深度学习方法对几何变换（如旋转、缩放）的局限性源于卷积操作的平移不变性。最后介绍了位姿估计中2D-3D映射网络的应用及其在目标跟踪中的价值。
基于深度学习的胸部 X 光图像肺炎分类系统（二）
wh_xia_jun的专栏
07-24 762
不是固定公式：没有 “必须 21 层” 的规定，就像盖房子，3 层能住，5 层也能住，看需求。经验为主：人们发现处理这类 X 光片（中等复杂度的图片），用 4 个卷积块（16 层）+ 简单分类器（5 层）比较合适：少于 10 层：可能 “看不透” 细节（比如小的肺炎阴影抓不到）。多于 30 层：电脑要算很久，还可能 “想太多”（把正常的纹理当成肺炎特征）。试出来的：程序员可能一开始试了 10 层，发现效果不好（漏诊多）；又试了 30 层，发现太慢还容易错；最后调到 21 层，效果和效率比较平衡。
循环神经网络 中文情感分析案例
2301_76654710的博客
07-28 514
目录一、数据处理1、读取原始文件2、清洗数据3、分词4、构建词典并保存5、把每条文本编码成数字列表6、固定长度二、设置数据集、数据加载器三、构建模型结构四、配置具体模型参数与训练细节五、开始训练并保存六、模型测试（测试集）七、单条评论测试（可选）又做了一个小案例，刚好来复盘一下，是关于分析酒店评论的好坏，首先原始数据集如下：前面一列是标签，1代表好评，0代表差评，后面的是评论内容，一共有5000多条评论，下面开始：这里我总结了一下大概的步骤：读取原始文件 --> 清洗数据（去除标点符号等） --> 分词 -
无源域自适应综合研究【2】
weixin_52201996的博客
07-24 1088
这篇论文为SFUDA领域提供了全面且系统的综述，不仅有助于研究人员快速了解该领域的研究现状和应用情况，还为未来的研究指明了方向。其分类方法和对未来方向的探讨具有重要的参考价值，可推动SFUDA在更多实际场景中的应用和发展。原文题目：Source-Free Unsupervised Domain Adaptation: Current research and future directions请大家自行搜索阅读原论文。
基于深度学习的图像分类：使用ShuffleNet实现高效分类
qq_74383080的博客
07-27 900
本文介绍了基于ShuffleNet的轻量级图像分类方法。首先阐述了图像分类的定义和应用场景，包括医疗、自动驾驶等领域。重点分析了ShuffleNet的核心技术：点群卷积和通道混洗操作，这些设计在保证精度的同时显著降低了计算量。文章提供了完整的代码实现方案，包括数据预处理、模型加载、训练和评估流程，使用CIFAR-10数据集进行验证。实验表明，ShuffleNet在保持较高分类精度的同时，具有模型轻量化优势，特别适合移动和嵌入式设备应用。最后建议读者可以尝试扩展应用到其他数据集或改进模型架构。
基于深度学习的医学图像分析：使用YOLOv5实现细胞检测
最新发布
qq_74383080的博客
07-28 793
本文介绍了使用YOLOv5实现医学图像中细胞检测的方法。文章首先阐述了医学图像分析和细胞检测的重要性及其在病理诊断、生物医学研究等领域的应用。然后详细讲解了YOLOv5的架构优势，包括高效性、灵活性和可扩展性。接着提供了完整的代码实现方案，包括环境准备、数据集加载、预训练模型迁移、模型训练与评估等步骤。通过实际案例展示了如何将YOLOv5应用于细胞检测任务，并鼓励读者尝试改进模型性能。文章为AI在医疗影像分析领域的实践应用提供了实用指导。
【第四章:大模型（LLM)】01.神经网络中的 NLP-(2)Seq2Seq 原理及代码解析
IT古董
07-28 361
本文介绍了Seq2Seq（序列到序列）模型的基本原理及其在自然语言处理中的应用。Seq2Seq模型由编码器和解码器组成，通过编码器将输入序列转换为上下文向量，再由解码器生成目标序列。文章详细阐述了模型架构、数学公式及训练流程，并针对传统模型的不足引入了注意力机制。通过PyTorch代码示例演示了编码器、解码器和完整Seq2Seq模型的实现方法。该模型在机器翻译、文本摘要、对话系统和语音识别等领域有广泛应用。
深度学习篇---剪裁&缩放
道阻且长，行则将至。
07-25 987
深度学习图像预处理中，剪裁和缩放是关键操作：剪裁通过截取关键区域去除冗余信息，常用方法包括中心剪裁、随机剪裁和目标区域剪裁；缩放则通过插值算法统一图像尺寸，主要方法有最近邻、双线性和双三次插值。二者协同使用能有效提升模型训练效率和泛化能力，但需注意平衡细节保留与计算成本，避免过度处理导致特征丢失。实际应用中应根据任务需求选择合适的策略组合。
Inception网络架构：深度学习视觉模型的里程碑
2301_80338712的博客
07-25 909
本文深入探讨了谷歌研究团队开发的Inception网络架构，这一架构自2014年提出以来，对计算机视觉领域产生了深远影响。从最初的GoogLeNet（Inception v1）到后续的多个版本迭代，Inception系列网络不仅在ImageNet等图像分类竞赛中取得了卓越成绩，还引入了多个关键创新，如并行多尺度卷积结构、批量归一化技术和残差连接等。本文详细分析了Inception架构的演进历程、核心设计理念以及其在计算机视觉任务中的应用，同时探讨了该架构的优缺点及其对后续深度学习网络设计的启示。
储粮温度预测新方案！FEBL模型用代码实现：LSTM+注意力+岭回归的完整流程
2301_76444133的博客
07-25 401
本文提出了一种特征增强型宽度学习（FEBL）模型用于储粮温度预测。该模型结合LSTM提取时序特征，通过多头自注意力机制增强关键特征，并采用宽度学习系统扩展模型容量。数据处理阶段使用滑动窗口构建时序数据集，并进行归一化处理。模型整合特征增强模块和宽度学习系统，最后采用岭回归计算输出权重以避免过拟合。实验结果表明，该方法能有效预测储粮温度，评价指标包括MAE、RMSE和MAPE。该方案为储粮温度监控提供了新的深度学习解决方案。
【大模型LLM】梯度累积（Gradient Accumulation）原理详解
weixin_43988131的博客
07-28 519
梯度累积（Gradient Accumulation）原理详解
多层感知机（深度学习-李沐-学习笔记）
gyeolhada的博客
07-25 945
多层感知机（深度学习-李沐-学习笔记）
从JPEG到SER：小波+CNN如何横扫CVPR/ICASSP？
Tulingxueshu的博客
07-28 819
分享一个大模型时代很有潜力的研究方向：小波变换+CNN。随着深度学习的发展，小波变换与CNN的结合受到了越来越多的关注。小波变换能够有效地提取信号的多尺度特征，而CNN则擅长处理图像等复杂数据。两者的结合不仅在图像压缩、语音情感识别等领域取得了显著成果，还为解决特征提取和模型优化等问题提供了新的思路。
RNN模型数学推导过程（笔记）
niki_yang
07-25 263
RNN按顺序处理输入序列。每个序列元素在特定的t被输入网络。这是RNN的“记忆”或“状态”所在。它是一个向量（h_t），总结了从序列开始（t=0）到当前时间步t所处理过的所有信息。h_t被传递给下一个时间步t+1，用于计算h_{t+1}。在时间步t，网络接收该时间步的输入向量x_t。在时间步t，网络可以产生一个输出向量y_t（例如，预测下一个词、分类当前情绪等）。y_t通常基于当前的隐藏状态h_t计算得出。
定义损失函数并以此训练和评估模型
Frost_Descent的博客
07-24 1359
损失函数计算模型输出和目标之间的距离。Pytorch 中的 optim 包提供了各种优化算法的实现，例如SGD、Adam、RMSprop 等。通过torch.nn 包可以定义一个负对数似然损失函数，负对数似然损失对于训练具有多个类的分类问题比较有效，负对数似然损失函数的输入为对数概率，而在模型搭建的输出层部分接触过log_softmax，它能从模型中获取对数概率。break得到一个测试值定义一个Adam优化器，优化器的输入是模型参数和学习率。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值