《算法的乐趣》12.实验数据与曲线拟合------python

曲线拟合

曲线拟合的定义

曲线拟合(curve ftting)是指用连续曲线近似地刻画或比拟平面上一组离散点所表示的坐标之间的函数关系，是一种用解析表达式逼近离散数据的方法。就是将现有数据透过数学方法来代人一条数学方程式的表示方法。
由以上定义可知，曲线拟合不仅仅是根据离散数据画出一条曲线，曲线拟合更重要的意义是通过特定的曲线拟合算法，推算出一个(或一系列)能逼近离散数据并能维持统计误差最小的数学解析表达式，也就是拟合曲线的数学方程。

最小二乘法曲线拟合

最小二乘法是一种通过最小化误差的平方和寻找数据的最佳函数匹配的方法。
多项式为基$\{1,x,x^2,\cdots ,x^m\}$:
$$y=a_0+a_{1}x+a_2{x}^2+\cdots +a_m{x}^m$$
离散的各点到这条曲线的平方和$F(a_0,a_1,\cdots ,a_m)$为：
$$F(a_0,a_1,\cdots ,a_m)=\sum _{i=1}^n[y_i-(a_0+a_1{x}_i+a_2{x}_i^2+\cdots +a_m{x}_i^m){]}^2$$
第一步对$F(a_0,a_1,\cdots ,a_m)$分别求对$a_i$的偏导数，得到$m$个等式：
$$-2\sum _{i=1}^n[y_i-(a_0+a_1{x}_i+a_2{x}_i^2+\cdots +a_m{x}_i^m)]=0$$
$$-2\sum _{i=1}^n[y_i-(a_0+a_1{x}_i+a_2{x}_i^2+\cdots +a_m{x}_i^m)]x_i=0$$
$$\cdots$$
$$-2\sum _{i=1}^n[y_i-(a_0+a_1{x}_i+a_2{x}_i^2+\cdots +a_m{x}_i^m)]x_i^m=0$$
第二步处理就是整理为针对$a_0,a_1,\cdots ,a_m$的正规方程组：
$$a_{0}n+a_1\sum _{i=1}^n{x}_i+a_2\sum _{i=1}^n{x}_i^2+\cdots +a_m\sum _{i=1}^n{x}_i^m=\sum _{i=1}^n{y}_i$$
$$a_0{x}_i+a_1\sum _{i=1}^n{x}_i^2+a_2\sum _{i=1}^n{x}_i^3+\cdots +a_m\sum _{i=1}^n{x}_i^{m+1}=\sum _{i=1}^n{x}_i{y}_i$$
$$\cdots$$
$$a_0{x}_i^m+a_1\sum _{i=1}^n{x}_i^{m+1}+a_2\sum _{i=1}^n{x}_i^{m+2}+\cdots +a_m\sum _{i=1}^n{x}_i^{2m}=\sum _{i=1}^n{x}_i^m{y}_i$$
第三步处理就是求解这个多元一次方程组，得到多项式系数$a_0,a_1,\cdots ,a_m$,就可以得到曲线的拟合多项式函数。

高斯消元法求解方程组

高斯消元法的主要思想是通过对系数矩阵进行行变换，将方程组的系数矩阵有对称矩阵变为三角矩阵，从而达到消元的目的，最后通过回代逐个获得方程组的解。
两个步骤：
1.通过选择主元，逐行消元，最终形成方程组系数矩阵的三角矩阵形式；
2.逐步回代的过程，最终矩阵的对角线上的元素就是方程组的解。

参考文章：https://blog.csdn.net/Jerr__y/article/details/53218883

import numpy as np
def arguemented_mat(a, b):
    """增广矩阵"""
    return np.c_[a, b] # 按行转换成矩阵

# 行交换
def swap_row(a, i, j):
    m, n = a.shape
    if i >= m or j >= m:
        print('error: out of index ...')
    else:
        # 异或运算，交换两行
        a[i] = a[i] ^ a[j]
        a[j] = a[i] ^ a[j]
        a[i] = a[i] ^ a[j]
    return a

def trape_mat(sigma):
    """阶梯矩阵转换"""
    m, n = sigma.shape
    # 保存主元所在的列数，一般来说，每行都有一个主元，除非某行全零
    main_factor = []
    main_col = 0
    while main_col < n and len(main_factor) < m:

        # 当行数多于列数的时候，会出现所有的列已经处理完的情况，直接结束
        if main_col == n:
            break
        
        # 逐列找主元，若该列全零（从第i行往下），则没有主元
        first_row = len(main_factor)  # 当前查找小矩阵首行所在原矩阵的行号
        while main_col < n:
            new_col = sigma[first_row:, main_col]
            not_zeros = np.where(new_col > 0)[0]

            # 若该列没有非零值，则该列非主元列
            if len(not_zeros) == 0:
                main_col += 1
                break
            # 否则通过行变换找到主元
            else:
                main_factor.append(main_col)
                index = not_zeros[0]
                # 若首个元素不是主元,需要行变换，此处只是不为0的时候交换
                if index != 0:
                    sigma = swap_row(sigma, first_row, first_row + index)
                # 把该主元下面的元素全部变成0
                if first_row < m - 1:
                    for k in range(first_row+1, m):
                        times = float(sigma[k, main_col]) / sigma[first_row, main_col]
                        sigma[k] = sigma[k] - times * sigma[first_row]        
                main_col += 1
                break
    return sigma, main_factor


# 回代求解
def back_solve(sigma, main_factor):
    # 判断是否有解
    if len(main_factor) == 0:
        print('wrong main_factor ...')
        return None
    m, n = sigma.shape
    if main_factor[-1] == n-1:
        print('no answer ...')
        return None
    # 把所有的主元元素上方的元素变成0
    for i in range(len(main_factor)-1,-1,-1):
        factor = sigma[i, main_factor[i]]
        sigma[i] = sigma[i] / float(factor)
        for j in range(i):
            times = sigma[j, main_factor[i]]
            sigma[j] = sigma[j] - float(times)*sigma[i]
    return sigma

# 结果打印
def print_result(sigma, main_factor):
    if sigma is None:
        print('no answer ...')
        return 
    m, n = sigma.shape
    result = [''] * (n-1)
    main_factor = list(main_factor)
    for i in range(n-1):
        # 如果不是主元列，则为自由变量
        if i not in main_factor:
            result[i] = 'X' + str(i+1) + '(free var)'
        # 否则是主元变量，从对应的行，将主元变量表示成非主元变量的线性组合
        else:
            # row_of_maini表示该主元所在的行
            row_of_maini = main_factor.index(i)
            result[i] = str(sigma[row_of_maini, -1])
            for j in range(i+1, n-1):
                ratio = sigma[row_of_maini, j]
                if ratio > 0:
                    result[i] = result[i] + '-' + str(ratio) + '*X' + str(j+1)
                if ratio < 0:
                    result[i] = result[i] + '+' + str(-ratio) + '*X' + str(j+1)
    print('方程的通解是：\n', )
    for i in range(n-1):
        print('X' + str(i+1), '=', result[i])   
    return result


# 得到简化的阶梯矩阵和主元列
def solve(a, b):
    sigma = arguemented_mat(a, b)
    print('增广矩阵为：')
    print(sigma)

    sigma, main_factor = trape_mat(sigma)
    sigma = back_solve(sigma, main_factor)
    print('方程的简化阶梯矩阵:')
    print(sigma)

    print('方程的主元列为：')
    print(main_factor)

    result = print_result(sigma, main_factor)
    return result

if __name__ == '__main__':
    a = np.array([[1, 6, 2, -5, -2], [0, 0, 2, -8, -1], [0, 0, 0, 0, 1]])
    b = np.array([-4, 3, 7])
    result = solve(a, b)
    print('=' * 30)
    a = np.array([[1, 0, -5], [0, 1, 1], [0, 0, 0]])
    b = np.array([1, 4, 0])
    result  = solve(a,b)
    print('=' * 30)

增广矩阵为：
[[ 1  6  2 -5 -2 -4]
 [ 0  0  2 -8 -1  3]
 [ 0  0  0  0  1  7]]
方程的简化阶梯矩阵:
[[ 1  6  0  3  0  0]
 [ 0  0  1 -4  0  5]
 [ 0  0  0  0  1  7]]
方程的主元列为：
[0, 2, 4]
方程的通解是：

X1 = 0-6*X2-3*X4
X2 = X2(free var)
X3 = 5+4*X4
X4 = X4(free var)
X5 = 7
==============================
增广矩阵为：
[[ 1  0 -5  1]
 [ 0  1  1  4]
 [ 0  0  0  0]]
方程的简化阶梯矩阵:
[[ 1  0 -5  1]
 [ 0  1  1  4]
 [ 0  0  0  0]]
方程的主元列为：
[0, 1]
方程的通解是：

X1 = 1+5*X3
X2 = 4-1*X3
X3 = X3(free var)
==============================

最小二乘法解决“速度与加速度”实验

时间：[3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
速度：[8.41, 9.94, 11.58, 13.02, 14.33, 15.92, 17.54, 19.22, 20.49, 22.01, 23.53, 24.47]

# 生成矩阵组
def init_mat(t, v, m=1):
    t = np.array(t)
    v = np.array(v)
    x = []
    y = []
    a = np.zeros([m+1,m+1])
    b = np.zeros([m+1,1])
    num = len(t)
    for i in range(m+2):
        x.append(sum(t**i))
    for i in range(m+1):
        y.append(sum((t**i)* v))
        a[i] = x[i:i+m+1]
        b[i] = y[i]
    return a, b

t = [3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]  
v = [8.41, 9.94, 11.58, 13.02, 14.33, 15.92, 17.54, 19.22, 20.49, 22.01, 23.53, 24.47] 
a, b = init_mat(t, v)
result = solve(a, b)

增广矩阵为：
[[  12.    102.    200.46]
 [ 102.   1010.   1916.72]]
方程的简化阶梯矩阵:
[[1.         0.         4.05545455]
 [0.         1.         1.48818182]]
方程的主元列为：
[0, 1]
方程的通解是：

X1 = 4.055454545454562
X2 = 1.4881818181818163

import matplotlib
import matplotlib.pyplot as plt
fig = plt.figure()
ax = fig.add_subplot(111)
ax.scatter(t,v)
func = np.poly1d(np.array([float(result[1]), float(result[0])]).astype(float))
x = np.linspace(3,14,30)
y = func(x)
ax.plot(x, y, color='coral')
plt.show()

三次样条曲线拟合

插值函数

若在$[a,b]$上给出$n+1$个点$a\le x_0<x_1<\cdots <x_n\le b$,$f(x)$是$[a,b]$上的实值函数，要求一个具有$n+1$个参数的函数$s(x;a_0,\cdots ,a_n)$使它满足
$$s(x;a_0,\cdots ,a_n)=f(x_i),i=0,1,\cdots ,n$$
则称$s(x)$为$f(x)$在$[a,b]$上的插值函数。
若$s(x)$关于参量$a_0,a_1,\cdots ,a_n$是线性关系，即：
$$s(x)=a_0{s}_0(x)+a_1{s}_1(x)+\cdots +a_n{s}_n(x)$$
$s(x)$就是多项式插值函数，如果$s_i(x)$是三角函数，则$s(x)$就是三角插值函数。

样条函数的定义

设区间$[a,b]$上选取$n-1$个结点（包括区间端点$a$和$b$共$n+1$个节点），将其划分为$n$个子区间$a=x_0<x_1<\cdots <x_n=b$,如果存在函数$s(x)$,使得$s(x)$满足以下两个条件：
1.$s(x)$在整个区间$[a,b]$上具有$m-1$阶连续导数；
2.$s(x)$在每个子区间$[x_{i-1},x_i],i=1,2,\cdots ,n$上是$m$次代数多项式（最高次数为$m$次）；
则称$s(x)$是区间$[a,b]$上的$m$次样条函数。
假如区间$[a,b]$上存在实值函数$f(x)$,使得每个节点处的值$f(x_i)$与$s_{x_i}$相等，即
$$s(x_i)=f(x_i),i=0,1,\cdots ,n$$
则称$s(x)$是实值函数$f(x)$的$m$次样条插值函数。

需要确定$4n$个系数，本身具备$4n-2$个条件。

边界条件

第一类边界条件：即满足$s^{\prime }(x_0)=f^{\prime }(x_0),s^{\prime }(x_n)=f^{\prime }(x_n)$两个条件，其中$f(x)$是实值函数。
第二类边界条件：即满足$s^{\prime \prime }(x_0)=f^{\prime \prime }(x_0),s^{\prime \prime }(x_n)=f^{\prime \prime }(x_n)$两个条件，其中$f(x)$是实值函数。又称为自然边界条件。
第三类边界条件：即满足$s^{\prime }(x_0-0)=s^{\prime }(x_0+0),s^{\prime \prime }(x_n-0)=s^{\prime \prime }(x_n+0)$两个条件。

推导三次样条函数

基本原理首先求出由待定系数组成的$s(x)$,以及其一阶导数$s^{\prime }(x)$和二阶导数$s^{\prime \prime }(x)$,然后将其带入到$4n$个条件中，得到关于待定系数的方程组，最后求解方程组得到待定系数，并最终确定插值函数$s(x)$.

追赶法求解方程组

三次样条曲线拟合算法实现