计算神经网络数据读取与完成训练高效方法对比与推荐

先聊聊我们这次用的数据集——大名鼎鼎的 MNIST 手写数字集。根据官方介绍，这个数据集一共有 70000 个样本，其中 60000 个用于训练，10000 个用于测试。下载下来之后，文件被分成了四个部分：训练集图片、训练集标签、测试集图片、测试集标签。所有数据都以二进制格式存储。

具体来说，训练集图片文件的前 16 个字节存放了图片数量、行数、列数等信息；训练集标签文件的前 8 个字节存放了标签数量等。测试集的两个文件结构完全一致。

文摘菌下载好的文件存储地址

读取数据

train_img_path=r'C:UsersDellMNISTtrain-images.idx3-ubyte'
train_lab_path=r'C:UsersDellMNISTtrain-labels.idx1-ubyte'
test_img_path=r'C:UsersDellMNISTt10k-images.idx3-ubyte'
test_lab_path=r'C:UsersDellMNISTt10k-labels.idx1-ubyte'

根据文件在本地解压后的存储地址，生成四个路径。上面代码中的 r 是转义字符——因为反斜杠在 Python 中有特殊含义，所以需要用 raw string 来明确文件地址。

为了让模型表现更好，我们把训练集进一步拆分：50000 个样本用于训练，10000 个样本作为验证集。

注：验证集是模型训练过程中单独留出来的样本集，用于调整超参数，以及对模型能力进行初步评估。

import struct
train_num=50000
valid_num=10000
test_num=10000
with open(train_img_path,'rb') as f:
    struct.unpack('>4i',f.read(16))
    tmp_img=np.fromfile(f,dtype=np.uint8).reshape(-1,28*28)
train_img=tmp_img[:train_num]
valid_img=tmp_img[train_num:]
with open(test_img_path,'rb') as f:
    struct.unpack('>4i',f.read(16))
    test_img=np.fromfile(f,dtype=np.uint8).reshape(-1,28*28)
with open(train_lab_path,'rb') as f:
    struct.unpack('>2i',f.read(8))
    tmp_lab=np.fromfile(f,dtype=np.uint8)
train_lab=tmp_lab[:train_num]
valid_lab=tmp_lab[train_num:]
with open(test_lab_path,'rb') as f:
    struct.unpack('>2i',f.read(8))
    test_lab=np.fromfile(f,dtype=np.uint8)

文件是以二进制格式存储的，所以读取方式要用 rb。为了让数据以数值方式显示，这里用到了 Python 的 struct 包。struct.unpack('>4i', f.read(16)) 中的 > 代表字节存储方向，i 表示整数，4 表示需要前 4 个整数。f.read(16) 读取 16 个字节（一个整数 4 个字节，共 4 个整数）。reshape(-1, 28*28) 中，-1 表示该维度由其他参数决定，这里是将一维数组转换为二维矩阵，第二个参数指定每行的元素个数。

注：np.fromfile 的用法：np.fromfile(frame, dtype=np.float, count=-1, sep='')，其中 frame 是文件或字符串，dtype 是读取的数据类型，count 是读入元素个数（-1 表示读入整个文件），sep 是数据分割字符串。

文件读取完，接下来把数据显示成图片的样子：

import matplotlib.pyplot as plt
def show_train(index):
    plt.imshow(train_img[index].reshape(28,28),cmap='gray')
    print('label:{}'.format(train_lab[index]))
def show_test(index):
    plt.imshow(train_img[index].reshape(28,28),cmap='gray')
    print('label:{}'.format(test_lab[index]))
def valid_train(index):
    plt.imshow(valid_img[index].reshape(28,28),cmap='gray')
    print('label:{}'.format(valid_lab[index]))

注意，如果不定义 cmap='gray'，图片的底色会非常奇怪。

测试一下，定义完函数之后显示的效果就是这样~

数据显示和读取完成后，接下来开始训练参数。

训练数据

在开始之前，先把第一次课程的代码贴上来，方便上下衔接：

def tanh(x):
    return np.tanh(x)
def softmax(x):
    exp = np.exp(x-x.max())
    return exp/exp.sum()
dimensions = [28*28,10]
activation = [tanh,softmax]
distribution=[{'b':[0,0]},{'b':[0,0],'w':[-math.sqrt(6/(dimensions[0] + dimensions[1])),math.sqrt(6/(dimensions[0] + dimensions[1]))]}]

初始化参数b

def init_parameters_b(layer):
    dist = distribution[layer]['b']
    return np.random.rand(dimensions[layer])*(dist[1]-dist[0])+dist[0]

初始化参数w

def init_parameters_w(layer):
    dist = distribution[layer]['w']
    return np.random.rand(dimensions[layer-1],dimensions[layer])*(dist[1]-dist[0])+dist[0]

初始化参数方法

def init_parameters():
    parameter=[]
    for i in range(len(distribution)):
        layer_parameter={}
        for j in distribution[i].keys():
            if j=='b':
                layer_parameter['b'] = init_parameters_b(i)
                continue
            if j=='w':
                layer_parameter['w'] = init_parameters_w(i)
                continue
        parameter.append(layer_parameter)
    return parameter

预测函数

def predict(img,init_parameters):
    l0_in = img + parameters[0]['b']
    l0_out = activation[0](l0_in)
    l1_in = np.dot(l0_out,parameters[1]['w'])+ parameters[1]['b']
    l1_out = activation[1](l1_in)
    return l1_out

先定义两个激活函数的导数，导数的具体推导过程这里不展开，感兴趣的同学可以自行搜索。

def d_softmax(data):
    sm = softmax(data）
    return np.diag(sm)-np.outer(sm,sm)
def d_tanh(data):
    return 1/(np.cosh(data))**2
differential = {softmax:d_softmax,tanh:d_tanh}

其中 tanh 的导数本来是 np.diag(1/(np.cosh(data))**2)，优化后直接写成 1/(np.cosh(data))**2（diag 生成对角矩阵，outer 函数的作用是第一个参数挨个乘以第二个参数得到矩阵）。

再定义一个字典，并将数据解析为某一位置为1的一维矩阵：

differential = {softmax:d_softmax,tanh:d_tanh}
onehot = np.identity(dimensions[-1])

求平方差函数，其中 parameters 是第一次课程定义的那个初始化参数，在训练过程中会自动更新。

def sqr_loss(img,lab,parameters):
    y_pred = predict(img,parameters)
    y = onehot[lab]
    diff = y-y_pred
    return np.dot(diff,diff)

计算梯度：

def grad_parameters(img,lab,init_parameters):
    l0_in = img + parameters[0]['b']
    l0_out = activation[0](l0_in)
    l1_in = np.dot(l0_out,parameters[1]['w'])+ parameters[1]['b']
    l1_out = activation[1](l1_in)
    diff = onehot[lab]-l1_out
    act1 = np.dot(differential[activation[1]](l1_in),diff)
    grad_b1 = -2*act1
    grad_w1 = -2*np.outer(l0_out,act1)
    # 与上文优化d_tanh有关，将矩阵乘法化为数组乘以矩阵
    grad_b0 = -2*differential[activation[0]](l0_in)*np.dot(parameters[1]['w'],act1)
    return {'b1':grad_b1,'w1':grad_w1,'b0':grad_b0}

这次的梯度计算公式用到了 (y_predict - y)^2，根据复合函数求导，所以有 -2(y_predict - y) 乘以相关的导数——这也是 grad_b1 后面 -2 的来历。

按理说应该用导数的定义 [f(x+h) - f(x)] / h 验证下梯度求的对不对，为了照顾新手同学对神经网络的理解过程，这一步就省略了哈。

下面进入训练环节。我们将数据以 batch 的方式输入，每个 batch 包含 100 张图片（batch_size=100）。梯度的获取是用平均求得的，代码体现在 grad_accu[key] /= batch_size。

def train_batch(current_batch,parameters):
    grad_accu = grad_parameters(train_img[current_batch*batch_size+0],train_lab[current_batch*batch_size+0],parameters)
    for img_i in range(1,batch_size):
        grad_tmp = grad_parameters(train_img[current_batch*batch_size+img_i],train_lab[current_batch*batch_size+img_i],parameters)
        for key in grad_accu.keys():
            grad_accu[key] += grad_tmp[key]
    for key in grad_accu.keys():
        grad_accu[key]/=batch_size
    return grad_accu

import copy
def combine_parameters(parameters,grad,learn_rate):
    parameter_tmp = copy.deepcopy(parameters)
    parameter_tmp[0]['b'] -= learn_rate*grad['b0']
    parameter_tmp[1]['b'] -= learn_rate*grad['b1']
    parameter_tmp[1]['w'] -= learn_rate*grad['w1']
    return parameter_tmp

采用 copy 机制，是为了避免 parameters 变化影响全局训练。copy.deepcopy 可以重新拷贝，不影响原来的数据。这里用到的公式是：

然后定义学习率：

def learn_self(learn_rate):
    for i in range(train_num//batch_size):
        if i%100 == 99:
            print("running batch {}/{}".format(i+1,train_num//batch_size))
        grad_tmp = train_batch(i,parameters)
        global parameters
        parameters = combine_parameters(parameters,grad_tmp,learn_rate)

里面的 if 语句可以让我们看到神经网络训练的进度。

到这里，我们就完成了神经网络的一次训练。为了验证准确度，可以用验证集看看效果如何。

定义验证集的损失：

def valid_loss(parameters):
    loss_accu = 0
    for img_i in range(valid_num):
        loss_accu += sqr_loss(valid_img[img_i],valid_lab[img_i],parameters)
    return loss_accu

计算准确度：

def valid_accuracy(parameters):
    correct = [predict(valid_img[img_i],parameters).argmax()==valid_lab[img_i] for img_i in range(valid_num) ]
    print("validation accuracy:{}".format(correct.count(True)/len(correct)))

最后得到结果：

有 90% 的准确度，结果还好吧，毕竟没有怎么调学习率，也没有解决过拟合的问题。

好了，这一期的内容就到这儿了。内容有点多，大家多多消化。下一期我们聊聊怎么调节学习率，以及看看更复杂的神经网络。