最直接的ResNet-34 PyTorch代码

最新推荐文章于 2025-02-18 12:41:39 发布
最新推荐文章于 2025-02-18 12:41:39 发布
阅读量2.3k 收藏 9
点赞数 3
分类专栏： 深度技术学习 文章标签： pytorch 深度学习 神经网络 ResNet源码 ResNet-34
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lillllllll/article/details/120320911
版权

最直接的ResNet-34 PyTorch代码，根据官方的源码手写的，名称对应关系：

官方是

本代码去掉了层和子层之间的点号‘.’

 这样做的好处在于名称和官方有一一对应关系，可以方便用load_state_dict（）装载云训练参数。下面是具体代码（代码有点长）

# -*- coding: utf-8 -*-
import torch
from torchvision.models.resnet import resnet34
import torch.nn as nn
from collections import OrderedDict
import torch 

class MyResNetD(nn.Module):
    # OutChannal represents kernal size.
    def __init__(self):
        super(MyResNetD, self).__init__()
        self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3, bias=False)
        self.bn1 = nn.BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        self.relu = nn.ReLU(inplace=False)
        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)        
        # layer1 0
        self.layer10conv1=nn.Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        self.layer10bn1=nn.BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        self.layer10relu=nn.ReLU(inplace=True)     
        self.layer10conv2=nn.Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        self.layer10bn2=nn.BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)

                # layer1 1
        self.layer11conv1=nn.Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        self.layer11bn1=nn.BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        self.layer11relu=nn.ReLU(inplace=True)     
        self.layer11conv2=nn.Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        self.layer11bn2=nn.BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        
                # layer1 2
        self.layer12conv1=nn.Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        self.layer12bn1=nn.BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        self.layer12relu=nn.ReLU(inplace=True)     
        self.layer12conv2=nn.Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        self.layer12bn2=nn.BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        
                # layer2 0
        self.layer20conv1=nn.Conv2d(64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
        self.layer20bn1=nn.BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        self.layer20relu=nn.ReLU(inplace=True)     
        self.layer20conv2=nn.Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        self.layer20bn2=nn.BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        self.layer20downsample0=nn.Conv2d(64, 128, kernel_size=(1, 1), stride=(2, 2), bias=False)
        self.layer20downsample1=nn.BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)

                 # layer2 1
        self.layer21conv1=nn.Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        self.layer21bn1=nn.BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        self.layer21relu=nn.ReLU(inplace=True)     
        self.layer21conv2=nn.Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        self.layer21bn2=nn.BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        
                 # layer2 2
        self.layer22conv1=nn.Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        self.layer22bn1=nn.BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        self.layer22relu=nn.ReLU(inplace=True)     
        self.layer22conv2=nn.Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        self.layer22bn2=nn.BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
                # layer2 3
        self.layer23conv1=nn.Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        self.layer23bn1=nn.BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        self.layer23relu=nn.ReLU(inplace=True)     
        self.layer23conv2=nn.Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        self.layer23bn2=nn.BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
           

        # layer3 0
        self.layer30conv1=nn.Conv2d(128, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
        self.layer30bn1=nn.BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        self.layer30relu=nn.ReLU(inplace=True)     
        self.layer30conv2=nn.Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        self.layer30bn2=nn.BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        self.layer30downsample0=nn.Conv2d(128, 256, kernel_size=(1, 1), stride=(2, 2), bias=False)
        self.layer30downsample1=nn.BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)

        # layer 3 1
        self.layer31conv1=nn.Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        self.layer31bn1=nn.BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        self.layer31relu=nn.ReLU(inplace=True)     
        self.layer31conv2=nn.Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        self.layer31bn2=nn.BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  
          # layer 3 2
        self.layer32conv1=nn.Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        self.layer32bn1=nn.BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        self.layer32relu=nn.ReLU(inplace=True)     
        self.layer32conv2=nn.Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        self.layer32bn2=nn.BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          # layer 3 3
        self.layer33conv1=nn.Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        self.layer33bn1=nn.BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        self.layer33relu=nn.ReLU(inplace=True)     
        self.layer33conv2=nn.Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        self.layer33bn2=nn.BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  
        # layer 3 4
        self.layer34conv1=nn.Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        self.layer34bn1=nn.BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        self.layer34relu=nn.ReLU(inplace=True)     
        self.layer34conv2=nn.Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        self.layer34bn2=nn.BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  
        # layer 3 5
        self.layer35conv1=nn.Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        self.layer35bn1=nn.BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        self.layer35relu=nn.ReLU(inplace=True)     
        self.layer35conv2=nn.Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        self.layer35bn2=nn.BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  
        # layer 4 0
        self.layer40conv1=nn.Conv2d(256, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
        self.layer40bn1=nn.BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        self.layer40relu=nn.ReLU(inplace=True)     
        self.layer40conv2=nn.Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        self.layer40bn2=nn.BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        self.layer40downsample0=nn.Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)
        self.layer40downsample1=nn.BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)

      # layer 4 1
        self.layer41conv1=nn.Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        self.layer41bn1=nn.BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        self.layer41relu=nn.ReLU(inplace=True)     
        self.layer41conv2=nn.Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        self.layer41bn2=nn.BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          # layer 4 2
        self.layer42conv1=nn.Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        self.layer42bn1=nn.BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        self.layer42relu=nn.ReLU(inplace=True)     
        self.layer42conv2=nn.Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        self.layer42bn2=nn.BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
       
        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
        self.fc = nn.Linear(512, 1000)

    def forward(self, x):
        x = self.conv1(x)
        x = self.bn1(x)
        x = self.relu(x)
        x = self.maxpool(x) 
        
        # layer1 0
        identity=x
        x=self.layer10conv1(x)
        x=self.layer10bn1(x)
        x=self.layer10relu(x)
        x=self.layer10conv2(x)
        x=self.layer10bn2(x)
        x+=identity
        x=self.layer10relu(x)

        # layer1 1
        identity=x
        x=self.layer11conv1(x)
        x=self.layer11bn1(x)
        x=self.layer11relu(x)
        x=self.layer11conv2(x)
        x=self.layer11bn2(x)
        x+=identity
        x=self.layer11relu(x)

        # layer1 2
        identity=x
        x=self.layer12conv1(x)
        x=self.layer12bn1(x)
        x=self.layer12relu(x) #relu
        x=self.layer12conv2(x)
        x=self.layer12bn2(x)
        x+=identity
        x=self.layer12relu(x)#relu

        # layer2 0
        identity=x       
        x=self.layer20conv1(x)
        x=self.layer20bn1(x)
        x=self.layer20relu(x)#relu
        x=self.layer20conv2(x)
        x=self.layer20bn2(x)        
        identity=self.layer20downsample0(identity)
        identity=self.layer20downsample1(identity)
        x+=identity
        x=self.layer20relu(x)#relu

        # layer2 1
        identity=x       
        x=self.layer21conv1(x)
        x=self.layer21bn1(x)
        x=self.layer21relu(x)#relu
        x=self.layer21conv2(x)
        x=self.layer21bn2(x)   
        x+=identity
        x=self.layer20relu(x)#relu

  # layer2 2
        identity=x       
        x=self.layer22conv1(x)
        x=self.layer22bn1(x)
        x=self.layer22relu(x)#relu
        x=self.layer22conv2(x)
        x=self.layer22bn2(x)   
        x+=identity
        x=self.layer22relu(x)#relu
  # layer2 3
        identity=x       
        x=self.layer23conv1(x)
        x=self.layer23bn1(x)
        x=self.layer23relu(x)#relu
        x=self.layer23conv2(x)
        x=self.layer23bn2(x)   
        x+=identity
        x=self.layer23relu(x)#relu
      # layer 3 0
        identity=x       
        x=self.layer30conv1(x)
        x=self.layer30bn1(x)
        x=self.layer30relu(x)#relu
        x=self.layer30conv2(x)
        x=self.layer30bn2(x)        
        identity=self.layer30downsample0(identity)
        identity=self.layer30downsample1(identity)
        x+=identity
        x=self.layer30relu(x)#relu
   
      # layer 3 1
        identity=x       
        x=self.layer31conv1(x)
        x=self.layer31bn1(x)
        x=self.layer31relu(x)#relu
        x=self.layer31conv2(x)
        x=self.layer31bn2(x)        
        x+=identity
        x=self.layer31relu(x)#relu

          # layer 3 2
        identity=x       
        x=self.layer32conv1(x)
        x=self.layer32bn1(x)
        x=self.layer32relu(x)#relu
        x=self.layer32conv2(x)
        x=self.layer32bn2(x)        
        x+=identity
        x=self.layer32relu(x)#relu  

      # layer 3 3
        identity=x       
        x=self.layer33conv1(x)
        x=self.layer33bn1(x)
        x=self.layer33relu(x)#relu
        x=self.layer33conv2(x)
        x=self.layer33bn2(x)        
        x+=identity
        x=self.layer33relu(x)#relu 
     
        # layer 3 4
        identity=x       
        x=self.layer34conv1(x)
        x=self.layer34bn1(x)
        x=self.layer34relu(x)#relu
        x=self.layer34conv2(x)
        x=self.layer34bn2(x)        
        x+=identity
        x=self.layer34relu(x)#relu
        # layer 3 5
        identity=x       
        x=self.layer35conv1(x)
        x=self.layer35bn1(x)
        x=self.layer35relu(x)#relu
        x=self.layer35conv2(x)
        x=self.layer35bn2(x)        
        x+=identity
        x=self.layer35relu(x)#relu

        # layer 4 0
        identity=x       
        x=self.layer40conv1(x)
        x=self.layer40bn1(x)
        x=self.layer40relu(x)#relu
        x=self.layer40conv2(x)
        x=self.layer40bn2(x)        
        identity=self.layer40downsample0(identity)
        identity=self.layer40downsample1(identity)
        x+=identity
        x=self.layer40relu(x)#relu

        # layer 4 1
        identity=x       
        x=self.layer41conv1(x)
        x=self.layer41bn1(x)
        x=self.layer41relu(x)#relu
        x=self.layer41conv2(x)
        x=self.layer41bn2(x)
        x+=identity
        x=self.layer41relu(x)#relu
        # layer 4 2
        identity=x       
        x=self.layer42conv1(x)
        x=self.layer42bn1(x)
        x=self.layer42relu(x)#relu
        x=self.layer42conv2(x)
        x=self.layer42bn2(x)
        x+=identity
        x=self.layer42relu(x)#relu

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

        return x
from torchvision import models
Onet=models.resnet34(pretrained=True) #官方模型，包含了预训练参数
OWeight=Onet.state_dict()

 
net=MyResNetD()  #自己的模型，参数名称变化了
Cweight=net.state_dict()

for k,v in OWeight.items():    
    if k in Cweight.keys():   #加载相同的参数名称
        Cweight[k]=v        
    if k.startswith('layer') and 'downsample' not in k : #加载代码生成的layer但
            kt=k.replace('.','',2)                       #不包含downsample的名称
            Cweight[kt]=v
    if 'downsample' in k : #加载downsample层名称的参数
            kt=k.replace('.','',3)
            Cweight[kt]=v
net.load_state_dict(Cweight)

out=torch.rand(10,3,224,224)
#对比输出结果
out2=net(out)
outO=Onet(out)
print(out2[1,0:10])
print(outO[1,0:10])

用测试数据看看两者是否一样，上述代码输出

上面两个网络输出结果一致，代码改写成功

【PyTorch】：ResNet34实现
晓峰博客笔记
06-23 3237
# Pytorch 0.4.0 ResNet34实现cifar10分类. # @Time: 2018/6/17 # @Author: xfLi import torchvision as tv import torch as t import torchvision.transforms as transforms from torch import nn from torch.utils.da...
Inception-Resnet-v1、Inception-Resnet-v2学习笔记（附Pytorch代码）_inception-resnet-v1 代码(2)
2401_83620927的博客
04-28 716
Reduction-A模块：输入35*35*256，输出17*17*896.Reduction-B模块：输入17*17*896，输出8*8*1792.IR-B模块*10：输入17*17*896，输出17*17*896.IR-A模块*5：输入35*35*256，输出35*35*256.Stem模块：输入299*299*3，输出35*35*256.IR-C模块*5：输入8*8*1792，输出8*8*1792.stem模块：输入299*299*3，输出35*35*384.Reduction-A结构。
ResNet34 构建（继续优化代码。。）
weixin_46088823的博客
11-11 609
【代码】ResNet34 构建（继续优化代码。。）
《深度学习》——ResNet网络
最新发布
will be blogging
02-18 6425
定义残差块类，继承自 nn.Module# 调用父类的构造函数# 定义第一个卷积层，输入通道数为 channels_in，输出通道数为 30，卷积核大小为 5，填充为 2# 定义第二个卷积层，输入通道数为 30，输出通道数为 channels_in，卷积核大小为 3，填充为 1# 输入数据通过第一个卷积层# 经过第一个卷积层的输出再通过第二个卷积层# 将输入 x 与卷积输出 out 相加，并通过 ReLU 激活函数# 定义 ResNet 网络类，继承自 nn.Module。
C ++中实现ResNet34代码
ywfwyht的博客
05-26 945
ResNet是一个深度残差神经网络，其基础结构是由多个残差块（Residual block）堆叠而成的。每个残差块包含两个卷积层和一个跳跃连接（shortcut connection），跳跃连接负责绕过这两个卷积层，直接连接两个卷积层的输入和输出，从而允许信息在深度网络中跳过某些层。请注意，这只是一个示例，实际上，ResNet34模型包含更多的层，每个层都需要设计相应的卷积核和步长。您可能需要花费更多的时间来实现一个完整的模型。实现ResNet34需要实现一些基本的模块，如卷积层、残差块等。
Restnet34网络结构及代码
weixin_46672808的博客
12-23 1749
看了https://blog.csdn.net/rothschild666/article/details/123497166这个博客的代码，感觉有错误。我自己又修改了一下。torch环境是1.8.1。
Resnet 18 及34 的代码复现（基于李沐的动手学深度学习）
m0_57122465的博客
05-16 2614
BasicBlock模块有两种模式，一种是输入X以后需要用1x1卷积层来进行下采样，从而升维，将通道数加倍，其中的步幅stride=2，一种是不需要1x1卷积层，直接将x与拟合的残差F(X)相加。其中conv_3,conv_4,conv_5的三个模块中每个模块中的第一个残差块的输入输出通道数分别从64——128,128——256,256——512，并需要进行1x1的卷积将输入x下采样，从而保证输出的x的通道数与两层3X3卷积后的通道数一致。上述的num_classes表示需要分类的类别数。
人工智能-深度学习-ResNet网络-使用Pytorch实现ResNet50进行跨年龄人脸识别-Pytorch
03-16
2. 源代码文件：可能包括PyTorch实现的ResNet50模型以及训练、验证和测试代码。 3. 数据集：可能包含跨年龄人脸识别所需的人脸图像数据，可能分为训练集、验证集和测试集。 4. 预训练模型：如果有的话，可能提供了预...
resnet-pytorch
05-17
ResNet-34 CIFAR-10 93.5％ 95.5％ ResNet-50 CIFAR-10 90.3％ 95.0％ ResNet-10 CIFAR-100 75.5％ 75.3％ ResNet-18 CIFAR-100 76.7％ 79.2％ ResNet-34 CIFAR-100 71.4％ 79.4％ 评论和实施...
【学习笔记】resnet-18 pytorch源代码解读
热门推荐
lcn463365355的博客
11-17 3万+
对于pytorch中预定义的ResNet-18的代码进行简单的分析
深度学习ResNet网络-使用Pytorch实现ResNet50进行跨年龄人脸识别项目源码（高分项目）
10-31
深度学习ResNet网络-使用Pytorch实现ResNet50进行跨年龄人脸识别项目源码（高分项目），该项目是个人毕设项目，答辩评审分达到98分，代码都经过调试测试，确保可以运行！欢迎下载使用，可用于小白学习、进阶。该资源...
resnet34-333f7ec4.pth
03-14
resnet34-333f7ec4.pth
resnet34_to_TNN_imageclass.rar
12-25
根据官方文档，通过TNN中的tools的工具吧pytorch导出的torchvision.resnet34的模型转换成tnn模型，并整理tnn的库，整理成一个demo，文档为CMake项目
RESNET、GOOGLENET等Python代码实现
07-19
懒得描述了，ResNet,GoogleNet等网络结构的Python实现，很好的资源
TensorFlow2.0_ResNet:使用TensorFlow-2.0的ResNet（ResNet18，ResNet34，ResNet50，ResNet101，ResNet152）实现
05-22
TensorFlow2.0_ResNet 使用TensorFlow-2.0的ResNet（ ResNet18，ResNet34，ResNet50，ResNet101，ResNet152 ）实现 有关更多的CNN，请参见 。 火车 要求： Python> = 3.6 Tensorflow == 2.0.0 要在自己的数据集上训练ResNet，可以将数据集放在原始数据集文件夹下，目录应如下所示： |——original dataset |——class_name_0 |——class_name_1 |——class_name_2 |——class_name_3 运行脚本split_dataset.py将原始数据集拆分为训练集，有效集和测试集。 更改config.py中的相应参数。 运行train.py开始培训。 评估 运行valuate.py评估模型在测
resnet-34训练c-10分类模型
12-30
93%
ResNet学习笔记
weixin_44382711的博客
03-06 347
https://www.bilibili.com/video/BV1T7411T7wa 分析ResNet网络的结构，了解Batch Normalization和迁移学习的相关概念 不能简单堆叠cnn与pool：效果差了 1.梯度消失与爆炸明显 消失： 解决：数据标准化处理，模型初始化，以及BatchNormalization 2.退化的问题 用残差结构解决 两种残差结构：左面的给小的，右边的给大的 7：35 很详细 下采样（用右边的卷积核降维） 迁移学习： 31：58 model
【源码解读】Pytorch实现ResNet官方版
darkeyers的博客
05-23 7942
ResNet（残差神经网络），其重要性和对神经网络的提升不再赘述，详见论文，这里对ResNet在pytorch上实现进行解读。 resnet.py import torch.nn as nn import torch.utils.model_zoo as model_zoo 解读：写入必要的包，其中torch.nn 为其提供基础函数，model_zoo提供权重数据的下载。 __all_...
Pytorch之torchvision.models的resnet34模型源码
math_computer的博客
08-22 3655
源码地址：https://github.com/pytorch/vision/blob/master/torchvision/models/resnet.py 注意torchvision版本，之前的版本如0.2.0中，self.avgpool=nn.AvgPool2d(7, stride=1)，这样的话输入就限定为224*224了，但是版本0.4.0中，就是self.avgpool=nn.Ada...
resnet-v2 pytorch
09-17
ResNet-v2是一种深度卷积神经网络架构，用于图像分类和其他计算机视觉任务。它是对ResNet的一种改进，引入了残差模块的变体，包括预激活残差单元和身份映射（identity mapping）。在PyTorch中，您可以使用torchvision库来加载和使用预训练的ResNet-v2模型。 首先，您需要安装torchvision库。可以使用以下命令进行安装： ``` pip install torchvision ``` 然后，您可以使用以下代码加载ResNet-v2模型： ```python import torch import torchvision.models as models model = models.resnet50(pretrained=True) ``` 这将加载一个预训练的ResNet-50模型。您可以根据需要选择不同的ResNet版本，如resnet18、resnet34等。 接下来，您可以使用模型进行推理或微调。下面是一个使用ResNet-50模型进行推理的示例： ```python input = torch.randn(1, 3, 224, 224) # 输入图像的形状为[batch_size, channels, height, width] output = model(input) ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值