预备知识

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]]

复杂度、学习率

复杂度

指数衰减学习率

可以先用较大的学习率，快速得到最优解，然后逐步减小学习率，使得模型在训练后期稳定
$$指数衰减学习率=初试学习率\ast 学习率衰减{率}^{当前轮数/多少轮衰减一次}$$

激活函数

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

均方误差

$$均方误差mse：MSE(\hat{y},y)=\frac{{\sum }_{i=1}^n(y-\hat{y}{)}^2}{n}$$

loss_mse=tf.reduce_mean(tf.square(y_-y))

交叉熵损失函数

$$H=-\sum ylog\hat{y}$$

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])