类似于高级三目运算符,若条件语句为真返回A,否则返回B
用法:
tf.where(条件语句,A,B)
代码示例:
a = tf.constant([1,2,3,1,1])
b = tf.constant([0,1,3,4,5])
c = tf.where(tf.greater(a,b), a, b)
print("c:", c)
运行结果
c: tf.Tensor([1 2 3 4 5], shape=(5,), dtype=int32)
按照给出的维度生成随机数矩阵
用法
np.random.RandomState.rand(维度)
代码示例
rdm = np.random.RandomState()
print(rdm.rand(2,3))
运行结果
[[0.18024415 0.14105498 0.23681506]
[0.46079149 0.13543915 0.02365349]]
将两个数组按照垂直方向叠加(有点升维的意思)
用法
np.vstack((数组1,数组2))
代码示例
a = np.array([1,2,3])
b = np.array([4,5,6])
c = np.array([7,8,9])
d = np.vstack((a,b,c))
print("d:\n", d)
运行结果
d:
[[1 2 3]
[4 5 6]
[7 8 9]]
np.mgrid[]根据所给条件生成具有“空间结构”的等差三维数组
ravel()将数组“拉直”,即将高维数组变成一维数组
np.c_[]将数组中的数据点配对生成数据点集合
根据合起来就是依据所给条件生成坐标点
用法
np.mgrid[起始值:结束值:步长, 起始值:结束值:步长, ...]
数组.ravel()
np.c_[数组1,数组2]
示例代码1
x, y, z = np.mgrid[1:3:1, 2:4:0.5, 5:7:1]
运行结果
x: array([[[1., 1.],
[1., 1.],
[1., 1.],
[1., 1.]],
[[2., 2.],
[2., 2.],
[2., 2.],
[2., 2.]]])
示例代码2
x, y, z = x.ravel(), y.ravel(), z.ravel()
array([1., 1., 1., 1., 1., 1., 1., 1., 2., 2., 2., 2., 2., 2., 2., 2.])
示例代码3
np.c_[x.ravel(),y.ravel(),z.ravel()]
运行结果
array([[1. , 2. , 5. ],
[1. , 2. , 6. ],
[1. , 2.5, 5. ],
[1. , 2.5, 6. ],
[1. , 3. , 5. ],
[1. , 3. , 6. ],
[1. , 3.5, 5. ],
[1. , 3.5, 6. ],
[2. , 2. , 5. ],
[2. , 2. , 6. ],
[2. , 2.5, 5. ],
[2. , 2.5, 6. ],
[2. , 3. , 5. ],
[2. , 3. , 6. ],
[2. , 3.5, 5. ],
[2. , 3.5, 6. ]])
神经网络复杂度分为两种,分别是空间复杂度和时间复杂度
主要有两个参数:层数和总参数。层数指隐藏层加输出层的层数;总参数指参数的总数,即w的总数加上b的总数
一般指乘加运算总数,等于w总数
学习率可以理解为向损失函数值减小的方向移动的速率*(好像有点绕)*,但下面的公式很好地解释了学习率的作用
w t + 1 = w t − l r ∗ ∂ l o s s ∂ w t {w_{t + 1}} = {w_t} - lr*\frac{{\partial loss}}{{\partial {w_t}}} wt+1=wt−lr∗∂wt∂loss
一般学习率设置的策略为先大后小,主要作用是首先快速趋近到较优解,然后减小学习率,使模型能够收敛到稳定解而非在稳定解附近左右横跳
激活函数的主要作用就是将原本线性输出的神经网络变成了非线性输出的神经网络,使得多层的神经网络有了意义——当激活函数非线性时,多层神经网络可以逼近所有函数。
优秀的激活函数有以下几个特点
常见激活函数
f ( x ) = 1 1 + e − x f(x) = \frac{1}{{1 + {e^{ - x}}}} f(x)=1+e−x1
特点:易造成梯度消失;输出非0均值,收敛慢;幂运算计算速度慢
f ( x ) = 1 − e − 2 x 1 + e − 2 x f(x) = \frac{1-{e^{-2x}}}{{1 + {e^{ -2x}}}} f(x)=1+e−2x1−e−2x
特点:易造成梯度消失;输出归一;幂运算计算速度慢
f ( x ) = { 0 x < 0 x x ≥ 0 f(x) = \left\{ \begin{array}{l} 0 \quad x < 0\\ x \quad x \ge 0 \end{array} \right. f(x)={0x<0xx≥0
特点:正区间无梯度消失问题;输出非0均值,收敛慢;简单,计算速度快;Dead Relu问题,某些神经元可能永远不会被激活,导致相应参数不能更新(可以通过改进随机初始化并减小学习率减少输入Relu的负数特征,也可以使用Leaky Relu)
损失函数(loss)主要作用是计算预测值(y)与已知答案(y_)的差距,而神经网络的优化目标就是使loss取值尽可能小,损失函数主要分为以下三类
M S E ( y _ , y ) = ∑ i = 1 n ( y − y _ ) n MSE({y_\_},y) = \frac{{\sum\nolimits_{i = 1}^n {{{(y - y_\_^{})}^{}}} }}{n} MSE(y_,y)=n∑i=1n(y−y_)
对异常值非常敏感,适用于回归问题
H ( y _ , y ) = − ∑ ( y _ ∗ l n y ) H(y_{\_},y)=-\sum(y_{\_}*lny) H(y_,y)=−∑(y_∗lny)
对正确值看重,适用于分类问题
自定义函数,较灵活
正则化在损失函数中引入模型复杂度指标,通过给w参数加权值,弱化了训练数据的噪声。实际上,正则化可以看作损失函数中的惩罚项
l o s s = l o s s ( y , y _ ) + R E G U L A R I Z E R ∗ l o s s ( w ) loss=loss(y,y_{\_})+REGULARIZER*loss(w) loss=loss(y,y_)+REGULARIZER∗loss(w)
公式中的REGULARIZER是调整正则化的超参数,从公式能直观的理解为消除较大的参数w,甚至使得部分参数变为0,可以降低模型复杂度
正则化主要分为两类,分类如下
大概率使很多参数变为0,更适用于特征选择,找出更关键的特征
l o s s L 1 ( w ) = ∑ i ∣ w i ∣ loss_{L1}(w)=\sum_i|w_i| lossL1(w)=i∑∣wi∣
作用:稀疏参数,降低复杂度;同时稀疏解,使得模型更具有“可解释性”;
使参数很接近零但不为零,
l o s s L 2 ( w ) = ∑ i ∣ w i 2 ∣ loss_{L2}(w)=\sum_i|{w_i}^2| lossL2(w)=i∑∣wi2∣
作用:通过减小参数值的大小降低网络复杂度;减小参数的大小使函数值的变化减小,缓解过拟合;
优化器就是引导神经网络更新参数的工具,优化器之间的区别实际上就是其中一阶动量和二阶动量之间的区别,常用的优化器有五种,此处列举基础的两种
一阶动量: m t = g t 二阶动量: v t = 1 下降梯度: η t = l r ∗ m t / v t 新参数: w t + 1 = w t − η t = m t − l r ∗ m t / v t 一阶动量: m_t=g_t\\ 二阶动量:v_t=1\\ 下降梯度:\eta_t=lr*m_t/{\sqrt{v_t}}\\ 新参数:w_{t+1}=w_t-\eta_t=m_t-lr*m_t/{\sqrt{v_t}} 一阶动量:mt=gt二阶动量:vt=1下降梯度:ηt=lr∗mt/vt新参数:wt+1=wt−ηt=mt−lr∗mt/vt
一阶动量: m t = β ∗ m t − 1 + ( 1 − β ) ∗ g t 二阶动量: v t = 1 下降梯度: η t = l r ∗ m t / v t = l r ∗ ( β ∗ m t − 1 + ( 1 − β ) ∗ g t ) 新参数: w t + 1 = w t − η t = w t − l r ∗ ( β ∗ m t − 1 + ( 1 − β ) ∗ g t ) 一阶动量: m_t = \beta * m_{t - 1} + (1 - \beta ) * {g_t}\\ 二阶动量:v_t=1\\ 下降梯度:\eta_t=lr*m_t/{\sqrt{v_t}}=lr*(\beta * m_{t - 1} + (1 - \beta ) * {g_t})\\ 新参数:w_{t+1}=w_t-\eta_t=w_t-lr*(\beta * m_{t - 1} + (1 - \beta ) * {g_t}) 一阶动量:mt=β∗mt−1+(1−β)∗gt二阶动量:vt=1下降梯度:ηt=lr∗mt/vt=lr∗(β∗mt−1+(1−β)∗gt)新参数:wt+1=wt−ηt=wt−lr∗(β∗mt−1+(1−β)∗gt)