最小二乘法的曲线拟合

最小二乘法解决的问题：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()

运行效果：