Pytorch intermediate(二) ResNet

这篇具有很好参考价值的文章主要介绍了Pytorch intermediate(二) ResNet。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

实现了残差网络,残差网络结构。代码比之前复杂很多

conv3x3:将输入数据进行一次卷积,将数据转换成为,残差块需要的shape大小

ResidualBlock:残差块,也是所谓的恒等块。为什么被称为恒等块,大概可以理解为经过几层卷积过后大小形状不变,并且能和输入相加;如果形状变了,那么输入也会利用一次卷积得到和残差块输出大小相同的数据块。

       可以看到在残差块中有一个判断,就是判断输入数据是否被向下采样,也就是形状是否变化,如果变化就进行上述处理。

ResNet:构建一个完整的残差网络。传入参数是一个残差块的结构,还有每一层中残差块的个数元组。重点看以下其中的层次结构。

       conv3x3:将输入图片变成16通道

       输入通道数:16

       layer1:输入通道:16,输出通道:16,padding = 0,stride = 0

       layer2:输入通道:16,输出通道:32,padding = 0, stride = 2。由于输入不等于输出通道数,增加了一层卷积层,并且带有对应的stride。

       layer3:输入通道:32,输出通道:64,其余同上

       pooling:均值池化

       fc:全连接


       update_lr:在每个epoch之后实现对learning_rate的下降

       同样由于加入了batchnorm层,测试时需要使用model.eval()


网络结构:

ResNet(
  (conv): Conv2d(3, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
  (bn): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  (relu): ReLU(inplace)
  (layer1): Sequential(
    (0): ResidualBlock(
      (conv1): Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace)
      (conv2): Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
    (1): ResidualBlock(
      (conv1): Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace)
      (conv2): Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
  )
  (layer2): Sequential(
    (0): ResidualBlock(
      (conv1): Conv2d(16, 32, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace)
      (conv2): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (downsample): Sequential(
        (0): Conv2d(16, 32, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
        (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (1): ResidualBlock(
      (conv1): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace)
      (conv2): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
  )
  (layer3): Sequential(
    (0): ResidualBlock(
      (conv1): Conv2d(32, 64, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace)
      (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)
      (downsample): Sequential(
        (0): Conv2d(32, 64, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
        (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (1): ResidualBlock(
      (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace)
      (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)
    )
  )
  (avg_pool): AvgPool2d(kernel_size=8, stride=8, padding=0)
  (fc): Linear(in_features=64, out_features=10, bias=True)
)

代码如下 :文章来源地址https://www.toymoban.com/news/detail-707779.html

import torch
import torch.nn as nn
import torchvision
import torchvision.transforms as transforms


# Device configuration
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

# Hyper-parameters
num_epochs = 80
learning_rate = 0.001

# Image preprocessing modules
transform = transforms.Compose([
    transforms.Pad(4),
    transforms.RandomHorizontalFlip(),
    transforms.RandomCrop(32),
    transforms.ToTensor()])

# CIFAR-10 dataset
train_dataset = torchvision.datasets.CIFAR10(root='../../data/',
                                             train=True, 
                                             transform=transform,
                                             download=True)

test_dataset = torchvision.datasets.CIFAR10(root='../../data/',
                                            train=False, 
                                            transform=transforms.ToTensor())

# Data loader
train_loader = torch.utils.data.DataLoader(dataset=train_dataset,
                                           batch_size=100, 
                                           shuffle=True)

test_loader = torch.utils.data.DataLoader(dataset=test_dataset,
                                          batch_size=100, 
                                          shuffle=False)

# 3x3 convolution
def conv3x3(in_channels, out_channels, stride=1):
    return nn.Conv2d(in_channels, out_channels, kernel_size=3, 
                     stride=stride, padding=1, bias=False)

# Residual block
class ResidualBlock(nn.Module):
    def __init__(self, in_channels, out_channels, stride=1, downsample=None):
        super(ResidualBlock, self).__init__()
        self.conv1 = conv3x3(in_channels, out_channels, stride)
        self.bn1 = nn.BatchNorm2d(out_channels)
        self.relu = nn.ReLU(inplace=True)
        self.conv2 = conv3x3(out_channels, out_channels)
        self.bn2 = nn.BatchNorm2d(out_channels)
        self.downsample = downsample
        
    def forward(self, x):
        residual = x
        out = self.conv1(x)
        out = self.bn1(out)
        out = self.relu(out)
        out = self.conv2(out)
        out = self.bn2(out)
        if self.downsample:
            residual = self.downsample(x)
        out += residual
        out = self.relu(out)
        return out

# ResNet
class ResNet(nn.Module):
    def __init__(self, block, layers, num_classes=10):
        super(ResNet, self).__init__()
        self.in_channels = 16
        self.conv = conv3x3(3, 16)
        self.bn = nn.BatchNorm2d(16)
        self.relu = nn.ReLU(inplace=True)
        self.layer1 = self.make_layer(block, 16, layers[0])
        self.layer2 = self.make_layer(block, 32, layers[1], 2)
        self.layer3 = self.make_layer(block, 64, layers[2], 2)
        self.avg_pool = nn.AvgPool2d(8)
        self.fc = nn.Linear(64, num_classes)
        
    def make_layer(self, block, out_channels, blocks, stride=1):
        downsample = None
        if (stride != 1) or (self.in_channels != out_channels):
            downsample = nn.Sequential(
                conv3x3(self.in_channels, out_channels, stride=stride),
                nn.BatchNorm2d(out_channels))
        layers = []
        layers.append(block(self.in_channels, out_channels, stride, downsample))
        self.in_channels = out_channels
        for i in range(1, blocks):
            layers.append(block(out_channels, out_channels))
        return nn.Sequential(*layers)
    
    def forward(self, x):
        out = self.conv(x)
        out = self.bn(out)
        out = self.relu(out)
        out = self.layer1(out)
        out = self.layer2(out)
        out = self.layer3(out)
        out = self.avg_pool(out)
        out = out.view(out.size(0), -1)
        out = self.fc(out)
        return out
    
model = ResNet(ResidualBlock, [2, 2, 2]).to(device)


# Loss and optimizer
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)

# For updating learning rate
def update_lr(optimizer, lr):    
    for param_group in optimizer.param_groups:
        param_group['lr'] = lr

# Train the model
total_step = len(train_loader)
curr_lr = learning_rate
for epoch in range(num_epochs):
    for i, (images, labels) in enumerate(train_loader):
        images = images.to(device)
        labels = labels.to(device)
        
        # Forward pass
        outputs = model(images)
        loss = criterion(outputs, labels)
        
        # Backward and optimize
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        
        if (i+1) % 100 == 0:
            print ("Epoch [{}/{}], Step [{}/{}] Loss: {:.4f}"
                   .format(epoch+1, num_epochs, i+1, total_step, loss.item()))

    # Decay learning rate
    if (epoch+1) % 20 == 0:
        curr_lr /= 3
        update_lr(optimizer, curr_lr)

# Test the model
model.eval()
with torch.no_grad():
    correct = 0
    total = 0
    for images, labels in test_loader:
        images = images.to(device)
        labels = labels.to(device)
        outputs = model(images)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

    print('Accuracy of the model on the test images: {} %'.format(100 * correct / total))

# Save the model checkpoint
torch.save(model.state_dict(), 'resnet.ckpt')

到了这里,关于Pytorch intermediate(二) ResNet的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • Deep Learning With Pytorch - 最基本的感知机、贯序模型/分类、拟合

    Step1. 感知机,多层感知机(MLP)的基本结构 感知机(Perceptron)是神经网络中的基本单元,神经网络的雏形,也被称作神经元(原理就是仿照生物上的神经元)、单层神经网络。 通过设置不同的权重,并加上一个激活函数(判决门限),就构成了一个单层感知机的基本网络结

    2024年02月12日
    浏览(48)
  • cmm是什么意思(风量cmm是什么意思)

    cmm是三坐标测量机的意思、 cmm数据顾名思义就是三坐标测量机检测出来的数据!表示他的数据 软件测试行业的CMM指的是“能力成熟度模型”。 其英文全称为Capability Maturity Model for Software,英文缩写为SW-CMM,简称CMM。 它是对于软件组织在定义、实施、度量、控制和改善其软件

    2024年02月03日
    浏览(47)
  • ssid是什么意思?SSID广播又是什么意思?

    SSID一词相信很多朋友又陌生又熟悉,陌生在于我们日常很少会提到SSID一词,熟悉在于在路由器设置中,我们会看到有SSID设置,并且每个使用Wifi无线网络的朋友,无线中接触了SSID广播。究竟ssid是什么意思、SSID广播又是什么?下面yii666小编为大家详细科普介绍下。 ssid是什么

    2024年02月07日
    浏览(48)
  • 银行利率bp是什么意思,bp是什么意思贷款利率

    利率bp换算:1bp=0.01%。bp是指基点BasisPoint(bp)用于金融方面,债券和票据利率改变量的度量单位。1个基点等于0.01%,即1%的百分之一。基点经常被缩写为“BP/BPS”。 一个基点等于一个百分点(%)的百分之一,即万分之一。100个基点等于1个百分点,即1基点等于0.01个百分点。

    2024年02月04日
    浏览(52)
  • 银行利率bp是什么意思,基准利率bp是什么意思

    在银行业里bp是指基点,是衡量利率的度量单位,1个基点等于0.01%,100基点就是1%。比如存款利率从5%下降到4%就是下调了100个bp。 在银行业里,通常用bp来表示某个金融工具的利率变动幅度,或者两种利率之间的差价。此外票据和债券利率增减的单位也可以用bp。拓展资料银行

    2024年02月05日
    浏览(60)
  • 利率里面的BP是什么意思,基准利率bp是什么意思

    利率bp换算:1bp=0.01%。bp是指基点BasisPoint(bp)用于金融方面,债券和票据利率改变量的度量单位。1个基点等于0.01%,即1%的百分之一。基点经常被缩写为“BP/BPS”。 一个基点等于一个百分点(%)的百分之一,即万分之一。100个基点等于1个百分点,即1基点等于0.01个百分点。

    2024年02月10日
    浏览(44)
  • 电商运营是什么意思,主要做什么?

    不少小伙伴都在问,电商运营是什么意思,主要做什么?今天小编就给大家简单讲解一下。 电商运营为电子商务运营的简称,其最初定义为电子商务平台建设以及产品优化推广等。现在主要是指把意向消费者或目标消费者通过各种手段引进你的店铺,然后带动你店铺产品的销

    2024年02月04日
    浏览(67)
  • 云账户是什么意思?有什么用?

    云计算时代,衍生很多云相关概念,例如云资源、云成本、混合云、公有云、私有云等等。那你知道云账户是什么意思骂?云账户有什么用?在行云管家中如何创建云账户? 云账户是什么意思? 云账户简单来说,就是在互联网上注册的账户,只要有网络,随时就能登录的账

    2024年02月06日
    浏览(47)
  • verilog中#是什么意思?#有什么作用?

    在使用verilog语言进行硬件描述时,你是否也经常用到#这个符号,那么你是否关心过这个符号到底是什么意思呢?它的作用是什么呢? `我们在进行verilog编程时经常会遇到如下一样的代码块 上述的代码块在最开始定义模块时#的作用就是为了将169这个常数在一开始的时候传递给

    2024年02月08日
    浏览(54)
  • 服务器4c是什么意思?8g是什么?

    4核8G是云服务器的参数,代表云服务器的硬件配置和网络带宽,4核代表CPU、8G是指内存、12M代表带宽值为12Mbps,腾讯云百科txybk.com以腾讯云轻量应用服务器4核8G12M带宽配置为例,来详细介绍下服务器参数: 4c8g是什么意思?或者4h8g12m代表什么?代表云服务器的参数配置。目前

    2024年02月22日
    浏览(53)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包