AI 助理
备案控制台
开发者社区 人工智能 文章 正文

PyTorch应用实战一：实现卷积操作

2023-10-13 184
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： PyTorch应用实战一：实现卷积操作

实验环境

python3.6 + pytorch1.8.0

import torch
print(torch.__version__)
1.8.0


0.卷积定义

卷积操作是指两个函数f和g之间的一种数学运算，它在信号处理、图像处理、机器学习等领域中广泛应用。在离散情况下，卷积操作可以表示为：

1697176219885.png

其中，f ff和g gg是离散函数，∗ *∗表示卷积操作，n nn是离散的变量。卷积操作可以看作是将函数g gg沿着n nn轴翻转，然后平移，每次和函数f ff相乘并求和，最后得到一个新的函数。这种操作可以实现信号的滤波、特征提取等功能，是数字信号处理中非常重要的基础操作。

1.利用张量操作实现卷积

1.1 unfold函数

PyTorch的unfold函数用于对张量进行展开操作。torch.unfold()可以理解为将一个高维的张量展开成一个二维矩阵的操作。即将原来的张量沿着指定的维度展开成一个二维矩阵，其中第一维对应原来张量的维度，第二维对应展开的位置。

函数原型如下：

torch.unfold(input, dimension, size, step)

参数说明：

  • input (Tensor) – 要展开的张量
  • dimension (int) – 沿着哪个维度展开
  • size (int) – 展开窗口的大小
  • step (int) – 两个相邻窗口之间的步长

1.2 张量分片

import torch
a = torch.arange(16).view(4, 4)
a
tensor([[ 0,  1,  2,  3],
        [ 4,  5,  6,  7],
        [ 8,  9, 10, 11],
        [12, 13, 14, 15]])
b = a.unfold(0, 3, 1)
b
tensor([[[ 0,  4,  8],
         [ 1,  5,  9],
         [ 2,  6, 10],
         [ 3,  7, 11]],
        [[ 4,  8, 12],
         [ 5,  9, 13],
         [ 6, 10, 14],
         [ 7, 11, 15]]])

b.shape
torch.Size([2, 4, 3])
c = b.unfold(1, 3, 1)
c
tensor([[[[ 0,  1,  2],
          [ 4,  5,  6],
          [ 8,  9, 10]],
         [[ 1,  2,  3],
          [ 5,  6,  7],
          [ 9, 10, 11]]],
        [[[ 4,  5,  6],
          [ 8,  9, 10],
          [12, 13, 14]],
         [[ 5,  6,  7],
          [ 9, 10, 11],
          [13, 14, 15]]]])

c.shape
torch.Size([2, 2, 3, 3])

完整程序

import torch
a = torch.arange(16).view(4, 4)
b = a.unfold(0, 3, 1)
c = b.unfold(1, 3, 1)
c.shape
torch.Size([2, 2, 3, 3])


这段代码定义了三个变量。假设我们将其分别命名为a，b和c，则：

  • 变量a是一个4x4的张量，其中包含了0到15的整数值，它通过torch.arange(16)和.view(4, 4)两个函数调用来实现。
  • 变量b是通过对变量a进行折叠操作得到的一个张量，具体来说，它是将变量a沿着第0维（即行）展开，并取窗口大小为3，步长为1的子张量所得到的结果。因此，如果我们将张量b打印出来，会得到：
tensor([[[ 0,  1,  2],
         [ 4,  5,  6],
         [ 8,  9, 10],
         [12, 13, 14]],
        [[ 1,  2,  3],
         [ 5,  6,  7],
         [ 9, 10, 11],
         [13, 14, 15]]])

其中，第一个子张量的值为[[0, 1, 2], [4, 5, 6], [8, 9, 10], [12, 13, 14]]，第二个子张量的值为[[1, 2, 3], [5, 6, 7], [9, 10, 11], [13, 14, 15]]。注意，这个张量的形状为(2, 4, 3)，即它包含2个子张量，每个子张量的形状为(4, 3)。

  • 变量c是对变量b进行类似的操作得到的，但是它是在第1维（即列）上展开并取子张量。具体来说，它是将变量b沿着第1维（即列）展开，并取窗口大小为3，步长为1的子张量所得到的结果。因此，如果我们将张量c打印出来，会得到：
tensor([[[[ 0,  1,  2],
          [ 4,  5,  6],
          [ 8,  9, 10]],
         [[ 1,  2,  3],
          [ 5,  6,  7],
          [ 9, 10, 11]]],
        [[[ 4,  5,  6],
          [ 8,  9, 10],
          [12, 13, 14]],
         [[ 5,  6,  7],
          [ 9, 10, 11],
          [13, 14, 15]]]])

其中，第一个子张量的值为[[[0, 1, 2], [4, 5, 6], [8, 9, 10]], [[1, 2, 3], [5, 6, 7], [9, 10, 11]]]，第二个子张量的值为[[[4, 5, 6], [8, 9, 10], [12, 13, 14]], [[5, 6, 7], [9, 10, 11], [13, 14, 15]]]。注意，这个张量的形状为(2, 2, 3, 3)，即它包含2个子张量，每个子张量的形状为(2, 3, 3)。

2.实现卷积操作

2.1 编写卷积函数

完整程序

import torch
def conv2d(x, weight, bias, stride, pad):
    n, c, h, w = x.shape
    d, c, k, j = weight.shape
    x_pad = torch.zeros(n, c, h+2*pad, w+2*pad).to(x.device)
    x_pad[:, :, pad:-pad, pad:-pad] = x
    x_pad = x_pad.unfold(2, k, stride)
    x_pad = x_pad.unfold(3, j, stride)
    out = torch.einsum('nchwkj,dckj->ndhw', x_pad, weight)
    out = out + bias.view(1, -1, 1, 1)
    return out

该函数实现了二维卷积操作。下面对函数进行详细分析：

  1. 输入参数：
  • x: 输入张量，维度为（batch_size，in_channels，input_height，input_width）。
  • weight: 卷积核张量，维度为（out_channels，in_channels，kernel_height，kernel_width）。
  • bias: 偏置项张量，维度为（out_channels，）。
  • stride: 卷积核移动的步长，可以是一个数或是一个长度为 2 的元组，分别表示水平方向和竖直方向的步长。
  • pad: 输入张量周围要填充的零的数量。
  1. 局部填充：
  • 在进行卷积操作之前，需要在输入张量的周围按照给定的 pad 进行填充，以避免卷积核在张量边缘处超出范围的情况发生。
  • 在函数中使用 x_pad 表示经过填充后的输入张量。

具体实现：将输入张量 x 在第 2 和第 3 个维度（height 和 width 维度）上分别拆分成若干个形状为（kernel_height，kernel_width）的张量，每个张量之间的跳跃长度由 stride 决定，然后在第 2 和第 3 个维度上分别进行展开。

  • 这样每个展开后的张量就可以看作一个二维卷积核作用在 x 上的局部卷积结果，这些局部结果被按照第 2 和第 3 个维度重新拼接起来，得到新的张量 x_pad。
  1. 卷积操作：
  • 在新的张量 x_pad 上使用 einsum 函数对卷积核进行卷积操作。
  • einsum 的第一个参数表示操作的规则，其中 ndhw 表示最终输出的张量的维度为（batch_size，out_channels，output_height，output_width），nchw 和 dckj 表示两个输入张量 x_pad 和 weight 的维度，其中 c k j 分别表示 input_channels、kernel_height 和 kernel_width。
  • 最终得到的输出张量形状为（batch_size，out_channels，output_height，output_width），并在每个位置上加上偏置项 bias。
  • torch: PyTorch库
  • einsum: Einstein summation notation，爱因斯坦求和约定，一种张量求和的简便表示法。
  • 'nchwkj,dckj->ndhw':爱因斯坦求和符号，左侧的张量为x_pad，右侧的张量为weight。在左侧张量中，n, c, h, w分别表示batch size、通道数、高度、宽度。在右侧张量中，d, c, k, j分别表示输出通道数、输入通道数、卷积核高度、卷积核宽度。这个式子的意义是将x_pad和weight执行卷积操作，并输出结果张量，其形状为(batch_size, output_channels, height, width)。
  • x_pad: 输入的张量，形状为 (batch_size, input_channels, input_height, input_width)。
  • weight: 卷积核张量，形状为 (output_channels, input_channels, kernel_height, kernel_width)。
  1. 返回结果：
  • 返回卷积操作后得到的输出张量。

2.2 对编写的卷积函数举例分析

# 设置测试数据
x = torch.randn(2, 3, 5, 5, requires_grad=True)
weight = torch.randn(4, 3, 3, 3, requires_grad=True)
bias = torch.randn(4, requires_grad = True)
stride = 2
pad = 2
x, weight, bias

(tensor([[[[-0.4888,  1.0257,  0.0312, -0.9026, -0.9060],
           [ 0.2071, -0.4962, -0.1658,  1.0919,  0.3785],
           [-0.4654,  1.5442,  0.6005,  0.3594, -2.6207],
           [ 0.5830,  0.0533,  0.5719,  1.5413,  0.5949],
           [-0.9152, -0.2114, -0.4888, -0.0065, -0.9767]],
          [[ 0.4706, -0.1108, -0.1563, -1.7946, -0.8533],
           [-0.2119,  0.3165, -2.2668, -0.8956,  1.0617],
           [-0.7809, -0.2120, -0.8592, -0.5057,  0.7954],
           [-2.8820, -0.6888,  0.4450, -0.3586, -0.9477],
           [ 0.6244,  0.4303,  1.4739,  0.2740,  1.6605]],
          [[-0.1501,  0.6234, -1.6086,  0.1693,  0.4932],
           [ 1.0611, -1.0938,  0.1695,  1.0193,  0.4263],
           [ 1.4681, -0.1552, -0.0667, -0.7293,  1.0816],
           [ 0.8972,  1.1683, -1.4757,  0.4421, -0.0355],
           [-2.1331,  1.4847,  0.1378, -1.6907, -0.1350]]],
         [[[-1.3853,  1.6396,  0.3436,  0.3841,  0.2355],
           [-0.2206, -0.5087, -1.6956,  1.3205,  0.7058],
           [ 0.0993,  0.3533, -0.2086,  0.2969,  0.2627],
           [ 0.3752,  0.0304,  1.2487,  1.3963, -0.0063],
           [-1.3758,  0.5088, -1.3849,  1.3050,  0.4150]],
          [[ 0.2824, -2.8634, -0.1016, -0.1627,  1.7081],
           [ 0.1406,  0.2220, -0.6005,  0.2997, -0.1846],
           [ 1.6700,  0.5787,  0.6561, -0.0236,  1.7743],
           [ 2.1429, -0.2838, -0.0527,  0.3504, -0.3444],
           [-0.9409, -0.4734, -0.4060, -0.5088, -1.8518]],
          [[-2.2152,  0.2104, -0.3302,  0.2036, -0.9443],
           [-0.6576, -0.4455,  0.5117, -2.0058, -1.3985],
           [-0.5688,  1.2338, -0.1832,  0.1760,  0.4506],
           [-0.6563,  0.4021, -1.6210,  0.5582, -0.9238],
           [-1.0506, -0.9638,  0.7453, -0.3535, -0.3536]]]], requires_grad=True),
 tensor([[[[ 0.3069,  0.2079, -0.2952],
           [ 1.7681,  1.1056, -1.0555],
           [ 1.5845,  0.8294,  0.6588]],
          [[ 0.2574,  0.5007,  0.2912],
           [-0.0210,  0.6593, -0.9691],
           [-0.2918,  0.5695, -1.1242]],
          [[ 0.7327, -0.3453,  0.7041],
           [-0.2236, -1.7762,  0.0190],
           [-1.0927, -2.9369,  0.1768]]],
         [[[-2.3830, -1.4807,  1.8573],
           [ 1.0097, -0.9640,  1.0361],
           [-0.5222, -1.0386, -0.4016]],
          [[ 0.5071,  1.1433, -0.1194],
           [-0.0133, -0.3878, -0.1853],
           [ 0.3456, -0.6502,  0.2221]],
          [[-1.7672, -0.0469, -0.5996],
           [-0.2080, -1.6209,  0.4120],
           [ 0.8404, -1.6748, -0.7170]]],
         [[[ 0.2850,  0.1691, -0.9228],
           [ 0.7234,  0.5582, -0.4327],
           [ 0.6563,  0.2941,  1.5549]],
          [[ 0.2642, -1.9061,  1.6212],
           [-0.5276, -0.5608,  0.3824],
           [ 0.4452, -2.5152,  0.4490]],
          [[-0.1276,  0.7784,  0.7998],
           [-0.3030, -0.9776,  0.9681],
           [ 1.0225,  0.8946, -0.8084]]],
         [[[-0.5087, -0.8345, -1.4763],
           [-0.4938,  1.1979, -0.1335],
           [ 0.5010,  0.2865,  0.0728]],
          [[-0.3177, -0.6937, -1.0327],
           [ 0.8147, -1.7101, -1.8257],
           [-0.1593, -1.3855, -0.0885]],
          [[-0.4687, -1.6307,  1.5791],
           [-1.3030,  0.2004, -0.7055],
           [ 0.0674, -0.8772,  0.1586]]]], requires_grad=True),
 tensor([ 1.5349, -0.5608,  0.5182,  0.3328], requires_grad=True))

n, c, h, w = x.shape
d, c, k, j = weight.shape
n, c, h, w
(2, 3, 5, 5)
d, c, k, j
(4, 3, 3, 3)
# 补零
x_pad = torch.zeros(n, c, h+2*pad, w+2*pad).to(x.device)
x_pad
tensor([[[[0., 0., 0., 0., 0., 0., 0., 0., 0.],
          [0., 0., 0., 0., 0., 0., 0., 0., 0.],
          [0., 0., 0., 0., 0., 0., 0., 0., 0.],
          [0., 0., 0., 0., 0., 0., 0., 0., 0.],
          [0., 0., 0., 0., 0., 0., 0., 0., 0.],
          [0., 0., 0., 0., 0., 0., 0., 0., 0.],
          [0., 0., 0., 0., 0., 0., 0., 0., 0.],
          [0., 0., 0., 0., 0., 0., 0., 0., 0.],
          [0., 0., 0., 0., 0., 0., 0., 0., 0.]],
         [[0., 0., 0., 0., 0., 0., 0., 0., 0.],
          [0., 0., 0., 0., 0., 0., 0., 0., 0.],
          [0., 0., 0., 0., 0., 0., 0., 0., 0.],
          [0., 0., 0., 0., 0., 0., 0., 0., 0.],
          [0., 0., 0., 0., 0., 0., 0., 0., 0.],
          [0., 0., 0., 0., 0., 0., 0., 0., 0.],
          [0., 0., 0., 0., 0., 0., 0., 0., 0.],
          [0., 0., 0., 0., 0., 0., 0., 0., 0.],
          [0., 0., 0., 0., 0., 0., 0., 0., 0.]],
         [[0., 0., 0., 0., 0., 0., 0., 0., 0.],
          [0., 0., 0., 0., 0., 0., 0., 0., 0.],
          [0., 0., 0., 0., 0., 0., 0., 0., 0.],
          [0., 0., 0., 0., 0., 0., 0., 0., 0.],
          [0., 0., 0., 0., 0., 0., 0., 0., 0.],
          [0., 0., 0., 0., 0., 0., 0., 0., 0.],
          [0., 0., 0., 0., 0., 0., 0., 0., 0.],
          [0., 0., 0., 0., 0., 0., 0., 0., 0.],
          [0., 0., 0., 0., 0., 0., 0., 0., 0.]]],
        [[[0., 0., 0., 0., 0., 0., 0., 0., 0.],
          [0., 0., 0., 0., 0., 0., 0., 0., 0.],
          [0., 0., 0., 0., 0., 0., 0., 0., 0.],
          [0., 0., 0., 0., 0., 0., 0., 0., 0.],
          [0., 0., 0., 0., 0., 0., 0., 0., 0.],
          [0., 0., 0., 0., 0., 0., 0., 0., 0.],
          [0., 0., 0., 0., 0., 0., 0., 0., 0.],
          [0., 0., 0., 0., 0., 0., 0., 0., 0.],
          [0., 0., 0., 0., 0., 0., 0., 0., 0.]],
         [[0., 0., 0., 0., 0., 0., 0., 0., 0.],
          [0., 0., 0., 0., 0., 0., 0., 0., 0.],
          [0., 0., 0., 0., 0., 0., 0., 0., 0.],
          [0., 0., 0., 0., 0., 0., 0., 0., 0.],
          [0., 0., 0., 0., 0., 0., 0., 0., 0.],
          [0., 0., 0., 0., 0., 0., 0., 0., 0.],
          [0., 0., 0., 0., 0., 0., 0., 0., 0.],
          [0., 0., 0., 0., 0., 0., 0., 0., 0.],
          [0., 0., 0., 0., 0., 0., 0., 0., 0.]],
         [[0., 0., 0., 0., 0., 0., 0., 0., 0.],
          [0., 0., 0., 0., 0., 0., 0., 0., 0.],
          [0., 0., 0., 0., 0., 0., 0., 0., 0.],
          [0., 0., 0., 0., 0., 0., 0., 0., 0.],
          [0., 0., 0., 0., 0., 0., 0., 0., 0.],
          [0., 0., 0., 0., 0., 0., 0., 0., 0.],
          [0., 0., 0., 0., 0., 0., 0., 0., 0.],
          [0., 0., 0., 0., 0., 0., 0., 0., 0.],
          [0., 0., 0., 0., 0., 0., 0., 0., 0.]]]])

x_pad.shape
torch.Size([2, 3, 9, 9])
x_pad[:, :, pad:-pad, pad:-pad] = x
x_pad
tensor([[[[ 0.0000,  0.0000,  0.0000,  0.0000,  0.0000,  0.0000,  0.0000,
            0.0000,  0.0000],
          [ 0.0000,  0.0000,  0.0000,  0.0000,  0.0000,  0.0000,  0.0000,
            0.0000,  0.0000],
          [ 0.0000,  0.0000, -0.4888,  1.0257,  0.0312, -0.9026, -0.9060,
            0.0000,  0.0000],
          [ 0.0000,  0.0000,  0.2071, -0.4962, -0.1658,  1.0919,  0.3785,
            0.0000,  0.0000],
          [ 0.0000,  0.0000, -0.4654,  1.5442,  0.6005,  0.3594, -2.6207,
            0.0000,  0.0000],
          [ 0.0000,  0.0000,  0.5830,  0.0533,  0.5719,  1.5413,  0.5949,
            0.0000,  0.0000],
          [ 0.0000,  0.0000, -0.9152, -0.2114, -0.4888, -0.0065, -0.9767,
            0.0000,  0.0000],
          [ 0.0000,  0.0000,  0.0000,  0.0000,  0.0000,  0.0000,  0.0000,
            0.0000,  0.0000],
          [ 0.0000,  0.0000,  0.0000,  0.0000,  0.0000,  0.0000,  0.0000,
            0.0000,  0.0000]],
         [[ 0.0000,  0.0000,  0.0000,  0.0000,  0.0000,  0.0000,  0.0000,
            0.0000,  0.0000],
          [ 0.0000,  0.0000,  0.0000,  0.0000,  0.0000,  0.0000,  0.0000,
            0.0000,  0.0000],
          [ 0.0000,  0.0000,  0.4706, -0.1108, -0.1563, -1.7946, -0.8533,
            0.0000,  0.0000],
          [ 0.0000,  0.0000, -0.2119,  0.3165, -2.2668, -0.8956,  1.0617,
            0.0000,  0.0000],
          [ 0.0000,  0.0000, -0.7809, -0.2120, -0.8592, -0.5057,  0.7954,
            0.0000,  0.0000],
          [ 0.0000,  0.0000, -2.8820, -0.6888,  0.4450, -0.3586, -0.9477,
            0.0000,  0.0000],
          [ 0.0000,  0.0000,  0.6244,  0.4303,  1.4739,  0.2740,  1.6605,
            0.0000,  0.0000],
          [ 0.0000,  0.0000,  0.0000,  0.0000,  0.0000,  0.0000,  0.0000,
            0.0000,  0.0000],
          [ 0.0000,  0.0000,  0.0000,  0.0000,  0.0000,  0.0000,  0.0000,
            0.0000,  0.0000]],
         [[ 0.0000,  0.0000,  0.0000,  0.0000,  0.0000,  0.0000,  0.0000,
            0.0000,  0.0000],
          [ 0.0000,  0.0000,  0.0000,  0.0000,  0.0000,  0.0000,  0.0000,
            0.0000,  0.0000],
          [ 0.0000,  0.0000, -0.1501,  0.6234, -1.6086,  0.1693,  0.4932,
            0.0000,  0.0000],
          [ 0.0000,  0.0000,  1.0611, -1.0938,  0.1695,  1.0193,  0.4263,
            0.0000,  0.0000],
          [ 0.0000,  0.0000,  1.4681, -0.1552, -0.0667, -0.7293,  1.0816,
            0.0000,  0.0000],
          [ 0.0000,  0.0000,  0.8972,  1.1683, -1.4757,  0.4421, -0.0355,
            0.0000,  0.0000],
          [ 0.0000,  0.0000, -2.1331,  1.4847,  0.1378, -1.6907, -0.1350,
            0.0000,  0.0000],
          [ 0.0000,  0.0000,  0.0000,  0.0000,  0.0000,  0.0000,  0.0000,
            0.0000,  0.0000],
          [ 0.0000,  0.0000,  0.0000,  0.0000,  0.0000,  0.0000,  0.0000,
            0.0000,  0.0000]]],
        [[[ 0.0000,  0.0000,  0.0000,  0.0000,  0.0000,  0.0000,  0.0000,
            0.0000,  0.0000],
          [ 0.0000,  0.0000,  0.0000,  0.0000,  0.0000,  0.0000,  0.0000,
            0.0000,  0.0000],
          [ 0.0000,  0.0000, -1.3853,  1.6396,  0.3436,  0.3841,  0.2355,
            0.0000,  0.0000],
          [ 0.0000,  0.0000, -0.2206, -0.5087, -1.6956,  1.3205,  0.7058,
            0.0000,  0.0000],
          [ 0.0000,  0.0000,  0.0993,  0.3533, -0.2086,  0.2969,  0.2627,
            0.0000,  0.0000],
          [ 0.0000,  0.0000,  0.3752,  0.0304,  1.2487,  1.3963, -0.0063,
            0.0000,  0.0000],
          [ 0.0000,  0.0000, -1.3758,  0.5088, -1.3849,  1.3050,  0.4150,
            0.0000,  0.0000],
          [ 0.0000,  0.0000,  0.0000,  0.0000,  0.0000,  0.0000,  0.0000,
            0.0000,  0.0000],
          [ 0.0000,  0.0000,  0.0000,  0.0000,  0.0000,  0.0000,  0.0000,
            0.0000,  0.0000]],
         [[ 0.0000,  0.0000,  0.0000,  0.0000,  0.0000,  0.0000,  0.0000,
            0.0000,  0.0000],
          [ 0.0000,  0.0000,  0.0000,  0.0000,  0.0000,  0.0000,  0.0000,
            0.0000,  0.0000],
          [ 0.0000,  0.0000,  0.2824, -2.8634, -0.1016, -0.1627,  1.7081,
            0.0000,  0.0000],
          [ 0.0000,  0.0000,  0.1406,  0.2220, -0.6005,  0.2997, -0.1846,
            0.0000,  0.0000],
          [ 0.0000,  0.0000,  1.6700,  0.5787,  0.6561, -0.0236,  1.7743,
            0.0000,  0.0000],
          [ 0.0000,  0.0000,  2.1429, -0.2838, -0.0527,  0.3504, -0.3444,
            0.0000,  0.0000],
          [ 0.0000,  0.0000, -0.9409, -0.4734, -0.4060, -0.5088, -1.8518,
            0.0000,  0.0000],
          [ 0.0000,  0.0000,  0.0000,  0.0000,  0.0000,  0.0000,  0.0000,
            0.0000,  0.0000],
          [ 0.0000,  0.0000,  0.0000,  0.0000,  0.0000,  0.0000,  0.0000,
            0.0000,  0.0000]],
         [[ 0.0000,  0.0000,  0.0000,  0.0000,  0.0000,  0.0000,  0.0000,
            0.0000,  0.0000],
          [ 0.0000,  0.0000,  0.0000,  0.0000,  0.0000,  0.0000,  0.0000,
            0.0000,  0.0000],
          [ 0.0000,  0.0000, -2.2152,  0.2104, -0.3302,  0.2036, -0.9443,
            0.0000,  0.0000],
          [ 0.0000,  0.0000, -0.6576, -0.4455,  0.5117, -2.0058, -1.3985,
            0.0000,  0.0000],
          [ 0.0000,  0.0000, -0.5688,  1.2338, -0.1832,  0.1760,  0.4506,
            0.0000,  0.0000],
          [ 0.0000,  0.0000, -0.6563,  0.4021, -1.6210,  0.5582, -0.9238,
            0.0000,  0.0000],
          [ 0.0000,  0.0000, -1.0506, -0.9638,  0.7453, -0.3535, -0.3536,
            0.0000,  0.0000],
          [ 0.0000,  0.0000,  0.0000,  0.0000,  0.0000,  0.0000,  0.0000,
            0.0000,  0.0000],
          [ 0.0000,  0.0000,  0.0000,  0.0000,  0.0000,  0.0000,  0.0000,
            0.0000,  0.0000]]]], grad_fn=<CopySlices>)

# 卷积
x_pad = x_pad.unfold(2, k, stride)
x_pad.shape
torch.Size([2, 3, 4, 9, 3])
x_pad = x_pad.unfold(3, j, stride)
x_pad.shape
torch.Size([2, 3, 4, 4, 3, 3])
out = torch.einsum('nchwkj,dckj->ndhw', x_pad, weight)
out.shape
torch.Size([2, 4, 4, 4])
bias.view(1, -1, 1, 1).shape
torch.Size([1, 4, 1, 1])
# 偏置
out = out + bias.view(1, -1, 1, 1)
out
tensor([[[[ 0.6573, -0.3444,  1.5693, -0.1906],
          [ 2.5483,  5.1142, -2.3528, -3.6162],
          [ 2.9913, -6.1289,  6.8200,  0.9229],
          [ 0.4849,  0.1813,  3.2616,  1.5637]],
         [[-0.1524, -1.2003, -0.3415,  0.0318],
          [-1.7830,  2.5286, -1.6660,  3.1253],
          [ 1.3314, -8.2623, -5.0055,  5.7671],
          [-1.0563,  5.2751, -0.4214,  2.8473]],
         [[ 0.0908,  2.6704,  1.0336,  0.0481],
          [ 0.2077,  2.0459,  1.8095, -0.7039],
          [ 0.9519, -4.5551,  3.7108,  0.7446],
          [ 0.6689,  3.9448,  2.3968,  0.6958]],
         [[ 0.2318, -0.3356,  2.4320,  0.0480],
          [ 0.2101, -1.7177,  6.3956, -0.4108],
          [ 8.2352, -5.8456, 12.9459, -0.8763],
          [-2.3292, -1.5263,  2.1349,  0.3653]]],
        [[[-0.0869,  1.0713,  0.1655,  2.4414],
          [-1.3623, -3.0759,  0.2430,  2.3259],
          [-0.9281,  2.1402,  7.1618,  4.1895],
          [ 0.9273,  1.1176,  0.7792,  0.9265]],
         [[ 1.6465, -1.7187, -0.7251, -0.8871],
          [-1.6260, -0.8628, -1.0122,  3.2737],
          [ 0.5831,  2.1665, -0.5353, -2.0468],
          [-2.3738, -0.1232, -0.0771, -1.8642]],
         [[ 0.2819,  6.0978,  2.9618,  0.4676],
          [ 1.3592,  6.7231,  3.8100,  3.6118],
          [ 0.9885, -5.7760,  5.4375,  0.5480],
          [-0.5778,  1.4657, -2.8315,  0.1923]],
         [[-0.1444,  3.6788,  0.3721,  0.1150],
          [-1.4057,  0.1613, -2.5436,  1.3156],
          [-6.1195,  1.8325,  3.1565,  0.8296],
          [ 1.6766,  6.9403,  1.3986,  0.8758]]]], grad_fn=<AddBackward0>)

2.3 验证编写卷积函数的正确性

import torch.nn.functional as F
x = torch.randn(2, 3, 5, 5, requires_grad=True)
w = torch.randn(4, 3, 3, 3, requires_grad=True)
b = torch.randn(4, requires_grad = True)
stride = 2
pad = 2
torch_out = F.conv2d(x, w, b, stride, pad)
my_out = conv2d(x, w, b, stride, pad)

torch_out == my_out

tensor([[[[ True,  True,  True,  True],
          [ True, False, False,  True],
          [ True,  True, False,  True],
          [ True,  True, False,  True]],
         [[ True,  True,  True,  True],
          [ True, False,  True,  True],
          [False,  True,  True,  True],
          [ True,  True,  True,  True]],
         [[ True, False, False,  True],
          [False, False,  True,  True],
          [ True, False, False,  True],
          [ True,  True, False,  True]],
         [[ True,  True, False,  True],
          [False, False, False,  True],
          [ True, False, False, False],
          [ True,  True,  True,  True]]],
        [[[ True,  True,  True,  True],
          [False,  True, False,  True],
          [ True,  True, False,  True],
          [ True, False,  True,  True]],
         [[ True,  True, False,  True],
          [ True, False, False, False],
          [ True, False, False, False],
          [ True, False,  True,  True]],
         [[ True,  True, False,  True],
          [False, False, False,  True],
          [ True, False, False, False],
          [ True, False,  True,  True]],
         [[ True, False,  True,  True],
          [ True, False, False,  True],
          [False, False, False, False],
          [ True,  True, False,  True]]]])

torch.allclose(torch_out, my_out, atol=1e-5)
True
  • torch.allclose是用于检查两个张量之间的数值是否相等的函数。
  • 在使用时，需要将第一个张量作为第一个参数传入（即torch_out），将第二个张量作为第二个参数传入（即my_out），并将允许的绝对误差（atol）作为第三个参数传入（默认值为1e-8）。
  • 函数将返回一个布尔值，表示两个张量是否具有相近的数值。如果返回True，则表示两个张量具有相近的数值，否则表示它们之间存在数值差异。
grad_out = torch.randn(*torch_out.shape)
grad_x = torch.autograd.grad(torch_out, x, grad_out, retain_graph=True)
my_grad_x = torch.autograd.grad(my_out, x, grad_out, retain_graph=True)

torch.allclose(grad_x[0], my_grad_x[0], atol=1e-5)
True
grad_w = torch.autograd.grad(torch_out, w, grad_out, retain_graph=True)
my_grad_w = torch.autograd.grad(my_out, w, grad_out, retain_graph=True)

torch.allclose(grad_w[0], my_grad_w[0], atol=1e-5)
True
grad_b = torch.autograd.grad(torch_out, b, grad_out, retain_graph=True)
my_grad_b = torch.autograd.grad(my_out, b, grad_out, retain_graph=True)

torch.allclose(grad_b[0], my_grad_b[0], atol=1e-5)
True

全是True，表明编写的卷积函数在一定范围内与PyTorch内置的Conv2d函数结果相近，说明了实现的正确性

附：系列文章

序号 文章目录 直达链接
序号 文章目录 直达链接
1 PyTorch应用实战一：实现卷积操作 https://want595.blog.csdn.net/article/details/132575530
2 PyTorch应用实战二：实现卷积神经网络进行图像分类 https://want595.blog.csdn.net/article/details/132575702
3 PyTorch应用实战三：构建神经网络 https://want595.blog.csdn.net/article/details/132575758
4 PyTorch应用实战四：基于PyTorch构建复杂应用 https://want595.blog.csdn.net/article/details/132625270
5 PyTorch应用实战五：实现二值化神经网络 https://want595.blog.csdn.net/article/details/132625348
6 PyTorch应用实战六：利用LSTM实现文本情感分类 https://want595.blog.csdn.net/article/details/132625382
文章标签：
算法框架/工具
PyTorch
机器学习/深度学习
计算机视觉
关键词：
pytorch实战
pytorch应用
pytorch操作
pytorch卷积
pytorch实战卷积
Want595
目录
相关文章
Python大数据分析
|
4月前
|
机器学习/深度学习 PyTorch TensorFlow
TensorFlow和PyTorch的实际应用比较
TensorFlow和PyTorch的实际应用比较
Python大数据分析
86 1
东方睿赢
|
3月前
|
机器学习/深度学习 数据挖掘 TensorFlow
解锁Python数据分析新技能，TensorFlow&PyTorch双引擎驱动深度学习实战盛宴
在数据驱动时代，Python凭借简洁的语法和强大的库支持，成为数据分析与机器学习的首选语言。Pandas和NumPy是Python数据分析的基础，前者提供高效的数据处理工具，后者则支持科学计算。TensorFlow与PyTorch作为深度学习领域的两大框架，助力数据科学家构建复杂神经网络，挖掘数据深层价值。通过Python打下的坚实基础，结合TensorFlow和PyTorch的强大功能，我们能在数据科学领域探索无限可能，解决复杂问题并推动科研进步。
东方睿赢
71 0
LDG_AGI
|
4月前
|
机器学习/深度学习 PyTorch TensorFlow
【PyTorch】PyTorch深度学习框架实战（一）：实现你的第一个DNN网络
【PyTorch】PyTorch深度学习框架实战（一）：实现你的第一个DNN网络
LDG_AGI
191 1
郑小健
|
4月前
|
机器学习/深度学习 数据采集 自然语言处理
PyTorch 在自然语言处理中的应用实践
【8月更文第29天】随着深度学习技术的发展，自然语言处理（NLP）领域取得了显著的进步。PyTorch 作为一款强大的深度学习框架，因其灵活性和易用性而被广泛采用。本文将介绍如何利用 PyTorch 构建文本分类模型，并以情感分析为例进行详细介绍。
郑小健
62 0
东方睿赢
|
5月前
|
机器学习/深度学习 数据挖掘 TensorFlow
解锁Python数据分析新技能，TensorFlow&PyTorch双引擎驱动深度学习实战盛宴
【7月更文挑战第31天】在数据驱动时代，Python凭借其简洁性与强大的库支持，成为数据分析与机器学习的首选语言。**数据分析基础**从Pandas和NumPy开始，Pandas简化了数据处理和清洗，NumPy支持高效的数学运算。例如，加载并清洗CSV数据、计算总销售额等。
东方睿赢
63 2
众所周知
|
5月前
|
机器学习/深度学习 人工智能 数据挖掘
从0到1构建AI帝国：PyTorch深度学习框架下的数据分析与实战秘籍
【7月更文挑战第30天】PyTorch以其灵活性和易用性成为深度学习的首选框架。
众所周知
73 2
众所周知
|
5月前
|
机器学习/深度学习 数据挖掘 PyTorch
🚀PyTorch实战宝典：从数据分析小白到深度学习高手的飞跃之旅
【7月更文挑战第29天】在数据驱动的世界里, **PyTorch** 作为深度学习框架新星, 凭借其直观易用性和高效计算性能, 助力数据分析新手成为深度学习专家。首先, 掌握Pandas、Matplotlib等工具进行数据处理和可视化至关重要。接着, 安装配置PyTorch环境, 学习张量、自动求导等概念。通过构建简单线性回归模型, 如定义 `nn.Module` 类、设置损失函数和优化器, 进行训练和测试, 逐步过渡到复杂模型如CNN和RNN的应用。不断实践, 你将能熟练运用PyTorch解决实际问题。
众所周知
95 1
小森ai小小贾
|
6月前
|
存储 机器学习/深度学习 PyTorch
Pytorch-张量形状操作
PyTorch中，张量形状操作至关重要，如reshape用于改变维度而不变元素，transpose/permute用于维度交换，view改形状需内存连续，squeeze移除单维度，unsqueeze添加维度。这些函数帮助数据适应神经网络层间的转换。例如，reshape能调整数据适配层的输入，transpose用于矩阵转置或多维排列，而squeeze和unsqueeze则用于处理单维度。理解并熟练运用这些工具是深度学习中必要的技能。
小森ai小小贾
91 5
阿旭算法与机器学习
|
6月前
|
机器学习/深度学习 PyTorch 算法框架/工具
【从零开始学习深度学习】47. Pytorch图片样式迁移实战：将一张图片样式迁移至另一张图片，创作自己喜欢风格的图片【含完整源码】
【从零开始学习深度学习】47. Pytorch图片样式迁移实战：将一张图片样式迁移至另一张图片，创作自己喜欢风格的图片【含完整源码】
阿旭算法与机器学习
86 2
阿旭算法与机器学习
|
6月前
|
机器学习/深度学习 资源调度 PyTorch
【从零开始学习深度学习】15. Pytorch实战Kaggle比赛：房价预测案例【含数据集与源码】
【从零开始学习深度学习】15. Pytorch实战Kaggle比赛：房价预测案例【含数据集与源码】
阿旭算法与机器学习
276 0

热门文章

最新文章

  • 1
    视觉神经网络模型优秀开源工作：PyTorch Image Models（timm）库（下）
  • 2
    Pytorch 各种奇葩古怪的使用方法
  • 3
    什么是LSTM模型，什么是BILSTM模型，给出　pytorch案例
  • 4
    如何用PyTorch处理人脸姿态的数据？
  • 5
    PyTorch 实战-张量
  • 6
    pytorch优化器与学习率设置详解
  • 7
    一个易用且高效的基于 PyTorch 的 MoE 模型训练系统.
  • 8
    【Pytorch神经网络理论篇】 25 基于谱域图神经网络GNN：基础知识+GNN功能+矩阵基础+图卷积神经网络+拉普拉斯矩阵
  • 9
    详解PyTorch编译并调用自定义CUDA算子的三种方式
  • 10
    【PyTorch基础教程17】损失函数详解
  • 1
    使用PyTorch实现L1, L2和Elastic Net正则化
    103
  • 2
    TensorFlow与PyTorch框架的深入对比：特性、优势与应用场景
    691
  • 3
    【Python机器学习专栏】PyTorch在深度学习中的应用
    192
  • 4
    PyTorch与NLP：自然语言处理的深度学习实战
    617
  • 5
    【pytorch框架】对模型知识的基本了解
    56
  • 6
    TensorFlow与PyTorch在Python面试中的对比与应用
    234
  • 7
    PyTorch在NLP任务中的应用：文本分类、序列生成等
    97
  • 8
    PyTorch分布式训练：加速大规模数据集的处理
    288
  • 9
    PyTorch模型优化与调优：正则化、批归一化等技巧
    280
  • 10
    PyTorch与迁移学习：利用预训练模型提升性能
    167

    • 相关课程

    更多
  • Pytorch实战
  • 深度学习理论与实战（基于TensorFlow实现）
  • 深入浅出PyTorch
  • 跟着指南学PyTorch
  • 深度学习框架TensorFlow入门

    • 相关电子书

    更多
  • 典型模型-卷积神经网络入门
  • 线性加速Tensorflow分布式计算
  • 机器能理解上下文吗 RNN和LSTM神经网络的原理及应用

    • 相关实验场景

    更多
  • 使用PAI-快速开始，低代码实现大语言模型微调和部署

    • 推荐镜像

    更多
  • pytorch-wheels
  • blender
  • python-release
    • 下一篇
    阿里云oss存储简介和如何使用