卷积神经网络（四）Resnet网络pytorch实现

最新推荐文章于 2024-01-01 22:05:24 发布
最新推荐文章于 2024-01-01 22:05:24 发布
阅读量970 收藏 12
点赞数 2
分类专栏： 卷积神经网络 文章标签： 卷积神经网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45837625/article/details/107667478
版权

1.Resnet 主要结构图

在这里插入图片描述

2.VGG与resnet34比较

注意虚线和实线的区别：

2.1不需要下采样，直接相加

在这里插入图片描述
3.1需要下采样，下采样之后再相加
在这里插入图片描述

在这里插入图片描述

3.resnet参数结构

在这里插入图片描述

4.具有代表性的残差块

前面是34-的，后面是50+的
在这里插入图片描述

5.具体代码实现

5.1先定义适合Resnet34的基础卷积块

#18，34

class BasicBlock(nn.Module):
    #因为第一个卷积和第二个卷积的通道数一样，所以这个设置为1
    expansion = 1

    def __init__(self, in_channel, out_channel, stride=1, downsample=None):
        super(BasicBlock, self).__init__()
        #Conv(3x3,64)  stride=1
        self.conv1 = nn.Conv2d(in_channels=in_channel, out_channels=out_channel,
                               kernel_size=3, stride=stride, padding=1, bias=False)
        self.bn1 = nn.BatchNorm2d(out_channel)
        self.relu = nn.ReLU()
        #Conv(3x3,64)   stride=1
        self.conv2 = nn.Conv2d(in_channels=out_channel, out_channels=out_channel,
                               kernel_size=3, stride=1, padding=1, bias=False)
        self.bn2 = nn.BatchNorm2d(out_channel)
        #残差边
        self.downsample = downsample
    def forward(self, x):
        #
        identity = x
        #判断是否需要下采样   
        if self.downsample is not None:
            #若需要
            identity = self.downsample(x)
        #第一次卷积
        out = self.conv1(x)
        out = self.bn1(out)
        out = self.relu(out)
        #第二次卷积
        out = self.conv2(out)
        out = self.bn2(out)
        #相加之后传入给激活函数
        out += identity
        out = self.relu(out)
      
        return out

5.2Resnet50基础卷积块

#50，101，152
class Bottleneck(nn.Module):
    #第三个卷积块的通道数是第一个的四倍（64->256) ,前面定义方便后面运算
    expansion = 4

    def __init__(self, in_channel, out_channel, stride=1, downsample=None):
        super(Bottleneck, self).__init__()

        #Conv(1x1,64)  stride=1 

        self.conv1 = nn.Conv2d(in_channels=in_channel, out_channels=out_channel,
                               kernel_size=1, stride=1, bias=False)  # squeeze channels
        self.bn1 = nn.BatchNorm2d(out_channel)

        # Conv(3x3,64)   第一个的时候stride=2 其他就是=1

        self.conv2 = nn.Conv2d(in_channels=out_channel, out_channels=out_channel,
                               kernel_size=3, stride=stride, bias=False, padding=1)   #stride=2,stride=1
        self.bn2 = nn.BatchNorm2d(out_channel)

        #Conv(1x1,256)  stride=1

        self.conv3 = nn.Conv2d(in_channels=out_channel, out_channels=out_channel*self.expansion,
                               kernel_size=1, stride=1, bias=False)  # unsqueeze channels
        self.bn3 = nn.BatchNorm2d(out_channel*self.expansion)

        self.relu = nn.ReLU(inplace=True)
        self.downsample = downsample



    def forward(self, x):
        identity = x
        #第一次卷积
        out = self.conv1(x)
        out = self.bn1(out)
        out = self.relu(out)
        #第二次卷积
        out = self.conv2(out)
        out = self.bn2(out)
        out = self.relu(out)
        #第三次卷积
        out = self.conv3(out)
        out = self.bn3(out)
        #是否要进行下采样
        if self.downsample is not None:
            identity = self.downsample(x)
        #相加之后再使用激活函数
        out += identity
        out = self.relu(out)

        return out

6.模型整体代码：

import torch.nn as nn
import torch

#18，34

class BasicBlock(nn.Module):
    #因为第一个卷积块和第二个卷积块的通道数一样，所以这个设置为1
    expansion = 1

    def __init__(self, in_channel, out_channel, stride=1, downsample=None):
        super(BasicBlock, self).__init__()
        #Conv(3x3,64)  stride 要自己定义，因为如果为大卷积块的第一个残差网络，这儿的步长就是2
        self.conv1 = nn.Conv2d(in_channels=in_channel, out_channels=out_channel,
                               kernel_size=3, stride=stride, padding=1, bias=False)
        self.bn1 = nn.BatchNorm2d(out_channel)
        self.relu = nn.ReLU()
        #Conv(3x3,64)   stride=1
        self.conv2 = nn.Conv2d(in_channels=out_channel, out_channels=out_channel,
                               kernel_size=3, stride=1, padding=1, bias=False)
        self.bn2 = nn.BatchNorm2d(out_channel)
        #残差边
        self.downsample = downsample
    def forward(self, x):
        #
        identity = x
        #判断是否需要下采样   
        if self.downsample is not None:
            #若需要
            identity = self.downsample(x)
        #第一次卷积
        out = self.conv1(x)
        out = self.bn1(out)
        out = self.relu(out)
        #第二次卷积
        out = self.conv2(out)
        out = self.bn2(out)
        #相加之后传入给激活函数
        out += identity
        out = self.relu(out)
      
        return out

#50，101，152
class Bottleneck(nn.Module):
    #第三个卷积块的通道数是第一个的四倍（64->256) ,前面定义方便后面运算
    expansion = 4

    def __init__(self, in_channel, out_channel, stride=1, downsample=None):
        super(Bottleneck, self).__init__()

        #Conv(1x1,64)  stride=1 

        self.conv1 = nn.Conv2d(in_channels=in_channel, out_channels=out_channel,
                               kernel_size=1, stride=1, bias=False)  # squeeze channels
        self.bn1 = nn.BatchNorm2d(out_channel)

        # Conv(3x3,64)   第一个的时候stride=2 其他就是=1

        self.conv2 = nn.Conv2d(in_channels=out_channel, out_channels=out_channel,
                               kernel_size=3, stride=stride, bias=False, padding=1)   #stride=2,stride=1
        self.bn2 = nn.BatchNorm2d(out_channel)

        #Conv(1x1,256)  stride=1

        self.conv3 = nn.Conv2d(in_channels=out_channel, out_channels=out_channel*self.expansion,
                               kernel_size=1, stride=1, bias=False)  # unsqueeze channels
        self.bn3 = nn.BatchNorm2d(out_channel*self.expansion)

        self.relu = nn.ReLU(inplace=True)
        self.downsample = downsample



    def forward(self, x):
        identity = x
        #第一次卷积
        out = self.conv1(x)
        out = self.bn1(out)
        out = self.relu(out)
        #第二次卷积
        out = self.conv2(out)
        out = self.bn2(out)
        out = self.relu(out)
        #第三次卷积
        out = self.conv3(out)
        out = self.bn3(out)
        #是否要进行下采样
        if self.downsample is not None:
            identity = self.downsample(x)
        #相加之后再使用激活函数
        out += identity
        out = self.relu(out)

        return out


class ResNet(nn.Module):
    #block       :BasicBlock    Bottleneck
    #blocks_num  :[3, 4, 6, 3], [3, 4, 23, 3]
    #num_classes=1000

    def __init__(self, block, blocks_num, num_classes=1000, include_top=True):
        super(ResNet, self).__init__()

        self.include_top = include_top  #看是否有后面的全连接
        #定义初始通道数=64
        self.in_channel = 64

        #第一个卷积层(7x7,64)  stride=2
        self.conv1 = nn.Conv2d(3, self.in_channel, kernel_size=7, stride=2,
                               padding=3, bias=False)
        self.bn1 = nn.BatchNorm2d(self.in_channel)
        self.relu = nn.ReLU(inplace=True)

        #(3x3,2)  stride=2
        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
        #第一个卷积层结束
        #Bottleneck ，64，3
        #
        #
        #

        self.layer1 = self._make_layer(block, 64, blocks_num[0])
        #

        self.layer2 = self._make_layer(block, 128, blocks_num[1], stride=2)


        self.layer3 = self._make_layer(block, 256, blocks_num[2], stride=2)


        self.layer4 = self._make_layer(block, 512, blocks_num[3], stride=2)


        if self.include_top:
            self.avgpool = nn.AdaptiveAvgPool2d((1, 1))  # output size = (1, 1)
            self.fc = nn.Linear(512 * block.expansion, num_classes)

        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
        #Bottleneck ，64，3
        #Bottleneck ，128，4
        #Bottleneck ，256，6
        #Bottleneck ，512,3


    def _make_layer(self, block, channel, block_num, stride=1):
        #下采样初始定义为：None
        downsample = None

        """
        下采样部分

        """
        
        #当步长不等于1，或者输入通道不等于 4xchannel的时候要进行下采样

        #stride=2,这个数值要自己传入的，channel，这个数值也是要自己传入的

        #只有这种情况才执行下采样：3个大块，第一个小块开始的时候才执行这个下采样，为了特征图大小维度一致
        #                      : 4个大块。。。。。。。。。。
        #                      ：6个大块。。。。。。。。。。
        #                      ：3个大块。。。。。。。。。。

        if stride != 1 or self.in_channel != channel * block.expansion:   #当步长不等于一，In_channel不等于四倍的block.expension
        #把特征的维度，宽高都要和前面的搞一致，这样就可以相加了

            downsample = nn.Sequential(
                nn.Conv2d(self.in_channel, channel * block.expansion, kernel_size=1, stride=stride, bias=False),  #stride=2
                nn.BatchNorm2d(channel * block.expansion))


        #定义一个列表 
        layers = []
        #
        #64，64，None,1
        #把第一个卷积层传入到列表中   第一个含有下采样，其他的没有
        #注意这个block()代表的是所要传入的参数，
        layers.append(block(self.in_channel, channel, downsample=downsample, stride=stride)) #stride=2(50) #stride=1(34)
        #256
        #重新定义4倍
        self.in_channel = channel * block.expansion   #256,512,1024,2048
        #(1,3)

        for i in range(1, block_num):    #（1到block_num） 不包括block_num  （0，block_num）0，       #1，2
            #block()->Bottleneck()
            layers.append(block(self.in_channel, channel))     #256, 64 
        #256
        """0
        inchannel=256,这个就是下采样的那个残差网络块，产生的，因为他是一个块一个块的，用block(self.in_channel=256,channel=64)
        #对于这个channel=64这个，self._make_layer(block, 64, blocks_num[0])，这个参数一定要对应，channel里面是64，调用make_layer()的时候
        要注意前面传入的block,后面传入的是channel,block里面的参数就是残差网络块的了
        终于0明0白
        """
        return nn.Sequential(*layers)
        #注意参数的对应，

    def forward(self, x):
        x = self.conv1(x)
        x = self.bn1(x)
        x = self.relu(x)
        x = self.maxpool(x)

        x = self.layer1(x)
        x = self.layer2(x)
        x = self.layer3(x)
        x = self.layer4(x)

        if self.include_top:
            x = self.avgpool(x)
            x = torch.flatten(x, 1)
            x = self.fc(x)

        return x


def resnet34(num_classes=1000, include_top=True):
    return ResNet(BasicBlock, [3, 4, 6, 3], num_classes=num_classes, include_top=include_top)



def resnet101(num_classes=1000, include_top=True):
    return ResNet(Bottleneck, [3, 4, 23, 3], num_classes=num_classes, include_top=include_top)
行走的鸭蛋
关注
  • 2
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
可视化学习笔记1-pytorch netron可视化网络结构图
LZL2020LZL的博客
05-18 806
前提安装netron、torch、torchvision包 执行下方代码即可 # 针对有网络模型，但还没有训练保存 .pth 文件的情况 import netron import torch.onnx from torch.autograd import Variable from torchvision.models import resnet50 # 以 resnet18 为例 myNet = resnet50() # 实例化 resnet18 x = torch.randn(16, 3, 40,
python动作识别库_用于动作识别的3D ResNets
weixin_33324197的博客
01-29 1253
3D ResNets for Action RecognitionUpdate (2020/4/13)We published a paper on arXiv.We uploaded the pretrained models described in this paper including ResNet-50 pretrained on the combined dataset with K...
利用Pytorch复现ResNet34网络
步步心愿的博客
08-29 929
根据残差网络的官方论文可知： ResNet34的计算图如下： 利用pytorch实现的代码如下： import numpy as np import torch import math # import torch import torchvision import torch.nn as nn import torch.nn.functional as F import torchvision...
pytorch-resnet34残差网络理解
weixin_52646021的博客
12-20 3252
工欲善其事必先利其器，在使用该网络之前要先了解该网络的具体细节，我今天也是第一次查资料，然后加上自己的理解去写这篇学习成长文章。 残差模块 class ResidualBlock(nn.Module): def __init__(self, inchannel, outchannel, stride=1, dowansample=None): super(ResidualBlock, self).__init__() self.left = nn.Sequential
3D-ResNets-PyTorch复现
weixin_47994925的博客
07-06 884
【视频分类】3D-ResNets-PyTorch复现
卷积神经网络ResNet50训练CIFAR-100图像分类Pytorch实现
07-03
# 卷积神经网络ResNet50训练CIFAR-100图像分类Pytorch实现 1. 使用pytorch调用CIFAR-100数据集，首次训练自动下载； 2. 包含训练代码，调用resnet50模型进行训练，使用交叉熵损失和SGD优化器； 3. 包含训练了50 ...
Resnet50卷积神经网络训练MNIST手写数字图像分类 Pytorch训练代码
02-05
# Resnet50卷积神经网络训练MNIST手写数字图像分类 Pytorch训练代码 1. 使用Pytorch定义ReNet50网络模型； 2. 使用Pytorch加载MNIST数据集，首次运行自动下载； 3. 实现训练MNIST手写数字图像分类，训练过程显示loss...
卷积神经网络-基于Pytorch+ResNet实现的动物10分类算法.zip
最新发布
05-03
卷积神经网络（Convolutional Neural Networks，简称CNN）是一种深度学习模型，特别适用于图像处理和计算机视觉任务。在本项目中，我们将探讨如何利用PyTorch这一强大的深度学习框架，结合ResNet（残差网络）结构来...
ResNet网络Pytorch实战.pdf
06-05
总结了ResNet的相关原理、网络结构，pytorch代码实现，并对自定义花类数据集进行训练和测试。
ResNet代码（超详细注释）+数据集，pytorch实现
10-02
ResNet，全称为残差网络（Residual Network），是深度学习领域中的一种经典卷积神经网络（CNN）架构，由Kaiming He等人在2015年提出。该模型解决了深度神经网络训练过程中的梯度消失问题，使得网络可以构建得更深，...
CIFAR与ResNet卷积神经网络实战.zip
10-09
人工智能的计算机视觉 越来越火热 本资源是 使用主流深度学习框架Pytorch来实现基础数据集cifar-10的10分类 效果还不错
SegNet_ResNet_resnet语义分割_segnet_语义分割resnet_迁移学习
09-11
语义分割：基于restnet50的segnet迁移学习，模型的训练，与使用；
卷积神经网络-ResNet
qqyouhappy的博客
05-23 452
import torch import torch.nn as nn def conv3x3(in_planes, out_plances, stride=1): return nn.Sequential( nn.Conv2d(in_planes, out_plances, kernel_size=3, padding=1, bias=False) ) #基础班 class BasicBlock(nn.Module): expansion = 1 .
Resnet残差网络|卷积神经网络|原理|新人总结
xl_xaio的博客
09-23 8068
Resnet使深层网络更加容易训练，使用残差连接让新的网络至少不会比旧的网络差，并且保证梯度不会消失可以一直跑得动。理论上不加残差网络也能够学到这么一个东西，但是实际上做不到，因为没有引导。而Resnet正是引导整个网络不会走偏，使得它训练出一个更深更好的模型。
经典卷积神经网络——resnet
热门推荐
Lightismore的博客
05-06 1万+
resnet前言一、resnet二、resnet网络结构三、resnet181.导包2.残差模块2.通道数翻倍残差模块3.rensnet18模块4.数据测试5.损失函数，优化器6.加载数据集，数据增强7.训练数据8.保存模型9.加载测试集数据，进行模型测试四、resnet深层对比 前言 随着深度学习的不断发展，从开山之作Alexnet到VGG，网络结构不断优化，但是在VGG网络研究过程中，人们发现随着网络深度的不断提高，准确率却没有得到提高，如图所示： 人们觉得深度学习到此就停止了，不能继续研究了，但是
经典卷积神经网络-ResNet
houjingchuan的博客
01-01 1562
残差神经网络(ResNet)是由微软研究院的何恺明、张祥雨、任少卿、孙剑等人提出的。ResNet 在2015 年的ILSVRC（ImageNet Large Scale Visual Recognition Challenge）中取得了冠军。残差神经网络的主要贡献是发现了“退化现象（Degradation）”，并针对退化现象发明了 “快捷连接（Shortcut connection）”，极大的消除了深度过大的神经网络训练困难问题。本文使用Pytorch复现了ResNet-18和ResNet-50。
现代卷积神经网络（ResNet）
qq_51957239的博客
03-08 2504
残差网络（Residual Network，简称 ResNet）是由微软研究院于 2015 年提出的一种深度卷积神经网络。它的主要特点是在网络中添加了“残差块”（Residual Block），有效地解决了深层网络的梯度消失和梯度爆炸问题，从而使得更深的网络结构可以训练得更好。
李沐动手学深度学习V2-风格迁移学习（style transfer learning）和代码实现
flyingluohaipeng的博客
06-13 2541
本节介绍如何使用卷积神经网络，自动将一个图像中的风格应用在另一图像之上，即风格迁移学习（style transfer learning）。 这里需要两张输入图像：一张是内容图像，另一张是风格图像，使用卷积神经网络修改内容图像，使其在风格上接近风格图像。 例如下图中内容图像为李沐老师在西雅图郊区的雷尼尔山国家公园拍摄的风景照，而风格图像则是一幅主题为秋天橡树的油画，最终输出的合成图像应用了风格图像的油画笔触让整体颜色更加鲜艳，同时保留了内容图像中物体主体的形状。 首先初始化合成图像，例如将其初始化为内容图像，
使用ResNet50实现CIFAR100数据集的训练
走出那座山
01-11 2489
本文将实现使用Resnet模型进行数据集进行模型的训练，并且将训练的模型效果进行有用信息的记录和将在训练过程当中训练效果的ACC最优的模型进行保存。
基于卷积神经网络的人脸识别 pytorch
06-26
### 回答1： 卷积神经网络（CNN）是一种深度学习算法，通常用于解决计算机视觉问题。在人脸识别领域，CNN非常适合提取人脸图像的特征，因为它可以自动学习并提取最有意义的特征。 PyTorch是一种基于Python的深度学习框架，可以帮助开发人员快速设计、构建和训练深度学习模型。在人脸识别领域，PyTorch已被广泛使用。 基于卷积神经网络的人脸识别模型通常由卷积层、池化层、全连接层和分类器组成。 卷积层主要用于提取人脸图像的特征，而池化层则用于减少模型的参数数量和计算量。 全连接层是用于该模型的分类器，通常用于将卷积层和池化层中提取的特征将其转换为可供分类器识别的形式。 在使用PyTorch进行人脸识别时，通常需要遵循以下步骤： 1. 收集和准备人脸数据集。 2. 构建卷积神经网络。 3. 通过将数据集分割成训练集和测试集来训练模型。 4. 评估模型的准确性以及确定任何需要进行调整的部分。 5. 使用模型进行实际的人脸识别任务。 基于卷积神经网络的人脸识别模型具有许多优势，包括高准确度、高效、可伸缩性和应用范围广，已经被广泛应用于面部识别，安全和监控系统等领域。 ### 回答2： 基于卷积神经网络的人脸识别是目前人工智能领域的热门应用之一，其中pytorch是当前广泛应用于该领域的深度学习框架之一。卷积神经网络是一种特殊类型的神经网络，具有良好的特征提取和分类能力，适合用于人脸识别领域。 在pytorch中，可以通过搭建卷积神经网络来进行人脸识别。首先，需要准备一组训练数据集和测试数据集，可以采用公开的人脸数据集，如LFW数据集。接着，可以使用pytorch的卷积层、池化层、全连接层等组件搭建卷积神经网络模型，可以采用经典的卷积神经网络结构，如AlexNet、VGG或ResNet等。 然后，需要对训练数据集进行数据增强、归一化等预处理操作，并使用损失函数来进行模型的训练和优化。同时，为了避免过拟合，可以采用一些正则化方法，如dropout、L1/L2正则化等。 最后，在测试阶段，可以将测试数据集输入训练好的人脸识别模型中，通过计算模型的预测结果（如softmax概率分布）来进行人脸识别判别。 总的来说，基于卷积神经网络的人脸识别pytorch实现较为简单易懂，具有很高的精度和效率，有着广泛的应用前景。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值