精华内容
下载资源
问答
  • 用C#最小二乘法拟合任意次曲线,解线性方程组,三元一次方程组,高斯方程解方程参数等,代码中有注释,详细步骤介绍,且未引用第三方库,纯手敲代码,下载后可用VS直接运行
  • 最小二乘法拟合曲线

    2015-10-25 14:56:23
    使用最小二乘法拟合y=ae^(bx)型曲线,包括了求对数后拟合和直接拟合两种方法,后者的拟合精确度最高,并给出了均方误差和最大偏差点。
  • 用VB实现数据拟合,主要使用最小二乘方法
  • 本程序采用stm32为主控,可实现adc的采集及滤波,oled显示,通过最小二乘法将数据拟合成曲线,并可通过解方程组的方式求解点。
  • 最小二乘法拟合曲线(也叫最佳平方逼近),拟合次数可选,最多到20次,不必懂原理,拷贝到项目中直接用,纯C代码+注解
  • 3. 血液容积 v, t=0 注射剂量 d, 血药浓度立即为 d/v. 2. 药物排除速率与血药浓度成正比比例系数 k>0) 模型假设 1. 机体看作一个房室室内血药浓度均匀 一室模型 模型建立 ? d/ c(0) 3 ? 得 由假设 -kc dt dc 2 ?...
  • 最小二乘法拟合原理。
  • 使用最小二乘法拟合出的直线和曲线,基于c++实现,为了可视化,这里借助了opencv
  • 使用最小二乘法拟合曲线

    千次阅读 2020-06-20 22:33:39
    使用最小二乘法拟合曲线并对过拟合进行正则化处理 引言 高斯于1823年在误差????1,…,????????独立同分布的假定下,证明了最小二乘法的一个最优性质:在所有无偏的线性估计类中,最小二乘方法是其中方差最小的! 对于...

    使用最小二乘法拟合曲线并对过拟合进行正则化处理


    引言

    高斯于1823年在误差𝑒1,…,𝑒𝑛独立同分布的假定下,证明了最小二乘法的一个最优性质:在所有无偏的线性估计类中,最小二乘方法是其中方差最小的!

    对于数据(𝑥𝑖,𝑦𝑖)(𝑖=1,2,3…,𝑚),拟合出函数ℎ(𝑥)有误差,即残差:𝑟𝑖=ℎ(𝑥𝑖)−𝑦𝑖,此时𝐿2范数(残差平方和)最小时,ℎ(𝑥)和 𝑦相似度最高,说明两者最具有拟合性。

    一般的𝐻(𝑥)为𝑛次的多项式,
    H ( x ) = w 0 + w 1 x + w 2 x 2 + ⋯ + w n x n H(x)=w_0+w_1 x+w_2 x^2+⋯+w_n x^n H(x)=w0+w1x+w2x2++wnxn

    ( w 0 + w 1 x + w 2 x 2 + ⋯ + w n x n ) 为 参 数 (w_0+w_1 x+w_2 x^2+⋯+w_n x^n)为参数 (w0+w1x+w2x2++wnxn)

    最小二乘法就是要找到一组

    实例

    我们用目标函数𝑦=𝑠𝑖𝑛2𝜋𝑥,加上一个正态分布的噪音干扰,用多项式去拟合

    import numpy as np
    import scipy as sp
    from scipy.optimize import leastsq
    import matplotlib.pyplot as plt
    
    # 1.目标函数,进行拟合的数据点都分布在这条正弦曲线附近
    def real_func(x):
        return np.sin(2*np.pi*x)
    
    # 2.多项式  numpy.poly1d([1,2,3]) 生成1𝑥^2+2𝑥^1+3𝑥^0,p为多项式的参数,x为下面linspace(0, 1, 10)取得的点
    def fit_func(p, x):
        f = np.poly1d(p)
        return f(x)
    
    # 3.残差 误差函数,所谓误差就是指我们拟合的曲线的值对应真实值的差
    def residuals_func(p, x, y):
        ret = fit_func(p, x) - y
        return ret
    
    # 4.十个点
    x = np.linspace(0, 1, 10) #linspace均分计算指令,用于产生x1,x2之间的N点行线性的矢量 0到10以1为步长或者可以表达为(0,10,10):0到10输出10个值
    x_points = np.linspace(0, 1, 1000)
    # 加上正态分布噪音的目标函数的值
    y_ = real_func(x)
    y = [np.random.normal(0, 0.1) + y1 for y1 in y_]
    
    # 5.关于拟合的曲线的函数
    def fitting(M=0):
        # M为多项式的次数,随机初始化多项式参数,生成M+1个随机数的列表,这样poyld函数返回的多项式次数就是M
        p_init = np.random.rand(M + 1)
        # 最小二乘法,三个参数:误差函数、函数参数列表,数据点
        p_lsq = leastsq(residuals_func, p_init, args=(x, y))
        print('Fitting Parameters:', p_lsq[0])
    
        # 可视化
        plt.plot(x_points, real_func(x_points), label='real')
        plt.plot(x_points, fit_func(p_lsq[0], x_points), label='fitted curve')
        plt.plot(x, y, 'bo', label='noise')
        plt.legend() #图例
        plt.show()
        return p_lsq
    

    下面分别为选取多项式次数M不同时的运行结果:

    p_lsq_0= fitting(M=0)
    

    p_lsq_0= fitting(M=1)
    

    p_lsq_0= fitting(M=3)
    

    p_lsq_0= fitting(M=9)
    

    由上图运行结果可以发现:

    M=0,多项式曲线是一个常数,数据拟合效果很差

    M=1,多项式曲线是一条直线,数据拟合效果也很差

    M=9,多项式曲线通过每个数据点,训练误差为0(“通过每个数据点”,在这里的数据点指的是真正曲线加了噪声的数据点)。对给定训练数据拟合的角度来说,效果是最好的,但是,因为训练数据本身存在噪声,这种拟合曲线对未知数据的预测能力往往并不是最好的,在实际学习中并不可取

    M=3,多项式曲线对数据拟合效果足够好,模型也比较简单,是一个较好的选择

    M=9进行数据拟合时出现的这种现象叫做过拟合,引入正则化项(regularizer),降低过拟合

    回归问题中,损失函数是平方损失,正则化可以是参数向量的L2范数,也可以是L1范数:

    • L1:regularization×abs(p)
    • L2:0.5×regularization×np.square(p)

    对上述多项式M=9的过拟合现象进行正则化处理,代码如下:

    #结果显示过拟合, 引入正则化项(regularizer),降低过拟合
    regularization = 0.0001
    
    def residuals_func_regularization(p, x, y):
        ret = fit_func(p, x) - y   #残差
        ret = np.append(ret,
                        np.sqrt(0.5 * regularization * np.square(p)))  # L2范数作为正则化项
        return ret
    
    # 最小二乘法,加正则化项
    p_init = np.random.rand(9 + 1)
    p_lsq_regularization = leastsq(
        residuals_func_regularization, p_init, args=(x, y))
    
    plt.plot(x_points, real_func(x_points), label='real')
    plt.plot(x_points, fit_func(p_lsq_9[0], x_points), label='fitted curve')
    plt.plot(
        x_points,
        fit_func(p_lsq_regularization[0], x_points),
        label='regularization')
    plt.plot(x, y, 'bo', label='noise')
    plt.legend()
    plt.show()
    

    运行结果图如下所示:

    展开全文
  • 最小二乘法拟合曲线matlab实现 拟合 最小二乘法 matlab 示例
  • 最小二乘法拟合一条直线(C语言代码) #include<stdio.h> #define N 9?//N为要拟合的数据的个数 ? float X[9] = {1,1.477,1.778,2,2.176,2.301,2.398,2.477,2.638}; float Y[9] = {7.55,8.02,8.41,8.64,8.75,8.79,8.81...
  • C++最小二乘法拟合直线,根据数据直接计算直线的斜率、截距和相似度,即拟合的好坏。
  • 采用C#语言,利用最小二乘法算法对二元多次曲线系数拟合
  • 最小二乘法拟合直线和圆,QT界面实现,利用公式,读取文本文件进行拟合,并将结果用QT界面实时得显示出来
  • 多项式拟合最小二乘法曲线拟合C语言实现,有详细描述文档和代码
  • java实现一元、多元、对数、指数等拟合(最小二乘法拟合直线、曲线
  • 公式原理,请移步二阶回归曲线拟合 以下是我改编的4阶实现 从data.txt中,读入指定数量(x,y),进行拟合四阶曲线,打印输出各系数值。 改编成n阶,仅需要修改do{}while();循环即可。 #include <stdio.h> #...

    公式原理,请移步二阶回归曲线拟合

    以下是我改编的4阶实现

    从data.txt中,读入指定数量(x,y),进行拟合四阶曲线,打印输出各系数值。

    改编成n阶,仅需要修改do{}while();循环即可。

    #include <stdio.h>
    #include<stdlib.h>
    #include <math.h>
    #define N 1e-13	
    #define T 4		//阶数
    #define NUM 101  //数据数量
    #define OUTPUT
    int main() {
    
    	int i, j, k;
    
    	//初始化数组
    	long double x[NUM + 1] = { 0 };
    	long double y[NUM + 1] = { 0 };
    
      //读入数据
    	FILE *fp;
    	fopen_s(&fp, "data.txt", "r");
    	int checkNum;
    	for (i = 0; i <= NUM; i++) {
    		if (!fscanf_s(fp, "%lf", &x[i]))break;
    		if (!fscanf_s(fp, "%lf", &y[i]))break;
    		
    	}
    	fclose(fp);
    #ifdef OUTPUT 
    	for (i = 0; i < 10; i++) {
    		printf("%16.9lf ", x[i]);
    		printf("%16.9lf\n", y[i]);
    	}
    	printf("\n\n");
    #endif 
    
    	long double a[T + 1] = { 0 }; // 参数
    	long double m[T + 1] = { 0 };// 中间变量
    	long double z[T + 1] = { 0 };// 中间变量
    
    	long double sumXY[T * 2 + 1][2] = { 0 };//存储各幂值累加和,如sumxy[3][3] 存储 (x ^ 3 * y ^ 3)的累加和
    
    	for (j = 0; j <= T * 2 + 1; j++) {
    		for (k = 0; k <= 1; k++) {
    			for (i = 0; i < NUM; i++)
    			{
    				sumXY[j][k] += (pow(x[i], j) * pow(y[i], k));
    							
    			}
    		}
    	}
    #ifdef OUTPUT 
    	for (i = 0; i < 5; i++) {
    		printf("%16.9lf ", sumXY[i][0]);
    		printf("%16.9lf\n", sumXY[i][1]);
    	}
    	printf("\n\n");
    #endif 
    	int countNum = 0;
    	do {
    		m[4] = a[4]; 
    		a[4] = (sumXY[4][1] - a[0] * sumXY[4][0] - a[1] * sumXY[5][0] - a[2] * sumXY[6][0] - a[3] * sumXY[7][0])/ sumXY[8][0]; 
    		z[4] = (a[4] - m[4])*(a[4] - m[4]);
    
    
    		m[3] = a[3]; 
    		a[3] = (sumXY[3][1] - a[0] * sumXY[3][0] - a[1] * sumXY[4][0] - a[2] * sumXY[5][0] - a[4] * sumXY[7][0]) / sumXY[6][0];
    		z[3] = (a[3] - m[3])*(a[3] - m[3]);
    		
    		m[2] = a[2];
    		a[2] = (sumXY[2][1] - a[0] * sumXY[2][0] - a[1] * sumXY[3][0] - a[3] * sumXY[5][0] - a[4] * sumXY[6][0]) / sumXY[4][0];
    		z[2] = (a[2] - m[2])*(a[2] - m[2]);
    		
    		m[1] = a[1];
    		a[1] = (sumXY[1][1] - a[0] * sumXY[1][0] - a[2] * sumXY[3][0] - a[3] * sumXY[4][0] - a[4] * sumXY[5][0]) / sumXY[2][0];
    		z[1] = (a[1] - m[1])*(a[1] - m[1]);
    
    		m[0] = a[0];
    		a[0] = (sumXY[0][1] - a[1] * sumXY[1][0] - a[2] * sumXY[2][0] - a[3] * sumXY[3][0] - a[4] * sumXY[4][0]) / NUM;
    		z[0] = (a[0] - m[0])*(a[0] - m[0]);
    
    
    		printf("%d\n", countNum++);//统计运算次数
    	} while ((z[0] > N || z[1] > N || z[2] > N || z[3] > N || z[4] > N ));
      //打印输出
    	printf("a=%9.6f,\nb=%9.6f,\nc=%9.6f\nd=%9.6f\ne=%9.6f\n", a[4], a[3], a[2], a[1], a[0]);
    	printf("四阶拟合方程为  y=%9.6fx^4 + %9.6fx^3 + %9.6fx^2 + %9.6fx^1 + %9.6f ", a[4], a[3], a[2], a[1], a[0]);
    
    
    	getchar();
    	return 0;
    }
    
    
    展开全文
  • https://blog.csdn.net/StupidAutofan/article/details/78924601

    https://blog.csdn.net/StupidAutofan/article/details/78924601

    展开全文
  • 最小二乘法(又称最小平方法)是一种数学优化技术。它通过最小化误差的平方和寻找数据的最佳函数匹配。 利用最小二乘法可以简便地求得未知的数据,并使得这些求得的数据与实际数据之间误差的平方和为最小。
  • //-----------------------------------【头文件包含部分】--------------------------------------- // 描述:包含程序所依赖的头文件 //-----------------------------------------------------------------------...
    //-----------------------------------【头文件包含部分】---------------------------------------
    //       描述:包含程序所依赖的头文件
    //----------------------------------------------------------------------------------------------
    #include"opencv2/highgui/highgui.hpp"
    #include"opencv2/imgproc/imgproc.hpp"
    #include <iostream>
    
    //-----------------------------------【命名空间声明部分】--------------------------------------
    //    描述:包含程序所使用的命名空间
    //-----------------------------------------------------------------------------------------------
    using namespace cv;
    
    
    bool polynomial_curve_fit(std::vector<cv::Point>& key_point, int n, cv::Mat& A)
    {
        //Number of key points
        int N = key_point.size();
    
        //构造矩阵X
        cv::Mat X = cv::Mat::zeros(n + 1, n + 1, CV_64FC1);
        for (int i = 0; i < n + 1; i++)
        {
            for (int j = 0; j < n + 1; j++)
            {
                for (int k = 0; k < N; k++)
                {
                    X.at<double>(i, j) = X.at<double>(i, j) +
                        std::pow(key_point[k].x, i + j);
                }
            }
        }
    
        //构造矩阵Y
        cv::Mat Y = cv::Mat::zeros(n + 1, 1, CV_64FC1);
        for (int i = 0; i < n + 1; i++)
        {
            for (int k = 0; k < N; k++)
            {
                Y.at<double>(i, 0) = Y.at<double>(i, 0) +
                    std::pow(key_point[k].x, i) * key_point[k].y;
            }
        }
    
        A = cv::Mat::zeros(n + 1, 1, CV_64FC1);
        //求解矩阵A
        cv::solve(X, Y, A, cv::DECOMP_LU);
        return true;
    }
    
    int main()
    {
        //创建用于绘制的深蓝色背景图像
        cv::Mat image = cv::Mat::zeros(480, 640, CV_8UC3);
        image.setTo(cv::Scalar(0, 0, 100));
    
        //输入拟合点
        std::vector<cv::Point> points;
        points.push_back(cv::Point(100., 58.));
        points.push_back(cv::Point(150., 70.));
        points.push_back(cv::Point(200., 90.));
        points.push_back(cv::Point(252., 140.));
        points.push_back(cv::Point(300., 220.));
        points.push_back(cv::Point(350., 400.));
    
        //将拟合点绘制到空白图上
        for (int i = 0; i < points.size(); i++)
        {
            cv::circle(image, points[i], 5, cv::Scalar(0, 0, 255), 2, 8, 0);
        }
    
        //绘制折线
        cv::polylines(image, points, false, cv::Scalar(0, 255, 255), 1, 8, 0);
    
        cv::Mat A;
    
        polynomial_curve_fit(points, 3, A);
        std::cout << "A = " << A << std::endl;
    
        std::vector<cv::Point> points_fitted;
    
        for (int x = 0; x < 400; x++)
        {
            double y = A.at<double>(0, 0) + A.at<double>(1, 0) * x +
                A.at<double>(2, 0)*std::pow(x, 2) + A.at<double>(3, 0)*std::pow(x, 3);
    
            points_fitted.push_back(cv::Point(x, y));
        }
        cv::polylines(image, points_fitted, false, cv::Scalar(255, 255, 255), 1, 8, 0);
    
        cv::imshow("image", image);
    
        cv::waitKey(0);
        return 0;
    }

    1047308-20191225172528139-1449770008.png

    展开全文
  • C#最小二乘法拟合曲线绘制

    热门讨论 2016-04-08 22:23:25
    可以最小二乘法拟合任意次数的曲线,绘制了原始折线和拟合曲线的对比图,有现成代码可供引用
  • 最小二乘法(又称最小平方法)是一种数学优化技术。它通过最小化误差的平方和寻找数据的最佳函数匹配。...最小二乘法还可用于曲线拟合。其他一些优化问题也可通过最小化能量或最大化熵用最小二乘法来表达。
  • polyfit函数用于多项式拟合拟合y=a0+a1*x+a2*x^2+……+apoly_n*x^poly_n 参数: /// \param x 观察值的x /// \param y 观察值的y /// \param poly_n 期望拟合的阶数,若poly_n=2,则y=a0+a1*x+a2*x^2 /// \...
  • 下面这篇文章主要跟大家介绍了关于python中matplotlib实现最小二乘法拟合的相关内容,下面话不多说,来一起看看详细的介绍: 一、最小二乘法拟合直线 生成样本点 首先,我们在直线 y = 3 + 5x 附近生成服从正态分布...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 8,952
精华内容 3,580
关键字:

最小二乘法拟合曲线