文章目录
预备知识
tf.where
#条件语句真返回A，条件语句假返回B
#tf.where(条件语句,真返回A,假返回B)
import tensorflow as tf
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)#若a>b,返回a对应位置的元素，否则返回b对应位置的元素
print("c:",c)
>>>
c: tf.Tensor([1 2 3 4 5], shape=(5,), dtype=int32)
tf.random.RandomState.rand() 返回一个[0,1)之间的随机数
#返回一个[0,1)之间的随机数
#np.random.RandomState.rand(维度)#维度为空，返回标量
import numpy as np
rdm=np.random.RandomState(seed=1)#seed=常数，每次生成的随机数相同
a=rdm.rand()#返回一个随机标量
b=rdm.rand(2,3)#返回维度为2行3列的随机矩阵
print("a:",a)
print("b:",b)
>>>
a: 0.417022004702574
b: [[7.20324493e-01 1.14374817e-04 3.02332573e-01]
[1.46755891e-01 9.23385948e-02 1.86260211e-01]]
np.vstack() 将数组按照垂直方向叠加
import numpy as np
a=np.array([1,2,3])
b=np.array([4,5,6])
c=np.vstack((a,b))
print("c:\n",c)
>>>
c:
[[1 2 3]
[4 5 6]]
np.mgrid[ ] np.ravel( ) np.c_[ ] 一起使用可以生成网格坐标点
#np.mgrid[] np.ravel() np.c_[]一起使用可以生成网格坐标点
# np.mgrid[起始值:结束值:步长,起始值：步长,......]
# x.ravel()将x变为一维数组，“把.向量拉直”
# np.c_[数组1,数组2,...]
import numpy as np
x,y=np.mgrid[1:3:1,2:4:0.5]
grid=np.c_[x.ravel(),y.ravel()]
print("x:",x)
print("y:",y)
print("x.ravel():\n", x.ravel())
print("y.ravel():\n", y.ravel())
print("grid:\n",grid)
>>>
x: [[1. 1. 1. 1.]
[2. 2. 2. 2.]]
y: [[2. 2.5 3. 3.5]
[2. 2.5 3. 3.5]]
x.ravel():
[1. 1. 1. 1. 2. 2. 2. 2.]
y.ravel():
[2. 2.5 3. 3.5 2. 2.5 3. 3.5]
grid:
[[1. 2. ]
[1. 2.5]
[1. 3. ]
[1. 3.5]
[2. 2. ]
[2. 2.5]
[2. 3. ]
[2. 3.5]]
复杂度、学习率
复杂度
指数衰减学习率
可以先用较大的学习率，快速得到最优解，然后逐步减小学习率，使得模型在训练后期稳定
指
数
衰
减
学
习
率
=
初
试
学
习
率
∗
学
习
率
衰
减
率
当
前
轮
数
/
多
少
轮
衰
减
一
次
指数衰减学习率=初试学习率*学习率衰减率^{当前轮数/多少轮衰减一次}
指数衰减学习率=初试学习率∗学习率衰减率当前轮数/多少轮衰减一次
激活函数
Sigmoid激活函数
特点：
(1)容易造成梯度消失
(2)输出非0均值，收敛慢（我们希望输入每层神经网络的特征是以0为均值的小数值）
(3)幂运算复杂，训练时间长
Tanh激活函数
特点：
(1)输出是0均值(由于sigmoid的地方)
(2)易造成梯度消失
(3)幂运算复杂，训练时间长
ReLu激活函数
优点：
(1)解决了梯度消失问题(在正区间)
(2)只需要判断输入是否大于0，计算速度快
(3)收敛速度远快于Sigmoid和Tanh
缺点：
(1)输出非0均值，收敛慢
(2)Dead ReLu问题：某些神经元可能永远无法被激活，导致相应的参数无法被更新（可以改变随机初始化，避免过多的负数特征送入relu函数；可以设置更小的学习率，减小参数分布的巨大变化，避免训练中产生过多负数特征）
Leaky ReLu激活函数
为了解决ReLu负区间为0，引起神经元死亡问题而设计的
Leaky ReLu在负区间引入了一个固定的斜率a，使得Leaky ReLu负区间不恒等于0
理论上来讲，Leaky ReLu有ReLu的所有优点，外加不会有Dead Relu问题,但是在实际操作当中，并没有完全证明Leaky ReLu总是好于ReLu。
损失函数
标签：y_
预测：y
均方误差
均 方 误 差 m s e ： M S E ( y ^ , y ) = ∑ i = 1 n ( y − y ^ ) 2 n 均方误差mse：MSE(\hat{y},y)=\frac{\sum_{i=1}^{n}(y-\hat{y})^2}{n} 均方误差mse：MSE(y^,y)=n∑i=1n(y−y^)2
loss_mse=tf.reduce_mean(tf.square(y_-y))
交叉熵损失函数
H = − ∑ y l o g y ^ H=-\sum{}ylog\hat{y} H=−∑ylogy^
tf.losses.categorical_crossentropy(y_-y)
import tensorflow as tf
loss_ce1 = tf.losses.categorical_crossentropy([1, 0], [0.6, 0.4])
loss_ce2 = tf.losses.categorical_crossentropy([1, 0], [0.8, 0.2])
print("loss_ce1:", loss_ce1)
print("loss_ce2:", loss_ce2)
>>>
loss_ce1: tf.Tensor(0.5108256, shape=(), dtype=float32)
loss_ce2: tf.Tensor(0.22314353, shape=(), dtype=float32)
自定义损失函数
可以用tf.where构建损失函数
Softmax与交叉熵结合
分类问题中，输出先经过Softmax函数，再计算y与y_的交叉熵损失函数
Tensorflow提供一个函数，将两者结合
tf.nn.softmax_cross_entropy_with_logits(y_,y)
import tensorflow as tf
import numpy as np
y_ = np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1], [1, 0, 0], [0, 1, 0]])
y = np.array([[12, 3, 2], [3, 10, 1], [1, 2, 5], [4, 6.5, 1.2], [3, 6, 1]])
y_pro = tf.nn.softmax(y)
loss_ce1 = tf.losses.categorical_crossentropy(y_,y_pro)
loss_ce2 = tf.nn.softmax_cross_entropy_with_logits(y_, y)
print('分步计算的结果:\n', loss_ce1)
print('结合计算的结果:\n', loss_ce2)
>>>
分步计算的结果:
tf.Tensor(
[1.68795487e-04 1.03475622e-03 6.58839038e-02 2.58349207e+00
5.49852354e-02], shape=(5,), dtype=float64)
结合计算的结果:
tf.Tensor(
[1.68795487e-04 1.03475622e-03 6.58839038e-02 2.58349207e+00
5.49852354e-02], shape=(5,), dtype=float64)
欠拟合与过拟合
欠拟合的解决方法:
增加输入特征项
增加网络参数
减少正则化参数
过拟合的解决方法:
数据清洗
增大训练集
采用正则化
增大正则化参数
正则化缓解过拟合
tf.nn.l2_loss(w)
过拟合情况：
正则化之后：
曲线变得更为平缓，有效缓解了过拟合
下面为L2正则化的例子：
with tf.GradientTape() as tape: # 记录梯度信息
h1 = tf.matmul(x_train, w1) + b1 # 记录神经网络乘加运算
h1 = tf.nn.relu(h1)
y = tf.matmul(h1, w2) + b2
# 采用均方误差损失函数mse = mean(sum(y-out)^2)
loss_mse = tf.reduce_mean(tf.square(y_train - y))
# 添加l2正则化
loss_regularization = []
# tf.nn.l2_loss(w)=sum(w ** 2) / 2
loss_regularization.append(tf.nn.l2_loss(w1))
loss_regularization.append(tf.nn.l2_loss(w2))
# 求和
# 例：x=tf.constant(([1,1,1],[1,1,1]))
# tf.reduce_sum(x)
# >>>6
loss_regularization = tf.reduce_sum(loss_regularization)
loss = loss_mse + 0.03 * loss_regularization # REGULARIZER = 0.03
# 计算loss对各个参数的梯度
variables = [w1, b1, w2, b2]
grads = tape.gradient(loss, variables)
# 实现梯度更新
# w1 = w1 - lr * w1_grad
w1.assign_sub(lr * grads[0])
b1.assign_sub(lr * grads[1])
w2.assign_sub(lr * grads[2])
b2.assign_sub(lr * grads[3])