| 1 |
# Benchmarking scripts for lmfit |
| 2 |
|
| 3 |
from copy import deepcopy |
| 4 |
|
| 5 |
import numpy as np |
| 6 |
|
| 7 |
from lmfit import Minimizer, Parameters, conf_interval, minimize |
| 8 |
|
| 9 |
|
| 10 |
def obj_func(params, x, data): |
| 11 |
""" decaying sine wave, subtract data""" |
| 12 |
amp = params['amp'].value |
| 13 |
shift = params['shift'].value |
| 14 |
omega = params['omega'].value |
| 15 |
decay = params['decay'].value |
| 16 |
model = amp * np.sin(x * omega + shift) * np.exp(-x*x*decay) |
| 17 |
return model - data |
| 18 |
|
| 19 |
|
| 20 |
class MinimizeSuite: |
| 21 |
""" |
| 22 |
Benchmarks using minimize() and least-squares |
| 23 |
""" |
| 24 |
def setup(self): |
| 25 |
pass |
| 26 |
|
| 27 |
def time_minimize(self): |
| 28 |
np.random.seed(201) |
| 29 |
x = np.linspace(0, 15, 601) |
| 30 |
|
| 31 |
data = (5. * np.sin(2 * x - 0.1) * np.exp(-x*x*0.025) + |
| 32 |
np.random.normal(size=len(x), scale=0.3)) |
| 33 |
params = Parameters() |
| 34 |
params.add('amp', value=1, min=0, max=100) |
| 35 |
params.add('decay', value=0.0, min=0, max=10) |
| 36 |
params.add('shift', value=0.0, min=-np.pi/2., max=np.pi/2) |
| 37 |
params.add('omega', value=1.0, min=0, max=10) |
| 38 |
|
| 39 |
return minimize(obj_func, params, args=(x, data)) |
| 40 |
|
| 41 |
def time_minimize_withnan(self): |
| 42 |
np.random.seed(201) |
| 43 |
x = np.linspace(0, 15, 601) |
| 44 |
x[53] = np.nan |
| 45 |
|
| 46 |
data = (5. * np.sin(2 * x - 0.1) * np.exp(-x*x*0.025) + |
| 47 |
np.random.normal(size=len(x), scale=0.3)) |
| 48 |
params = Parameters() |
| 49 |
params.add('amp', value=1, min=0, max=100) |
| 50 |
params.add('decay', value=0.0, min=0, max=10) |
| 51 |
params.add('shift', value=0.0, min=-np.pi/2., max=np.pi/2) |
| 52 |
params.add('omega', value=1.0, min=0, max=10) |
| 53 |
|
| 54 |
return minimize(obj_func, params, args=(x, data), nan_policy='omit') |
| 55 |
|
| 56 |
def time_minimize_large(self): |
| 57 |
np.random.seed(201) |
| 58 |
x = np.linspace(0, 19, 70001) |
| 59 |
data = (5. * np.sin(0.6*x - 0.1) * np.exp(-x*x*0.0165) + |
| 60 |
np.random.normal(size=len(x), scale=0.3)) |
| 61 |
params = Parameters() |
| 62 |
params.add('amp', value=1, min=0, max=100) |
| 63 |
params.add('decay', value=0.0, min=0, max=10) |
| 64 |
params.add('shift', value=0.0, min=-np.pi/2., max=np.pi/2) |
| 65 |
params.add('omega', value=0.40, min=0, max=10) |
| 66 |
|
| 67 |
return minimize(obj_func, params, args=(x, data)) |
| 68 |
|
| 69 |
def time_confinterval(self): |
| 70 |
np.random.seed(0) |
| 71 |
x = np.linspace(0.3, 10, 100) |
| 72 |
y = 1/(0.1*x)+2+0.1*np.random.randn(x.size) |
| 73 |
|
| 74 |
p = Parameters() |
| 75 |
p.add_many(('a', 0.1), ('b', 1)) |
| 76 |
|
| 77 |
def residual(p): |
| 78 |
a = p['a'].value |
| 79 |
b = p['b'].value |
| 80 |
|
| 81 |
return 1/(a*x)+b-y |
| 82 |
|
| 83 |
minimizer = Minimizer(residual, p) |
| 84 |
out = minimizer.leastsq() |
| 85 |
return conf_interval(minimizer, out) |
| 86 |
|
| 87 |
|
| 88 |
class MinimizerClassSuite: |
| 89 |
""" |
| 90 |
Benchmarks for the Minimizer class |
| 91 |
""" |
| 92 |
def setup(self): |
| 93 |
self.x = np.linspace(1, 10, 250) |
| 94 |
np.random.seed(0) |
| 95 |
self.y = (3.0 * np.exp(-self.x / 2) |
| 96 |
- 5.0 * np.exp(-(self.x - 0.1) / 10.) |
| 97 |
+ 0.1 * np.random.randn(len(self.x))) |
| 98 |
|
| 99 |
self.p = Parameters() |
| 100 |
self.p.add_many(('a1', 4., True, 0., 10.), |
| 101 |
('a2', 4., True, -10., 10.), |
| 102 |
('t1', 3., True, 0.01, 10.), |
| 103 |
('t2', 3., True, 0.01, 20.)) |
| 104 |
|
| 105 |
self.p_emcee = deepcopy(self.p) |
| 106 |
self.p_emcee.add('noise', 0.2, True, 0.001, 1.) |
| 107 |
|
| 108 |
self.mini_de = Minimizer(Minimizer_Residual, |
| 109 |
self.p, |
| 110 |
fcn_args=(self.x, self.y), |
| 111 |
kws={'seed': 1, |
| 112 |
'polish': False, |
| 113 |
'maxiter': 100}) |
| 114 |
|
| 115 |
self.mini_emcee = Minimizer(Minimizer_lnprob, |
| 116 |
self.p_emcee, |
| 117 |
fcn_args=(self.x, self.y)) |
| 118 |
|
| 119 |
def time_differential_evolution(self): |
| 120 |
return self.mini_de.minimize(method='differential_evolution') |
| 121 |
|
| 122 |
def time_emcee(self): |
| 123 |
return self.mini_emcee.emcee(self.p_emcee, steps=100, seed=1) |
| 124 |
|
| 125 |
|
| 126 |
def Minimizer_Residual(p, x, y): |
| 127 |
v = p.valuesdict() |
| 128 |
return (v['a1'] * np.exp(-x / v['t1']) |
| 129 |
+ v['a2'] * np.exp(-(x - 0.1) / v['t2']) |
| 130 |
- y) |
| 131 |
|
| 132 |
|
| 133 |
def Minimizer_lnprob(p, x, y): |
| 134 |
noise = p['noise'].value |
| 135 |
return -0.5 * np.sum((Minimizer_Residual(p, x, y) / noise)**2 |
| 136 |
+ np.log(2 * np.pi * noise**2)) |