Multivariate curve fitting Python

class Methods

Evaluate the model with supplied parameters and keyword arguments.

• params (, optional) – Parameters to use in Model.

• **kwargs (optional) – Additional keyword arguments to pass to model function.

Value of model given the parameters and other arguments.

, , or

Notes

1. if params is None, the values for all parameters are expected to be provided as keyword arguments. If params is given, and a keyword argument for a parameter value is also given, the keyword argument will be used.

2. all non-parameter arguments for the model function, including all the independent variables will need to be passed in using keyword arguments.

3. The return type depends on the model function. For many of the built-models it is a numpy.ndarray, with the exception of ConstantModel and ComplexConstantModel, which return a float/int or complex value.

Fit the model to the data using the supplied Parameters.

• data (array_like) – Array of data to be fit.

• params (, optional) – Parameters to use in fit (default is None).

• weights (array_like, optional) – Weights to use for the calculation of the fit residual [i.e., weights*(data-fit)]. Default is None; must have the same size as data.

• method (, optional) – Name of fitting method to use (default is ‘leastsq’).

• iter_cb (callable, optional) – Callback function to call at each iteration (default is None).

• scale_covar (, optional) – Whether to automatically scale the covariance matrix when calculating uncertainties (default is True).

• verbose (, optional) – Whether to print a message when a new parameter is added because of a hint (default is True).

• fit_kws (, optional) – Options to pass to the minimizer being used.

• nan_policy ({'raise', 'propagate', 'omit'}, optional) – What to do when encountering NaNs when fitting Model.

• calc_covar (, optional) – Whether to calculate the covariance matrix (default is True) for solvers other than ‘leastsq’ and ‘least_squares’. Requires the

  from scipy.optimize import curve_fit
  
  x = linspace(-10, 10, 101)
  y = gaussian(x, 2.33, 0.21, 1.51) + random.normal(0, 0.2, x.size)
  
  init_vals = [1, 0, 1]  # for [amp, cen, wid]
  best_vals, covar = curve_fit(gaussian, x, y, p0=init_vals)
  

  07 package to be installed.

• max_nfev ( or None, optional) – Maximum number of function evaluations (default is None). The default value depends on the fitting method.

• **kwargs (optional) – Arguments to pass to the model function, possibly overriding parameters.

Notes

1. if params is None, the values for all parameters are expected to be provided as keyword arguments. If params is given, and a keyword argument for a parameter value is also given, the keyword argument will be used.

2. all non-parameter arguments for the model function, including all the independent variables will need to be passed in using keyword arguments.

3. Parameters (however passed in), are copied on input, so the original Parameter objects are unchanged, and the updated values are in the returned ModelResult.

Examples

Take

from scipy.optimize import curve_fit

x = linspace(-10, 10, 101)
y = gaussian(x, 2.33, 0.21, 1.51) + random.normal(0, 0.2, x.size)

init_vals = [1, 0, 1]  # for [amp, cen, wid]
best_vals, covar = curve_fit(gaussian, x, y, p0=init_vals)

from scipy.optimize import curve_fit

x = linspace(-10, 10, 101)
y = gaussian(x, 2.33, 0.21, 1.51) + random.normal(0, 0.2, x.size)

init_vals = [1, 0, 1]  # for [amp, cen, wid]
best_vals, covar = curve_fit(gaussian, x, y, p0=init_vals)

Or, for more control, pass a Parameters object.

from scipy.optimize import curve_fit

x = linspace(-10, 10, 101)
y = gaussian(x, 2.33, 0.21, 1.51) + random.normal(0, 0.2, x.size)

init_vals = [1, 0, 1]  # for [amp, cen, wid]
best_vals, covar = curve_fit(gaussian, x, y, p0=init_vals)

Keyword arguments override Parameters.

from scipy.optimize import curve_fit

x = linspace(-10, 10, 101)
y = gaussian(x, 2.33, 0.21, 1.51) + random.normal(0, 0.2, x.size)

init_vals = [1, 0, 1]  # for [amp, cen, wid]
best_vals, covar = curve_fit(gaussian, x, y, p0=init_vals)

Guess starting values for the parameters of a Model.

This is not implemented for all models, but is available for many of the built-in models.

• data (array_like) – Array of data (i.e., y-values) to use to guess parameter values.

• x (array_like) – Array of values for the independent variable (i.e., x-values).

• **kws (optional) – Additional keyword arguments, passed to model function.

Initial, guessed values for the parameters of a Model.

– If the guess method is not implemented for a Model.

Notes

Should be implemented for each model subclass to run self.make_params(), update starting values and return a Parameters object.

Changed in version 1.0.3: Argument

x_eval = linspace(0, 10, 201)
y_eval = gmodel.eval(params, x=x_eval)

Create a Parameters object for a Model.

• verbose (, optional) – Whether to print out messages (default is False).

• **kwargs (optional) – Parameter names and initial values.

params – Parameters object for the Model.

Notes

1. The parameters may or may not have decent initial values for each parameter.

2. This applies any default values or parameter hints that may have been set.

Set hints to use when creating parameters with make_params().

This is especially convenient for setting initial values. The name can include the models prefix or not. The hint given can also include optional bounds and constraints

from scipy.optimize import curve_fit

x = linspace(-10, 10, 101)
y = gaussian(x, 2.33, 0.21, 1.51) + random.normal(0, 0.2, x.size)

init_vals = [1, 0, 1]  # for [amp, cen, wid]
best_vals, covar = curve_fit(gaussian, x, y, p0=init_vals)

• name () – Parameter name.

• **kwargs (optional) –

  Arbitrary keyword arguments, needs to be a Parameter attribute. Can be any of the following:

  • valuefloat, optional

    Numerical Parameter value.

  • varybool, optional

    Whether the Parameter is varied during a fit (default is True).

  • minfloat, optional

    Lower bound for value (default is

    from scipy.optimize import curve_fit
    
    x = linspace(-10, 10, 101)
    y = gaussian(x, 2.33, 0.21, 1.51) + random.normal(0, 0.2, x.size)
    
    init_vals = [1, 0, 1]  # for [amp, cen, wid]
    best_vals, covar = curve_fit(gaussian, x, y, p0=init_vals)
    

    11, no lower bound).

  • maxfloat, optional

    Upper bound for value (default is

    from scipy.optimize import curve_fit
    
    x = linspace(-10, 10, 101)
    y = gaussian(x, 2.33, 0.21, 1.51) + random.normal(0, 0.2, x.size)
    
    init_vals = [1, 0, 1]  # for [amp, cen, wid]
    best_vals, covar = curve_fit(gaussian, x, y, p0=init_vals)
    

    12, no upper bound).

  • exprstr, optional

    Mathematical expression used to constrain the value during the fit.

Example

from scipy.optimize import curve_fit

x = linspace(-10, 10, 101)
y = gaussian(x, 2.33, 0.21, 1.51) + random.normal(0, 0.2, x.size)

init_vals = [1, 0, 1]  # for [amp, cen, wid]
best_vals, covar = curve_fit(gaussian, x, y, p0=init_vals)

See .

Print a nicely aligned text-table of parameter hints.

colwidth (, optional) – Width of each column, except for first and last columns.

class Attributes

The model function used to calculate the model.

List of strings for names of the independent variables.

Describes what to do for NaNs that indicate missing values in the data. The choices are:

• from scipy.optimize import curve_fit
  
  x = linspace(-10, 10, 101)
  y = gaussian(x, 2.33, 0.21, 1.51) + random.normal(0, 0.2, x.size)
  
  init_vals = [1, 0, 1]  # for [amp, cen, wid]
  best_vals, covar = curve_fit(gaussian, x, y, p0=init_vals)
  

  14: Raise a

  from scipy.optimize import curve_fit
  
  x = linspace(-10, 10, 101)
  y = gaussian(x, 2.33, 0.21, 1.51) + random.normal(0, 0.2, x.size)
  
  init_vals = [1, 0, 1]  # for [amp, cen, wid]
  best_vals, covar = curve_fit(gaussian, x, y, p0=init_vals)
  

  15 (default)

• from scipy.optimize import curve_fit
  
  x = linspace(-10, 10, 101)
  y = gaussian(x, 2.33, 0.21, 1.51) + random.normal(0, 0.2, x.size)
  
  init_vals = [1, 0, 1]  # for [amp, cen, wid]
  best_vals, covar = curve_fit(gaussian, x, y, p0=init_vals)
  

  16: Do not check for NaNs or missing values. The fit will try to ignore them.

• from scipy.optimize import curve_fit
  
  x = linspace(-10, 10, 101)
  y = gaussian(x, 2.33, 0.21, 1.51) + random.normal(0, 0.2, x.size)
  
  init_vals = [1, 0, 1]  # for [amp, cen, wid]
  best_vals, covar = curve_fit(gaussian, x, y, p0=init_vals)
  

  17: Remove NaNs or missing observations in data. If pandas is installed, is used, otherwise

  from scipy.optimize import curve_fit
  
  x = linspace(-10, 10, 101)
  y = gaussian(x, 2.33, 0.21, 1.51) + random.normal(0, 0.2, x.size)
  
  init_vals = [1, 0, 1]  # for [amp, cen, wid]
  best_vals, covar = curve_fit(gaussian, x, y, p0=init_vals)
  

  19 is used.

Name of the model, used only in the string representation of the model. By default this will be taken from the model function.

Extra keyword arguments to pass to model function. Normally this will be determined internally and should not be changed.

Dictionary of parameter hints. See .

List of strings of parameter names.

Prefix used for name-mangling of parameter names. The default is

from scipy.optimize import curve_fit

x = linspace(-10, 10, 101)
y = gaussian(x, 2.33, 0.21, 1.51) + random.normal(0, 0.2, x.size)

init_vals = [1, 0, 1]  # for [amp, cen, wid]
best_vals, covar = curve_fit(gaussian, x, y, p0=init_vals)

from scipy.optimize import curve_fit

x = linspace(-10, 10, 101)
y = gaussian(x, 2.33, 0.21, 1.51) + random.normal(0, 0.2, x.size)

init_vals = [1, 0, 1]  # for [amp, cen, wid]
best_vals, covar = curve_fit(gaussian, x, y, p0=init_vals)

from scipy.optimize import curve_fit

x = linspace(-10, 10, 101)
y = gaussian(x, 2.33, 0.21, 1.51) + random.normal(0, 0.2, x.size)

init_vals = [1, 0, 1]  # for [amp, cen, wid]
best_vals, covar = curve_fit(gaussian, x, y, p0=init_vals)

from scipy.optimize import curve_fit

x = linspace(-10, 10, 101)
y = gaussian(x, 2.33, 0.21, 1.51) + random.normal(0, 0.2, x.size)

init_vals = [1, 0, 1]  # for [amp, cen, wid]
best_vals, covar = curve_fit(gaussian, x, y, p0=init_vals)

from scipy.optimize import curve_fit

x = linspace(-10, 10, 101)
y = gaussian(x, 2.33, 0.21, 1.51) + random.normal(0, 0.2, x.size)

init_vals = [1, 0, 1]  # for [amp, cen, wid]
best_vals, covar = curve_fit(gaussian, x, y, p0=init_vals)

from scipy.optimize import curve_fit

x = linspace(-10, 10, 101)
y = gaussian(x, 2.33, 0.21, 1.51) + random.normal(0, 0.2, x.size)

init_vals = [1, 0, 1]  # for [amp, cen, wid]
best_vals, covar = curve_fit(gaussian, x, y, p0=init_vals)

from scipy.optimize import curve_fit

x = linspace(-10, 10, 101)
y = gaussian(x, 2.33, 0.21, 1.51) + random.normal(0, 0.2, x.size)

init_vals = [1, 0, 1]  # for [amp, cen, wid]
best_vals, covar = curve_fit(gaussian, x, y, p0=init_vals)

from scipy.optimize import curve_fit

x = linspace(-10, 10, 101)
y = gaussian(x, 2.33, 0.21, 1.51) + random.normal(0, 0.2, x.size)

init_vals = [1, 0, 1]  # for [amp, cen, wid]
best_vals, covar = curve_fit(gaussian, x, y, p0=init_vals)

Determining parameter names and independent variables for a function

The created from the supplied function

from scipy.optimize import curve_fit

x = linspace(-10, 10, 101)
y = gaussian(x, 2.33, 0.21, 1.51) + random.normal(0, 0.2, x.size)

init_vals = [1, 0, 1]  # for [amp, cen, wid]
best_vals, covar = curve_fit(gaussian, x, y, p0=init_vals)

By default, the independent variable is taken as the first argument to the function. You can, of course, explicitly set this, and will need to do so if the independent variable is not first in the list, or if there is actually more than one independent variable.

If not specified, Parameters are constructed from all positional arguments and all keyword arguments that have a default value that is numerical, except the independent variable, of course. Importantly, the Parameters can be modified after creation. In fact, you will have to do this because none of the parameters have valid initial values. In addition, one can place bounds and constraints on Parameters, or fix their values.

Explicitly specifying y_eval = gmodel.eval(x=x_eval, cen=6.5, amp=100, wid=2.0) 2

As we saw for the Gaussian example above, creating a from a function is fairly easy. Let’s try another one:

from lmfit import Model

gmodel = Model(gaussian)
print(f'parameter names: {gmodel.param_names}')
print(f'independent variables: {gmodel.independent_vars}')

from lmfit import Model

gmodel = Model(gaussian)
print(f'parameter names: {gmodel.param_names}')
print(f'independent variables: {gmodel.independent_vars}')

Here,

from scipy.optimize import curve_fit

x = linspace(-10, 10, 101)
y = gaussian(x, 2.33, 0.21, 1.51) + random.normal(0, 0.2, x.size)

init_vals = [1, 0, 1]  # for [amp, cen, wid]
best_vals, covar = curve_fit(gaussian, x, y, p0=init_vals)

If you want

from scipy.optimize import curve_fit

x = linspace(-10, 10, 101)
y = gaussian(x, 2.33, 0.21, 1.51) + random.normal(0, 0.2, x.size)

init_vals = [1, 0, 1]  # for [amp, cen, wid]
best_vals, covar = curve_fit(gaussian, x, y, p0=init_vals)

from lmfit import Model

gmodel = Model(gaussian)
print(f'parameter names: {gmodel.param_names}')
print(f'independent variables: {gmodel.independent_vars}')

from lmfit import Model

gmodel = Model(gaussian)
print(f'parameter names: {gmodel.param_names}')
print(f'independent variables: {gmodel.independent_vars}')

You can also supply multiple values for multi-dimensional functions with multiple independent variables. In fact, the meaning of independent variable here is simple, and based on how it treats arguments of the function you are modeling:

A function argument that is not a parameter or otherwise part of the model, and that will be required to be explicitly provided as a keyword argument for each fit with or evaluation with .

Note that independent variables are not required to be arrays, or even floating point numbers.

Functions with keyword arguments

If the model function had keyword parameters, these would be turned into Parameters if the supplied default value was a valid number (but not

from scipy.optimize import curve_fit

x = linspace(-10, 10, 101)
y = gaussian(x, 2.33, 0.21, 1.51) + random.normal(0, 0.2, x.size)

init_vals = [1, 0, 1]  # for [amp, cen, wid]
best_vals, covar = curve_fit(gaussian, x, y, p0=init_vals)

from scipy.optimize import curve_fit

x = linspace(-10, 10, 101)
y = gaussian(x, 2.33, 0.21, 1.51) + random.normal(0, 0.2, x.size)

init_vals = [1, 0, 1]  # for [amp, cen, wid]
best_vals, covar = curve_fit(gaussian, x, y, p0=init_vals)

from scipy.optimize import curve_fit

x = linspace(-10, 10, 101)
y = gaussian(x, 2.33, 0.21, 1.51) + random.normal(0, 0.2, x.size)

init_vals = [1, 0, 1]  # for [amp, cen, wid]
best_vals, covar = curve_fit(gaussian, x, y, p0=init_vals)

from lmfit import Model

gmodel = Model(gaussian)
print(f'parameter names: {gmodel.param_names}')
print(f'independent variables: {gmodel.independent_vars}')

from lmfit import Model

gmodel = Model(gaussian)
print(f'parameter names: {gmodel.param_names}')
print(f'independent variables: {gmodel.independent_vars}')

Here, even though

from scipy.optimize import curve_fit

x = linspace(-10, 10, 101)
y = gaussian(x, 2.33, 0.21, 1.51) + random.normal(0, 0.2, x.size)

init_vals = [1, 0, 1]  # for [amp, cen, wid]
best_vals, covar = curve_fit(gaussian, x, y, p0=init_vals)

from scipy.optimize import curve_fit

x = linspace(-10, 10, 101)
y = gaussian(x, 2.33, 0.21, 1.51) + random.normal(0, 0.2, x.size)

init_vals = [1, 0, 1]  # for [amp, cen, wid]
best_vals, covar = curve_fit(gaussian, x, y, p0=init_vals)

from scipy.optimize import curve_fit

x = linspace(-10, 10, 101)
y = gaussian(x, 2.33, 0.21, 1.51) + random.normal(0, 0.2, x.size)

init_vals = [1, 0, 1]  # for [amp, cen, wid]
best_vals, covar = curve_fit(gaussian, x, y, p0=init_vals)

Defining a from scipy.optimize import curve_fit x = linspace(-10, 10, 101) y = gaussian(x, 2.33, 0.21, 1.51) + random.normal(0, 0.2, x.size) init_vals = [1, 0, 1] # for [amp, cen, wid] best_vals, covar = curve_fit(gaussian, x, y, p0=init_vals) 44 for the Parameters

As we will see in the next chapter when combining models, it is sometimes necessary to decorate the parameter names in the model, but still have them be correctly used in the underlying model function. This would be necessary, for example, if two parameters in a composite model (see or examples in the next chapter) would have the same name. To avoid this, we can add a

from scipy.optimize import curve_fit

x = linspace(-10, 10, 101)
y = gaussian(x, 2.33, 0.21, 1.51) + random.normal(0, 0.2, x.size)

init_vals = [1, 0, 1]  # for [amp, cen, wid]
best_vals, covar = curve_fit(gaussian, x, y, p0=init_vals)

from lmfit import Model

gmodel = Model(gaussian)
print(f'parameter names: {gmodel.param_names}')
print(f'independent variables: {gmodel.independent_vars}')

from lmfit import Model

gmodel = Model(gaussian)
print(f'parameter names: {gmodel.param_names}')
print(f'independent variables: {gmodel.independent_vars}')

You would refer to these parameters as

from scipy.optimize import curve_fit

x = linspace(-10, 10, 101)
y = gaussian(x, 2.33, 0.21, 1.51) + random.normal(0, 0.2, x.size)

init_vals = [1, 0, 1]  # for [amp, cen, wid]
best_vals, covar = curve_fit(gaussian, x, y, p0=init_vals)

from scipy.optimize import curve_fit

x = linspace(-10, 10, 101)
y = gaussian(x, 2.33, 0.21, 1.51) + random.normal(0, 0.2, x.size)

init_vals = [1, 0, 1]  # for [amp, cen, wid]
best_vals, covar = curve_fit(gaussian, x, y, p0=init_vals)

from scipy.optimize import curve_fit

x = linspace(-10, 10, 101)
y = gaussian(x, 2.33, 0.21, 1.51) + random.normal(0, 0.2, x.size)

init_vals = [1, 0, 1]  # for [amp, cen, wid]
best_vals, covar = curve_fit(gaussian, x, y, p0=init_vals)

Initializing model parameters

As mentioned above, the parameters created by are generally created with invalid initial values of

from scipy.optimize import curve_fit

x = linspace(-10, 10, 101)
y = gaussian(x, 2.33, 0.21, 1.51) + random.normal(0, 0.2, x.size)

init_vals = [1, 0, 1]  # for [amp, cen, wid]
best_vals, covar = curve_fit(gaussian, x, y, p0=init_vals)

1. You can supply initial values in the definition of the model function.

2. You can initialize the parameters when creating parameters with .

3. You can give parameter hints with .

4. You can supply initial values for the parameters when you use the or methods.

Of course these methods can be mixed, allowing you to overwrite initial values at any point in the process of defining and using the model.

from lmfit import Model

gmodel = Model(gaussian)
print(f'parameter names: {gmodel.param_names}')
print(f'independent variables: {gmodel.independent_vars}')

from lmfit import Model

gmodel = Model(gaussian)
print(f'parameter names: {gmodel.param_names}')
print(f'independent variables: {gmodel.independent_vars}')

parameter names: ['amp', 'cen', 'wid']
independent variables: ['x']

parameter names: ['amp', 'cen', 'wid']
independent variables: ['x']

parameter names: ['amp', 'cen', 'wid']
independent variables: ['x']

Using parameter hints

After a model has been created, you can give it hints for how to create parameters with . This allows you to set not only a default initial value but also to set other parameter attributes controlling bounds, whether it is varied in the fit, or a constraint expression. To set a parameter hint, you can use , as with:

parameter names: ['amp', 'cen', 'wid']
independent variables: ['x']

Parameter hints are stored in a model’s attribute, which is simply a nested dictionary:

parameter names: ['amp', 'cen', 'wid']
independent variables: ['x']

parameter names: ['amp', 'cen', 'wid']
independent variables: ['x']

You can change this dictionary directly, or with the method. Either way, these parameter hints are used by when making parameters.

An important feature of parameter hints is that you can force the creation of new parameters with parameter hints. This can be useful to make derived parameters with constraint expressions. For example to get the full-width at half maximum of a Gaussian model, one could use a parameter hint of:

parameter names: ['amp', 'cen', 'wid']
independent variables: ['x']

Saving and Loading Models

New in version 0.9.8.

It is sometimes desirable to save a for later use outside of the code used to define the model. Lmfit provides a function that will save a to a file. There is also a companion function that can read this file and reconstruct a from it.

Saving a model turns out to be somewhat challenging. The main issue is that Python is not normally able to serialize a function (such as the model function making up the heart of the Model) in a way that can be reconstructed into a callable Python object. The

from scipy.optimize import curve_fit

x = linspace(-10, 10, 101)
y = gaussian(x, 2.33, 0.21, 1.51) + random.normal(0, 0.2, x.size)

init_vals = [1, 0, 1]  # for [amp, cen, wid]
best_vals, covar = curve_fit(gaussian, x, y, p0=init_vals)

If the

from scipy.optimize import curve_fit

x = linspace(-10, 10, 101)
y = gaussian(x, 2.33, 0.21, 1.51) + random.normal(0, 0.2, x.size)

init_vals = [1, 0, 1]  # for [amp, cen, wid]
best_vals, covar = curve_fit(gaussian, x, y, p0=init_vals)

from scipy.optimize import curve_fit

x = linspace(-10, 10, 101)
y = gaussian(x, 2.33, 0.21, 1.51) + random.normal(0, 0.2, x.size)

init_vals = [1, 0, 1]  # for [amp, cen, wid]
best_vals, covar = curve_fit(gaussian, x, y, p0=init_vals)

from scipy.optimize import curve_fit

x = linspace(-10, 10, 101)
y = gaussian(x, 2.33, 0.21, 1.51) + random.normal(0, 0.2, x.size)

init_vals = [1, 0, 1]  # for [amp, cen, wid]
best_vals, covar = curve_fit(gaussian, x, y, p0=init_vals)

from scipy.optimize import curve_fit

x = linspace(-10, 10, 101)
y = gaussian(x, 2.33, 0.21, 1.51) + random.normal(0, 0.2, x.size)

init_vals = [1, 0, 1]  # for [amp, cen, wid]
best_vals, covar = curve_fit(gaussian, x, y, p0=init_vals)

from scipy.optimize import curve_fit

x = linspace(-10, 10, 101)
y = gaussian(x, 2.33, 0.21, 1.51) + random.normal(0, 0.2, x.size)

init_vals = [1, 0, 1]  # for [amp, cen, wid]
best_vals, covar = curve_fit(gaussian, x, y, p0=init_vals)

Save a Model to a file.

• model () – Model to be saved.

• fname () – Name of file for saved Model.

Load a saved Model from a file.

• fname () – Name of file containing saved Model.

• funcdefs (, optional) – Dictionary of custom function names and definitions.

Model object loaded from file.

As a simple example, one can save a model as:

parameter names: ['amp', 'cen', 'wid']
independent variables: ['x']

To load that later, one might do:

parameter names: ['amp', 'cen', 'wid']
independent variables: ['x']

See also .

methods

Evaluate model function.

• params (, optional) – Parameters to use.

• **kwargs (optional) – Options to send to Model.eval().

Array or value for the evaluated model.

, , , or

Evaluate each component of a composite model function.

• params (, optional) – Parameters, defaults to ModelResult.params.

• **kwargs (optional) – Keyword arguments to pass to model function.

Keys are prefixes of component models, and values are the estimated model value for each component of the model.

Re-perform fit for a Model, given data and params.

• data (array_like, optional) – Data to be modeled.

• params (, optional) – Parameters with initial values for model.

• weights (array_like, optional) – Weights to multiply

  from scipy.optimize import curve_fit
  
  x = linspace(-10, 10, 101)
  y = gaussian(x, 2.33, 0.21, 1.51) + random.normal(0, 0.2, x.size)
  
  init_vals = [1, 0, 1]  # for [amp, cen, wid]
  best_vals, covar = curve_fit(gaussian, x, y, p0=init_vals)
  

  98 for fit residual.

• method (, optional) – Name of minimization method to use (default is ‘leastsq’).

• nan_policy ({'raise', 'propagate', 'omit'}, optional) – What to do when encountering NaNs when fitting Model.

• **kwargs (optional) – Keyword arguments to send to minimization routine.

Return a printable fit report.

The report contains fit statistics and best-fit values with uncertainties and correlations.

• modelpars (, optional) – Known Model Parameters.

• show_correl (, optional) – Whether to show list of sorted correlations (default is True).

• min_correl (, optional) – Smallest correlation in absolute value to show (default is 0.1).

• sort_pars (callable, optional) – Whether to show parameter names sorted in alphanumerical order (default is False). If False, then the parameters will be listed in the order as they were added to the Parameters dictionary. If callable, then this (one argument) function is used to extract a comparison key from each list element.

Multi-line text of fit report.

Calculate the confidence intervals for the variable parameters.

Confidence intervals are calculated using the

from lmfit import Model

gmodel = Model(gaussian)
print(f'parameter names: {gmodel.param_names}')
print(f'independent variables: {gmodel.independent_vars}')

Return a formatted text report of the confidence intervals.

• with_offset (, optional) – Whether to subtract best value from all other values (default is True).

• ndigits (, optional) – Number of significant digits to show (default is 5).

• **kwargs (optional) – Keyword arguments that are passed to the conf_interval function.

Text of formatted report on confidence intervals.

Evaluate the uncertainty of the model function.

This can be used to give confidence bands for the model from the uncertainties in the best-fit parameters.

• params (, optional) – Parameters, defaults to ModelResult.params.

• sigma (, optional) – Confidence level, i.e. how many sigma (default is 1).

• **kwargs (optional) – Values of options, independent variables, etcetera.

Uncertainty at each value of the model.

Notes

1. This is based on the excellent and clear example from , which references the original work of: J. Wolberg, Data Analysis Using the Method of Least Squares, 2006, Springer

2. The value of sigma is number of sigma values, and is converted to a probability. Values of 1, 2, or 3 give probabilities of 0.6827, 0.9545, and 0.9973, respectively. If the sigma value is < 1, it is interpreted as the probability itself. That is,

   from lmfit import Model
   
   gmodel = Model(gaussian)
   print(f'parameter names: {gmodel.param_names}')
   print(f'independent variables: {gmodel.independent_vars}')
   

   04 and

   from lmfit import Model
   
   gmodel = Model(gaussian)
   print(f'parameter names: {gmodel.param_names}')
   print(f'independent variables: {gmodel.independent_vars}')
   

   05 will give the same results, within precision errors.

3. Also sets attributes of dely for the uncertainty of the model (which will be the same as the array returned by this method) and dely_comps, a dictionary of dely for each component.

Examples

parameter names: ['amp', 'cen', 'wid']
independent variables: ['x']

Plot the fit results and residuals using matplotlib.

The method will produce a matplotlib figure (if package available) with both results of the fit and the residuals plotted. If the fit model included weights, errorbars will also be plotted. To show the initial conditions for the fit, pass the argument

from lmfit import Model

gmodel = Model(gaussian)
print(f'parameter names: {gmodel.param_names}')
print(f'independent variables: {gmodel.independent_vars}')

• datafmt (, optional) – Matplotlib format string for data points.

• fitfmt (, optional) – Matplotlib format string for fitted curve.

• initfmt (, optional) – Matplotlib format string for initial conditions for the fit.

• xlabel (, optional) – Matplotlib format string for labeling the x-axis.

• ylabel (, optional) – Matplotlib format string for labeling the y-axis.

• yerr (, optional) – Array of uncertainties for data array.

• numpoints (, optional) – If provided, the final and initial fit curves are evaluated not only at data points, but refined to contain numpoints points in total.

• fig (, optional) – The figure to plot on. The default is None, which means use the current pyplot figure or create one if there is none.

• data_kws (, optional) – Keyword arguments passed to the plot function for data points.

• fit_kws (, optional) – Keyword arguments passed to the plot function for fitted curve.

• init_kws (, optional) – Keyword arguments passed to the plot function for the initial conditions of the fit.

• ax_res_kws (, optional) – Keyword arguments for the axes for the residuals plot.

• ax_fit_kws (, optional) – Keyword arguments for the axes for the fit plot.

• fig_kws (, optional) – Keyword arguments for a new figure, if a new one is created.

• show_init (, optional) – Whether to show the initial conditions for the fit (default is False).

• parse_complex ({'abs', 'real', 'imag', 'angle'}, optional) – How to reduce complex data for plotting. Options are one of: ‘abs’ (default), ‘real’, ‘imag’, or ‘angle’, which correspond to the NumPy functions with the same name.

• title (, optional) – Matplotlib format string for figure title.

See also

Plot the fit results using matplotlib.

Plot the fit residuals using matplotlib.

Notes

The method combines ModelResult.plot_fit and ModelResult.plot_residuals.

If yerr is specified or if the fit model included weights, then matplotlib.axes.Axes.errorbar is used to plot the data. If yerr is not specified and the fit includes weights, yerr set to

from lmfit import Model

gmodel = Model(gaussian)
print(f'parameter names: {gmodel.param_names}')
print(f'independent variables: {gmodel.independent_vars}')

If model returns complex data, yerr is treated the same way that weights are in this case.

If fig is None then matplotlib.pyplot.figure(**fig_kws) is called, otherwise fig_kws is ignored.

Plot the fit results using matplotlib, if available.

The plot will include the data points, the initial fit curve (optional, with

from lmfit import Model

gmodel = Model(gaussian)
print(f'parameter names: {gmodel.param_names}')
print(f'independent variables: {gmodel.independent_vars}')

• ax (, optional) – The axes to plot on. The default in None, which means use the current pyplot axis or create one if there is none.

• datafmt (, optional) – Matplotlib format string for data points.

• fitfmt (, optional) – Matplotlib format string for fitted curve.

• initfmt (, optional) – Matplotlib format string for initial conditions for the fit.

• xlabel (, optional) – Matplotlib format string for labeling the x-axis.

• ylabel (, optional) – Matplotlib format string for labeling the y-axis.

• yerr (, optional) – Array of uncertainties for data array.

• numpoints (, optional) – If provided, the final and initial fit curves are evaluated not only at data points, but refined to contain numpoints points in total.

• data_kws (, optional) – Keyword arguments passed to the plot function for data points.

• fit_kws (, optional) – Keyword arguments passed to the plot function for fitted curve.

• init_kws (, optional) – Keyword arguments passed to the plot function for the initial conditions of the fit.

• ax_kws (, optional) – Keyword arguments for a new axis, if a new one is created.

• show_init (, optional) – Whether to show the initial conditions for the fit (default is False).

• parse_complex ({'abs', 'real', 'imag', 'angle'}, optional) – How to reduce complex data for plotting. Options are one of: ‘abs’ (default), ‘real’, ‘imag’, or ‘angle’, which correspond to the NumPy functions with the same name.

• title (, optional) – Matplotlib format string for figure title.

See also

Plot the fit residuals using matplotlib.

Plot the fit results and residuals using matplotlib.

Notes

For details about plot format strings and keyword arguments see documentation of matplotlib.axes.Axes.plot.

If yerr is specified or if the fit model included weights, then matplotlib.axes.Axes.errorbar is used to plot the data. If yerr is not specified and the fit includes weights, yerr set to

from lmfit import Model

gmodel = Model(gaussian)
print(f'parameter names: {gmodel.param_names}')
print(f'independent variables: {gmodel.independent_vars}')

If model returns complex data, yerr is treated the same way that weights are in this case.

If ax is None then matplotlib.pyplot.gca(**ax_kws) is called.

Plot the fit residuals using matplotlib, if available.

If yerr is supplied or if the model included weights, errorbars will also be plotted.

• ax (, optional) – The axes to plot on. The default in None, which means use the current pyplot axis or create one if there is none.

• datafmt (, optional) – Matplotlib format string for data points.

• yerr (, optional) – Array of uncertainties for data array.

• data_kws (, optional) – Keyword arguments passed to the plot function for data points.

• fit_kws (, optional) – Keyword arguments passed to the plot function for fitted curve.

• ax_kws (, optional) – Keyword arguments for a new axis, if a new one is created.

• parse_complex ({'abs', 'real', 'imag', 'angle'}, optional) – How to reduce complex data for plotting. Options are one of: ‘abs’ (default), ‘real’, ‘imag’, or ‘angle’, which correspond to the NumPy functions with the same name.

• title (, optional) – Matplotlib format string for figure title.

See also

Plot the fit results using matplotlib.

Plot the fit results and residuals using matplotlib.

Notes

For details about plot format strings and keyword arguments see documentation of matplotlib.axes.Axes.plot.

If yerr is specified or if the fit model included weights, then matplotlib.axes.Axes.errorbar is used to plot the data. If yerr is not specified and the fit includes weights, yerr set to

from lmfit import Model

gmodel = Model(gaussian)
print(f'parameter names: {gmodel.param_names}')
print(f'independent variables: {gmodel.independent_vars}')

If model returns complex data, yerr is treated the same way that weights are in this case.

If ax is None then matplotlib.pyplot.gca(**ax_kws) is called.

attributes

Floating point best-fit Akaike Information Criterion statistic (see ).

numpy.ndarray result of model function, evaluated at provided independent variables and with best-fit parameters.

Dictionary with parameter names as keys, and best-fit values as values.

Floating point best-fit Bayesian Information Criterion statistic (see ).

Floating point best-fit chi-square statistic (see ).

Confidence interval data (see ) or

from scipy.optimize import curve_fit

x = linspace(-10, 10, 101)
y = gaussian(x, 2.33, 0.21, 1.51) + random.normal(0, 0.2, x.size)

init_vals = [1, 0, 1]  # for [amp, cen, wid]
best_vals, covar = curve_fit(gaussian, x, y, p0=init_vals)

numpy.ndarray (square) covariance matrix returned from fit.

numpy.ndarray of data to compare to model.

numpy.ndarray of estimated uncertainties in the

x_eval = linspace(0, 10, 201)
y_eval = gmodel.eval(params, x=x_eval)

a dictionary of estimated uncertainties in the

x_eval = linspace(0, 10, 201)
y_eval = gmodel.eval(params, x=x_eval)

Boolean for whether error bars were estimated by fit.

Integer returned code from scipy.optimize.leastsq.

numpy.ndarray result of model function, evaluated at provided independent variables and with initial parameters.

Initial parameters.

Dictionary with parameter names as keys, and initial values as values.

Optional callable function, to be called at each fit iteration. This must take take arguments of

from lmfit import Model

gmodel = Model(gaussian)
print(f'parameter names: {gmodel.param_names}')
print(f'independent variables: {gmodel.independent_vars}')

from lmfit import Model

gmodel = Model(gaussian)
print(f'parameter names: {gmodel.param_names}')
print(f'independent variables: {gmodel.independent_vars}')

from lmfit import Model

gmodel = Model(gaussian)
print(f'parameter names: {gmodel.param_names}')
print(f'independent variables: {gmodel.independent_vars}')

from lmfit import Model

gmodel = Model(gaussian)
print(f'parameter names: {gmodel.param_names}')
print(f'independent variables: {gmodel.independent_vars}')

from lmfit import Model

gmodel = Model(gaussian)
print(f'parameter names: {gmodel.param_names}')
print(f'independent variables: {gmodel.independent_vars}')

from lmfit import Model

gmodel = Model(gaussian)
print(f'parameter names: {gmodel.param_names}')
print(f'independent variables: {gmodel.independent_vars}')

Optional callable function, to be called to calculate Jacobian array.

String message returned from scipy.optimize.leastsq.

String message returned from .

String naming fitting method for .

Dict of keyword arguments actually send to underlying solver with .

Instance of used for model.

Integer number of data points.

Integer number of function evaluations used for fit.

Integer number of free parameters in fit.

Integer number of independent, freely varying variables in fit.

Parameters used in fit; will contain the best-fit values.

Floating point reduced chi-square statistic (see ).

numpy.ndarray for residual.

Floating point \(R^2\) statisic, defined for data \(y\) and best-fit model \(f\) as

\begin{eqnarray*} R^2 &=& 1 - \frac{\sum_i (y_i - f_i)^2}{\sum_i (y_i - \bar{y})^2} \end{eqnarray*}

Boolean flag for whether to automatically scale covariance matrix.

Boolean value of whether fit succeeded.

numpy.ndarray (or

from scipy.optimize import curve_fit

x = linspace(-10, 10, 101)
y = gaussian(x, 2.33, 0.21, 1.51) + random.normal(0, 0.2, x.size)

init_vals = [1, 0, 1]  # for [amp, cen, wid]
best_vals, covar = curve_fit(gaussian, x, y, p0=init_vals)

from scipy.optimize import curve_fit

x = linspace(-10, 10, 101)
y = gaussian(x, 2.33, 0.21, 1.51) + random.normal(0, 0.2, x.size)

init_vals = [1, 0, 1]  # for [amp, cen, wid]
best_vals, covar = curve_fit(gaussian, x, y, p0=init_vals)

from lmfit import Model

gmodel = Model(gaussian)
print(f'parameter names: {gmodel.param_names}')
print(f'independent variables: {gmodel.independent_vars}')

Calculating uncertainties in the model function

We return to the first example above and ask not only for the uncertainties in the fitted parameters but for the range of values that those uncertainties mean for the model function itself. We can use the method of the model result object to evaluate the uncertainty in the model with a specified level for \(\sigma\).

That is, adding:

params = gmodel.make_params()

to the example fit to the Gaussian at the beginning of this chapter will give 3-\(\sigma\) bands for the best-fit Gaussian, and produce the figure below.

New in version 1.0.4.

If the model is a composite built from multiple components, the method will evaluate the uncertainty of both the full model (often the sum of multiple components) as well as the uncertainty in each component. The uncertainty of the full model will be held in

from lmfit import Model

gmodel = Model(gaussian)
print(f'parameter names: {gmodel.param_names}')
print(f'independent variables: {gmodel.independent_vars}')

from lmfit import Model

gmodel = Model(gaussian)
print(f'parameter names: {gmodel.param_names}')
print(f'independent variables: {gmodel.independent_vars}')

An example script shows how the uncertainties in components of a composite model can be calculated and used:

params = gmodel.make_params()

params = gmodel.make_params()

Saving and Loading ModelResults

New in version 0.9.8.

As with saving models (see section ), it is sometimes desirable to save a , either for later use or to organize and compare different fit results. Lmfit provides a function that will save a to a file. There is also a companion function that can read this file and reconstruct a from it.

As discussed in section , there are challenges to saving model functions that may make it difficult to restore a saved a in a way that can be used to perform a fit. Use of the optional

from scipy.optimize import curve_fit

x = linspace(-10, 10, 101)
y = gaussian(x, 2.33, 0.21, 1.51) + random.normal(0, 0.2, x.size)

init_vals = [1, 0, 1]  # for [amp, cen, wid]
best_vals, covar = curve_fit(gaussian, x, y, p0=init_vals)

Save a ModelResult to a file.

• modelresult () – ModelResult to be saved.

• fname () – Name of file for saved ModelResult.

Load a saved ModelResult from a file.

• fname () – Name of file containing saved ModelResult.

• funcdefs (, optional) – Dictionary of custom function names and definitions.

ModelResult object loaded from file.

An example of saving a is:

params = gmodel.make_params()

To load that later, one might do:

params = gmodel.make_params()