Подгонка экспоненциального распада без первоначального угадывания

Ответ 1

У вас есть два варианта:

• Линеаризовать систему и поместить строку в журнал данных.
• Используйте нелинейный решатель (например, scipy.optimize.curve_fit

Первый вариант, безусловно, самый быстрый и надежный. Однако для этого требуется, чтобы вы знали y-offset a-priori, иначе линеаризировать уравнение невозможно. (т.е. y = A * exp(K * t) можно линеаризовать, установив y = log(A * exp(K * t)) = K * t + log(A), но y = A*exp(K*t) + C можно линеаризовать только путем подгонки y - C = K*t + log(A), а поскольку y - ваша независимая переменная, C должна быть заранее известна, чтобы это было линейная система.

Если вы используете нелинейный метод, то a) не гарантируется сходимость и получение решения, b) будет намного медленнее, c) дает гораздо худшую оценку неопределенности в ваших параметрах, а d) часто гораздо менее точный. Однако нелинейный метод имеет одно огромное преимущество перед линейной инверсией: он может решить нелинейную систему уравнений. В вашем случае это означает, что вам не нужно заранее знать C.

Чтобы дать пример, разрешите для y = A * exp (K * t) с некоторыми шумными данными, используя как линейные, так и нелинейные методы:

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()

Обратите внимание, что линейное решение дает результат намного ближе к фактическим значениям. Однако мы должны предоставить значение y-offset для использования линейного решения. Нелинейное решение не требует этого априорного знания.

Ответ 2

Я бы использовал функцию scipy.optimize.curve_fit. Строка doc для него даже имеет пример установки экспоненциального распада в нем, который я буду копировать здесь:

>>> import numpy as np
>>> from scipy.optimize import curve_fit
>>> def func(x, a, b, c):
...     return a*np.exp(-b*x) + c

>>> x = np.linspace(0,4,50)
>>> y = func(x, 2.5, 1.3, 0.5)
>>> yn = y + 0.2*np.random.normal(size=len(x))

>>> popt, pcov = curve_fit(func, x, yn)

Установленные параметры будут меняться из-за случайного шума, добавленного в, но я получил 2.47990495, 1.40709306, 0.53753635 как a, b и c, так что не так плохо с шумом там. Если я подхожу к y вместо yn, я получаю точные значения a, b и c.

Ответ 3

Процедура, чтобы соответствовать экспоненте без начального угадывания, а не итеративного процесса:

Это происходит из статьи (стр .16-17): https://fr.scribd.com/doc/14674814/Regressions-et-equations-integrales

При необходимости это можно использовать для инициализации исчисления нелинейной регрессии, чтобы выбрать конкретные критерии оптимизации.

ПРИМЕР:

Интересен пример, приведенный Джо Кингтоном. К сожалению, данные не отображаются, а только график. Таким образом, данные (x, y) ниже относятся к графическому просмотру графика, и, как следствие, численные значения, вероятно, не совсем те, что используются Джо Кингтоном. Тем не менее, соответствующие уравнения "подогнанных" кривых очень близки друг к другу, учитывая широкий разброс точек.

Верхняя фигура - это копия графа Кингтона.

На нижнем рисунке показаны результаты, полученные с помощью описанной выше процедуры.

Ответ 4

Правильный способ сделать это - сделать оценку Prony и использовать результат в качестве исходного предположения для финализации наименьших квадратов (или какой-либо другой более надежной подпрограммы). Оценка Prony не требует первоначального предположения, но для получения хорошей оценки требуется много точек.

Вот обзор

http://www.statsci.org/other/prony.html

В Octave это реализовано как expfit, поэтому вы можете написать свою собственную процедуру, основанную на библиотечной функции Octave.

Оценка Prony требует, чтобы смещение было известно, но если вы пойдете "достаточно далеко" в свой распад, у вас есть разумная оценка смещения, поэтому вы можете просто сдвинуть данные, чтобы поместить смещение в 0. При любом rate, оценка Prony - это всего лишь способ получить разумную первоначальную предположение для других подпрограмм подгонки.

Ответ 5

У меня никогда не было функции curve_fit работать, как вы говорите, я не хочу ничего угадывать. Я пытался упростить пример Джо Кингтона, и это то, что я получил. Идея состоит в том, чтобы перевести "шумные" данные в журнал, а затем перевести их обратно и использовать polyfit и polyval для определения параметров:

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()

где xVals и yVals - просто списки.

Ответ 6

Я не знаю питона, но я знаю простой способ нетеративно оценивать коэффициенты экспоненциального распада со смещением, учитывая три точки данных с фиксированной разницей в их независимой координате. Ваши точки данных имеют фиксированную разницу в их независимой координате (ваши значения x разнесены с интервалом 60), поэтому мой метод может быть применен к ним. Вы можете перевести математику в python.

Предположим

y = A + B*exp(-c*x) = A + B*C^x

где C = exp(-c)

Учитывая y_0, y_1, y_2, для x = 0, 1, 2, мы решаем

y_0 = A + B
y_1 = A + B*C
y_2 = A + B*C^2

чтобы найти A, B, C следующим образом:

A = (y_0*y_2 - y_1^2)/(y_0 + y_2 - 2*y_1)
B = (y_1 - y_0)^2/(y_0 + y_2 - 2*y_1)
C = (y_2 - y_1)/(y_1 - y_0)

Соответствующая экспонента проходит точно через три точки (0, y_0), (1, y_1) и (2, y_2). Если ваши точки данных не находятся в координатах x 0, 1, 2, а скорее в k, k + s и k + 2 * s, то

y = A′ + B′*C′^(k + s*x) = A′ + B′*C′^k*(C′^s)^x = A + B*C^x

чтобы вы могли использовать приведенные выше формулы для поиска A, B, C, а затем вычислить

A′ = A
C′ = C^(1/s)
B′ = B/(C′^k)

Полученные коэффициенты очень чувствительны к ошибкам в координатах y, что может привести к большим ошибкам, если вы экстраполируете за пределы, определенные тремя используемыми точками данных, поэтому лучше всего вычислить A, B, C из трех данных точки, которые находятся как можно дальше друг от друга (при этом все еще имеют фиксированное расстояние между ними). ​​

В вашем наборе данных имеется 10 эквидистантных точек данных. Позвольте выбрать три точки данных (110, 2391), (350, 786), (590, 263) для использования - они имеют максимально возможное фиксированное расстояние (240) в независимой координате. Таким образом, y_0 = 2391, y_1 = 786, y_2 = 263, k = 110, s = 240. Затем A = 10.20055, B = 2380.799, C = 0.3258567, A '= 10.20055, B' = 3980.329, C '= 0.9953388. Экспонента

y = 10.20055 + 3980.329*0.9953388^x = 10.20055 + 3980.329*exp(-0.004672073*x)

Вы можете использовать эту экспоненту в качестве исходного предположения в алгоритме нелинейной подгонки.

Формула для вычисления A такая же, как и для преобразования Shanks (http://en.wikipedia.org/wiki/Shanks_transformation).

Ответ 7

Если ваш распад начинается не с 0, используйте:

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

где x0 - начало распада (где вы хотите начать подгонку). И снова используйте x0 для построения:

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

где функция:

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

Ответ 8

Реализация @JJququinin на Python. Мне понадобилось приблизительное решение без решения без начальных догадок, поэтому ответ @Jacquelin был действительно полезен. Первоначальный вопрос был задан как запрос python numpy/scipy. Я взял @johanvdw хороший чистый R-код и реорганизовал его как python/numpy. Надеюсь, кому-то полезно: https://gist.github.com/friendtogeoff/00b89fa8d9acc1b2bdf3bdb675178a29

import numpy as np

"""
compute an exponential decay fit to two vectors of x and y data
result is in form y = a + b * exp(c*x).
ref. https://gist.github.com/johanvdw/443a820a7f4ffa7e9f8997481d7ca8b3
"""
def exp_est(x,y):
    n = np.size(x)
    # sort the data into ascending x order
    y = y[np.argsort(x)]
    x = x[np.argsort(x)]

    Sk = np.zeros(n)

    for n in range(1,n):
        Sk[n] = Sk[n-1] + (y[n] + y[n-1])*(x[n]-x[n-1])/2
    dx = x - x[0]
    dy = y - y[0]

    m1 = np.matrix([[np.sum(dx**2), np.sum(dx*Sk)],
                    [np.sum(dx*Sk), np.sum(Sk**2)]])
    m2 = np.matrix([np.sum(dx*dy), np.sum(dy*Sk)])

    [d, c] = (m1.I * m2.T).flat

    m3 = np.matrix([[n,                  np.sum(np.exp(  c*x))],
                    [np.sum(np.exp(c*x)),np.sum(np.exp(2*c*x))]])

    m4 = np.matrix([np.sum(y), np.sum(y*np.exp(c*x).T)])

    [a, b] = (m3.I * m4.T).flat

    return [a,b,c]