动手学习卷积神经网络（二）---通过数据学习核数据

在进行通过数据学习核数据时，首先看一个简单的案例：检测图像中物体的边缘，即找到像素变化的位置。

⾸先我 们构造⼀张6 × 8的图像（即⾼和宽分别为6像素和8像素的图像）。它中间4列为⿊（0），其余为⽩(1) 然后构造⼀个⾼和宽分别为1和2的卷积核K。当它与输⼊做互相关运算时，如果横向相邻元素相同，输出为0；否则输出为⾮0。

因此，现在构造一个6 × 8的图像，利用ones进行创建单元数组：

X=nd.ones(6,8)

[[1. 1. 1. 1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1. 1. 1. 1.]]
<NDArray 6x8 @cpu(0)>

接着，为了构造边缘图像像素，将创建的单元数组X进行变化，让其中间列为⿊（0），其余为⽩(1)。

X[:, 2:6] = 0

[[1. 1. 0. 0. 0. 0. 1. 1.]
 [1. 1. 0. 0. 0. 0. 1. 1.]
 [1. 1. 0. 0. 0. 0. 1. 1.]
 [1. 1. 0. 0. 0. 0. 1. 1.]
 [1. 1. 0. 0. 0. 0. 1. 1.]
 [1. 1. 0. 0. 0. 0. 1. 1.]]
<NDArray 6x8 @cpu(0)>

构造⼀个⾼和宽分别为 1 和 2 的卷积核 K 。当它与输⼊做互相关运算时，如果横向相邻元

素相同，输出为 0 ；否则输出为⾮ 0 。

K = nd.array([[1, -1]])  #构造卷积核
Y = corr2d(X, K)         #做互相关运算

[[ 0.  1.  0.  0.  0. -1.  0.]
 [ 0.  1.  0.  0.  0. -1.  0.]
 [ 0.  1.  0.  0.  0. -1.  0.]
 [ 0.  1.  0.  0.  0. -1.  0.]
 [ 0.  1.  0.  0.  0. -1.  0.]
 [ 0.  1.  0.  0.  0. -1.  0.]]
<NDArray 6x7 @cpu(0)>

即可看出，此时的不同部分交替过程中，变为非0的数，其它的变为0.

整体的代码流程如下：

from mxnet import autograd, nd
from mxnet.gluon import nn

#卷积运算--互相关运算
def corr2d(X, K): # 本函数已保存在d2lzh包中⽅便以后使⽤
    h, w = K.shape    #读取核的行与列
    #print(h,w)
    Y = nd.zeros((X.shape[0] - h + 1, X.shape[1] - w + 1))   #给输出创建空间
    #print(Y)
    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

X = nd.ones((6, 8))
print(X)
X[:, 2:6] = 0
print(X)
K = nd.array([[1, -1]])  #构造卷积核
Y = corr2d(X, K)         #做互相关运算
print(Y)

最后，使⽤物体边缘检测中的输⼊数据X和输出数据Y来学习我们构造的核 数组K。

使⽤ Gluon 提供的 Conv2D 类来实现：

# 构造⼀个输出通道数为1（将在“多输⼊通道和多输出通道”⼀节介绍通道），核数组形状是(1, 2)的⼆维卷积层
#利用mxnet.gluon中的Conv2D进行二维卷积层的搭建

conv2d = nn.Conv2D(1, kernel_size=(1, 2))  #搭建输出通道与核数组
conv2d.initialize()

#print(conv2d) 

# ⼆维卷积层使⽤4维输⼊输出，格式为(样本, 通道, ⾼, 宽)，这⾥批量⼤⼩（批量中的样本数）和通
# 道数均为1
X = X.reshape((1, 1, 6, 8))   
Y = Y.reshape((1, 1, 6, 7))
#print(X)

for i in range(10):
    with autograd.record():
        Y_hat = conv2d(X)
        l = (Y_hat - Y) ** 2
    l.backward()
# 训练核数组
    conv2d.weight.data()[:] -= 3e-2 * conv2d.weight.grad()
    if (i + 1) % 2 == 0:
        print('batch %d, loss %.3f' % (i + 1, l.sum().asscalar()))

#查看学习得到的核数组
result=conv2d.weight.data().reshape((1, 2))
print(result)

输出结果：

batch 2, loss 4.949
batch 4, loss 0.831
batch 6, loss 0.140
batch 8, loss 0.024
batch 10, loss 0.004

[[ 0.9895    -0.9873705]]
<NDArray 1x2 @cpu(0)>

可以看出，迭代10次的时候，我们的核数组接近了之前的检测图像中物体的边缘核数组[1,-1],说明利用输入、输出数据可以很好的训练出核数组，有利于模型的搭建。