普通线性回归/岭回归/lasso回归[x.T/np.dot/lrg.coef_/lrg.intercept_/Xw = y/r2

基础运算

导包

import numpy as np

随机产生数据集

a = np.random.randint(0,10,size = (2,3))
a
Out：
array([[2, 8, 2],[8, 3, 3]])

转置：x.T

b = a.T
b
Out：
array([[2, 8],[8, 3],[2, 3]])

矩阵的乘积：np.dot(a,b)

# 方阵
np.dot(a,b)
Out:
array([[72, 46],[46, 82]])np.dot(b,a)
Out:
array([[68, 40, 28],[40, 73, 25],[28, 25, 13]])

# 3行2列
c = np.random.randint(0,10,size = (3,2))
d = np.random.randint(0,10,size = (2,4))display(c,d)
Out:
array([[0, 5],[7, 8],[9, 4]])array([[5, 8, 5, 5],[5, 6, 2, 3]])np.dot(c,d)
Out:
array([[ 25,  30,  10,  15],[ 75, 104,  51,  59],[ 65,  96,  53,  57]])np.dot(d,c)
Out:
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-8-f18b888c5625> in <module>()
----> 1 np.dot(d,c)ValueError: shapes (2,4) and (3,2) not aligned: 4 (dim 1) != 3 (dim 0)

【关键词】最小二乘法，线性

一、普通线性回归

1、原理

分类的目标变量是标称型数据，而回归将会对连续型的数据做出预测。

应当怎样从一大堆数据里求出回归方程呢？

假定输人数据存放在矩阵X中，而回归系数存放在向量W中。那么对于给定的数据X1, 预测结果将会通过Y=X*W给出。现在的问题是，手里有一些X和对应的Y,怎样才能找到W呢？

一个常用的方法就是找出使误差最小的W。这里的误差是指预测Y值和真实Y值之间的差值，使用该误差的简单累加将使得正差值和负差值相互抵消，所以我们采用平方误差。

最小二乘法

平方误差可以写做:

对W求导，当导数为零时，平方误差最小，此时W等于：

求解W【一个矩阵乘以单位矩阵，还是自身】

x1=np.random.randint(0,5,(2,2))
y1=np.random.randint(0,5,(2,1))
display(x1,y1)
Out：
array([[3, 2],[1, 0]])array([[4],[2]])
'''
公式：w = (X^T * X)^(-1) * X^T *y
（1）np.linalg.inv()：矩阵求逆
（2）np.linalg.det()：矩阵求行列式（标量）
'''
s1=np.linalg.inv(np.dot(x1.T,x1))
s2=np.dot(x1.T,y1)
display(s1,s2)
Out：
array([[ 1. , -1.5],[-1.5,  2.5]])array([[14],[ 8]])np.dot(s1,s2)
Out：
array([[ 2.],[-1.]])'''或者'''
np.dot(np.dot(s1,x1.T),y1)
Out：
array([[ 2.],[-1.]])

公式推导

# w是方程的系数f(x) =Xw
# X和y都是矩阵
# y 和X都是已知数据
#  w是未知的
(y - Xw)**2# y - Xw   -----> -X
2(y - Xw)(-X) = 0
(y - Xw)(X) = 0
y - Xw = 0# 矩阵
Xw = y# 矩阵要想求解逆矩阵，条件：必须是方阵
X.TXw = X.Ty# np.linalg.inv(X.TX) == INV
INVX.TXw = INVX.Ty
w = INVX.Ty

例如有下面一张图片：

求回归曲线，得到：

2、实例

导包

from sklearn.linear_model import LinearRegression

有特征数据集：1,0,2 ；对应结果数据集：7,4,10

X = [[1],[0],[2]]
y = [7,4,10]
# 使用线性回归算法
lrg = LinearRegression()
# 使用线性回归算法进行训练fit（特征值，结果值）
lrg.fit(X,y)
Out：
LinearRegression(copy_X=True, fit_intercept=True, n_jobs=1, normalize=False)# 系数
lrg.coef_
Out：
array([3.])# 截距
lrg.intercept_
Out：
4.0'''
可知w=3,b=4,即 f(x) = 3x + 4 ——>机器学习都是在解方程
验证：当x=1时，y=7 满足方程
'''

解二元一次方程

# 2x + y = 8
# x - y = 10
# x + y = 2
# 2x - y = 16

X = np.array([[2,1],[1,-1],[1,1],[2,-1]])
y = np.array([8,10,2,16])# 大量数据，总结大量数据数据
lrg = LinearRegression()lrg.fit(X,y)display(lrg.coef_,lrg.intercept_)
Out：
array([ 6., -4.])
1.7763568394002505e-15'''
2元一次方程 x = 6 y = -4
'''

举栗子①

获取糖尿病数据

import sklearn.datasets as datasets

diabetes = datasets.load_diabetes()
diabetes
'''
'feature_names': [
'age','sex','bmi','bp','s1','s2', 's3','s4','s5','s6']
'''

假设Data---->target 关系线性

f(diabets) = age*w1 + sex*w2 + bmi*w3 + …… + s6*w10 + b

# age，性别，体重指数，血压，血液的数据6个
# 是不是线性
# 假设Data---->target 关系线性
# f(diabets) = age*w1 + sex*w2 + bmi*w3 + …… + s6*w10 + b
# 将复杂的问题，简单化----->大概解决lrg = LinearRegression()X = diabetes['data']
y = diabetes['target']
display(X.shape,y.shape)
Out:
(442, 10)
(442,)lrg.fit(X,y)
Out: LinearRegression(copy_X=True, fit_intercept=True, n_jobs=1, normalize=False)

10个未知数，442个方程

求解系数w和截距b

lrg.coef_
Out:
array([ -10.01219782, -239.81908937,  519.83978679,  324.39042769,-792.18416163,  476.74583782,  101.04457032,  177.06417623,751.27932109,   67.62538639])lrg.intercept_
Out:
152.1334841628965

取第300个数据集

X[300]
Out：
array([ 0.01628068, -0.04464164,  0.07355214, -0.04124694, -0.00432087,-0.01352667, -0.01394774, -0.00111622,  0.04289569,  0.04448548])

使用线性算法训练的模型预测结果数据

lrg.predict(X[300].reshape(1,10))
Out：
array([218.13375502])

使用求解系数w和截距b的公式求解结果数据

'''
f(diabets) = age*w1 + sex*w2 + ……+s6*w10 + b
age,sex……s6 ：X[300]
w1,w2,……w10：lrg.coef_
b : lrg.intercept_
'''
np.dot(X[300],lrg.coef_) + lrg.intercept_
Out：
218.1337550171172y[300]
Out: 275.0

举栗子②

导入数据集

boston = datasets.load_boston()
boston
'''
'feature_names': array(['CRIM', 'ZN', 'INDUS', 'CHAS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD',
'''

线性算法训练数据集

lrg = LinearRegression()
X = boston['data']
y = boston['target']lrg.fit(X,y)
Out：
LinearRegression(copy_X=True, fit_intercept=True, n_jobs=1, normalize=False)

预测

# 使用线性算法训练模型预测后20个特征数据
y_ = lrg.predict(X[-20:])
display(y_,y[-20:])
Out：
array([19.65423066, 21.324671  , 11.86231364,  8.22260592,  3.65825168,13.76275951, 15.93780944, 20.62730097, 20.61035443, 16.88048035,14.01017244, 19.10825534, 21.29720741, 18.45524217, 20.46764235,23.53261729, 22.37869798, 27.62934247, 26.12983844, 22.34870269])array([19.1, 20.6, 15.2,  7. ,  8.1, 13.6, 20.1, 21.8, 24.5, 23.1, 19.7,18.3, 21.2, 17.5, 16.8, 22.4, 20.6, 23.9, 22. , 11.9])

二、岭回归

导包

# 岭回归依然是线性模块，所以Ridge和线性回归类似
# 不同
from sklearn.linear_model import Ridge

不是满秩的矩阵不能求解逆矩阵（np.linalg.matrix_rank(a)）

a = np.array([[1,2,3],[2,3,4],[2,4,6]])
a
Out：
array([[1, 2, 3],[2, 3, 4],[2, 4, 6]])# 不是满秩矩阵
np.linalg.matrix_rank(a)
Out： 2# 求逆矩阵报错
np.linalg.inv(a)
Out:
---------------------------------------------------------------------------
LinAlgError                               Traceback (most recent call last)
<ipython-input-59-b24b020fe220> in <module>()
----> 1 np.linalg.inv(a)

满秩的矩阵可以求解逆矩阵

b = np.eye(3)
b
Out：
array([[1., 0., 0.],[0., 1., 0.],[0., 0., 1.]])c = a + b
c
Out：
array([[2., 2., 3.],[2., 4., 4.],[2., 4., 7.]])np.linalg.matrix_rank(c)
Out：3# 如果矩阵的秩，满秩的
# 可以求解逆矩阵了
np.linalg.inv(c)
Out:
array([[ 1.        , -0.16666667, -0.33333333],[-0.5       ,  0.66666667, -0.16666667],[ 0.        , -0.33333333,  0.33333333]])

举栗子

以一个具体的例子来看。假设一帮孩子和家长出去旅游，去程坐的是bus，小孩票价为3元，家长票价为3.2元；
回程坐的是Train，小孩票价为3.5元，家长票价为3.6元。
问题是分别求小孩和家长的人数。我们就可以用下列矩阵求之。

'''
以一个具体的例子来看：
假设一帮孩子和家长出去旅游，去程坐的是bus，小孩票价为3元，家长票价为3.2元；
回程坐的是Train，小孩票价为3.5元，家长票价为3.6元。
问题是分别求小孩和家长的人数，我们就可以用下列矩阵求之。
# 3x + 3.2y = 118.4
# 3.5x + 3.6y = 135.2
'''
X = np.array([[3,3.2],[3.5,3.6]])
y = np.array([118.4,135.2])'''w 代表着大人和小孩的数量Xw = yw = (X^-1)y
'''
# 求解 w
np.dot(np.linalg.inv(X),y)
Out:
array([16., 22.])

岭回归的作用

如果数据的特征比样本点还多应该怎么办？是否还可以使用线性回归和之前的方法来做预测？
答案是否定的，即不能再使用前面介绍的方法。这是因为输入数据的矩阵X不是满秩矩阵。非满秩矩阵在求逆时会出现问题。
为了解决这个问题，统计学家引入了岭回归（ridge regression)的概念

缩减方法可以去掉不重要的参数，因此能更好地理解数据。此外，与简单的线性回归相比，缩减法能取得更好的预测效果。
岭回归是加了二阶正则项的最小二乘，主要适用于过拟合严重或各变量之间存在多重共线性的时候，岭回归是有bias的，这里的bias是为了让variance更小。

归纳总结

1.岭回归可以解决特征数量比样本量多的问题
2.岭回归作为一种缩减算法可以判断哪些特征重要或者不重要，有点类似于降维的效果
3.缩减算法可以看作是对一个模型增加偏差的同时减少方差
岭回归用于处理下面两类问题：
1.数据点少于变量个数
2.变量间存在共线性（最小二乘回归得到的系数不稳定，方差很大）

# 300个方程，500个未知数
统计数据.shape = (300,500)----->500系数 ---->特征、属性

2、实例

岭回归一般用在样本值不够的时候

'''此处参数alpha == lambda如果alpha = 0 ----领回归就变成了普通的线性回归
'''
ridge = Ridge(alpha = 1)ridge.fit(X,y)
Out:
Ridge(alpha=1, copy_X=True, fit_intercept=True, max_iter=None,normalize=False, random_state=None, solver='auto', tol=0.001)

使用岭回归算法

# 领回归：
y_ = ridge.predict(X[-20:])
display(y_,y[-20:])Out:
array([19.29761443, 21.10662988, 11.35909077,  7.60740964,  2.97923905,13.24858019, 15.58528884, 20.92928039, 20.97861581, 17.32864056,14.14726143, 19.34761433, 21.53915843, 18.60665716, 20.61884555,23.9462061 , 22.71180209, 27.93031657, 26.44766018, 22.68549172])
array([19.1, 20.6, 15.2,  7. ,  8.1, 13.6, 20.1, 21.8, 24.5, 23.1, 19.7,18.3, 21.2, 17.5, 16.8, 22.4, 20.6, 23.9, 22. , 11.9])

如果alpha = 0 岭回归就变成了普通的线性回归

# 如果alpha = 0 ----领回归就变成了普通的线性回归
ridge = Ridge(alpha = 0)
ridge.fit(X,y)y_ = ridge.predict(X[-20:])
display(y_,y[-20:])
Out:
array([19.65423066, 21.324671  , 11.86231364,  8.22260592,  3.65825168,13.76275951, 15.93780944, 20.62730097, 20.61035443, 16.88048035,14.01017244, 19.10825534, 21.29720741, 18.45524217, 20.46764235,23.53261729, 22.37869798, 27.62934247, 26.12983844, 22.34870269])
array([19.1, 20.6, 15.2,  7. ,  8.1, 13.6, 20.1, 21.8, 24.5, 23.1, 19.7,18.3, 21.2, 17.5, 16.8, 22.4, 20.6, 23.9, 22. , 11.9])

三、lasso回归

导包

from sklearn.linear_model import Lasso

1、原理

【拉格朗日乘数法】

对于参数w增加一个限定条件，能到达和岭回归一样的效果：

在lambda足够小的时候，一些系数会因此被迫缩减到0

boston = datasets.load_boston()
X = boston['data']
y = boston['target']display(X.shape,y.shape)
Out：
(506, 13)
(506,)

普通线性回归

lrg = LinearRegression()
lrg.fit(X,y)y_ = lrg.predict(X[-20:])
display(y_,y[-20:])
Out：
array([19.65423066, 21.324671  , 11.86231364,  8.22260592,  3.65825168,13.76275951, 15.93780944, 20.62730097, 20.61035443, 16.88048035,14.01017244, 19.10825534, 21.29720741, 18.45524217, 20.46764235,23.53261729, 22.37869798, 27.62934247, 26.12983844, 22.34870269])
array([19.1, 20.6, 15.2,  7. ,  8.1, 13.6, 20.1, 21.8, 24.5, 23.1, 19.7,18.3, 21.2, 17.5, 16.8, 22.4, 20.6, 23.9, 22. , 11.9])

使用lasso回归算法

lasso = Lasso(alpha=1)
lasso.fit(X,y)y_ = lasso.predict(X[-20:])
display(y_,y[-20:])
Out：
array([19.24330788, 21.457258  , 12.1730258 ,  7.37085594,  2.45397245,12.72391244, 15.8918641 , 21.89390353, 20.65287424, 16.76589151,14.75113172, 20.38438031, 21.71037125, 19.7966713 , 20.88700534,23.90404166, 24.23416367, 28.04250156, 27.0151864 , 25.00282962])
array([19.1, 20.6, 15.2,  7. ,  8.1, 13.6, 20.1, 21.8, 24.5, 23.1, 19.7,18.3, 21.2, 17.5, 16.8, 22.4, 20.6, 23.9, 22. , 11.9])

四、普通线性回归、岭回归与lasso回归比较

导包，导入sklearn.metrics.r2_score用于给模型打分

from sklearn.metrics import r2_score

使用numpy创建数据X，创建系数，对系数进行处理，对部分系数进行归零化操作，然后根据系数进行矩阵操作求得目标值
增加噪声

''' 50个样本数据，200个特征数据 '''
smapes = 50
features = 200
X = np.random.randn(smapes,features)

w = np.random.randn(features)
w
Out:
array([ 2.65919549,  0.53463105,  0.69463205,  0.50774209,  0.25268796,0.4639237 ,  0.96151096, -0.03447678,  0.14268437, -0.0135876 ,-1.59657353, -1.4496309 , -2.21753706,  0.15978437,  0.60327467,0.35251854, -0.09908555,  1.27359032,  0.83536267, -0.19743705,
……

打乱的下标

index = np.arange(200)
np.random.shuffle(index)
index
Out：
array([129, 113, 144,  68,  69,  91, 135,  63,  83, 163, 185, 111, 100,10,  75, 147, 168, 177, 116, 167, 152,  22,   1,  33,  44,  92,
……

让部分w变0

# 复杂问题，------>简单
w[index[:190]] = 0
w

求出结果数据值

y = np.dot(X,w)
y
Out：
array([-2.06915415,  0.75602271,  1.68583087, -0.50380867, -1.70273373,0.25883931,  3.37157387, -2.65197656,  2.75909651, -0.9338132 ,-1.07130213,  0.17220665, -0.37184521, -0.90420979,  2.2804321 ,1.951437  , -3.37082395, -1.09482486, -0.49763548,  0.96388205,-0.55710526, -0.24215568, -2.56041668,  2.77614458,  3.24834267,4.00069945, -0.75220753,  0.84390147, -0.64063876,  0.17820628,0.23760335, -1.78851945,  0.10202367,  3.30420819,  0.3857338 ,-5.14745813,  2.92096927, -2.8058189 , -1.3376047 ,  1.22534598,0.5108669 , -0.81571537,  4.85131057, -1.0107182 , -2.40542963,2.47543333,  0.37111005,  0.10050113,  0.11309061,  0.42835218])

分别使用线性回归，岭回归，Lasso回归进行数据预测

lrg = LinearRegression()ridge = Ridge(alpha=1)lasso = Lasso(alpha=0.3)

数据视图，此处获取各个算法的训练数据的coef_:系数

plt.figure(figsize=(12,9))
axes = plt.subplot(2,2,1)axes.plot(w)
axes.set_title('True')# 线性
axes = plt.subplot(2,2,2)
lrg.fit(X,y)
axes.plot(lrg.coef_)
axes.set_title('LinearRegressor')# Lasso
axes = plt.subplot(2,2,3)
lasso.fit(X,y)
axes.plot(lasso.coef_)
axes.set_title('Lasso')# Ridge
axes = plt.subplot(2,2,4)
ridge.fit(X,y)
axes.plot(ridge.coef_)
axes.set_title('Ridge')

预测并使用r2_score评价回归模型【R2 决定系数（拟合优度）】

模型越好：r2→1
模型越差：r2→0
用法：r2_score(y_true,y_pred)