chainer-骨干网络backbone-ResNet代码重构【附源码】

已于 2023-02-13 08:20:28 修改
阅读量203 收藏
点赞数 1
分类专栏： 深度学习-chainer 文章标签： 分类 重构 python ResNet chainer
于 2023-01-15 10:19:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ctu_sue/article/details/128687532
版权

文章目录

前言

本文基于chainer实现ResNet网络结构，并基于torch的结构方式构建chainer版的，并计算ResNet的参数量。

代码实现(chainer官方)


class BasicBlock_Simple(chainer.Chain):
    def __init__(self, n_in, n_mid, n_out, stride=1, proj=False,initialW=chainer.initializers.HeNormal()):
        super(BasicBlock_Simple, self).__init__()
        with self.init_scope():
            self.conv3x3a = L.Convolution2D(n_in, n_mid, 3, stride, 1, initialW=initialW, nobias=True)
            self.conv3x3b = L.Convolution2D(n_mid, n_out, 3, 1, 1, initialW=initialW, nobias=True)
            self.bn_a = L.BatchNormalization(n_mid)
            self.bn_b = L.BatchNormalization(n_out)
            if proj:
                self.conv1x1r = L.Convolution2D(n_in, n_out, 1, stride, 0, initialW=initialW, nobias=True)
                self.bn_r = L.BatchNormalization(n_out)
        self.proj = proj

    def __call__(self, x):
        h = F.relu(self.bn_a(self.conv3x3a(x)))
        h = self.bn_b(self.conv3x3b(h))
        if self.proj:
            x = self.bn_r(self.conv1x1r(x))
        return F.relu(h + x)

class BottleNeck_Simple(chainer.Chain):
    def __init__(self, n_in, n_mid, n_out, stride=1, proj=False,initialW=chainer.initializers.HeNormal()):
        super(BottleNeck_Simple, self).__init__()
        with self.init_scope():
            self.conv1x1a = L.Convolution2D(n_in, n_mid, 1, stride, 0, initialW=initialW, nobias=True)
            self.conv3x3b = L.Convolution2D(n_mid, n_mid, 3, 1, 1, initialW=initialW, nobias=True)
            self.conv1x1c = L.Convolution2D(n_mid, n_out, 1, 1, 0, initialW=initialW, nobias=True)
            self.bn_a = L.BatchNormalization(n_mid)
            self.bn_b = L.BatchNormalization(n_mid)
            self.bn_c = L.BatchNormalization(n_out)
            if proj:
                self.conv1x1r = L.Convolution2D(n_in, n_out, 1, stride, 0, initialW=initialW, nobias=True)
                self.bn_r = L.BatchNormalization(n_out)
        self.proj = proj

    def __call__(self, x):
        h = F.relu(self.bn_a(self.conv1x1a(x)))
        h = F.relu(self.bn_b(self.conv3x3b(h)))
        h = self.bn_c(self.conv1x1c(h))
        if self.proj:
            x = self.bn_r(self.conv1x1r(x))
        return F.relu(h + x)

class ResBlock_Simple(chainer.ChainList):
    def __init__(self, block, n_layers, n_in, n_mid, n_out, stride=2):
        super(ResBlock_Simple, self).__init__()
        self.add_link(block(n_in, n_mid, n_out, stride, True))
        for _ in range(n_layers - 1):
            self.add_link(block(n_out, n_mid, n_out))

    def __call__(self, x):
        for f in self.children():
            x = f(x)
        return x
    
class ResNet_Simple(chainer.Chain):
    cfgs={
        'resnet18':{'block':BasicBlock_Simple, 'blocks_num':[2, 2, 2, 2],'expansion':1},
        'resnet34':{'block':BasicBlock_Simple, 'blocks_num':[3, 4, 6, 3],'expansion':1},
        'resnet50':{'block':BottleNeck_Simple, 'blocks_num':[3, 4, 6, 3],'expansion':4},
        'resnet101':{'block':BottleNeck_Simple, 'blocks_num':[3, 4, 23, 3],'expansion':4},
        'resnet152':{'block':BottleNeck_Simple, 'blocks_num':[3, 8, 36, 3],'expansion':4},
    }
    def __init__(self, num_classes=1000, model_name='resnet18',channels=3,image_size=224,initialW=chainer.initializers.HeNormal()):
        super(ResNet_Simple, self).__init__()
        with self.init_scope():
            self.conv1 = L.Convolution2D(in_channels=channels, out_channels = 64, ksize=7, stride=2, pad=3, initialW=initialW, nobias=True)
            self.bn1 = L.BatchNormalization(64)
                
            self.res2 = ResBlock_Simple(self.cfgs[model_name]['block'],self.cfgs[model_name]['blocks_num'][0], 64, 64, 64*self.cfgs[model_name]['expansion'], 1)
            self.res3 = ResBlock_Simple(self.cfgs[model_name]['block'],self.cfgs[model_name]['blocks_num'][1], 64*self.cfgs[model_name]['expansion'], 128, 128*self.cfgs[model_name]['expansion'])
            self.res4 = ResBlock_Simple(self.cfgs[model_name]['block'],self.cfgs[model_name]['blocks_num'][2], 128*self.cfgs[model_name]['expansion'], 256, 256*self.cfgs[model_name]['expansion'])
            self.res5 = ResBlock_Simple(self.cfgs[model_name]['block'],self.cfgs[model_name]['blocks_num'][3], 256*self.cfgs[model_name]['expansion'], 512, 512*self.cfgs[model_name]['expansion'])
            self.fc6 = L.Linear(512*self.cfgs[model_name]['expansion'], num_classes)

    def __call__(self, x):
        h = self.bn1(self.conv1(x))
        h = F.max_pooling_2d(F.relu(h), 2, 2)
        h = self.res2(h)
        h = self.res3(h)
        h = self.res4(h)
        h = self.res5(h)
        h = F.average_pooling_2d(h, h.shape[2:], stride=1)
        h = self.fc6(h)
        if chainer.config.train:
            return h
        return F.softmax(h)

代码实现(基于torch结构版的chainer)


class BasicBlock(chainer.Chain):
    expansion = 1

    def __init__(self,layers_num,block_num, in_channel, out_channel, stride=1, downsample=None,initialW=None, **kwargs):
        super(BasicBlock, self).__init__()
        layers=[]
        layers += [('block{0}_{1}_conv1'.format(layers_num,block_num),L.Convolution2D(in_channels=in_channel, out_channels=out_channel, ksize=3, stride=stride, pad=1, nobias=True,initialW=initialW))]
        layers += [('block{0}_{1}_bn1'.format(layers_num,block_num),L.BatchNormalization(out_channel))]
        layers += [('_block{0}_{1}_relu'.format(layers_num,block_num),ReLU())]
        
        layers += [('block{0}_{1}_conv2'.format(layers_num,block_num),L.Convolution2D(in_channels=out_channel, out_channels=out_channel, ksize=3, stride=1, pad=1, nobias=True,initialW=initialW))]
        layers += [('block{0}_{1}_bn2'.format(layers_num,block_num),L.BatchNormalization(out_channel))]
        
        self.downsample = downsample
        self.layers=layers
        
        with self.init_scope():
            for n in self.layers:
                if not n[0].startswith('_'):
                    setattr(self, n[0], n[1])
            if self.downsample is not None:
                for n in self.downsample:
                    if not n[0].startswith('_'):
                        setattr(self, n[0], n[1])
        
    def __call__(self, x):
        identity = x
        
        if self.downsample is not None:
            for n, f in self.downsample:
                if not n.startswith('_'):
                    identity = getattr(self, n)(identity)
                else:
                    identity = f.apply((identity,))[0]
                    
        for n, f in self.layers:
            if not n.startswith('_'):
                x = getattr(self, n)(x)
            else:
                x = f.apply((x,))[0]

        x += identity
        out = F.relu(x)

        return out

class Bottleneck(chainer.Chain):
    expansion = 4
    def __init__(self, layers_num,block_num, in_channel, out_channel, stride=1, downsample=None,initialW=None, **kwargs):
        super(Bottleneck, self).__init__()
        layers=[]
        layers += [('block{0}_{1}_conv1'.format(layers_num,block_num),L.Convolution2D(in_channels=in_channel, out_channels=out_channel, ksize=1, stride=1, nobias=True,initialW=initialW))]
        layers += [('block{0}_{1}_bn1'.format(layers_num,block_num),L.BatchNormalization(out_channel))]
        layers += [('_block{0}_{1}_relu1'.format(layers_num,block_num),ReLU())]
        layers += [('block{0}_{1}_conv2'.format(layers_num,block_num),L.Convolution2D(in_channels=out_channel, out_channels=out_channel, ksize=3, stride=stride, nobias=True, pad=1,initialW=initialW))]
        layers += [('block{0}_{1}_bn2'.format(layers_num,block_num),L.BatchNormalization(out_channel))]
        layers += [('_block{0}_{1}_relu2'.format(layers_num,block_num),ReLU())]
        layers += [('block{0}_{1}_conv3'.format(layers_num,block_num),L.Convolution2D(in_channels=out_channel, out_channels=out_channel*self.expansion, ksize=1, stride=1, nobias=True,initialW=initialW))]
        layers += [('block{0}_{1}_bn3'.format(layers_num,block_num),L.BatchNormalization(out_channel*self.expansion))]
        
        self.downsample = downsample
        self.layers=layers
        
        with self.init_scope():
            for n in self.layers:
                if not n[0].startswith('_'):
                    setattr(self, n[0], n[1])
            if self.downsample is not None:
                for n in self.downsample:
                    if not n[0].startswith('_'):
                        setattr(self, n[0], n[1])
        
    def forward(self, x):
        identity = x
        
        if self.downsample is not None:
            for n, f in self.downsample:
                if not n.startswith('_'):
                    identity = getattr(self, n)(identity)
                else:
                    identity = f.apply((identity,))[0]
        
        for n, f in self.layers:
            if not n.startswith('_'):
                x = getattr(self, n)(x)
            else:
                x = f.apply((x,))[0]

        x += identity
        out = F.relu(x)
        return out

class ResNet_Complex(chainer.Chain):
    cfgs={
        'resnet18':{'block':BasicBlock, 'blocks_num':[2, 2, 2, 2]},
        'resnet34':{'block':BasicBlock, 'blocks_num':[3, 4, 6, 3]},
        'resnet50':{'block':Bottleneck, 'blocks_num':[3, 4, 6, 3]},
        'resnet101':{'block':Bottleneck, 'blocks_num':[3, 4, 23, 3]},
        'resnet152':{'block':Bottleneck, 'blocks_num':[3, 8, 36, 3]},
    }
    
    def _make_layer(self,layers_num, block, channel, block_num, stride=1,initialW=None):
        downsample = None
        
        if stride != 1 or self.in_channel != channel * block.expansion:
            downsample = [
                ("downsample_{0}".format(layers_num),L.Convolution2D(in_channels=self.in_channel, out_channels=channel * block.expansion, ksize=1, stride=stride, nobias=True,initialW=initialW)),
                ("downsample_bn_{0}".format(layers_num),L.BatchNormalization(channel * block.expansion))
            ]

        layers = []
        # 每个conv2/conv3/conv4/conv5下的第一层残差结构
        layers += [("blobk_{0}_0".format(layers_num),block(layers_num,0,self.in_channel, channel, downsample=downsample, stride=stride,initialW=initialW))]
        self.in_channel = channel * block.expansion
        
        # 过滤调第一层残差结构，从1开始遍历
        for _ in range(1, block_num):
            layers += [('block_{0}_{1}'.format(layers_num,_),block(layers_num,_,self.in_channel, channel))]

        return layers
    
    def __init__(self,  num_classes=1000, model_name='resnet18',channels=3,image_size=224,initialW=chainer.initializers.HeNormal(), **kwargs):
        super(ResNet_Complex, self).__init__()
        block = self.cfgs[model_name]['block']
        blocks_num = self.cfgs[model_name]['blocks_num']
        
        self.in_channel = 64
        out_size = image_size
        
        layers=[]
        # 224*224*3 -> int((224-7+2*3)/2+1):112*112*64
        out_size = int((out_size-7+2*3)/2+1)
        layers += [('conv1',L.Convolution2D(channels, self.in_channel, ksize=7, stride=2, pad=3, nobias=True,initialW=initialW))]
        layers += [('bn1',L.BatchNormalization(self.in_channel))]
        layers += [('_relu1',ReLU())]
        # 112*112*64 -> 112/2:56*56*64
        out_size = math.ceil(out_size/2)
        layers += [("_maxpool1",MaxPooling2D(ksize=3, stride=2, pad=1))]
        
        # 56*56*64 -> 56*56*128
        self.layer1 = self._make_layer(1,block, 64, blocks_num[0],initialW=initialW)
        # 56*56*128 -> 28*28*256
        out_size = math.ceil(out_size/2)
        self.layer2 = self._make_layer(2,block, 128, blocks_num[1], stride=2,initialW=initialW)
        # 28*28*256 -> 14*14*512
        out_size = math.ceil(out_size/2)
        self.layer3 = self._make_layer(3,block, 256, blocks_num[2], stride=2,initialW=initialW)
        # 14*14*512 -> 7*7*2048
        out_size = math.ceil(out_size/2)
        self.layer4 = self._make_layer(4,block, 512, blocks_num[3], stride=2,initialW=initialW)
        layers += [('layer1',self.layer1)]
        layers += [('layer2',self.layer2)]
        layers += [('layer3',self.layer3)]
        layers += [('layer4',self.layer4)]
        
        layers += [('_avgpool',AveragePooling2D(ksize=out_size,stride=2,pad=0))]
        #  7*7*2048 -> 2048,num_classes
        layers += [('fc',L.Linear(512 * block.expansion, num_classes,initialW=initialW))]
        
        self.layers = layers
        with self.init_scope():
            for n in self.layers:
                if not n[0].startswith('_'):
                    setattr(self, n[0], n[1])
                if n[0].startswith('layer'):
                    for each_layer in n[1]:
                        if not each_layer[0].startswith('_'):
                            setattr(self, each_layer[0], each_layer[1])

    def forward(self, x):
        for n, f in self.layers:
            origin_size = x.shape
            if not n.startswith('_'):
                if n.startswith('layer'):
                    for n2, f2 in f:
                        if not n2.startswith('_'):
                            x = getattr(self, n2)(x)
                        else:
                            x = f2.apply((x,))[0]
                else:
                    x = getattr(self, n)(x)
            else:
                x = f.apply((x,))[0]
            print(n,origin_size,x.shape)  
        if chainer.config.train:
            return x
        return F.softmax(x)

注意此类就是ResNet的实现过程，注意网络的前向传播过程中，分了训练以及测试。
训练过程中直接返回x，测试过程中会进入softmax得出概率

调用方式

if __name__ == '__main__':
    batch_size = 4
    n_channels = 3
    image_size = 299
    num_classes = 10
    
    model_simple = ResNet_Simple(num_classes=num_classes, channels=n_channels,image_size=image_size)
    model_complex = ResNet_Complex(num_classes=num_classes, channels=n_channels,image_size=image_size)
    print("参数量",model_simple.count_params())
    print("参数量",model_complex.count_params())
    
    x = np.random.rand(batch_size, n_channels, image_size, image_size).astype(np.float32)
    t = np.random.randint(0, num_classes, size=(batch_size,)).astype(np.int32)
    with chainer.using_config('train', True):
        y1 = model_simple(x)
        y2 = model_complex(x)
    loss1 = F.softmax_cross_entropy(y1, t)
    loss2 = F.softmax_cross_entropy(y2, t)
    print(loss1.data,loss2.data)

在这里插入图片描述

爱学习的广东仔
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
chainer-图像分类-resnet网络结构
09-20
在文章与之前编写的图像分类框架构建组合使用，这里只讲述基于chainer的模型构建，本次讲解如何使用chainer构建ResNet网络结构以及对应的其他版本：resnet50，resnet101，resnet152。
(三)重构ResNet50以诊断COVID-19
寒冰屋的专栏
06-28 504
目录 重构基础模型 冻结权重 下一步 下载源 - 300.4 KB 在本系列文章中，我们将应用深度学习网络ResNet50来诊断胸部X射线图像中的Covid-19。我们将使用Python的TensorFlow库在Jupyter Notebook上训练神经网络。 此项目所需的工具和库是： IDE： Jupyter Notebook 库： TensorFlow 2.0 Keras NumPy Matplotlib CV2 我们假设您熟悉使用Python和Jupyter notebook进
Backbone和以ResNet为例的几种操作方法
mashiro1323的博客
04-21 661
在图像分类任务中，通常会在ResNet的顶部添加一个全局平均池化层和一个全连接层，以生成最终的预测结果。通过对backbone进行适当的处理，可以更好地利用ResNet作为深度学习模型的优点，从而实现更准确、更高效的视觉计算任务。“backbone”通常指的是深度学习模型中的主体架构，它由多个层次组成，每个层次都有自己的功能和特点。总之，“backbone”通常是指深度神经网络模型中的主体架构，它是整个模型的核心部分，也是决定模型性能的重要因素之一。
2024年最新PyTorch ResNet 实现图片分类_return torch(1)，满满干货
最新发布
2401_84182020的博客
05-10 790
batch_size = 1024 # 一次训练的样本数目learning_rate = 0.0001 # 学习率iteration_num = 20 # 迭代次数optimizer = torch.optim.Adam(network.parameters(), lr=learning_rate) # 优化器。
以resnet50为backbone的ssd模型以及代码总结
qq_43238260的博客
08-19 8937
ssd模型图示 模型原理 ssd主要的思想是以cnn做为特征提取网络，例如以resnet50做为提取网络，删除掉resnet后面的全连接层，再增添几层额外的卷基层提取特征，得到不同尺度的特征图，然后我们让这些不同层次的特征图分别预测不同大小的目标，浅层卷积层提取到的是比较细小的特征，越深层的卷积提取到的信息会越丰富，因此我们让浅层的卷积特征图去检测小的目标，让深层的卷积特征图去检测大的目标。 还是直接上图和代码吧 ssd原论文应该是使用的vgg做为backbone，这里我做了一点修改，使用更优秀的resn
pytorch 中resnet如何快速加载官方提供的预训练模型（推荐）
Lily的博客
07-23 4820
在做神经网络的搭建过程，经常使用pytorch中的resnet作为backbone，特别是resnet50,比如下面的这个网络设定 import torchimport torch.nn as nnfrom torchvision import datasets, transformsfrom torchvision import modelsclass base_resnet(nn.Module): de...
分享几种resnet框架的backbone代码（pytorch）
peihj的博客
11-20 2401
import torchvision import torch.nn as nn __all__ = ["ResNet18", "ResNet50","resnext50_32x4d"] class ResNet18(nn.Module): output_size = 512 def __init__(self, pretrained=True): super(ResNet18, self).__init__() pretrained = torch.
chainer-ClariNet:ClariNet的Chainer实现
03-21
Chainer-ClariNet ClariNet（ ）的Chainer实现。结果使用VCTK Corpus训练的自回归WaveNet（单高斯版）高斯IAF学生接受LJ-Speech培训要求我训练并产生了python（3.5.2）链接器（5.0.0b4） librosa（0.6.2） ...
chainer-图像分类-ResNext网络结构
09-20
与resnet网络结构类似，这里主要是实现resnext的网络结构
chainer-Xception:Chainer执行文件“ Xception”
05-18
Chainer-Xception 这个库包含实现供纸： （CVPR 2017年，弗朗索瓦CHOLLET）。 要求 链接器4.0.0+ CuPy 4.0.0+ 使用预先训练的模型 从下载经过预训练的caffemodel。 如果将pretrained_model指定为xception.caffe...
chainer-FaceNet源码，可直接使用
09-20
人脸关键点检测，检测到人脸后对人脸关键点进行人脸对齐(转换)，再将人脸裁剪出，输入神经网络中，最后输出人脸嵌入特征(超球面欧式空间)，该特征可用于聚类、相似性检测、分类等。 本次使用国外已有模型，本人没有...
度学习pytorch实战六：ResNet50网络图像分类篇自建花数据集图像分类（5类）超详细代码
qq_55433305的博客
06-12 1万+
1.数据集简介、训练集与测试集划分 2.模型相关知识 3.model.py——定义ResNet50网络模型 4.train.py——加载数据集并训练，训练集计算损失值loss，测试集计算accuracy，保存训练好的网络参数 5.predict.py——利用训练好的网络参数后，用自己找的图像进行分类测试
深度学习基于Resnet18的图像多分类--训练自己的数据集(超详细 含源码)
热门推荐
weixin_49345320的博客
06-22 1万+
深度学习基于Resnet18的图像多分类--训练自己的数据集(超详细 含源码)
基于ResNet50算法实现图像分类识别
Rocky006的博客
07-18 3871
ResNet50是一种基于深度卷积神经网络（Convolutional Neural Network，CNN）的图像分类算法。它是由微软研究院的Kaiming He等人于2015年提出的，是ResNet系列中的一个重要成员。ResNet50相比于传统的CNN模型具有更深的网络结构，通过引入残差连接（residual connection）解决了深层网络训练过程中的梯度消失问题，有效提升了模型的性能。深度卷积神经网络（CNN） CNN是一种专门用于图像处理的神经网络结构，具有层次化的特征提取能力。
resnet图像分类代码
mqdlff_python的博客
10-13 189
resnet图像分类代码
图像识别之ResNet（结构详解以及代码实现）
weixin_44598554的博客
02-18 2871
在人工智能的浪潮中，深度学习已经成为了推动计算机视觉、自然语言处理等领域突破的关键技术。在这众多技术中，ResNet（残差网络）无疑是一个闪耀的名字。自从2015年Kaiming He等人提出ResNet架构以来，它不仅在图像识别领域取得了革命性的进展，更影响了后续神经网络设计的诸多方面。那么，什么是ResNet？简而言之，ResNet是一种深度卷积神经网络（CNN），其核心创新在于引入了“残差学习”的概念，通过残差块（residual block）的设计优雅地解决了深度网络训练中的退化问题。
chainer-图像分类-ResNet【附源码】
ctu_sue的博客
09-14 1277
在文章与之前编写的图像分类框架构建组合使用，这里只讲述基于chainer的模型构建，本次讲解如何使用chainer构建ResNet网络结构以及对应的其他版本：resnet50，resnet101，resnet152。并且考虑到有些电脑的显存不高，所以使用alpha降低通道数，但是效果经过测试后还是比较理想的。本次使用ResNet网络结构以及对应他的一些不同深度的结构进行测试，效果对比，调用只需要在图像分类框架篇中替换model即可。
图像分类篇-5：ResNet+ResNeXt
qq_43312094的博客
12-30 337
自己学习这方面视频的一个记录
【图像分类案例】(8) ResNet50 鸟类图像4分类，附Pytorch完整代码
博观而约取，厚积而薄发
05-29 1万+
大家好，今天和大家分享一些如何使用 Pytorch 搭建 ResNet50 卷积神经网络模型，并使用迁移学习的思想训练网络，完成鸟类图片的预测。 ResNet 的原理和 TensorFlow2实现方式可以看我之前的两篇博文，这里就不详细说明原理了。 ResNet18、34：https://blog.csdn.net/dgvv4/article/details/122396424 ResNet50：https://blog.csdn.net/dgvv4/article/details/12187...
ModuleNotFoundError: No module named 'chainer'
07-27
回答: ModuleNotFoundError: No module named 'chainer'错误通常是由于缺少chainer模块导致的。您可以尝试使用pip安装chainer来解决这个问题。请在命令行中运行以下命令: "pip install chainer"。这将安装chainer...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

爱学习的广东仔

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值