为了限制模型参数的数值大小，就在模型原来的目标函数上加上一个惩罚项，这个过程叫做正则化（Regularization）。

• 如果惩罚项是参数的$l_2$范数，就是岭回归(Ridge Regression)
• 如果惩罚项是参数的$l_1$范数，就是套索回归（Lasso Regrission）

        Ridge是在结构风险最小化的正则化因子上使用模型参数向量的二阶范数形式，Lasso使用的是一阶范数形式。虽然Ridge可以将参数估计值向0进行收缩，但对于任何调优参数值，它都不能将系数取值变为严格的0。尽管某些参数估计值变得非常小以至于可以忽略，但事实上Ridge并没有进行变量选择。这可能对预测精确度来说不是问题，但却对模型解释提出了挑战，尤其在变量个数大的时候。一种流行的用来替代Ridge的模型是“最小绝对收缩与选择算子”模型，通常被称为Lasso。Lasso不仅将参数估计向0收缩，当调优参数足够大时，一些参数估计将直接缩减为零，这可以达到特征选择的作用。这样一来，Lasso回归的结果更易于解释。

        可能有人会问从Ridge到Lasso，只是罚函数从二阶范数变成一阶范数，为什么Lasso就能够将参数估计收缩成0而Ridge不能呢？要回答这个问题，我们先看下Lasso和Ridge分别对应的另一版本的等价优化方程。对于Lasso而言，优化下面两个方程是等价的：

$$\begin{gathered} {\Sigma }_{i=1}^n(y_i-{\beta }_0-{\Sigma }_{j=1}^p{\beta }_j{x}_{ij}{)}^2+\lambda {\Sigma }_{j=1}^p|{\beta }_j|=RSS+\lambda {\Sigma }_{j=1}^p|{\beta }_j| \\ \underset{\beta }{\min }\left\{{\Sigma }_{i=1}^n{\left(y_i-{\beta }_0-{\Sigma }_{j=1}^p{\beta }_j{x}_{ij}\right)}^2\right\},{\Sigma }_{j=1}^p|{\beta }_j|\le s\text{\hspace{1em}(1)} \end{gathered}$$

        也就是说，对每个调优参数$\lambda$的取值，都存在相应的$s$值，使得上面两个方程优化后得到的参数估计相同。类似的，对于Ridge，下面两个方程等价：

$$\begin{gathered} {\Sigma }_{i=1}^n(y_i-{\beta }_0-{\Sigma }_{j=1}^p{\beta }_j{x}_{ij}{)}^2+\lambda {\Sigma }_{j=1}^p{\beta }_j^2=RSS+\lambda {\Sigma }_{j=1}^p{\beta }_j^2 \\ \underset{\beta }{\min }\left\{{\Sigma }_{i=1}^n{\left(y_i-{\beta }_0-{\Sigma }_{j=1}^p{\beta }_j{x}_{ij}\right)}^2\right\},{\Sigma }_{j=1}^p{\beta }_j^2\le s\text{\hspace{1em}(2)} \end{gathered}$$

        当$p＝2$时，Lasso的参数估计是所有满足$|{\beta }_1|+|{\beta }_2|\le s$的${\beta }_1$和${\beta }_2$取值中最小化RSS的。Ridge是估计所有满足${\beta }_1^2+{\beta }_2^2\le s$的参数取值中最小化RSS的。当$s$很大时，相应的限制条件几乎是无效的，只要参数估计能够最小化RSS即使绝对值很大也没有问题。只要$s$所定义的区域包含最小二乘解，那么收缩方法得出的参数估计和一般最小二乘回归就相同。相反，如果$s$很小，那么可能的参数取值范围就很有限。

        下面看看看看Lasso和Ridge的不同之处

        左边是Lasso对应的误差等位线和正方形限制区域，右边是Ridge对应的等位线和圆形限制区域。 上面图中围绕在$\hat{\beta }$周围的椭圆表示有相同RSS的参数估计。随着椭圆的扩大，对应的RSS增加。Lasso和Ridge的估计值就是在一定的限制区域下，椭圆不断扩张的过程中和限制区域的第一个接触点。大家想想看，如果有某个参数的估计是0的话，那么这个接触点该在哪里？一定在某条坐标轴上。由于Ridge的限制区域是圆形，所以真正的触点无法落在坐标轴上，可能无限接近，但就是到不了。这就是求之而不可得的数学诠释。所以Ridge无法将参数收缩成0，而Lasso可以。

        上面是2个参数的情况。如果参数个数是3的话，那么lasso的限制区域就是一个三位空间的多面体，而ridge的限制区域就是个球。参数个数再增加的话，就得发挥你自己想象力。希望大家理解Lasso可以进行变量选择，而Ridge不行的几何解释。

        从代数角度思考，看下面的二维示意图，Lasso的目标函数是非光滑的。我们知道对于非光滑的优化问题，它的最优解要么是在导数为0处，要么就是在不可导的地方，也就是各个角上。对于多维的Lasso，所谓的“角”，就是那些很多特征的系数为0的地方。所以Lasso会给出一个稀疏解，能有特征选择的作用。

        以上内容主要整理自：

• 为什么LASSO可以做特征选择，而Ridge却不行？：http://sofasofa.io/forum_main_post.php?postid=1001156
• 为什么Lasso回归可以做特征选择(变量挑选)而岭回归做不到呢？：https://scientistcafe.com/2016/09/11/lassoridge

 知识梳理不易，请尊重劳动成果，文章仅发布在CSDN网站上，在其他网站看到该博文均属于未经作者授权的恶意爬取信息

案例五： 正则惩罚解决过拟合（Ridge回归和Lasso回归）

模型过拟合解决的方式一般有三种：增加数据量，减少模型复杂度，正则惩罚。一般情况下，数据量基本上是确定了，模型也是指定的，可以调整的就是最后一种方式。正则惩罚的模式可以有如下三种：

• L1（Ridge回归对应绝对值）:

  

• L2（Lasso回归对应平方）:
  

• Elastic Net（L1和L2的结合）：
  

结合着实际案例进行正则惩罚的使用，数据集来自于kaagle网站，数据获取网址：https://www.kaggle.com/anthonypino/melbourne-housing-market。

3.2.1 模块加载与数据读入

新建一个python3文件，命名为正则惩罚模型.ipynb。数据集中的字段在之前的短租房和房价预测案例分析中基本上都有介绍，然后直接导入模块进行数据读取。

import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
import seaborn as sns

import warnings
warnings.filterwarnings('ignore')

dataset = pd.read_csv('./data/Melbourne_housing_FULL.csv')
dataset

输出结果如下。（数据集中共有34857条数据，21个字段）

通过nunique()方法可以快速查看各个字段中的唯一值的数量，用来确定一些分类字段（唯一值较少）和连续字段（唯一值较多）。输出结果如下，其中显然统计数值低于20的字段都可以认定为分类字段，比如房子所在的地区Regionname，而数据超过100的也基本上为数值连续字段。

3.2.2 特征工程

假定通过数据EDA 已经知道了哪些因素是重要数据特征 ，进行数据提取（通过corr()和heatmap()方法进行关联性探究）。本案例中主要探讨的是惩罚项如何使用，对于关联性这里不用再深究，直接提取有关联的字段构建数据集。

cols_to_use = ['Suburb', 'Rooms', 'Type', 'Method', 'SellerG', 'Regionname', 'Propertycount', 
               'Distance', 'CouncilArea', 'Bedroom2', 'Bathroom', 'Car', 'Landsize', 'BuildingArea', 'Price']
dataset = dataset[cols_to_use]

首先查看数据集中缺失数据情况，输出结果如下。

然后针对与不同类型的数据进行不同方式的缺失值处理，第一类数据直接进行0填充。

cols_to_fill_zero = ['Propertycount', 'Distance', 'Bedroom2', 'Bathroom', 'Car']
dataset[cols_to_fill_zero] = dataset[cols_to_fill_zero].fillna(0)

另一种，使用数据的均值进行填充。

dataset['Landsize'] = dataset['Landsize'].fillna(dataset.Landsize.mean())
dataset['BuildingArea'] = dataset['BuildingArea'].fillna(dataset.BuildingArea.mean())

标签数据一般不进行填充，而是直接进行删除。

dataset.dropna(inplace=True)

处理完毕后，再次核实缺失值数据情况，输出结果如下。

前面使用nunique()方法确定部分字段属于分类数据，而对于分类数据传入数据模型之前需要进行独热编码的处理，处理的方式直接使用get_dummies()方法即可解决。由下面的输出结果可知，构建数据集中原有15个字段扩展为745个字段。

至此，数据集清洗和转化的工作都完成了，下一步再次核实数据集的缺失值情况，没有缺失值后就可以进行模型的创建和应用

3.2.3 模型搭建与应用

（1）构建特征数据与标签数据。

X = dataset.drop('Price', axis=1)
y = dataset['Price']

（2）划分训练集和测试集。按照9:1的比例进行拆分。

from sklearn.model_selection import train_test_split
train_X, test_X, train_y, test_y = train_test_split(X, y, test_size=0.1, random_state=2)

（3）模型初始化与训练。

from sklearn.linear_model import LinearRegression
reg = LinearRegression().fit(train_X, train_y)

（4）模型评估。

模型在训练集和测试集中的表现的结果输出如下。（很显然和上一个案例创建的模型类似，都是在训练数据上表现的还算可以，但是在测试数据上面得分小于0，存在着过拟合现象）

（5）L1惩罚模型。

导入linear_model模块中的Lasso模型，其中的三个参数，可以调用使用手册查看对应的说明文档，本案例的重点不是对于参数的讲解，而是如何进行正则惩罚的使用，模型创建和训练的代码如下。

from sklearn import linear_model
lasso_reg = linear_model.Lasso(alpha=50, max_iter=100, tol=0.1)
lasso_reg.fit(train_X, train_y)

进一步评估模型在训练集和测试集中的得分，结果如下。（经过L1正则惩罚的模型在训练集和测试集上表现均可，且两者的得分情况相近，解决了过拟合的问题）

（6）L2惩罚模型

使用的方式和L1类似，导入linear_model模块下的Ridge模型，三个参数与L1中的保持一致，创建和训练模型的代码如下。

from sklearn.linear_model import Ridge
ridge_reg= Ridge(alpha=50, max_iter=100, tol=0.1)
ridge_reg.fit(train_X, train_y)

进一步评估模型在训练集和测试集中的得分，结果如下。（经过L2正则惩罚的模型在训练集和测试集上表现均可，且两者的得分情况相近，解决了过拟合的问题。与L1不同的是，L2模型在测试集上的表现要比训练集好，而L1模型却相反）

关于惩罚模型的通俗的理解，以赛车比赛为例：第一名的赛车手要比第二名、第三名快7s，这个概念相当于成绩绝对碾压。而在平时的比赛中，前三名的比分咬的很死，基本上只会存在0.1s，0.2s的差距，7s这个时间差就相当于是老手和新手的之间的对比。为了提高比赛的观赏性，避免出现这种绝对优势的情景，可以在第一名的赛车上增加负重，比如增加100kg配重，此时第一名还是领先3s，那么再加配重到200kg，比赛结果中发现此时的赛车手落后原来的第二名0.3s，这次的调整就解决了比赛选手之间的实力悬殊的问题，保证了观赏性。这个过程就类似惩罚模型的工作原理，辅助对于惩罚模型的理解。

补充（经验之谈）：在处理离散数据比较多时后使用L2惩罚模型比较好，处理连续数据模型较多时候使用L1惩罚模型比较好。

Ridge和Lasso回归代码实现–Tensorflow部分–潘登同学的机器学习笔记

python版本–3.6 ; Tensorflow版本–1.15.0 ;编辑器–Pycharm

Ridge回归

• 任务:

以iris数据集的除Sepal length的数据作为X, 以Sepal length作为Y, 用X去拟合Y；

前面已经很详细介绍过了, 这里直接看代码

代码

import matplotlib.pyplot as plt  # 画图库
import tensorflow as tf
import numpy as np  #矩阵库
from sklearn import datasets   #导入数据集
from tensorflow.python.framework import ops   #Loss函数优化器
ops.get_default_graph()
sess = tf.Session()

iris = datasets.load_iris()
X = np.array([x[1:4] for x in iris.data])
Y = np.array([y[0] for y in iris.data])

# 声明学习率, 批量大小, 占位符和模型变量
seed = 42
tf.set_random_seed(seed)
learning_rate = 0.01
batch_size = 25
x_data = tf.placeholder(shape=[None, 3], dtype=tf.float32)
y_target = tf.placeholder(shape=[None, 1], dtype=tf.float32)
W = tf.Variable(tf.random_normal(shape=[3, 1]))
b = tf.Variable(tf.random_normal(shape=[1, 1]))

# 增加线性模型
model_output = tf.add(tf.matmul(x_data, W), b)

# 声明损失函数 MSE+L2, 其为批量损失的平均值, 初始化变量, 声明优化器
L2_regularization_param = tf.reduce_mean(tf.square(W))  # L2正则项
loss = tf.expand_dims(tf.add(tf.reduce_mean(tf.square(y_target - model_output)), L2_regularization_param), 0) # MSE+L2
# `tf.square` 表示向量的平方  `tf.reduce_mean` 表示计算张量在指定维度上的平均值, 如果没有指定就是普通的算平均值
init = tf.global_variables_initializer()  # 表示初始化操作
my_opt = tf.train.GradientDescentOptimizer(learning_rate)  # 表示选择梯度下降法作为优化器
train_step = my_opt.minimize(loss)  # 最小化Loss损失
sess.run(init)  # 运行初始化操作

# 迭代遍历, 并在随机选择的数据上进行模型训练， 迭代100次 每25次迭代输出变量值和损失值, 将其用于之后的可视化
loss_vec = []  # 储存loss随迭代次数的变化, 等一下用于画图
for i in range(100):
    rand_index = np.random.choice(len(X), size=batch_size)  # 随机挑选X, 用于小批量随机梯度下降
    rand_x = X[rand_index]
    rand_y = np.transpose([Y[rand_index]])
    # 目标：最优化损失
    sess.run(train_step, feed_dict={x_data:rand_x,
                                    y_target:rand_y})
    # 更新loss值
    temp_loss = sess.run(loss, feed_dict={x_data:rand_x,
                                          y_target:rand_y})
    loss_vec.append(temp_loss)
    # 每25次打印
    if (i+1) % 25 == 0:
        print('Step:', i+1, 'w为:', sess.run(W), 'b为:', sess.run(b)[0][0])
        print('Loss为:', temp_loss)

# 抽取系数, 创建最佳拟合直线
slope = sess.run(W)[0][0]
y_intercept = sess.run(b)[0][0]
best_fit = []
for i in X:
    best_fit.append(slope * i + y_intercept)
# 绘制两幅图 第一个是拟合直线(高维空间的画图就不画了) 另一个是迭代100次的L2正则损失
plt.figure(2)
plt.plot(loss_vec, 'k--')
plt.title('Ridge loss per Generation')
plt.xlabel('Generation')
plt.ylabel('loss')
plt.show()

结果

Lasso回归

• 任务:

以iris数据集的除Sepal length的数据作为X, 以Sepal length作为Y, 用X去拟合Y；

代码

import matplotlib.pyplot as plt  # 画图库
import tensorflow as tf
import numpy as np  #矩阵库
from sklearn import datasets   #导入数据集
from tensorflow.python.framework import ops   #Loss函数优化器
ops.get_default_graph()
sess = tf.Session()

iris = datasets.load_iris()
X = np.array([x[1:4] for x in iris.data])
Y = np.array([y[0] for y in iris.data])

# 声明学习率, 批量大小, 占位符和模型变量
seed = 42
tf.set_random_seed(seed)
learning_rate = 0.01
batch_size = 25
x_data = tf.placeholder(shape=[None, 3], dtype=tf.float32)
y_target = tf.placeholder(shape=[None, 1], dtype=tf.float32)
W = tf.Variable(tf.random_normal(shape=[3, 1]))
b = tf.Variable(tf.random_normal(shape=[1, 1]))

# 增加线性模型
model_output = tf.add(tf.matmul(x_data, W), b)

# 声明损失函数 MSE+L2, 其为批量损失的平均值, 初始化变量, 声明优化器
L1_regularization_param = tf.reduce_mean(tf.abs(W))  # L1正则项
loss = tf.expand_dims(tf.add(tf.reduce_mean(tf.square(y_target - model_output)), L1_regularization_param), 0) # MSE+L1
# `tf.square` 表示向量的平方  `tf.reduce_mean` 表示计算张量在指定维度上的平均值, 如果没有指定就是普通的算平均值
init = tf.global_variables_initializer()  # 表示初始化操作
my_opt = tf.train.GradientDescentOptimizer(learning_rate)  # 表示选择梯度下降法作为优化器
train_step = my_opt.minimize(loss)  # 最小化Loss损失
sess.run(init)  # 运行初始化操作

# 迭代遍历, 并在随机选择的数据上进行模型训练， 迭代100次 每25次迭代输出变量值和损失值, 将其用于之后的可视化
loss_vec = []  # 储存loss随迭代次数的变化, 等一下用于画图
for i in range(100):
    rand_index = np.random.choice(len(X), size=batch_size)  # 随机挑选X, 用于小批量随机梯度下降
    rand_x = X[rand_index]
    rand_y = np.transpose([Y[rand_index]])
    # 目标：最优化损失
    sess.run(train_step, feed_dict={x_data:rand_x,
                                    y_target:rand_y})
    # 更新loss值
    temp_loss = sess.run(loss, feed_dict={x_data:rand_x,
                                          y_target:rand_y})
    loss_vec.append(temp_loss)
    # 每25次打印
    if (i+1) % 25 == 0:
        print('Step:', i+1, 'w为:', sess.run(W), 'b为:', sess.run(b)[0][0])
        print('Loss为:', temp_loss)

# 抽取系数, 创建最佳拟合直线
slope = sess.run(W)[0][0]
y_intercept = sess.run(b)[0][0]
best_fit = []
for i in X:
    best_fit.append(slope * i + y_intercept)
# 绘制两幅图 第一个是拟合直线(高维空间的画图就不画了) 另一个是迭代100次的L2正则损失
plt.figure(2)
plt.plot(loss_vec, 'k--')
plt.title('Lasso loss per Generation')
plt.xlabel('Generation')
plt.ylabel('loss')
plt.show()

结果

ElasticNet

还记得吗？ ElasticNet是即用L1也用L2

• 任务:

以iris数据集的除Sepal length的数据作为X, 以Sepal length作为Y, 用X去拟合Y；

代码

import matplotlib.pyplot as plt  # 画图库
import tensorflow as tf
import numpy as np  #矩阵库
from sklearn import datasets   #导入数据集
from tensorflow.python.framework import ops   #Loss函数优化器
ops.get_default_graph()
sess = tf.Session()

iris = datasets.load_iris()
X = np.array([x[1:4] for x in iris.data])
Y = np.array([y[0] for y in iris.data])

# 声明学习率, 批量大小, 占位符和模型变量
seed = 42
tf.set_random_seed(seed)
learning_rate = 0.01
batch_size = 25
x_data = tf.placeholder(shape=[None, 3], dtype=tf.float32)
y_target = tf.placeholder(shape=[None, 1], dtype=tf.float32)
W = tf.Variable(tf.random_normal(shape=[3, 1]))
b = tf.Variable(tf.random_normal(shape=[1, 1]))

# 增加线性模型
model_output = tf.add(tf.matmul(x_data, W), b)

# 声明损失函数 MSE+L2, 其为批量损失的平均值, 初始化变量, 声明优化器
L1_regularization_param = tf.reduce_mean(tf.abs(W))  # L1正则项
L2_regularization_param = tf.reduce_mean(tf.square(W))  # L2正则项
regularization_param = tf.add(L1_regularization_param, L2_regularization_param) # L1 + L2
loss = tf.expand_dims(tf.add(tf.reduce_mean(tf.square(y_target - model_output)), regularization_param), 0) # MSE+ L1 + L2
# `tf.square` 表示向量的平方  `tf.reduce_mean` 表示计算张量在指定维度上的平均值, 如果没有指定就是普通的算平均值
init = tf.global_variables_initializer()  # 表示初始化操作
my_opt = tf.train.GradientDescentOptimizer(learning_rate)  # 表示选择梯度下降法作为优化器
train_step = my_opt.minimize(loss)  # 最小化Loss损失
sess.run(init)  # 运行初始化操作

# 迭代遍历, 并在随机选择的数据上进行模型训练， 迭代100次 每25次迭代输出变量值和损失值, 将其用于之后的可视化
loss_vec = []  # 储存loss随迭代次数的变化, 等一下用于画图
for i in range(100):
    rand_index = np.random.choice(len(X), size=batch_size)  # 随机挑选X, 用于小批量随机梯度下降
    rand_x = X[rand_index]
    rand_y = np.transpose([Y[rand_index]])
    # 目标：最优化损失
    sess.run(train_step, feed_dict={x_data:rand_x,
                                    y_target:rand_y})
    # 更新loss值
    temp_loss = sess.run(loss, feed_dict={x_data:rand_x,
                                          y_target:rand_y})
    loss_vec.append(temp_loss)
    # 每25次打印
    if (i+1) % 25 == 0:
        print('Step:', i+1, 'w为:', sess.run(W), 'b为:', sess.run(b)[0][0])
        print('Loss为:', temp_loss)

# 抽取系数, 创建最佳拟合直线
slope = sess.run(W)[0][0]
y_intercept = sess.run(b)[0][0]
best_fit = []
for i in X:
    best_fit.append(slope * i + y_intercept)
# 绘制两幅图 第一个是拟合直线(高维空间的画图就不画了) 另一个是迭代100次的L2正则损失
plt.figure(2)
plt.plot(loss_vec, 'k--')
plt.title('ElasticNet loss per Generation')
plt.xlabel('Generation')
plt.ylabel('loss')
plt.show()

结果

Ridge和Lasso回归代码实现–Tensorflow部分就是这样了, 继续下一章吧！pd的Machine Learning