作者：Peter 编辑：Peter
本文给大家介绍深度学习神经网络中的基础知识：
数学和Python基础 在神经网络中，向量和矩阵是随处可见的。下面介绍基于numpy创建一维、二维和高维数组
向量（一维数组） 向量是同时拥有大小和方向 的量，向量可以表示成排成一排的数字集合。
In [1]:
import numpy as np In [2]:
# 创建行向量 print ("行向量：" ) print (row_vector) In [3]:
# 创建列向量 print ("列向量：" ) print (col_vector)矩阵（二维数组） 创建一个3乘3的矩阵：
In [4]:
# 创建一个3x3的矩阵 print ("原始矩阵：" )print (matrix)矩阵的相关计算操作：
In [5]:
# 1-计算矩阵的转置 print ("转置矩阵：" )print (transpose_matrix)也可以使用矩阵的T属性来实现转置：
In [6]:
matrix.T Out[6]:
array([[1, 4, 7], 下面介绍矩阵的逆的求解（只有方阵才有逆）：
已知，矩阵A，如果逆矩阵
并非所有的方阵都有逆矩阵；当方阵不可逆时，引入零矩阵的概念
In [7]:
# 2-计算矩阵的逆 print ("逆矩阵：" )print (inverse_matrix)矩阵A的行列式表示为|A|或det(A)：如果一个矩阵的行列式不为零，则该矩阵是可逆的；反之若行列式为0，则不可逆。
In [8]:
# 计算矩阵的行列式 print ("行列式：" )print (determinant)多维数组 将向量和矩阵扩展到N维，就是多维数组。
1、创建全0张量：
In [9]:
tensor = np.zeros((2, 3, 4, 4)) Out[9]:
array([[[[0., 0., 0., 0.], In [10]:
tensor.shape # 多维数组的形状 Out[10]:
(2, 3, 4, 4) In [11]:
tensor.size # 数组整体的元素个数 Out[11]:
96 In [12]:
tensor.ndim # 表示4个维度 Out[12]:
4 2、全1数组
In [13]:
tensor1 = np.ones((2,4,3)) Out[13]:
array([[[1., 1., 1.], In [14]:
tensor1.ndim # 表示4个维度 Out[14]:
3 3、自定义数组
In [15]:
tensor2 = np.arange(48) Out[15]:
array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, In [16]:
tensor2.ndim Out[16]:
1 实施形状shape的改变：
In [17]:
tensor2.reshape((2,8,3)) Out[17]:
array([[[ 0, 1, 2], In [18]:
# 效果同上：numpy会自动推断-1所在维度的数值 Out[18]:
array([[[ 0, 1, 2], numpy广播机制broadcast 在NumPy多维数组中，形状不同的数组之间也可以进行运算，看下面的例子：
In [19]:
A = np.array([[1,2,3], Out[19]:
array([[1, 2, 3], In [20]:
A * 100 Out[20]:
array([[100, 200, 300], 相当于是把100变成了[[100,100,100],[100,100,100]]，然后和数组A中对应位置上的元素相乘。
In [21]:
A + 200 Out[21]:
array([[201, 202, 203], 在加法上的广播机制：
In [22]:
A + [100,200,300] Out[22]:
array([[101, 202, 303], 乘积dot 向量的内积是一个具体的数值：
In [23]:
a = np.array([1,2,3]) In [24]:
a * b # 矩阵乘法 Out[24]:
array([ 4, 10, 18]) In [25]:
np.dot(a,b) # 4+10+18=32 Out[25]:
32 In [26]:
sum(a * b) # 矩阵乘法的结果就是乘积 Out[26]:
32 矩阵的内积：
In [27]:
c = np.array([[1,2],[3,4]]) In [28]:
c Out[28]:
array([[1, 2], In [29]:
d Out[29]:
array([[5, 6], In [30]:
np.dot(c,d) Out[30]:
array([[19, 22], 神经网络基础 基本原理 神经网络就是一个复杂的函数。函数是将某些输入转变某些输出的变换器，神经网络的功能也是类似：
表示输入层的数据，、
第一个隐藏神经元的结果可以表示为：
隐藏层的神经元是基于加权和计算出来的。
箭头上带有两个信息：权重w和偏置b；权重和神经元的值相乘再加上偏置，经过某个激活函数后的值作为下个神经元的输入
隐藏层实现 所有相邻神经元之间通过权重和偏置连接的网络也称之为全连接网络 。
4个隐藏神经元基于矩阵乘积的完整计算：
可以缩写为：
其中，
下面实现隐藏层的计算：
In [31]:
# 简单实现隐藏层的计算 # 会进行广播机制 Out[31]:
array([[-0.80051904, -0.98416179, 1.7341734 , -2.04167071], 激活函数 全连接层网络的变换是线性变换。使用激活函数能够赋予它“非线性”的效果。使用激活函数能够增强神经网络的表现力。
在这里介绍下常用的激活函数：
1、sigmoid函数
In [32]:
import numpy as np# 定义函数 return 1 / (1 + np.exp(-x))# x-y 'x' )'sigmoid(x)' )'Sigmoid Function' ) 2、relu激活函数：
In [33]:
import numpy as npreturn np.maximum(0, x)'x' )'ReLU(x)' )'ReLU Function' )
3、tanh函数：
In [34]:
import numpy as np# 定义Tanh函数 return np.tanh(x)# 生成x值 # 计算y值 # 绘制图像 'x' )'tanh(x)' )'Tanh Function' ) 神经网络加上sigmoid激活函数 In [35]:
def sigmoid(x):""" return 1 / (1 + np.exp(-x))print ("W1：\n" ,W1)print ("b1：\n" ,b1)print ("W1：\n" ,W2)print ("b1：\n" ,b2) 上面的例子中有10笔样本数据：、
、
In [36]:
h = np.dot(x,W1) + b1 # 隐藏神经元 # 对隐藏神经元使用激活函数 Out[36]:
array([[0.89036829, 0.68166094, 0.6709089 , 0.07559634], In [37]:
s = np.dot(a,W2) + b2 # 输出神经元 Out[37]:
array([[ 1.21123139, -1.89885556, 1.54047697], 用另一个全连接层来变换这个激活函数的输出
隐藏层有4个神经元，输出层有3个神经元，所以全连接层使用的权重矩阵的形状设置成
完整代码 整体的完整代码为：
In [38]:
# 神经网络 + sigmoid激活函数的完整代码 return 1 / (1+np.exp(-x))# 10*2 # 2*4 # 4表示隐藏神经元个数；2是和输入x的x.shape[1]相匹配 # 10*4；偏置必须为4 # 4*3 # 3个输出神经元个数；4个第一个隐藏神经元的shape[1] # # 10*3；偏置必须为3 Out[38]:
array([[ 1.52757614, -1.50378018, 0.69751311], 神经网络层的实现（类） 正向传播 正向传播（Forward Propagation）是指神经网络中的信息从输入层开始，经过各层神经元的处理后，最终到达输出层的过程。
在正向传播过程中，每一层的神经元将前一层的输出作为输入，经过内部的计算后，将结果传递给下一层。这个过程会一直持续到输出层，产生网络的最终输出。
正向传播过程中，神经元的输入和输出之间通过权重连接，并且会经过激活函数的非线性变换，使得网络可以学习和模拟复杂的非线性关系
反向传播 反向传播（Backpropagation）是一种优化算法，用于训练神经网络。
它是通过计算损失函数对神经网络参数的梯度来更新参数，从而最小化损失函数。在神经网络的训练过程中，反向传播算法通过对每个节点的输出误差进行反向传播，调整每个节点的权重，使得网络能够更准确地预测结果。
具体来说，首先给网络输入一组训练数据，并计算输出结果。然后计算输出结果与实际结果的差异，也就是网络的误差。接下来计算每个节点对误差的贡献，并将这些贡献反向传播到前一层。根据贡献的大小，调整每个节点的权重，使得误差减小。重复以上过程，直到误差达到一定程度为止。通过不断调整权重，反向传播算法能够使网络越来越准确地预测结果。
定义网络层 全连接层的变换相当于几何学领域的放射变换：Affine层 代码规范：
所有的层都使用forward()方法和backward()方法，分别代表正向传播和反向传播。 所有的层都使用params 和 grads实例变量；其中params使用列表保存权重和偏置参数（可能多个参数，用列表），grads以与params中的参数对应的形式。 Sigmoid层 定义激活函数的Sigmoid层：
In [39]:
import numpy as np# 没有学习的参数，使用空列表 return 1 / (1 + np.exp(-x)) Affine层 定义全连接层Affine：
In [40]:
class Affine:""" # 参数列表保存：W-权重 b-偏置 """ # 将参数列表进行赋给W和b # 实现前向传播功能 return out TwoLayerNet网络 In [41]:
class TwoLayerNet:""" # 连接输入层和隐藏层 # 权重和偏置项的初始值 # 连接隐藏层和输出层 # 定义层列表，包含全连接层1、激活层、全连接层2 # 将所有的权重整理到列表中 for layer in self.layers: # 循环每个层 # 权重参数放到列表params中 for layer in self.layers:# 对每个层使用forward的更新方法，最终输出Out return x 定义一个名为 TwoLayerNet 的类，表示一个包含两个隐藏层的神经网络。以下是对代码的详细解释：
第一层: 一个线性变换层 (通过 Affine 实现) 连接输入层和隐藏层。 第二层: 一个Sigmoid激活函数层 (通过 Sigmoid 实现)。 第三层: 一个线性变换层 (通过 Affine 实现) 连接隐藏层和输出层。 W1 和 b1 : 随机生成用于连接输入层和隐藏层的权重矩阵和偏置项。
W2 和 b2 : 随机生成用于连接隐藏层和输出层的权重矩阵和偏置项。
self.layers：定义了一个层列表，包含以下三层：
self.params : 用于存储所有的权重参数。
对每一层，使用其 forward 方法进行前向传播，更新 x 的值。 该网络没有包括偏置项的更新过程，所以偏置项只在前向传播中被使用，而在反向传播中不会被更新。
正向传播案例 In [42]:
x = np.random.randn(10,2) Out[42]:
array([[-0.11149934, 2.92086863, 0.02600311], 神经网络的学习 神经网络的过程一般是先进行学习，再利用好的参数进行推理。为了知道学习的效果如何，通常需要一个指标。这个指标一般称之为损失loss。
损失函数loss function（Softmax） 基于监督学习或者神经网络的预测结果，与实际结果之间差异程度。也就说将模型的恶劣程度作为标量值计算出来，得到的就是损失。
多类别分类问题中，通常使用的 交叉熵误差cross entropy 作为损失函数。
绘制softmax函数的图像：
In [43]:
import numpy as npreturn e_x / e_x.sum()# 生成输入数据 # 计算softmax值 # 绘制softmax曲线 'x' )'softmax(x)' )'Softmax Function' ) Softmax函数输出的各个元素是0.0~1.0的实数。如果将这些元素全部加起来，则和为1.因此，Softmax的输出可以解释为概率。之后这个概率被输入交叉熵误差中。交叉熵误差表示为：
在考虑了mini-batch处理的情况下，交叉熵误差可以表示为：
假设有N笔数据，
导数和梯度 导数 神经网络的学习的目标是找到损失尽可能小的参数组合。简单介绍下导数和梯度：
函数
关于
梯度 那么对所有x的导数为：
将L关于向量各个元素的导数罗列在一起，就得到了梯度gradient 。
矩阵求解梯度：
其中
具有相同的形状。
链式法则 学习阶段的神经网络在给定学习数据后会输出损失。当我们得到了损失关于各个参数的梯度，就可以利用这些梯度对参数对梯度进行更新。
如何求出神经网络的梯度？使用反向传播法 。理解反向传播法的关键是：链式法则。链式法则是复合函数的求导法则，其中复合函数是由多个函数构成的函数。
考虑两个函数：
MatMul层的实现 实现矩阵操作的层：
In [44]:
class MatMul:# 保存学习的参数，此时只有权重W # 梯度保存在grads # 前向传播 # 参数 # 输出 return out# 后向传播 # grads[0][...] 使用了省略号：可以固定Numpy数组的内存地址，覆盖Numpy数组的元素 # grads[0]=dW 浅复制 grads[0][...] = dW 深复制 # 实例变量grads中设置权重的梯度；grads列表中每个元素是Numpy数组 return dx 关于Numpy的[...]复制问题 案例 其实讨论的就是深浅复制的问题。
In [45]:
a = np.array([1, 2, 3]) In [46]:
print ("原始数据a的地址：" , id(a))print ("原始数据b的地址：" , id(b))In [47]:
a = b # 将b赋值给a； Out[47]:
array([4, 5, 6]) 再次查看a和b的内存地址：
In [48]:
print ("经过a=b后数据a的地址：" , id(a))print ("经过a=b后数据b的地址：" , id(b)) 可以看到a和b的内存地址是完全相同的。也就是收将b的引用赋值给a，此时a和b指向内存中的不同位置。
In [49]:
a = np.array([1, 2, 3]) In [50]:
print ("原始数据a的地址：" , id(a))print ("原始数据b的地址：" , id(b))In [51]:
a[...] = b # 赋值 In [52]:
print ("经过a[...]=b后数据a的地址：" , id(a))print ("经过a[...]=b后数据b的地址：" , id(b)) 可以看到a和b的内存地址是不同的；且a的地址还是赋值前的地址。
a[...]=b 表示的是原地修改数据：正在将数组b赋值为数组a，因为这是一个原地操作，所以a和b仍然指向同一个内存地址。
结论 在上面的例子中， a = b 是浅复制，而 a[...] = b 是深复制。
a = b 是浅复制，因为它创建了一个新的引用 a，指向与 b 相同的内存地址。此时，修改 b 的值也会影响 a，因为它们引用的是同一个对象。 a[...] = b 是深复制，因为它在原地修改了数组 a 的值 ，使其与数组 b 相等。这个操作不会影响数组 b 的内存地址，而只是将 b 的值复制到 a 中。因此，即使后续修改了 b 的值，也不会影响 a 的值 。 梯度的推导和反向传播实现 Sigmoid层 实现基于Sigmoid函数的前项传播和反向传播的过程：
In [53]:
class Sigmoid:# 保存参数和及其梯度 # 存储前项传播的结果 # 前向传播过程；经过Sigmoid函数进行输出 # sigmoid函数 # 保存输出out return out# 后项传播过程 # sigmoid的导数是y*(1-y) return dx # 返回梯度 Affine层 通过
In [54]:
class Affine:""" # 保存权重矩阵和偏置向量 # 初始化两个与权重矩阵和偏置向量形状相同的零梯度数组，保存在实例的grads属性中 """ # 从params属性中取出权重和偏置 # 前向输出：基于线性变换 # 将输入x保存在实例的x属性中 return out""" # 从params属性中取出权重和偏置 # 通过点乘计算梯度 # 计算关于权重矩阵的梯度 # 计算关于偏置向量的梯度 # 权重矩阵和梯度存储在实例的grads属性中 return dx 权重更新 通过误差反向传播法求出梯度后，就可以使用该梯度更新神经网络的参数。
步骤1：mini-batch
步骤2：计算梯度
基于误差反向传播法，计算损失函数关于各个权重参数的梯度 步骤3：更新参数
重复步骤1-2-3
这里说的梯度指向当前的权重参数所处位置中损失增加最多 的方向。通常将参数向该梯度的反方向进行更新，可以加速降低损失，这就是梯度下降法（gradient descent）。
下面介绍随机梯度下降法（Stochastic Gradient Descent, SGD）。随机 指的就是选择的数据（mini-batch）的梯度。
其中，
In [55]:
class SGD:# 学习率设置 for i in range(len(params)):# 参数更新 使用SGD类更新神经网络的参数（提供伪代码）
# 伪代码 for i in range(10000):
