【深度学习】神经网络的建立与推理_神经网络的知识表示与推理

源代码文件请点击此处！

神经网络（neural network）的结构

• 输入层（input layer）：第 0 层（layer 0）
• 隐藏层（hidden layer）：第 1 层（layer 1）、第 2 层（layer 2）、······、第 $l-1$ 层（layer $l-1$）
• 输出层（output layer）：第 $l$ 层（layer $l$）

神经元中常用的激活函数（activation function）

• 线性激活函数（linear activation function）（用于线性回归）：输出可正可负，相当于没有使用激活函数，所以不能使用该函数作为激活函数！

$$g(z)=z$$

• ReLU（rectified linear unit）函数（用于线性回归）：输出为非负，常用于神经网络的隐藏层

g ( z ) = max ⁡ ( 0 , z ) = { 0 , z < 0 z , z ≥ 0 g(z) = \max (0, z) =

$$\begin{cases} 0, z < 0 \\ z, z \geq 0 \end{cases}$$ g(z)=max(0,z)={0,z<0z,z≥0​

• sigmoid 函数（用于二元分类/逻辑回归）：输出只能为正，常用于神经网络的输出层

$$g(z)=\frac{1}{1+e^{-z}}=P(\hat{y}=1|\vec{x})$$

• softmax 函数（用于多元分类）：常用于神经网络的输出层

$$g(z_i)=\frac{e^{z_i}}{{\sum }_{j=1}^N{e}^{z_j}}=P(\hat{y}=i|\vec{x})$$

• 改良的 softmax 函数：指数运算的结果容易过大而导致溢出，因此可进行如下改进：

g ( z i ) = e z i ∑ j = 1 N e z j = C e z i C ∑ j = 1 N e z j = e z i + ln ⁡ C ∑ j = 1 N e z j + ln ⁡ C = e z i + C ′ ∑ j = 1 N e z j + C ′

$$\begin{aligned} g(z_{i}) &= \frac{e^{z_i}}{\sum_{j=1}^{N}e^{z_j}} \\ &= \frac{Ce^{z_i}}{C\sum_{j=1}^{N}e^{z_j}} \\ &= \frac{e^{z_i + \ln C}}{\sum_{j=1}^{N}e^{z_j + \ln C}} \\ &= \frac{e^{z_i + C'}}{\sum_{j=1}^{N}e^{z_j + C'}} \\ \end{aligned}$$ g(zi​)​=∑j=1N​ezj​ezi​​=C∑j=1N​ezj​Cezi​​=∑j=1N​ezj​+lnCezi​+lnC​=∑j=1N​ezj​+C′ezi​+C′​​

为防止溢出，一般 $C^{\prime }$ 取输入信号的最大值。

神经网络的表示

继续以上图为例（设神经元的激活函数为 $g(z)$）：

• 输入层：$\vec{x}={\vec{a}}^{[0]}=(a_1^{[0]},a_2^{[0]})$
• 第 1 层：输入 ${\vec{a}}^{[0]}=(a_1^{[0]},a_2^{[0]})$，输出 ${\vec{a}}^{[1]}=(a_1^{[1]},a_2^{[1]},a_3^{[1]},a_4^{[1]})$
  • $a_1^{[1]}=g({\vec{w}}_1^{[1]}\cdot {\vec{a}}^{[0]}+b_1^{[1]})$
  • $a_2^{[1]}=g({\vec{w}}_2^{[1]}\cdot {\vec{a}}^{[0]}+b_2^{[1]})$
  • $a_3^{[1]}=g({\vec{w}}_3^{[1]}\cdot {\vec{a}}^{[0]}+b_3^{[1]})$
  • $a_4^{[1]}=g({\vec{w}}_4^{[1]}\cdot {\vec{a}}^{[0]}+b_4^{[1]})$
  • 矩阵形式：令 $W^{[1]}=({\vec{w}}_1^{[1]},{\vec{w}}_2^{[1]},{\vec{w}}_3^{[1]},{\vec{w}}_4^{[1]}{)}_{2\times 4}$，$B^{[1]}=(b_1^{[1]},b_2^{[1]},b_3^{[1]},b_4^{[1]}{)}_{1\times 4}$，则 ${\vec{a}}^{[1]}=g({\vec{a}}^{[0]}{W}^{[1]}+B^{[1]})$
• 第 2 层：输入 ${\vec{a}}^{[1]}=(a_1^{[1]},a_2^{[1]},a_3^{[1]},a_4^{[1]})$，输出 ${\vec{a}}^{[2]}=(a_1^{[2]},a_2^{[2]},a_3^{[2]},a_4^{[2]},a_5^{[2]})$
  • $a_1^{[2]}=g({\vec{w}}_1^{[2]}\cdot {\vec{a}}^{[1]}+b_1^{[2]})$
  • $a_2^{[2]}=g({\vec{w}}_2^{[2]}\cdot {\vec{a}}^{[1]}+b_2^{[2]})$
  • $a_3^{[2]}=g({\vec{w}}_3^{[2]}\cdot {\vec{a}}^{[1]}+b_3^{[2]})$
  • $a_4^{[2]}=g({\vec{w}}_4^{[2]}\cdot {\vec{a}}^{[1]}+b_4^{[2]})$
  • $a_5^{[2]}=g({\vec{w}}_5^{[2]}\cdot {\vec{a}}^{[1]}+b_5^{[2]})$
  • 矩阵形式：令 $W^{[2]}=({\vec{w}}_1^{[2]},{\vec{w}}_2^{[2]},{\vec{w}}_3^{[2]},{\vec{w}}_4^{[2]},{\vec{w}}_5^{[2]}{)}_{4\times 5}$，$B^{[2]}=(b_1^{[1]},b_2^{[1]},b_3^{[1]},b_4^{[1]},b_5^{[1]}{)}_{1\times 5}$，则 ${\vec{a}}^{[2]}=g({\vec{a}}^{[1]}{W}^{[2]}+B^{[2]})$
• 第 3 层：输入 ${\vec{a}}^{[2]}=(a_1^{[2]},a_2^{[2]},a_3^{[2]},a_4^{[2]},a_5^{[2]})$，输出 ${\vec{a}}^{[3]}=(a_1^{[3]},a_2^{[3]},a_3^{[3]})$
  • $a_1^{[3]}=g({\vec{w}}_1^{[3]}\cdot {\vec{a}}^{[2]}+b_1^{[3]})$
  • $a_2^{[3]}=g({\vec{w}}_2^{[3]}\cdot {\vec{a}}^{[2]}+b_2^{[3]})$
  • $a_3^{[3]}=g({\vec{w}}_3^{[3]}\cdot {\vec{a}}^{[2]}+b_3^{[3]})$
  • 矩阵形式：令 $W^{[3]}=({\vec{w}}_1^{[3]},{\vec{w}}_2^{[3]},{\vec{w}}_3^{[3]}{)}_{5\times 3}$，$B^{[3]}=(b_1^{[3]},b_2^{[3]},b_3^{[3]}{)}_{1\times 3}$，则 ${\vec{a}}^{[3]}=g({\vec{a}}^{[2]}{W}^{[3]}+B^{[3]})$
• 第 4 层：输入 ${\vec{a}}^{[3]}=(a_1^{[3]},a_2^{[3]},a_3^{[3]})$，输出 ${\vec{a}}^{[4]}=(a_1^{[4]})$
  • $a_1^{[4]}=g({\vec{w}}_1^{[4]}\cdot {\vec{a}}^{[3]}+b_1^{[4]})$
  • 矩阵形式：令 $W^{[4]}=({\vec{w}}_1^{[4]}{)}_{3\times 1}$，$B^{[4]}=(b_1^{[3]},{)}_{1\times 1}$，则 ${\vec{a}}^{[4]}=g({\vec{a}}^{[3]}{W}^{[4]}+B^{[4]})$
• 第 $l$ 层：输入 ${\vec{a}}^{[l-1]}=(...,a_j^{[l-1]},...)$，输出 ${\vec{a}}^{[l]}=(...,a_j^{[l]},...)$
  • $a_j^{[l]}=g({\vec{w}}_j^{[l]}\cdot {\vec{a}}^{[l-1]}+b_j^{[l]})$

神经网络的代码实现

以上图为例：

import numpy as np

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

# softmax 函数
def softmax_function(a):
    exp_a = np.exp(a)
    sum_exp_a = np.sum(exp_a)
    y = exp_a / sum_exp_a
    return y

# 改良的 softmax 函数（防止在指数运算时发生溢出）
def softmax_function_trick(a):
    c = np.max(a)
    exp_a = np.exp(a - c)
    sum_exp_a = np.sum(exp_a)
    y = exp_a / sum_exp_a
    return y

# ReLU 函数
def relu_function(x):
    return np.maximum(0, x)

# 线性激活函数（恒等函数）
def linear_activation_function(x):
    return x

# 初始化配置各个神经元的参数
def init_network():
    network = {} # 字典类型

    # 隐藏层第 1 层（layer 1）：一共 4 个神经元
    network['W1'] = np.array([[0.1, 0.2, 0.3, 0.4],
                              [0.5, 0.6, 0.7, 0.8]])
    network['B1'] = np.array([[0.1, 0.2, 0.3, 0.4]])

    # 隐藏层第 2 层（layer 2）：一共 5 个神经元
    network['W2'] = np.array([[0.1, 0.2, 0.3, 0.4, 0.5],
                              [0.6, 0.7, 0.8, 0.9, 1.0],
                              [0.1, 0.2, 0.3, 0.4, 0.5],
                              [0.6, 0.7, 0.8, 0.9, 1.0]])
    network['B2'] = np.array([[0.1, 0.2, 0.3, 0.4, 0.5]])

    # 隐藏层第 3 层（layer 3）：一共 3 个神经元
    network['W3'] = np.array([[0.1, 0.2, 0.3],
                              [0.4, 0.5, 0.6],
                              [0.7, 0.8, 0.9],
                              [0.6, 0.7, 0.8],
                              [0.1, 0.2, 0.3]])
    network['B3'] = np.array([[0.1, 0.2, 0.3]])

    # 隐藏层第 4 层（layer 4）：一共 1 个神经元
    network['W4'] = np.array([[0.1],
                              [0.2],
                              [0.3]])
    network['B4'] = np.array([[0.1]])

    return network

# 神经元的内部实现：输入A，权重W，偏置B，激活函数g()，输出A_out
def dense(A, W, B, g):
	Z = np.matmul(A, W) + B # 这里是矩阵乘法，而非点乘
	A_out = g(Z)
	return A_out

# 神经网络的搭建
def predict(network, X):
    W1, W2, W3, W4 = network['W1'], network['W2'], network['W3'], network['W4']
    B1, B2, B3, B4 = network['B1'], network['B2'], network['B3'], network['B4']

    A1 = dense(X, W1, B1, sigmoid_function) # layer 1
    A2 = dense(A1, W2, B2, sigmoid_function) # layer 2
    A3 = dense(A2, W3, B3, sigmoid_function) # layer 3
    A4 = dense(A3, W4, B4, linear_activation_function) # layer 4

    return A4

# 从这里开始执行
if __name__ == '__main__':
    network = init_network() # 配置神经网络的参数
    X = np.array([[1.0, 0.5]]) # 输入层（layer 0）
    Y = predict(network, X) # 输出层（layer 4）
    print(Y)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

使用已学习完毕的神经网络进行推理（inference）

• 测试集：源自 MNIST 数据集（研究手写数字识别的数据集），数据集的下载脚本位于代码仓库的 /dataset/mnist.py
• one-hot 表示：将正确解标签表示为 1，其他错误解标签表示为 0 的表示方法，例如：

# y: 图像数据经过神经网络计算后的输出结果，对应数字 0~9 的概率，即“0”的概率为 0.1，“2”的概率最高，为 0.6
y = [0.1, 0.05, 0.6, 0.0, 0.05, 0.1, 0.0, 0.1, 0.0, 0.0]
# t: 监督数据，将正确解标签表示为 1，其他错误解标签表示为 0，这里正确解对应数字“2”
t = [0, 0, 1, 0, 0, 0, 0, 0, 0, 0]
1
2
3
4

• 代码执行流程：

  • 第一次调用函数 load_mnist 时，会自动下载 MNIST 数据集并转换为字典类型的数据，并创建文件 mnist.pkl；以后再调用时，会直接读入该文件，节省时间
  • 调用函数 init_network，这里读入文件 sample_weight.pkl，内容为已学习好的神经网络参数（至于如何学习到这些参数会在下一篇介绍）
  • 对 MNIST 中的每个图像数据，调用函数 predict，用上述参数构建神经网络，对该图像进行推理（具体是对 0 到 9 依次给出一个概率，概率最高的数字 x 说明图像最有可能是数字 x）
  • 与正确解标签进行对比，统计正确分类的个数，并得出精度结果

• 代码实现：

# coding: utf-8

import sys, os
sys.path.append(os.pardir)  # 为了导入父目录的文件而进行的设定
import numpy as np
import pickle
from dataset.mnist import load_mnist

# ============================= activation functions ===================================

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

# softmax 函数
def softmax_function(a):
    exp_a = np.exp(a)
    sum_exp_a = np.sum(exp_a)
    y = exp_a / sum_exp_a
    return y

# 改良的 softmax 函数（防止在指数运算时发生溢出）
def softmax_function_trick(a):
    c = np.max(a)
    exp_a = np.exp(a - c)
    sum_exp_a = np.sum(exp_a)
    y = exp_a / sum_exp_a
    return y

# ReLU 函数
def relu_function(x):
    return np.maximum(0, x)

# 线性激活函数（恒等函数）
def linear_activation_function(x):
    return x

# ============================= neural network ===================================

# 神经元的内部实现：输入A，权重W，偏置B，激活函数g()，输出A_out
def dense(A, W, B, g):
	Z = np.matmul(A, W) + B # 这里是矩阵乘法，而非点乘
	A_out = g(Z)
	return A_out

# 初始化配置各个神经元的参数，可直接导入记录了神经网络参数的pickle文件
def init_network(filename):
    with open(filename, 'rb') as f:
        network = pickle.load(f)
    return network

# 神经网络的搭建
def predict(network, X):
    W1, W2, W3 = network['W1'], network['W2'], network['W3']
    B1, B2, B3 = network['b1'], network['b2'], network['b3']
    A1 = dense(X, W1, B1, sigmoid_function) # layer 1
    A2 = dense(A1, W2, B2, sigmoid_function) # layer 2
    A3 = dense(A2, W3, B3, softmax_function_trick) # layer 3
    return A3

# 获取训练集和测试集
def get_data():
    # 训练集数据和结果，测试集数据和结果
    # 参数说明：展开为一维数组，不使用归一化，不使用 one-hot 标签（直接使用 7，2 这样简单保存正确解标签）
    # 详细参数说明见代码仓库内的 dataset/mnist.py
    (x_train, t_train), (x_test, t_test) = load_mnist(flatten=True, normalize=True, one_hot_label=False)
    return x_train, t_train, x_test, t_test

# 模型评估
def assessment():
    pass

# ============================= main ===================================

if __name__ == '__main__':
    network = init_network('sample_weight.pkl') # 配置神经网络的参数
    _, _, X, T = get_data() # X：测试集数据，T：测试集正确结果
    accuracy_cnt = 0 # 记录推理正确的个数

    for i in range(X.shape[0]): # X.shape[0] 即为测试集数据个数
        Y = predict(network, X[i])  # 对测试集每个数据进行推理，得到 10 个概率数值的一维数组
        # print(Y)
        # axis=0：返回每一列最大值的索引；axis=1：返回每一行最大值的索引
        # axis=None：降为一维数组后，返回最大值的索引
        p = np.argmax(Y, axis=None) # 返回概率最大的索引
        if p == T[i]: # 如果推理结果与测试集结果相同，说明推理正确
            accuracy_cnt += 1

    print(f"accuracy: {float(accuracy_cnt) / X.shape[0]}") # 精度结果：93.52%
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89