tensorflow学习笔记------神经网络优化

其他 2018-11-12 22:10:49 阅读次数: 0
  • 神经元模型：用数学公式表示为：f(∑iXiWi + b)，其中f为激活函数，b为偏置向。神经网络是以神经元为基本单位构成的。
    这里写图片描述
  • 激活函数：引入非线性激活因子，提高模型的表达能力。常用的激活函数有relu, sigmoid, tanh等。
  1. 激活函数relu：在tensorflow中使用tf.nn.relu()表示
tf.nn.relu()

这里写图片描述
2. 激活函数sigmoid: 在TensorFlow中，用tf.nn.sigmoid()表示

tf.nn.sigmoid()

这里写图片描述
3. 激活函数tanh: 在tensorflow中用tf.nn.tanh()表示

tf.nn.tanh()

这里写图片描述

  • 神经网络的复杂度：可用神经网络的层数和神经网络中待优化参数个数表示。
  • 神经网络的层数：一般不计入输入层，所以层数=n个隐藏层 + 1个输出层。
  • 神经网络待优化的参数：神经网络中所有参数w的个数 + 所有参数b的个数。
  • 例子：
    这里写图片描述
    在上面的神经网络中，包含1个输入层、1个隐藏层和1个输出层，则该神经网络的层数为2层。在神经网络中，参数的个数是所有参数w的个数加上是所有参数b的总数，第一层参数用三行四列的二阶张量表示(即12个线上的权重w)再加上4个偏置b；第二层参数是用四行二列的二阶张量(即8个线上的权重w)加上2个偏置b。总参数=3*4+4 + 4*2+2 = 26。
  • 损失函数(loss)：用来表示预测值(y) 与已知答案(标签y_)的差距。在训练神经网络时，通过不断的改变神经网络中所有的参数，使得损失函数不断的减小，从而训练出更高准确率的神经网络模型。
  • 常用的损失函数：均方误差、自定义和交叉熵等。
  • 均方误差mse：n个样本的预测值y与标签y_之差的平方和，再求平均值。
    这里写图片描述
    在tensorflow中使用loss_mse = tf.reduce_mean(tf.square(y_-y))
    看下面均方误差是我例子：
    预测酸奶日销量y，x1和x2是影响日销量的两个因素。应提前采集的数据有：一段时间内，每日的x1因素，x2因素和销量y_，采集的数据应尽量多。在该例中，用销量预测产量，最优的产量应该等于销量。因没有数据集，所以拟造了一套数据集。利用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))
#在本代码#2中尝试其他反向传播方法，看对收敛速度的影响，把体会写到笔记中

在上述代码可知，本例中的神经网络预测模型为y=w1+x1 + w2*x2，损失函数采用均方误差。通过是损失函数值(loss)不断降低，神经网络模型得到最终参数w1=0.98,w2=1.02，销量的预测结果为y=0.98*x1 + 1.02*x2。因为标准答案为y=x1+x2，因此销量预测结果和标准答案已是非常接近的，说明该神经网络预测酸奶日销量正确。

  • 自定义损失函数：根据问题的实际情况，定制合理的损失函数。
    例如：对于上面预测酸奶日销量问题，如果预测销量大于实际则会损失成本；如果预测销量小于实际销量，则损失利润。在实际生活中，往往制造一盒酸奶的成本和销量一盒酸奶的利润是不等价的。所以，需要使用符合该问题的自定义损失函数。
    自定义损失函数为：loss = ∑f(y_, y)
    其中，损失定义成分段函数：
    这里写图片描述
    该损失函数表示，若预测结果y小于标准答案y_，损失函数为利润乘以预测结果y与标准答案y_之差；若预测结果y大于标准答案y_，损失函数为成本乘以预测结果y与标准答案y_之差。
    用tensorflow表示为：
loss = tf.reduce_sum(tf.greater(y,y_),COST(y-Y_),PROFIT(y_-y))

a、若酸奶成本为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=1.03，w2=1.05，销量预测结果为y=1.03*w1 + 1.05*w2。由此可见，采用自定义的损失函数预测结果大于采用均方误差预测的结果。更加符合实际的要求。

b、若酸奶的成本为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)

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

预测结果为：y = 0.96*x1 + 0.97*x2。更符合实际。

  • 交叉熵(Cross Entropy)：表示两个概率分部之间的距离。交叉熵越大，两个概率分布距离越远，两概率分布越相异；交叉熵越小，两个概率分布距离越近，两个概率分布越相似。
    计算公式：H(y_ , y) = −∑y_ ∗ log y
ce= -tf.reduce_mean(y_* tf.log(tf.clip_by_value(y, 1e-12, 1.0)))

例子：两个神经网络模型解决二分类问题中，已知标准答案为 y_ = (1, 0)，第一个神经网络模型预测结果为7y1=(0.6, 0.4)，第二个神经网络模型预测结果为 y2=(0.8, 0.2)，判断哪个神经网络模型预测的结果更接近标准答案。根据交叉熵的计算公式得：
H1((1,0),(0.6,0.4)) = -(1*log0.6 + 0*log0.4) ≈ -(-0.222 + 0) = 0.222
H2((1,0),(0.8,0.2)) = -(1*log0.8 + 0*log0.2) ≈ -(-0.097 + 0) = 0.097
由于 0.222>0.097，所以预测结果 y2 与标准答案 y_更接近， y2 预测更准确。
softmax函数：将n分类的n个输出(y1,y2,y3…yn)变为满足以下概率分布要求的函数。
这里写图片描述
softmax的函数表示为：
这里写图片描述
softmax函数的应用：在n分类中，一般让模型的输出经过softmax函数，以获得输出分类的概率分布，在于标准答案对比，求出交叉熵，得到损失函数，用如下函数实现：

ce = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=y, labels=tf.argmax(y_, 1))
cem = tf.reduce_mean(ce)
  • 学习率learning_rate：表示了每次参数更新的幅度大小。学习过大，会导致待优化的参数在最小值附近波动，不收敛；学习率过小，会使得待优化参数收敛缓慢。在训练过程中，参数的更新向着损失函数梯度下降的方向。
  • 参数的更新公式：

    假设损失函数为loss = (w+1)^2。梯度是损失函数loss的倒数为∇=2w+2。如参数初值为5，学习率为0.2，则参数与损失函数更新如下：
    1 次 参数 w： 5 5 - 0.2 * (2 * 5 + 2) = 2.6
    2 次 参数 w： 2.6 2.6 - 0.2 * (2 * 2.6 + 2) = 1.16
    3 次 参数 w： 1.16 1.16 – 0.2 * (2 * 1.16 + 2) = 0.296
    4 次 参数 w： 0.296
    损失函数 loss = (w + 1)^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))

运行结果：
这里写图片描述
由结果可知，随着损失函数值的减小，w无限接近于-1，模型计算推测出最优参数w = -1。

  • 学习率过大的情况：学习率过大，会导致待优化的参数在最小值附近波动，不收敛。
    将上面的代码的学习率改为1，其余不变，结果如下：
    这里写图片描述
    由结果可知，损失函数loss值并没有收敛，而是在5和-7之间波动。

  • 学习率过小的情况：学习率过小， 会导致待优化的参数收敛缓慢。
    将上面的代码的学习率改为0.0001，其余内容不变。实验结果如下：
    这里写图片描述
    由实验结果可知，损失函数loss的值在缓慢下降，w值也在小幅度的变化，收敛缓慢。

  • 指数衰减学习率：学习率随着训练轮数变化而动态更新
    计算公式如下：
    这里写图片描述
    用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))

运行结果:
这里写图片描述
由结果可知，随着训练轮数增加而学习率在不断变小。

  • 滑动平均：记录了一段时间内模型中所有参数w和b各自的平均值。利用滑动平均值可以增强模型的泛化能力。
  • 滑动平均值（影子）计算公式：
    影子 = 衰减率 * 影子 + (1 - 衰减率) * 参数。
    这里写图片描述

用tensorflow表示为

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

其中，MOVING_AVERAGE_DECAY表示滑动平均衰减率，一般会赋接近1的值，global_step表示当前悬链多少轮。
ema.apply()函数实现对括号内参数求滑动平均，tf.trainable_variables()函数实现把所有待训练参数汇总为列表。
with部分实现将滑动平均和训练过程同步运行。
查看模型中参数的平均值，可以用 ema.average()函数。
看下面的例子：
在神经网络模型中，将 MOVING_AVERAGE_DECAY 设置为 0.99，参数 w1 设置为 0， w1 的滑动平均值设置为 0。

  1. 开始时，轮数 global_step 设置为 0， 参数 w1 更新为 1，则 w1 的滑动平均值为：
    w1滑动平均值=min(0.99,1/10)*0+(1– min(0.99,1/10)*1 = 0.9
  2. 当轮数 global_step 设置为 100 时，参数 w1 更新为 10， 以下代码 global_step 保持为100，每次执行滑动平均操作影子值更新， 则滑动平均值变为：
    w1 滑动平均值=min(0.99,101/110)*0.9+(1– min(0.99,101/110)*10 = 0.826+0.818=1.644
  3. 再次运行，参数 w1 更新为 1.644，则滑动平均值变为：
    w1 滑动平均值=min(0.99,101/110)*1.644+(1– min(0.99,101/110)*10 = 2.328
  4. 再次运行，参数 w1 更新为 2.328，则滑动平均值：
    w1 滑动平均值=2.956

代码实现如下

#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("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  看影子追随速度

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

  • 过拟合：神经网络模型在训练数据集上的准确率较高，在新的数据进行数据预测或分类时准确率较低，说明模型的泛化能力差。
  • 正则化：在损失函数中给每一个参数w加上权重，引入模型复杂度指标，从而抑制模型噪声，减小过拟合。

使用正则化后，损失函数loss变为两项之和：loss = loss(y 与 y_) + REGULARIZER*loss(w)
其中，第一项是预测结果与标准答案之间的差距，如之前讲过的交叉熵、均方误差等；第二项为正则化计算结果。

  • 正则化计算方法：
    这里写图片描述
    cem的计算在前面已经给出。

看下面的例子：
用 300 个符合正态分布的点 X[x0, x1]作为数据集，根据点 X[x0, x1]计算生成标注 Y_，将数据集标注为红色点和蓝色点。标注规则为：当 x02 + x12 < 2 时， y_=1，标注为红色；当 x02 + x12 ≥2 时， y_=0，标注为蓝色。我们分别用无正则化和有正则化两种方法，拟合曲线， 把红色点和蓝色点分开。 在实际分类时，如果前向传播输出的预测值 y 接近 1 则为红色点概率越大，接近 0 则为蓝色点概率越大，输出的预测值 y 为 0.5 是红蓝点概率分界线。
补充知识：

# matplotlib 模块： Python 中的可视化工具模块，实现函数可视化
# 终端安装指令： sudo pip install matplotlib
# 函数 plt.scatter（）： 利用指定颜色实现点(x,y)的可视化
plt.scatter(x 坐标, y 坐标, c=” 颜色”)
plt.show()

# 收集规定区域内所有的网格坐标点：
xx, yy = np.mgrid[起:止:步长, 起:止:步长]  #找到规定区域以步长为分辨率的行列网格坐标点
grid = np.c_[xx.ravel(), yy.ravel()]      #收集规定区域内所有的网格坐标点
plt.contour()                             # 函数：告知 x、 y 坐标和各点高度，用 levels 指定高度的点描上颜色
plt.contour (x 轴坐标值, y 轴坐标值, 该点的高度, levels=[等高线的高度])
plt.show()

本例代码：

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

执行的效果如下：
首先，数据集实现可视化，x1^2 + x2^2 < 2 的点显示红色，x1^2 + x2^2 >= 2 显示蓝色，如图所示：
这里写图片描述
接着执行无正则化的训练过程，把红色的点和蓝色的点分开，生成曲线如下图所示：
这里写图片描述
最后执行有正则化的训练过程，把红色的点和蓝色的点分开，生成曲线如下图所示：
这里写图片描述
对比有无正则化训练的模型的训练结果，可以看出有正则化模型的拟合曲线平滑，模型具有更好的泛化能力。

最后，对上面最后一个例子采用模块化的方式搭建：
代码如下：

  • 生成数据集的模块(generateds.py)
#coding:utf-8
#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()
  • 前向传播模块(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
  • 反向传播模块(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()

运行代码的结果如下：
这里写图片描述
由运行结果可见， 程序使用模块化设计方法，加入指数衰减学习率，使用正则化后，红色点和蓝色点的分割曲线相对平滑，效果变好。

猜你喜欢

转载自blog.csdn.net/perfect1t/article/details/81437135
今日推荐
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
周排行
Java基础复习_day13_Collection集合
2018.11.16 c语言学习经验
且看Java内置四大核心函数式接口
小程序云开发中数据库的数据分段和显示图片
python的函数
Web-JS进阶
【干货】C++常用代码积累笔记大全
Spring的ioc操作 与 IOC底层原理
构建之法20191121-11 Scrum立会报告+燃尽图 07
Spring boot之Hello World访问404
每日归档
更多
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022