Neural Networks on LunaTide's Blog

鱼书笔记-与学习相关的技巧

Tue, 25 Nov 2025 00:00:00 +0000

参数的更新

鱼书笔记-误差反向传播法

Sat, 22 Nov 2025 00:00:00 +0000

计算图

用计算图求解

我们先来看一个简单的问题

问题：太郎在超市买了2个100日元一个的苹果，消费税是10%，请计算支付金额

如何用计算图表示，这个非常简单，小学生都能看懂

或者也可以把运算的数字放在圆圈外面，如下图

上面说的这种便是正向传播运算，也就是我们的正常运算的逻辑，但是这章的主题是反向传播，我们来看看这是什么

反向传播

加法节点的反向传播

以z=x+y为例，左图为正向传播，右图为反向传播

乘法节点的反向传播

以z=xy为例

回到开头的例子

所以重新思考开头的那个买苹果的例子，要解的就是苹果的价格，苹果的个数，消费税这三个变量之间各自如何影响最终支付的金额，相当于求“支付金额关于苹果价格的导数”，“支付金额关于苹果个数的导数“，”支付金额关于消费税的导数”，反向传播的过程如下图

如图，苹果价格的导数是2.2，苹果个数的导数是110，消费税的导数是200，意思就是，如果消费税和苹果的价值增长同样的值，消费税将对最终金额产生200倍左右的影响，苹果的价格将产生2.2倍大小的影响（不过这个例子在中两者的量纲不同）

简单层的实现

本节用python实现购买苹果的例子

乘法层的实现

层的实现中有两个共通的方法forwar()和backward()。forward()对应正向传播，backward()对应反向传播。

然后来实现乘法层

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


class MulLayer:
 def __init__(self):
 self.x = None
 self.y = None

 def forward(self,x,y):
 self.x = x
 self.y = y
 out = x * y

 return out

 def backward(self,dout):
 dx = dout * self.y
 dy = dout * self.x

 return dx,dy

__init__()中会初始化实例变量x和y，它们用于保存正向传播时的输出值。forward()接收x和y两个参数，将它们相乘后输出。backward()将从上游传来的导数(dout)乘以正向传播的翻转值，然后传给下游

加法层的实现

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


class AddLayer:
 def __init__(self):
 pass

 def forward(self,x,y):
 out = x + y
 return out

 def backward(self,dout):
 dx = dout * 1
 dy = dout * 1
 return dx,dy

加法层不需要初始化，实现非常简单

例子

接下来看个实际操作的例子

上图可以像如下一样实现

 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


apple = 100
apple_num = 2
orange = 150
orange_num = 3
tax = 1.1

#layer
mul_apple_layer = MulLayer()
mul_apple_layer = MulLayer()
add_apple_orange_layer = AddLayer()
mul_tax_layer = MulLayer()

# forward
apple_price = mul_apple_layer.forward(apple,app_num)
orange_price = mul_orange_layer.forward(orange,orange_num)
all_price = add_apple_orange_layer.forward(apple_price,orange_price)
price = mul_tax_layer.forward(all,price,tax)

#backward
dprice = 1
dall_price,dtax = mul_tax_layer.backward(dprice)
dapple_price,dorange_nprice =add_apple_orange_layer.backward(dall_price)
dorange,dorange_num = mul_orange_layer.backward(dorange_price)
dapple,dapple_num = mul_apple_layer.backward(dapple_price)

print(price)
print(dapple_num,dapple,dorange_num,dtax)

激活函数层的实现

ReLU层

激活函数ReLU由下式表示

$$ y = \begin{cases} x & (x>0) \\ 0 & (x \le 0) \end{cases}\tag{1} $$

通过式(1)，可以求出y关于x的导数，如下式

$$ \frac{\partial y}{\partial x} = \begin{cases} 1 & (x>0) \\ 0 & (x \le 0) \end{cases}\tag{2} $$

接下来实现一下ReLU层

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


class ReLU:
 def __init__(self):
 self.mask = None

 def forward(self,x):
 self.mask = (x <= 0)
 out = x.copy()
 out[self.mask] = 0

 def backward(self,dout):
 dout[self.mask] = 0
 dx = dout

 return dx

ReLU由实例变量mask。这个变量mask是由True/False构成的NumPy数组，它会把正向传播时输入的x的元素中小于等于0的地方保存为True，其他地方（大于0的元素）保存为False

Sigmoid层

接下来来实现一下sigmoid函数，sigmoid函数如下式所示

$$ y = \frac{1}{1 + \exp(-x)}\tag{3} $$

用计算图表示上式，如下所示

然后我们来看下反向传播是怎么样的

上图就是Sigmoid函数的反向传播过程，如果你看懂了上面的内容相信这个不难理解

我们在反向传输的过程中只需要专注于它的输入和输出就可以，不用在意繁琐的过程

输出的结果此外， $\frac{\partial L}{\partial y} y^{2} \exp(-x)$ 可以进一步整理如下：

$$ \begin{aligned} \frac{\partial L}{\partial y} y^{2} \exp(-x) &= \frac{\partial L}{\partial y} \frac{1}{(1+\exp(-x))^{2}} \exp(-x) \\ &= \frac{\partial L}{\partial y} \frac{1}{1+\exp(-x)} \frac{\exp(-x)}{1+\exp(-x)} \\ &= \frac{\partial L}{\partial y} \, y (1-y) \end{aligned}\tag{4} $$

实现一下Sigmoid层

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


class Sigmoid:
 def __init__(self):
 self.out = Nonoe

 def forward(self,x):
 out = 1 / (1 + np.exp(-x))
 self.out = out

 return out

 def backward(self,dout):
 dx = dout * (1.0 - self.out) * self.out

 return dx

Affine/Softmax层的实现

Affine层

神经网络的正向传播中，为了计算加权信号的总和，使用了矩阵的积乘运算(NumPy中是np.dot)

神经网络的正向传播中进行的矩阵的乘积运算在几何学领域被称为“仿射变换”。因此，这里将进行仿射变换的处理实现称为“Affine层”

将这里进行的求矩阵的乘积和偏置的和的运算用计算图表示出来。将乘积运算用“dot”节点表示的话，则np.dot(X,W) + B的运算可以用下图的计算图来表示出来，另外，在各个变量的上方标记了它们的形状

上图是比较简单的计算图，不过要注意X,W,B是矩阵

考虑上图的反向传播，以矩阵为对象的反向传播，按矩阵的各个元素进行计算时，步骤和以标量为对象的计算图相同。

我们可以写出计算图的反向传播，如下图

观察一下上图中各个变量的形状，X和$\frac{\partial L}{\partial \mathbf{X}}$形状相同，W和$\frac{\partial L}{\partial \mathbf{W}}$，形状相同，从下式就可以看出X和$\frac{\partial L}{\partial \mathbf{X}}$形状相同

$$ \mathbf{X} = (x_0, x_1, \cdots, x_n)\\ \frac{\partial L}{\partial \mathbf{X}} = \left( \frac{\partial L}{\partial x_0}, \frac{\partial L}{\partial x_1}, \cdots, \frac{\partial L}{\partial x_n} \right)\tag{5} $$

批版本的Affine层

前面介绍的Affine层的输入X是以单个数据为对象的。现在我们考虑N个数据一起进行正向传播的情况

下图是批版本的affine层的计算图

现在输入X的形状是(N,2)。之后就和前面一样

正向传播时，偏置被加到$X·W$的各个数据上。比如，N=2时，偏置会分别加到这两个数据上，因此反向传播时，各个数据的反向传播的值需要汇总为偏置的元素

Affine的实现如下

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


class Affine:
 def __init__(self,W,b):
 self.W = W
 self.b = b
 self.x = None
 self.dW = None
 delf.db = None

 def forward(self,x):
 self.x = x
 out = np.dot(x,self.W) + self.b

 return out

 def backward(self,dout):
 dx = np.dot(dout,self.W.T)
 self.dW = np.dot(self,x.T,dout)
 self.db = np.sum(dout,axis=0)

 return dx

Softmax-with-Loss层

之前说过softmax函数会将输入值正规化（将输出值的和调整为1）然后再输出。另外，因为手写数字识别要进行10类分类，所以向Softmax层的输入也有10个

下面来实现Softmax层，计算图如下图所示

上图的计算图可以简化成下图

上图的计算图中，softmax函数记为Softmax层，交叉熵误差记为Cross Entropy error层。这里假设要进行三类分类，从前面的层接收三个输入，Softmax层将输入(a1,a2,a3)正规化，输出(y1,y2,y3)Cross Entropy Error层接收Softmax的输出(y1,y2,y3)和教师标签(t1,t2,t3)，从这些数据中输出损失L

上图要注意的是反向传播的结果，Softmax层的反向传播得到了(y1-t1,y2-t2,y3-t3)这样漂亮的结果。由于(y1,y2,y3)是Softmax层的输出，(t1,t2,t3)是监督数据，所以(y1-t1,y2-t2,y3-t3)是Softmax层的输出和教师标签的差分。神经网络会把这个差分表示的误差传递给前面的层。

神经网络学习的目的就是通过调整权重参数，使神经网络的输出接近教师标签。因此，必须将神经网络的输出与教师标签的误差高效地传递给前面的层

现在实现一下Softmax-with-Loss层

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


class SoftmaxWithLoss:
 def __init__(self):
 self.loss = None # 损失
 self.y = None # softmax的输出
 self.t = None # 监督数据（one-hot vector）

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

 return self.loss

 def backward(self, dout=1):
 batch_size = self.t.shape[0]
 dx = (self.y - self.t) / batch_size
 r return dx

鱼书笔记-神经网络的学习

Mon, 17 Nov 2025 00:00:00 +0000

从数据中学习

神经网络的特征就是从数据中学习（由数据自动决定权重参数的值）

数据驱动

我们接着上一章最后手写数字识别的话题，思考一下会发现如果设计一个能自动识别5的算法还是挺困难的（至少我是这样认为的），所以我们应该考虑通过有效利用数据来解决这个问题，一种方案是从图像中提取特征量，再用机器学习技术学习这些特征量的模式

机器学习的方法中，由机器从收集到的数据中找到规律性。但是将图像转换为向量时使用的特征量仍是由人设计的，对于不同的问题，必须使用合适的特征量，才能得到好的结果

还有一种是神经网络（深度学习）的方法，该方法不存在人为介入，神经网络会直接学习图像本身

训练数据和测试数据

机器学习中把数据分成训练数据和测试数据两部分，首先用训练数据进行学习，寻找最优的参数，然后用测试数据评价训练得到的模型的实际能力，为了正确评价模型的泛化能力，就必须划分训练数据和测试数据，训练数据也被称作监督数据

泛化能力是指处理未被观察过的数据的能力。机器学习的目标就是为了提高泛化能力

因此，仅仅用一个数据集去学习和评价参数，无法正确评价，只用某个数据集过度拟合的状态称为过拟合

损失函数

神经网络的学习通过某个指标来表示现在的状态。然后以这个指标为基准，寻找最优权重参数。这个指标被称为损失函数。损失函数可以使用任意参数，但一般用均方误差和交叉熵误差等。

均方误差

如下式

$$ E = \frac{1}{2} \sum_k (y_k - t_k) ^ 2 \tag{1} $$

这里$y_k$是表示神经网络的输出，$t_k$是表示监督数据，$k$表示数据的维数，如式(1)所示，均方误差会计算神经网络的输出和正确解监督数据的各个元素之差的平方，再求总和。python实现均方误差的实现方式如下所示

1
2


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

交叉熵误差

交叉熵误差如下式所示

$$ E = - \sum_k (t_k \log{y_k}) \tag{2} $$

$y_k$是神经网络的输出，$t_k$是正确解标签(采用one-hot表示)。交叉熵误差的值是由正确解标签所对应的输出结果决定的。

根据对数函数的性质我们可以知道，正确解标签对应的输出越大，式(2)的值就越靠近0；输出为1时，交叉熵的误差为0。如果正确解标签对应的输出较小，(2)的值就越大。

下面实现一下交叉熵误差

1
2
3


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

y和t在这里是NumPy数组，加上一个delta是为了防止-inf的发生

mini-batch学习

前面说的都是单个数据的损失函数。如果要求所有训练数据的损失函数的总和，以交叉熵误差为例，可以写成下面的式(3)

$$ E = -\frac{1}{N} \sum_{n} \sum_{k} t_{nk}\,\log y_{nk} \tag{3} $$

假设一共有N个数据，$t_{nk}$表示第n个数据的第k个元素的值

这个式子就是把单个数据的损失函数的式扩大到了N份数据，不过最后还要除以N进行正规化。

MNIST数据集的训练数据有60000个，用全部数据来计算损失函数的值所花费的时间太长，所以我们从中选取一部分。神经网络的学习也是从训练数据中选出一批数据（称为mini-batch)，然后对每个mini-batch进行学习。

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

对于mini-batch的交叉熵误差，只要改良一下之前实现对应单个数据的交叉熵误差就可以。这里实现一个可以同时处理单个数据和批量数据两种情况的函数

1
2
3
4
5
6
7


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

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

这里，y是神经网络的输出，t是监督数据。y的维度为1时，即求单个数据的交叉熵误差时，需要改变数据的形状。并且，当输入为mini-batch时，要用batch的个数进行正规化，计算单个数据的平均交叉熵误差

此外，当监督数据时标签形式(非one-hot表示，而是像"2" “7"这样的)交叉熵误差可以如下实现

1
2
3
4
5
6
7


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

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

由于one-hot表示中t为0的元素的交叉熵误差也为0，因此针对这些元素的计算可以忽略。只要可以获得神经网络在正确解标签的输出，就可以计算交叉熵误差,t为one-hot表示时通过t * np.log(y)计算的地方t为标签形式时，可以用np.log(y[np.arange(batch_size),t])表示实现相同的处理

为什么要设定损失函数

假设有一个神经网络，对其中一个权重参数的损失函数求导，如果这个导数的值为负，说明使该权重参数向正正方向改变，可以减小损失函数的值；反之亦然，以及当导数的值为0时候，无论权重参数往哪个方向，损失函数的值都不会改变。而如果用识别精度作为指标，则参数的导数在绝大多数地方都为0

梯度法

梯度的方向不一定指向最小值，但是沿着梯度的方向能够最大限度地减小函数的值

梯度法是什么，就是让函数的取值沿着梯度的方向前进一段距离，在新的地方重新求梯度，然后再沿着梯度方向前进，像这样反复，逐渐减小函数值，然后我们用数学式来表示梯度法，如下式(4)

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

上式的$\eta$表示更新量，在神经网络的学习中，称为学习率，决定了在一次学习中，应该学习多少，以及在多大程度上更新参数

接下来用python实现下梯度下降法

1
2
3
4
5
6
7


def gradient_descet(f,init_x,lr = 0.01,step_num = 100):
 x = init_x;
 for i in range(step_num):
 grad = numerical_gradient(f,x)
 x -= lr * grad

 return x

参数f是要进行最优化的函数，init_x是初始值，lr是学习率，step_num是梯度法的重复次数，numerical_gradient(f,x)会求函数的梯度

神经网络的梯度

神经网络的学习也要求梯度，这里所说的梯度是指损失函数关于权重参数的梯度，例如一个形状2x3的权重$W$的神经网络，损失函数用L表示。此时，梯度可以用$\frac{\partial L}{\partial \mathbf{W}}$表示

$$ \mathbf{W} = \begin{pmatrix} w_{11} & w_{12} & w_{13} \\ w_{21} & w_{22} & w_{23} \end{pmatrix}\\ \frac{\partial L}{\partial \mathbf{W}} = \begin{pmatrix} \frac{\partial L}{\partial w_{11}} & \frac{\partial L}{\partial w_{12}} & \frac{\partial L}{\partial w_{13}} \\ \frac{\partial L}{\partial w_{21}} & \frac{\partial L}{\partial w_{22}} & \frac{\partial L}{\partial w_{23}} \end{pmatrix}\tag{5} $$

鱼书笔记-神经网络(下)

Wed, 12 Nov 2025 00:00:00 +0000

以下内容皆基于鱼书《深度学习入门基于python的理论与实现》

3层神经网络的实现

开始进行神经网络的实现，以下图的三层神经网络为例

符号确认

首先导入符号$w_{12}^{(1)}$, $a_{1}^{(1)}$等，如下图，权重和隐藏层的神经元右上角有一个"(1)"，它表示权重和神经元的层号，此外，权重右下角的两个数字，它们是后一层的神经元和前一层的神经元的索引号，比如$w_{12}^{(1)}$表示前一层的第二个神经元$x_2$到后一层的第1个神经元$a_{1}^{(1)}$的权重。权重右下角按照"后一层的索引号、前一层的索引号"的顺序排序

各层间信号传递的实现

上图增加了表示偏置的神经元"1"。偏置的右下角的索引号只有一个因为前一层的偏置神经元只有一个

现在通过加权信号和偏置的和计算表示$a_{1}^{(1)}$。

$$ a_{1}^{(1)} = w_{11}^{(1)} x_{1} + w_{12}^{(1)} x_{2} + b_{1}^{(1)}\tag{8} $$

如果用矩阵的乘法运算，则可以将第1层的加权和表示成下面的式(9)

$$ A^{(1)} = XW^{(1)} + B^{(1)} \tag{9} $$

其中，$A^{(1)}$、$X$、$B^{(1)}$、$W^{(1)}$ 如下所示：

$$ A^{(1)} = \begin{pmatrix} a_{1}^{(1)} & a_{2}^{(1)} & a_{3}^{(1)} \end{pmatrix}, \quad X = \begin{pmatrix} x_1 & x_2 \end{pmatrix}, \quad B^{(1)} = \begin{pmatrix} b_{1}^{(1)} & b_{2}^{(1)} & b_{3}^{(1)} \end{pmatrix} $$$$ W^{(1)} = \begin{pmatrix} w_{11}^{(1)} & w_{21}^{(1)} & w_{31}^{(1)} \\ w_{12}^{(1)} & w_{22}^{(1)} & w_{32}^{(1)} \end{pmatrix} $$

然后用NumPy多维数组来实现式(9)，输入信号，权重，偏置设置成任意值

1
2
3
4
5
6
7
8
9


X = np.array([1.0,0.5])
W1 = np.array([[0.1,0.3,0.5],[0.2,0.4,0.6]])
B1 = np.array([0,1,0,2,0,3])

print(W1.shape) # (2,3)
print(X.shape) #(2,)
print(B1.shape) #(3.)

A1 = np.dot(X,W1) + B1

W1是2x3的数组，X是元素个数为2的一维数组。这里，W1和X的对应维度的元素个数也保持了一致。

然后我们用python来实现第一层激活函数的计算过程

1
2
3
4


Z1 = sigmoid(A1)

print(A1)
print(Z1)

这里说的sigmoid函数就是之前定义的那个，它会接收NumPy数组，然后返回元素个数相同的NumPy数组

下面我们来实现第1层到第2层的信号传递

1
2
3
4
5
6
7
8
9


W2 = np.array([[0.1,0.4],[0.2,0.5],[0.3,0.6]])
B2 = np.array([0.1,0.2])

print(Z1.shape) #(3,)
print(W2.shape) #(3,2)
print(B2.shape) #(2,)

A2 = np.dot(Z1,W2) + B2
Z2 = sigmoid(A2)

除了第一层的输出变成了第二层的输入，这个实现和刚才的一样

最后是第二层到输出层的信号传递，输出层的实现也和之前的实现基本相同，不过，最后的激活函数和之前的隐藏层有所不同

1
2
3
4
5
6
7
8


def identity_function(x):
 return x

W3 = np.array([0.1,0.3],[0.2,0.4])
B3 = np.array([0.1,0.2])

A3 = np.dot(Z2,W3) + B3
Y = identity_function(A3)

这里定义了identity_function()函数（恒等函数），并将其作为输出层的激活函数。

代码总结

按照神经网络的实现惯例，把权重记为大写字母W1，其他都用小写字母表示

 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


def init_network():
 network = {}
 network['W1'] = np.array([[0.1, 0.3, 0.5], [0.2, 0.4, 0.6]])
 network['b1'] = np.array([0.1, 0.2, 0.3])
 network['W2'] = np.array([[0.1, 0.4],[0.2, 0.5],[0.3, 0.6]])
 network['b2'] = np.array([0.1, 0.2])
 network['W3'] = np.array([[0.1, 0.3],[0.2, 0.4]])
 network['b3'] = np.array([0.1, 0.2])

 return network

def forward(network,x):
 W1, W2, W3 = network['W1'],network['W2'],network['W3']
 b1, b2, b3 = network['b1'],network['b2'],network['b3']

 a1 = np.dot(x, W1) + b1
 z1 = sigmoid(a1)
 a2 = np.dot(z1, W2) + b2
 z2 = sigmoid(a2)
 a3 = np.dot(z2, W3) + b3
 y = identity_function(a3)

 return y;

network = init_network()
x = np.array([1.0, 0.5])
y = forward(network, x)
print(y) # [ 0.31682708 0.69627909]

这里定义了init_network()和forward()函数，init_network()函数会进行权重和偏置的初始化，并将它们保存在字典变量network中。forward()函数中则封装了将输入信号转换为输出信号的处理过程

输出层的设计

神经网络要根据情况改变输出层的激活函数。一般而言，回归问题用恒等函数，分类问题用softmax函数。

恒等函数和softmax函数

恒等函数会将输入按原样输出

分类问题中的softmax函数可以用下面的式(10)表示

$$ y_k = \frac{\exp(a_k)}{\sum_{i=1}^{n} \exp(a_i)}\tag{10} $$

上式表示假设输出层共有n个神经元，计算第k个神经元的输出$y_k$，如式(10)所示，softmax函数的分子是输入信号$a_k$的指数函数，分母是所有输入信号的指数函数的和

接下来来实现softmax函数。

1
2
3
4
5
6


def softmax(a):
 exp_a = np.exp(a)
 sum_exp_a = np.sum(exp_a)
 y = exp_a / sub_exp_a

 return y;

实现softmax函数时的注意事项

上面的softmax函数在计算上有一定的缺陷，就是溢出的问题，softmax函数的实现中要进行指数函数的运算，但是此时指数函数的值很容易变得非常大，比如$e^{1000}$的结果会返回一个表示无穷大大inf，在这些超大值之间进行除法运算，结果会出现不确定的情况，softmax可以像如下(11)改进

$$ \begin{aligned} y_k &= \frac{\exp(a_k)}{\sum_{i=1}^{n} \exp(a_i)} = \frac{C \exp(a_k)}{C \sum_{i=1}^{n} \exp(a_i)} \\[6pt] &= \frac{\exp(a_k + \log C)}{\sum_{i=1}^{n} \exp(a_i + \log C)} \\[6pt] &= \frac{\exp(a_k + C')}{\sum_{i=1}^{n} \exp(a_i + C')} \end{aligned} \tag{11} $$

先在分子和分母上都乘以C（一个任意的常数），然后把C移动到指数函数中，记为$log C$。最后把$logC$替换为另外一个符号$C'$

综上，我们来实现下最终版的softmax函数

1
2
3
4
5
6
7


def softmax(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

softmax函数的特征

输出总和为1，因为这个性质我们才可以把softmax函数的输出解释为“概率”
使用了softmax函数各个元素之间的大小关系也不会改变，因为exp是单调递增的
神经网络一般只会把输出值最大的神经元所对应的类别作为识别结果。使用softmax函数输出值最大的神经元的位置也不会变，因此输出层的softmax函数一般会被忽略

输出层的神经元数量

输出层的神经元数量需要根据待解决的问题来决定。对于分类问题，输出层的神经元数量一般设定为类别的数量。比如，对于某个输入图像，预测是图中的数字0到9中的哪个的问题，可以把输出层的神经元设定为10个，然后把这十个神经元按照从上到下，从0-9依次编号，并且值用不同的灰度表示，颜色越深，输出的值就越大

手写数字识别

开始解决实际问题，假设学习已经全部结束，我们使用学习到的参数，先实现神经网络的“推理处理”。这个推理处理也称为神经网络的前向传播

MNIST数据集

MNIST数据集是由0到9的数字图像构成的。训练图像有6万张，测试图像有1万张，这些图像可以用于学习与推理。MNIST数据集的一般使用方法是，先用训练图像进行学习，再用学习到的模型度量能在能在多大程度上对测试图像进行正确的分类

MNIST的图像数据是28像素x28像素的灰度图像（1通道），各个像素的取值在0到255之间。每个图像都相应地标有“7” “2” “1”等标签。

从数据中学习

数据驱动

如何实现数字“5”的识别，如果要设计一个能将5正确分类的程序

鱼书笔记-神经网络(上)

Mon, 10 Nov 2025 00:00:00 +0000

以下内容皆基于鱼书《深度学习入门基于python的理论与实现》

从感知机到神经网络

感知机回顾

用图来表示神经网络，类比感知机，我们把左边的一列称为输入层，最右边的称之为输出层，中间的称为中间层(也称为隐藏层，因为神经元肉眼看不见)，我们知道当感知机接受$x_1,x_2$两个输入信号，输出$y$时，可以用如下的数学式来表示

$$ y = \begin{cases} 0, & b + w_1 x_1 + w_2 x_2 \le 0 \\ 1, & b + w_1 x_1 + w_2 x_2 > 0 \end{cases} \tag{1} $$

$b$是偏置，用于控制神经元被激活的容易程度，而$w_1,w_2$是表示各个信号的权重的参数，用于控制各个信号的重要性

我们现在可以通过调用一个函数来替代(1)中分case讨论的情况来简化(1)，改写成如下形式

$$ y = h(b + w_1x_1+ w_2x_2)\tag{2} $$$$ h(x) = \begin{cases} 0, & x \le 0 \\ 1, & x > 0 \end{cases}\tag{3} $$

激活函数引入

刚才的h(x)把输入信号的总和转换成了输出信号，h(x)就被称为激活函数(activation function)

现在进一步改写式(2)，写成如下形式

$$ a = b + w_1x_1 + w_2x_2\tag{4} $$$$ y = h(a)\tag{5} $$

首先，式(4)计算加权输入信号的和偏置的总和，然后用(5)的h函数转换为输出

激活函数

sigmoid函数

神经网络中经常使用的一个激活函数就是sigmoid函数

$$ h(x)=\frac{1}{1+e^{-x}} \quad (\text{sigmoid function})\tag{6} $$

实际上，感知机和神经网络的主要区别就在于激活函数，其他方面基本都是一样的

阶跃函数的实现

阶跃函数如(3)所示，当输入超过0时，输出1，否则输出0，可以用如下代码简单实现

1
2
3
4
5


def step_function(x):
 if x > 0:
 return 1
 else:
 return 0

这个代码中参数x只能接受实数。例如不允许step_function(np.array([1.0,2.0]))，所以我们把它修改为支持NumPy数组的实现

1
2
3


def step_function(x):
 y = x > 0
 return y.astype(np.int)

阶跃函数的图形

接下来我们就用图来表示上面定义的阶跃函数

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


import numpy as np
import matplotlib.pylab as plt

def step_function(x):
 return np.array(x > 0,dtype=np.int)

x = np.arange(-5.0,5.0,0.1)
y = step_function(x)
plt.plot(x,y)
plt.ylim(-0.1,1.1) #y轴范围
plt.show()

sigmoid函数的实现

1
2


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

之所以sigmoid函数的实现支持NumPy数组，就是因为NumPy的广播功能，如果在标量和NumPy数组之间进行运算，标量会和NumPy数组的各个元素进行运算，np.exp(-x)会生成NumPy数组，所以1/(1 + np.exp(-x))的运算将会在NumPy数组的各个元素间进行

sigmoid函数和阶跃函数的比较

观察可以发现，首先区别就是平滑性，sigmoid函数是一条平滑的曲线，输出随着输入发生连续性的变化。而阶跃函数以0为界，输出发生急剧性的变化。因此我们可以知道，感知机的神经元之间流动的是0或1的二元信号，神经网络中流动的是连续的实数值信号。

然后说一下阶跃函数和sigmoid函数的共同性质，两者的结构均是“输入小时输出接近0；输入大时，输出靠近1”，以及不管输入是什么值，输出信号的值都在0和1中间

非线性函数

阶跃函数和sigmoid函数都是非线性函数

神经网络的激活函数必须使用非线性函数，因为如果使用线性函数，加深神经网络的层数就没有意义了（应该很好理解，很多线型函数复合仍然是线性的，就不具体说了）

ReLU函数

最近比较常见的是ReLU函数

ReLU函数在输入大于0时，直接输出该值；在输入小于等于0的时候，输出0

ReLU函数可以表示为以下数学式

$$ h(x) =\begin{cases} x, & x > 0 \\ 0, & x \le 0 \end{cases} \tag{7} $$

ReLU函数的实现也非常简单

1
2


def relu(x):
 return np.maximum(0,x)

多维数组的运算

多维数组

首先假定有一个一维数组A = np.array[1,2,3,4]，数组的维数可以通过np.ndim得到。数组的形状可以通过实例变量shape获得，A由四个元素构成，是一维的，所以A.shape就是（4，），这个结果是个元组，这个一维数组为了保证和多维一样的格式，所以仍然被写成元组

矩阵乘法

不再赘述

Neural Networks on LunaTide's Blog

鱼书笔记-与学习相关的技巧

参数的更新

鱼书笔记-误差反向传播法

计算图

用计算图求解

反向传播

加法节点的反向传播

乘法节点的反向传播

回到开头的例子

简单层的实现

乘法层的实现

加法层的实现

例子

激活函数层的实现

ReLU层

Sigmoid层

Affine/Softmax层的实现

Affine层

批版本的Affine层

Softmax-with-Loss层

鱼书笔记-神经网络的学习

从数据中学习

数据驱动

训练数据和测试数据

损失函数

均方误差

交叉熵误差

mini-batch学习

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

为什么要设定损失函数

梯度法

神经网络的梯度

鱼书笔记-神经网络(下)

3层神经网络的实现

符号确认

各层间信号传递的实现

代码总结

输出层的设计

恒等函数和softmax函数

实现softmax函数时的注意事项

softmax函数的特征

输出层的神经元数量

手写数字识别

MNIST数据集

从数据中学习

数据驱动

鱼书笔记-神经网络(上)

从感知机到神经网络

感知机回顾

激活函数引入

激活函数

sigmoid函数

阶跃函数的实现

阶跃函数的图形

sigmoid函数的实现

sigmoid函数和阶跃函数的比较

非线性函数

ReLU函数

多维数组的运算

多维数组

矩阵乘法

神经网络的内积