提高lmfit中多个数据集拟合的速度？ 字符串调用限制

Question

我想用形状（161,14）拟合数据集，其中行是能量方向，而cols是在不同实验条件下相同光谱的重排。

数据集中应该有3个不同的峰，因此我建立了三个语音的复合模型。 目标是共享参数，以使原声的中心和宽度相同。

我发现了与Python和lmfit有关的问题：如何使用共享参数拟合多个数据集？

但是这里的参数是硬接线的，所以我尝试如下。

import h5py
import numpy as np
from lmfit import Parameters, minimize, report_fit
from lmfit.models import VoigtModel, LinearModel
from matplotlib import pyplot as plt
import cProfile

mods = None
c = [530., 531.5, 533.]
c_win = 1
sigma = 0.2
gamma = 0.2
gamma_min = 0.1
gamma_max = 1.


def objective(params, x, data):
    """ calculate total residual for fits to several data sets held
    in a 2-D array, and modeled by Gaussian functions"""
    nx, ndata = data.shape
    resid = 0.0 * data[:]
    # nx = 1
    # make residual per data set
    for i in range(ndata):
        resid[:, i] = data[:, i] - mods[i].eval(params,x=x)
    # resid = data - mods[0].eval(params, x=x)
    # now flatten this to a 1D array, as minimize() needs
    # print(resid.sum())
    return resid.flatten()


def make_param(v, params):
    for i in range(3):
        v[i].set_param_hint('amplitude', value=1e3)
        v[i].set_param_hint('center', value=c[i], min=c[i] - c_win, max=c[i] + c_win)
        v[i].set_param_hint('sigma', vary=False, value=sigma)
        v[i].set_param_hint('gamma', vary=True, expr='', value=gamma, min=gamma_min, max=gamma_max)
        params += v[i].make_params()


f = h5py.File("../../analysis.h5", "a")
raw = f["rawdata"]
proc = f["processed"]
spec_group = raw["Co0001_0042O1s_4600"]
specs = spec_group['sweeps'][()]
x = spec_group['x_b'][()]

specs2 = np.zeros((161, 14))
specs2[:, :] = specs[:, 0, :]

l0 = LinearModel(prefix="l0_")
v0 = VoigtModel(prefix="p0_")
v1 = VoigtModel(prefix="p1_")
v2 = VoigtModel(prefix="p2_")
v = [v0, v1, v2]
params = Parameters()
mod0 = l0 + v0 + v1 + v2
params += l0.make_params(intercept=3000, slope=0)

make_param(v, params)

specs2 = specs2[:, ::4]

mods = [mod0]
for i in range(1, specs2.shape[1]):
    l0 = LinearModel(prefix="l0_%i" % i)
    v0 = VoigtModel(prefix="p0_%i" % i)
    v1 = VoigtModel(prefix="p1_%i" % i)
    v2 = VoigtModel(prefix="p2_%i" % i)
    params += l0.make_params(intercept=3000, slope=0)
    v = [v0, v1, v2]
    make_param(v, params)
    params['p0_%icenter' % i].expr = 'p0_center'
    params['p1_%icenter' % i].expr = 'p1_center'
    params['p2_%icenter' % i].expr = 'p2_center'
    params['p0_%igamma' % i].expr = 'p0_gamma'
    params['p1_%igamma' % i].expr = 'p1_gamma'
    params['p2_%igamma' % i].expr = 'p2_gamma'
    params['p0_%isigma' % i].expr = 'p0_sigma'
    params['p1_%isigma' % i].expr = 'p1_sigma'
    params['p2_%isigma' % i].expr = 'p2_sigma'

    mods += [l0 + v0 + v1 + v2]

cProfile.run('result = minimize(objective, params, args=(x, specs2))')
# result = minimize(objective, params, args=(x, specs2))#,method='ampgo')
report_fit(result)

plt.figure()
plt.plot(x, specs2[:, 0], x, mods[0].eval(result.params, x=x))
plt.plot(x, specs2[:, -1], x, mods[-1].eval(result.params, x=x))
high = np.max(x)
low = np.min(x)
plt.xlim(high, low)
plt.show()

代码运行和拟合令人满意，但是需要很长时间。

所以我做了一个cprofile，看来大多数时候都是字符串解析。 这是故意的还是有办法减少这种时间？

我还注意到，必须对这4个光谱进行14125个评估。 很多，对吧？ 我是在定义参数的方式上犯了一个根本性的错误，还是针对此特定问题进行了不同的最小化？

分析和拟合报告： https ： //pastebin.com/pveD6sRe

First lines of the profiling sorted by total time:
   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
10163844/1288568   21.010    0.000   42.870    0.000 asteval.py:279(run)
   226048    9.725    0.000   32.178    0.000 model.py:775(make_funcargs)
 18309888    8.781    0.000   13.574    0.000 model.py:769(_strip_prefix)
   169536    6.870    0.000    6.870    0.000 lineshapes.py:63(voigt)
  1695690    4.731    0.000   54.555    0.000 parameter.py:745(_getval)

Answer 1

好吧，分析通常很棘手，但是您没有包括分析结果或拟合报告，因此也很难做出充分响应。

14000个功能评估的确很多。 但是，我对Voigt参数的初始值不太现实。 定义三个Voigt函数然后将所有参数约束为相同似乎有些奇怪。 混合创建复合Model然后使用lmfit.minimize看起来也很奇怪。

对于基于lmfit示例的简化（但应该相关？）案例（数据来自https://github.com/lmfit/lmfit-py/blob/master/examples/test_peak.dat ）：

#!/usrbin/env python
from numpy import loadtxt
import cProfile
from lmfit.models import  VoigtModel

data = loadtxt('examples/test_peak.dat') # from lmfit/examples
x = data[:, 0]
y = data[:, 1]

mod = VoigtModel()
pars = mod.guess(y, x=x)
pars['gamma'].set(value = 2, vary=True, expr=None)

cProfile.run("out= mod.fit(y, pars, x=x)", sort=1)

print(out.fit_report(min_correl=0.25))

我得到了54个功能评估和配置文件输出

42228 function calls (37487 primitive calls) in 0.054 seconds
Ordered by: internal time

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
        3    0.021    0.007    0.021    0.007 {built-in method numpy.dot}
33225/150    0.006    0.000    0.013    0.000 asteval.py:279(run)
       59    0.004    0.000    0.004    0.000 lineshapes.py:63(voigt)
 1050/150    0.001    0.000    0.012    0.000 asteval.py:581(on_binop)
  300/225    0.001    0.000    0.008    0.000 asteval.py:744(on_call)
     8364    0.001    0.000    0.001    0.000 {built-in method builtins.isinstance}
      156    0.001    0.000    0.001    0.000 {built-in method builtins.compile}
      412    0.001    0.000    0.013    0.000 parameter.py:740(_getval)

这向我表明，拟合工作花费了一些时间来评估约束表达式（对于Voigt来说， fwhm和height有点复杂），但是它并不能支配运行时。 我觉得你有更多的福格特的功能和更多功能的评估，所以它可能是更显著。

如果我显式简化约束表达式，则不正确

mod = VoigtModel()
mod.param_hints['fwhm']['expr'] = 'sigma'
mod.param_hints['height']['expr'] = 'amplitude'

pars = mod.guess(y, x=x)
pars['gamma'].set(value = 2, vary=True, expr=None)
cProfile.run("out= mod.fit(y, pars, x=x)", sort=1)

然后我看到的分析输出

16723 function calls (16361 primitive calls) in 0.045 seconds
Ordered by: internal time
 ncalls  tottime  percall  cumtime  percall filename:lineno(function)
      3    0.022    0.007    0.022    0.007 {built-in method numpy.dot}
     59    0.005    0.000    0.005    0.000 lineshapes.py:63(voigt)
450/150    0.001    0.000    0.002    0.000 asteval.py:279(run)
    412    0.001    0.000    0.004    0.000 parameter.py:740(_getval)

因此，它不会对asteval进行多次调用，但也似乎运行起来并不快（FWIW，函数eval的数量相同）。

我可能建议尝试类似的策略，也许删除height和fwhm的参数提示，也许用

 mod.param_hints.pop('fwhm')
 mod.param_hints.pop('height')

看看是否能改善您的运行时间。

我怀疑了解为什么您的健身需要进行多次迭代可能会更有用。 如果您有多个Voigt峰，则可能要检查它们是在交换位置还是在重叠...