《PyTorch深度学习实践》课上代码笔记 四

最新推荐文章于 2024-07-13 21:18:24 发布
最新推荐文章于 2024-07-13 21:18:24 发布
阅读量456 收藏 3
点赞数
分类专栏： pytorch课程代码笔记 文章标签： 卷积 深度学习 神经网络 python pytorch
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhanglw882/article/details/109325907
版权

自学笔记

课程老师：刘二大人 河北工业大学教师 https://liuii.github.io
课程来源：https://www.bilibili.com/video/BV1Y7411d7Ys

十一、Implementation_of_Inception_Module

先看一下Inception_Module模块的图，课上老师按照下面的图进行的类的构建，然后封装，码代码时，是按照图中标注的分支1—4依次进行。其实构建四个分支的顺序可以随意调换，四个分支是平行的。
Inception_ModuleInception_Module模块图

先构建Inception_Module类的代码，结合上图以及注释进行理解

#创建模型块,因为这个块在整个神经网络中经常使用,且不是基础的单层
#所以将其组合到一起,减少代码的重复性工作
class InceptionA(nn.Module):
    def __init__(self,in_channels):
        #使其能继承父类的属性,不明白的可以再看看python的类继承
        super(InceptionA,self).__init__()
        #结合老师课上给的模型图,这个网络分为了四个分支,下面逐一初始化
        
        #分支1：1*1卷积层
        self.branch1x1 = nn.Conv2d(in_channels, 16, kernel_size=1)

        #分支2：1*1卷积层 --> 5*5的卷积层
        self.branch5x5_1 = nn.Conv2d(in_channels,16, kernel_size=1)
        #5*5的卷积层中,padding为2,保持了卷积后图片尺寸不变
        self.branch5x5_2 = nn.Conv2d(16, 24, kernel_size=5, padding=2)

        #分支3：1*1卷积层 --> 3*3卷积层 --> 3*3卷积层
        self.branch3x3_1 = nn.Conv2d(in_channels, 16, kernel_size=1)
        #两个3*3的卷积层,padding为1,同样保持了卷积后图片尺寸不变
        self.branch3x3_2 = nn.Conv2d(16, 24, kernel_size=3, padding=1)
        self.branch3x3_3 = nn.Conv2d(24, 24, kernel_size=3, padding=1)

        #分支4：平均池化层 --> 1*1卷积,池化层在后面的forward中体现
        self.branch_pool = nn.Conv2d(in_channels, 24, kernel_size=1)

    def forward(self, x):
        #分支1
        branch1x1 = self.branch1x1(x)

        #分支2
        branch5x5 = self.branch5x5_1(x)
        branch5x5 = self.branch5x5_2(branch5x5)

        #分支3
        branch3x3 = self.branch3x3_1(x)
        branch3x3 = self.branch3x3_2(branch3x3)
        branch3x3 = self.branch3x3_3(branch3x3)

        #分支4，进行了池化层后，接了1*1卷积层
        branch_pool = F.avg_pool2d(x, kernel_size=3, stride=1, padding=1)
        branch_pool = self.branch_pool(branch_pool)

        #将四层的输出结果按层进行合并。前面所有做的变换保证了每层的输出尺寸是一样大的，所以可以进行合并。
        outputs = [branch1x1, branch5x5, branch3x3, branch_pool]
        return torch.cat(outputs, dim=1)

接下来进行Net的构建

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        #初始化所需的卷积层
        self.conv1 = nn.Conv2d(1, 10, kernel_size=5)
        self.conv2 = nn.Conv2d(88, 20, kernel_size=5)

        #初始化所需的InceptionA(nn.Module)
        self.incep1 = InceptionA(in_channels=10)
        self.incep2 = InceptionA(in_channels=20)

        #初始化所需的最大池化层与线性层(fc即Fully_Connected,全连接)
        self.mp = nn.MaxPool2d(2)

        #这里老师教了一个偷懒的方法,线性层的输入大小(即下面的线性层输入1408)让系统自动计算
        #方法：将下行代码注释掉,再在forward中输出对应位置的x.size(1)
        self.fc = nn.Linear(1408, 10)

    def forward(self, x):
        #获取输入x的尺寸，这里即batch_size的大小
        in_size = x.size(0)

        #卷积-->池化-->relu
        x = F.relu(self.mp(self.conv1(x)))

        #经过第一个InceptionA模块
        x = self.incep1(x)

        #卷积-->池化-->relu
        x = F.relu(self.mp(self.conv2(x)))

        #经过第二个InceptionA模块
        x = self.incep2(x)

        #变形成 in_size 行,列自动变换
        x = x.view(in_size, -1)

        #如果想让程序自动计算出1408,将下方的代码(#print(x.size(1)))解除注释
        #并注释它的下一行：x = self.fc(x),其它地方不变,整个代码跑一次,
        #就能得到x.size(1),就是需要的全连接(线性层)的输入大小
        #print(x.size(1))
        x = self.fc(x)
        return x

整个代码如下：

#仅模型部分做了改变，其它部分和前面的代码一致
#导入相应的包
import torch
from torchvision import transforms
from torchvision import datasets
from torch.utils.data import DataLoader
import torch.nn.functional as F
import torch.optim as optim
import torch.nn as nn

#小训练集大小
batch_size = 64

#数据集的处理
#图片变换:转换成Tensor,标准化
transform = transforms.Compose([transforms.ToTensor(),
                                transforms.Normalize((0.1307,),(0.3081,))])
#创建训练数据集
train_dataset = datasets.MNIST(root='../dataset/mnist/',
                               train=True, download=True,
                               transform=transform)
#导入训练数据集
train_loader = DataLoader(train_dataset,
                          shuffle=True,
                          batch_size=batch_size)
#创建测试数据集
test_dataset = datasets.MNIST(root='../dataset/mnist/',
                              train=False,
                              download=True,
                              transform=transform)
#导入测试数据集
test_loader = DataLoader(test_dataset,
                          shuffle=False,
                          batch_size=batch_size)

#创建模型块,因为这个块在整个神经网络中经常使用,且不是基础的单层
#所以将其组合到一起,减少代码的重复性工作
class InceptionA(nn.Module):
    def __init__(self,in_channels):
        #使其能继承父类的属性,不明白的可以再看看python的类继承
        super(InceptionA,self).__init__()
        #结合老师课上给的模型图,这个网络分为了四个分支,下面逐一初始化
        #分支1：1*1卷积层
        self.branch1x1 = nn.Conv2d(in_channels, 16, kernel_size=1)

        #分支2：1*1卷积层 --> 5*5的卷积层
        self.branch5x5_1 = nn.Conv2d(in_channels,16, kernel_size=1)
        #5*5的卷积层中,padding为2,保持了卷积后图片尺寸不变
        self.branch5x5_2 = nn.Conv2d(16, 24, kernel_size=5, padding=2)

        #分支3：1*1卷积层 --> 3*3卷积层 --> 3*3卷积层
        self.branch3x3_1 = nn.Conv2d(in_channels, 16, kernel_size=1)
        #两个3*3的卷积层,padding为1,同样保持了卷积后图片尺寸不变
        self.branch3x3_2 = nn.Conv2d(16, 24, kernel_size=3, padding=1)
        self.branch3x3_3 = nn.Conv2d(24, 24, kernel_size=3, padding=1)

        #分支4：平均池化层 --> 1*1卷积,池化层在后面的forward中体现
        self.branch_pool = nn.Conv2d(in_channels, 24, kernel_size=1)

    def forward(self, x):
        #分支1
        branch1x1 = self.branch1x1(x)

        #分支2
        branch5x5 = self.branch5x5_1(x)
        branch5x5 = self.branch5x5_2(branch5x5)

        #分支3
        branch3x3 = self.branch3x3_1(x)
        branch3x3 = self.branch3x3_2(branch3x3)
        branch3x3 = self.branch3x3_3(branch3x3)

        #分支4，进行了池化层后，接了1*1卷积层
        branch_pool = F.avg_pool2d(x, kernel_size=3, stride=1, padding=1)
        branch_pool = self.branch_pool(branch_pool)

        #将四层的输出结果按层进行合并
        outputs = [branch1x1, branch5x5, branch3x3, branch_pool]
        return torch.cat(outputs, dim=1)

#设计总的模型,就可以直接调用上面的InceptionA(nn.Module)类
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        #初始化所需的卷积层
        self.conv1 = nn.Conv2d(1, 10, kernel_size=5)
        self.conv2 = nn.Conv2d(88, 20, kernel_size=5)

        #初始化所需的InceptionA(nn.Module)
        self.incep1 = InceptionA(in_channels=10)
        self.incep2 = InceptionA(in_channels=20)

        #初始化所需的最大池化层与线性层(fc即Fully_Connected,全连接)
        self.mp = nn.MaxPool2d(2)

        #这里老师教了一个偷懒的方法,线性层的输入大小(即下面的线性层输入1408)让系统自动计算
        #方法：将下行代码注释掉,再在forward中输出对应位置的x.size(1)
        self.fc = nn.Linear(1408, 10)

    def forward(self, x):
        #获取输入x的尺寸，这里即batch_size的大小
        in_size = x.size(0)

        #卷积-->池化-->relu
        x = F.relu(self.mp(self.conv1(x)))

        #经过第一个InceptionA模块
        x = self.incep1(x)

        #卷积-->池化-->relu
        x = F.relu(self.mp(self.conv2(x)))

        #经过第二个InceptionA模块
        x = self.incep2(x)

        #变形成 in_size 行,列自动变换
        x = x.view(in_size, -1)

        #如果想让程序自动计算出1408,将下方的代码(#print(x.size(1)))解除注释
        #并注释它的下一行：x = self.fc(x),其它地方不变,整个代码跑一次,
        #就能得到x.size(1),就是需要的全连接(线性层)的输入大小
        #print(x.size(1))
        x = self.fc(x)
        return x

#实例化
model = Net()

#损失函数及反馈
criterion = torch.nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.5)

#训练
def train(epoch):
    running_loss = 0.0
    for batch_idx,data in enumerate(train_loader, 0):
        inputs, target = data
        optimizer.zero_grad()
        # forward + backward + update
        outputs = model(inputs)
        loss = criterion(outputs, target)
        loss.backward()
        optimizer.step()

        running_loss += loss.item()
        if batch_idx % 300 == 299:
            print('[%d, %5d] loss: %.3f' % (epoch + 1, batch_idx + 1, running_loss / 300))
            running_loss = 0.0

def test():
    correct = 0
    total = 0
    #不计算梯度，节省内存
    with torch.no_grad():
        for data in test_loader:
            #导入测试数据
            images, labels = data
            #带入模型，得到输出
            outputs = model(images)
            #找到输出中概率最大的下标及值
            _, predicted = torch.max(outputs.data, dim=1)
            #计算所有的测试个数
            total += labels.size(0)
            #计算正确的个数
            correct += (predicted == labels).sum().item()
    #输出准确率
    print('Accuracy on test set: %d %%' % (100 * correct / total))

if __name__ == '__main__':
    #训练10次
    for epoch in range(10):
        #训练
        train(epoch)
        #测试
        test()
Zhanglw882
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
PyTorch深度学习实践代码 第四讲
m0_46166352的博客
03-01 324
#引入torch import torch #构建数据集 x_data = [1.0,2.0,3.0] y_data = [2.0,4.0,6.0] #用torch.Tensor创建一个权重变量，后面的1.0代表只有一个权重 w = torch.Tensor([1.0]) #权重w是需要计算梯度的，设它为真。 w.requires_grad = True #构建模型 def forward(x): return x * w #计算损失函数 def loss(x,y): y_pred = f.
PyTorch深度学习实践代码 第五讲
m0_46166352的博客
03-01 326
#引入torch import torch #准备数据，用Tensor张量表示 x_data = torch.Tensor([[1.0],[2.0],[3.0]]) y_data = torch.Tensor([[2.0],[4.0],[6.0]]) #将线性模型定义为一个类，nn的意思是神经网络neural network.所有的模型都要从nn.Module模块继承下来。 class LinearModel(torch.nn.Module): #__init__为构造函数，初始化你的对象的时候.
Python-FastAutoAugment的官方PyTorch实现
08-11
'Fast AutoAugment'的官方PyTorch实现
[Pytorch] Pytorch深度学习实践 | 模型代码
qq_31225201的博客
04-02 354
纸上得来终觉浅，绝知此事要躬行。 最近在学Pytorch和深度学习实践类的课程，老师讲得真的很不错呀，醍醐灌顶，感觉之前云里雾里的很多东西都清楚了，墙裂推荐。 刘二大人-PyTorch深度学习实践：https://space.bilibili.com/21241234/channel/detail?cid=110513 相关的两个博客，记录有代码和笔记： [1] https://blog.csdn.net/bit452/category_10569531.html?spm=1001.2014.3001.54
河北工业大学刘二大人深度学习作业
weixin_43581594的博客
03-07 1138
import numpy as np import matplotlib.pyplot as plt from mpl_toolkits.mplot3d import Axes3D fig = plt.figure() ax = fig.add_subplot(111, projection='3d') x_data=[1.0,2.0,3.0] y_data=[5.0,8.0,11.0] def forward(x): y_pre=x*w+b return y_pre; def loss(.
《PyTorch深度学习实践》课上代码笔记 一
Zhanglw882的博客
10-20 1039
自学笔记 课程老师：刘二大人 河北工业大学教师 https://liuii.github.io 课程来源：https://www.bilibili.com/video/BV1Y7411d7Ys 一、Gradient Descent梯度下降(无反馈) #梯度下降的线性拟合过程，梯度使用的是平均梯度 #导入数据 x_data = [1,2,3] y_data = [2,4,6] #初始化w的值 w = 1 #正向传递函数 def forward(x): return x*w #计算损失函数 def co
GoogLeNet图像分类网络（PyTorch）
weixin_41423872的博客
10-09 1910
GoogLeNet是在2014年由Google团队提出的，获得了当年ImageNet比赛中分类任务的第一名，也就是和VGG是同一年提出的，在ImageNet比赛中都获得了很好的成绩。
PyTorch：我的PyTorch深度学习笔记本
02-16
《PyTorch深度学习探索——基于个人笔记本的实践与理解》 PyTorch，作为一款由Facebook开发的开源机器学习库，以其灵活易用、动态计算图的优势在深度学习领域备受青睐。它不仅适合研究者进行快速原型设计，也适用于...
深度学习pytorch2.0教材学习笔记，以及自己的一点扩充
05-19
通过这些笔记，读者可以系统地学习PyTorch 2.0中的深度学习技术，并结合作者的个人见解和实践经验，对深度学习有更深入的理解。每个Jupyter Notebook不仅是理论的阐述，也包含实际运行的代码示例，使学习更具实战性...
深度学习pytorch教程
03-03
通过这个PyTorch深度学习教程，你将不仅掌握深度学习的基本原理，还能熟练运用PyTorch框架构建和优化复杂的神经网络模型，为你的AI开发之路奠定坚实基础。记得实践是检验真理的唯一标准，理论知识结合实际项目，会让...
基于PyTorch的Python深度学习实战源码
03-25
项目概述：《Python深度学习实战：基于PyTorch》 本项目采用Python语言编写，致力于...本项目以《Deep Learning with Python and PyTorch》为主题，旨在帮助开发者通过实践掌握Python和PyTorch在深度学习领域的应用。
PyTorch 深度学习实践 第2讲
热门推荐
bit452的专栏
11-11 5万+
第2讲 linear_model 源代码 import numpy as np import matplotlib.pyplot as plt x_data = [1.0, 2.0, 3.0] y_data = [2.0, 4.0, 6.0] def forward(x): return x*w def loss(x, y): y_pred = forward(x) return (y_pred - y)**2 w_list = [] mse_list = []..
机器学习到深度学习（pytorch）绝对的入门教程
Carrie526的博客
07-07 892
最近开始学习深度学习，由于以前是做通信的，所以对机器学习、深度学习完全零基础，看了很多视频，对新手小白都不是太友好，近期发现几个对新手小白绝对友好的入门视频，分享出来，供大家参考！ 1、机器学习入门教程： https://www.iqiyi.com/v_19rqt7gt3o.html#curid=1744319800_f3a64c420751d7fa7147fdbf5942c967 黑马教程，相信大家都听过，确实讲的不错！ 2、pytorch教程： https://www.bilibili.com/vide
pytorch图像分类篇：5. GoogLeNet结构详解与模型的搭建
fun1024
07-17 7652
GoogLeNet 网络与搭建
在Pycharm中安装及测试PaddleOCR
m0_60321191的博客
06-21 2059
PaddleOCRhttps://github.com/PaddlePaddle/PaddleOCR1.Python3.6 - 3.92.Visual C++ Build Tools 2014或以上如果安装了Anconda可以新建Conda环境，Python版本选3.6-3.9或者Python官网下载3.9版本作为解释器注意：3.10的版本会导致一些库安装不上直接下载官网的安装器，等待十几分钟安装好即可。Visual C++ Build Tools有些同学（比如我）会遇见安装包已损坏等问题，这时可以下载离线
卷积神经网络-猫狗识别实战
最新发布
sylviiiiiia的博客
07-13 388
CNN
【深度学习】图形模型基础(6)：模型优化理论
MUKAMO的博客
07-10 880
模型优化理论关注提升模型性能、准确性和效率。SGD（随机梯度下降）是其关键算法之一，通过随机选取样本计算梯度并更新模型参数，以提高训练速度和适用性。SGD尤其适合大规模数据集，但可能因梯度噪声导致收敛波动。改进算法如动量法和自适应学习率算法（如Adam）进一步加速收敛并提升精度。总之，模型优化理论和SGD是机器学习不可或缺的工具，助力提升模型性能，推动深度学习发展。
人工智能及深度学习在病理组学中的应用概述｜系列推文·24-07-11
qq_45404805的博客
07-10 1169
首先，小罗会带大家回顾计算机和编程的起源，解释从最初的电子计算器到现代计算机的发展历程，以及高级编程语言如何简化计算机指令的编写。其次，本期推文会深入探讨机器学习的不同类型，包括深度学习、神经网络和其他学习算法，以及它们如何被应用于解决实际问题，特别是在病理学领域。最后，小罗会列举一些AI技术当前面临的挑战，包括算法的单一任务限制、对大量数据集的需求以及计算过程中的能源效率问题……。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值