之前文章《深度学习入门（4）神经网络参数的训练方式》主要介绍神经网络中的参数梯度是如何计算的。本文将直接使用之前公众号介绍过损失函数、激活函数以及梯度计算直接手动实现一个两层的神经网络训练过程。

也许有人会说使用pytorch或者tensorflow框架，几行代码就可以搭建一个神经网络，为什么要自己手动去实现呢？我觉得使用现成框架确实很容易搭建一个神经网络，但是对于其中的计算原理如果不了解的话，那始终只会停在使用框架的基础上，如果能够自己亲手去了解其中的工作原理，手动去实现一下，也许能够对其有更深刻的理解，这也能够为后续自己去更好的优化一个神经网络提供基础。

本文将介绍一个两层神经网络的搭建过程，并且以手写体数字集Mnist对所搭建的神经网络进行训练。

神经网络的训练过程

训练过程.png
训练过程2.png

神经网络的学习按照上面4个步骤进行。这个方法通过梯度下降法更新参数，不过因为这里使用的数据是随机选择的mini batch数据，所以又称为随机梯度下降法（ stochastic gradient descent）---SGD。“随机”指的是“随机选择的”的意思，因此，随机梯度下降法是“对随机选择的数据进行的梯度下降法”。深度学习的很多框架中，随机梯度下降法一般由一个名为SGD的函数来实现。SGD来源于随机梯度下降法的英文名称的首字母。

构建辅助函数

首先我们先将之前文章中的损失函数、激活函数以及梯度计算的代码给弄过来，用于辅助神经网络的构建。如果对于这几个函数不太清楚可以点击相应链接，看之前写过的文章。

def sigmoid(x):
    # sigmoid激活函数
    return 1 / (1 + np.exp(-x))

def sigmoid_grad(x):
    # 计算sigmoid激活函数的梯度
    return (1.0 - sigmoid(x)) * sigmoid(x)

def softmax(x):
    # softmax激活函数,用于输出层
    if x.ndim == 2:
        x = x.T
        x = x - np.max(x, axis=0)
        y = np.exp(x) / np.sum(np.exp(x), axis=0)
        return y.T

    x = x - np.max(x) # 溢出对策
    return np.exp(x) / np.sum(np.exp(x))

def cross_entropy_error(y, t):
    # 损失函数使用交叉熵函数
    if y.ndim == 1:
        t = t.reshape(1, t.size)
        y = y.reshape(1, y.size)

    # 监督数据是one-hot-vector的情况下，转换为正确解标签的索引
    if t.size == y.size:
        t = t.argmax(axis=1)

    batch_size = y.shape[0]
    return -np.sum(np.log(y[np.arange(batch_size), t] + 1e-7)) / batch_size


def numerical_gradient(f, x):
    # 计算损失函数f的参数x的梯度
    h = 1e-4  # 0.0001
    grad = np.zeros_like(x)

    it = np.nditer(x, flags=['multi_index'], op_flags=['readwrite'])
    while not it.finished:
        idx = it.multi_index
        tmp_val = x[idx]
        x[idx] = float(tmp_val) + h
        fxh1 = f(x)  # f(x+h)

        x[idx] = tmp_val - h
        fxh2 = f(x)  # f(x-h)
        grad[idx] = (fxh1 - fxh2) / (2 * h)

        x[idx] = tmp_val  # 还原值
        it.iternext()
    return grad

二层神经网络的搭建

class TwoLayerNet:

    def __init__(self, input_size, hidden_size, output_size, weight_init_std=0.01):
        # 初始化权重
        self.params = {}
        # 先用高斯分布进行权重参数的初始化,然后对其进行训练
        self.params['W1'] = weight_init_std * np.random.randn(input_size, hidden_size)
        self.params['b1'] = np.zeros(hidden_size)
        self.params['W2'] = weight_init_std * np.random.randn(hidden_size, output_size)
        self.params['b2'] = np.zeros(output_size)

    def predict(self, x):
        # 对输入x进行预测,并输出预测值y
        W1, W2 = self.params['W1'], self.params['W2']
        b1, b2 = self.params['b1'], self.params['b2']
    
        a1 = np.dot(x, W1) + b1
        z1 = sigmoid(a1)
        a2 = np.dot(z1, W2) + b2
        y = softmax(a2)
        
        return y
        
    # x:输入数据, t:监督数据
    def loss(self, x, t):
        y = self.predict(x)
        # 使用交叉熵误差作为目标损失函数
        return cross_entropy_error(y, t)
    
    def accuracy(self, x, t):
        y = self.predict(x)
        y = np.argmax(y, axis=1)
        t = np.argmax(t, axis=1)
        
        accuracy = np.sum(y == t) / float(x.shape[0])
        return accuracy
        
    # x:输入数据, t:监督数据
    def numerical_gradient(self, x, t):
        # 使用数值微分来计算梯度
        # loss_W为损失函数
        loss_W = lambda W: self.loss(x, t)
        
        grads = {}
        # 计算各个参数的梯度
        grads['W1'] = numerical_gradient(loss_W, self.params['W1'])
        grads['b1'] = numerical_gradient(loss_W, self.params['b1'])
        grads['W2'] = numerical_gradient(loss_W, self.params['W2'])
        grads['b2'] = numerical_gradient(loss_W, self.params['b2'])

        return grads
        
    def gradient(self, x, t):
        # 使用误差的反向传播来计算梯度
        W1, W2 = self.params['W1'], self.params['W2']
        b1, b2 = self.params['b1'], self.params['b2']
        grads = {}
        
        batch_num = x.shape[0]
        
        # forward
        a1 = np.dot(x, W1) + b1
        z1 = sigmoid(a1)
        a2 = np.dot(z1, W2) + b2
        y = softmax(a2)
        
        # backward
        dy = (y - t) / batch_num
        grads['W2'] = np.dot(z1.T, dy)
        grads['b2'] = np.sum(dy, axis=0)
        
        da1 = np.dot(dy, W2.T)
        dz1 = sigmoid_grad(a1) * da1
        grads['W1'] = np.dot(x.T, dz1)
        grads['b1'] = np.sum(dz1, axis=0)

        return grads

各个参数说明如下：

参数说明1.png
参数说明2.png
该代码中包含两种参数梯度的计算方式numerical_gradient与gradient，其中numerical_gradient是使用的之前文章讲过的数值微分的方式计算参数梯度值的，而gradient则是使用的误差的反向传播来计算梯度值的，这种计算方式比微分方式计算梯度值更加快速。因此，在使用神经网络梯度计算通常会使用误差的反向传播来计算梯度。这个后续文章会进行详细讲解。

神经网络的训练

以上两层的神将网络已经搭建好了，下面我们以经典的手写体数字识别mnist数字集，使用上述神经网络进行训练，过程如下：

# 读入数据
(x_train, t_train), (x_test, t_test) = load_mnist(normalize=True, one_hot_label=True)
x_train = x_train[:5000] #仅选择前5000个数据进行训练测试
x_test = x_test[:5000]


train_loss_list = [] # 记录误差的变化情况
# 超参数
iters_num = 6000  # 设定迭代的次数
train_size = x_train.shape[0]
batch_size = 100 # 每一批取100个样本
learning_rate = 0.1

# 设置输入层784， 隐藏层50，层50
network = TwoLayerNet(input_size=784, hidden_size=50, output_size=10)

iter_per_epoch = max(train_size / batch_size, 1)

for i in range(iters_num):
    # 获取mini-batch
    batch_mask = np.random.choice(train_size, batch_size)
    x_batch = x_train[batch_mask]
    t_batch = t_train[batch_mask]

    # 计算梯度
    #数值方式计算梯度
    # grad = network.net_numerical_gradient(x_batch, t_batch) 
    # 误差的反向传播方式计算梯度
    grad = network.gradient(x_batch, t_batch)

    # 通过梯度更新每组参数
    for key in ('W1', 'b1', 'W2', 'b2'):
        network.params[key] -= learning_rate * grad[key]

    # 记录学习过程
    loss = network.loss(x_batch, t_batch)
    train_loss_list.append(loss)

    if i % iter_per_epoch == 0:
        print("train loss," + str(loss))

# 将每一步训练的结果得到的损失函数值打印出来
x = np.arange(len(train_loss_list))
plt.plot(x, train_loss_list, label='train loss')
plt.xlabel("iteration")
plt.ylabel("loss")
plt.show()

上述得到损失函数值随训练的推移如下：

损失函数的结果.png
由上图可以发现随着学习的进行，损失函数的值在不断减小。说明神经网络的权重参数在逐渐拟合数据，并逐渐向最优参数靠近。
然后使用训练得到的神经网络，即可对未知的数据集进行预测。下一篇文章会介绍对神经网络的评估过程。
如果喜欢本文，欢迎点赞 并 关注作者，后续将会不断更新干货文章，以供大家共同学习交流，谢谢！