1 在多个位置复用权重
1、神经网络最大的挑战是过拟合。过拟合指的是神经网络试图记忆一个数据集，而不是从中学习可以泛化到还没见过的数据的有用抽象。换句话说，神经网络学会的是基于数据集中的噪声进行预测，而不是依赖于基本信号
2、过拟合的产生通常是由于当前网络参数的数量多于学习特定数据集所需要的参数数量。这种情况下，网络有足够多的参数，以至于它可以记住训练集中的每一个细节，而不是高层次的抽象进行学习
3、网络结构是一种很好的防止过拟合的方法。网络结构指的是，在神经网络中，因为我们相信能够在多个位置检测到相同的模式，所以可以有选择地重复用针对多个目标的权重。正如所见，这可以显著地减少过拟合，并导致模型的精度更高，因为它降低了权重数量与数据量的比例
4、在神经网络中，最著名且最广泛使用的网络结构叫作卷积，当作为一层使用时叫作卷积层
2 卷积层（Convolutional Layer）
1、化整为零，将许多小线性神经元层在各处重用。卷积层背后的思想是，它不是一个大的、稠密的线性神经元层，在其中从每个输入到每个输出都有连接，而是由很多非常小的线性层构成，每个线性层通常拥有少于25个输入和一个输出，我们可以在任意输入位置使用它。每个小神经元层都被称为卷积核，但它实际上只是一个很小的线性层，含有weights和激活函数功能，接受少量的输入并作为单一输出
2、图片底部是4个不同的卷积核，它们处理相同的8×8的数字2的图像。每个卷积核的结果是是一个6×6（8-3卷积核长度+1）的预测矩阵。你可以对这些矩阵求和（求和池化），取它们的均值（平均池化），或者按元素计算最大值（最大池化）
3、最大池化方式是使用最多的：对于每个位置，查看4个卷积核各自的输出，找到最大值，并将它复制到一个6×6的最终矩阵中，如图2右下角所示。当所有运算完成后，这个最终矩阵（且仅有这个最终矩阵）将信号向前传播到下一层。需要注意的是这4个卷积核的学习模式不同，右下角的卷积核没有识别出被训练来预测的任何模式
4、网络的训练过程允许每个卷积核学习特定的模式，然后在图像的某个地方寻找该模式的存在。每个小巧的卷积核都在多数数据上进行了多次向前传播，从而改变了权重数量与训练这些权重的数量比例。这对网络产生了显著影响，极大地降低了过拟合现象，提高了网络的泛化能力
3 代码实现
1、layer_0是一批大小为28×28的图像，现在将每个图像切成3×3的小图像，一张图像可以分割成几百个子区域。通过线性层的一个输出神经元对它们进行正向传播这一过程，与每批图像在各个子区域上基于线性层进行预测是一样的
2、具有 n 个输出神经元的线性层，与n个卷积核（线性层）在每个输入位置进行预测的输出是一样的。这样做可以使代码更简单，也会更快
import sys,numpy as np
np.random.seed(1)
from keras.datasets import mnist
(x_train,y_train),(x_test,y_test) = mnist.load_data()
#维度分别为(60000,28,28),((60000,)
x_train.shape,y_train.shape
#维度分别为(1000,28*28),((1000,)
#功能：降维，进行标准化
images,labels = (x_train[0:1000].reshape(1000,28*28)/255,y_train[0:1000])
#维度是(1000,10)，将一个最终的数字，扩充到0-9上的比例
one_hot_labels = np.zeros((len(labels),10))
#这个是结果的维度(1000,10),在0-9的的对应位置上标记为1，其余位置标记为0
for i,l in enumerate(labels):
one_hot_labels[i][l] = 1
labels = one_hot_labels
#将像素值降到0-1之间
test_images = x_test.reshape(len(x_test),28*28)/255
test_labels = np.zeros((len(y_test),10))
for i,l in enumerate(y_test):
test_labels[i][l] = 1
#relu = lambda x:(x>0) * x
#relu2deriv = lambda x:x>0
#激活函数，将数值变换到(-1,1)之间
#隐藏层激活函数
def tanh(x):
return np.tanh(x)
#反向传播，tanh再求导
def tanh2deriv(output):
return 1-(output**2)
#沿着第一维进行求和，保留数组的维度
#输出层激活函数
def softmax(x):
temp = np.exp(x)
return temp/np.sum(temp,axis=1,keepdims=True)
alpha,interations = (2,10)
pixels_per_image,num_labels = (784,10)
#进行批训练的时候，batch_size 为 128
batch_size = 128
#图片的行、列个数
input_rows = 28
input_cols = 28
#卷积核的行、列数
kernel_rows = 3
kernel_cols = 3
#使用的卷积核的个数
num_kernels = 16
#10000
#隐藏层的size
hidden_size = ((input_rows - kernel_rows)*(input_cols - kernel_cols)) * num_kernels
#维度(9,16), 初始的kernels 权重，相当于weights_0_1
kernels = 0.02*np.random.random((kernel_rows*kernel_cols,num_kernels)) - 0.01
#维度(1000,10),输出层的维度
weights_1_2 = 0.2*np.random.random((hidden_size,num_labels)) - 0.1
#在一批图像中选择子区域，选择了一批输入图像的一小部分
def get_image_section(layer,row_from,row_to,col_from,col_to):
#对layer数据进行切片
section = layer[:,row_from:row_to,col_from:col_to]
#重塑切片后的shape
#reshape 用于修改数组的形状，不会改变数组的数据和数量，只会改变其维度
#-1 表示让Numpy自动计算这一维度的大小.是reshape之后的行数
return section.reshape(-1,1,row_to-row_from,col_to-col_from)
for j in range(interations):
correct_cnt = 0
#按照 batch_size 分批进行训练
for i in range(int(len(images)/batch_size)):
batch_start,batch_end = ((i * batch_size),((i+1)*batch_size))
#在图像的每个位置对它进行多次调用
#维度(128,784)
layer_0 = images[batch_start:batch_end]
#维度(128,28,28)，这里是将其升维到 28*28 行列的矩阵
layer_0 = layer_0.reshape(layer_0.shape[0],28,28)
sects = list()
#0-24
for row_start in range(layer_0.shape[1]-kernel_rows):
#0-24
for col_start in range(layer_0.shape[2]-kernel_cols):
#依次选取128个images的卷积kernels，维度应该是（128,1,3,3）
sect = get_image_section(layer_0,row_start,row_start+kernel_rows,col_start,col_start+kernel_cols)
sects.append(sect)
#将众多小的卷积数据进行汇总
expanded_input = np.concatenate(sects,axis=1)
es = expanded_input.shape
#降维
flattened_input = expanded_input.reshape(es[0]*es[1],-1)
#是在layer0之间加了许多线性卷积核，乘以kernels权重
kernel_output = flattened_input.dot(kernels)
layer_1 = tanh(kernel_output.reshape(es[0],-1))
dropout_mask = np.random.randint(2,size=layer_1.shape)
layer_1 *= dropout_mask*2
#最终的预测结果
layer_2 = softmax(np.dot(layer_1,weights_1_2))
for k in range(batch_size):
labelset = labels[batch_start+k:batch_start+k+1]
_inc = int(np.argmax(layer_2[k:k+1])==np.argmax(labelset))
correct_cnt += _inc
#反向传播步骤
layer_2_delta = (labels[batch_start:batch_end]-layer_2)/(batch_size*layer_2.shape[0])
layer_1_delta = layer_2_delta.dot(weights_1_2.T)*tanh2deriv(layer_1)
layer_1_delta *= dropout_mask
weights_1_2 += alpha*layer_1.T.dot(layer_2_delta)
#对kernel进行更新，相当于更新的 weights_0_1
l1d_reshape = layer_1_delta.reshape(kernel_output.shape)
k_update = flattened_input.T.dot(l1d_reshape)
kernels -= alpha*k_update
test_correct_cnt = 0
for i in range(len(test_images)):
layer_0 = test_images[i:i+1]
layer_0 = layer_0.reshape(layer_0.shape[0],28,28)
layer_0.shape
sects = list()
for row_start in range(layer_0.shape[1] - kernel_rows):
for col_start in range(layer_0.shape[2]-kernel_cols):
sect = get_image_section(layer_0,row_start,row_start+kernel_rows,col_start,col_start+kernel_cols)
sects.append(sect)
expanded_input = np.concatenate(sects,axis=1)
es = expanded_input.shape
flattened_input = expanded_input.reshape(es[0]*es[1],-1)
kernel_output = flattened_input.dot(kernels)
layer_1 = tanh(kernel_output.reshape(es[0],-1))
layer_2 = np.dot(layer_1,weights_1_2)
test_correct_cnt += int(np.argmax(layer_2)==np.argmax(test_labels[i:i+1]))
if(j %1 ==0):
sys.stdout.write("\n" + "I:" + str(j) + " Test-Acc:" +str(test_correct_cnt/float(len(test_images))) + \
" Train-Acc:" +str(correct_cnt/float(len(images))))
4 总结
1、卷积层的大多数用法是多层叠加在一起，这样每个卷积都将前一层的输出作为输入
2、层叠卷积层是促成非常深的神经网络以及深度学习流行的主要进展之一
3、复用权重是深度学习中最重要的创新之一
4、当神经网络需要在多处使用相同想法时，应试着在这些地方使用相同的权重，这样做会使那些权重有更多的样本可以学习并提高泛化能力，从而让权重更智能
5 参考资料
《深度学习图解》
