TensorFlow笔记—7—过拟合,正则化,matplotlib 区分红蓝点

一. 唠嗑

加油

二. 基本概念和模块安装

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

使用正则化后，损失函数 loss 变为两项之和：

loss = loss(y与y_) + REGULARIZER*loss(w)

其中，第一项是预测结果与标准答案之间的差距，如之前讲过的交叉熵，均方误差等；第二项是正则化计算结果。

• 正则化计算方法：
  （1）L1正则化：lossL1 = Σi |wi|
  用 Tensorflow 函数表示：loss(w) = tf.contrib.layers.11_regularizer(REGULARIZER)(w)
  （2）L2正则化：lossL2 = Σi |wi|2
  用 Tensorflow 函数表示：loss(w) = tf.contrib.layers.12_regularizer(REGULARIZER)(w)

• 用 Tensorflow 函数实现L2正则化：

#加入正则化，L2正则化
tf.add_to_collection('losses', tf.contrib.layers.l2_regularizer(regularizer)(w))
# 定义损失函数
loss_mse = tf.reduce_mean(tf.square(y-y_))  #均方误差，不含正则化
#均方误差+每一个正则化w的损失，含正则化
loss_total = loss_mse + tf.add_n(tf.get_collection('losses'))  

• matplotlib 模块：Python 中可视化工具模块，实现函数可视化
• matplotlib 的安装我在之前的文章中已经讲到了，根据需要适当安装
• 函数 plt.scatter ()：利用指定颜色实现点 (x,y) 的可视化

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

• 收集规定区域内所有的网格坐标点：

    #xx在-3到3之间以步长为0.01，yy在-3到3之间以步长0.01，生成二维码网格坐标点
    #mgrid()函数返回多维结构，常见的如2D图形，3D图形，此时返回的是2D结构
    xx,  yy = np.mgrid[-3:3:.01, -3:3:.01]
    #将xx,yy拉直，用函数ravel()降维，用np.c_将数据合成一个2列的矩阵，得到一个网格的集合
    grid = np.c_[xx.ravel(), yy.ravel()]
    #将网格坐标点喂入神经网络，probs为输出

• plt.contour() 函数：告知 x，y 坐标和各点高度，用 levels 指定高度的点瞄上颜色

plt.contour (x 轴坐标值，y 轴坐标值，该点的高度，levels=[等高线高度])
plt.show()

三. 具体实例：

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

代码如下：

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’，0赋值‘blue’，这样子可视化显示可以直观区分
Y_c = [['red' if y else 'blue'] for y in Y_]
#对数据集X和标签Y_进行shape整理，第一个元素为-1表示，随第二个参数计算得到
# 第二个元素表示多少列，把X整理为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加上权重，引入模型复杂度指标，抑制模型噪声，减小过拟合
    w = tf.Variable(tf.random_normal(shape), dtype=tf.float32)
    #加入正则化，L2正则化
    tf.add_to_collection('losses', tf.contrib.layers.l2_regularizer(regularizer)(w))
    return w

def get_bias(shape):
    #偏置b赋值为0.01
    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)      #2行11列，正则化权重0.01
b1 = get_bias([11])                 #偏置有11个
y1 = tf.nn.relu(tf.matmul(x, w1)+b1)    #先矩阵相乘，然后过激活函数relu()线性输出

w2 = get_weight([11, 1], 0.01)      #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'))   #均方误差+每一个正则化w的损失，含正则化

# 定义反向传播方法：不含正则化
train_step = tf.train.AdadeltaOptimizer(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_val = sess.run(loss_mse, feed_dict={x: X, y_: Y_})
            print("After %d steps, loss is:%f" % (i, loss_mse_val))

    #xx在-3到3之间以步长为0.01，yy在-3到3之间以步长0.01，生成二维码网格坐标点
    #mgrid()函数返回多维结构，常见的如2D图形，3D图形，此时返回的是2D结构
    xx,  yy = np.mgrid[-3:3:.01, -3:3:.01]
    #将xx,yy拉直，用函数ravel()降维，用np.c_将数据合成一个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.contour (x 轴坐标值 , y 轴坐标值 , 该点的高度 , levels=[等高线的高度])，此函数作用是绘制轮廓
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在-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()

运行结果：

主要看输出的三张图，第一张图片输出的是红蓝点的分布情况，第二幅图是没有正则化，第三幅图加入正则化。

第一张图：
    只有红蓝点，对随机的点进行数据集可视化，标注规则：当 X2 + X2 >= 2 时，y_=0，标注为蓝色

                         

第二张图：
    代码的注释中说明已经很详细了，就是执行没有正则化训练过程，将红蓝点分开的效果，主要是跟第三张图片对比

                              

第三张图：
执行包含正则化训练过程，将红蓝点分开的效果比第二张图片效果更好