【深度学习】计算机视觉（CV）-图像分类-ResNet（Residual Network，残差网络）

已于 2025-07-07 09:30:59 修改
阅读量1.4k 收藏 12
点赞数 20
CC 4.0 BY-SA版权
分类专栏： 深度学习 人工智能 文章标签： 深度学习 计算机视觉 分类
于 2025-02-17 09:14:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/IT_ORACLE/article/details/145674432

ResNet（Residual Network，残差网络）是一种深度卷积神经网络（CNN）架构，由 何恺明（Kaiming He）等人 在 2015 年提出，最初用于 ImageNet 竞赛，并在分类任务上取得了 冠军。ResNet 的核心思想是残差学习（Residual Learning），它通过跳跃连接（Skip Connections） 解决了深度神经网络训练中的梯度消失和梯度爆炸问题，使得非常深的网络（如 50 层、101 层甚至 152 层）仍能有效训练。

1. ResNet 主要特点

(1) 残差块（Residual Block）

  • 传统神经网络直接学习 输入 → 输出 的映射，ResNet 通过 "跳跃连接" 让网络学习 残差（Residual）：

    y = F(x) + x

    其中：

    • x 是输入
    • F(x) 是卷积层等变换
    • y 是输出
    • 核心思想：学习残差 F(x) 而不是直接学习 y，使得梯度更容易传播，缓解梯度消失问题。

(2) 跳跃连接（Skip Connection）

  • 直接将输入 x 加到输出 F(x) 上，让梯度可以绕过多个层传播，避免梯度消失问题。
  • 这样，即使某些层的学习效果不好，也不会影响整体信息的传递，保持网络的稳定性。

(3) 更深的网络

  • 传统 CNN 过深时容易出现退化问题（网络更深但效果下降），ResNet 通过跳跃连接让更深的网络仍能有效训练（ResNet-50、ResNet-101、ResNet-152）。

2. ResNet 结构

(1) 基本残差块

适用于浅层 ResNet（ResNet-18 / ResNet-34）

  • 由 2 个 3×3 卷积 组成，并在输入与输出之间添加直接连接：

    计算方式：

    y = x + F(x)
    • ReLU 激活函数 在跳跃连接后应用。

(2) 瓶颈残差块（Bottleneck Block）

适用于深层 ResNet（ResNet-50 / ResNet-101 / ResNet-152）

  • 由 1×1 → 3×3 → 1×1 组合的 3 层卷积 组成：

    • 1×1 卷积 减少维度
    • 3×3 卷积 进行特征提取
    • 1×1 卷积 恢复维度
    • 这样减少计算量，提高效率

3. 经典 ResNet 版本

版本残差块类型网络深度参数量
ResNet-18基本残差块18 层11M
ResNet-34基本残差块34 层21M
ResNet-50瓶颈残差块50 层25M
ResNet-101瓶颈残差块101 层44M
ResNet-152瓶颈残差块152 层60M

4. ResNet 的优势

  • 解决梯度消失问题：跳跃连接让梯度可以直接传递到前面层，不容易消失。
  • 提高训练效率：学习的是残差，而不是完整映射，优化更容易收敛。
  • 可以训练更深的网络：ResNet-152 比 VGG-19 深很多，但计算量更少。
  • 广泛应用：计算机视觉任务，如 图像分类、目标检测、分割（Mask R-CNN）、GAN 等。

5. ResNet 的应用

  • ImageNet 分类任务：ResNet 在 2015 年 ImageNet 竞赛中夺冠
  • 目标检测：YOLO、Faster R-CNN、Mask R-CNN 采用 ResNet 作为骨干网络
  • 医学图像分析：癌症检测、X 光片分析等
  • 视频分析：动作识别、自动驾驶感知系统

6. 代码实现（ResNet-50）

使用 PyTorch 实现 ResNet-50：

import torch
import torch.nn as nn
import torchvision.models as models

# 加载预训练的 ResNet-50
resnet50 = models.resnet50(pretrained=True)

# 查看网络结构
print(resnet50)

运行结果 

ResNet(
  (conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)
  (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  (relu): ReLU(inplace=True)
  (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)
  (layer1): Sequential(
    (0): Bottleneck(
      (conv1): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (downsample): Sequential(
        (0): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (1): Bottleneck(
      (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
    )
    (2): Bottleneck(
      (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
    )
  )
  (layer2): Sequential(
    (0): Bottleneck(
      (conv1): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (downsample): Sequential(
        (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)
        (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (1): Bottleneck(
      (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
    )
    (2): Bottleneck(
      (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
    )
    (3): Bottleneck(
      (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
    )
  )
  (layer3): Sequential(
    (0): Bottleneck(
      (conv1): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (downsample): Sequential(
        (0): Conv2d(512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False)
        (1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (1): Bottleneck(
      (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
    )
    (2): Bottleneck(
      (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
    )
    (3): Bottleneck(
      (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
    )
    (4): Bottleneck(
      (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
    )
    (5): Bottleneck(
      (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
    )
  )
  (layer4): Sequential(
    (0): Bottleneck(
      (conv1): Conv2d(1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (downsample): Sequential(
        (0): Conv2d(1024, 2048, kernel_size=(1, 1), stride=(2, 2), bias=False)
        (1): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (1): Bottleneck(
      (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
    )
    (2): Bottleneck(
      (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
    )
  )
  (avgpool): AdaptiveAvgPool2d(output_size=(1, 1))
  (fc): Linear(in_features=2048, out_features=1000, bias=True)
)

7. ResNet 进化版本

ResNet 之后，还发展出了多个改进版本：

  • ResNeXt：增加了 组卷积（Group Convolution），提升性能
  • Res2Net：进一步优化特征分解和信息融合
  • HRNet：更适用于高分辨率任务
  • Wide ResNet：减少网络深度，但增加通道数

8. 总结

  • 残差连接 解决梯度消失，使得更深的网络可训练
  • ResNet-50/101/152 在计算机视觉任务中表现出色
  • 跳跃连接 让模型更容易优化，收敛更快
  • 广泛应用于分类、目标检测、医学影像等任务

一句话总结：ResNet 通过残差学习和跳跃连接成功训练了超深的神经网络，是计算机视觉领域的里程碑。

ResNet（Residual Network，残差网络）介绍
浩瀚之水的专栏
06-04 186
ResNet（残差网络）是何恺明团队2015年提出的深度卷积神经网络架构，通过引入残差学习机制解决了深度网络的梯度消失和退化问题。其核心是将输入信号通过跳跃连接传递至输出端，使网络只需学习残差映射。
PyTorch图像分类系列——ResNet
weixin_48633207的博客
06-26 1189
ResNet核心及高复用性ResNet讲解与实现
计算机视觉篇---图像分类实战+理论讲解（5）RESNET
free_girl_fang的博客
03-14 2503
深度残差网络 深度残差网络创新点？ 超深的网络结构，提出了Residule 结构. 使用Bach Normalizetion。 在残差块中添加1X1升维结构，大大降低超深网络参数。inception结构。 退化问题：随着网络深度的加深，会出现梯度消失和梯度爆炸 残差网络的结构如图 与之前网络结构不同的是增加了快速通道，将输入与输出（原)求和。网络层关系映射为 H(x), 残差网络拟合另一个映射， F(x):= H(x)-x , 那么原先的映射就是 F(x)+x。 优化残差映射F(x) 比优化原来的映射
使用ResNet网络实现猫狗数据集分类
最新发布
ZHW-鲜橙大AI课题组的博客
04-09 1128
乔幸荣，女，西安工程大学电子信息学院，2024级研究生研究方向：模式识别与智能系统电子邮件：2029518801@qq.comResNet（Residual Network）是一种深度神经网络架构，它由微软研究院的何凯明（Kaiming He）等人在 2015 年提出，并在 ImageNet 竞赛中取得了惊人的成绩。ResNet 的核心思想是引入残差连接（Residual Connection），能有效地缓解深度神经网络训练中的梯度消失和梯度爆炸问题。
[ 图像分类 ] 经典网络模型4——ResNet 详解与复现
热门推荐
A_John 的博客
04-12 2万+
[ 图像分类 ] 经典网络模型4——ResNet 详解与复现 1、Residual Network 2、残差网络 3、Residual Block 4、ResNet50 详解 5、ResNet50 复现 6、ResNet50 结构框图 Residual Network 简称 ResNet (残差网络)，何凯明团队于2015年提出的一种网络； 在 ImageNet 比赛 classification 任务上获得第一名； 目前在检测，分割，识别等领域里得到了广泛的应用；...
计算机视觉之ResNet
十年以上架构设计经验，专注于软件架构和人工智能领域，对机器视觉、NLP、音视频等领域都有涉猎
05-18 2万+
RestNet是2015年由微软团队提出的，在当时获得分类任务，目标检测，图像分割第一名。该论文的四位作者何恺明、张祥雨、任少卿和孙剑如今在人工智能领域里都是响当当的名字，当时他们都是微软亚研的一员。实验结果显示，残差网络更容易优化，并且加深网络层数有助于提高正确率。在ImageNet上使用152层的残差网络（VGG net的8倍深度，但残差网络复杂度更低）。对这些网络使用集成方法实现了3.75%的错误率。获得了ILSVRC 2015竞赛的第一名。原文链接这是一篇计算机视觉领域的经典论文。
resnet图像分类
chengxuyuan66666的博客
09-30 627
ResNet通过其创新的残差学习机制，在图像分类领域取得了显著的应用成果。它不仅在ImageNet等大规模图像识别竞赛中取得了优异的成绩，还在目标检测、图像分割等其他计算机视觉任务中表现出了强大的性能。随着深度学习技术的不断发展，ResNet及其变体将继续在图像分类和其他领域发挥重要作用。
计算机视觉+深度学习技术+经典网络模型+图像处理和识别 在计算机视觉领域，经典深度学习网络如CNN、ResNet、VGG等，使
03-21
### 计算机视觉与深度学习技术：经典网络模型及应用 #### 一、引言 随着人工智能技术的发展，计算机视觉已成为深度学习技术应用最广泛和成熟的领域之一。该领域利用经典网络模型如CNN（卷积神经网络）、ResNet...
计算机视觉之基于Pytorch实现ResNet34网络进行卫星图像分类
07-16
ResNet，全称为残差网络（Residual Network），由Kaiming He等人在2015年提出，解决了深度神经网络中的梯度消失和爆炸问题。ResNet34是ResNet系列的一个变体，拥有34层，相对于更深层次的ResNet50或ResNet101，它的...
fb.resnet.torch-master.zip_ResNet_ResNet深度学习_facebook_torch resn
09-20
ResNet（残差网络）是由微软研究院的研究人员何凯明、尹启融、陈欣刚等人在2015年提出的深度学习模型，它解决了深度神经网络在训练过程中容易遇到的梯度消失或爆炸的问题。在ResNet模型中，通过引入“残差块”这一...
深度学习模型--残差网络（ResNet）
Amy_bj的博客
04-04 887
残差网络通过残差学习的创新设计，成功地解决了深度学习中的关键挑战，允许神经网络达到前所未有的深度，极大地提高了深度神经网络在各种视觉任务上的性能。
图像分类残差网络-pytorch实现
01-20
基于残差网络的训练模型，准确率可以达到99%，测试集有86%
深度学习系列5——Pytorch 图像分类(ResNet)
霁风AI
02-08 1万+
深度学习系列5——Pytorch 图像分类(ResNet)
图像分类：Pytorch图像分类之--ResNet模型
xp_fangfei的博客
04-07 2221
图像分类：Pytorch图像分类之--ResNet模型；BN的介绍，残差块的介绍
ResNet简述（图像分类篇）
栋哥修炼日记
01-17 2502
文章是对博主视频讲解的一些总结。 博主链接：https://blog.youkuaiyun.com/qq_37541097?spm=1001.2014.3001.5509 1.预言 ResNet来自2015年，是出自微软实验室之手。可以训练152层超深网络。 对于一般网络而言，加深网络会带来问题： 梯度的消失或者爆炸（引入数据标准化处理、权重初始化、BN） 网络的退化（引入残差结构） 2.亮点 超深的网络结构（突破1000层） 提出residual模块（残差块） 使用BN加速训练（丢弃dropout）
Pytorch之ResNet图像分类
风间琉璃的博客
09-30 6193
2015 年，微软亚洲研究院何凯明等人发表了基于 Skip Connection 的深度残差网络(Residual Neural Network，简称 ResNet)算法，并提出了 18 层、34 层、50 层、101层、152 层的 ResNet-18、ResNet-34、ResNet-50、ResNet-101 和 ResNet-152 等模型，甚至成功训练出层数达到 1202 层的极深层神经网络，斩获当年ImageNet竞赛中分类任务第一名，目标检测第一名。
【图像分类】实战篇 （2）5分钟学会用迁移学习ResNet50训练自己的图像分类模型（鸟类识别为例）
06-10 1万+
此项目主要是小白入门教学，项目可以直接运行，需要请私信！！！图像分类是深度学习图像处理领域最基本的识别任务。先上结果。
【图像分类】实战——使用ResNet实现猫狗分类（pytorch）
2301_82241859的博客
04-13 2113
ResNet有不同的网络层数，比较常用的是18-layer，34-layer，50-layer，101-layer，152-layer。他们都是由上述的残差模块堆叠在一起实现的。 下图展示了不同的ResNet模型。​本次使用ResNet18实现图像分类，模型使用pytorch集成的模型。具体的实现方式可以查考这篇文章。里面说的很详细了。但是我们在实战项目中能用官方的还是优先选用官方的，有预训练模型，而且有的模型还做了优化。手撕ResNet——复现ResNet（Pytorch）_AI浩-优快云博客导入项目使
基于resnet网络架构训练图像分类模型
qq_65838372的博客
09-07 609
output表示对一个batch中每一个数据得到其属于各个类别的可能性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值