正则化缓解过拟合

一、正则化

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

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

二、正则化计算方法

用Tesnsorflow 函数实现正则化 ：

#L1正则
l1loss=tf.contrib.layers.l1_regulaizer(REGULARIZER)(w)
#L2正则
l2loss=tf.contrib.layers.l2_regulaizer(REGULARIZER)(w)
#把内容加到集合对应位置
tf.add_to_collection('losses',l2loss)
#在原来的损失函数上加上正则项构成总损失函数
loss=cem+tf.add_n(tf.get_collection("losses"))

三、例子详解

用 300 个符合正态分布的点 X[x0 , x1]作为数据集，根据点 X[x0 , x1]计算生成标注Y_，将数据集标注为红色点和蓝色点。

标注规则：

我们分别用无正则化和有正则化两种方法，拟合曲线，把红色点和蓝色点分开。在实际分类时，如果前向传播输出的预测值 y 接近 1 则为红色点概率越大，接近 0 则为蓝色点概率越大，输出的预测值 y 为 0.5 是红蓝点概率分界线。

# coding:utf-8
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt

BATCH_SIZE = 30
seed = 2
STEPS = 40000

rdm = np.random.RandomState(seed)
# 生成300个符合正态分布的点
X = rdm.randn(300, 2)

# 标注规则：点的平方和小于2 ，y_=1，标注为红色，否则，就标记为蓝色
Y_ = [int(x0 * x0 + x1 * x1 < 2) for (x0, x1) in X]

# 每个点的颜色，y_=1，标注为红色，其余的标记为蓝色
Y_c = [['red' if y else 'blue'] for y in Y_]

# 对数据集X和标签y进行shape整理
# 将数组堆叠成一列
X = np.vstack(X).reshape(-1, 2)
Y_ = np.vstack(Y_).reshape(-1, 1)

print(X.shape)
print(Y_.shape)
# print(Y_c)

# 利用指定颜色实现点( ( x,y)
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.001)
b2 = get_bias([1])
y = tf.matmul(y1, W2) + b2

#
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(0.0001).minimize(loss_mse)

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_mse_v = sess.run(loss_mse, feed_dict={x: X, y_: Y_})
            print('Step:%d , loss：%f ' % (i, loss_mse_v))

    xx, yy = np.mgrid[-3:3:0.1, -3:3:0.1]
    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))

print("# ----------------------------------   有正则化   ----------------------------")
plt.scatter(X[:, 0], X[:, 1], c=np.squeeze(Y_c))
# plt.contour() 函数：告知 x x 、y y  坐标和各点高度，用 s levels
# plt.contour (x  轴坐标值y , y  轴坐标值 ,  该点的高度 , levels=[ 等高线的高度 ])
plt.contour(xx, yy, probs, levels=[.5])
plt.show()

# ----------------------------------   有正则化   ----------------------------
# 有正则化，此处是唯一的不同之处：loss_total
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)
    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('Step:%d , loss：%f ' % (i, loss_mse_v))

    xx, yy = np.mgrid[-3:3:0.1, -3:3:0.1]
    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()

代码执行结果：

（1）数据集实现可视化，平方和< 2 的点显示红色，平方和 ≥2 的点显示蓝色；

（2）执行无正则化的训练过程，把红色的点和蓝色的点分开，生成曲线如下图所示：

（3）最后，执行有正则化的训练过程，把红色的点和蓝色的点分开，生成曲线如下图所示：

实验结果显示：

对比无正则化与有正则化模型的训练结果，可看出有正则化模型的拟合曲线平滑，模型具有更好的泛化能力。

转载于:https://www.cnblogs.com/ch-forever/p/10233298.html