ajustement exponentiel décroissance sans devinettes initiales

Vous avez deux options:

1. Linéariser le système, et d'adapter une ligne dans le journal des données.
2. Utiliser un non-solveur linéaire (par exemple, scipy.optimiser.curve_fit

La première option est de loin la manière la plus rapide et la plus robuste. Cependant, il faut que vous connaissez le y-offset a-priori, sinon il est impossible de linéariser l'équation. (c'est à dire y = A * exp(K * t) peut être linéarisée par l'ajustement de y = log(A * exp(K * t)) = K * t + log(A)mais y = A*exp(K*t) + C ne peut être linéarisée par l'ajustement de y - C = K*t + log(A)et comme y est votre variable indépendante, C doit être connue à l'avance pour que ce soit un système linéaire.

Si vous utilisez une non-linéaire de la méthode, c'est une) n'est pas garantie de converger et de donner une solution, b) sera beaucoup plus lente, c) donne une beaucoup moins bonne estimation de l'incertitude dans vos paramètres, et d) est souvent beaucoup moins précis. Cependant, un non-linéaires méthode a un énorme avantage sur un linéaire d'inversion: Il permet de résoudre un système non linéaire d'équations. Dans votre cas, cela signifie que vous n'avez pas à savoir C à l'avance.

Juste pour donner un exemple, nous allons résoudre pour y = A * exp(K * t) avec un peu bruyant données à l'aide de méthodes linéaires et non linéaires:

import numpy as np
import matplotlib.pyplot as plt
import scipy as sp
import scipy.optimize
def main():
# Actual parameters
A0, K0, C0 = 2.5, -4.0, 2.0
# Generate some data based on these
tmin, tmax = 0, 0.5
num = 20
t = np.linspace(tmin, tmax, num)
y = model_func(t, A0, K0, C0)
# Add noise
noisy_y = y + 0.5 * (np.random.random(num) - 0.5)
fig = plt.figure()
ax1 = fig.add_subplot(2,1,1)
ax2 = fig.add_subplot(2,1,2)
# Non-linear Fit
A, K, C = fit_exp_nonlinear(t, noisy_y)
fit_y = model_func(t, A, K, C)
plot(ax1, t, y, noisy_y, fit_y, (A0, K0, C0), (A, K, C0))
ax1.set_title('Non-linear Fit')
# Linear Fit (Note that we have to provide the y-offset ("C") value!!
A, K = fit_exp_linear(t, y, C0)
fit_y = model_func(t, A, K, C0)
plot(ax2, t, y, noisy_y, fit_y, (A0, K0, C0), (A, K, 0))
ax2.set_title('Linear Fit')
plt.show()
def model_func(t, A, K, C):
return A * np.exp(K * t) + C
def fit_exp_linear(t, y, C=0):
y = y - C
y = np.log(y)
K, A_log = np.polyfit(t, y, 1)
A = np.exp(A_log)
return A, K
def fit_exp_nonlinear(t, y):
opt_parms, parm_cov = sp.optimize.curve_fit(model_func, t, y, maxfev=1000)
A, K, C = opt_parms
return A, K, C
def plot(ax, t, y, noisy_y, fit_y, orig_parms, fit_parms):
A0, K0, C0 = orig_parms
A, K, C = fit_parms
ax.plot(t, y, 'k--', 
label='Actual Function:\n $y = %0.2f e^{%0.2f t} + %0.2f$' % (A0, K0, C0))
ax.plot(t, fit_y, 'b-',
label='Fitted Function:\n $y = %0.2f e^{%0.2f t} + %0.2f$' % (A, K, C))
ax.plot(t, noisy_y, 'ro')
ax.legend(bbox_to_anchor=(1.05, 1.1), fancybox=True, shadow=True)
if __name__ == '__main__':
main()

Noter que le linéaire de la solution fournit un résultat beaucoup plus proches des valeurs réelles. Cependant, nous devons fournir la y-valeur de décalage dans le but d'utiliser un linéaire de la solution. Les non-linéaire de la solution ne nécessite pas la connaissance a priori.

Procédure d'ajustement exponentiel avec pas de deviner pas processus itératif :

Cela vient de la feuille de papier (pp. 16-17) : https://fr.scribd.com/doc/14674814/Regressions-et-equations-integrales

Si nécessaire, ceci peut être utilisé à l'initialisation d'une régression non linéaire calcul dans l'ordre choisi un critère d'optimisation.

EXEMPLE :

L'exemple donné par Joe kingston portant est intéressant. Malheureusement, ces Données n'est pas visible, seul le graphique. Ainsi, les données (x,y) ci-dessous provient d'un graphique d'analyse du graphique et, en conséquence, les valeurs numériques sont probablement pas exactement à ceux utilisés par Joe kingston portant. Néanmoins, les équations de la "installés", les courbes sont très proches l'un de l'autre, compte tenu de la grande dispersion des points.

La partie supérieure de la Figure est la copie de la kingston portant graphique.

La Figure du bas montre les résultats obtenus avec la procédure présentée ci-dessus.

Je n'ai jamais eu curve_fit pour fonctionner correctement, comme vous le dites, je ne veux pas deviner quoi que ce soit. J'ai essayé de simplifier Joe kingston portant l'exemple et c'est ce que j'ai eu à travailler. L'idée est de traduire le "bruyant" des données dans le journal et puis transalte en arrière et utiliser polyfit et polyval de comprendre les paramètres:

model = np.polyfit(xVals, np.log(yVals) , 1);   
splineYs = np.exp(np.polyval(model,xVals[0]));
pyplot.plot(xVals,yVals,','); #show scatter plot of original data
pyplot.plot(xVals,splineYs('b-'); #show fitted line
pyplot.show()

où xVals et yVals sont des listes.

Si votre carie commence pas à partir de 0:

popt, pcov = curve_fit(self.func, x-x0, y)

où x0 le début de la décroissance (où vous voulez commencer l'ajustement).
Et puis, de nouveau, l'utilisation x0 pour le traçage:

plt.plot(x, self.func(x-x0, *popt),'--r', label='Fit')

où la fonction est:

    def func(self, x, a, tau, c):
return a * np.exp(-x/tau) + c