缓解过拟合【Tensorflow笔记-CH2.5】

欠拟合与过拟合

欠拟合的解决方法：
√ 增加输入特征项
√ 增加网络参数
√ 减少正则化参数
过拟合的解决方法：
√ 数据清洗
√ 增大训练集
√ 采用正则化
√ 增大正则化参数

正则化

正则化在损失函数中引入模型复杂度指标，利用给W加权值，弱化了训练数据的噪声

通过实际用一下TF的正则化函数，看看是怎么计算的，也熟悉一下TF和python的用法：

import tensorflow as tf
a = tf.constant([1, 2, 3], dtype=tf.float32)
b = tf.constant([[1, 1], [2, 2], [3, 3]], dtype=tf.float32)
print('a_l2_loss')
print(tf.nn.l2_loss(a))
print('b_l2_loss')
print(tf.nn.l2_loss(b))

结果：

a_l2_loss
tf.Tensor(7.0, shape=(), dtype=float32)
b_l2_loss
tf.Tensor(14.0, shape=(), dtype=float32)

正则化计算方法：tf.nn.l2_loss(a)=(1平方+2平方+3平方)/2=7
下面再试一下列表的加入元素操作和求和运算：（python也太方便了吧）

loss_regularization=[]
loss_regularization.append(tf.nn.l2_loss(a))
loss_regularization.append(tf.nn.l2_loss(b))

print("loss_regularization[]=")
print(loss_regularization)
loss_regularization=tf.reduce_sum(loss_regularization)
print("loss_regularization:")
print(loss_regularization)

结果：

loss_regularization[]=
[<tf.Tensor: id=4, shape=(), dtype=float32, numpy=7.0>, <tf.Tensor: id=5, shape=(), dtype=float32, numpy=14.0>]
loss_regularization:
tf.Tensor(21.0, shape=(), dtype=float32)

在class2文件夹中有dot.csv文件，有三列数据，分别是输入特征和标签。
我们让神经网络拟合x1、x2和标签的关系，模型训练好之后，再有数据输入神经网络，神经网络会通过前向传播输出预测值。
np.vstack讲解博客
enumerate枚举

# 导入所需模块
import tensorflow as tf
from matplotlib import pyplot as plt
import numpy as np
import pandas as pd

# 读入数据/标签 生成x_train y_train
df = pd.read_csv('dot.csv')
x_data = np.array(df[['x1', 'x2']])
y_data = np.array(df['y_c'])

x_train = np.vstack(x_data).reshape(-1,2)
y_train = np.vstack(y_data).reshape(-1,1)
#堆叠数组，参考博文

Y_c = [['red' if y else 'blue'] for y in y_train]

# 转换x的数据类型，否则后面矩阵相乘时会因数据类型问题报错
x_train = tf.cast(x_train, tf.float32)
y_train = tf.cast(y_train, tf.float32)

# from_tensor_slices函数切分传入的张量的第一个维度，生成相应的数据集，使输入特征和标签值一一对应
train_db = tf.data.Dataset.from_tensor_slices((x_train, y_train)).batch(32)

# 生成神经网络的参数，输入层为2个神经元，隐藏层为11个神经元，1层隐藏层，输出层为1个神经元
# 用tf.Variable()保证参数可训练
w1 = tf.Variable(tf.random.normal([2, 11]), dtype=tf.float32)
b1 = tf.Variable(tf.constant(0.01, shape=[11]))

w2 = tf.Variable(tf.random.normal([11, 1]), dtype=tf.float32)
b2 = tf.Variable(tf.constant(0.01, shape=[1]))

lr = 0.01  # 学习率
epoch = 400  # 循环轮数

训练部分

# 训练部分
for epoch in range(epoch):
    for step, (x_train, y_train) in enumerate(train_db):  #enumerate枚举
        with tf.GradientTape() as tape:  # 记录梯度信息
            h1 = tf.matmul(x_train, w1) + b1  # 记录神经网络乘加运算
            h1 = tf.nn.relu(h1)
            y = tf.matmul(h1, w2) + b2

            # 采用均方误差损失函数mse = mean(sum(y-out)^2)
            loss = tf.reduce_mean(tf.square(y_train - y))

        # 计算loss对各个参数的梯度
        variables = [w1, b1, w2, b2]
        grads = tape.gradient(loss, variables)

        # 实现梯度更新
        # w1 = w1 - lr * w1_grad tape.gradient是自动求导结果与[w1, b1, w2, b2] 索引为0，1，2，3 
        w1.assign_sub(lr * grads[0])
        b1.assign_sub(lr * grads[1])
        w2.assign_sub(lr * grads[2])
        b2.assign_sub(lr * grads[3])

    # 每20个epoch，打印loss信息
    if epoch % 20 == 0:
        print('epoch:', epoch, 'loss:', float(loss))

预测部分

np.r_是按行方向扩展连接两个矩阵（row的缩写r），就是把两矩阵上下相加，要求列数相等。作用等同于 hstack 函数；np.c_是按列方向扩展连接两个矩阵（column的缩写c），就是把两矩阵左右相加，要求行数相等。作用等同于 vstack 函数。

# 预测部分
print("*******predict*******")
# xx在-3到3之间以步长为0.01，yy在-3到3之间以步长0.01,生成间隔数值点
xx, yy = np.mgrid[-3:3:.1, -3:3:.1]
# 将xx , yy拉直，并合并配对为二维张量，生成二维坐标点
grid = np.c_[xx.ravel(), yy.ravel()]  #ravel()拉直为1维数组，np.c_作用等同于 hstack 函数
grid = tf.cast(grid, tf.float32)
# 将网格坐标点喂入神经网络，进行预测，probs为输出
probs = []
for x_test in grid:
    # 使用训练好的参数进行预测
    h1 = tf.matmul([x_test], w1) + b1
    h1 = tf.nn.relu(h1)
    y = tf.matmul(h1, w2) + b2  # y为预测结果
    probs.append(y)

# 取第0列给x1，取第1列给x2
x1 = x_data[:, 0]
x2 = x_data[:, 1]
# probs的shape调整成xx的样子
probs = np.array(probs).reshape(xx.shape)
plt.scatter(x1, x2, color=np.squeeze(Y_c)) #squeeze去掉纬度是1的纬度,相当于去掉[['red'],[''blue]],内层括号变为['red','blue']
# 把坐标xx yy和对应的值probs放入contour<[‘kɑntʊr]>函数，给probs值为0.5的所有点上色  plt点show后 显示的是红蓝点的分界线
plt.contour(xx, yy, probs, levels=[.5])
plt.show()

# 读入红蓝点，画出分割线，不包含正则化
# 不清楚的数据，建议print出来查看 

运行结果：