深度学习入门（三）构建简单的两层神经网络

25天看完了吴恩达的机器学习以及《深度学习入门》和《tensorflow实战》两本书，吴恩达的学习课程只学了理论知识，另外两本书的代码自己敲了一遍，感觉过的太快，趁着跑cGAN的时间把两本书的知识点总结下，然后继续深度学习的课程。欢迎小伙伴一起学习~
另外，本文先把框架搭好，后续会一直补充细节和知识点。
最后，本文参考的书是《深度学习入门》斋藤康毅著，十分推荐初学者使用。

本文的代码地址

神经网络学习的全貌图

1. 从训练数据随机抽取一部分数据
2. 带入模型计算梯度
3. 根据梯度更新参数
4. 重复步骤1，2，3

两层神经网络实现

首先定义两层神经网络的类并初始化变量，类中包含了计算损失、准确率、梯度更新等函数。
这里保存参数使用的字典形式，构建的神经层使用的OrderDict，目的是保存神经层的顺序

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)
        #生成层
        self.layers = OrderedDict()
        self.layers['Affinel1'] = Affine(self.params['W1'], self.params['b1'])
        self.layers['Relu'] = Relu()
        self.layers['Affinel2'] = Affine(self.params['W2'], self.params['b2'])
        self.lastlayer = SoftmaxWithLoss()

定义了预测函数、计算损失和准确率，前面提到，我们把每一神经层模块化为一个类，类中主要包含了前向传播forward（）和反向传播backward（）
这里主要用到全连接层和relu层两个类，在文末给出代码

    def predict(self, x):
        for layer in self.layers.values(): #values需要有括号
            x = layer.forward(x)  # 调用forward计算前向传播结果
        return x

    def loss(self, x, t):
        y = self.predict(x)
        return self.lastlayer.forward(y, t)

    def accuracy(self, x, t):
        y = self.predict(x)
        y = np.argmax(y, axis=1)
        if t.ndim != 1:
            t = np.argmax(t, axis=1)
        accuracy = np.sum(y==t) / float(t.shape[0])
        return accuracy

接下来是根据损失来计算梯度，反向传播backward（）

 def gradient(self, x, t):
        # forward
        self.loss(x, t)
        # backward
        dout = 1
        dout = self.lastLayer.backward(dout)
        layers = list(self.layers.values())
        layers.reverse()
        for layer in layers:
            dout = layer.backward(dout)
        grads = {}
        grads['W1'], grads['b1'] = self.layers['Affine1'].dW, self.layers['Affine1'].db
        grads['W2'], grads['b2'] = self.layers['Affine2'].dW, self.layers['Affine2'].db
        return grads

最后，导入数据，定义训练

(x_train, t_train), (x_test, t_test) = load_mnist(normalize=True, one_hot_label=True) # 这里的load_mnist是导入数据的脚本

network = TwoLayerNet(input_size=784, hidden_size=50, output_size=10) # 定义模型

iters_num = 1000 # 迭代的最大数目
train_size = x_train.shape[0]  # 训练集的大小
batch_size = 100 # 每一个batch的大小
learning_rate = 0.1 #学习率

train_loss_list = []
train_acc_list = []
test_acc_list = []

iter_per_epoch = max(train_size / batch_size, 1) #一个epoch（纪元）的迭代次数

for i in range(iters_num):
    batch_mask = np.random.choice(train_size, batch_size) #随机抽取batch_size个数据的编号
    x_batch = x_train[batch_mask]
    t_batch = t_train[batch_mask]

    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: # 一个epoch后，计算训练集和测试集的准确率
        train_acc = network.accuracy(x_train, t_train)
        test_acc = network.accuracy(x_test, t_test)
        train_acc_list.append(train_acc)
        test_acc_list.append(test_acc)
        print(train_acc, test_acc)

至此，我们的简易的使用反向传播算法的两层神经网络搭建和训练就完成啦~