NNDL 实验六 卷积神经网络(2)基础算子

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

卷积神经网络是目前计算机视觉中使用最普遍的模型结构,如下图所示,由M个卷积层和b个汇聚层组合作用在输入图片上,在网络的最后通常会加入K个全连接层。
在这里插入图片描述
从上图可以看出,卷积网络是由多个基础的算子组合而成。下面我们先实现卷积网络的两个基础算子:卷积层算子和汇聚层算子。

5.2.1 卷积算子

卷积层是指用卷积操作来实现神经网络中一层。为了提取不同种类的特征,通常会使用多个卷积核一起进行特征提取。

5.2.1.1 多通道卷积

在前面介绍的二维卷积运算中,卷积的输入数据是二维矩阵。但实际应用中,一幅大小为M×N的图片中的每个像素的特征表示不仅仅只有灰度值的标量,通常有多个特征,可以表示为D维的向量,比如RGB三个通道的特征向量。因此,图像上的卷积操作的输入数据通常是一个三维张量,分别对应了图片的高度M、宽度N和深度D,其中深度D通常也被称为输入通道数D。如果输入如果是灰度图像,则输入通道数为1;如果输入是彩色图像,分别有R、G、B三个通道,则输入通道数为3。

此外,由于具有单个核的卷积每次只能提取一种类型的特征,即输出一张大小为U×V的特征图(Feature Map)。而在实际应用中,我们也希望每一个卷积层能够提取多种不同类型的特征,所以一个卷积层通常会组合多个不同的卷积核来提取特征,经过卷积运算后会输出多张特征图,不同的特征图对应不同类型的特征。输出特征图的个数通常将其称为输出通道数P。

说明:《神经网络与深度学习》将Feature Map翻译为“特征映射”,这里翻译为“特征图”。

在这里插入图片描述
在这里插入图片描述

说明:在代码实现时,通常将非线性激活函数放在卷积层算子外部。

公式(5.13)对应的可视化如下图所示。
在这里插入图片描述
多张输出特征图的计算
在这里插入图片描述

5.2.1.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):
        super(Conv2D, self).__init__()
        # 创建卷积核
        self.weight = nn.Parameter(torch.ones(size=[out_channels, in_channels, kernel_size, kernel_size]))
        # 创建偏置
        self.bias = nn.Parameter(torch.ones(size=[out_channels, 1]))
        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,
                    axis=[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), dim=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运算结果
conv2d_torch = nn.Conv2d(in_channels=2, out_channels=3, kernel_size=2)
# 初始化w和b
conv2d_torch.weight.data = nn.Parameter(torch.ones(size=[3, 2, 2, 2]))
conv2d_torch.bias.data = nn.Parameter(torch.ones(size=[3]))
outputs_torch = conv2d_torch(inputs)
# 自定义算子运算结果
print('Conv2D outputs:', outputs)
# paddle API运算结果
print('nn.Conv2D outputs:', outputs_torch)

运行结果:
在这里插入图片描述

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

参数量
在这里插入图片描述
计算量
在这里插入图片描述

5.2.2 汇聚层算子

汇聚层的作用是进行特征选择,降低特征数量,从而减少参数数量。由于汇聚之后特征图会变得更小,如果后面连接的是全连接层,可以有效地减小神经元的个数,节省存储空间并提高计算效率。

常用的汇聚方法有两种,分别是:平均汇聚和最大汇聚。
平均汇聚:将输入特征图划分为2×2大小的区域,对每个区域内的神经元活性值取平均值作为这个区域的表示;
最大汇聚:使用输入特征图的每个子区域内所有神经元的最大活性值作为这个区域的表示。

下图给出了两种汇聚层的示例。
在这里插入图片描述
在这里插入图片描述
由于过大的采样区域会急剧减少神经元的数量,也会造成过多的信息丢失。目前,在卷积神经网络中比较典型的汇聚层是将每个输入特征图划分为2×2大小的不重叠区域,然后使用最大汇聚的方式进行下采样。

由于汇聚是使用某一位置的相邻输出的总体统计特征代替网络在该位置的输出,所以其好处是当输入数据做出少量平移时,经过汇聚运算后的大多数输出还能保持不变。比如:当识别一张图像是否是人脸时,我们需要知道人脸左边有一只眼睛,右边也有一只眼睛,而不需要知道眼睛的精确位置,这时候通过汇聚某一片区域的像素点来得到总体统计特征会显得很有用。这也就体现了汇聚层的平移不变特性。

汇聚层的参数量和计算量

由于汇聚层中没有参数,所以参数量为0;最大汇聚中,没有乘加运算,所以计算量为0,而平均汇聚中,输出特征图上每个点都对应了一次求平均运算。
代码如下:

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':
                    output[:, :, i, j] = torch.max(
                        x[:, :, self.stride * i:self.stride * i + self.w, self.stride * j:self.stride * j + self.h])
                # 平均汇聚
                elif self.mode == 'avg':
                    output[:, :, i, j] = torch.mean(
                        x[:, :, self.stride * i:self.stride * i + self.w, self.stride * j:self.stride * j + self.h])

        return output


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))

# 比较Maxpool2d与paddle 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)

# 比较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)
# paddle API运算结果
print('nn.Avgpool2d outputs:', outputs_torch)

运行结果:
在这里插入图片描述

选做题:使用pytorch实现Convolution Demo

1. 翻译以下内容

在这里插入图片描述
卷积演示。下面是一个 CONV 层的运行演示。由于 3D 体积难以可视化,因此所有体积(输入体积(蓝色)、权重体积(红色)、输出体积(绿色))都被可视化,每个深度切片按行堆叠。输入体积大小为W1= 5 , H1= 5 , D1= 3, CONV层参数为K= 2 , F= 3 , S= 2 , P= 1. 也就是说,我们有两个大小为3 × 3的过滤器,并且它们的应用步幅为 2。因此,输出体积大小的空间大小为 (5 - 3 + 2)/2 + 1 = 3。此外,请注意P的填充= 1应用于输入体积,使输入体积的外边界为零。下面的可视化迭代了输出激活(绿色),并显示每个元素是通过将突出显示的输入(蓝色)与过滤器(红色)相乘,将其相加,然后用偏差抵消结果来计算的。

2. 代码实现下图

在这里插入图片描述
代码如下:

import torch.nn as nn
import torch

# 输入层
inputs = torch.as_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]]
                        ]], dtype=torch.float)
# 定义卷积
conv2d = torch.nn.Conv2d(in_channels=3, out_channels=2, kernel_size=3, padding=1, stride=2)
# 初始化权重层
conv2d.weight.data = nn.Parameter(torch.as_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.]]
],
    [[[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.]]]]))
# 初始化偏移量
conv2d.bias.data = nn.Parameter(torch.as_tensor([1, 0], dtype=torch.float))
output = conv2d(inputs)
# 输出(去掉无用的为1的维度)
output = torch.squeeze(output)
print("output:", output)
print("output.shape:", output.shape)

运行结果:
在这里插入图片描述


总结

心得体会

本次实验是实验六的第二部分实验,主要是多通道卷积算子进行实现实验、卷积层和汇聚层一些基础算子的实现,选做题整体的体会了一下利用不同卷积核提取不同特征的过程。

参考链接

NNDL 实验5(上) - HBU_DAVID - 博客园 (cnblogs.com)
CS231n Convolutional Neural Networks for Visual Recognition
NNDL 实验六 卷积神经网络(2)基础算子

  • 1
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值