Tensorflow笔记：神经网络优化

损失函数

损失函数用来表示预测值(y)与已知答案(y_)的差距。在训练神经网络时，通过不断改变神经网络中所有参数，使损失函数不断减小，从而训练出更高准确率的神经网络模型。常用的损失函数有均方误差、自定义和交叉熵等。

1.均方误差mse：n个样本的预测值y与已知答案y_之差的平方和，再求平均值。

在Tensorflow中用loss_mse=tf.reduce_mean(tf.square(y_-y))

例子：

预测酸奶日销量y，x1和x2是影响日销量的两个因素。

在本例中用销量预测产量，最优的产量应该等于销量。由于目前没有数据集，所以拟造了一套数据集。利用Tensorflow中函数随机生成x1、x2，制造标准答案y_=x1+x2，为了更真实，求和后还加了正负0.05的随机噪声。

#coding:utf-8
# 预测多或预测少的影响一样
# 0.导入模块，生成数据集
import tensorflow as tf
import numpy as np
BATCH_SIZE = 8
SEED = 23455rdm = np.random.RandomState(SEED)
X = rdm.rand(32,2)
Y_= [[x1+x2+(rdm.rand()/10.0-0.05)] for (x1, x2) in X]#　1.定义神经网络的输入、参数和输出，定义前向传播过程
x = tf.placeholder(tf.float32, shape=(None, 2))
y_= tf.placeholder(tf.float32, shape=(None, 1))
w1= tf.Variable(tf.random_normal([2, 1], stddev=1, seed=1))
y = tf.matmul(x, w1)# 2.定义损失函数及反向传播方法
# 定义损失函数为MSE，反向传播方法为梯度下降
loss_mse = tf.reduce_mean(tf.square(y_-y))
train_step = tf.train.GradientDescentOptimizer(0.001).minimize(loss_mse)# 3.生成会话，训练STEPS轮
with tf.Session() as sess:init_op = tf.global_variables_initializer()sess.run(init_op)STEPS = 20000for i in range(STEPS):start = (i*BATCH_SIZE) % 32end = (i*BATCH_SIZE) % 32 + BATCH_SIZEsess.run(train_step, feed_dict={x: X[start:end], y_: Y_[start:end]})if i % 500 ==0:print("After %d training steps, w1 is :" % (i))print(sess.run(w1), "\n")print("Final w1 is: \n",sess.run(w1))

运行结果如下：

After 19000 training steps, w1 is :
[[0.974931 ][1.0206276]] After 19500 training steps, w1 is :
[[0.9777026][1.0181949]] Final w1 is: [[0.98019385][1.0159807 ]]

销量预测结果为y=0.98*x1+1.02*x2。由于在生成数据集时，标准答案为y=x1+x2，因此，销量预测结果和标准答案已非常接近，说明该神经网络预测酸奶日销量正确。

2.自定义损失函数：根据问题的实际情况，定制合理的损失函数。

例子：

对于预测酸奶日销量问题，如果预测销量大于实际销量则会损失成本；如果预测销量小于实际销量则会损失利润。在实际生活中，往往制造一盒酸奶的成本和销售一盒酸奶的利润是不等价的。因此，需要使用符合该问题的自定义损失函数。

自定义损失函数为： $loss=\sum_{n}^{ }f(y_{-},y)$

其中，损失定义成分段函数：

$f(y_{-},y)=\left\{\begin{matrix} PROFIT*(y_{-}-y)...y<y_{-}\\COST*(y-y_{-})...y>=y_{-} \end{matrix}\right.$

用Tensorflow函数表示为：loss=tf.reduce_sum(tf.where(tf.greater(y,y_),COST*(y,y_),PROFIT(y_-y)))

（1）若酸奶成本为1元，酸奶销售利润为9元，则制造成本小于酸奶利润，因此希望预测的结果y多一些。

#coding:utf-8
# 酸奶成本1元，酸奶利润9元
# 预测少了损失大，故不要预测少，故生成的模型会多预测一些
# 0.导入模块，生成数据集
import tensorflow as tf
import numpy as np
BATCH_SIZE = 8
SEED = 23455
COST = 1
PROFIT = 9rdm = np.random.RandomState(SEED)
X = rdm.rand(32,2)
Y = [[x1+x2+(rdm.rand()/10.0-0.05)] for (x1, x2) in X]# 1.定义神经网络的输入、参数和输出，定义前向传播过程
x = tf.placeholder(tf.float32, shape=(None, 2))
y_= tf.placeholder(tf.float32, shape=(None, 1))
w1= tf.Variable(tf.random_normal([2, 1], stddev=1, seed=1))
y = tf.matmul(x, w1)# 2.定义损失函数及反向传播方法
#　定义损失函数使得预测少了的损失大，于是模型应该偏向多的方向预测
loss = tf.reduce_sum(tf.where(tf.greater(y, y_), (y - y_)*COST, (y_-y)*PROFIT))
train_step = tf.train.GradientDescentOptimizer(0.001).minimize(loss)with tf.Session() as sess:init_op = tf.global_variables_initializer()sess.run(init_op)STEPS = 20000for i in range(STEPS):start = (i*BATCH_SIZE) % 32end = (i*BATCH_SIZE) % 32 + BATCH_SIZEsess.run(train_step, feed_dict={x: X[start:end], y_: Y[start:end]})if i % 500 == 0:print("After %d training steps, w1 is :" % (i))print(sess.run(w1), "\n")print("FInal w1 is: \n",sess.run(w1))

运行结果如下：

After 2000 training steps, w1 is :
[[1.0179386][1.0412899]] After 2500 training steps, w1 is :
[[1.0205938][1.0390677]] FInal w1 is: [[1.0296593][1.0484432]]

由代码执行结果可知，神经网络最终参数为w1=1.03，w2=1.05，销量预测结果为y=1.03*x1+1.05*x2。由此可见，采用自定义损失函数预测的结果大于采用均方误差预测的结果，更符合实际需求。

（2）若酸奶成本为9元，酸奶销售利润为1元，则制造成本大于酸奶利润，因此希望预测结果y小一些。

#coding:utf-8
# 酸奶成本9元，酸奶利润1元
# 预测多了损失大，故不要预测多，故生成的模型会少预测一些
# 0.导入模块，生成数据集
import tensorflow as tf
import numpy as np
BATCH_SIZE = 8
SEED = 23455
COST = 9
PROFIT = 1rdm = np.random.RandomState(SEED)
X = rdm.rand(32,2)
Y = [[x1+x2+(rdm.rand()/10.0-0.05)] for (x1, x2) in X]# 1.定义神经网络的输入、参数和输出，定义前向传播过程
x = tf.placeholder(tf.float32, shape=(None, 2))
y_= tf.placeholder(tf.float32, shape=(None, 1))
w1= tf.Variable(tf.random_normal([2, 1], stddev=1, seed=1))
y = tf.matmul(x, w1)# 2.定义损失函数及反向传播方法
# 重新定义损失函数，使得预测多了的损失大，于是模型应该偏向少的方向预测
loss = tf.reduce_sum(tf.where(tf.greater(y, y_), (y - y_)*COST, (y_ - y)*PROFIT))
train_step = tf.train.GradientDescentOptimizer(0.001).minimize(loss)with tf.Session() as sess:init_op = tf.global_variables_initializer()sess.run(init_op)STEPS = 20000for i in range(STEPS):start = (i*BATCH_SIZE) % 32end = (i*BATCH_SIZE) % 32 + BATCH_SIZEsess.run(train_step, feed_dict={x: X[start:end], y_: Y[start:end]})if i % 500 == 0:print("After %d training steps, w1 is :" % (i))print(sess.run(w1), "\n")print("Final w1 is: \n",sess.run(w1))

运行结果如下：

After 2000 training steps, w1 is :
[[0.9602475][0.9742084]] After 2500 training steps, w1 is :
[[0.96100295][0.96993417]] Final w1 is: [[0.9600407 ][0.97334176]]

由执行结果可知，神经网络最终参数为w1=0.96，w2=0.97，销量预测结果为y=0.96*x1+0.97*x2。因此，采用自定义损失函数预测的结果小于采用均方误差预测的结果，更符合实际需求。

3.交叉熵：表示两个概率分布之间的距离。交叉熵越大，两个概率分布距离越远，两个概率分布越相异；交叉熵越小，两个概率分布距离越近，两个概率分布越相似。

计算公式： $H(y_{-},y)=-\sum y_{-}*logy$

用Tensorflow函数表示为：ce=-tf.reduce_mean(y_*tf.log(tf.clip_by_value(y,1e-12,1.0)))

softmax函数：将n分类的n个输出(y1,y2...yn)变为满足以下概率分布要求的函数。

$\forall x...P(X=x)\epsilon [0,1]and\sum P_{x}(X=x)=1$

softmax函数表示为： $softmax(y_{i})=\frac{e^{yi}}{\sum_{j=1}^{n}e^{yi}}$

在Tensorflow中，一般让模型的输出经过softmax函数，以获得输出分类的概率分布，再与标准答案对比，求出交叉熵，得到损失函数，用如下函数实现：

ce=tf.nn.sparse_cross_entropy_with_logits(logits=y,labels=tf.argmax(y_,1))

cem=tf.reduce_mean(ce)

学习率

1.学习率learning_rate：表示了每次参数更新的幅度大小。学习率过大，会导致待优化的参数在最小值附近波动，不收敛；学习率过小，会导致待优化的参数收敛缓慢。

参数的更新公式为： $w_{n+1}=w_{n}-learning_{-}rate\bigtriangledown$

假如损失函数为 $loss=(w+1)^{2}$ 。梯度是损失函数loss的导数为 $\bigtriangledown =2w+2$ ，参数初值为5，学习率为0.2。则损失函数loss的最小值会在(-1,0)处得到，此时损失函数的导数为0，得到最终参数w=-1

#coding:utf-8
# 设损失函数loss=(w+1)^2，令w初值是常数5。反向传播就是求最优w，即求最小loss对应的w值
import tensorflow as tf
# 定义待优化参数w初值赋5
w = tf.Variable(tf.constant(5, dtype=tf.float32))
# 定义损失函数loss
loss = tf.square(w+1)
# 定义反向传播方法
train_step = tf.train.GradientDescentOptimizer(0.2).minimize(loss)
# 生成会话，训练40轮
with tf.Session() as sess:init_op = tf.global_variables_initializer()sess.run(init_op)for i in range(40):sess.run(train_step)w_val = sess.run(w)loss_val = sess.run(loss)print("After %s steps: w is %f, loss is %f." % (i, w_val, loss_val))

运行结果如下：

After 30 steps: w is -0.999999, loss is 0.000000.
After 31 steps: w is -1.000000, loss is 0.000000.
After 32 steps: w is -1.000000, loss is 0.000000.
After 33 steps: w is -1.000000, loss is 0.000000.
After 34 steps: w is -1.000000, loss is 0.000000.
After 35 steps: w is -1.000000, loss is 0.000000.
After 36 steps: w is -1.000000, loss is 0.000000.
After 37 steps: w is -1.000000, loss is 0.000000.
After 38 steps: w is -1.000000, loss is 0.000000.
After 39 steps: w is -1.000000, loss is 0.000000.

由结果可知，随着损失函数值的减小，w无限趋近于-1，模型计算推测出最优参数w=-1。

学习率的设置：学习率过大，会导致待优化的参数在最小值附近波动，不收敛；学习率过小，会导致待优化的参数收敛缓慢。

2.指数衰减学习率：学习率随着训练轮数变化而动态更新

学习率计算公式如下：

$Learning_{-}rate=LEARNING_{-}RATE_{-}BASE*LEARNING_{-}RATE_{-}DECAY*\frac{global_{-}step}{LEARNING_{-}RATE_{-}BATCH_{-}SIZE}$

用Tensorflow的函数表示为：

global_step=tf.Variable(0,trainable=False)

learning_rate=tf.train.exponential_decay(

LEARNING_RATE_BASE,

global_step,

LEARNING_RATE_STEP,

LEARNING_RATE_DECAY,

staircase=True/False)

其中，LEARNING_RATE_BASE为学习率初始值，LEARNING_RATE_DECAY为学习率衰减率，global_step记录了当前训练轮数，为不可训练型参数。学习率learning_rate更新频率为输入数据集总样本数除以每次喂入样本数。若staircase设置为 True 时,表示global_step/learning rate step取整数，学习率阶梯型衰减；若 staircase 设置为 false 时，学习率会是一条平滑下降的曲线。

在本例中，模型训练过程不设定固定的学习率，使用指数衰减学习率进行训练。其中，学习率初值设置为0.1，学习率衰减率设置为0.99，BATCH_SIZE设置为1。

#coding:utf-8
# 设损失函数loss=(w+1)^2，令w初值是常数10。反向传播就是求最优w，即求最小loss对应的w值。
# 使用指数衰减的学习率，在迭代初期得到较高的下降速度，可以在较小的训练轮数下取得更有收敛度。
import tensorflow as tfLEARNING_RATE_BASE = 0.1  # 最初学习率
LEARNING_RATE_DECAY = 0.99  #　学习率衰减率
LEARNING_RATE_STEP = 1  # 喂入多少轮BATCH_SIZE后，更新一次学习率，一般设为：总样本数/BATCH_SIZE# 运行了几轮BATCH_SIZE的计数器，初值为0，设为不被训练
global_step = tf.Variable(0, trainable=False)
# 定义指数下降学习率
learning_rate = tf.train.exponential_decay(LEARNING_RATE_BASE, global_step, LEARNING_RATE_STEP, LEARNING_RATE_DECAY, staircase=True)
# 定义待优化参数，初值给10
w = tf.Variable(tf.constant(5, dtype=tf.float32))
# 定义损失函数loss
loss = tf.square(w+1)
# 定义反向传播方法
train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss, global_step=global_step)
#生成会话，训练40轮
with tf.Session() as sess:init_op = tf.global_variables_initializer()sess.run(init_op)for i in range(40):sess.run(train_step)learning_rate_val = sess.run(learning_rate)global_step_val = sess.run(global_step)w_val = sess.run(w)loss_val = sess.run(loss)print("After %s steps: global_step is %f, w is %f,learning rate is %f, loss is %f." % (i, global_step_val, w_val, learning_rate_val, loss_val))

运行结果如下：

After 35 steps: global_step is 36.000000, w is -0.992297,learning rate is 0.069641, loss is 0.000059.
After 36 steps: global_step is 37.000000, w is -0.993369,learning rate is 0.068945, loss is 0.000044.
After 37 steps: global_step is 38.000000, w is -0.994284,learning rate is 0.068255, loss is 0.000033.
After 38 steps: global_step is 39.000000, w is -0.995064,learning rate is 0.067573, loss is 0.000024.
After 39 steps: global_step is 40.000000, w is -0.995731,learning rate is 0.066897, loss is 0.000018.

由此看出，随着训练轮数增加学习率在不断减小。

滑动平均

滑动平均：记录了一段时间内模型中所有参数w和b各自的平均值。利用滑动平均值可以增强模型的泛化能力。

用Tensorflow函数表示为：

ema=tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY,global_step)

其中，MOVING_AVERAGE_DECAY表示滑动平均衰减率，一般会赋接近1的值，global_step表示当前训练了多少轮。

ema_op=ema.apply(tf.trainable_variables())

其中，ema.apply()函数实现对括号内参数求滑动平均，tf.trainable_variables()函数实现把所有待训练参数汇总为列表。

with tf.control_dependencies([train_step,ema_op]):

train_op=tf.no_op(name='train')

其中，该函数实现将滑动平均和训练过程同步运行。

在神经网络模型中，将MOVING_AVERAGE_DECAY设置为0.99，参数w1设置为0，w1的滑动平均值设置为0

#coding:utf-8
import tensorflow as tf# 1.定义变量及滑动平均类
# 定义一个32位浮点变量，初始值为0.0，这个代码就是不断更新w1参数，优化w1参数，滑动平均做了个w1的影子
w1 = tf.Variable(0, dtype=tf.float32)
# 定义num_updates(NN的迭代轮数)，初始值为0，不可被优化（训练），这个参数不训练
global_step = tf.Variable(0, trainable=False)
# 实例化滑动平均类，给衰减率为0.99，当前轮数global_step
MOVING_AVERAGE_DECAY = 0.99
ema = tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY, global_step)
# ema.apply后的括号里是更新列表，每次运行sess.run(ema_op)时，对更新列表中的元素求滑动平均值。
# 在实际应用中会使用tf.trainable_variables()自动将所有待训练的参数汇总为列表
# ema_op=ema.apply([w1])
ema_op = ema.apply(tf.trainable_variables())# 2.查看不同迭代中变量取值的变化
with tf.Session() as sess:# 初始化init_op = tf.global_variables_initializer()sess.run(init_op)# 用ema.average(w1)获取w1滑动平均值（要运行多个节点，作为列表中的元素列出，写在sess.run中）# 打印出当前参数w1和w1滑动平均值print(sess.run([w1, ema.average(w1)]))# 参数w1的值赋为1sess.run(tf.assign(w1, 1))sess.run(ema_op)print(sess.run([w1, ema.average(w1)]))# 更新step和w1的值，模拟出100轮迭代后，参数w1变为10sess.run(tf.assign(global_step, 100))sess.run(tf.assign(w1, 10))sess.run(ema_op)print(sess.run([w1, ema.average(w1)]))# 每次sess.run会更新一次w1的滑动平均值sess.run(ema_op)print(sess.run([w1, ema.average(w1)]))sess.run(ema_op)print(sess.run([w1, ema.average(w1)]))

运行结果如下：

[0.0, 0.0]
[1.0, 0.9]
[10.0, 1.6445453]
[10.0, 2.3281732]
[10.0, 2.955868]

从运行结果可知，最初参数w1和滑动平均值都是0；参数w1设定为1后，滑动平均值变为0.9；当迭代轮数更新为 100 轮时，参数w1更新为10后，滑动平均值变为1.644。随后每执行一次，参数w1的滑动平均值都向参数w1靠近。可见，滑动平均值随参数的变化而变化。

正则化

过拟合：神经网络模型在训练数据集上的准确率较高，在新的数据进行预测或分类时准确率较低，说明模型的泛化能力差。

正则化：在损失函数中给每个参数w加上权重，引入模型复杂度指标，从而抑制模型噪声，减小过拟合。

使用正则化后，损失函数loss变为两项之和：loss=loss(y与y_)+REGULARIZER*loss(w)

正则化计算方法：

（1）L1正则化： $loss_{L1}=\sum_{i}^{ }\left | w_{i} \right |$

用Tensorflow函数表示：loss(w)=tf.contrib.layers.l1_regularizer(REGULARIZER)(w)

（2）L2正则化： $loss_{L2}=\sum_{i}^{ }\left | w_{i} \right |^{2}$

用Tensorflow函数表示：loss(w)=tf.contrib.layers.l2_regularizer(REGULARIZER)(w)

用Tensorflow函数实现正则化：

tf.add_to_collection('losses',tf.contrib.layers.l2_regularizer(regularizer)(w)

loss=cem+tf.add_n(tf.get_collection('losses')

搭建模块化神经网络八股

1.前向传播：由输入到输出，搭建完整的网络结构。

描述前向传播的过程需要定义三个函数：

def forward(x,regularizer):

return y

第一个函数 forward()完成网络结构的设计，从输入到输出搭建完整的网络结构，实现前向传播过程。该函数中，参数 x 为输入，regularizer 为正则化权重，返回值为预测或分类结果 y。

def get_weight(shape,regularizer):

w=tf.Variable()

tf.add_to_collection('losses',tf.contrib.layers.l2_regularizer(regularizer)(w))

return w

第二个函数 get_weight()对参数 w 设定。该函数中，参数 shape 表示参数 w 的形状，regularizer表示正则化权重，返回值为参数 w。其中，tf.variable()给 w 赋初值，tf.add_to_collection()表示将参数 w 正则化损失加到总损失 losses 中。

def get_bias(shape):

b=tf.Variable()

return b

第三个函数 get_bias()对参数 b 进行设定。该函数中，参数 shape 表示参数 b 的形状，返回值为参数b。其中，tf.variable()表示给 b 赋初值。

2.反向传播：训练网络，优化网络参数，提高模型准确性。

def backward():

x=tf.placeholder()

y_=tf.placeholder()

y=forward.forward(x,REGULARIZER)

global_step=tf.Variable(0,trainable=False)

loss=

函数 backward()中，placeholder()实现对数据集 x 和标准答案 y_占位， forward.forward()实现前向传播的网络结构，参数 global_step 表示训练轮数，设置为不可训练型参数。

在训练网络模型时，常将正则化、指数衰减学习率和滑动平均这三个方法作为模型优化方法。

3.正则化：

首先，计算预测结果与标准答案的损失值：

（1）MSE：y与y_的差距(loss_mse)=tf.reduce_mean(tf.square(y-y_))

（2）交叉熵：ce=tf.nn.sparse_softmax_cross_entropy_with_logits(logits=y,labels=tf.argmax(y_,1))

y与y_的差距(cem)=tf.reduce_mean(ce)

（3）自定义：y与y_的差距

其次，总损失值为预测结果与标准答案的损失值加上正则化项

loss=y与y_的差距+tf.add_n(tf.get_collection('losses'))

4.指数衰减学习率：

learning_rate=tf.train.exponential_decay(

LEARNING_RATE_BASE,

global_step,

数据集总样本数/BATCH_SIZE,

LEARNING_RATE_DECAY,

staircase=True)

train_step=tf.train.GradientDescentOptimizer(learning_rate).minimize(loss,global_step=global_step)

5.滑动平均：

ema=tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY,global_step)

ema_op=ema.apply(tf.trainable_variables())

with tf.control_dependencies([train_step,ema_op]):

train_op=tf.no_op(name='train')

6.用with结构初始化所有参数

with tf.Session() as sess:

init_op=tf.global_variables_initializer()

sess.run(init_op)

for i in range(STEPS):

sess.run(train_step,feed_dict={x: , y_: })

if i % 轮树 == 0:

7.判断python运行文件是否为主文件

if __name__=='__main__':

backward()

例子：

用300个符合正态分布的点X[X0,X1]作为数据集，根据点X[x0,x1]的不同进行标注Y_，将数据集标注为红色和蓝色。标注规则为：当 $x_{0}^{2}+x_{1}^{2}\geqslant 2$ 时，y_=0，点X标注为蓝色。我们加入指数衰减学习率优化效率，加入正则化提高泛化性，并使用模块化设计方法，把红色点和蓝色点分开。

（1）生成数据集模块(generated.py)

#coding:utf-8
import numpy as np
import matplotlib.pyplot as plt
seed = 2
def generateds():rdm = np.random.RandomState(seed)X = rdm.randn(300,2)Y_ = [int(x0*x0 + x1*x1 <2) for (x0,x1) in X]Y_c= [['red' if y else 'blue'] for y in Y_]X = np.vstack(X).reshape(-1,2)Y_= np.vstack(Y_).reshape(-1,1)return X,Y_,Y_c

（2）前向传播模块(forward.py)

#coding:utf-8
# 0.导入模块，生成模拟数据集
import tensorflow as tf# 定义神经网络的输入、参数和输出，定义前向传播过程
def get_weight(shape, regularizer):w = tf.Variable(tf.random_normal(shape), dtype=tf.float32)tf.add_to_collection('losses', tf.contrib.layers.l2_regularizer(regularizer)(w))return wdef get_bias(shape):b = tf.Variable(tf.constant(0.01, shape=shape))return bdef forward(x, regularizer):w1 = get_weight([2,11], regularizer)b1 = get_bias([11])y1 = tf.nn.relu(tf.matmul(x,w1) + b1)w2 = get_weight([11,1], regularizer)b2 = get_bias([1])y = tf.matmul(y1, w2) + b2  # 输出层不过激活return y

（3）反向传播模块(backward.py)

#coding:utf-8
# 0.导入模块，生成数据集
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
import opt4_8_generateds
import opt4_8_forwardSTEPS = 40000
BATCH_SIZE = 30
LEARNING_RATE_BASE = 0.001
LEARNING_RATE_DECAY = 0.999
REGULARIZER = 0.01def backward():x = tf.placeholder(tf.float32, shape=(None, 2))y_= tf.placeholder(tf.float32, shape=(None, 1))X, Y_, Y_c = opt4_8_generateds.generateds()y = opt4_8_forward.forward(x, REGULARIZER)global_step = tf.Variable(0, trainable=False)learning_rate = tf.train.exponential_decay(LEARNING_RATE_BASE,global_step,300/BATCH_SIZE,LEARNING_RATE_DECAY,staircase=True)# 定义损失函数loss_mse = tf.reduce_mean(tf.square(y-y_))loss_total = loss_mse + tf.add_n(tf.get_collection('losses'))# 定义反向传播方法：包含正则化train_step = tf.train.AdamOptimizer(learning_rate).minimize(loss_total)with tf.Session() as sess:init_op = tf.global_variables_initializer()sess.run(init_op)for i in range(STEPS):start = (i*BATCH_SIZE) % 300end = start + BATCH_SIZEsess.run(train_step, feed_dict={x: X[start:end], y_:Y_[start:end]})if i % 2000 == 0:loss_v = sess.run(loss_total, feed_dict={x:X,y_:Y_})print("After %d steps, loss is: %f" % (i, loss_v))xx, yy = np.mgrid[-3:3:.01, -3:3:.01]grid = np.c_[xx.ravel(), yy.ravel()]probs = sess.run(y, feed_dict={x:grid})probs = probs.reshape(xx.shape)plt.scatter(X[:,0], X[:,1], c=np.squeeze(Y_c))plt.contour(xx, yy, probs, levels=[.5])plt.show()if __name__=='__main__':backward()

运行结果如下：

由运行结果可见，程序使用模块化设计方法，加入指数衰减学习率，使用正则化后，红色点和蓝色点的分割曲线相对平滑,效果变好。

学习地址：https://www.icourse163.org/course/PKU-1002536002

Tensorflow笔记：神经网络优化相关推荐

人工智能实践：TensorFlow笔记学习（四）—— 神经网络优化
神经网络优化大纲 4.1 损失函数 4.2 学习率 4.3 滑动平均 4.4 正则化 4.5 神经网络搭建八股目标掌握神经网络优化方法 4.1 损失函数神经元模型:用数学公式表示为:,f为激 ...
TensorFlow笔记-06-神经网络优化-损失函数,自定义损失函数,交叉熵
TensorFlow笔记-06-神经网络优化-损失函数,自定义损失函数,交叉熵神经元模型:用数学公式比表示为:f(Σi xi*wi + b), f为激活函数神经网络是以神经元为基本单位构成的激 ...
神经网络优化算法详解
本文,是摘录的学习笔记,书读一遍,需要招录一些核心的知识点,或者较难理解的知识点,下次在看的时候,就不需要子啊去翻书找了,总结之后,下次在看的时候,总是挑着关键点,效率也就高了. 本文主要摘录自< ...
北京大学人工智能实践：Tensorflow笔记——曹健（writed by Enigmalgia）
可以看下我转载的一篇文章机器学习入门概括关于TensorFlow的安装 Ubuntu18.04下安装anaconda和pycharm搭建TensorFlow 贴一下TensorFlow的官方中文版教 ...
人工智能实践：TensorFlow笔记学习（八）—— 卷积神经网络实践
大纲 7.1 复现已有的卷积神经网络 7.2 用vgg16实现图片识别目标掌握复现已有网络,用vgg16实现图片识别 7.1 复现已有的卷积神经网络 VGGNet是Karen simonya ...
人工智能实践：TensorFlow笔记学习（六）—— 全连接网络实践
输入手写数字输出识别结果大纲 6.1 输入手写数字图片输出识别结果 6.2 制作数据集目标 1.实现断点续训 2.输入真实图片,输出预测结果 3.制作数据集,实现特定应用 6.1 输入手写数字图 ...
人工智能实践：TensorFlow笔记学习（五）—— 全连接网络基础
MNIST数据集输出手写数字识别准确率大纲 5.1 MNIST数据集 5.2 模块化搭建神经网络 5.3 手写数字识别准确率输出目标利用MNIST数据集巩固模块化搭建神经网路的八股,实践前向传播 ...
人工智能实践：TensorFlow笔记学习（一）—— 人工智能概述
概述一. 基本概念 1.什么是人工智能人工智能的概念:机器模拟人的意识和思维重要人物:艾伦·麦席森·图灵(Alan Mathison Turing) 人物简介:1912年6月23日-19 ...
【深度学习】从梯度下降到 Adam！一文看懂各种神经网络优化算法
王小新编译自 Medium 量子位出品 | 公众号 QbitAI,编辑:AI有道在调整模型更新权重和偏差参数的方式时,你是否考虑过哪种优化算法能使模型产生更好且更快的效果?应该用梯度下降,随机梯 ...
TensorFlow笔记（12） VGG16
TensorFlow笔记(12) VGG16 1. 迁移学习 2. 数据读取 3. 构建模型 4. 训练模型 5. 模型预测 1. 迁移学习现在已经有很很多优秀的神经网络模型,这些模型大部分都是使用 ...

Tensorflow笔记：神经网络优化

损失函数

学习率

滑动平均

正则化

搭建模块化神经网络八股

Tensorflow笔记：神经网络优化相关推荐

最新文章

热门文章