NNDL 实验六 卷积神经网络（2）基础算子

最新推荐文章于 2024-08-07 21:45:43 发布
最新推荐文章于 2024-08-07 21:45:43 发布
阅读量725 收藏
点赞数 1
文章标签： 1024程序员节 cnn 神经网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52836183/article/details/127487128
版权
本文详细介绍了卷积神经网络中的卷积层和汇聚层算子，包括多通道卷积和多通道卷积层的实现。通过自定义PyTorch算子与框架内置算子的比较，加深了对卷积和汇聚运算的理解。同时，探讨了卷积算子的参数量和计算量，以及汇聚层的作用和计算特点。最后，通过实例演示了卷积运算的过程。
摘要由CSDN通过智能技术生成

目录

5.2 卷积神经网络的基础算子

5.2.1 卷积算子

5.2.1.1 多通道卷积

5.2.1.2 多通道卷积层算子

5.2.1.3 卷积算子的参数量和计算量

5.2.2 汇聚层算子

选做题：使用pytorch实现Convolution Demo

1. 翻译以下内容

2. 代码实现下图

心得体会： 

参考博客 ：

5.2 卷积神经网络的基础算子

我们先实现卷积网络的两个基础算子：卷积层算子和汇聚层算子 

5.2.1 卷积算子

卷积层是指用卷积操作来实现神经网络中一层。

为了提取不同种类的特征，通常会使用多个卷积核一起进行特征提取。

5.2.1.1 多通道卷积

5.2.1.2 多通道卷积层算子

1. 多通道卷积卷积层的代码实现

2. Pytorch：torch.nn.Conv2d()代码实现

3. 比较自定义算子和框架中的算子

代码如下：

import torch
import torch.nn as nn
class Conv2D(nn.Module):
    def __init__(self, in_channels, out_channels, kernel_size, stride=1, padding=0,weight_attr=[],bias_attr=[]):
        super(Conv2D, self).__init__()
        # 创建卷积核
        weight_attr = torch.randn([out_channels, in_channels, kernel_size,kernel_size])
        weight_attr = torch.nn.init.constant(torch.tensor(weight_attr,dtype=torch.float32),val=1.0)
        self.weight = torch.nn.Parameter(weight_attr)
        # 创建偏置
        bias_attr = torch.zeros([out_channels, 1])
        bias_attr = torch.tensor(bias_attr,dtype=torch.float32)
        self.bias = torch.nn.Parameter(bias_attr)
        self.stride = stride
        self.padding = padding
        # 输入通道数
        self.in_channels = in_channels
        # 输出通道数
        self.out_channels = out_channels

    # 基础卷积运算
    def single_forward(self, X, weight):
        # 零填充
        new_X = torch.zeros([X.shape[0], X.shape[1]+2*self.padding, X.shape[2]+2*self.padding])
        new_X[:, self.padding:X.shape[1]+self.padding, self.padding:X.shape[2]+self.padding] = X
        u, v = weight.shape
        output_w = (new_X.shape[1] - u) // self.stride + 1
        output_h = (new_X.shape[2] - v) // self.stride + 1
        output = torch.zeros([X.shape[0], output_w, output_h])
        for i in range(0, output.shape[1]):
            for j in range(0, output.shape[2]):
                output[:, i, j] = torch.sum(
                    new_X[:, self.stride*i:self.stride*i+u, self.stride*j:self.stride*j+v]*weight, 
                    [1,2])
        return output

    def forward(self, inputs):
        """
        输入：
            - inputs：输入矩阵，shape=[B, D, M, N]
            - weights：P组二维卷积核，shape=[P, D, U, V]
            - bias：P个偏置，shape=[P, 1]
        """
        feature_maps = []
        # 进行多次多输入通道卷积运算
        p=0
        for w, b in zip(self.weight, self.bias): # P个(w,b),每次计算一个特征图Zp
            multi_outs = []
            # 循环计算每个输入特征图对应的卷积结果
            for i in range(self.in_channels):
                single = self.single_forward(inputs[:,i,:,:], w[i])
                multi_outs.append(single)
                # print("Conv2D in_channels:",self.in_channels,"i:",i,"single:",single.shape)
            # 将所有卷积结果相加
            feature_map = torch.sum(torch.stack(multi_outs), 0) + b #Zp
            feature_maps.append(feature_map)
            # print("Conv2D out_channels:",self.out_channels, "p:",p,"feature_map:",feature_map.shape)
            p+=1
        # 将所有Zp进行堆叠
        out = torch.stack(feature_maps, 1) 
        return out

inputs = torch.tensor([[[[0.0, 1.0, 2.0], [3.0, 4.0, 5.0], [6.0, 7.0, 8.0]],
               [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]]]])
conv2d = Conv2D(in_channels=2, out_channels=3, kernel_size=2)
print("inputs shape:",inputs.shape)
outputs = conv2d(inputs)
print("Conv2D outputs shape:",outputs.shape)

# 比较与torch API运算结果
weight_attr = torch.ones([3,2,2,2])
bias_attr = torch.zeros([3, 1])
bias_attr = torch.tensor(bias_attr,dtype=torch.float32)
conv2d_torch = nn.Conv2d(in_channels=2, out_channels=3, kernel_size=2,bias=True)
conv2d_torch.weight = torch.nn.Parameter(weight_attr)
outputs_torch = conv2d_torch(inputs)
# 自定义算子运算结果
print('Conv2D outputs:', outputs)
# torch API运算结果
print('nn.Conv2D outputs:', outputs_torch)

运行结果：

  

5.2.1.3 卷积算子的参数量和计算量

0. 变量定义

1.参数量

2.计算量  

2.1乘法计算量

2.2加法计算量 

5.2.2 汇聚层算子

汇聚层的作用是进行特征选择，降低特征数量，从而减少参数数量。

由于汇聚之后特征图会变得更小，如果后面连接的是全连接层，可以有效地减小神经元的个数，节省存储空间并提高计算效率。

常用的汇聚方法有两种，分别是：平均汇聚、最大汇聚。

1. 代码实现一个简单的汇聚层。 

2. torch.nn.MaxPool2d()；torch.nn.avg_pool2d()代码实现

3. 比较自定义算子和框架中的算子
代码如下：

import torch
import torch.nn as nn
class Pool2D(nn.Module):
    def __init__(self, size=(2, 2), mode='max', stride=1):
        super(Pool2D, self).__init__()
        # 汇聚方式
        self.mode = mode
        self.h, self.w = size
        self.stride = stride

    def forward(self, x):
        output_w = (x.shape[2] - self.w) // self.stride + 1
        output_h = (x.shape[3] - self.h) // self.stride + 1
        output = torch.zeros([x.shape[0], x.shape[1], output_w, output_h])
        # 汇聚
        for i in range(output.shape[2]):
            for j in range(output.shape[3]):
                # 最大汇聚
                if self.mode == 'max':
                    value_m = max(torch.max(
                        x[:, :, self.stride * i:self.stride * i + self.w, self.stride * j:self.stride * j + self.h],
                        3).values[0][0])
                    output[:, :, i, j] = torch.tensor(value_m)
                # 平均汇聚
                elif self.mode == 'avg':
                    value_m = max(torch.mean(
                        x[:, :, self.stride * i:self.stride * i + self.w, self.stride * j:self.stride * j + self.h],
                        3)[0][0])
                    output[:, :, i, j] = torch.tensor(value_m)

        return output


# 1.实现一个简单汇聚层
inputs = torch.tensor([[[[1., 2., 3., 4.], [5., 6., 7., 8.], [9., 10., 11., 12.], [13., 14., 15., 16.]]]])
pool2d = Pool2D(stride=2)
outputs = pool2d(inputs)
print("input: {}, \noutput: {}".format(inputs.shape, outputs.shape))
# 2.自定义算子上述代码已经实现，下面我们进行比较。
# 3.比较Maxpool2D与torch API运算结果
maxpool2d_torch = nn.MaxPool2d(kernel_size=(2, 2), stride=2)
outputs_torch = maxpool2d_torch(inputs)
# 自定义算子运算结果
print('Maxpool2D outputs:', outputs)
# torch API运算结果
print('nn.Maxpool2D outputs:', outputs_torch)

# 3.比较Avgpool2D与torch API运算结果
avgpool2d_torch = nn.AvgPool2d(kernel_size=(2, 2), stride=2)
outputs_torch = avgpool2d_torch(inputs)
pool2d = Pool2D(mode='avg', stride=2)
outputs = pool2d(inputs)
# 自定义算子运算结果
print('Avgpool2D outputs:', outputs)
# torch API运算结果
print('nn.Avgpool2D outputs:', outputs_torch)

汇聚层的参数量和计算量

由于汇聚层中没有参数，所以参数量为0；

最大汇聚中，没有乘加运算，所以计算量为0，

平均汇聚中，输出特征图上每个点都对应了一次求平均运算。

运行结果：

选做题：使用pytorch实现Convolution Demo

1. 翻译以下内容

翻译：

卷积演示：下面是一个正在运行的卷积层的示例，因为3D体积很难去可视化，所有的体积(输入体积(蓝色)，权重体积(红色)，输出体积(绿色))和每个深度层堆叠成行被可视化。输入体积是W1=5,H1=5,D1=3大小的，并且卷积层的参数是K=2,F=3,S=2,P=1。就是说，我们有两个大小为3*3的卷积核(滤波器)，并且他们的步长为2，因此，输出体积大小有空间大小为：(5-3+2)/2 +1 =3。除此之外，注意到padding(填充)的P=1被应用于输入体积，使得输入体积的外部边界为0。下面的可视化迭代输出激活(绿色)，并且展示了每个元素的计算方法是将高亮的输入(蓝色)与过滤器(红色)逐个元素相乘，然后相加，用偏差抵消结果。


2. 代码实现下图

代码如下：

import torch
import torch.nn as nn
class Conv2D(nn.Module):
    def __init__(self, in_channels, out_channels, kernel_size, stride=1, padding=0,weight_attr=[],bias_attr=[]):
        super(Conv2D, self).__init__()
        self.weight = torch.nn.Parameter(weight_attr)
        self.bias = torch.nn.Parameter(bias_attr)
        self.stride = stride
        self.padding = padding
        # 输入通道数
        self.in_channels = in_channels
        # 输出通道数
        self.out_channels = out_channels

    # 基础卷积运算
    def single_forward(self, X, weight):
        # 零填充
        new_X = torch.zeros([X.shape[0], X.shape[1]+2*self.padding, X.shape[2]+2*self.padding])
        new_X[:, self.padding:X.shape[1]+self.padding, self.padding:X.shape[2]+self.padding] = X
        u, v = weight.shape
        output_w = (new_X.shape[1] - u) // self.stride + 1
        output_h = (new_X.shape[2] - v) // self.stride + 1
        output = torch.zeros([X.shape[0], output_w, output_h])
        for i in range(0, output.shape[1]):
            for j in range(0, output.shape[2]):
                output[:, i, j] = torch.sum(
                    new_X[:, self.stride*i:self.stride*i+u, self.stride*j:self.stride*j+v]*weight,
                    [1,2])
        return output

    def forward(self, inputs):
        """
        输入：
            - inputs：输入矩阵，shape=[B, D, M, N]
            - weights：P组二维卷积核，shape=[P, D, U, V]
            - bias：P个偏置，shape=[P, 1]
        """
        feature_maps = []
        # 进行多次多输入通道卷积运算
        p=0
        for w, b in zip(self.weight, self.bias): # P个(w,b),每次计算一个特征图Zp
            multi_outs = []
            # 循环计算每个输入特征图对应的卷积结果
            for i in range(self.in_channels):
                single = self.single_forward(inputs[:,i,:,:], w[i])
                multi_outs.append(single)
                # print("Conv2D in_channels:",self.in_channels,"i:",i,"single:",single.shape)
            # 将所有卷积结果相加
            feature_map = torch.sum(torch.stack(multi_outs), axis=0) + b #Zp
            feature_maps.append(feature_map)
            # print("Conv2D out_channels:",self.out_channels, "p:",p,"feature_map:",feature_map.shape)
            p+=1
        # 将所有Zp进行堆叠
        out = torch.stack(feature_maps, 1)
        return out
#创建第一层卷积核
weight_attr1 = torch.tensor([[[-1,1,0],[0,1,0],[0,1,1]],[[-1,-1,0],[0,0,0],[0,-1,0]],[[0,0,-1],[0,1,0],[1,-1,-1]]],dtype=torch.float32)
weight_attr1 = weight_attr1.reshape([1,3,3,3])
bias_attr1 = torch.tensor(torch.ones([3,1]))
print("使用的卷积核Filter　W0为：\n",weight_attr1)
#传入参数进行输出
Input_Volume = torch.tensor([[[0,1,1,0,2],[2,2,2,2,1],[1,0,0,2,0],[0,1,1,0,0],[1,2,0,0,2]]
                ,[[1,0,2,2,0],[0,0,0,2,0],[1,2,1,2,1],[1,0,0,0,0],[1,2,1,1,1]],
               [[2,1,2,0,0],[1,0,0,1,0],[0,2,1,0,1],[0,1,2,2,2],[2,1,0,0,1]]])
Input_Volume = Input_Volume.reshape([1,3,5,5])
conv2d_1 = Conv2D(in_channels=3, out_channels=3, kernel_size=3, stride=2,padding=1,weight_attr=weight_attr1 , bias_attr=bias_attr1)
output1 = conv2d_1(Input_Volume)
print("使用卷积核Filter　W0的输出结果为:\n",output1)

#创建第二层卷积核
weight_attr2 = torch.tensor([[[1,1,-1],[-1,-1,1],[0,-1,1]],[[0,1,0],[-1,0,-1],[-1,1,0]],[[-1,0,0],[-1,0,1],[-1,0,0]]],dtype=torch.float32)
weight_attr2 = weight_attr2.reshape([1,3,3,3])
bias_attr2 = torch.tensor(torch.zeros([3,1]))
print("使用的卷积核Filter　W1为：\n",weight_attr2)
Input_Volume = torch.tensor([[[0,1,1,0,2],[2,2,2,2,1],[1,0,0,2,0],[0,1,1,0,0],[1,2,0,0,2]]
                ,[[1,0,2,2,0],[0,0,0,2,0],[1,2,1,2,1],[1,0,0,0,0],[1,2,1,1,1]],
               [[2,1,2,0,0],[1,0,0,1,0],[0,2,1,0,1],[0,1,2,2,2],[2,1,0,0,1]]])
Input_Volume = Input_Volume.reshape([1,3,5,5])
conv2d_2 = Conv2D(in_channels=3, out_channels=2, kernel_size=3, stride=2,padding=1,weight_attr=weight_attr2 , bias_attr=bias_attr2)
output2 = conv2d_2(Input_Volume)
print("使用卷积核Filter　W1的输出结果为:\n",output2)

运行结果：

 

心得体会： 

       本次实验理解了彩色图，灰度图，单通道卷积，多通道卷积之间的关系，能够使用代码来实现多通道卷积卷积层，同时也比较了自定义算子与框架中的算子，学会了如何计算卷积算子中的参数量和计算量。了解了汇聚层，以及汇聚层的实现。在选做题中，掌握了一些英语的专业名词，使用python实现了卷积演示。

参考博客 ：

1. 卷积层参数量和计算量计算公式

2. CS231n Convolutional Neural Networks for Visual Recognition

3. NNDL 实验5（上） - HBU_DAVID - 博客园 (cnblogs.com)

4. NNDL 实验5（下） - HBU_DAVID - 博客园 (cnblogs.com)

AI-2 刘子豪
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
NNDL 实验六 卷积神经网络（1）卷积
Guo_weiqi的博客
10-21 112
NNDL 实验六 卷积神经网络（1）卷积
MobileNet系列
a1691125058的博客
10-18 124
MobileNet系列学习笔记
总结几个好用的CNN模块（Pytorch）
AI浩
01-25 2546
总结几个比较好的CNN模块。 SEBlock 代码： class SEBlock(nn.Module): def __init__(self, input_channels, internal_neurons): super(SEBlock, self).__init__() self.down = nn.Conv2d(in_channels=input_channels, out_channels=internal_neurons, kern...
Pytorch：搭建CNN模型的基本架构
weixin_40522801的博客
05-13 3063
import torch.nn as nn # 搭建CNN模型 class CNN(nn.Module): def __init__(self): super(CNN, self).__init__() # 1号网络 self.conv1 = nn.Sequential( # 卷积参数设置 nn.Conv2d( in_channels=1, # 输入数据的通道为1，.
在百度飞桨平台上使用pytorch框架
m0_73585512的博客
07-20 2881
因此可以将之前使用的命令保存进一个脚本文件env.sh中，之后每次重新进入项目时运行该脚本即可自动配置文件，配置的环境在服务器自带的python35-paddle120-env。在notebooke上直接pip安装pytorch，服务器会因为兼容性的原因制止本次安装，因此需要新建一个终端，在终端中新建虚拟环境—>安装pytorch。在百度飞桨配置pytorch框架有一个问题在于，每次重启项目时，之前配置好的环境会被删除，需要重新配置。可以换清华源加快速度，网络上有很多教程，在此不再赘述。
实验环境5-1所需要的nndl包
10-28
《神经网络基础与nndl库解析》 神经网络，作为人工智能领域的核心组成部分，已经在机器学习、深度学习等众多领域展现出强大的潜力。nndl（Neural Network and Deep Learning Library）是针对这一主题的一个重要...
邱锡鹏著 《神经网络与深度学习》案例与实践实验1-5中所需的nndl包
11-10
如出现如下问题均可导入nndl包均...1、实验中出现from nndl.dataset import load_data报错的 2、No module named 'nndl' 3、运行是显示ModuleNotFoundError: No module named 'nndl' 去下载nndl这个模块的时候显示没有
NNDL:神经网络与深度学习
03-07
对于学习NNDL，Jupyter Notebook提供了一个理想的平台，因为用户可以逐步探索和实验各种神经网络模型，直观地查看每一步的结果。 在《NNDL-main》这个压缩包中，很可能是包含了用Jupyter Notebook编写的教程或项目...
NNDL:神经网络和深度学习课程回购
04-12
神经网络神经网络和深度学习课程库。 它包含以下问题：找到函数f（x）= x 4 + 3 * x 2 + 10的全局最小值。作业2： 它包含以下问题：找到函数f（x，y）= x 2 + y 2 + 10的x和y的全局最优点。作业3： 它包括对点采样的...
NNDL2018_神经网络与深度学习_deeplearning_cv_
10-01
总之，《NNDL2018_神经网络与深度学习》是一本全面覆盖神经网络和深度学习基础知识，并重点关注计算机视觉应用的教材。无论是初学者还是经验丰富的研究者，都能从中受益匪浅，提升自己在深度学习和计算机视觉领域的...
卷积神经网络相关计算
Mr_health的博客
10-28 2944
1. 求特征图大小及感受野 参考博客：关于感受野的理解与计算 感受野计算总结 某一个网络有三个操作，输入大小为200×200，第一层为卷积层，卷积核的大小为5×5，stride为2，padding为1；第二层为池化层，池化大小为3×3，stride为1；第三层为卷积层，卷积核大小为3×3，padding为1，stride为1.求每一层特征图的大小及感受...
卷积神经网络中的参数计算
weixin_30416871的博客
10-03 1381
举例1： 　　比如输入是一个32x32x3的图像，3表示RGB三通道，每个filter/kernel是5x5x3，一个卷积核产生一个feature map，下图中，有6个5x5x3的卷积核，故输出6个feature map（activation map），大小即为28x28x6。 下图中，第二层到第三层，其中每个卷积核大小为5x5x6，这里的6就是28x28x6中的6，两者需...
卷积神经网络基础题——如何计算CNN的参数量？
Lorenzo's Oil
10-09 3656
卷积神经网络基础 如何计算CNN的参数量？ 先从简单的单层结构分析： CNN的单层结构与标准的神经网络单层结构非常相似： Z[l]=W[l]A[l−1]+bA[l]=g[l](Z[l])Z^{[l]}=W^{[l]}A^{[l-1]}+b \\A^{[l]}=g^{[l]}(Z^{[l]})Z[l]=W[l]A[l−1]+bA[l]=g[l](Z[l]) 卷积运算对应着上式中的乘积运算，滤波器组...
卷积神经网络进阶-计算题分享
PCRMINA的博客
02-18 1205
通道数为3，宽高均为224的输入，经过一层输出通道数为96，卷积核大小为11，步长为4，无padding的卷积层后，得到的feature map的宽高为（）？ 答案：{(224−11)/4} +1=54 ...
NNDL 作业7：第五章课后题（1×1 卷积核 | CNN BP）
qq_51698536的博客
10-30 447
无
卷积神经网络（详细解说题）
dong-技术驱动人生
05-27 2591
经典的多层感知机由一系列全连接层组成，卷积神经网络中除全连接层外，还有卷积层和汇合（pooling）层。 （1）卷积层 为什么要用卷积层 输入图像通常维数很高，例如：1000×1000大小的彩色图像对应于三百万维特征。因此，继续沿用多层感知机中的全连接会导致庞大的参数量。大参数量需要繁重的计算，而更重要的是，大参数量会有更高的过拟合风险。卷积是局部连接、共享参数版的全连接。这俩个特性使参数...
神经网络中的优化方法
最新发布
liuzibujian的博客
08-07 1363
在之前的文章中介绍了神经网络中的损失函数。有了损失函数之后，就要求损失函数的最小值，并且需要求出参数（这个参数可能是神经网络中的W或b）在取什么值时，损失函数才能取到最小值。那么这个就是优化方法做的事情。这篇文章就来介绍一下神经网络中的优化方法。
2、编程练习：利用卷积神经网络，处理MNIST 数据集分类问题。 https://github.com/nndl/exercise/
05-04
好的，以下是处理 MNIST 数据集分类问题的卷积神经网络的代码： ```python import tensorflow as tf from tensorflow.examples.tutorials.mnist import input_data # 加载 MNIST 数据集 mnist = input_data.read_...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

AI-2 刘子豪

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

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

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

打赏作者

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

抵扣说明：

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

余额充值