神经网络的学习 《深度学习 基于Python的理论与实现》第四章

---

layout: post
title: 深度学习入门 基于Python的理论实现
subtitle: 第四章 神经网络的学习
tags: [Machine learning, Reading]

---

第四章 神经网络的学习

上一章我们讲前向传播，主要说的数据的传递和计算，没有涉及到参数的训练和选择，本章的主题是神经网络的学习。为了使神经网络可以学习，引入了损失函数这个指标，学习的目的是以该损失函数为基准，找出使它的值最小的权重参数。

4.1 从数据中学习

神经网络的特征就是可以从数据中学习。所谓从数据中学习，指的就是可以由税局自动决定权重参数的值。

4.1.1 数据驱动

所谓数据驱动，强调了数据对机器学习的重要性。几乎所有的事情都和数据有关。以下列出三种解决问题的方法。

• 人面对问题时，研究问题，想出算法，最终解决问题。
• 从图中提取特征，再学习模式，最终解决问题。
• 直接学习数据，得到答案。

深度学习有时也被称为端到端机器学习（end-to-end machine learning）。

4.1.2 训练数据和测试数据

在机器学习中一般将数据集分为测试集和训练集。

4.2 损失函数

神经网络用来寻找最优权重参数的指标被称作损失函数。这个损失函数可以使用任意函数，但一半用均方误差和交叉熵误差等。

4.2.1 均方误差

用作损失函数的函数很多，其中最有名的是均方误差。(mean squared error MSE)，表达形式如下：

$$E=\frac{1}{2}\sum _k(y_k-t_k{)}^2$$

这里的$y_k$代表神经网络的输出，$t_k$代表监督数据，$k$代表维数。下来我们进行实现：

def mean_squared_error(y,t):
    return (np.sum((y-t)**2))*0.5

观察数学意义可以知道，MSE的大小直接反映了预测结果和真实值之间的差异。

4.2.2 交叉熵误差

$$E=-\sum _k{t}_{k}log{y}_k$$

公式里的$log$代表以$e$为底的自然对数($lo{g}_e$)。$y_k$是神经网络的输出，$t_k$是监督值，也就是标准值。$t_k$使用one-hot表示。

def cross_entropy_error(y,t):
    delta = 1e-7
    return - np.sum(t * np.log(y + delta))

因为np.log(0)会计算成负无穷，所以这里delta的作用是为了应对这个情况。

4.2.3 mini-batch学习

上一章我们讲了批处理，对应实际中使用的批处理，损失函数的写法也要做相应改变。之前介绍的损失函数考虑的都是单个数据的损失函数，如果要求所有的训练数据的损失函数的总和，以交叉熵为例，可以写成如下的形式：

$$E=-\frac{1}{N}\sum _n\sum _k{t}_{nk}log{y}_{nk}$$

这里假设有$N$个数据，$t_{n}k$代表第$n$个数据的第$k$个元素的值。另外，MNIST有60000个数据，假设以全部数据为对象求损失函数的和，计算过程需要花费较长的时间。实际中的数据集比这个量更大，因此，我们从全部数据中选出一批数据，然后对每个mini-batch进行学习。这种方式叫做mini-batch学习。

之前我们已经有了读取数据集的代码，接下来我们要从中随机选取10个数据。随机选取可以使用np.random.choice()。

import sys,os
import numpy as np

sys.path.append(os.pardir)
from dataset.mnist import load_mnist

(x_train, t_train),(x_test, t_test) = load_mnist(flatten=True, normalize=True)


train_size = x_train.shape[0]
batch_size = 10
batch_mask = np.random.choice(train_size,batch_size)

x_batch = x_train[batch_mask]
t_batch = t_train[batch_mask]

4.2.4 mini-batch 版交叉熵误差的实现

def cross_entropy_error(y,t):
    if y.ndim == 1:
        t = t.reshape(1, t.size)
        y = y.reshape(1, y.size)

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

对于非one-hot标签，可以用下面的形式：

def cross_entropy_error(y,t):
    if y.ndim == 1:
        t = t.reshape(1, t.size)
        y = y.reshape(1, y.size)

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

4.2.5 为何要设定损失函数

原因主要有以下几点：

• 不能关注某一个特定的参数
• 不能以识别精度为指标
• 识别精度对微小的参数变化不敏感

4.3 数值微分

4.3.1 导数

4.3.2 数值微分的例子

下面的例子是一个求数值微分的例子。使用的中心差分。求的是$f(x)=0.01x^2+0.1x$在$f(x+h)$到$f(x-h)$之间的差分。

def function_x(x):
    return 0.01*x**2 + 0.1*x

import numpy as np
import matplotlib.pyplot as plt

x = np.arange(0.0,20.0,0.1)
y = function_x(x)

plt.plot(x,y)
plt.show()

def numerical_diff(f,x):
    h = 1e-4
    return (f(x+h) - f(x-h))/(2*h)

print(numerical_diff(function_x,5))

print(numerical_diff(function_x,10))

4.3.3 偏导数

这里以一个函数为例：

$$f(x_0,x_1)=x_0^2+x_1^2$$

因为这里有两个变量，所以求偏导数时，固定一个值，对另一个变量求导数。

4.4 梯度

学习了导数和偏导数，那么什么是梯度呢。形如
$$（\frac{\partial f}{\partial x_0},\frac{\partial f}{\partial x_1}）$$
的由全部变量的偏导数汇总而成形成的向量被称为梯度。

下面实际看一个例子：

def function_2(x):
    return x[0]**2 + x[1]**2

def numerical_gradient(f,x):
    h = 1e-4
    grad = np.zeros(x.size)

    for idx in range(x.size):
        tmp_val = x[idx]
        x[idx] = tmp_val + h
        fxh1 = f(x)

        x[idx] = tmp_val - h
        fxh2 = f(x)

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

    return grad


print(numerical_gradient(function_2,np.array([3.0,4.0])))

这里提供一个梯度的可视化方法。使用了matplotlib中的quiver函数。quiver函数使用方法很简单，前面四个参数分别代表了箭头起点，XY，也就是每一个点的梯度位置，后两个参数就是计算出的梯度，代表箭头在两个方向上的矢量。

x0 = np.arange(-2, 2.5, 0.25)
x1 = np.arange(-2, 2.5, 0.25)
X, Y = np.meshgrid(x0, x1)

X = X.flatten()
Y = Y.flatten()

grad = numerical_gradient(function_2, np.array([X, Y]) )

plt.figure()
plt.quiver(X, Y, -grad[0], -grad[1],  angles="xy",color="#666666")#,headwidth=10,scale=40,color="#444444")
plt.xlim([-2, 2])
plt.ylim([-2, 2])
plt.xlabel('x0')
plt.ylabel('x1')
plt.grid()
plt.legend()
plt.draw()
plt.show()

4.4.1 梯度法

讲解了梯度的意义，现在要讲的是具体的使用，也就是梯度法对于寻找最优参数的意义。这里的最优参数就是损失函数取最小值时的参数。

但是这个最小值通常是很难找的，因为函数通常比较复杂，并且可能找到的仅仅是局部最优解，但是不可否认的是，梯度的下降方向是可以使损失函数减小的方向。

简而言之，梯度法就是通过不断的沿着梯度方向前进，逐渐减小损失函数的值的过程就叫做梯度法。寻找最小值的方法乘坐梯度下降法，反之，则称为梯度上升法。

接下来用数学方式表示梯度法。

$$x_0=x_0-\eta \frac{\partial f}{\partial x_0}$$

$$x_1=x_0-\eta \frac{\partial f}{\partial x_1}$$

在上面的式子里，$\eta$称为学习率（learning rate）。这个类似于步长的概念。学习率需要事先确定，过大或者过小都不利于找到好的位置。

接下来实现一下梯度下降法。

def gradient_decent(f,init_x,lr=0.01,step_num=100):
    x = init_x

    for i in range(step_num):
        grad = numerical_gradient(f,x)
        x = x - lr*grad

    return x

拥有了所有的工具，接下来尝试解决问题。

问题：用梯度法求解$f(x_0,x_1)=x_0^2+x_1^2$的最小值。

思路：使用梯度下降，指定一个初始值，学习率和步长即可。下面是代码和图示。

# coding: utf-8
import numpy as np
import matplotlib.pylab as plt


def numerical_gradient(f, X):
    if X.ndim == 1:
        return _numerical_gradient_no_batch(f, X)
    else:
        grad = np.zeros_like(X)

        for idx, x in enumerate(X):
            grad[idx] = _numerical_gradient_no_batch(f, x)

        return grad

def gradient_descent(f, init_x, lr=0.01, step_num=100):
    x = init_x
    x_history = []

    for i in range(step_num):
        x_history.append( x.copy() )

        grad = numerical_gradient(f, x)
        x -= lr * grad

    return x, np.array(x_history)


def function_2(x):
    return x[0]**2 + x[1]**2

init_x = np.array([-3.0, 4.0])

lr = 0.1
step_num = 20
x, x_history = gradient_descent(function_2, init_x, lr=lr, step_num=step_num)

plt.plot( [-5, 5], [0,0], '--b')
plt.plot( [0,0], [-5, 5], '--b')
plt.plot(x_history[:,0], x_history[:,1], 'o')

plt.xlim(-3.5, 3.5)
plt.ylim(-4.5, 4.5)
plt.xlabel("X0")
plt.ylabel("X1")
plt.savefig('gradient_decent_visualization.png')
plt.show()

像学习率这样的参数，取大取小都不好，他和诸如权重和偏置这样通过神经网络学习获得的参数不同，它需要人为进行设定，这一类参数通常被称为超参数。

4.4.2 神经网络的梯度

神经网络的学习过程也需要求梯度，这里的损失函数就是基于权重参数的梯度。如有一个形状为$2\times 3$的权重为$W$的神经网络,损失函数用$L$表示，此时梯度可以用 $\frac{\partial L}{\partial W}$ 表示。

$$W=\left(\begin{array}{ccc}{\omega }_{11}& {\omega }_{12}& {\omega }_{13}\\ {\omega }_{21}& {\omega }_{22}& {\omega }_{23}\end{array}\right)$$

$$\frac{\partial L}{\partial W}=\left(\begin{array}{ccc}\frac{\partial L}{\partial {\omega }_{11}}& \frac{\partial L}{\partial {\omega }_{12}}& \frac{\partial L}{\partial {\omega }_{13}}\\ \frac{\partial L}{\partial {\omega }_{21}}& \frac{\partial L}{\partial {\omega }_{22}}& \frac{\partial L}{\partial {\omega }_{23}}\end{array}\right)$$

$\frac{\partial L}{\partial W}$ 的元素是关于$W$的偏导数，例如第一行第一列的元素 $\frac{\partial L}{\partial {\omega }_{11}}$ 表示当 ${\omega }_{11}$ 稍微变化时，损失函数$L$会发生多大变化。接下来看每一个简单神经网络求梯度的例子：

import numpy as np


def softmax(x):
    exp_a = np.exp(x-np.max(x))
    sum_exp_a = np.sum(exp_a)

    return exp_a/sum_exp_a

def cross_entropy_error(y,t):
    delta = 1e-7
    return -np.sum(t*np.log(y + delta))

class SimpleNet:
    def __init__(self):
        self.W = np.random.randn(2,3)

    def predict(self,x):
        return np.dot(x,self.W)

    def loss(self,x,t):
        z = self.predict(x)
        y = softmax(z)
        loss = cross_entropy_error(y,t)

        return loss

net = SimpleNet()

x = np.array([0.6,0.9])

p = net.predict(x)

print(p)

print(np.argmax(p))

t = np.array([1,0,0])

loss = net.loss(x,t)

print(loss)

上面构建了简单的神经网络，使用交叉熵作为损失函数。求得了误差之后，接下来使用梯度下降，更新参数后看误差的变化。

4.5 学习算法的实现

截至目前，神经网络学习的所有基础知识已经全部讲解完毕。接下来确认一下神经网络的学习步骤。

前提

神经网络存在合适的权重的偏置，调整权重和偏置的过程称为学习。

步骤1(mini-batch)
从训练数据中选取一部分数据，使用这部分数据来减小损失函数的值。

步骤2（计算梯度）

为了减小损失函数的值，需要求出各个权重参数的梯度。梯度表示损失函数的值减小最多的方向。

步骤3（更新参数）
将权重参数做微小的更新。

步骤4（重复）

重复上面的步骤

神经网络的学习按照上面的步骤进行，这里的数据是随机选择的mini batch数据，所以称为随机梯度下降法（stochastic gradient descent）。因此随机梯度下降法也叫做“对随机选择的数据进行的梯度下降法”，在很多框架中，随机梯度下降法一般由一个名为SGD的函数实现。

下面以手写数字识别为例做实现。

4.5.1 2层神经网络的类

我们将这个类命名为TwoLayerNet的类。这个类用于构建我们所用的神经网络，使用这个类可以根据需要创建。

def sigmoid(x):
    return 1/(1+np.exp(-x))


def softmax(x):
    exp_x = np.exp(x-np.max(x))
    sum_exp_x = np.sum(exp_x)

    return exp_x/sum_exp_x

def cross_entropy_error(y,t):
  delta = 1e-7

  return -np.sum(t * np.log/(y + delta))



class TwoLayerNet:
    def __init__(self,input_size,hidden_size,output_size):
        self.params = {}
        self.params['W1'] = np.random.randn(input_size,hidden_size)
        self.params['b1'] = np.zeros(hidden_size)
        self.params['W2'] = np.random.randn(hidden_size,output_size)
        self.params['b2'] = np.zeros(output_size)

    def predict(self, x):
        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

    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

    def numerical_gradient(self, x, t):
        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['W1'])
        grads['b2'] = numerical_gradient(loss_W, self.params['b2'])

        return grads

这个类的实现稍稍有点长，但是并没有什么新鲜的内容。TwoLayerNet类有params和grads两个字典实例变量，在实现的时候，调用了构造函数，init(self,input_size,hidden_size,output_size)第一个参数代表输入层神经元个数，第二个参数代表隐藏层的神经元个数，第三个参数代表输出层神经元个数，在这里，输入层的神经元个数为 $28\times 28=784$，输出为10个类别，隐藏层设置一个合适的参数即可。
在后面将会详细讨论参数初始化问题，这里我们使用符合高斯分布的随机数进行初始化，偏置使用0进行初始化。predict(self, x)和 accuracy(self, x, t)的实现和上一章的神经网络的推理处理基本一样。如 果仍有不明白的地方，请再回顾一下上一章的内容。另外，loss(self, x, t)是计算损失函数值的方法。这个方法会基于predict()的结果和正确解标签，计算交叉熵误差。剩下的numerical_gradient(self, x, t)方法会计算各个参数的梯度。根 据数值微分，计算各个参数相对于损失函数的梯度。另外，gradient(self, x, t) 是下一章要实现的方法，该方法使用误差反向传播法高效地计算梯度。

4.5.2 mini-batch的实现

神经网络的学习使用的是前面介绍过的mini batch学习，所谓mini batch学习指的是从训练数据中随机选取一部分数据，再使用这些数据用梯度法更新参数。

import numpy as np
from mnist import load_mnist

def numerical_gradient(f, X):
  if X.ndim == 1:
      return _numerical_gradient_no_batch(f, X)
  else:
      grad = np.zeros_like(X)

      for idx, x in enumerate(X):
          grad[idx] = _numerical_gradient_no_batch(f, x)

  return grad

def cross_entropy_error(y,t):
  delta = 1e-7
  return -np.sum(t*np.log(y + delta))

def _numerical_gradient_no_batch(f, x):
  h = 1e-4 # 0.0001
  grad = np.zeros_like(x)

  for idx in range(x.size):
      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 # 还原值

  return grad


(x_train,t_train),(x_test,t_test) = load_mnist(normalize=True,one_hot_label=True)

train_loss_list = []

#超参数

iters_num = 10000
train_size = x_train.shape[0]
batch_size = 100
learning_rate = 0.1


network = TwoLayerNet(input_size=x_train.shape[1],hidden_size=50,output_size=10)

for i in range(iters_num):
  print(i)
  batch_mask = np.random.choice(train_size,batch_size)
  x_batch = x_train[batch_mask]
  t_batch = t_train[batch_mask]

  grad = network.numerical_gradient(x_batch,t_batch)


  for key in ('W1','b1','W2','b2'):
      print(key)
      network.params[key] -= learning_rate * grad[key]

      loss = network(x_batch,t_batch)
      train_loss_list.append(loss)
      print(loss)

这样的计算是十分缓慢的。以至于，在计算的时候。完成整个循环需要很久很久。

4.5.3 基于测试数据的评价

从上面的代码，可以看出，使用梯度下降法，实现了损失函数减小。
在神经网络的学习中，必须首先确认是否发生过拟合，即能否识别除训练数据以外的数据。接下来要确认的是神经网络是否掌握泛化能力。

4.6 小结

本章介绍了神经网络的学习。首先，为了顺利进行神经网络的学习，我们导入损失函数这个指标。以这个损失函数为基准，找出使它的值达到最小的权重参数，这就是神经网络的学习目标。为了找到尽可能小的损失函数值，我们介绍了使用函数斜率的梯度法。

• 机器学习中使用的数据集分为训练数据和测试数据
• 神经网络用训练数据进行学习，并用测试数据评价学习到的模型的泛化能力。
• 神经网络的学习以损失函数为指标，更新权重参数，以使损失函数的值减小
• 利用某个给定的微小值的差分求倒数的过程，称为数值微分
• 利用数值微分，可以计算权重参数的梯度
• 数值为分虽然费时间，但是实现起来很简单。下一章中要实现的是复杂一些的误差反向传播法，可以高速的计算梯度。