python求解多元方程最优解_Python实现梯度下降算法求多元线性回归(二)

前言

上一篇我们对数据进行了读取并进行了可视化，今天我们来继续实现算法。

完整代码会在最后给出，如果你直接复制下面零散的代码可能会运行不了。

这篇的代码已经默认import了pandas,numpy等模块。

数据标准化

首先我们先取要用的三列数据作为训练数据集：

trainData = cReader[['mpg','displacement','acceleration']]

trainData.insert(0,'ones',1)

cols = trainData.shape[1]

X = trainData.iloc[:,0:cols-1]

Y = trainData.iloc[:,cols-1:cols]

X = np.mat(X.values)

Y = np.mat(Y.values)

for i in range(1,3):

X[:,i] = (X[:,i] - min(X[:,i])) / (max(X[:,i]) - min(X[:,I]))

Y[:,0] = (Y[:,0] - min(Y[:,0])) / (max(Y[:,0]) - min(Y[:,0]))

打印一下trainData前五行数据:

trainData数据

代码说明

在训练数据第一列加一列全为1的列矩阵trainData.insert(0,'ones',1)，目的是为了进行线性回归的时候简化计算，因为我们的目标方程是h(x)= θ0+ θ11+ θ22的一个常数项可以看成是θ0和1的乘积，其他项为θi和i的乘积

下图βi即为我们的θi

解释

cols得到trainData的列数，shape[0],shape[1]分别是trainData的行数和列数，下面把它的前三行'ones','mpg','displacement'分配给自变量矩阵最后一列分配给因变量矩阵Y

得到数据之后将它们标准化，关于做线性回归是否需要标准化数据，这里有一个比较好的解释

一般来说，我们再做线性回归时并不需要中心化和标准化数据。大多数情况下数据中的特征会以不同的测量单位展现，无论有没有中心化或者标准化都不会影响线性回归的结果。

因为估计出来的参数值β会恰当地将每个解释变量的单位x转化为响应变量的单位y.

但是标准化数据能将我们的结果更具有可解释性，比如β1=0.6

和β2=0.3, 我们可以理解为第一个特征的重要性是第二个特征的两倍。

这里采用以下公式进行标准化，对应上面代码的最后三行：

离差标准化公式

开始回归

首先用最小二乘法计算回归系数，并给出梯度下降的代价函数的代码表示

最小二乘法公式:

最小二乘法

代码:

theta_n = (X.T*X).I*X.T*Y

print(theta_n)

打印结果: [[ 0.58007057] [-0.0378746 ] [-0.35473364]]，从左到右分别是θ0，θ1，θ2

定义代价函数:

公式：

代价函数公式

代码:

我是直接自己定义了一个新模块linearRegrassion.py，在里面写了线性回归相关的函数，这也是上篇文章中开头的import linearRegrassion as lg

记得在新文件linearRegrassion.py里要

import pandas as pd

import numpy as np

代价函数costFunc：

def costFunc(X,Y,theta):

inner = np.power((X*theta.T)-Y,2)

return np.sum(inner)/(2*len(X))

观察公式，h(x)是预测值，y是实际值，通过他们俩的差来体现不同的拟合曲线的可靠程度，这个值越小说明对应的系数θ拟合出的曲线越接近实际，我们下面要做的就是用梯度下降的算法，取一系列θ值来逼近这个最优解，最后得到回归曲线。

梯度下降算法

公式:

梯度下降公式

解释

我们举一个代价函数的例子，看下面这个函数图像:

cost

我们在上面取一点(-30, 2500), 假设它对应一组我们待求的系数θ，此时代价函数值为2500，远没有达到最小的情况。

由于这个函数在(-∞, 20)区间内递减，所以我们肯定需要增大θ值来逼近最优解，于是我们对θ求偏导，然后再用θ减去偏导值，这样就可以使θ增大

(因为此时斜率k为负，所以减去之后肯定是增大的，相应的，如果这个点跑到对称轴右边，斜率变成正数，那么θ则会减少，仍然向最优解方向逼近)

说了这么多，我们取两个点画个图来看看:

k

梯度下降迭代到最后，斜率越来越接近0，代价函数也越来越接近最优解，此时我们得到的便是拟合度最高的系数θ

上两图的代码

import numpy as np

import matplotlib.pyplot as plt

x = np.linspace(-100,+100,10)

y = pow(x-20,2)

k = 2*(x-20)

y1 = -20*(x-10)+100

y2 = -100*(x+30)+2500

plt.plot(x,y)

plt.plot(x,y1,label= 'k=-20')

plt.plot(x,y2,label= 'k=-100')

leg = plt.legend(loc='upper right',ncol=1)

plt.show()

梯度下降代码编写,还是在linearRegrassion.py模块中:

def gradientDescent(X,Y,theta,alpha,iters):

temp = np.mat(np.zeros(theta.shape))

cost = np.zeros(iters)

thetaNums = int(theta.shape[1])

print(thetaNums)

for i in range(iters):

error = (X*theta.T-Y)

for j in range(thetaNums):

derivativeInner = np.multiply(error,X[:,j])

temp[0,j] = theta[0,j] - (alpha*np.sum(derivativeInner)/len(X))

theta = temp

cost[i] = costFunc(X,Y,theta)

return theta,cost

解释一下几个参数:

alpha是公式中的，我们通常称之为步长，它决定了θ逼近最优解的速度, 过大会导致函数无法收敛得不到最优解，过小则会使逼近速度过慢。

iters是迭代次数，足够大的情况下得到的θ才有说服力

theta则是初始化迭代时给的一组θ值，最后得到拟合度最高的θ并在函数中返回

开始回归

开始回归之前，我们先设置一下学习的参数:

theta = np.mat([0,0,0])

iters = 100000

alpha = 0.001

回归结果及可视化

finalTheta,cost = lg.gradientDescent(X,Y,theta,alpha,iters)

print(finalTheta)

print(cost)

x1 = np.linspace(X[:,1].min(),X[:,1].max(),100)

x2 = np.linspace(X[:,2].min(),X[:,2].max(),100)

x1,x2 = np.meshgrid(x1,x2)

f = finalTheta[0,0] + finalTheta[0,1]*x1 + finalTheta[0,2]*x2

fig = plt.figure()

Ax = Axes3D(fig)

Ax.plot_surface(x1, x2, f, rstride=1, cstride=1, cmap=cm.viridis,label='prediction')

Ax.scatter(X[:100,1],X[:100,2],Y[:100,0],c='y')

Ax.scatter(X[100:250,1],X[100:250,2],Y[100:250,0],c='r')

Ax.scatter(X[250:,1],X[250:,2],Y[250:,0],c='b')

Ax.set_zlabel('acceleration') # 坐标轴

Ax.set_ylabel('displacement')

Ax.set_xlabel('mpg')

plt.show()

finalTheta，也就是最终的θ:

[[ 15.47017446 2.99065096 -3.31870705]]

最小二乘法估计的结果

[[ 17.74518558]

[ -0.63629322]

[ -5.95952521]]

代价函数的值:

[ 124.67279846 124.37076615 124.06949161 ..., 2.77449658 2.77449481

2.77449304]

可以看到迭代十万次之后得到的θ是和之前估计的比较接近的，如果你把迭代次数改为100万次，虽然计算时间长一点但可以看到结果是基本一样的

可视化:

回归结果

比较密集的部分还是基本分布在平面上下的

梯度下降的过程可视化:

代码：

fig, bx = plt.subplots(figsize=(8,6))

bx.plot(np.arange(iters), cost, 'r')

bx.set_xlabel('Iterations')

bx.set_ylabel('Cost')

bx.set_title('Error vs. Training Epoch')

plt.show()

梯度下降

如图，随着迭代次数的增加，代价函数越来越小，趋势越来越平稳，同时逼近最优解。

完整代码:

linearRegression.py

import pandas as pd

import numpy as np

def costFunc(X,Y,theta):

inner = np.power((X*theta.T)-Y,2)

return np.sum(inner)/(2*len(X))

def gradientDescent(X,Y,theta,alpha,iters):

temp = np.mat(np.zeros(theta.shape))

cost = np.zeros(iters)

thetaNums = int(theta.shape[1])

print(thetaNums)

for i in range(iters):

error = (X*theta.T-Y)

for j in range(thetaNums):

derivativeInner = np.multiply(error,X[:,j])

temp[0,j] = theta[0,j] - (alpha*np.sum(derivativeInner)/len(X))

theta = temp

cost[i] = costFunc(X,Y,theta)

return theta,cost

lgScript.py

from io import StringIO

from urllib import request

import matplotlib.pyplot as plt

from mpl_toolkits.mplot3d import Axes3D

from matplotlib import cm

import ssl

import pandas as pd

import numpy as np

import linearRegrassion as lg

ssl._create_default_https_context = ssl._create_unverified_context

names =["mpg","cylinders","displacement","horsepower",

"weight","acceleration","model year","origin","car name"]

url = 'https://archive.ics.uci.edu/ml/machine-learning-databases/auto-mpg/auto-mpg.data'

s = request.urlopen(url).read().decode('utf8')

dataFile = StringIO(s)

cReader = pd.read_csv(dataFile,delim_whitespace=True,names=names)

ax = plt.subplot(111, projection='3d') # 创建一个三维的绘图工程

ax.scatter(cReader["mpg"][:100],cReader["displacement"][:100],cReader["acceleration"][:100],c='y')

ax.scatter(cReader["mpg"][100:250],cReader["displacement"][100:250],cReader["acceleration"][100:250],c='r')

ax.scatter(cReader["mpg"][250:],cReader["displacement"][250:],cReader["acceleration"][250:],c='b')

ax.set_zlabel('acceleration') # 坐标轴

ax.set_ylabel('displacement')

ax.set_xlabel('mpg')

plt.show()

plt.scatter(cReader["mpg"],cReader["displacement"])

plt.xlabel('mpg')

plt.ylabel('displacement')

plt.show()

trainData = cReader[['mpg','displacement','acceleration']]

trainData.insert(0,'ones',1)

print(trainData.head(5))

cols = trainData.shape[1]

X = trainData.iloc[:,0:cols-1]

Y = trainData.iloc[:,cols-1:cols]

X = np.mat(X.values)

Y = np.mat(Y.values)

for i in range(1,3):

X[:,i] = (X[:,i] - min(X[:,i])) / (max(X[:,i]) - min(X[:,i]))

print(X[:5:,:3])

#Y[:,0] = (Y[:,0] - min(Y[:,0])) / (max(Y[:,0]) - min(Y[:,0]))

print(Y[:5,0])

theta_n = (X.T*X).I*X.T*Y

print(theta_n)

theta = np.mat([0,0,0])

iters = 100000

alpha = 0.001

finalTheta,cost = lg.gradientDescent(X,Y,theta,alpha,iters)

print(finalTheta)

print(cost)

x1 = np.linspace(X[:,1].min(),X[:,1].max(),100)

x2 = np.linspace(X[:,2].min(),X[:,2].max(),100)

x1,x2 = np.meshgrid(x1,x2)

f = finalTheta[0,0] + finalTheta[0,1]*x1 + finalTheta[0,2]*x2

fig = plt.figure()

Ax = Axes3D(fig)

Ax.plot_surface(x1, x2, f, rstride=1, cstride=1, cmap=cm.viridis,label='prediction')

Ax.scatter(X[:100,1],X[:100,2],Y[:100,0],c='y')

Ax.scatter(X[100:250,1],X[100:250,2],Y[100:250,0],c='r')

Ax.scatter(X[250:,1],X[250:,2],Y[250:,0],c='b')

Ax.set_zlabel('acceleration') # 坐标轴

Ax.set_ylabel('displacement')

Ax.set_xlabel('mpg')

plt.show()

fig, bx = plt.subplots(figsize=(8,6))

bx.plot(np.arange(iters), cost, 'r')

bx.set_xlabel('Iterations')

bx.set_ylabel('Cost')

bx.set_title('Error vs. Training Epoch')

plt.show()

总结

这个系列算是学习吴恩达机器学习的笔记与作业，由于平时课程较多，所以不定期更新，下一篇大概是用Python实现逻辑回归，希望不足之处大家可以讨论一下。