पायथन nonlinear कम से कम वर्ग फिटिंग

Question

मेरी समस्या में शामिल गणित के मामले में मैं अपनी गहराई से थोड़ा सा हूं, इसलिए मैं किसी भी गलत नामकरण के लिए क्षमा चाहता हूं।

मैं scipy function leastsq का उपयोग कर देख रहा था, लेकिन मुझे यकीन नहीं है कि यह सही कार्य है या नहीं। मैं निम्न समीकरण है:

eq = lambda PLP,p0,l0,kd : 0.5*(-1-((p0+l0)/kd) + np.sqrt(4*(l0/kd)+(((l0-p0)/kd)-1)**2)) 

मैं केडी (पीएलपी, p0, l0) को छोड़कर सभी शब्दों के लिए डेटा (8 सेट) की है। मुझे उपरोक्त समीकरण के गैर-रैखिक प्रतिगमन द्वारा केडी के मूल्य को खोजने की आवश्यकता है। मैंने जो उदाहरण पढ़े हैं, उनमें से मुझे लगता है कि आउटपुट प्राप्त करने के लिए डेटा की इनपुटिंग की अनुमति नहीं है।

आपकी मदद के लिए धन्यवाद

Answer 1

यह scipy.optimize.leastsq कैसे उपयोग करने के लिए की एक नंगे हड्डियों उदाहरण है:

import numpy as np 
import scipy.optimize as optimize 
import matplotlib.pylab as plt 

def func(kd,p0,l0): 
    return 0.5*(-1-((p0+l0)/kd) + np.sqrt(4*(l0/kd)+(((l0-p0)/kd)-1)**2)) 

residuals के वर्गों का योग kd का कार्य हम कोशिश कर रहे हैं कम करने के लिए:

def residuals(kd,p0,l0,PLP): 
    return PLP - func(kd,p0,l0) 

यहां मैं कुछ यादृच्छिक डेटा उत्पन्न करता हूं। आप इसके बजाय अपना वास्तविक डेटा लोड करना चाहते हैं।

N=1000 
kd_guess=3.5 # <-- You have to supply a guess for kd 
p0 = np.linspace(0,10,N) 
l0 = np.linspace(0,10,N) 
PLP = func(kd_guess,p0,l0)+(np.random.random(N)-0.5)*0.1 

kd,cov,infodict,mesg,ier = optimize.leastsq(
    residuals,kd_guess,args=(p0,l0,PLP),full_output=True,warning=True) 

print(kd) 

तरह

3.49914274899 

यह kd के लिए सबसे उपयुक्त मूल्य optimize.leastsq द्वारा पाया है कुछ अर्जित करता है।

PLP_fit=func(kd,p0,l0) 

नीचे PLP बनाम p0 की एक साजिश है:

यहाँ हम kd के लिए मूल्य का उपयोग कर PLP का मूल्य हम सिर्फ पाया उत्पन्न करते हैं। नीली रेखा डेटा से है, लाल रेखा सबसे अच्छा फिट वक्र है।

plt.plot(p0,PLP,'-b',p0,PLP_fit,'-r') 
plt.show() 

Answer 2

एक अन्य विकल्प lmfit उपयोग करने के लिए है।

वे आपको शुरू करने के लिए एक महान example प्रदान करते हैं:।

#!/usr/bin/env python 
#<examples/doc_basic.py> 
from lmfit import minimize, Minimizer, Parameters, Parameter, report_fit 
import numpy as np 

# create data to be fitted 
x = np.linspace(0, 15, 301) 
data = (5. * np.sin(2 * x - 0.1) * np.exp(-x*x*0.025) + 
     np.random.normal(size=len(x), scale=0.2)) 

# define objective function: returns the array to be minimized 
def fcn2min(params, x, data): 
    """ model decaying sine wave, subtract data""" 
    amp = params['amp'] 
    shift = params['shift'] 
    omega = params['omega'] 
    decay = params['decay'] 
    model = amp * np.sin(x * omega + shift) * np.exp(-x*x*decay) 
    return model - data 

# create a set of Parameters 
params = Parameters() 
params.add('amp', value= 10, min=0) 
params.add('decay', value= 0.1) 
params.add('shift', value= 0.0, min=-np.pi/2., max=np.pi/2) 
params.add('omega', value= 3.0) 


# do fit, here with leastsq model 
minner = Minimizer(fcn2min, params, fcn_args=(x, data)) 
kws = {'options': {'maxiter':10}} 
result = minner.minimize() 


# calculate final result 
final = data + result.residual 

# write error report 
report_fit(result) 

# try to plot results 
try: 
    import pylab 
    pylab.plot(x, data, 'k+') 
    pylab.plot(x, final, 'r') 
    pylab.show() 
except: 
    pass 

#<end of examples/doc_basic.py>