标签: curve-fitting

所以我已经阅读了计算图表趋势线的两个相关问题,但我仍然输了.

我有一个xy坐标数组,我想提出另一个xy坐标数组(可以是更少的坐标),它们代表使用PHP的对数趋势线.

我将这些数组传递给javascript以在客户端绘制图形.

我给了一个数组,当我绘制它时,我得到一个带有一些噪音的高斯形状.我想要适合高斯.这是我已经拥有的,但是当我绘制这个时,我没有得到一个拟合的高斯,而是我只是得到一条直线.我尝试了很多不同的方法,但我无法理解.

random_sample=norm.rvs(h)

parameters = norm.fit(h)

fitted_pdf = norm.pdf(f, loc = parameters[0], scale = parameters[1])

normal_pdf = norm.pdf(f)

plt.plot(f,fitted_pdf,"green")
plt.plot(f, normal_pdf, "red")
plt.plot(f,h)
plt.show()

如果我有一些(x,y)数据,我可以很容易地直线绘制,例如

f=glm(y~x)
plot(x,y)
lines(x,f$fitted.values)

但对于弯曲的数据,我想要一条曲线.似乎可以使用loess():

f=loess(y~x)
plot(x,y)
lines(x,f$fitted)

这个问题随着我输入和研究而得到了发展.我开始想要一个简单的函数来适应弯曲的数据(我对数据一无所知),并想要了解如何使用nls()或optim()做到这一点.这就是每个人似乎在我发现的类似问题中提出的建议.但现在我偶然发现loess()我很高兴.所以,现在我的问题是为什么有人会选择使用nls或optim代替loess(或smooth.spline)？使用工具箱类比,是nls一把螺丝刀,loess是一个电动螺丝刀(意思是我几乎总是选择后者,因为它做同样的事情,但我的努力更少)？或者是nls平头螺丝刀和loess十字螺丝刀(意味着黄土更适合某些问题,但对于其他人来说它根本不能完成这项工作)？

作为参考,这里是我正在使用的播放数据,它loess给出了令人满意的结果:

x=1:40
y=(sin(x/5)*3)+runif(x)

和:

x=1:40
y=exp(jitter(x,factor=30)^0.5)

可悲的是,它在这方面做得不太好:

x=1:400
y=(sin(x/20)*3)+runif(x)

nls()或任何其他函数或库,可以处理这个和前面的exp示例,而不给出提示(即没有被告知它是正弦波)？

更新:stackoverflow上相同主题的一些有用页面:

R中的拟合优度函数

如何在R中为我的数据拟合平滑曲线？

smooth.spline"开箱即用"在我的第一和第三个例子上给出了很好的结果,但在第二个例子中可怕(它只是加入了点).然而,f = smooth.spline(x,y,spar = 0.5)在所有三个上都是好的.

更新#2:gam()(来自mgcv包)到目前为止很棒:当它更好时它会给loess()一个类似的结果,而当它更好时它会给smooth.spline()一个类似的结果.并且没有提示或额外参数.到目前为止,文件已经超出了我的脑海,我觉得我正眯着眼睛望着飞过头顶的飞机; 但发现了一些试验和错误:

#f=gam(y~x)    #Works just like glm(). I.e. pointless
f=gam(y~s(x)) #This is what you want
plot(x,y)
lines(x,f$fitted)

我试图将多行匹配到2D中的点列表.我的分数很低(16或32).

这些点来自机器人的模拟环境,其侧面附有激光测距仪.如果点位于一条线上,则表示它们检测到一堵墙,如果不是,则表示它们检测到一个障碍物.我试图检测墙壁并计算它们的交点,为此我认为最好的想法是在数据集上拟合线条.

如果我们知道线上或线周围的所有点,则将一条线拟合到一组点不是问题.

我的问题是,我不知道如何检测哪些点应该被分类以适合同一行,哪些不应该为每一行.此外,我现在甚至没有一条线上的点数,而自然地,最好是检测最长的线段.

你会如何解决这个问题？如果我查看所有可能性,例如对于所有32个点的5个点的组,则它给出32个选择5 = 201376的可能性.我认为这需要花费太多时间来尝试所有可能性,并尝试在所有5元组中使用一条线.

那么什么是更好的算法会运行得更快？我可以在极限内连接点并创建折线.但即使连接点也是一项艰巨的任务,因为即使在一条线内边缘距离也会发生变化.

您是否认为可以对具有如此少数量条目的离散数据集进行某种Hough变换？

注意:如果这个问题太难解决,我正在考虑使用传感器的顺序并将其用于过滤.这样算法可以更容易,但如果墙前有一个小障碍物,它会分散线的连续性,从而将墙分成两半.

我试图在许多数据点上进行高斯拟合.例如,我有一个256 x 262144数据阵列.256点需要拟合高斯分布,我需要262144.

有时高斯分布的峰值在数据范围之外,因此要获得准确的平均结果,曲线拟合是最好的方法.即使峰值在范围内,曲线拟合也会提供更好的西格玛,因为其他数据不在范围内.

我使用http://www.scipy.org/Cookbook/FittingData中的代码为一个数据点工作.

我试图重复这个算法,但看起来需要大约43分钟才能解决这个问题.是否有一种已经写好的快速方法可以并行或更有效地执行此操作？

from scipy import optimize                                                                                                                                          
from numpy import *                                                                                                                                                 
import numpy                                                                                                                                                        
# Fitting code taken from: http://www.scipy.org/Cookbook/FittingData                                                                                                

class Parameter:                                                                                                                                                    
    def __init__(self, value):                                                                                                                                  
            self.value = value                                                                                                                                  

    def set(self, value):                                                                                                                                       
            self.value = value                                                                                                                                  

    def __call__(self):                                                                                                                                         
            return self.value                                                                                                                                   


def fit(function, parameters, y, x = None):                                                                                                                         
    def f(params):                                                                                                                                              
            i = 0                                                                                                                                               
            for p in parameters:                                                                                                                                
                    p.set(params[i])                                                                                                                            
                    i += 1                                                                                                                                      
            return y - function(x)                                                                                                                              

    if x is None: x = arange(y.shape[0])                                                                                                                        
    p = [param() for param in parameters] …

我正在尝试从我运行的模拟代码中拟合一些数据,以便找出幂律依赖性.当我绘制线性拟合时,数据不太适合.

这是我用来拟合数据的python脚本:

#!/usr/bin/env python
from scipy import optimize
import numpy

xdata=[ 0.00010851,  0.00021701,  0.00043403,  0.00086806,  0.00173611, 0.00347222]
ydata=[ 29.56241016,  29.82245508,  25.33930469,  19.97075977,  12.61276074, 7.12695312]

fitfunc = lambda p, x: p[0] + p[1] * x ** (p[2])
errfunc = lambda p, x, y: (y - fitfunc(p, x))

out,success = optimize.leastsq(errfunc, [1,-1,-0.5],args=(xdata, ydata),maxfev=3000)

print "%g + %g*x^%g"%(out[0],out[1],out[2])

我得到的输出是:-71205.3 + 71174.5*x ^ -9.79038e-05

虽然在情节上,合体看起来和你期望的最小方形一样好,但输出的形式让我感到困扰.我希望常数接近你预期的零点(大约30).而且我期望找到比10 ^ -5更大的功率依赖性.

我已经尝试重新调整我的数据并使用参数来优化.leastsq没有运气.我正在努力实现的目标是什么,或者我的数据是不允许的？计算成本很高,因此获得更多数据点并非易事.

谢谢!

我试图模拟一些遵循S形曲线关系的数据.在我的工作领域(心理物理学)中,Weibull函数通常用于模拟这种关系,而不是概率.

我正在尝试使用R创建一个模型,并且正在努力学习语法.我知道我需要使用包中的vglm()功能VGAM,但我无法得到一个合理的模型.这是我的数据:

# Data frame example data
dframe1 <- structure(list(independent_variable = c(0.3, 0.24, 0.23, 0.16, 
0.14, 0.05, 0.01, -0.1, -0.2), dependent_variable = c(1, 1, 
1, 0.95, 0.93, 0.65, 0.55, 0.5, 0.5)), .Names = c("independent_variable", 
"dependent_variable"), class = "data.frame", row.names = c(NA, 
-9L))

这是dframe1中的数据图:

library(ggplot2)

# Plot my original data
ggplot(dframe1, aes(independent_variable, dependent_variable)) + geom_point()

这应该能够通过Weibull函数建模,因为数据符合S形曲线关系.以下是我对数据建模并生成代表性图的尝试:

library(VGAM)

# Generate model
my_model <- vglm(formula = dependent_variable ~ independent_variable, family = weibull, data = dframe1)

# Create a new …

我试图用指数衰减函数(RC类似系统)拟合数据:

我的数据位于以下数据框中:

dataset <- data.frame(Exp = c(4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6), t = c(0, 0.33, 0.67, 1, 1.33, 1.67, 2, 4, 6, 8, 10, 0, 33, 0.67, 1, 1.33, 1.67, 2, 4, 6, 8, 10, 0, 0.33, 0.67, 1, 1.33, 1.67, 2, 4, 6, 8, 10), fold = c(1, 0.957066345654286, 1.24139015724819, 1.62889151698633, …

我有x和y的以下数据:

x   y
1.71    0.0
1.76    5.0
1.81    10.0
1.86    15.0
1.93    20.0
2.01    25.0
2.09    30.0
2.20    35.0
2.32    40.0
2.47    45.0
2.65    50.0
2.87    55.0
3.16    60.0
3.53    65.0
4.02    70.0
4.69    75.0
5.64    80.0
7.07    85.0
9.35    90.0
13.34   95.0
21.43   100.0

对于上面的数据,我试图在表单中拟合数据:

然而,x和y存在某些不确定性,其中x具有x的50%的不确定性,y具有固定的不确定性.我试图用这个不确定性包来确定拟合参数的不确定性.但是,我遇到了曲线拟合与scipy optimize曲线拟合函数的问题.我收到以下错误:

minpack.error:函数调用的结果不是一个正确的浮点数组.

如何修复以下错误并确定拟合参数(a,b和n)的不确定度？

MWE

from __future__ import division
import numpy as np
import re
from scipy import optimize, interpolate, spatial
from scipy.interpolate import UnivariateSpline
from uncertainties import unumpy


def …

我正在尝试将 sigmoid 曲线拟合到一小组点上，基本上从一组观察中生成概率曲线。我正在使用scipy.optimize.curve_fit, 带有稍微修改的逻辑函数（以便完全绑定在 [0,1] 内）。目前，我在 dogbox 方法和精确的 tr_solver 方面取得了最大的成功。

当我尝试运行代码时，对于某些数据点，它会引发：

ValueError: `x0` violates bound constraints.

我没有遇到这个问题（使用相同的代码和数据），直到我更新到最新版本的 numpy/scipy（numpy 1.17.0，scipy 1.3.1），所以我相信这是这次更新的结果（我无法降级，因为我需要用于该项目其他方面的其他库需要这些版本）

我在一个大型数据集 (N ~15000) 上运行它，对于非常具体的值，曲线拟合失败，声称初始猜测超出了边界约束。事实并非如此，甚至在提供的示例中拟合曲线之前通过打印语句快速检查也证实了这一点。

起初我认为这是一个 numpy 精度错误，这么小的值被认为是越界的，但是稍微改变它或提供一个新的、类似大小的任意数字不会导致 ValueError。此外，其他失败的值与 ~1e-10 一样大，所以我认为它一定是别的东西。

这是一个每次都失败的例子：

import numpy as np
import scipy as sp
from scipy.special import expit, logit
import scipy.optimize

def f(x,x0,g,c,k):
    y = c*expit(k*10.*(x-x0)) + g*(1.-c)
    return y

#               x0                      g                       c                       k
p0 = np.array([8.841357069490852e-01, 4.492363462957287e-19, 5.547073496706608e-01, 7.435378446218519e+00])
bounds = np.array([[-1.,1.], [0.,1.], [0.,1.], [0.,20.]])
x = np.array([1.0, 1.0, 1.0, 1.0, …