《TensorFlow实战Google深度学习框架(第2版)》4.深层神经网络

最新推荐文章于 2021-08-05 11:02:00 发布

su_n_y_

最新推荐文章于 2021-08-05 11:02:00 发布

阅读量194

点赞数

分类专栏：《TensorFlow实战Google深度学习框架(第2版)》

本文链接：https://blog.csdn.net/sunny1235435/article/details/97134567

版权

《TensorFlow实战Google深度学习框架(第2版)》专栏收录该内容

2 篇文章 0 订阅

订阅专栏

文章目录

深度学习与深层神经网络

深度学习的精确定义为“一类通过多层非线性变换对高复杂性数据建模算法的合集”。

激活函数去线性化：

ReLU: $f (x) = m a x (x, 0)$
sigmoid: $f(x)=\frac{1}{1+e^{-x}}$
tanh: $f(x)=\frac{1+e^{-2x}}{1+e^{-2x}}$

多层网络解决异或运算

损失函数的定义

分类

交叉熵：刻画了两个概率分布之间的距离，它是分类问题中使用比较广的一种损失函数。需要概率来计算。它刻画的是
通过概率分布q来表达概率分布p的困难程度
softmax回归本身可以作为一个学习算法来优化分类结果，但在TensorFlow 中，softmax回归的参数被去掉了，它只是一层额外的处理层，将神经网络的输出变成一个概率分布。
使用了Softmax回归之后的交叉熵：
cross_entropy= tf.nn.sparse_softmax_cross_entropy_with_logits(labels=y, logits=y)

回归

均方误差(MSE, mean squared error)
mse = tf.reduce_mean(tf.square(y_-y))

自定义损失函数

TensorFlow支持自定义损失函数

import tensorflow as tf
from numpy.random import RandomState

batch_size = 8

x = tf.placeholder(tf.float32, shape=(None, 2), name="x-input")
y_ = tf.placeholder(tf.float32, shape=(None, 1), name="y-input")

w1 = tf.Variable(tf.random_normal([2, 1], stddev=1, seed=1))
y = tf.matmul(x, w1)

# 自定义损失函数
loss_less = 10
loss_more = 1
loss = tf.reduce_sum(tf.where(tf.greater(y, y_), (y-y_)*loss_more, (y_-y)*loss_less))
train_step = tf.train.AdamOptimizer(0.001).minimize(loss)

rdm = RandomState(1)
dataset_size = 128
X = rdm.rand(dataset_size, 2)
Y = [[x1 + x2 + rdm.rand()/10.0 - 0.05] for (x1, x2) in X]

with tf.Session() as sess:
    init_op = tf.global_variables_initializer()
    sess.run(init_op)
    STEPS = 5000 # 训练轮数
    for i in range(STEPS):
        # 每次选取batch_size=8个样本进行训练。
        start = (i * batch_size) % dataset_size
        end = min(start + batch_size, dataset_size)
        sess.run(train_step, feed_dict={x: X[start:end], y_: Y[start:end]})
    print(sess.run(w1))

[[1.019347 ]
 [1.0428089]]

神经网络优化算法

《Learning representations by back-propagating errors》
梯度下降算法:不一定能达到全局最优,计算时间太长。
随机梯度下降算法：每次随机挑选一个
综合：每次选取一小部分数据"batch"

神经网络的进一步优化

学习率的设置

指数衰减法

# decayed_learning_rate = learning_rate * decay_rate ^ (global_step / decay_steps)
# decayed_learning_rate 为每一轮优化时使用的学习率
# learning_rate 为事先设定的初始学习率
# decay_rate 为衰减系数
# decay_steps 为衰减速度
#====================通过expinential_decay函数生成学习率
#learning_rate= tf.train.exponential_decay(0.1, global_step, 100, 0.96, staircase=True)
#训练100轮后学习率乘以0.96.

过拟合问题

所谓过拟合，指的是当一个模型过为复杂之后，它可以很好地“记忆”每一个训练数据中随机噪音的部分而忘记了要去“学习”训练数据中通用的趋势。
正则化：正则化的思想就是在损失函数中加入刻画模型复杂程度的指标
损失函数 $J(\theta)$ ,那么在优化时不是直接优化 $J(\theta)$ ,而是优化 $J(\theta)+\lambda R(w)$ .其中 $R (w)$ 刻画的是模型的复杂程度，而 $\lambda$ 表示模型复杂损失在总损失中的比例。基本的思想都是希望通过限制权重的大小，使得模型不能任意拟合训练数据中的随机噪音。
L1正则化：更稀疏 $R(w)=||w||_{1}=\sum_{i}|w_{i}|$
L2正则化： $R(w)=||w||_{2}^{2}=\sum_{i}|w_{i}^{2}|$

# 简单的带L2正则化的损失函数定义
# w = tf.Variable(tf.random_normal([2, 1], stddev=1, seed=1))
# y = tf.matmul(x, w)
# loss = tf.reduce_mean(tf.square(y_ - y)) +  \              # 均方误差损失函数
#         tf.contrib.layers.l2_regularizer(lambda)(w)       # 正则化

import tensorflow as tf
weights = tf.constant([[1.0, -2.0], [-3.0, 4.0]])
with tf.Session() as sess:
    print(sess.run(tf.contrib.layers.l1_regularizer(.5)(weights)))
    print(sess.run(tf.contrib.layers.l2_regularizer(.5)(weights)))

5.0
7.5

通过集合计算一个5层神经网络带L2正则化的损失函数的计算方法

import tensorflow as tf

# 获取一层神经网络边上的权重，并将这个权重的L2正则化损失加入名称为“losses”的集合中
def get_weight(shape, lambda1):
    var = tf.Variable(tf.random_normal(shape), dtype=tf.float32)
    tf.add_to_collection('losses', tf.contrib.layers.l2_regularizer(lambda1)(var))
    return var

x = tf.placeholder(tf.float32, shape=(None, 2))
y_ = tf.placeholder(tf.float32, shape=(None, 1))
batch_size = 8
# 定义每一层网络中节点的个数
layer_dimension = [2, 10, 10, 10, 1]
# 神经网络的层数
n_layers = len(layer_dimension)

# 这个变量维护前向传播时最深层的节点，开始的时候就是输入层
cur_layer = x
# 当前层的节点个数
in_dimension = layer_dimension[0]

# 循环生成网络结构
for i in range(1, n_layers):
    out_dimension = layer_dimension[i] # 下一层的节点个数
    # 当前层中权重的变量，并将这个变量的L2正则化损失加入计算图上的集合
    weight = get_weight([in_dimension, out_dimension], 0.001)
    bias = tf.Variable(tf.constant(0.1, shape=[out_dimension]))
    # 使用ReLU激活函数
    cur_layer = tf.nn.relu(tf.matmul(cur_layer, weight) + bias)
    # 进入下一层之前将下一层的节点个数更新为当前层节点个数
    in_dimension = layer_dimension[i]

# 在定义神经网络前向传播的同时已经将所有的L2正则化损失加入了图上的集合，
# 这里只需要计算刻画模型在训练数据上表现的损失函数。
mse_loss = tf.reduce_mean(tf.square(y_ - cur_layer))

# 将均方误差损失函数加入损失集合。
tf.add_to_collection("losses", mse_loss)

# get_collection返回一个列表，这个列表是所有这个集合中的元素。在这个样例中，
# 这些元素就是损失函数的不同部分，将它们加起来就可以得到最终的损失函数。
loss = tf.add_n(tf.get_collection("losses"))

例子

1. 生成模拟数据集。

import tensorflow as tf
import matplotlib.pyplot as plt
import numpy as np

data = []
label0 = []
np.random.seed(0)

# 以原点为圆心，半径为1的圆把散点划分成红蓝两部分，并加入随机噪音。
for i in range(150):
    x1 = np.random.uniform(-1, 1)
    x2 = np.random.uniform(0, 2)
    if x1**2 + x2**2 <= 1:
        data.append([np.random.normal(x1, 0.1),np.random.normal(x2, 0.1)])
        label0.append(0)
    else:
        data.append([np.random.normal(x1, 0.1), np.random.normal(x2, 0.1)])
        label0.append(1)
    
data = np.hstack(data).reshape(-1, 2)
plt.scatter(data[:, 0], data[:, 1], c=label0,
           cmap="RdBu", vmin=-0.2, vmax=1.2, edgecolor="white")
plt.show()
label = np.hstack(label0).reshape(-1, 1)

在这里插入图片描述

2. 定义一个获取权重，并自动加入正则项到损失的函数。

def get_weight(shape, lambda1):
    var = tf.Variable(tf.random_normal(shape), dtype=tf.float32)
    tf.add_to_collection('losses', tf.contrib.layers.l2_regularizer(lambda1)(var))
    return var

3. 定义神经网络。

x = tf.placeholder(tf.float32, shape=(None, 2))
y_ = tf.placeholder(tf.float32, shape=(None, 1))
sample_size = len(data)

# 每层节点的个数
layer_dimension = [2, 10, 5, 3, 1]

n_layers = len(layer_dimension)

cur_layer = x
in_dimension = layer_dimension[0]

# 循环生成网络结构
for i in range(1, n_layers):
    out_dimension = layer_dimension[i]
    weight = get_weight([in_dimension, out_dimension], 0.003)
    bias = tf.Variable(tf.constant(0.1, shape=[out_dimension]))
    cur_layer = tf.nn.relu(tf.matmul(cur_layer, weight) + bias)
    in_dimension = layer_dimension[i]

y= cur_layer

# 损失函数的定义。
mse_loss = tf.reduce_sum(tf.pow(y_ - y, 2)) / sample_size
tf.add_to_collection('losses', mse_loss)
loss = tf.add_n(tf.get_collection('losses'))

4. 训练不带正则项的损失函数mse_loss。

# 定义训练的目标函数mse_loss，训练次数及训练模型
train_op = tf.train.AdamOptimizer(0.001).minimize(mse_loss)
TRAINING_STEPS = 40000

with tf.Session() as sess:
    tf.global_variables_initializer().run()
    for i in range(TRAINING_STEPS):
        sess.run(train_op, feed_dict={x: data, y_: label})
        if i % 2000 == 0:
            print("After %d steps, mse_loss: %f" % (i,sess.run(mse_loss, feed_dict={x: data, y_: label})))

    # 画出训练后的分割曲线       
    xx, yy = np.mgrid[-1.2:1.2:.01, -0.2:2.2:.01]
    grid = np.c_[xx.ravel(), yy.ravel()]
    probs = sess.run(y, feed_dict={x:grid})
    probs = probs.reshape(xx.shape)

plt.scatter(data[:,0], data[:,1], c=label0,
           cmap="RdBu", vmin=-.2, vmax=1.2, edgecolor="white")
plt.contour(xx, yy, probs, levels=[.5], cmap="Greys", vmin=0, vmax=.1)
plt.show()

After 0 steps, mse_loss: 0.597972
After 2000 steps, mse_loss: 0.024146
After 4000 steps, mse_loss: 0.021657
After 6000 steps, mse_loss: 0.015733
After 8000 steps, mse_loss: 0.010555
After 10000 steps, mse_loss: 0.007910
After 12000 steps, mse_loss: 0.007517
After 14000 steps, mse_loss: 0.006668
After 16000 steps, mse_loss: 0.006667
After 18000 steps, mse_loss: 0.006667
After 20000 steps, mse_loss: 0.006667
After 22000 steps, mse_loss: 0.006667
After 24000 steps, mse_loss: 0.006667
After 26000 steps, mse_loss: 0.006667
After 28000 steps, mse_loss: 0.006667
After 30000 steps, mse_loss: 0.006667
After 32000 steps, mse_loss: 0.006667
After 34000 steps, mse_loss: 0.006667
After 36000 steps, mse_loss: 0.006667
After 38000 steps, mse_loss: 0.006667

在这里插入图片描述

5. 训练带正则项的损失函数loss。

# 定义训练的目标函数loss，训练次数及训练模型
train_op = tf.train.AdamOptimizer(0.001).minimize(loss)
TRAINING_STEPS = 40000

with tf.Session() as sess:
    tf.global_variables_initializer().run()
    for i in range(TRAINING_STEPS):
        sess.run(train_op, feed_dict={x: data, y_: label})
        if i % 2000 == 0:
            print("After %d steps, loss: %f" % (i, sess.run(loss, feed_dict={x: data, y_: label})))

    # 画出训练后的分割曲线       
    xx, yy = np.mgrid[-1:1:.01, 0:2:.01]
    grid = np.c_[xx.ravel(), yy.ravel()]
    probs = sess.run(y, feed_dict={x:grid})
    probs = probs.reshape(xx.shape)

plt.scatter(data[:,0], data[:,1], c=label0,
           cmap="RdBu", vmin=-0.2, vmax=1.2, edgecolor="white")
plt.contour(xx, yy, probs, levels=[0.5], cmap="Greys", vmin=0, vmax=.1)
plt.show()

After 0 steps, loss: 0.640029
After 2000 steps, loss: 0.048152
After 4000 steps, loss: 0.039120
After 6000 steps, loss: 0.038880
After 8000 steps, loss: 0.038837
After 10000 steps, loss: 0.038654
After 12000 steps, loss: 0.038642
After 14000 steps, loss: 0.038642
After 16000 steps, loss: 0.038645
After 18000 steps, loss: 0.038643
After 20000 steps, loss: 0.038642
After 22000 steps, loss: 0.038644
After 24000 steps, loss: 0.038644
After 26000 steps, loss: 0.038642
After 28000 steps, loss: 0.038642
After 30000 steps, loss: 0.038643
After 32000 steps, loss: 0.038644
After 34000 steps, loss: 0.038643
After 36000 steps, loss: 0.038644
After 38000 steps, loss: 0.038643

滑动平均模型

参考链接：https://blog.csdn.net/Sengo_GWU/article/details/80519250
在未知数据上更加健壮
tf.train.ExponentialMovingAverage来实现滑动平均模型

import tensorflow as tf
# 定义一个变量用于计算滑动平均，这个变量的初始值为0.
v1 = tf.Variable(0, dtype=tf.float32)
step = tf.Variable(0, trainable=False) # 模拟神经网络中迭代的轮数，可以用于动态控制衰减率

# 定义一个滑动平均的类，初始化时给定了衰减率为0.99和控制衰减率的变量step
ema = tf.train.ExponentialMovingAverage(0.99, step)
# 定义一个更新变量滑动平均的操作，每次执行这个操作时这个列表中的变量都会被更新
maintain_averages_op = ema.apply([v1])

with tf.Session() as sess:  
    # 初始化
    init_op = tf.global_variables_initializer()
    sess.run(init_op)
    print(sess.run([v1, ema.average(v1)]))
    
    # 更新变量v1的取值
    sess.run(tf.assign(v1, 5))
    # 更新v1的滑动平均值，衰减率为min{0.99,(1+step)/(10+step)=0.1}=0.1
    # v1的滑动平均会被更新为0.1*0+0.9*5=0.45
    sess.run(maintain_averages_op)
    print(sess.run([v1, ema.average(v1)]) )
    
    # 更新step和v1的取值
    sess.run(tf.assign(step, 10000))  
    sess.run(tf.assign(v1, 10))
    sess.run(maintain_averages_op)
    print(sess.run([v1, ema.average(v1)]))
    
    # 更新一次v1的滑动平均值
    sess.run(maintain_averages_op)
    print(sess.run([v1, ema.average(v1)]))

[0.0, 0.0]
[5.0, 4.5]
[10.0, 4.555]
[10.0, 4.60945]

su_n_y_

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
《TensorFlow实战Google深度学习框架(第2版)》4.深层神经网络

文章目录深度学习与深层神经网络激活函数去线性化：多层网络解决异或运算损失函数的定义分类回归自定义损失函数神经网络优化算法神经网络的进一步优化学习率的设置过拟合问题例子1. 生成模拟数据集。2. 定义一个获取权重，并自动加入正则项到损失的函数。3. 定义神经网络。4. 训练不带正则项的损失函数mse_loss。5. 训练带正则项的损失函数loss。滑动平均模型深度学习与深层神经网络深度学习的精确...
复制链接

扫一扫