最小二乘法解决的问题：Ax=C 无解下的最优解
例子1：
一条过原点的直线OA，C是直线外一点，求C在OA上的投影点P
例子1
例子2：
已知三个不在一条直线上的点A,B,C，求一条直线，使A,B,C到直线的距离和最小
例子2
例子3：
已知三个不在一条直线上的点A,B,C，求一点，到A,B,C的距离和最小
例子3
其实这3个例子的本质都是一样的。都是求未知的数据，并使得这些求得的数据与实际数据之间误差的平方和为最小。
以第一个例子为例：
Ax=C 无解
要求||Ax-C||^2最小
A.TAx'=A.TC
x'=(A.TA)^(-1)A.TC
P=Ax'
公式推导
同理，例子2，3中都需要写成Ax=C 的形式，求最优解。
只是例子2中的最优解是直线y=ax+b中的a，b。例子3中的最优解是P的坐标P（xp,yp）。
使用程序求例子1：A(3,1),C(1,3)
CODE
import numpy as np
from matplotlib import pyplot as plt
A = np.array([[3],[1]])
C = np.array([[1],[3]])
#x'=(A.TA)^(-1)A.TC
B = A.T.dot(C)
AA = np.linalg.inv(A.T.dot(A))#求A.T.dot(A)的逆
l=AA.dot(B)
#P=Ax'
P=A.dot(l)
x=np.linspace(-2,2,10)#x.shape=(10,)
x.shape=(1,10)
#画出直线y=ax
xx=A.dot(x)
fig = plt.figure() #figsize=(10,6)
ax= fig.add_subplot(111)
ax.plot(xx[0,:],xx[1,:])
#画出A点
ax.plot(A[0],A[1],'ko')
#画出C点，P点
ax.plot([C[0],P[0]],[C[1],P[1]],'r-o')
#画出OC线
ax.plot([0,C[0]],[0,C[1]],'m-o')
#画出坐标轴x=0,y=0
ax.axvline(x=0,color='black')
ax.axhline(y=0,color='black')
#标写每个点的字母
margin=0.1
ax.text(A[0]+margin, A[1]+margin, r"A",fontsize=20)
ax.text(C[0]+margin, C[1]+margin, r"C",fontsize=20)
ax.text(P[0]+margin, P[1]+margin, r"P",fontsize=20)
ax.text(0+margin,0+margin,r"O",fontsize=20)
ax.text(0+margin,4+margin, r"y",fontsize=20)
ax.text(4+margin,0+margin, r"x",fontsize=20)
plt.xticks(np.arange(-2,3))
plt.yticks(np.arange(-2,3))
ax.axis('equal')
plt.show()
结果：
最小二乘法 拟合曲线
1.直线拟合
直线拟合
已知图中拟合数据的坐标，对图中的拟合数据进行直线拟合。
依旧使用最小二乘法求解
Ax=b——————1
无解下的最优解。已知点的个数为n，所求直线的方程为y1=ax1+b，A由方程右边的a，b的系数构成构成(nx2)的矩阵,每行为（x1,1），b由已知点的y1坐标构成矩阵(nx1)。方程1中的x为要求的列向量[a,b]。
A.TAx'=A.Tb
x'=(A.TA)^(-1)A.TC
求得x‘后，画出拟合曲线的yy=Ax'
import numpy as np
import matplotlib.pyplot as plt
#x的个数决定了样本量
x = np.arange(-1,1,0.02)
#y为理想函数
y = 2*np.sin(x*2.3)+0.5*x**3
#y1为离散的拟合数据
y1 = y+0.5*(np.random.rand(len(x))-0.5)
##################################
#主要程序
one=np.ones((len(x),1))#len(x)得到数据量
x=x.reshape(x.shape[0],1)
A=np.hstack((x,one))#两个100x1列向量合并成100x2,(100, 1) (100,1 ) (100, 2)
C=y1.reshape(y1.shape[0],1)
#等同于C=y1.reshape(100,1)
#虽然知道y1的个数为100但是程序中不应该出现人工读取的数据
def optimal(A,b):
B = A.T.dot(b)
AA = np.linalg.inv(A.T.dot(A))#求A.T.dot(A)的逆
P=AA.dot(B)
print P
return A.dot(P)
#求得的[a,b]=P=[[ 2.88778507e+00] [ -1.40062271e-04]]
yy = optimal(A,b)
#yy=P[0]*x+P[1]
##################################
plt.plot(x,y,color='g',linestyle='-',marker='',label=u'理想曲线')
plt.plot(x,y1,color='m',linestyle='',marker='o',label=u'拟合数据')
plt.plot(x,yy,color='b',linestyle='-',marker='.',label=u"拟合曲线")
# 把拟合的曲线在这里画出来
plt.legend(loc='upper left')
plt.show()
直线拟合结果
从结果中可以看出，直线拟合并不能对拟合数据达到很好的效果，下面我们介绍一下曲线拟合。
2.曲线拟合
曲线拟合
图中的拟合数据如果用直线进行拟合效果会更差，曲线能更好的表达数据的特征。这里我们使用多项式函数进行拟合。
拟合函数：
y=axn+bx(n-1)+cx^(n-2)+...+d
假设拟合数据共有100个
由 Ax=b
A=[x1^n x1^(n-1) x1^(n-2) ...... 1]
[x2^n x2^(n-1) x2^(n-2) ...... 1]
......
[x100^n x100^(n-1) x100^(n-2) . 1]
b=[y1]
[y2]
......
[y100]
解得拟合函数的系数[a,b,c.....d]
CODE:
import numpy as np
import matplotlib.pyplot as plt
x = np.arange(-1,1,0.02)
y = ((x*x-1)**3+1)*(np.cos(x*2)+0.6*np.sin(x*1.3))
y1 = y+(np.random.rand(len(x))-0.5)
##################################
### 核心程序
#使用函数y=ax^3+bx^2+cx+d对离散点进行拟合，最高次方需要便于修改，所以不能全部列举，需要使用循环
#A矩阵
m=[]
for i in xrange(7):#这里选的最高次为x^7的多项式
a=x**(i)
m.append(a)
A=np.array(m).T
b=y1.reshape(y1.shape[0],1)
##################################
def projection(A,b):
AA = A.T.dot(A)#A乘以A转置
w=np.linalg.inv(AA).dot(A.T).dot(b)
print w#w=[[-0.03027851][ 0.1995869 ] [ 2.43887827] [ 1.28426472][-5.60888682] [-0.98754851][ 2.78427031]]
return A.dot(w)
yw = projection(A,b)
yw.shape = (yw.shape[0],)
plt.plot(x,y,color='g',linestyle='-',marker='',label=u"理想曲线")
plt.plot(x,y1,color='m',linestyle='',marker='o',label=u"已知数据点")
plt.plot(x,yw,color='r',linestyle='',marker='.',label=u"拟合曲线")
plt.legend(loc='upper left')
plt.show()
结果
根据结果可以看到拟合的效果不错。
我们可以通过改变
- 拟合函数类型
- 样本数（此处为x的个数）
来调整拟合效果。
如果此处我们把拟合函数改为最高次为x^20的多项式
m=[]
for i in xrange(20):
a=x**(i)
m.append(a)
所得结果如下：
x^20 样本数100
这种现象称为过拟合现象
- 可以通过增加样本数数，
- 降低拟合函数的次数
矫正过拟合现象
在保持拟合函数改为最高次为x^20的多项式的条件下，增大样本数：
x = np.arange(-1,1,0.005) #原来是x = np.arange(-1,1,0.02)
x^20 样本数400
通过结果可以看出，过拟合现象得到了改善。
概念
最小二乘法多项式曲线拟合，根据给定的m个点,并不要求这条曲线精确地经过这些点，而是曲线y=f(x)的近似曲线y= φ(x)。
原理
[原理部分由个人根据互联网上的资料进行总结，希望对大家能有用]
给定数据点pi(xi,yi)，其中i=1,2,…,m。求近似曲线y= φ(x)。并且使得近似曲线与y=f(x)的偏差最小。近似曲线在点pi处的偏差δi= φ(xi)-y，i=1,2,...,m。
常见的曲线拟合方法:
1.使偏差绝对值之和最小
2.使偏差绝对值最大的最小
3.使偏差平方和最小
按偏差平方和最小的原则选取拟合曲线，并且采取二项式方程为拟合曲线的方法,称为最小二乘法。
推导过程：
1. 设拟合多项式为：
2. 各点到这条曲线的距离之和，即偏差平方和如下：
3. 为了求得符合条件的a值，对等式右边求ai偏导数，因而我们得到了：
.......
4. 将等式左边进行一下化简，然后应该可以得到下面的等式：
.......
5. 把这些等式表示成矩阵的形式，就可以得到下面的矩阵：
6. 将这个范德蒙得矩阵化简后可得到:
7. 也就是说X*A=Y，那么A = (X'*X)-1*X'*Y，便得到了系数矩阵A，同时，我们也就得到了拟合曲线。
经验证 5，与 6 的 结果一致，所以 一般用 6的方式更简单。
验证代码：
# coding=utf-8
'''
作者:Jairus Chan
程序:多项式曲线拟合算法
'''
import matplotlib.pyplot as plt
import math
import numpy
import random
fig = plt.figure()
ax = fig.add_subplot(111)
# 阶数为9阶
order = 9
# 生成曲线上的各个点
x = numpy.arange(-1, 1, 0.02)
y = [((a * a - 1) * (a * a - 1) * (a * a - 1) + 0.5) * numpy.sin(a * 2) for a in x]
# ax.plot(x,y,color='r',linestyle='-',marker='')
# ,label="(a*a-1)*(a*a-1)*(a*a-1)+0.5"
# 生成的曲线上的各个点偏移一下，并放入到xa,ya中去
i = 0
xa = []
ya = []
for xx in x:
yy = y[i]
d = float(random.randint(60, 140)) / 100
# ax.plot([xx*d],[yy*d],color='m',linestyle='',marker='.')
i += 1
xa.append(xx * d)
ya.append(yy * d)
'''for i in range(0,5):
xx=float(random.randint(-100,100))/100
yy=float(random.randint(-60,60))/100
xa.append(xx)
ya.append(yy)'''
ax.plot(xa, ya, color='m', linestyle='', marker='.')
# 进行曲线拟合 验证 5
matA = []
for i in range(0, order + 1):
matA1 = []
for j in range(0, order + 1):
tx = 0.0
for k in range(0, len(xa)):
dx = 1.0
for l in range(0, j + i):
dx = dx * xa[k]
tx += dx
matA1.append(tx)
matA.append(matA1)
print(len(matA))
print(len(matA[0]))
print(matA[0])
print(matA[1])
print(matA[2])
# print(len(xa))
# print(matA[0][0])
matA = numpy.array(matA)
matB = []
for i in range(0, order + 1):
ty = 0.0
for k in range(0, len(xa)):
dy = 1.0
for l in range(0, i):
dy = dy * xa[k]
ty += ya[k] * dy
matB.append(ty)
matB = numpy.array(matB)
matAA = numpy.linalg.solve(matA, matB)
print(matAA.shape)
# 画出拟合后的曲线
# print(matAA)
xxa = numpy.arange(-1, 1.06, 0.03)
yya = []
for i in range(0, len(xxa)):
yy = 0.0
for j in range(0, order + 1):
dy = 1.0
for k in range(0, j):
dy *= xxa[i]
dy *= matAA[j]
yy += dy
yya.append(yy)
ax.plot(xxa, yya, color='g', linestyle='', marker='.')
# 多项式 拟合 验证 6
def projection(A, b):
AA = A.T.dot(A)
w = numpy.linalg.inv(AA).dot(A.T).dot(b)
return w
array_xa = numpy.array(xa)
array_ya = numpy.array(ya)
m = []
for i in range(10):
a = array_xa**(i)
m.append(a)
A = numpy.array(m).T
b = array_ya.reshape(array_ya.shape[0], 1)
w = projection(A, b)
print("w:", w.shape)
print("xxa", xxa.shape)
array_xxa = numpy.array(xxa)
mm = []
for i in range(10):
a = xxa**(i)
mm.append(a)
AA = numpy.array(mm).T
print("AA:", AA.shape)
new_y = AA.dot(w)
ax.plot(array_xxa, new_y, color='b', linestyle='-', marker='')
# 5 曲线 与 6 曲线 重合。
ax.legend()
plt.show()运行效果：
