关键词：
深度学习入门-误差反向传播法
博主微信公众号（左）、Python+智能大数据+AI学习交流群（右）：欢迎关注和加群，大家一起学习交流，共同进步！
目录
摘要
- 通过使用计算图，可以直观地把握计算过程。
- 计算图的节点是由局部计算构成的。局部计算构成全局计算。
- 计算图的正向传播进行一般的计算。通过计算图的反向传播，可以计算各个节点的导数。
- 通过将神经网络的组成元素实现为层，可以高效地计算梯度（反向传播法）。
- 通过比较数值微分和误差反向传播法的结果，可以确认误差反向传播法的实现是否正确（梯度确认）。
1. 计算图
通过数值微分计算神经网络的权重参数的梯度（严格来说，是损失函数关于权重参数的梯度），优点：简单、容易实现；缺点：计算上比较费时。
计算图：将计算过程用数据结构图表示出来（通过多个节点和边表示，连接节点的直线称为 “边”）。
计算图通过节点和箭头表示计算过程。节点用 
表示， 中是计算的内容。将计算的中间结果写在箭头的上方，表示各个节点的计算结果从左向右传递。
1.1 用计算图求解
问题1：小明在当当商城买了 2 本书（《python深度学习入门》《python深度学习进阶》），每本书的价格都是 100 元，消费税是 10%，请计算支付金额。
题目计算图解析：
(1) 书的价格 100 元流到 "x2" 节点，变成 200 元，然后被传递给下一个节点；
(2) 这个 200 元流向 "x(1-10%)" 节点，变成 220 元。
题目计算图解析：
(1) 只用 表示乘法运算 "x"；
(2) 将 "2" 和 "(1-10%)" 分别作为变量 "数的数量"、"消费税" 标在 外面。
问题2：小明在当当商城买了 2 本书（《python深度学习入门》《python深度学习进阶》）、3 支钢笔，每本书的价格是 100 元，每只钢笔的价格是 10 元。消费税是 10%，请计算支付金额。
计算图解题流程：
1. 构建计算图。
2. 在计算图上，从左向右进行计算。
正向传播（forward propagation）：从计算图出发点到结束点的传播。
反向传播（backward propagation）：从计算图结束点点到出发点的传播。
1.2 局部计算
局部计算：无论全局发生了什么，都能只根据与自己相关的信息输出接下来的结果。
问题：小明在当当商城买了 2 本书（《python深度学习入门》《python深度学习进阶》）和其他很多东西，每本书的价格是 100 元，其他很多东西的总花费为 4000 元。消费税是 10%，请计算支付金额。
题目解析：
这里各个节点处的计算都是局部计算。例如 书 和 其他很多东西 的求和运算 (4000+200
4200) 并不关心 4000 这个数字是如何计算来的，只要把两个数字相加就可以了。
各个节点处只需进行与自己相关的计算，不用考虑全局。
总结：
1. 计算图可以集中精力于局部计算。无论全局的计算有多么复杂，各个步骤所要做的就是对象节点的局部计算。
2. 虽然局部计算非常简单，但是通过传递它的计算结果，可以获得全局的复杂计算的结果。
1.3 为何用计算图解题
计算图的优点：
1. 局部计算。无论全局是多么复杂的计算，都可以通过局部计算使各个节点致力于简单的计算，从而简化问题。
2. 利用计算图可以将中间的计算结果全部保存起来（比如，计算进行到 2 本书时的金额是 200 元、加上消费税之前的金额 230 元等）。
3. 可以通过正向传播和反向传播高效计算各个变量的导数值。
题目：假设书的价格为 
，支付金额为 
，求 
（当书的价格稍微变化时，支付金额会变化多少）。
通过计算图的反向传播求导数：
在这个例子中，反向传播从右向左（图中加粗的向左箭头）传递导数的值（11.12.2。
从这个结果中可知，“支付金额关于书的价格的导数” 的值是 2.2 元（严格地讲，如果输的价格增加或减少某个微小值，则最终的支付金额将增加或减少那个微小值的 2.2 倍）。
重点：计算中途求得的导数的结果（中间传递的导数）可以被共享，从而可以高效地计算多个导数。
2. 链式法则
反向传播将局部导数向正方向的反方向（从右到左）传递。这个局部导数的原理，是基于链式法则（chain rule）的。
2.1 计算图的反向传播
计算的反向传播如图 4-6 所示。
如图所示，反向传播的计算顺序是，将信号 E 乘以节点的局部导数 (
)，然后将结果传递给下一个节点。
这里所说的局部导数是指正向传播中 的导数，也就是 
关于 的导数 ()。
比如，假设 
，则局部导数为 
。把这个局部导数乘以上游传过来的值（本例中为
），然后再传递给前面的节点。
2.2 什么是链式法则
复合函数：由多个函数构成的函数。比如，
是由式 (4.1) 所示的两个式子构成的。
链式法则：链式法则是关于复合函数的导数的性质，定义如下。
如果某个函数由复合函数表示，则该复合函数的导数可以用构成复合函数的各个函数的导数的乘积表示。
以式 (4.1) 为例，
（
关于 的导数）可以用 
（ 关于 
的导数）和 
（ 关于 的导数）的乘积表示。用数学公式表示的话，可以写成式 (5.2)。
使用链式法则，求式 (4.1) 的导数 ：
2.3 链式法则的计算图
用 "**2" 节点表示平方运算， 将式 (4.4) 的链式法则的计算过程用计算图表示出来，计算图如图 4-7 所示。
如图所示，计算图的反向传播从右到左传播信号。
反向传播的计算顺序：
1. 先将节点的输入信号乘以节点的局部导数（偏导数）;
2. 传递给下一个节点。
比如，反向传播时，"**2" 节点的输入是
，将其乘以局部导数
观察图 4-7 最左边反向传播的结果。根据链式法则，
成立，对应 “ 关于 的导数”。也就是说，反向传播时基于链式法则的。
把 式(4.3) 的结果带入到 图 4-7 中，结果如图 5-8 所示， 的结果为 
。
3. 反向传播
3.1 加法节点的反向传播
题目： 以 
为对象，观察它的反向传播。
的导数可由下式（解析性地）计算出来。
用计算图表示加法节点的反向传播：
1. 加法节点的反向传播将上游的值原封不动地输出到下游。
2. 加法节点存在于某个最后输出的计算的一部分中。反向传播时，从最右边的输出出发，局部导数从节点向节点反方向传播。
3.2 乘法节点的反向传播
题目： 以 
为对象，观察它的反向传播。
的导数可由下式（解析性地）计算出来。
用计算图表示加法节点的反向传播：
1. 乘法节点的反向传播将上游的值乘以正向传播时的输入信号的 “翻转值” 后传递给下游。
2. 翻转值表示一种翻转关系，如图 4-12 所示，正向传播时信号是
3. 乘法节点的反向传播需要正向传播时的输入信号值。因此，实现乘法节点的反向传播时，要保存正向传播的输入信号。
3.3 当当商城购买书的例子
问题：求解 书的价格、书的数量、消费税 这 3 个变量各自如何影响最终的支付金额。（"支付金额关于书的价格的导数"、"支付金额关于书的数量的导数"、"支付金额关于消费税的导数"）
4. 简单层的实现
用 Python 代码实现前面当当商城购买书的例子。
4.1 乘法层的实现
"""
乘法层的实现
"""
class MulLayer(object):
def __init__(self):
"""初始化实例变量，用于保存正向传播时的输入值"""
self.x = None
self.y = None
def forward(self, x, y):
"""
正向传播
:param x:
:param y:
:return:
"""
self.x = x
self.y = y
out = x * y
return out
def backward(self, dout):
"""
反向传播
:param dout: 上游传来的导数
:return: 上游传来的导数与正向传播的翻转值的乘积
"""
dx = dout * self.y
dy = dout * self.x
return dx, dy
# 书的单价
book = 100
# 书的数量
book_num = 2
# 消费税
tax = 1.1
# 书的单价对应的乘法层
mul_book_layer = MulLayer()
# 消费税对应的乘法层
mul_tax_layer = MulLayer()
# forward
book_price = mul_book_layer.forward(book, book_num)
price = mul_tax_layer.forward(book_price, tax)
print(price) # 220.00000000000003
# backword
dprice = 1
dbook_price, dtax = mul_tax_layer.backward(dprice)
dbook, dboook_num = mul_book_layer.backward(dbook_price)
print(dbook, dboook_num, dtax) # 2.2 110.00000000000001 2004.2 加法层的实现
"""
乘法层和加法层的实现
"""
class MulLayer(object):
def __init__(self):
"""初始化实例变量，用于保存正向传播时的输入值"""
self.x = None
self.y = None
def forward(self, x, y):
"""
正向传播
:param x:
:param y:
:return:
"""
self.x = x
self.y = y
out = x * y
return out
def backward(self, dout):
"""
反向传播
:param dout: 上游传来的导数
:return: 上游传来的导数与正向传播的翻转值的乘积
"""
dx = dout * self.y
dy = dout * self.x
return dx, dy
class AddLayer(object):
def __init__(self):
pass
def forward(self, x, y):
"""
正向传播
:param x:
:param y:
:return:
"""
return x + y
def backward(self, dout):
"""
反向传播
:param dout: 上游传来的导数
:return: 上游传来的导数
"""
dx = dout * 1
dy = dout * 1
return dx, dy
book = 100 # 书的单价
book_num = 2 # 书的数量
pen = 10 # 钢笔价格
pen_num = 3 # 钢笔数量
tax = 1.1 # 消费税
# layer
mul_book_layer = MulLayer() # 书的单价对应的乘法层
mul_pen_layer = MulLayer() # 钢笔的单价对应的乘法层
add_book_pen_layer = AddLayer() # 书和钢笔金额相加和对应的加法层
mul_tax_layer = MulLayer() # 消费税对应的乘法层
# forward
book_price = mul_book_layer.forward(book, book_num)
pen_price = mul_pen_layer.forward(pen, pen_num)
all_price = add_book_pen_layer.forward(book_price, pen_price)
price = mul_tax_layer.forward(all_price, tax)
print(price) # 253.00000000000003
# backword
dprice = 1
dall_price, dtax = mul_tax_layer.backward(dprice)
dbook_price, dpen_price = add_book_pen_layer.backward(dall_price)
dbook, dboook_num = mul_book_layer.backward(dbook_price)
dpen, dpen_num = mul_pen_layer.backward(dpen_price)
# 2.2 110.00000000000001 3.3000000000000003 11.0 230
print(dbook, dboook_num, dpen, dpen_num, dtax) 5. 激活函数层的实现
5.1 ReLU 层
激活函数 ReLU（Rectified Linear Unit）由式 (4.7) 表示。
通过式 (4.7)，可以求出 关于 的导数，如式 (4.8) 所示。
1. 正向传播时的输入
2. 正向传播时的输入
ReLU 层的计算图：
Python 代码实现：
"""ReLU层"""
class Relu(object):
def __init__(self):
# 由True/False构成的NumPy数组
# 正向传播时的输入x的元素中小于等于0的地方保存为True，其他地方(大于0的元素)保存为False
self.mask = None
def forward(self, x):
"""
正向传播
:param x: 正向传播时的输入
:return:
"""
# 输入x的元素中小于等于0的地方保存为True，其他地方(大于0的元素)保存为False
self.mask = (x <= 0)
# 输入x的元素中小于等于0的值变换为0
out = x.copy()
out[self.mask] = 0
return out
def backword(self, dout):
"""
反向传播
:param dout: 上游传来的导数
:return:
"""
# 将从上游传来的dout的mask中的元素为True的地方设为0
dout[self.mask] = 0
dx = dout
return dx5.2 Sigmoid 层
Sigmoid 函数由式 (4.9) 表示。
用计算图表示式 (4.9)，如图 4-18 所示。
Sigmoid 层的反向传播：
步骤 1
“/” 节点表示 
，它的导数可以解析性地表示为下式。
根据式 (4.10)，反向传播时，会将上游的值乘以 
（正向传播的输出的平方乘以 -1 后的值）后，再传给下游。计算图如下所示。
步骤 2
“+” 节点将上游的值原封不动地传给下游。计算图如下图所示。
步骤 3
“exp” 节点表示 
，它的导数由下式表示。
计算图中，上游的值乘以正向传播时的输出（这个例子中是 exp(-x)）后，再传给下游。
步骤 4
“x” 节点将正向传播时的值翻转后做乘法运算。因此，这里要乘以 -1。
集约化的 “Sigmoid” 节点：
1. 简洁版的计算图可以省略反向传播中的计算过程，计算效率更高。
2. 通过对节点进行集约化，可以不用在意 Sigmoid 层中琐碎的细节，而只需要专注于它的输入和输出。
根据正向传播的输出 计算反向传播：
由于 
，则 
可以进一步调整如下。
Python 实现 Sigmoid 层：
"""Sigmoid层"""
import numpy as np
class Sigmoid(object):
def __init__(self):
self.out = None # 正向传播的输出
def forword(self, x):
"""
正向传播
:param x:
:return:
"""
out = 1 / (1 + np.exp(-x))
self.out = out
return out
def backword(self, dout):
"""
反向传播
:param dout: 上游传来的导数
:return:
"""
dx = dout * (1.0 - self.out) * self.out
return dx6. Affine/Softmax 层的实现
6.1 Affine 层
>>> import numpy as np
>>> X = np.random.rand(2) # 输入
>>> W = np.random.rand(2, 3) # 权重
>>> B = np.random.rand(3) # 偏置
>>>
>>> X.shape
(2,)
>>> W.shape
(2, 3)
>>> B.shape
(3,)
>>>
>>> Y = np.dot(X, W) + B
>>> Y
array([1.22628425, 1.34681801, 0.62003537])
>>> Y.shape
(3,)
神经网络的正向传播中进行的矩阵的乘积运算在几何学领域称为 “仿射变换”。因此，这里将进行仿射变换的处理实现为 “Affine” 层。
Affine 层的计算图：
乘积运算用 “dot” 节点表示，np.dot(X, W) + B 的运算的计算图如图 4-23 所示。
输入 X 的形状为 (2,)，权重 W 的形状为(2, 3)，X * W 的形状为 (3,)，偏置 B 的形状为 (3,)，输出 Y 的形状为 (3,)。
Affine 层的反向传播：
式 (4.13) 中 
的 
表示转置。转置操作会把 
的元素 
换成元素 
。用数学式表示的话，可以写成下面这样。
如式 (4.14) 所示，如果 的形状是 (2, 3)，则 的形状就是 (3,2)。
矩阵乘积（“dot” 节点）的反向传播推导：
观察图 4-24 的计算图中各个变量的形状，可以发现 
和 
形状相同， 和 
形状相同。
从下面的数学式可以很明确第看出 和 形状相同。
为什么要注意矩阵的形状呢？
因为矩阵的乘积运算要求对应维度的元素个数保持一致，通过确认一致性，就可以推导出式 (4.13)。比如，
的形状是 (3,)， 的形状是 (2, 3) 时，思考 和 的乘积，使得 的形状为 (2,)（图 4-25）。这样一来，就会自然地推导出式 (4.13)。
矩阵的乘积（“dot”节点）的反向传播可以通过组建使矩阵对应维度的元素个数一致的乘积运算而推导出来。
6.2 批版本的 Affine 层
批版本的 Affine 层的计算图：
Python 实现 Affine层：
"""Affine层"""
import numpy as np
class Affine:
def __init__(self, W, b):
self.W = W # 权重参数
self.b = b # 偏置参数
self.x = None # 输入
self.original_x_shape = None # 输入张量的形状
self.dW = None # 权重参数的导数
self.db = None # 偏置参数的导数
def forward(self, x):
"""
正向传播
:param x:
:return:
"""
# 对应张量
self.original_x_shape = x.shape
x = x.reshape(x.shape[0], -1)
self.x = x
out = np.dot(self.x, self.W) + self.b
return out
def backward(self, dout):
"""
反向传播
:param dout: 上游传来的导数
:return: 输入的导数
"""
dx = np.dot(dout, self.W.T)
self.dW = np.dot(self.x.T, dout)
self.db = np.sum(dout, axis=0)
dx = dx.reshape(*self.original_x_shape) # 还原输入数据的形状（对应张量）
return dx6.3 Softmax-with-Loss 层
Softmax 层将输入值正规化（将输出值的和调整为 1）之后再输出。
Softmax-with-Loss 层（Softmax 函数和交叉熵误差）的计算图：
1. 图 4-27 的计算图中，softmax 函数标记为 Softmax 层，交叉熵误差记为 Cross Entropy Error 层。这里假设要进行 3 类分类，从前面的层接收 3 个输入（得分）。
2. 如图 4-27 所示，Softmax 层将输入
正规化，输出
。Cross Entropy Error 层接收 Softmax 的输出
，从这些数据中输出损失
3. 图 4-27 中 Softmax 层的反向传播得到了
这样 “漂亮” 的结果（Softmax 层的输出和监督标签的差分）。神经网络的反向传播会把这个差分表示的误差传递给前面的层。
例 1：监督标签是 (0, 1, 0)，Softmax 层的输出是 (0.3, 0.2, 0.5)。因为正确解标签处的概率是 0.2(20%)，这个时候的神经网络未能正确识别。此时，Softmax 层的反向传播传递的是 (0.3, -0.8, 0.5) 这样一个大的误差。因为这个大的误差会向前面的层传播，所以 Softmax 层前面的层会从这个大的误差中学习到 “大” 的内容。
例 2：监督标签是 (0, 1, 0)，Softmax 层的输出是 (0.01, 0.99, 0)。这个神经网络识别的相当准确。此时，Softmax 层的反向传播传递的是 (0.01, -0.01, 0) 这样一个小的误差。这个小的误差会向前面的层传播，所以 Softmax 层前面的层学习到的内容也很 “小”。
Python 实现 Softmax-with-Loss 层：
"""Softmax-with-Loss层"""
import numpy as np
def softmax(x):
if x.ndim == 2:
x = x.T
x = x - np.max(x, axis=0)
y = np.exp(x) / np.sum(np.exp(x), axis=0)
return y.T
x = x - np.max(x) # 溢出对策
return np.exp(x) / np.sum(np.exp(x))
def cross_entropy_error(y, t):
if y.ndim == 1:
t = t.reshape(1, t.size)
y = y.reshape(1, y.size)
# 监督数据是one-hot-vector的情况下，转换为正确解标签的索引
if t.size == y.size:
t = t.argmax(axis=1)
batch_size = y.shape[0]
return -np.sum(np.log(y[np.arange(batch_size), t] + 1e-7)) / batch_size
class SoftmaxWithLoss(object):
def __init__(self):
self.loss = None # 损失
self.y = None # softmax 的输出
self.t = None # 监督数据(one-hot vector)
def forward(self, x, t):
"""
正向传播
:param x: 输入
:param t: 监督数据
:return:
"""
self.t = t
self.y = softmax(x)
self.loss = cross_entropy_error(self.y, self.t)
return self.loss
def backword(self, dout=1):
"""
反向传播
:param dout: 上游传来的导数
:return:
"""
batch_size = self.t.shape[0]
dx = (self.y - self.t) / batch_size # 单个数据的误差
return dx7. 误差反向传播法的实现
7.1 神经网络学习的全貌图
前提
神经网络中有合适的权重和偏置，调整权重和偏置以便拟合训练数据的过程称为学习。神经网络的学习分为下面 4 个步骤。
步骤 1 （mini-batch）
从训练数据中随机选择一部分数据。
步骤 2（计算梯度）
计算损失函数关于各个权重参数的梯度。
步骤 3 （更新参数）
将权重参数沿梯度方向进行微小的更新。
步骤 4（重复）
重复步骤 1、步骤 2、步骤 3。
7.2 对应误差反向传播法的神经网络的实现
代码详见章节 7.5。
7.3 误差反向传播法的梯度确认
梯度确认（gradient check）：确认数值微分求出的梯度结果和误差反向传播法求出的结果是否一致的操作称为梯度确认（gradient check）。深度学习入门2022最新版深度学习简介(代码片段)
...栏为2022版深度学习入门教程.学习此教程需要具备一定的Python基础 查看详情 摘要最近在学习ng的神经网络入门。先记录一笔，一些概念CNN(conventionalNeualNetwork)卷积神经网络RNN(Recurrentneuralnetwork)递归神经网络误差函数logisticregression求导正向传播、反向传播单层神经网络双层神经网络多层神经网络 查看详情 ...播就是不断地利用求导的链式法则进行展开的过程常用的深度学习框架中均不需要我们手动编码进行反向传播，只需要我们前向传播的tensor流动路径定义清楚，框架会自动帮我们计算梯度并反传更新权值我们只需要关心... 查看详情 目录1梯度下降算法2反向传播算法（BP算法）2.1前向传播与反向传播2.2链式法则2.3反向传播算法3梯度下降优化方法3.1动量算法（Momentum）3.2指数加权平均3.3动量梯度下降算法3.4AdaGrad3.5RMSprop3.6Adam4学习率退火4.1分段... 查看详情 终于明白了反向传播的意义。 核心要明白一个概念就是求导就是要通过构建的正向链，然后再通过反向链求导数值。 为什么要求导数值？因为要求最小值。求什么最小值？ 求的是损失函数的最小值，可以通过数... 查看详情 ...习入门-神经网络的学习博主微信公众号（左）、Python+智能大数据+AI学习交流群（右）：欢迎关注和加群，大家一起学习交流，共同进步！目录摘要1、从数据中学习1.1 数据驱动1.2 训练数据... 查看详情 第四章.误差反向传播法4.2ReLU/Sigmoid/Affine/Softmax-with-Loss层的实现1.ReLU层1).公式2).导数：3).计算图：4).实现：classReLU:def__init__(self):self.mask=None#正向传播defforward(self,x):self.mask=(x<=0)#输入值是否≤0，返回值是... 查看详情 《Python深度学习》第二章笔记1.第一个神经网络示例2.张量与张量运算张量（输入网络的数据存储对象）张量运算（层的组成要素）逐元素运算广播张量点积张量变形3.神经网络如何通过反向传播与梯度下降进行学... 查看详情 🚩前言本节以较简单的例子来理解矩阵乘法下的反向传播过程。为了稍微形象一些，这里同样会用到计算图来进行描述。矩阵乘法下的反向传播，其实和标量计算下的反向传播区别不大，只是我们的研究对象从标... 查看详情 ...向传播和计算图正向传播正向传播的计算图反向传播训练深度学习模型小结正向传播、反向传播和计算图前面几节里我们使用了小批量随机梯度下降的优化算法来训练模型。在实现中，我们只提供了模型的正向传播（forwa... 查看详情 最近在看深度学习的东西，一开始看的吴恩达的UFLDL教程，有中文版就直接看了，后来发现有些地方总是不是很明确，又去看英文版，然后又找了些资料看，才发现，中文版的译者在翻译的时候会对省略的公式推导过程进行... 查看详情 本文是深度学习入门：基于Python的实现、神经网络与深度学习（NNDL）以及动手学深度学习的读书笔记。本文将介绍基于Numpy的循环神经网络的前向传播和反向传播实现，包括RNN、LSTM和GRU。一、概述1.1循环神经网络（RNN）循环神... 查看详情 识别猫的项目神经网络训练步骤数据准备定义神经网络结构解析神经网络、初始化参数（w、b）输入数据，前向传播得到本轮迭代的损失值求最末层误差，反向传播计算各层梯度根据各层的w、b梯度，使用梯度... 查看详情 动态计算图计算图可以用来表示两个变量之间的关系。例如，构建y=x2y=x^2y=x2，则可用一张简单计算图进行表示。pytorch支持动态计算图，动态意义在于，当创建其它由计算图中变量而来的新变量时，新... 查看详情 作者主页：文火冰糖（王文兵）的博客_文火冰糖的硅基工坊_CSDN博客本文网址：https://blog.csdn.net/HiWangWenBing/article/details/120258939目录第1章数据流图与正向传播 1.1数据流图（包括原预测函数、正向传播、损失函... 查看详情 ...深入浅出地剖析了深度学习的原理和相关技术。书中使用Python3，尽量不依赖外部库或工具，从基本的数学知识出发，带领读者从零创建一个经典的深度学习网络，使读者在此过程中逐步理解深度学习。书中不仅介绍了深度学习... 查看详情 ...11108反向传播(BackPropagation，简称BP)算法在神经网络（甚至深度学习）参数训练中，BP算法占据举足轻重的地位。实际上BP算法是一个典型的双向算法，但通常强调的是反向传播。工作流程分两大步：正向传播输入信号，输出分类... 查看详情 神经网络反向传播首先理解一个基础前提，神经网络只是一个嵌套的，非线性函数（激活函数）复合线性函数的函数。对其优化，也同一般机器学习算法的目标函数优化一样，可以用梯度下降等算法对所有函数参数进行优化。但... 查看详情 深度学习入门（占坑）
深度学习基础入门
深度学习的损失函数优化方法(代码片段)
深度学习-反向传播(代码片段)
python深度学习入门-神经网络的学习(代码片段)
.误差反向传播法—relu/sigmoid/affine/softmax-with-loss层的实现(代码片段)
《python深度学习》第二章笔记(代码片段)
深度学习7-矩阵乘法运算的反向传播求梯度(代码片段)
深度学习正向传播反向传播和计算图（backprop）(代码片段)
一文弄懂神经网络中的反向传播法——backpropagation(代码片段)
深度学习基础-基于numpy的循环神经网络（rnn）实现和反向传播训练
深度学习项目拆解：识别猫的项目(代码片段)
深度学习基础：3.反向传播和梯度下降(代码片段)
[人工智能-深度学习-7]：数据流图正向传播导数梯度梯度下降法反向链式求导，非常非常重要！！！
有哪些python经典书籍
ai-深度学习之美十四章-概念摘要（8~14）(代码片段)
深度学习知识点查漏补缺（反向传播）