TensorFlow-过拟合现象（L1正则化与L2正则化）

L1正则化 

import tensorflow as tf
from matplotlib import pyplot as plt
import numpy as np
import pandas as pd

df = pd.read_csv('dot.csv')#读入数据/标签 生成x_train和y_train
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个神经元（x1和x2），隐藏层为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.005#学习率
epoch = 800

#训练部分:
for epoch in range(epoch):
    for step,(x_train,y_train) in enumerate(train_db):
        with tf.GradientTape() as tape:  #在with中完成前向传播
            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))
        variables = [w1,b1,w2,b2]
        grads = tape.gradient(loss,variables)#loss分别对w1，b1，w2，b2求偏导
        
        #实现梯度更新，分别更新w1，b1，w2，b2
        #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))
#预测部分
print("*************predict*******************")
#xx在-3到3之间以步长为0.01，yy在-3到3之间以步长0.01，生成间隔数值点
#生成网格坐标点，密度为0.1
xx,yy = np.mgrid[-3:3:.1,-3:3:.1]
#将xx,yy拉直，并合并配对为二维张量，生成二维坐标点
grid = np.c_[xx.ravel(),yy.ravel()]
grid = tf.cast(grid,tf.float32)
#将网格坐标点喂入神经网络，进行预测，probs为输出
probs = []
#把每个网格坐标点送入神经网络，得到预测值y
for x_test in grid:
    #使用训练好的参数进行预测
    h1 = tf.matmul([x_test],w1) + b1
    h1 = tf.nn.relu(h1)
    y = tf.matmul(h1,w2) + b2
    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))#画出x1，x2散点
#squeeze去掉维度是1的维度，相当于去掉['red']['blue'],内层括号变为['red']['blue']
#把坐标xx yy和对应的值probs放入contour函数，给probs值为0.5的所有点上色，plt.show()后，显示的是红蓝点的分界线
plt.contour(xx,yy,probs,levels=[.5])#画出预测值y为0.5的曲线
plt.show()
#读入红蓝点，画出分割线，不包含正则化
#不清楚的数据，建议print出来查看

 加入L2正则化

#导入所需模块
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 = x_data
y_train = 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.005#学习率
epoch = 800#循环数

#训练部分
for epoch in range(epoch):
    for step,(x_train,y_train) in enumerate(train_db):
        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_mse = tf.reduce_mean(tf.square(y_train - y))
            #添加L2正则化
            loss_regularization = []
            #tf.nn,l2_loss(w) = sum(w**2)/2
            loss_regularization.append(tf.nn.l2_loss(w1))
            loss_regularization.append(tf.nn.l2_loss(w2))
            #求和
            loss_regularization = tf.reduce_sum(loss_regularization)
            loss = loss_mse + 0.03*loss_regularization
        #计算loss，对各个参数的梯度
        variables = [w1,b1,w2,b2]
        grads = tape.gradient(loss,variables)
        #实现梯度更新
        #w1 = w1 - lr*w1_grad
        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))
        
#预测部分
print("*************predict*******************")
xx,yy = np.mgrid[-3:3:.1,-3:3:.1]
grid = np.c_[xx.ravel(),yy.ravel()]
grid = tf.cast(grid,tf.float32)

probs = []
for x_predict in grid:
    h1 = tf.matmul([x_predict],w1) + b1
    h1 = tf.nn.relu(h1)
    y = tf.matmul(h1,w2) + b2
    probs.append(y)

x1 = x_data[:,0]
x2 = x_data[:,1]
probs = np.array(probs).reshape(xx.shape)
plt.scatter(x1,x2,color=np.squeeze(Y_c))
plt.contour(xx,yy,probs,levels=[.5])
plt.show()