快速搭建人工神经网络
- 一、简单概念综述
- 二、神经网络的优化以及实际问题模型的优化

快速搭建人工神经网络

一、简单概念综述

1.1、本文涉及内容

注：这里主要从实际问题出发，从代码的角度来看，关于具体的理论问题的探讨，读者可以参见我的其他系列的文章讲解。

- 从实际问题出发，搭建原始神经网络

神经网络优化
- 从损失函数上来看
- 从学习率上来看
- 从滑动平均上来看
- 从正则化上来看

1.2、实际问题的抛出

本文下面所要涉及到的内容均建立在更好的解决这个实际问题的基础上。
问题描述如下：
- 预测酸奶日销量 y，x1和 x2是影响日销量的两个因素。是影响日销量的两个因素。
- 应提前采集的数据有：一段时间内，每日的 x1 因素、x2 因素和销量 y_。采集的数据尽量多。
- 在本例中用销量预测产量，最优的产量应该等于销。由于目前没有实际的数据集，所以我们手动生成一组数据集。可以使用 Tensorflow 中函数随机生成 x1、x2，制造标准答案 y_= x1 + x2，为了更好的体现显示世界中的不确定向因素，让数据更加真实，求和后我们还加了正负 0.05 的随机噪声。
- 我们把它喂入神经网络，构建一个层的拟合预测酸奶日销量函数。这里虽然神经网络的层数较少，但是我们会从工程上会涉及到的优化方法，全方面将讲解，达到更深入学习了解神经网络的母的。

1.3、最为原始的神经网络

# 在这里我们认为预测多与预测少，对商家的影响一样。
# 细心的读者可能回注意到，实际中影响肯定会不一样的，这里因为是原宿模型，我们会在后面进行优化  

# 此外，还值得我们重视的是，人工神经网络搭建的步骤，它对于后面乃至学习深度神经网络以及扩展知识都很有帮助 
# 故，希望读者可以尽量记忆搭建流程，下以序号 1、2 、3 、···· 给出  

# 0、导入模块，生成数据集(如果有真实数据集，也可叫做数据加载)  
import tensorflow as tf 
import numpy as np 

BATCH_SIZE = 8   # 表示每一批次(Batch)喂进神经网络的样本的数目  
SEED =2345       # 随机种子，保证每次生成的数据一样，实际工程中不用定义 

rdm = np.random.RandomState(SEED)
X = rdm.rand(32,2)      # 生成两维数据，32行 2列
Y_ = [[x1 + x2 + (rdm.rand()/10 - 0.05)] for (x1, x2) in X] 

# 1、定义神经网络的输入、参数和输出，定义 前向传播 过程。 
# 输入在循环迭代的时候一起喂入，shape 第一个参数表示要喂入的样本组数的个数，第二个参数为样本的输入特征
x = tf.placeholder(tf.float32,shape=(None,2)) 
y_ = tf.placeholder(tf.float32,shape=(None,1))    # y_ 表示实际值 
w1 = tf.Variable(tf.random_normal([2,1],stddev=1,seed=1))   # 创建初始化的权重 w，以便前向传播
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 结构)中实现  
# 变量的初始化：在 sess.run 函数中用 tf.global_variables_initializer() 实现 
# 对于图节点运算：一般在 sess.run 函数中直接填入该运算的节点，例如：sess.run(y) 
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]})  
        # 每 500 轮输出一次 训练的权重 w  
        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) 

    # 此外读者还可以将原始的梯度下降换成其他的反向传播方法，对比查看对于收敛速度的影响
    # tf.train.AdagradOptimizer() 
    # tf.train.AdadeltaOptimizer()
    # tf.train.MomentumOptimizer()  等等

After 0 training steps, w1 is: 
[[-0.81032526]
 [ 1.4851102 ]] 

After 500 training steps, w1 is: 
[[-0.38153937]
 [ 1.692596  ]] 

此处省略部分内容 ······

Final w1 is : 
[[0.9480486]
 [1.057066 ]]

结果表明，拟合的 w1 和 w2 都接近于 1，拟合效果还算可以。但是这里存在着很多可以优化的问题，以及对实际问题建模没有考虑到的问题。下面一一讲解：

二、神经网络的优化以及实际问题模型的优化

2.1、从损失函数来看

上述代码的损失函数采用均方误差。通过使损失函数值（损失函数值 loss 不断降低，神经网络模型得到最终的拟合结果。当时我们认为的是我们预测(y值)多与预测少，对商家的影响一样。但是显然预测多了损失的是成本，预测少了损失的是利润，应该不一样才对。
故常见的损失函数有 MSE，交叉熵，以及自定义的损失函数，针对这里来说，对于预测酸奶日销量问题，如果预测销量大于实际则会损失成本，如果预测销量小于实际销量则会损失利润。在实际生活中，往往制造一盒酸奶的成本和销售是不等价因此需要使用符合该问题的自定义损失函数。如下：
我们定义损失函数为分段函数：如果预测值 y 小于实际值 y_, 则取 PROFIT * (y_ - y),如果预测值 y 大于等于实际值 y_, 则取 COST * (y - y_), 它用 TensorFlow 来表示的话，(其中 tf.where 便是询问，嵌套 tf.greater是否大于)可以为：

loss = tf.reduce_sum(tf.where(tf.greater(y,y_),COST(y-y_),PROFIT(y_-y)))

- 如果酸奶成本为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)

#3生成会话，训练STEPS轮。
with tf.Session() as sess:
    init_op = tf.global_variables_initializer()
    sess.run(init_op)
    STEPS = 3000
    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)  

# 通过输出，我们可以看到估计的 w1, w2 果然都比 1 要多出一些，符合我们的猜想 
# 此外，改了损失函数后，发现迭代次数也减少了很多，就可以拟合效果不错

After 0 training steps, w1 is: 
[[-0.762993 ]
 [ 1.5095658]] 

After 500 training steps, w1 is: 
[[1.0235443]
 [1.0463386]] 

After 1000 training steps, w1 is: 
[[1.0174844]
 [1.0406483]] 

After 1500 training steps, w1 is: 
[[1.0211805]
 [1.0472497]] 

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

同理，当如果成本价格大于利润价格时，我们可能希望预测的少一些，代码如下：

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

#3生成会话，训练STEPS轮。
with tf.Session() as sess:
    init_op = tf.global_variables_initializer()
    sess.run(init_op)
    STEPS = 3000
    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)

    # 通过结果，发现果然参数均小于 1 一些，符合我们的预期

After 0 training steps, w1 is: 
[[-0.80594873]
 [ 1.4873729 ]] 

After 500 training steps, w1 is: 
[[0.8732146]
 [1.006204 ]] 

After 1000 training steps, w1 is: 
[[0.9658064]
 [0.9698208]] 

After 1500 training steps, w1 is: 
[[0.9645447]
 [0.9682946]] 

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

这里在讲述一下交叉熵(Cross Entropy): 表示两个概率分布之间的距离，交叉熵越大，两个概率分布的距离越远，则它们越相异，交叉熵越小，两个概率分布距离越近，它们越相似 $H(y_, y) = - \sum y\_ * log y$

ce = -tf.reduce_mean(y_ * tf.log(tf.clip_by_value(y, 1e-12,1.0)))

在进行分类问题时，我们常用 softmax 函数作为输出层激活函数，以获得输出分类的概率分布，再与标准的答案对比，求出交叉熵，得到损失函数，在 TensorFlow 中可以用如下表示：

ce = tf.nn.sparse_softmax_cross_entropy_with_logits(logits-y,labels=tf.argmax(y_,1))  
cem = tf.reduce_mean(ce)

2.2、从学习率来看

学习率 learning_rate: 表示了每次参数更新的幅度大小。学习率过大，会导致待优化的参数在最小值附近波动，不收敛。学习率过小，会导致待优化的参数收敛慢。在训练过程中，参数的更新向着损失函数的梯度下降的反向。
$更新的公式为： W_{n + 1} = W_{n} - （ l e a r n i n g_r a t e ） * 梯度$ $更新的公式为： W_{n + 1} = W_n - （learning\_rate） * 梯度$
下面采用损失函数 $loss = ( w + 1)^2$ 来直观体验学习率对于寻找损失函数的极小值的影响。其图像如下：
并且从图像知，loss 的最小值会在(-1,0) 处得到，此时损失函数导数为 0，得到最终的参数 w = -1

%matplotlib inline
import numpy as np 
import matplotlib as mpl 
import matplotlib.pyplot as plt 
from matplotlib.lines import Line2D 

w = np.linspace(-8,8,300)
y = (w + 1) ** 2
line_min = [(-1,0),(-1,60)]
(line_x,line_y) = zip(*line_min)

figure, ax = plt.subplots()
ax.add_line(Line2D(line_x,line_y,c='m'))
plt.xlabel('w')
plt.ylabel('loss')
plt.plot(w,y,c='b')

[<matplotlib.lines.Line2D at 0x11452ba10>]

这里写图片描述

# 学习损失函数的极小值
# 设损失函数 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(35):
        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)  

        # 故读者可以尝试着将 11 行的学习率 0.2，改为较大值，
        # 如 1 会发现，loss 会来回震荡，不会减小，如果 学习率太小，则优化速度很慢

After 0 steps: w is 2.600000, loss is 12.959999.
After 1 steps: w is 1.160000, loss is 4.665599.
After 2 steps: w is 0.296000, loss is 1.679616.
After 3 steps: w is -0.222400, loss is 0.604662.
After 4 steps: w is -0.533440, loss is 0.217678.
After 5 steps: w is -0.720064, loss is 0.078364.
After 6 steps: w is -0.832038, loss is 0.028211.
After 7 steps: w is -0.899223, loss is 0.010156.
此处省略部分内容 ······
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.

其实除了手动设置学习率外，还可以用 TensorFlow 中的指数衰减学习率，即学习率随着训练轮数的变化而动态更新。其公式如下：
$L e a r n i n g_r a t e = L E A R N I N G_R A I T_B A S E * L E A R N I N G_R A T E_D E C A Y * \frac{g l o b a l_s t e p}{L E A R N I N G_R A T E_B A T C H_S I Z E}$ $Learning\_rate = LEARNING\_RAIT\_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_TATE_DECAY 为学习率的衰减率，global_step 记率了当前训练轮数，为不可训练型参数。学习率 learning_rate 更新频率为输入数据集总样本除以每次喂入样本数。若 staircase 设置为 True 时，表示 global_step/learning rate step 取整数，学习率阶梯型衰减；若为 false ,学习率会是一条平滑下降的曲线。
下面展示一下，使用指数学习率进行训练，其中，学习率初值设为 0.1，学习率衰减率设置为 0.99，BATCH_SIZE 设置为 1。

# 比起上面的代码，这里使用指数衰减的学习率，在迭代初期得到较高的下降速率，
# 可以在较小的训练轮数下取得更有效的收敛度 
import tensorflow as tf 

LEARNING_RATE_BASE = 0.1     # 最初的学习率  
LEARNING_RATE_DECAY = 0.99   # 学习率衰减率，一般来说比较大，近 1 
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)  

# 定义待优化的参数，初值给 5 
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) 
        if i % 10 == 0:
            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 0 steps:global_step is 1.000000, w is 3.800000，learning rate is 0.099000, loss is 23.040001
After 10 steps:global_step is 11.000000, w is -0.411674，learning rate is 0.089534, loss is 0.346128
After 20 steps:global_step is 21.000000, w is -0.910065，learning rate is 0.080973, loss is 0.008088
After 30 steps:global_step is 31.000000, w is -0.983281，learning rate is 0.073230, loss is 0.000280

2.3 从滑动平均来看

滑动平均：记录了一段时间内模型中所有参数 w 和 b 各自的平均值，利用滑动平均值可以增强模型的泛化能力。滑动平均值(影子) 的计算公式：
- 影子值 = 衰减率 * 影子 + （1 - 衰减率）* 参数
  - 其中，衰减率公式如下：，影子初值 = 参数初值
    $衰减值 = m i n {M O V I N G_A V E R A G E_D E C A Y, \frac{1 + 轮数}{10 + 轮数}}$ $衰减值 = min\{MOVING\_AVERAGE\_DECAY, \frac{1 + 轮数}{10 + 轮数} \}$
用 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() 函数实现对括号内的参数求滑动平均，tr.trainable_variables() 函数实现把所有待训练参数汇总为列表。

with tf.control_dependencies([train_step,ema_op])： 
    train_op = tf.no_op(name='train')

其中，该函数实现将滑动平均和训练过程同步运行。查看模型中参数的平均值，可以用 ema.average() 函数。
示例如下：

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 'current global_step: ',sess.run(global_step) 
    print 'current w1 ',sess.run([w1,ema.average(w1)])  

    # 参数 w1 的值赋为 1 
    sess.run(tf.assign(w1,1)) 
    sess.run(ema_op) 
    print 'current global_step:',sess.run(global_step) 
    print "current w1", sess.run([w1, ema.average(w1)]) 

    # 更新global_step和w1的值,模拟出轮数为100时，参数w1变为10, 以下代码global_step保持为100，每次执行滑动平均操作，影子值会更新 
    sess.run(tf.assign(global_step, 100))  
    sess.run(tf.assign(w1, 10))
    sess.run(ema_op)
    print "current global_step:", sess.run(global_step)
    print "current w1:", sess.run([w1, ema.average(w1)])       

    # 每次sess.run会更新一次w1的滑动平均值
    sess.run(ema_op)
    print "current global_step:" , sess.run(global_step)
    print "current w1:", sess.run([w1, ema.average(w1)])

    sess.run(ema_op)
    print "current global_step:" , sess.run(global_step)
    print "current w1:", sess.run([w1, ema.average(w1)])

    sess.run(ema_op)
    print "current global_step:" , sess.run(global_step)
    print "current w1:", sess.run([w1, ema.average(w1)])

    sess.run(ema_op)
    print "current global_step:" , sess.run(global_step)
    print "current w1:", sess.run([w1, ema.average(w1)])

    sess.run(ema_op)
    print "current global_step:" , sess.run(global_step)
    print "current w1:", sess.run([w1, ema.average(w1)])

    sess.run(ema_op)
    print "current global_step:" , sess.run(global_step)
    print "current w1:", sess.run([w1, ema.average(w1)])

#更改MOVING_AVERAGE_DECAY 为 0.1  看影子追随速度

current global_step:  0
current w1  [0.0, 0.0]
current global_step: 0
current w1 [1.0, 0.9]
此处省略部分内容 ······
current w1: [10.0, 4.547275]
current global_step: 100
current w1: [10.0, 4.9934072]

2.4、从正则化来看

这里写图片描述

#coding:utf-8
#0导入模块 ，生成模拟数据集
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
BATCH_SIZE = 30 
seed = 2 
#基于seed产生随机数
rdm = np.random.RandomState(seed)
#随机数返回300行2列的矩阵，表示300组坐标点（x0,x1）作为输入数据集
X = rdm.randn(300,2)
#从X这个300行2列的矩阵中取出一行,判断如果两个坐标的平方和小于2，给Y赋值1，其余赋值0
#作为输入数据集的标签（正确答案）
Y_ = [int(x0*x0 + x1*x1 <2) for (x0,x1) in X]
#遍历Y中的每个元素，1赋值'red'其余赋值'blue'，这样可视化显示时人可以直观区分
Y_c = [['red' if y else 'blue'] for y in Y_]
#对数据集X和标签Y进行shape整理，第一个元素为-1表示，随第二个参数计算得到，第二个元素表示多少列，把X整理为n行2列，把Y整理为n行1列
X = np.vstack(X).reshape(-1,2)
Y_ = np.vstack(Y_).reshape(-1,1)
# print X
# print Y_
# print Y_c
#用plt.scatter画出数据集X各行中第0列元素和第1列元素的点即各行的（x0，x1），用各行Y_c对应的值表示颜色（c是color的缩写） 
plt.scatter(X[:,0], X[:,1], c=np.squeeze(Y_c)) 
plt.show()


#定义神经网络的输入、参数和输出，定义前向传播过程 
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

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

w1 = get_weight([2,11], 0.01)   
b1 = get_bias([11])
y1 = tf.nn.relu(tf.matmul(x, w1)+b1)

w2 = get_weight([11,1], 0.01)
b2 = get_bias([1])
y = tf.matmul(y1, w2)+b2 


#定义损失函数
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(0.0001).minimize(loss_mse)

with tf.Session() as sess:
    init_op = tf.global_variables_initializer()
    sess.run(init_op)
    STEPS = 40000
    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_mse_v = sess.run(loss_mse, feed_dict={x:X, y_:Y_})
            print("After %d steps, loss is: %f" %(i, loss_mse_v))
    #xx在-3到3之间以步长为0.01，yy在-3到3之间以步长0.01,生成二维网格坐标点
    xx, yy = np.mgrid[-3:3:.01, -3:3:.01]
    #将xx , yy拉直，并合并成一个2列的矩阵，得到一个网格坐标点的集合
    grid = np.c_[xx.ravel(), yy.ravel()]
    #将网格坐标点喂入神经网络 ，probs为输出
    probs = sess.run(y, feed_dict={x:grid})
    #probs的shape调整成xx的样子
    probs = probs.reshape(xx.shape)
#   print "w1:\n",sess.run(w1)
#   print "b1:\n",sess.run(b1)
#   print "w2:\n",sess.run(w2)  
#   print "b2:\n",sess.run(b2)

plt.scatter(X[:,0], X[:,1], c=np.squeeze(Y_c))
plt.contour(xx, yy, probs, levels=[.5])
plt.show()



#定义反向传播方法：包含正则化
train_step = tf.train.AdamOptimizer(0.0001).minimize(loss_total)

with tf.Session() as sess:
    init_op = tf.global_variables_initializer()
    sess.run(init_op)
    STEPS = 40000
    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)
#   print "w1:\n",sess.run(w1)
#   print "b1:\n",sess.run(b1)
#   print "w2:\n",sess.run(w2)
#   print "b2:\n",sess.run(b2)

plt.scatter(X[:,0], X[:,1], c=np.squeeze(Y_c)) 
plt.contour(xx, yy, probs, levels=[.5])
plt.show() 

# 从结果中可以看出，加了正则项的泛化能力明显增强了

这里写图片描述

After 0 steps, loss is: 28.655834
After 2000 steps, loss is: 8.713348
After 4000 steps, loss is: 2.141488
此处省略部分内容 ······
After 34000 steps, loss is: 0.074597
After 36000 steps, loss is: 0.074495
After 38000 steps, loss is: 0.074372

这里写图片描述

After 0 steps, loss is: 3.871725
After 2000 steps, loss is: 0.796589
After 4000 steps, loss is: 0.409365
After 6000 steps, loss is: 0.299147
此处省略部分内容 ······
After 34000 steps, loss is: 0.112184
After 36000 steps, loss is: 0.110401
After 38000 steps, loss is: 0.108741

这里写图片描述

2.5 搭建模块化的神经网络

为了提高代码的复用性，以及模块化，工程实际中，我们常常会将神经网络的搭建的生成数据、前向传播、以及反向传播写成独立的文件格式组织。其构建流程如下：

这里写图片描述

代码如下：三个独立的 python 文件

This is generateds.py

#0导入模块 ，生成模拟数据集
import numpy as np
import matplotlib.pyplot as plt
seed = 2 
def generateds():
    #基于seed产生随机数
    rdm = np.random.RandomState(seed)
    #随机数返回300行2列的矩阵，表示300组坐标点（x0,x1）作为输入数据集
    X = rdm.randn(300,2)
    #从X这个300行2列的矩阵中取出一行,判断如果两个坐标的平方和小于2，给Y赋值1，其余赋值0
    #作为输入数据集的标签（正确答案）
    Y_ = [int(x0*x0 + x1*x1 <2) for (x0,x1) in X]
    #遍历Y中的每个元素，1赋值'red'其余赋值'blue'，这样可视化显示时人可以直观区分
    Y_c = [['red' if y else 'blue'] for y in Y_]
    #对数据集X和标签Y进行形状整理，第一个元素为-1表示跟随第二列计算，第二个元素表示多少列，可见X为两列，Y为1列
    X = np.vstack(X).reshape(-1,2)
    Y_ = np.vstack(Y_).reshape(-1,1)

    return X, Y_, Y_c

#print X
#print Y_
#print Y_c
#用plt.scatter画出数据集X各行中第0列元素和第1列元素的点即各行的（x0，x1），用各行Y_c对应的值表示颜色（c是color的缩写） 
#plt.scatter(X[:,0], X[:,1], c=np.squeeze(Y_c)) 
#plt.show()

this is 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

this is backward.py

#coding:utf-8
#0导入模块 ，生成模拟数据集
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
import generateds
import forward

# 定义参数 
STEPS = 40000               # 迭代轮数
BATCH_SIZE = 30             # 每轮送入网络训练的样本个数
LEARNING_RATE_BASE = 0.001  # 学习率基准
LEARNING_RATE_DECAY = 0.999 # 学习率衰减率
REGULARIZER = 0.01          # 正则 lamda 

# 定义反向传播过程，根据误差进行调整权重，训练网络的过程
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函数加上惩罚因子
    loss_total = loss_mse + tf.add_n(tf.get_collection('losses'))

    #定义反向传播方法：包含正则化
    train_step = tf.train.AdamOptimizer(learning_rate).minimize(loss_total)

    # 然后，在 with 结构中初始化参数，创建会话，运行会话，开始迭代循环，训练参数
    with tf.Session() as sess:
        # 首先初始化变量
        init_op = tf.global_variables_initializer()
        sess.run(init_op)
        # 开始迭代循环，迭代 Steps 轮
        for i in range(STEPS):
            start = (i*BATCH_SIZE) % 300
            end = start + BATCH_SIZE 
            # 通过 sess.run 执行 train_op
            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]
        # 通过 np.c_ 将 x, 与 y 凑成坐标点
        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()

神经网络快速搭建之一站式访问

快速搭建人工神经网络

一、简单概念综述

1.1、本文涉及内容

1.2、实际问题的抛出

1.3、最为原始的神经网络

二、神经网络的优化以及实际问题模型的优化

2.1、从损失函数来看

2.2、从学习率来看

2.3 从滑动平均来看

2.4、从正则化来看

2.5 搭建模块化的神经网络

猜你喜欢