文章目录

  • 1. 原理
  • 1.1 代码思路
  • 2.代码
  • 3.运行结果
  • 2. 分析
  • 3.思考


1. 原理

我们在思考，深度神经网络到底是在学习什么？程序在经过学习后到底是做什么？其实很简单，当我们得到一个输入 X和输出 Y,我们希望得到一个映射函数，即所谓的卷积核，通过不断的迭代来更新我们权重的值，最终得到一个符合我们输入X 和输出 Y 的卷积核值；我们可以通过这个值来进行后续的预测

1.1 代码思路

深度学习卷积核计算器 卷积核怎么训练_神经网络

2.代码

# 1. 定义卷积操作
import torch
from torch import nn
from d2l import torch as d2l

# 1. 定义卷积操作
def conv2dd(X, K):
    H, W = K.shape
    Y = torch.zeros((X.shape[0] - H + 1, X.shape[1] - W + 1))
    for i in range(Y.shape[0]):
        for j in range(Y.shape[1]):
            Y[i, j] = (X[i:i + H, j:j + W] * K).sum()
    return Y


# 2. 定义卷积类
class Conv2d(nn.Module):
    def __init__(self, kernel_size):
        super().__init__()
        self.weight = nn.Parameter(torch.rand(kernel_size))
        self.bias = nn.Parameter(torch.ones(1))

    def forward(self, x):
        return conv2dd(x, self.weight) + self.bias


# 3. 定义需要学习的卷积核：
# 注：构造⼀个⼆维卷积层，它具有1个输出通道和形状为（1，2）的卷积核
conv2d = nn.Conv2d(1, 1, kernel_size=(1, 2), bias=False)

# 4. 定义初始数据
X = torch.ones((6, 8))
X[:, 2:6] = 0

# 这是我们需要学习到的卷积核，
# 目标：最终通过梯度下降的情况下看是否跟这个卷积核一样
K = torch.tensor([[1.0, -1.0]])

# 5. 定义目标数据
Y = conv2dd(X, K)


# 6. 将初始数据与目标数据进行整理

X = X.reshape((1, 1, 6, 8))
Y = Y.reshape((1, 1, 6, 7))

# 7.十次迭代，训练得到需要的卷积核
for i in range(30):
    Y_hat = conv2d(X)  # 对初始化数据X 进行卷积操作，卷积核kernel_size=(1,2)
    l = (Y_hat - Y) ** 2 # 计算损失值
    conv2d.zero_grad()  # 对卷积核进行梯度清零
    l.sum().backward()  # 损失值反向传播
    conv2d.weight.data[:] -= 3e-2 * conv2d.weight.grad # 对卷积核值进行更新学习
    if (i + 1) % 2 == 0:
        print(f'batch{i + 1},loss={l.sum():.3f}')

print(f'weight={conv2d.weight.data.reshape(1, 2)}')

3.运行结果

batch2,loss=1.970
batch4,loss=0.335
batch6,loss=0.058
batch8,loss=0.011
batch10,loss=0.002
batch12,loss=0.000
batch14,loss=0.000
batch16,loss=0.000
batch18,loss=0.000
batch20,loss=0.000
batch22,loss=0.000
batch24,loss=0.000
batch26,loss=0.000
batch28,loss=0.000
batch30,loss=0.000
weight=tensor([[ 1.0000, -1.0000]])

2. 分析

通过上述例子，我们手写了一个纯机器学习模型。我们可以清楚地发现。在只有输入和输出情况下，神经网络是如何学习到卷积核的参数的，我们发现最后所得的权重 weight矩阵 与我们起初的矩阵值差不多了，是不是很神奇，居然学出来了。。。

# 最初我们定义的矩阵
K = torch.tensor([[1.0, -1.0]])
# 我们通过神经网络学习到的矩阵
weight=tensor([[ 1.0000, -1.0000]])
# 以上两个矩阵 K ≈ weight

3.思考

由上述问题来说，我们发现神经网络就像一个函数模拟器一样，通过输入和输出的结果，我们通过学习，就可以得到一个比较好的函数模拟器，通过这个函数模拟器来处理这类问题(输入和输出类别一样的数据集)