线性回归算法

1. 介绍

a) 什么是线性回归

找到一条直线，使得这些点的距离到这条直线的距离尽量的近，电当未知数据来的时候，就能够找到那个点，就是点的预测。 若是x的特征多，就是一个超平面，让咱们的点尽量的接近超平面.dom

b) 形式化定义：用数学来表示

(1) 假设函数机器学习

(2) 损失函数编辑器

预测值和真实值的差距函数

(3) 成本函数学习

每一个点的损失值和 除以2是为了后面化解方便测试

2. 梯度降低法

a) 梯度降低法介绍

b) 梯度降低法数学表示

c) numpy代码实现梯度降低法

import numpy as np

import matplotlib.pyplot as plt # 画图的包

# 求y=x^2+2x+5的最小值

# 函数图像

X = np.linspace(-6, 4, 100)

# 从-6到4之间取值，取100个值。

Y = x**2 + 2*x + 5 Plt.plot(x, y)

# 画出函数图像

# 初始化 x，a和迭代次数

X=3

# random函数，随便多少都行

Alpha = 0.8

# 步长

IterateNum =10

# 迭代次数 y的导数为2x+2，迭代次数theta

For i in range(iterateNum):

x = x - alpha*(2*x+2)

# 最后输出x

参数设置的重要性 alpha参数 alpha决定参数往最值方向走的速度，若是参数设置的太小，那么x每次就只是走一点点，当数据不少很复杂的时候，降低的速度就会很慢，会通过不少次才会到达最低点； alpha给的过于大，就会一会儿越过最低点，再下一次又跑到其余地方去了，就会在最低点的地方不断的震荡，没法收敛到最小值。 因此alpha不能过于大，也不能过于小。优化

iteraterNum迭代次数设置 到底迭代多少次它能达到最小值呢？有几种方法。ui

方法一： 上一次迭代的最小值下一次迭代和上一次迭代的值很相近了，不怎么变化了，收敛了。2 》1.96 〉1.9601》1.960001这时候能够去设置上一次的值和如今的值的差值，若是这个差值是在某一个很小的范围内，咱们就认为这个迭代收敛了。spa

方法二： 花损失函数的图像，当两个损失值相差很少的时候，就能够结束迭代。

d) 梯度降低法求解线性回归问题

(1) 公式推导

但愿代价函数越小越好，就要对它进行梯度降低。

(2) 例子

上面的迭代公式如何用呢？

(3) 使用梯度降低求解线性回归问题的代一码实现

i) 加载数据

# 数据集 6.1101，17.592  一行两条数据，分隔符是逗号，第二条是实际值

Import numpy as np

Import matplotlib.pyplot as plt

# 定义一个加载数据的函数

Def loaddata():

data = np.loadtxt(‘data/data1.txt’, delimiter=‘,’)

n = data.shape[1] - 1

# 特征数，有一条是实际值，因此减去1

x = data[:, 0:n] # 全部行，从0开始的第n个特征。

y = data[:, -1].reshape(-1, 1) # 全部行取最后一列。

return x, y # 这里的x尚未加入1的那列。

ii) 梯度降低法

def gradientDescent(x, y, iterations, alpha):

c = np.ones(x.shape[0]).transpose() # 全是1的列向量

x = np.insert(x, 0, values=c, axis=1) # 在x的0列上插入值c，对原始数据加入一个全为1的列

m = x.shape[0] # 数据量

n = x.shape[1] # 特征数

for num in range(iterations):

for j in range(n): # 对每一个特征进行更新

theta[j] = theta[j]*(alpha/m)*(y - np.dot(x, theta)*x[:,j].reshape(-1, 1)))

return theta

iii) 当前状况下调用代码

# 调用它

X, y = loaddata()

Theta = np.zera(x.shape[1]+1).reshape(-1, 1) # 多加一列至关于b，theta0那一列。

Iterations = 400 # 设定初始值

Alpha = 0.01

Theta = gradDescent(x, y, theta, iterations, alpha) # 求出theta值

# 画出图像

Plt.scratter(x, y)

# 散点图

H_theta = theta[0]+theta[1]*x

# 画出对应的直线

y = theta0*x0+theta1*x1 Plt.plot(x, h_theta)

iv) 特征归一化 特征数据的差值很大，不在一个量纲上，因此须要提早作一个归一化，比较简单，(x-均值)/方差。

Def featureNormalize(X):

mu = np.average(X, axis=0) # x第0列的均值

sigma = np.std(x, axis=0, doff=1) # doff是求方差的时候是除以n仍是n-1.

x = (x-mu)/sigma # 归一化

return x, mu, sigma # 再调用上一个块的函数。

v) 画损失函数图

画出这个图像对咱们观察大概迭代到哪一次它的迭代基本上就不会下降了，对于咱们观察算法是很好的方式。

# 损失函数

Def computeCost(x, y, theta):

m = x.shape[0] np.sum(np.power(np.dot(x, theta) - y, 2))/(2*m))

# 更新前面的代码。

def gradientDescent(x, y, iterations, alpha):

c = np.ones(x.shape[0]).transpose() # 全是1的列向量

x = np.insert(x, 0, values=c, axis=1) # 在x的0列上插入值c，对原始数据加入一个全为1的列

m = x.shape[0] # 数据量

n = x.shape[1] # 特征数

costs = np.zeros(iterations)

for num in range(iterations):

for j in range(n): # 对每一个特征进行更新

theta[j] = theta[j]*(alpha/m)*(y - np.dot(x, theta)*x[:,j].reshape(-1, 1))/)

costs[num] = computerCost(x, y, theta)

return theta, costs

# 接着调用运行的代码。

# 画损失函数值

X_axis = np.linspace(1, iterations, iterations) # x轴，从1开始到迭代次数，取迭代次数那么多个

Plt.plot(x_axis, costs[0:iterations]) # 每次迭代取出cost值。

vi) 预测函数

Def predict(x):

x = (x-mu)/sigma # 依然要归一化

c = np.ones(x.shape[0]).transpose()

x = np.insert(x, 0, value=c, axis=1) # 加一层1的列向量

return np.dot(x, theta) # 代入公式

(4) 梯度降低法的优化(变形)

i) 批量梯度降低法

要用到x里面的全部数据依次更新，在theta0，theta1更新的时候，咱们要用上全部的数据，每一个theta更新咱们都要用上全部数据，若是数据量不大其实也还好，可是若是数据量上百万千万的时候，作一次更新是很是耗时的。因此提出随机梯度降低。

ii) 随机梯度降低法

与批量梯度降低的区别就是没有求和了，咱们的每个参数更新只选择一个样本就能够了。好比咱们第一次拿出来的是样本1，那么咱们就能够更新每一个theta了，下一次能够拿出来样本2.能够加快随机梯度降低的速度，减小计算量。 有个问题，每次都是拿一个样本，这个样本降低的方向不是咱们减小最快的方向，就是会震荡降低，若是用全部样本至关于全局样本都看了一遍，相对来讲降低方向是比较准确的。因此提出小批量梯度降低。

iii) 小批量梯度降低法

它是介于批量梯度降低和随机梯度降低的折中。咱们每次只取一部分。咱们先把x的样本顺序打乱，好比batch—size取2，此次取2条进行一次梯度降低，下次再取2条进行梯度降低。综合前两个的优势即选择一批梯度降低，样本个数又不会太多，因此在实际应用中，尤为是数据量比较大的时候，推荐使用小批量梯度算法。

3. 模型评价指标

a) 均方偏差(MSE)

Y_true = np.array([1, 2, 3, 4, 5])

Y_pred = np.array([1.1, 2.2, 3.1, 4.2 ,5])

Def mse(y_true, y_pred):

return np.sum(np.power(y_true-y_pred, 2))/len(y_true)

b) 均方根偏差(RMSE)

def rmse(y_true, y_pred):

return np.sqrt(np.sum(np.power(y_true-y_pred, 2))/len(y_true))

c) 平均绝对偏差(MAE)

def Mae(y_true, y_pred):

return np.sum(np.abs(y_true-y_pred))/len(y_true)

4. 欠拟合与过拟合的概念

a) 欠拟合与过拟合

欠拟合：训练出来的结果没有很好的拟合数据。

过拟合：虽然每一个点都穿过了，可是不能预测将来的数据，它的泛化能力差，过度的拟合了训练数据，可是没法很好的对咱们的预测数据进行预测。

适合的拟合：不是全部的点都穿过，基本上符合数据的走势，当咱们对预测数据进行预测的时候，这条数据就可以很好的表示这样的测试数据。

因此但愿训练出来的模型是对训练数据拟合的不错，同时对测试数据预测也不错的一条曲线。

b) 正则化

为了解决过拟合的风险，提出了几种正则化的方式。

(1) 岭回归

在原来的代价函数基础上加入一个参数的二范式，对参数加入一个惩罚因子lamda，这个项是正则化项。 加入了二范式的惩罚因子之后，咱们也把它叫作L2正则化，使用了L2正则化的线性回归叫作岭回归。

i) 岭回归求解

def gradientDescent_ridge(x, y, iterations, alpha, lamda=0.02):

c = np.ones(x.shape[0]).transpose() # 全是1的列向量

x = np.insert(x, 0, values=c, axis=1) # 在x的0列上插入值c，对原始数据加入一个全为1的列

m = x.shape[0] # 数据量 n = x.shape[1] # 特征数

for num in range(iterations):

for j in range(n): # 对每一个特征进行更新

theta[j] = theta[j]*(alpha/m)*(y - np.dot(x, theta)*x[:,j].reshape(-1, 1)))-2*lamda*theta[j]

return theta # 只改变了蓝色部分。

ii) 为何使用岭回归能够减少过拟合

H0(x) = theta0 + theta1*x1 + theta2*x2 + theta3*x3 1+0.1*x1 + 0.0001*x2 + 0.6*x3

Theta2的数值很是的小，就是说给定x1,x2,x3这些训练数据的时候，x2对于函数值的影响比较小。一个很小的数乘以一个数，相对来讲它的结果会比较小，那么这个结果加上去对这个函数的影响就会比较小。至关于只有x1，x3起做用，三个特征只有两个特征起做用，这个模型相对来讲就比较简单，模型越简单，过拟合风险就越小，越复杂过拟合风险就越大。模型越复杂拟合程度就会越好。既然想减小过拟合风险，就要想办法使得模型简单，就是想办法让某一个theta值变得很小，theta小的时候特征就再也不起做用，因此经过训练 数据去决定哪一个theta比较小。 看thetaj最后的推导结果，提出thetaj，(1-2lamda)thetaj，假设lamda是0～1，1-2lamda就是0～1，乘以thetaj确定比原来的thetaj要小，中间的项能够看做一个定值，因此新的thetaj是更小的，5》4.7〉4.5 减少的程度由训练数据决定的，好比有的减少速度很快，theta2，那么它就不重要。

(2) LASSO回归

使用了L1范式的线性回归咱们把它叫作LASSO回归。

i) 求解

ii) 举例

iii) 代码实现LASSO回归

Import numpy as np

Import matplotlib.pyplot as plt

# 定义一个加载数据的函数

Def loaddata():

data = np.loadtxt(‘data/data1.txt’, delimiter=‘,’)

n = data.shape[1] - 1 # 特征数

x = data[:, 0:n]

y = data[:, -1].reshape(-1, 1)

return x, y

# 特征归一化 归一化方法有不少，这里是： 对每一个特征，这列中的每一个数据分别减去这列的均值，再除以这列的方差。

Def featureNormalize(x):

mu = np.average(x, axis=0)

sigma = np.std(x, axis=0, Dodd=1)

x = (x - mu)/sigma

return x, mu, sigma

# LASSO回归的核心代码

Def lasso_regression(x, y, iterations, lambd=0.2):

m, n = x.shape # 数据的行数和特征数

theta = np.matrix(np.zeros((n, 1))) # 参数，跟x的特征数一致

for it in range(iterations):

for k in range(n): # n个特征

# 计算常量值z_k和p_k

z_k = np.sum(x[:, k]**2)

# 当前数据的第k个特征

p_k = 0

for i in range(m):

p_k += x[i, k]*(y[i, 0]-np.sum([x[i,j]*theta[j, 0] for j in range(n) if j != k]))

# z_k是个临时变量，根据p_k的不一样取值进行计算

if p_k

w_k = (p_k+lamda/2)/z_k

elif p_k > lamda/2:

w_k = (p_k-lamda/2)/z_k

else:

w_k = 0

theta[k, 0] = w_k

return theta

# 调用代码

X,y = loaddata()

X, mu, sigma = featureNormalize(x) # 数据归一化

x_1 = np.insert(x, 0, values=1, axis=1) # 插入一列值为1的数据。

Theta = lasso_regression(x_1, y, 100)

Print(theta)

plt.scatter(x, y)

Line = theta[0, 0] + theta[1, 0]*x

Plt.plot(x, line)

(3) 弹性网

综合L1与L2解决过拟合，咱们把它叫作弹性网。rou是L1和L2的比例。

5. 使用Sklearn实现线性回归

a) 最小二乘法求解线性回归

b) 最小二乘法的代码实现

Import numpy as np

Import matplotlib.pyplot as plt

Def loaddata():

data = np.loadtxt(‘data/data1.txt’, delimiter=‘,’)

n = data.shape[1]- 1

x = data[:, 0:n]

y = data[:, -1].reshape(-1, 1)

return x, y

X_origin, y = loaddata()

X = np.insert(x_origin, 0, values=1,axis=1) # 加入一列全是1的特征 求解theta

Theta = np.Linalg.inv(x.T.dot(x)).dot(x.T).dot(y)

"""

(1)当数据量比较大的时候，求矩阵的逆其实也蛮慢的，因此数据量比较大的时候就仍是用梯度降低法迭代。

(2)若是矩阵的逆不存在，那么求解逆就会出错，能够改写括弧里面加一个lamda*I(对角线都是1)，保证逆存在。

"""

# 画图

Plt.scatter(x_origin, y)

h_theta = theta[0] + theta[1]*x_origin

Plt.plot(x_origin, h_theta)

c) 使用Sklearn实现Ridge，LASSO和ElasticNet

(1) 加载数据

Import numpy as np

Import matplotlib.pyplot as plt

From sklearn import linear_model

Def loaddata():

data = np.loadtxt(‘data/data1.txt’, delimiter=‘,’)

n = data.shape[1] - 1

x = data[:, 0:n] y = data[:, -1].reshape(-1, 1)

return x, y

X, y = loaddata()

(2) 画图

Plt.scatter(x, y)

Y_hat = model1.predict(x)

Plt.plot(x, y_hat)

(3) 最小二乘

Model1 = linear_model.LinearRegression()

Model1.fit(x, y) Print(model1.coef_) # 输出系数，theta_1到theta_n

Print(model1.intercept_) # 输出截距，输出theta_0

(4) Ridge

Model2 = linear_model.Ridge(alpha=0.01，normalize=True) # 这里的alpha至关于课堂上的lamda，表示正则化强度。

Model2.fit(x, y)

Print(model2.coef_) # 输出系数，theta_1到theta_n

Print(model2.intercept_) # 输出截距，输出theta_0

(5) LASSO

Model3 = linear_model.Lasso(alpha=0.01，normalize=True) # 这里的alpha至关于课堂上的lamda，表示正则化强度。

Model3.fit(x, y) Print(model3.coef_) # 输出系数，theta_1到theta_n

Print(model3.intercept_) # 输出截距，输出theta_0

(6) ElasticNet

Model2 = linear_model.ElasticNet(alpha=0.01，normalize=True) # 这里的alpha至关于课堂上的lamda，表示正则化强度。

Model2.fit(x, y) Print(model2.coef_) # 输出系数，theta_1到theta_n

Print(model2.intercept_) # 输出截距，输出theta_0

6. 案例： 波士顿房价预测

a) 机器学习项目流程

一、获取数据

不管是本身收集，仍是公开等等。

二、数据预处理(数据清洗)

数据不干净，有缺失值不全，数据有错误的值，有重复的数据。

三、数据分析和可视化

人为的分析数据，可视化，抽出几个维度看看什么关系，对数据有一些了解。

四、选择适合的机器学习模型

根据数据的样子选择一学习机器学习模型，看看什么模型适合，什么不适合，多用几个看看。

五、训练模型(使用交叉验证选择合适的参数)

模型里面有不少参数，用交叉验证选择合适的参数。

六、评价模型

看看它在测试集上面的表现如何，若是在测试集上表现不错，就能够进入到上线部署。

七、上线部署使用模型

b) 代码

(1) 引入包

Import numpy as np

Import matplotlib.pyplot as plt

From sklearn import linear_model

From sklearn.datasets import load_boston # 直接加载波士顿数据

From sklearn.model_selection import train_test_split

From sklearn.metrics import mean_squared_error From sklearn.metrics

import mean_absolute_error

(2) 获取数据

# 一、自帶的數據集

Boston = load_boston()

"""特征含义

CRIM: 城镇人均犯罪率

ZN: 住宅用地超过 250000 的比例

INDUS：城镇非零售土地的比例

CHAS：查理斯河空变量(若是边界是河流，则1，不然0)

NOX：一氧化碳浓度

RM：住宅平均房间数

AGE：1940年以前建成自用房屋比例

DIS：到波士顿五个中心区域的加权距离

RAD：辐射性千米的接近指数

TAX：每10000美圆的全值财产税率

PTRATIO：城镇师生比例 B：1000^2，其中Bk指代城镇中黑人比例

LSTAT：人口中地位低下者的比例

MEDV：自住房的平均房价，以千美圆计

"""

Boston.DESCR # 对数据集的描述

# 二、从文件中读取数据集

Import pandas as pd

Df = pa.read_excel(‘data/boston.xls’)

X = df[df.columns[0:-1]]

y = df[df.columns[-1]]

(3) 选择适合的机器学习模型

model1 =linear_model.Ridge(alpha=0.1)

Model1.fit(x, y)

Y_hat = model.predict(x)

代码

X_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2) # 分割数据

# 交叉验证

From sklearn.model_selection import GridSearchCV

Ridge_model = {‘alpha’: [0.01, 0.03, 0.05, 0.07, 0.1, 0.5, 0.8, 1], ‘normalize’: [True，Fasle]}

# ridge模型里面须要调节的参数

Gsearch = GridSearchCV(

estimator=ridge_model, # 什么模型

param_grid=param, # 调节的参数，而后就会对每一个参数值一一匹配，找出最大值那个

cv=5, # 5折交叉验证

scoring=‘neg_mean_squared_error’) # 采起什么评分，均方偏差，只不过前面加了一个负号

# 而后查看训练出来的参数

Gsearch.best_params_, gsearch.best_score_

(4) 模型评价和上线部署

五、模型评价

Final_model = linear_model.Ridge(alpha=0.01, normalize=True)

Final_model.fit(x_train, y_train)

Y_test_hat = Final_model.predict(x_test)

Print(“test MSE”, mean_squared_error(y_test, y_test_hat))

实际上GridSearchCV会运行好屡次的，此次0。03效果好，舅子0.03附近多取几个数。

六、上线部署

六、1模型保存

from sklaern.externals import joblib

Joblib.dump(final_model, “house_train_model.m”)

六、2模型读取

Load_model = joblib.load(“house_train_model.m”)