elman神经网络流程 神经网络mse

损失函数

损失函数用来表示预测值(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 = 23455

rdm = 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 = 20000
	for i in range(STEPS):
		start = (i*BATCH_SIZE) % 32
		end = (i*BATCH_SIZE) % 32 + BATCH_SIZE
		sess.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.自定义损失函数：根据问题的实际情况，定制合理的损失函数。

例子：

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

自定义损失函数为：

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

用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 = 9

rdm = 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 = 20000
	for i in range(STEPS):
		start = (i*BATCH_SIZE) % 32
		end = (i*BATCH_SIZE) % 32 + BATCH_SIZE
		sess.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 = 1

rdm = 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 = 20000
	for i in range(STEPS):
		start = (i*BATCH_SIZE) % 32
		end = (i*BATCH_SIZE) % 32 + BATCH_SIZE
		sess.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.交叉熵：表示两个概率分布之间的距离。交叉熵越大，两个概率分布距离越远，两个概率分布越相异；交叉熵越小，两个概率分布距离越近，两个概率分布越相似。

计算公式：

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

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

softmax函数表示为：

在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：表示了每次参数更新的幅度大小。学习率过大，会导致待优化的参数在最小值附近波动，不收敛；学习率过小，会导致待优化的参数收敛缓慢。

参数的更新公式为：

假如损失函数为

。梯度是损失函数loss的导数为

，参数初值为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.指数衰减学习率：学习率随着训练轮数变化而动态更新

学习率计算公式如下：

用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 tf

LEARNING_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的值赋为1
	sess.run(tf.assign(w1, 1))
	sess.run(ema_op)
	print(sess.run([w1, ema.average(w1)]))

	# 更新step和w1的值，模拟出100轮迭代后，参数w1变为10
	sess.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正则化：

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

（2）L2正则化：

用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):

    w=

    b=

    y=

    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:

            print

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

if __name__=='__main__':

    backward()

例子：

用300个符合正态分布的点X[X0,X1]作为数据集，根据点X[x0,x1]的不同进行标注Y_，将数据集标注为红色和蓝色。标注规则为：当

时，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 w

def get_bias(shape):
	b = tf.Variable(tf.constant(0.01, shape=shape))
	return b

def 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_forward

STEPS = 40000
BATCH_SIZE = 30
LEARNING_RATE_BASE = 0.001
LEARNING_RATE_DECAY = 0.999
REGULARIZER = 0.01

def 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) % 300
			end = start + BATCH_SIZE
			sess.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()

运行结果如下：

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