吴恩达机器学习课程-作业4-神经网络训练（python实现）

Machine Learning(Andrew) ex4-Neural Networks Learning

椰汁笔记

Neural Networks

• 1.1 Visualizing the data
• 1.2 Model representation

由于本次作业的数据和网络结构和上次的作业相同，因此这两步已经在上次作业中完成，这里不再赘述。

• 1.3 Feedforward and cost function

当前网络的前向传播计算方法
$$\begin{gathered} a^{(1)}=x \\ 向a^{(1)}添加偏执单元a_0^{(1)}=1 \\ {z}^{(2)}={\Theta }^{(1)}{a}^{(1)} \\ {a}^{(2)}=g(z^{(2)}) \\ 向a^{(2)}添加偏执单元a_0^{(2)}=1 \\ {z}^{(3)}={\Theta }^{(2)}{a}^{(2)} \\ {a}^{(3)}=g(z^{(3)})=h_{\theta }(x) \end{gathered}$$
最后利用输出层计算cost
$$J(\theta )=\frac{1}{m}\sum _{i=1}^m\sum _{k=1}^K[-y_k^{(i)}log((h_{\theta }(x^{(i)}){)}_k)-(1-y_k^{(i)})log(1-(h_{\theta }(x^{(i)}){)}_k)]$$

这里的y需要注意代表的意义

数字	1	2	3	4	5	6	7	8	9	0
对应的向量下标	0	1	2	3	4	5	6	7	8	9

    a1 = X  # (5000,400)
    a1 = np.insert(a1, 0, 1, axis=1)  # (5000,401)
    z2 = a1.dot(theta1.T)  # (5000,25)
    a2 = sigmoid(z2)  # (5000,25)
    a2 = np.insert(a2, 0, 1, axis=1)  # (5000,26)
    z3 = a2.dot(theta2.T)  # (5000,10)
    a3 = sigmoid(z3)  # (5000,10)
    cost = np.mean(np.sum((-y) * np.log(a3) - (1 - y) * np.log(1 - a3), axis=1))
    print(cost)#0.2876291651613189

在封装装成函数时，发现这个其实可以写成一个循环去处理每层。
在传入theta时需要考虑到后面使用高级的优化方法时theta只能是一维向量，所有我们需要在传入多个theta时先展开成一个向量，在内部再恢复

def serialize(thetas):
    """
    将多个参数多维数组，映射到一个向量上
    :param thetas: tuple or list,按顺序存储每层的theta参数，每个为ndarray
    :return: ndarray，一维化的参数向量
    """
    res = np.array([0])
    for t in thetas:
        res = np.concatenate((res, t.ravel()), axis=0)
    return res[1:]


def deserialize(theta):
    """
    将向量还原为多个参数(只适用当前网络)
    :param theta: ndarray,一维化的参数向量
    :return: tuple ,按顺序存储每层的theta参数，每个为ndarray
    """
    return theta[:25 * 401].reshape(25, 401), theta[25 * 401:].reshape(10, 26)

直接使用循环进行计算，每层计算的操作都是先添加偏置单元，再计算z，再计算A。

def not_regularized_cost(thetas, X, y):
    """
    计算非正则化的损失值
    :param theta: ndarray，一维参数向量
    :param X: ndarray,输入层的输入值
    :param y: ndarray,数据的标记
    :return: float,损失值
    """
    for t in deserialize(thetas):
        X = np.insert(X, 0, 1, axis=1)
        X = X.dot(t.T)
        X = sigmoid(X)
    return np.mean(np.sum((-y) * np.log(X) - (1 - y) * np.log(1 - X), axis=1))

从逻辑回归那里我们知道，由于特征太多，可能会出现过拟合的现象，需要正则化来解决
$$\begin{gathered} J(\theta )=\frac{1}{m}\sum _{i=1}^m\sum _{k=1}^K[-y_k^{(i)}log((h_{\theta }(x^{(i)}){)}_k)-(1-y_k^{(i)})log(1-(h_{\theta }(x^{(i)}){)}_k)] \\ +\frac{\lambda }{2m}[\sum _{j=0}^{25}\sum _{k=1}^{400}({\Theta }_{j,k}^{(1)}{)}^2+\sum _{j=0}^{25}\sum _{k=1}^{400}({\Theta }_{j,k}^{(2)}{)}^2] \end{gathered}$$
直接在之前的损失函数计算中，加入惩罚项即可。注意不要惩罚偏执单元。

def regularized_cost(theta, X, y, l):
    """
    计算正则化的损失值
    :param theta: ndarray，一维参数向量
    :param X: ndarray,输入层的输入值
    :param y: ndarray,数据的标记
    :param l: float,惩罚参数
    :return: float,损失值
    """
    m = X.shape[0]
    part2 = 0.0
    for t in deserialize(theta):
        X = np.insert(X, 0, 1, axis=1)
        X = X.dot(t.T)
        X = sigmoid(X)
        t = t[..., 1:]  # 要去掉bias unit
        part2 += (l / (2 * m)) * np.sum(t * t)
    part1 = np.mean(np.sum((-y) * np.log(X) - (1 - y) * np.log(1 - X), axis=1))
    return part1 + part2

print(regularized_cost(theta, X, y, 1))#0.38376985909092365

---

Backpropagation

反向传播算法为梯度下降的计算提供了一个方法。这里我们先不考虑起原理，直接动手实现。
反向传播算法，细节举例（这里以课程中的4层网络举例）
$$\begin{gathered} 引入{\delta }_j^{(l)}，表示第l层的单元j的“损失” \\ {\delta }^{(4)}=a^{(4)}-y \\ {\delta }^{(3)}=({\Theta }^{(3)}{)}^T{\delta }^{(4)}\cdot g^{\prime }(z^{(3)}) \\ {\delta }^{(2)}=({\Theta }^{(2)}{)}^T{\delta }^{(3)}\cdot g^{\prime }(z^{(2)}) \end{gathered}$$
这里没有d1要注意！！！
完整的反向传播算法
$$\begin{gathered} 训练集\{(x^{(1)},y^{(1)}),(x^{(2)},y^{(2)}),\dots ,(x^{(m)},y^{(m)})\} \\ 令{\Delta }_{ij}^{(l)}=0(foralli,j) \\ Fori=1tom: \\ 令a^{(1)}=x^{(i)} \\ 使用前向传播算法计算出所有a^{(l)} \\ 计算所有{\delta }^{(l)} \\ 计算{\Delta }_{ij}^{(l)}={\Delta }_{ij}^{(l)}+a_j^{(l)}{\delta }_i^{(l+1)},({\Delta }^{(l)}={\Delta }^{(l)}+{\delta }^{(l+1)}(a^{(l)}{)}^T) \\ {D}_{ij}^{(l)}=\frac{1}{m}{\Delta }_{ij}^{(l)}+\lambda {\Theta }_{ij}^{(l)},(ifj\ne 0) \\ {D}_{ij}^{(l)}=\frac{1}{m}{\Delta }_{ij}^{(l)},(ifj=0) \\ \frac{\partial J(\Theta )}{\partial {\theta }_{ij}^{(l)}}=D_{ij}^{(l)} \end{gathered}$$

• 2.1 Sigmoid gradient

在计算d时需要用到sigmoid函数的导数，这里很简单可以自己推到一下，这里我们实现
$$g^{\prime }(z)=\frac{d}{dz}g(z)=g(z)(1-g(z))$$

def sigmoid_gradient(z):
    return sigmoid(z) * (1 - sigmoid(z))
print(sigmoid_gradient(0))#0.25

• 2.2 Random initialization

神经网络的参数初始化是非常讲究的，不能像以前一样全部初始化为0，这样会导致所有隐藏单元计算的值相同高度冗余，这里选择将参数随机化到一个[-e,e]的范围内，这里的e选择方法
$$e=\frac{\sqrt{6}}{\sqrt{L_{in}+L_{out}}}$$

def random_initialize_weights(shape, e=0.12):
    """
    随机初始化参数，范围为[-e, e]
    :param shape: tuple or list，需要初始化的参数的规格
    :param e: float,边界
    :return: ndarray,参数矩阵
    """
    return (np.random.rand(shape[0], shape[1]) - 0.5) * 2 * e

• 2.3 Backpropagation

直接按照反向传播算法做就好

def back(theta, X, y, l):
    """
    反向传播算法
    :param theta: ndarray，一维参数向量
    :param X: ndarray,输入层的输入值
    :param y: ndarray,数据的标签
    :param l: float,惩罚参数
    :return: ndarray，下降后一维参数向量
    """
    A, Z = feedforward(theta, X)
    a1, a2, a3 = A  # a1(5000,401), a2(5000,26), a3(5000,10)
    z2, z3 = Z  # z2(5000,25), z3(5000,10)
    theta1, theta2 = deserialize(theta)  # theta1(25,401), theta2(10,26)
    m = X.shape[0]

    d3 = a3 - y  # d3(5000,10)
    d2 = d3.dot(theta2)[..., 1:] * sigmoid_gradient(z2)  # d2(5000,25)

    theta1 = np.insert(np.delete(theta1, 0, axis=1), 0, 0, axis=1)
    theta2 = np.insert(np.delete(theta2, 0, axis=1), 0, 0, axis=1)
    D1 = (1 / m) * d2.T.dot(a1) + (l / m) * theta1  # D1(25,401)
    D2 = (1 / m) * d3.T.dot(a2) + (l / m) * theta2  # D2(10,26)
    return serialize((D1, D2))

• 2.4 Gradient checking
  为了方便检测我们的梯度下降算法是否正确，我们采用近似计算的方式来对比
  $$\begin{gathered} let{\theta }^{(i+)}=\theta +\left[\begin{array}{c}0\\ \\ 0\\ \\ ⋮\\ \\ ϵ\\ \\ ⋮\\ \\ 0\\ \end{array}\right],{\theta }^{(i-)}=\theta -\left[\begin{array}{c}0\\ \\ 0\\ \\ ⋮\\ \\ ϵ\\ \\ ⋮\\ \\ 0\\ \end{array}\right] \\ {f}_i(\theta )\approx \frac{J({\theta }^{(i+)})-J({\theta }^{(i-)})}{2ϵ} \end{gathered}$$

def gradient_checking(theta, X, y, l, e=10 ** -4):
    """
    检测反向传播算法是否正确运行
    :param theta: ndarray，一维参数向量
    :param X: ndarray,输入层的输入值
    :param y: ndarray,数据的标签
    :param l: float,惩罚参数
    :param e: float，微小扰动
    :return: ndarray，下降后一维参数向量
    """
    res = np.zeros(theta.shape)
    for i in range(len(theta)):
        left = np.array(theta)
        left[i] -= e
        right = np.array(theta)
        right[i] += e
        gradient = (regularized_cost(right, X, y, l) - regularized_cost(left, X, y, l)) / (2 * e)
        res[i] = gradient
    return res

这个计算是非常耗时的，应用到一部分计算中对比结果，检测反向传播算法是否正确。之后要拿出。

• 2.5 Regularized Neural Networks

在上面我就一并做了正则化

• 2.6 Learning parameters using fmincg

下面开始训练我们的模型，这里建议训练完后将参数保存一下，因为训练时间还是比较久，免得后面重跑。

    # 以上是为了测试写得是否正确，所以按照提供数据更改了y，下面我们将使用最自然的y表示方式
    y = convert(data['y'])
    theta1 = random_initialize_weights((25, 401))
    theta2 = random_initialize_weights((10, 26))
    theta = serialize((theta1, theta2))
    # 参数初始化得不同，有时会导致溢出
    res = opt.minimize(fun=regularized_cost, x0=theta, args=(X, y, 1), method="TNC", jac=back)
    print(res)
    theta1, theta2 = deserialize(res.x)
    sio.savemat("parametersWeights.mat", {"theta1": theta1, "theta2": theta2})

接着评价一下结果

def predict(theta, X):
    a3 = feedforward(theta, X)[0][-1]
    p = np.zeros((1, 10))
    for i in a3:
        index = np.argmax(i)
        temp = np.zeros((1, 10))
        temp[0][index] = 1
        p = np.concatenate((p, temp), axis=0)
    return p[1:]
print(classification_report(y, predict(res.x, X)))
visualizing_the_hidden_layer(res.x, X)

可以看到，神经网络相较于逻辑回归拟合得更好，但是计算量确实大，我们这里只有一个隐藏层久需要计算数分钟，很难想象大型网络得计算需要多大得计算资源。当然我们这里得神经网络是最简单得全连接神经网络，参数确实多。神经网络还有其他带有非全连接得网络结构，这些结构会使参数量下降。

Visualizing the hidden layer

最后我么可以看看隐藏层输出得图像是个什么样子
注意在计算后显示要去掉偏执单元

def visualizing_the_hidden_layer(theta, X):
    """
    可视化显示隐藏层的输入和输出
    :param theta: ndarray，一维参数向量
    :param X: ndarray,输入层的输入值
    :return: None
    """
    A, _ = feedforward(theta, X)
    a1, a2, a3 = A
    # 要去掉bias unit
    input = a1[..., 1:][:25]
    output = a2[..., 1:][:25]
    input = mapping(input, 5)
    output = mapping(output, 5)
    plt.subplot(1, 2, 1)
    plt.axis('off')
    plt.imshow(input.T)
    plt.title("hidden layer input")

    plt.subplot(1, 2, 2)
    plt.axis('off')
    plt.imshow(output)
    plt.title("hidden layer output")
    plt.show()

只观察0得数据，可以看到，输出后得图像是存在一些相似。

总结一下简单的神经网络使用方法

• 1.选择一个网络结构
  • 将当前得特征数量作为输入层得单元数量
  • 将分类得类数作为输出单元数量
  • 当隐藏层大于1层时，通常所有隐藏层得单元数一样
• 2.训练网络
  • 随机初始化单元连接之间得权重
  • 实现前向传播
  • 实现计算损失值
  • 实现反向传播
  • 实现梯度下降
  • 最小化损失值
• 3.评价模型
  • 在训练网络前，需要将数据随机分为三部分，作为训练集、交叉验证集和测试集
  • 使用训练集训练网络
  • 交叉验证集用于，当需要从多个网络模型中择优时，利用交叉验证集计算误差，通过量化的方式选择，模型
  • 测试集用于最终评价模型

---

完整的代码会同步在我的github

欢迎指正错误