• 卷积神经网络(1)

    目录

    卷积

    1 自定义二维卷积算子

    2 自定义带步长和零填充的二维卷积算子

    3 实现图像边缘检测

    4 自定义卷积层算子和汇聚层算子

            4.1 卷积算子

            4.2 汇聚层算子

    5 学习torch.nn.Conv2d()、torch.nn.MaxPool2d()；torch.nn.avg_pool2d()，简要介绍使用方法。

    6 分别用自定义卷积算子和torch.nn.Conv2d()编程实现下面的卷积运算

    总结

    卷积

            考虑到使用全连接前馈网络来处理图像时，会出现如下问题：

            1. 模型参数过多，容易发生过拟合。在全连接前馈网络中，隐藏层的每个神经元都要跟该层所有输入的神经元相连接。随着隐藏层神经元数量的增多，参数的规模也会急剧增加，导致整个神经网络的训练效率非常低，也很容易发生过拟合。

            2. 难以提取图像中的局部不变性特征。 自然图像中的物体都具有局部不变性特征，比如尺度缩放、平移、旋转等操作不影响其语义信息。而全连接前馈网络很难提取这些局部不变性特征。

            卷积神经网络有三个结构上的特性：局部连接、权重共享和汇聚。这些特性使得卷积神经网络具有一定程度上的平移、缩放和旋转不变性。和前馈神经网络相比，卷积神经网络的参数也更少。因此，通常会使用卷积神经网络来处理图像信息。

            卷积是分析数学中的一种重要运算，常用于信号处理或图像处理任务。本节以二维卷积为例来进行实践。

    1 自定义二维卷积算子

            在机器学习和图像处理领域，卷积的主要功能是在一个图像（或特征图）上滑动一个卷积核，通过卷积操作得到一组新的特征。在计算卷积的过程中，需要进行卷积核的翻转，而这也会带来一些不必要的操作和开销。因此，在具体实现上，一般会以数学中的互相关（Cross-Correlatio）运算来代替卷积。

            在神经网络中，卷积运算的主要作用是抽取特征，卷积核是否进行翻转并不会影响其特征抽取的能力。特别是当卷积核是可学习的参数时，卷积和互相关在能力上是等价的。因此，很多时候，为方便起见，会直接用互相关来代替卷积。

            在本案例之后的描述中，除非特别声明，卷积一般指“互相关”。

            对于一个输入矩阵和一个滤波器，他们的卷积为:

            此时图片的输出大小为:

            计算量为： 

        

    1. import torch
    2. import numpy as np
    3. import torch.nn as nn
    4.  
    5.  
    6. class Conv2D(nn.Module):
    7.     def __init__(self, kernel_size, stride=1, padding=0, ):
    8.         super(Conv2D, self).__init__()
    9.         w = torch.tensor(np.array([[0., 1.], [2., 3.]], dtype='float32').reshape([kernel_size, kernel_size]))
    10.         self.weight = torch.nn.Parameter(w, requires_grad=True)
    11.  
    12.     def forward(self, X):
    13.         """
    14.         输入：
    15.             - X：输入矩阵，shape=[B, M, N]，B为样本数量
    16.         输出：
    17.             - output：输出矩阵
    18.         """
    19.         u, v = self.weight.shape
    20.         output = torch.zeros([X.shape[0], X.shape[1] - u + 1, X.shape[2] - v + 1])
    21.         for i in range(output.shape[1]):
    22.             for j in range(output.shape[2]):
    23.                 output[:, i, j] = torch.sum(X[:, i:i + u, j:j + v] * self.weight, dim=[1, 2])
    24.         return output
    25.  
    26.  
    27. # 随机构造一个二维输入矩阵
    28.  
    29.  
    30. inputs = torch.tensor([[[1., 2., 3.], [4., 5., 6.], [7., 8., 9.]]])
    31. conv2d = Conv2D(kernel_size=2)
    32. outputs = conv2d(inputs)
    33. print("input: {}, \noutput: {}".format(inputs, outputs))

     

    2 自定义带步长和零填充的二维卷积算子

            在计算卷积时，可以在所有维度上每间隔$S$个元素计算一次，$S$称为卷积运算的步长（Stride），也就是卷积核在滑动时的间隔。

            在二维卷积运算中，零填充（Zero Padding）是指在输入矩阵周围对称地补上$P$个$0$。

            对于一个输入矩阵$\mathbf X\in\Bbb{R}^{M\times N}$和一个滤波器$\mathbf W \in\Bbb{R}^{U\times V}$，，步长为$S$，对输入矩阵进行零填充，那么最终输出矩阵大小则为

            计算量为:

            

             一般常用的卷积有三种:

    1. 窄卷积：步长" role="presentation" style="position: relative;">S = 1，两端不补零P=0，卷积后输出尺寸为：

    2. 宽卷积：步长$S=1$，两端补零$P=U-1=V-1$，卷积后输出尺寸为：

     3. 等宽卷积：步长$S=1$，两端补零$P=\frac{(U-1)}{2}=\frac{(V-1)}{2}$，卷积后输出尺寸为：

    1. import torch
    2. import numpy as np
    3. import torch.nn as nn
    4.  
    5.  
    6. class Conv2D(nn.Module):
    7.     def __init__(self, kernel_size, stride=1, padding=0, ):
    8.         super(Conv2D, self).__init__()
    9.         w = torch.tensor(np.array([[1., 1., 1.], [1., 1., 1.], [1., 1., 1.]], dtype='float32').reshape([kernel_size, kernel_size]))
    10.         self.weight = torch.nn.Parameter(w, requires_grad=True)
    11.  
    12.         # 步长
    13.         self.stride = stride
    14.         # 零填充
    15.         self.padding = padding
    16.  
    17.     def forward(self, X):
    18.         """
    19.         输入：
    20.             - X：输入矩阵，shape=[B, M, N]，B为样本数量
    21.         输出：
    22.             - output：输出矩阵
    23.         """
    24.         new_X = torch.zeros([X.shape[0], X.shape[1] + 2 * self.padding, X.shape[2] + 2 * self.padding]) # 创建一个M'*N'的零矩阵
    25.         new_X[:, self.padding:X.shape[1] + self.padding, self.padding:X.shape[2] + self.padding] = X    # 将原数据放回
    26.         u, v = self.weight.shape
    27.         output_w = (new_X.shape[1] - u) // self.stride + 1
    28.         output_h = (new_X.shape[2] - v) // self.stride + 1
    29.         output = torch.zeros([X.shape[0], output_w, output_h])
    30.         for i in range(0, output.shape[1]):
    31.             for j in range(0, output.shape[2]):
    32.                 output[:, i, j] = torch.sum(
    33.                     new_X[:, self.stride * i:self.stride * i + u, self.stride * j:self.stride * j + v] * self.weight,
    34.                     dim=[1, 2])
    35.         return output
    36.  
    37.  
    38. # 随机构造一个二维输入矩阵
    39.  
    40.  
    41. inputs = torch.randn([2, 8, 8])
    42. conv2d_padding = Conv2D(kernel_size=3, padding=1)
    43. outputs = conv2d_padding(inputs)
    44. print("When kernel_size=3, padding=1 stride=1, input's shape: {}, output's shape: {}".format(inputs.shape, outputs.shape))
    45. conv2d_stride = Conv2D(kernel_size=3, stride=2, padding=1)
    46. outputs = conv2d_stride(inputs)
    47. print("When kernel_size=3, padding=1 stride=2, input's shape: {}, output's shape: {}".format(inputs.shape, outputs.shape))

            从输出结果看出，使用$3\times3$大小卷积，padding为1，当stride=1时，模型的输出特征图可以与输入特征图保持一致；当stride=2时，输出特征图的宽和高都缩小一倍。 

    3 实现图像边缘检测

            在图像处理任务中，常用拉普拉斯算子对物体边缘进行提取，拉普拉斯算子为一个大小为$3 \times 3$的卷积核，中心元素值是$8$，其余元素值是$-1$。

             考虑到边缘其实就是图像上像素值变化很大的点的集合，因此可以通过计算二阶微分得到，当二阶微分为0时，像素值的变化最大。此时，对$x$方向和$y$方向分别求取二阶导数：

             完整的二阶微分公式为：

            上述公式也被称为拉普拉斯算子，对应的二阶微分卷积核为： 

             对上述算子全部求反也可以起到相同的作用，此时，该算子可以表示为：

             也就是一个点的四邻域拉普拉斯的算子计算结果是自己像素值的四倍减去上下左右的像素的和，将这个算子旋转$45^{\circ}$后与原算子相加，就变成八邻域的拉普拉斯算子，也就是一个像素自己值的八倍减去周围一圈八个像素值的和，做为拉普拉斯计算结果，此时，该算子可以表示为：

             代码如下:

    1. import torch
    2.  
    3.  
    4. import matplotlib.pyplot as plt
    5. from PIL import Image
    6. import numpy as np
    7. import torch.nn as nn
    8.  
    9.  
    10. class Conv2d(nn.Module):
    11.     def __init__(self, kernel_size, stride=1, padding=0):
    12.         super(Conv2d, self).__init__()
    13.         # 设置卷积核参数
    14.         w = np.array([[-1, -1, -1], [-1, 8, -1], [-1, -1, -1]], dtype='float32').reshape((3, 3))
    15.         w = torch.from_numpy(w)
    16.         self.weight = torch.nn.Parameter(w, requires_grad=True)
    17.         self.stride = stride
    18.         self.padding = padding
    19.  
    20.     def forward(self, X):
    21.         # 零填充
    22.         new_X = torch.zeros([X.shape[0], X.shape[1] + 2 * self.padding, X.shape[2] + 2 * self.padding])
    23.         new_X[:, self.padding:X.shape[1] + self.padding, self.padding:X.shape[2] + self.padding] = X
    24.         u, v = self.weight.shape
    25.         output_w = (new_X.shape[1] - u) // self.stride + 1
    26.         output_h = (new_X.shape[2] - v) // self.stride + 1
    27.         output = torch.zeros([X.shape[0], output_w, output_h])
    28.         for i in range(0, output.shape[1]):
    29.             for j in range(0, output.shape[2]):
    30.                 output[:, i, j] = torch.sum(
    31.                     new_X[:, self.stride * i:self.stride * i + u, self.stride * j:self.stride * j + v] * self.weight,
    32.                     dim=[1, 2])
    33.         return output
    34.  
    35.  
    36. # 读取图片
    37. img = Image.open('OIP-C.jpg').convert('L')
    38. inputs = np.array(img, dtype='float32')
    39. # 创建卷积算子，卷积核大小为3x3，并使用上面的设置好的数值作为卷积核权重的初始化参数
    40. conv = Conv2d(kernel_size=3, stride=1, padding=0)
    41. print("bf to_tensor, inputs:", inputs)
    42. # 将图片转为Tensor
    43. inputs = torch.tensor(inputs)
    44. print("bf unsqueeze, inputs:", inputs)
    45. inputs = torch.unsqueeze(inputs, dim=0)
    46. print("af unsqueeze, inputs:", inputs)
    47. outputs = conv(inputs)
    48. print(outputs)
    49. # 可视化结果
    50. plt.figure(figsize=(8, 4))
    51. f = plt.subplot(121)
    52. f.set_title('input image', fontsize=15)
    53. plt.imshow(img)
    54. f = plt.subplot(122)
    55. f.set_title('output feature map', fontsize=15)
    56. plt.imshow(outputs.squeeze().detach().numpy(), cmap='gray')
    57. plt.show()

     

    4 自定义卷积层算子和汇聚层算子

             从上图可以看出，卷积网络是由多个基础的算子组合而成。下面我们先实现卷积网络的两个基础算子：卷积层算子和汇聚层算子。

            4.1 卷积算子

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

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

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

            PS:假设一个卷积层的输入特征图$\mathbf X\in \mathbb{R}^{D\times M\times N}$，其中$(M,N)$为特征图的尺寸，$D$代表通道数；卷积核为$\mathbf W\in \mathbb{R}^{P\times D\times U\times V}$，其中$(U,V)$为卷积核的尺寸，$D$代表输入通道数，$P$代表输出通道数。

             多张输出特征图的计算,如下图所示，具体的对这个不明确的可以翻翻我之前的博客，对这个解释的比较详细.

    1. class Conv2D(nn.Module):
    2.     def __init__(self, in_channels, out_channels, kernel_size, stride=1, padding=0):
    3.         super(Conv2D, self).__init__()
    4.         # 创建卷积核
    5.         weight = torch.zeros([out_channels, in_channels, kernel_size, kernel_size], dtype=torch.float32)
    6.         weight = nn.init.constant_(weight, val=1.0)
    7.         self.weight = nn.Parameter(weight)
    8.  
    9.         # 创建偏置
    10.         bias = torch.zeros([out_channels, 1], dtype=torch.float32)
    11.         self.bias = nn.init.constant_(bias, val=0.0)  # 值可调整
    12.         self.bias = nn.Parameter(bias)
    13.  
    14.         # 步长
    15.         self.stride = stride
    16.         # 零填充
    17.         self.padding = padding
    18.         # 输入通道数
    19.         self.in_channels = in_channels
    20.         # 输出通道数
    21.         self.out_channels = out_channels
    22.  
    23.     def single_forward(self, X, weight):
    24.         """
    25.         输入：
    26.             - X：输入矩阵，shape=[B, M, N]，B为样本数量
    27.         输出：
    28.             - output：输出矩阵
    29.         """
    30.         new_X = torch.zeros([X.shape[0], X.shape[1] + 2 * self.padding, X.shape[2] + 2 * self.padding])  # 创建一个M'*N'的零矩阵
    31.         new_X[:, self.padding:X.shape[1] + self.padding, self.padding:X.shape[2] + self.padding] = X  # 将原数据放回
    32.         u, v = weight.shape
    33.         output_w = (new_X.shape[1] - u) // self.stride + 1
    34.         output_h = (new_X.shape[2] - v) // self.stride + 1
    35.         output = torch.zeros([X.shape[0], output_w, output_h])
    36.         for i in range(0, output.shape[1]):
    37.             for j in range(0, output.shape[2]):
    38.                 output[:, i, j] = torch.sum(
    39.                     new_X[:, self.stride * i:self.stride * i + u, self.stride * j:self.stride * j + v] * weight,
    40.                     dim=[1, 2])
    41.         return output
    42.  
    43.     def forward(self, inputs):
    44.         """
    45.         输入：
    46.             - inputs：输入矩阵，shape=[B, D, M, N]
    47.             - weights：P组二维卷积核，shape=[P, D, U, V]
    48.             - bias：P个偏置，shape=[P, 1]
    49.         """
    50.         feature_maps = []
    51.         # 进行多次多输入通道卷积运算
    52.         p = 0
    53.         for w, b in zip(self.weight, self.bias):  # P个(w,b),每次计算一个特征图Zp
    54.             multi_outs = []
    55.             # 循环计算每个输入特征图对应的卷积结果
    56.             for i in range(self.in_channels):
    57.                 single = self.single_forward(inputs[:, i, :, :], w[i])
    58.                 multi_outs.append(single)
    59.                 # print("Conv2D in_channels:",self.in_channels,"i:",i,"single:",single.shape)
    60.             # 将所有卷积结果相加
    61.             feature_map = torch.sum(torch.stack(multi_outs), dim=0) + b  # Zp
    62.             feature_maps.append(feature_map)
    63.             # print("Conv2D out_channels:",self.out_channels, "p:",p,"feature_map:",feature_map.shape)
    64.             p += 1
    65.         # 将所有Zp进行堆叠
    66.         out = torch.stack(feature_maps, 1)
    67.         return out

                           

            4.2 汇聚层算子

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

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

    • 平均汇聚：将输入特征图划分为$2\times2$大小的区域，对每个区域内的神经元活性值取平均值作为这个区域的表示；
    • 最大汇聚：使用输入特征图的每个子区域内所有神经元的最大活性值作为这个区域的表示。

    汇聚层输出的计算尺寸与卷积层一致，对于一个输入矩阵$\mathbf X\in\Bbb{R}^{M\times N}$和一个运算区域大小为$U\times V$的汇聚层，步长为$S$，对输入矩阵进行零填充，那么最终输出矩阵大小则为

            由于过大的采样区域会急剧减少神经元的数量，也会造成过多的信息丢失。目前，在卷积神经网络中比较典型的汇聚层是将每个输入特征图划分为$2\times2$大小的不重叠区域，然后使用最大汇聚的方式进行下采样。

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

            汇聚层的参数量和计算量

            由于汇聚层中没有参数，所以参数量为$0$；最大汇聚中，没有乘加运算，所以计算量为$0$，而平均汇聚中，输出特征图上每个点都对应了一次求平均运算.

    1. class Pool2D(nn.Module):
    2.     def __init__(self, size=(2, 2), mode='max', stride=1):
    3.         super(Pool2D, self).__init__()
    4.         # 汇聚方式
    5.         self.mode = mode
    6.         self.h, self.w = size
    7.         self.stride = stride
    8.  
    9.     def forward(self, x):
    10.         output_w = (x.shape[2] - self.w) // self.stride + 1
    11.         output_h = (x.shape[3] - self.h) // self.stride + 1
    12.         output = torch.zeros([x.shape[0], x.shape[1], output_w, output_h])
    13.         # 汇聚
    14.         for i in range(output.shape[2]):
    15.             for j in range(output.shape[3]):
    16.                 # 最大汇聚
    17.                 if self.mode == 'max':
    18.                     value_m = max(torch.max(
    19.                         x[:, :, self.stride * i:self.stride * i + self.w, self.stride * j:self.stride * j + self.h],
    20.                         dim=3).values[0][0])
    21.                     output[:, :, i, j] = torch.tensor(value_m)
    22.                 # 平均汇聚
    23.                 elif self.mode == 'avg':
    24.                     output[:, :, i, j] = torch.mean(
    25.                         x[:, :, self.stride * i:self.stride * i + self.w, self.stride * j:self.stride * j + self.h],
    26.                         dim=[2, 3])
    27.  
    28.         return output
    29.  
    30.  
    31. inputs = torch.tensor([[[[1., 2., 3., 4.], [5., 6., 7., 8.], [9., 10., 11., 12.], [13., 14., 15., 16.]]]])
    32. pool2d = Pool2D(stride=2)
    33. outputs = pool2d(inputs)
    34. print("input: {}, \noutput: {}".format(inputs.shape, outputs.shape))
    35.  
    36. # 比较Maxpool2D与paddle API运算结果
    37. maxpool2d_torch = nn.MaxPool2d(kernel_size=(2, 2), stride=2)
    38. outputs_torch = maxpool2d_torch(inputs)
    39. # 自定义算子运算结果
    40. print('Maxpool2D outputs:', outputs)
    41. # paddle API运算结果
    42. print('nn.Maxpool2D outputs:', outputs_torch)
    43.  
    44. # 比较Avgpool2D与torch API运算结果
    45. avgpool2d_torch = nn.AvgPool2d(kernel_size=(2, 2), stride=2)
    46. outputs_torch = avgpool2d_torch(inputs)
    47. pool2d = Pool2D(mode='avg', stride=2)
    48. outputs = pool2d(inputs)
    49. # 自定义算子运算结果
    50. print('Avgpool2D outputs:', outputs)
    51. # paddle API运算结果
    52. print('nn.Avgpool2D outputs:', outputs_torch)

    5 学习torch.nn.Conv2d()、torch.nn.MaxPool2d()；torch.nn.avg_pool2d()，简要介绍使用方法。

    torch.nn.Conv2d()参数如下：

    torch.nn.MaxPool2d()参数如下：

    torch.nn.AvgPool2d()参数如下：

             具体的使用可以参照卷积层算子和池化层算子的代码中，有将调用库函数做比较~

    6 分别用自定义卷积算子和torch.nn.Conv2d()编程实现下面的卷积运算

    1. import torch.nn as nn
    2. import torch
    3. class Conv2D(nn.Module):
    4.     def __init__(self, in_channels, Kernel, out_channels, kernel_size, stride=1, padding=0):
    5.         super(Conv2D, self).__init__()
    6.         self.weight = nn.Parameter(Kernel)
    7.  
    8.         # 创建偏置
    9.         self.bias = nn.Parameter(torch.tensor([1, 0], dtype=torch.float32))
    10.  
    11.         # 步长
    12.         self.stride = stride
    13.         # 零填充
    14.         self.padding = padding
    15.         # 输入通道数
    16.         self.in_channels = in_channels
    17.         # 输出通道数
    18.         self.out_channels = out_channels
    19.  
    20.     def single_forward(self, X, weight):
    21.         """
    22.         输入：
    23.             - X：输入矩阵，shape=[B, M, N]，B为样本数量
    24.         输出：
    25.             - output：输出矩阵
    26.         """
    27.         new_X = torch.zeros([X.shape[0], X.shape[1] + 2 * self.padding, X.shape[2] + 2 * self.padding])  # 创建一个M'*N'的零矩阵
    28.         new_X[:, self.padding:X.shape[1] + self.padding, self.padding:X.shape[2] + self.padding] = X  # 将原数据放回
    29.         u, v = weight.shape
    30.         output_w = (new_X.shape[1] - u) // self.stride + 1
    31.         output_h = (new_X.shape[2] - v) // self.stride + 1
    32.         output = torch.zeros([X.shape[0], output_w, output_h])
    33.         for i in range(0, output.shape[1]):
    34.             for j in range(0, output.shape[2]):
    35.                 output[:, i, j] = torch.sum(
    36.                     new_X[:, self.stride * i:self.stride * i + u, self.stride * j:self.stride * j + v] * weight,
    37.                     dim=[1, 2])
    38.         return output
    39.  
    40.     def forward(self, inputs):
    41.         """
    42.         输入：
    43.             - inputs：输入矩阵，shape=[B, D, M, N]
    44.             - weights：P组二维卷积核，shape=[P, D, U, V]
    45.             - bias：P个偏置，shape=[P, 1]
    46.         """
    47.         feature_maps = []
    48.         # 进行多次多输入通道卷积运算
    49.         p = 0
    50.         for w, b in zip(self.weight, self.bias):  # P个(w,b),每次计算一个特征图Zp
    51.             multi_outs = []
    52.             # 循环计算每个输入特征图对应的卷积结果
    53.             for i in range(self.in_channels):
    54.                 single = self.single_forward(inputs[:, i, :, :], w[i])
    55.                 multi_outs.append(single)
    56.                 # print("Conv2D in_channels:",self.in_channels,"i:",i,"single:",single.shape)
    57.             # 将所有卷积结果相加
    58.             feature_map = torch.sum(torch.stack(multi_outs), dim=0) + b  # Zp
    59.             feature_maps.append(feature_map)
    60.             # print("Conv2D out_channels:",self.out_channels, "p:",p,"feature_map:",feature_map.shape)
    61.             p += 1
    62.         # 将所有Zp进行堆叠
    63.         out = torch.stack(feature_maps, 1)
    64.  
    65.         return out
    66.  
    67. x = torch.tensor([
    68.         [[0, 1, 1, 0, 2],
    69.          [2, 2, 2, 2, 1],
    70.          [1, 0, 0, 2, 0],
    71.          [0, 1, 1, 0, 0],
    72.          [1, 2, 0, 0, 2]],
    73.         [[1, 0, 2, 2, 0],
    74.          [0, 0, 0, 2, 0],
    75.          [1, 2, 1, 2, 1],
    76.          [1, 0, 0, 0, 0],
    77.          [1, 2, 1, 1, 1]],
    78.         [[2, 1, 2, 0, 0],
    79.          [1, 0, 0, 1, 0],
    80.          [0, 2, 1, 0, 1],
    81.          [0, 1, 2, 2, 2],
    82.          [2, 1, 0, 0, 1]]], dtype=torch.float32).reshape([1, 3, 5, 5])
    83. Kernel = torch.tensor([
    84.     [[[-1, 1, 0],
    85.      [0, 1, 0],
    86.      [0, 1, 1]],
    87.     [[-1, -1, 0],
    88.      [0, 0, 0],
    89.      [0, -1, 0]],
    90.     [[0, 0, -1],
    91.      [0, 1, 0],
    92.      [1, -1, -1]]],
    93.     [[[1, 1, -1],
    94.      [-1, -1, 1],
    95.      [0, -1, 1]],
    96.     [[0, 1, 0],
    97.      [-1, 0, -1],
    98.      [-1, 1, 0]],
    99.     [[-1, 0, 0],
    100.      [-1, 0, 1],
    101.      [-1, 0, 0]]]], dtype=torch.float32).reshape([2, 3, 3, 3])
    102. conv2d = Conv2D(in_channels=3, Kernel=Kernel, out_channels=2, kernel_size=3, padding=1, stride=2)
    103. print("inputs shape:",x.shape)
    104. outputs = conv2d(x)
    105. print("Conv2D outputs shape:",outputs.shape)
    106. print(outputs)
    107.  
    108. conv2d_2 = nn.Conv2d(in_channels=3, out_channels=2, kernel_size=3, padding=1, stride=(2, 2), bias=True)
    109. conv2d_2.weight = torch.nn.Parameter(Kernel)
    110. conv2d_2.bias = torch.nn.Parameter(torch.tensor([1, 0], dtype=torch.float32))
    111. out = conv2d_2(x)
    112. print(out)

    运行结果如下:

           

    总结

            本次实验较为有难度，通过再次对池化层、卷积层，手推和调用库函数的代码的整理书写，对整个流程也更为明确了，就最后一个实践的时候有一点点困难，对于变量初始化、传入值的维度还是不明确这里总结一下。

    对于卷积层的输入x:[batch_size(样本数), in_channel(图片的通道数), H, W(分别代表宽高)]

    卷积核w：[out_channel(输出通道，输出需要有几个通道), in_channel(输入通道数，图片有几个通道, H, W(卷积核的宽高)]

    偏置b：[1, out_channel（输出通道数)]

  • 相关阅读:
    与AI结对编程式是什么体验 Copilot vs AlphaCode, Codex, GPT-3
    内网安全学习
    java启动参数，idea参数设置，环境变量参数，jdk选项，程序main函数参数的配置和获取方式
    OpenAI （ChatGPT）中国免费试用地址
    【typescript】Typescript tsconfig.json全解析
    树莓派4B开机自动发微信报告ip地址
    Linux查看防火墙状态
    ​VsCode修改侧边栏字体大小——用缩放的方法​
    Spring Boot 2.x系列【8】功能篇之自定义启动Banner
    高级功能的PID控制器在电离规等真空计线性化处理中的应用
  • 原文地址：https://blog.csdn.net/m0_70026215/article/details/134279557