【Tensorflow学习二】神经网络优化方法学习率、激活函数、损失函数、正则化

文章目录

  • 预备知识
    • tf.where
    • tf.random.RandomState.rand() 返回一个[0,1)之间的随机数
    • np.vstack() 将数组按照垂直方向叠加
    • np.mgrid[ ] np.ravel( ) np.c_[ ] 一起使用可以生成网格坐标点
  • 复杂度、学习率
    • 复杂度
    • 指数衰减学习率
  • 激活函数
    • Sigmoid激活函数
    • Tanh激活函数
    • ReLu激活函数
    • Leaky ReLu激活函数
  • 损失函数
    • 均方误差
    • 交叉熵损失函数
    • 自定义损失函数
    • Softmax与交叉熵结合
  • 欠拟合与过拟合
    • 正则化缓解过拟合

预备知识

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

复杂度、学习率

复杂度

【Tensorflow学习二】神经网络优化方法学习率、激活函数、损失函数、正则化_第1张图片

指数衰减学习率

可以先用较大的学习率,快速得到最优解,然后逐步减小学习率,使得模型在训练后期稳定
指 数 衰 减 学 习 率 = 初 试 学 习 率 ∗ 学 习 率 衰 减 率 当 前 轮 数 / 多 少 轮 衰 减 一 次 指数衰减学习率=初试学习率*学习率衰减率^{当前轮数/多少轮衰减一次} =/
【Tensorflow学习二】神经网络优化方法学习率、激活函数、损失函数、正则化_第2张图片

激活函数

Sigmoid激活函数

【Tensorflow学习二】神经网络优化方法学习率、激活函数、损失函数、正则化_第3张图片

特点:

(1)容易造成梯度消失
(2)输出非0均值,收敛慢(我们希望输入每层神经网络的特征是以0为均值的小数值)
(3)幂运算复杂,训练时间长

Tanh激活函数

【Tensorflow学习二】神经网络优化方法学习率、激活函数、损失函数、正则化_第4张图片

特点:

(1)输出是0均值(由于sigmoid的地方)
(2)易造成梯度消失
(3)幂运算复杂,训练时间长

ReLu激活函数

【Tensorflow学习二】神经网络优化方法学习率、激活函数、损失函数、正则化_第5张图片

优点:

(1)解决了梯度消失问题(在正区间)
(2)只需要判断输入是否大于0,计算速度快
(3)收敛速度远快于Sigmoid和Tanh

缺点:

(1)输出非0均值,收敛慢
(2)Dead ReLu问题:某些神经元可能永远无法被激活,导致相应的参数无法被更新(可以改变随机初始化,避免过多的负数特征送入relu函数;可以设置更小的学习率,减小参数分布的巨大变化,避免训练中产生过多负数特征)

Leaky ReLu激活函数

【Tensorflow学习二】神经网络优化方法学习率、激活函数、损失函数、正则化_第6张图片

为了解决ReLu负区间为0,引起神经元死亡问题而设计的

Leaky ReLu在负区间引入了一个固定的斜率a,使得Leaky ReLu负区间不恒等于0

理论上来讲,Leaky ReLuReLu的所有优点,外加不会有Dead Relu问题,但是在实际操作当中,并没有完全证明Leaky ReLu总是好于ReLu

【Tensorflow学习二】神经网络优化方法学习率、激活函数、损失函数、正则化_第7张图片

损失函数

标签: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} mseMSE(y^,y)=ni=1n(yy^)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函数,再计算yy_的交叉熵损失函数

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)

欠拟合与过拟合

【Tensorflow学习二】神经网络优化方法学习率、激活函数、损失函数、正则化_第8张图片

欠拟合的解决方法:

增加输入特征项
增加网络参数
减少正则化参数

过拟合的解决方法:

数据清洗
增大训练集
采用正则化
增大正则化参数

正则化缓解过拟合

【Tensorflow学习二】神经网络优化方法学习率、激活函数、损失函数、正则化_第9张图片

tf.nn.l2_loss(w)

过拟合情况:

【Tensorflow学习二】神经网络优化方法学习率、激活函数、损失函数、正则化_第10张图片

正则化之后:

【Tensorflow学习二】神经网络优化方法学习率、激活函数、损失函数、正则化_第11张图片

曲线变得更为平缓,有效缓解了过拟合

下面为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])

你可能感兴趣的:(Tensorflow,神经网络,学习,numpy)