Deep Learning on LunaTide's Blog

CS231 第六讲 CNN架构

Sun, 28 Dec 2025 00:00:00 +0000

CNN架构

常用的层

归一层

归一层的工作原理分为两个部分，第一步是将输入数据归一化为标准正态分布，均值为0，标准差为1，然后进行缩放和偏移，通过乘以某个值调整中心偏差，再进行偏移以改变均值位置，所有归一化层都采用这样的技术，它们之间的区别在于如何计算统计量，均值和标准差，以及将这些统计量应用到哪些值

层归一化

这是最常用的归一化层，如下图

下面的图片展示了几种不同的归一化方法和它们各自张量的哪些维度上计算均值和方差

Dropout层

Dropout层的核心思想是在训练时添加随机性，而在测试时移除，目的是让模型难以过拟合训练数据，但会提升泛化能力，具体实现如下图，我们实际上随机将某些输出或激活值归零

下面是伪代码

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


""" Vanilla Dropout: Not recommended implementation (see notes below) """

p = 0.5 # probability of keeping a unit active. higher = less dropout

def train_step(X):
 """ X contains the data """

 # forward pass for example 3-layer neural network
 H1 = np.maximum(0, np.dot(W1, X) + b1)
 U1 = np.random.rand(*H1.shape) < p # first dropout mask
 H1 *= U1 # drop!
 H2 = np.maximum(0, np.dot(W2, H1) + b2)
 U2 = np.random.rand(*H2.shape) < p # second dropout mask
 H2 *= U2 # drop!
 out = np.dot(W3, H2) + b3

 # backward pass: compute gradients... (not shown)
 # perform parameter update... (not shown)

def predict(X):
 # ensembled forward pass
 H1 = np.maximum(0, np.dot(W1, X) + b1) * p # NOTE: scale the activations
 H2 = np.maximum(0, np.dot(W2, H1) + b2) * p # NOTE: scale the activations
 out = np.dot(W3, H2) + b3

上述方法需要注意一点：在预测的时候要乘以dropout概率$p$，这是因为假设输入为$x$，其期望输出为$px$，所以为了保持一致，预测时要乘以dropout概率$p$。这要会产生一个问题：预测时增加了运算量，一个改进方式如下

 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


"""
Inverted Dropout: Recommended implementation example.
We drop and scale at train time and don't do anything at test time.
"""

p = 0.5 # probability of keeping a unit active. higher = less dropout

def train_step(X):
 # forward pass for example 3-layer neural network
 H1 = np.maximum(0, np.dot(W1, X) + b1)
 U1 = (np.random.rand(*H1.shape) < p) / p # first dropout mask. Notice /p!
 H1 *= U1 # drop!
 H2 = np.maximum(0, np.dot(W2, H1) + b2)
 U2 = (np.random.rand(*H2.shape) < p) / p # second dropout mask. Notice /p!
 H2 *= U2 # drop!
 out = np.dot(W3, H2) + b3

 # backward pass: compute gradients... (not shown)
 # perform parameter update... (not shown)

def predict(X):
 # ensembled forward pass
 H1 = np.maximum(0, np.dot(W1, X) + b1) # no scaling necessary
 H2 = np.maximum(0, np.dot(W2, H1) + b2)
 out = np.dot(W3, H2) + b3

激活函数

激活函数的核心作用是为模型引入非线性

sigmoid函数

sigmoid函数的表达式如下

$$ \sigma(x)=1/(1+e^{-x}) $$

sigmoid函数主要有以下的问题：

经过多层sigmoid后，反向传播时梯度会越来越小
由于Sigmoid函数输出结果都大于0，由乘法门的含义可知，这会导致梯度的符号都相同，这也不利于训练。

ReLU

ReLU的表达式如下

$$ f(x)=max(0,x) $$

ReLU在正区域不会出现梯度消失的情况，但是在负区域还是会出现梯度为0的情况，所以我们基本上覆盖了输入域的一半，这个肯定比sigmoid函数牛逼，并且只需要计算0和x的最大值也比sigmoid函数效率更高

但是还是有上面的问题，对于任何负输入，会得到零梯度

GELU

GELU的表达式如下

$$ f(x)=x*\phi(x) $$

GELU在接近零的邻域内保留激活函数的非平坦区域，核心思想就是平滑0处的非连续跳跃

那么这些CNN中的激活函数在哪里用

答：通常放在线性算子之后（比如全连接层，卷积层）

残差网络

如果在普通CNN网络上不断堆叠更深的层，不断叠加新层，让网络变得越来越大，会发生什么年？

他们发现二十层模型的测试误差实际上低于56层模型，你可能会认为这是过拟合导致的，但是其实当我们看训练误差，20层模型的训练误差也更低，如下图

所以为什么会56层模型表现不如20层模型，更深的模型有更强的表示能力，理论上它们能表示浅层网络能处理的所有模型，因此可能的输入与输出之间的映射关系对于大型网络时小型网络的超集，因为从理论上讲，你可以想象将某些层设置为恒等函数，这些层不做任何操作，如果你将一半的层设置为无操作，你拥有的表示能力与模型完全相同，大小减半，所以说不是这些模型更差，但在表示能力方便，它们实际上更难优化，因为深层网络的可能模型集合更大，并且包含所有浅层网络可能学习到的模型

那么深层模型如何至少与浅层模型一样好，如下图，我们有一个一层模型和一个两层模型，如果我们让其中一个层几乎成为单位矩阵，模型至少应该和浅层模型一样好

那么我们如何将这种直觉融入模型，我们希望它可以和浅层模型一样优秀，我们通过拟合来实现，所谓的残差映射，而非直接拟合底层映射

直觉是一种观察到的现象，这些大型网络在训练和测试误差上表现更差，因为它们难以优化，因此直觉是我们需要构建能够轻松模拟浅层网络的模型，使其至少与浅层模型一样好，它们通过添加残差连接实现了这一点，以便轻松复制值，将其融入架构本身，而不是在卷积层之间学习恒等映射

如何初始化各层的权重值

Kaiming初始化

1
2
3
4
5
6
7


dims = [4096] * 7
hs = []
x = np.random.randn(16,dims[0])
for Din,Dout in zip(dims[:-1], dims[1:]):
 W = np.random.randn(Din,Dout) * np.sqrt(2/Din)
 x = np.maximum(0,x,dot(W))
 hs.append(x)

图像归一化要点总结：对每个通道进行居中和缩放

对每个通道减去均值
再除以每个通道的标准差（每个通道各自统计，共三个数）
需要预先计算：针对你的数据集，为每个像素通道计算均值和标准差

norm_pixel[i,j,c] = (pixsl[i,j,c] - np.mean(pixel[:,:,c])) / np.std(pixel[:,:,c])

正则化

训练：加入某种形式的随机性

$$ y = f_w(x, z) $$

测试：对随机性取平均

$$ y = f(x) = E_z [ f(x, z) ] = \int p(z) f(x, z) dz $$

数据增强

1.水平翻转

这对日常物体很有用，因为大多数物体具有对称性

2.调整大小和缩减，方案如下

CS231 第五讲基于CNN的图像分类

Sat, 27 Dec 2025 00:00:00 +0000

卷积神经网络

我们需要做的就是添加几个可以适合我们的计算图的新类型的节点，具体来说，我们只需要讨论两个运算符就可以构建更强大的网络，就是卷积层，然后是池化层，这是我们在处理图像时经常使用的另一个层

我们之前介绍的神经网络每层被称作全连接层，它是将图像的像素展平为一个大向量，进行矩阵乘法，进行ReLU，一个大问题是它破坏了图像的空间结构，比如说，图像实际上不是一维物体，是二维得到，二维结构对于这些图像的内容很重要，当你通过将原始像素拉伸称为一个大向量来构建线性分类器时，你基本上忽略了神经网络架构设计中输入数据的重要因素，所以当考虑为图像设计神经网络架构的时候，我们尤其要思考我们的网络还有哪些设计，我们可以将哪些其他计算原语插入到我们的计算图中

这就引出了卷积神经网络，所以卷积神经网络基本上是一类神经网络架构，它由线性层，非线性层，卷积层，池化层构成，有时还会将其他几个层拼接在一起形成这些神经网络架构，输入原始像素值，，然后输出图像的一些预测或者分数

它们的一般结构通常会有一些前缀，一些网络主体，即卷积层，池化层和非线性的一些交错序列，可以被认为是为图像提取一些有用的特征表示，在此基础上，它们通常会是一些全连接层，有时候只有一层，有时候不止一层，可以将其视作多重感知器完全连接的网络分类器，它位于网络卷积部分的顶部，并从中获取特征

至关重要的是，通过最小化训练数据集的损失，整个系统通过梯度下降进行端到端调整

全连接层如下图

卷积层如下图

也就是说我们不会把图像拉伸成一个大向量，而是要保持图像的3D空间结构

卷积层

因此，如上图，我们将卷积滤波器放到图像的某个块上，这个5x5x3滤波器和该空间位置上的某个5x5x3的图像块对其，然后计算两者之间的内积，这将为我们提供一个标量数，告诉我们该图像块和模版的对齐程度

然后我们重复这个过程并且将该模块滑动到图像中的任何位置，把模版放在每个地方，我们将再次计算模版的匹配分数，该分数表示该图像部分与该模版的匹配程度，然后我们把得到的匹配分数放在一个平面上，现在这平面是一个二维平面，基本上每个点都对应着平面上每个点与输入图像对应部分和滤波器的对齐程度

而实际中的运算我们需要多个滤波器，输出如下

填充

在进行卷积的时候，特征图的空间尺寸会缩小，我们想让所有东西保持相同的尺寸，所以一个技巧就是填充

在计算卷积运算符之前，会在周围添加额外的零，效果如下图

感受野

在考虑单个卷积时，每个输出都在查看输入的这个局部区域，因第一层卷积的输出只能查看图像的一部分，其大小与正在学习的卷积核相同

但是如果我们构建了一个将多个卷积堆叠在一起的ConvNet，如上图，这些感受野就会通过网络被放大，这里的每个条目都依赖于它之前一层的局部区域，因此，当有这些卷积时，即使每个单独的卷积都在查看它之前层中的局部邻域，当在多个层中堆叠卷积时，每个卷积所查看的原始输入的有效大小都会在网络的过程中增长，我们称之为有效感受野，所以卷积的有效感受野基本就是原始图像中有多少像素有机会影响下游网络的一次激活，这个有效感受野基本上随着卷积层的数量线性增长

有一个问题，当我们最终在网络末端做出分类决策时，我们希望我们的分类决策基本上能够汇总整个图像的全局信息，但是要很多卷积层才能做到这点，所以这里的技巧就是添加一些方法来更快增加有效感受野

步幅

上面的例子中，我们每次移动一个单位，而实际中可以移动多个单位，每次移动的单位数量就叫做步长，记作S，输出如下

池化层

池化层基本上是神经网络内部下采样的另一种方法，因此，我们看到，步幅卷积是我们可以在神经网络内部进行下采样的一种方法，下蔡样可以让我们在深入网络时更快地建立感受场，池化层是一种廉价的下采样方法，不需要花费太多的计算。

我们采用了几种不同的下采样机制，最常用的实际上是最大值，被称为最大池化，因此，在最大池化中，我们要做的是取单个深度切片，将其划分为不重叠的区域

所以池化的目的是降低数据维度，图片展示的是最大值池化，实际中还有平均值池化

池化层也有对应的步长，填充参数，计算维度的方式和之前相同

CS231 第四讲神经网络与反向传播

Fri, 12 Dec 2025 00:00:00 +0000

反向传播

反向传播是计算梯度的一种方法，这种方法需要利用计算图，计算图的每个节点表示我们执行的每一步计算，例如上一讲讲的损失函数的计算图如下

第一个节点计算得分s，第二个节点计算折页损失，最后一个节点计算总损失（加上正则项）

计算图的计算步骤分为前向传播以及反向传播，刚刚描述的步骤为前向传播，现在我们结合下图理解反向传播计算梯度的思路

对于每个节点，假设我们已知输出的梯度$\frac{\partial L}{\partial z}$，现在我们要计算输入的梯度$\frac{\partial L}{\partial x}$,$\frac{\partial L}{\partial y}$，计算的思路很简单，利用链式法则，首先计算“局部梯度”$\frac{\partial z}{\partial x}$,$\frac{\partial z}{\partial y}$，然后利用链式法则可得

$$ \frac{\partial L}{\partial x} =\frac{\partial L}{\partial z}\,\frac{\partial z}{\partial x}\,\frac{\partial L}{\partial y} =\frac{\partial L}{\partial z}\,\frac{\partial z}{\partial y} $$

计算过程如下图所示

如果节点有多个输出$z_j$，那么输入的梯度$\frac{\partial L}{\partial x}$,$\frac{\partial L}{\partial y}$需要累加，具体公式为

$$ \frac{\partial L}{\partial x} = \sum_{j} \frac{\partial L}{\partial z_{j}} \,\frac{\partial z_{j}}{\partial x}, \qquad \frac{\partial L}{\partial y} = \sum_{j} \frac{\partial L}{\partial z_{j}} \,\frac{\partial z_{j}}{\partial y} $$

计算过程如下图所示

CS231 第三讲正则化与优化

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

损失函数

给定一个图片数据集 ${(x_i, y_i)}_{i=1}^N$，$x_i$ 为图片，$y_i$ 为标签，损失为

$$ L = \frac{1}{N} \sum_i L_i(f(x_i, W), y_i) \tag{1} $$

这是一种衡量模型预测与训练数据匹配程度的损失，我们希望这个值越低越好，这代表模型很好地拟合了训练数据

多类SVM损失

给一个$s=f(x_i,W)$

SVM损失定义为

$$ \begin{aligned} L_i &= \sum_{j \neq y_i} \begin{cases} 0 & \text{如果} s_{y_i} \ge s_j + 1 \\ s_j - s_{y_i} + 1 & \text{其他} \end{cases} \\ &= \sum_{j \neq y_i} \max(0, s_j - s_{y_i} + 1) \end{aligned}\tag{2} $$

SVM损失函数的形式如下

$$ L_i = \sum_{j \neq y_i} \max(0, s_j - s_{y_i} + 1)\tag{3} $$

Softmax分类器

首先定义如下概率

$$ P(Y = k | X = x_i) = \frac{e^{s_k}}{\sum_j e^{s_j}} \quad s = f(x_i; W)\tag{4} $$

我们想最大化对数似然函数，而这也等价于最小化如下式子

$$ L_i = -\log P(Y = y_i | X = x_i) = -\log \left( \frac{e^{s_{y_i}}}{\sum_j e^{s_j}} \right)\tag{5} $$

损失函数的正则化项

$$ L(W) = \frac{1}{N} \sum_{i=1}^{N} L_i(f(x_i, W), y_i) + \lambda R(W)\tag{6} $$

它的作用是防止模型在训练数据上表现过好，因此正则化的目的就是让它在训练数据表现更差，在测试集表现更好，关于这里的$\lambda$，这是正则化强度，这也是一个超参数，这个参数用于控制模型对训练数据的拟合程度

上图是一个例子，目标是拟合这些数据点，有f1和f2两种模型，f1穿过了所有数据点，所以训练或数据损失会很低，因为几乎完美拟合，但是在测试新数据上，f2可能表现更好，因此不要过度拟合数据，越简单的模型可能效果更好

比较常见的正则化项如下

所以为什么我们要对模型正则化：

它允许我们对于权重表达某种偏好
让模型更简单从而在测试数据上表现更好
通过增加曲率改进优化

优化

梯度下降

这个我们非常熟悉了，只要跟随梯度，所以计算梯度就可以了

$$ \nabla_W L = \frac{1}{N} \sum_{i=1}^{N} \nabla_W L_i(f(x_i, W), y_i) + \lambda \nabla_W R(W)\tag{7} $$

随机梯度下降(SGD)

我们之前说过可以通过遍历整个训练集，对每个i计算损失$L_i$并且汇总整个训练集，但是这样计算量太大，SGD的核心是查看一个子集代替整个训练集，每次称为一个小批量或者一批数据

但是我们会遇到一些问题，当在鞍点或者局部最优点的时候，直观点如下图

所以我们就引入了动量，你可以用高中物理学过的知识想象一下，动不了了给个动量他就能朝着预期方向继续前行

RMSProp优化器

在梯度下降中，很容易出现参数更新不稳定，也就是振荡很大的情况，RMSProp就是改进了这个问题，维护了一个梯度平方的“指数加权移动平均”，说的直白点，它可以自适应学习率，在剧烈变化的方向降低学习率

Adam优化器

Adam优化器是现在最流行的，它实际上是带动量动量的RMSProp

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


first_moment = 0 # 一阶矩初始化
second_moment = 0 # 二阶矩初始化为

for t in range(1, num_iterations):
 dx = compute_gradient(x) # 当前参数 x 的梯度
 first_moment = beta1 * first_moment + (1 - beta1) * dx # 动量，对梯度做指数平均让梯度更平滑
 second_moment = beta2 * second_moment + (1 - beta2) * dx * dx # RMSProp
 # 因为 m_0=0，所以前几步的 m_t 偏小，用 1 - β1^t 修正
 first_unbias = first_moment / (1 - beta1 ** t)
 second_unbias = second_moment / (1 - beta2 ** t)

 x -= learning_rate * first_unbias / (np.sqrt(second_unbias) + 1e

CS231 第二讲图像分类

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

开始学cs231n了，期望是一周3-4节，尽量4周完成掉

课程主页:https://cs231n.stanford.edu/

作业:https://cs231n.stanford.edu/schedule.html

图像分类

图像通常由数据矩阵定义，更一般地说是数据张量，识别图像对于机器来说是个很大的挑战，举个例子，人类不管从什么角度看一个物体他都是一样的，但是当一个摄像机对准一个物体并转动，像素值实时都在改变，除此之外，光照，物体遮挡等等对于图像的识别来说都是挑战

机器学习采用了数据驱动的方法：

收集图像及其标签的数据集
使用机器学习算法训练分类器
在新图像上评估分类器

下面是分别对应步骤2和3的接口

Nearest Neighbor Classifier

设定一个距离函数，对于一对图像（query data和training data），返回一个定义两者相似度的值

下面是两种常见的计算距离的方式

首先是L1距离，定义为两个图像所有像素差绝对值的总和

不过我们不难发现，训练函数是$O(1)$的，而预测函数是$O(n)$的，这并不是我们想要的

因此我们把Nearest Neighbor自然推广到k-Nearest Neighbor，k值该如何选择才比较合适，以及距离函数该如何选择，这两个量就被称作超参数，也就是需要决策的变量Ruhr设置超参数有很多办法，第一种方法是把部分训练数据作为验证集，在训练集上训练模型，然后通过验证集的效果来选择超参数，然后用超参数对测试集进行结果复现，并在测试集验证

更好的方法是用交叉验证设置超参数，把训练数据分成若干分区，然后每个分区轮流作为验证集，在一组数据上训练数据然后再下一组数据评估模型，迭代，最后取结果的评估值作为结果

在实际中，k Nearest Neighbor从来不用，首先因为效率太低，其次它的距离是按照每个像素点之间来计算的，因此很容易识别错误，例如把颜色相近的猫识别成老虎，亦或者当有物体遮挡的时候，你去计算他的L2距离是相等的，但是实际上差别却很大，最后，当数据的维度很大的时候，计算会非常的慢

线性分类器

线性分类器就是给定一张图片，转换成向量然后计算

$$ f(x,W)=Wx + b\tag{1} $$

这里输出结果是10维向量，然后根据分量决定图片属于哪一类

但是线性分类器并不是所有东西都能解决（就比如上图，根据结果图片是狗，😓），对于无法分类大量分离的数据实例就无法解决

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

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，），这个结果是个元组，这个一维数组为了保证和多维一样的格式，所以仍然被写成元组

矩阵乘法

不再赘述

Deep Learning on LunaTide's Blog

CS231 第六讲 CNN架构

CNN架构

常用的层

激活函数

残差网络

如何初始化各层的权重值

CS231 第五讲 基于CNN的图像分类

卷积神经网络

卷积层

池化层

CS231 第四讲 神经网络与反向传播

反向传播

CS231 第三讲 正则化与优化

损失函数

多类SVM损失

Softmax分类器

损失函数的正则化项

优化

梯度下降

随机梯度下降(SGD)

RMSProp优化器

Adam优化器

CS231 第二讲 图像分类

图像分类

Nearest Neighbor Classifier

线性分类器

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

参数的更新

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

计算图

用计算图求解

反向传播

加法节点的反向传播

乘法节点的反向传播

回到开头的例子

简单层的实现

乘法层的实现

加法层的实现

例子

激活函数层的实现

ReLU层

Sigmoid层

Affine/Softmax层的实现

Affine层

批版本的Affine层

Softmax-with-Loss层

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

从数据中学习

数据驱动

训练数据和测试数据

损失函数

均方误差

交叉熵误差

mini-batch学习

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

为什么要设定损失函数

梯度法

神经网络的梯度

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

3层神经网络的实现

符号确认

各层间信号传递的实现

代码总结

输出层的设计

恒等函数和softmax函数

实现softmax函数时的注意事项

softmax函数的特征

输出层的神经元数量

手写数字识别

MNIST数据集

从数据中学习

数据驱动

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

从感知机到神经网络

感知机回顾

激活函数引入

激活函数

sigmoid函数

阶跃函数的实现

CS231 第五讲基于CNN的图像分类

CS231 第四讲神经网络与反向传播

CS231 第三讲正则化与优化

CS231 第二讲图像分类