Revision - ec17e42 - DOC: minor documentation updates for 1.0.2 - origin: https://github.com/lmfit/lmfit-py

visit type:

https://github.com/lmfit/lmfit-py

05 April 2024, 19:15:58 UTC

Revision ec17e42ecc093645f2bf71bc3c6b83c43e9f1b4f authored by reneeotten on 12 February 2021, 00:44:13 UTC, committed by reneeotten on 12 February 2021, 00:47:05 UTC

DOC: minor documentation updates for 1.0.2

- re-upload after commit 4e74a74bfbb9e1248b12474d87bc86297c606f68
- used the script publish_docs.sh that does some additional clean-up of
  old, no longer needed, files

1 parent 8ac6438

Files
Changes

Permalinks

Tip revision: ec17e42ecc093645f2bf71bc3c6b83c43e9f1b4f authored by reneeotten on 12 February 2021, 00:44:13 UTC
DOC: minor documentation updates for 1.0.2

Tip revision: ec17e42

model.html


<!DOCTYPE html>

<html>
  <head>
    <meta charset="utf-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Modeling Data and Curve Fitting &#8212; Non-Linear Least-Squares Minimization and Curve-Fitting for Python</title>
    <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
    <link rel="stylesheet" href="_static/sphinx13.css" type="text/css" />
    <link rel="stylesheet" type="text/css" href="_static/jupyter-sphinx.css" />
    <link rel="stylesheet" type="text/css" href="_static/thebelab.css" />
    <link rel="stylesheet" type="text/css" href="_static/gallery.css" />
    <link rel="stylesheet" type="text/css" href="_static/gallery-binder.css" />
    <link rel="stylesheet" type="text/css" href="_static/gallery-dataframe.css" />
    <link rel="stylesheet" type="text/css" href="_static/gallery-rendered-html.css" />
    <script id="documentation_options" data-url_root="./" src="_static/documentation_options.js"></script>
    <script src="_static/jquery.js"></script>
    <script src="_static/underscore.js"></script>
    <script src="_static/doctools.js"></script>
    <script src="_static/thebelab-helper.js"></script>
    <script src="https://cdnjs.cloudflare.com/ajax/libs/require.js/2.3.4/require.min.js"></script>
    <script src="https://unpkg.com/@jupyter-widgets/html-manager@^0.20.0/dist/embed-amd.js"></script>
    <script async="async" src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.7/latest.js?config=TeX-AMS-MML_HTMLorMML"></script>
    <link rel="index" title="Index" href="genindex.html" />
    <link rel="search" title="Search" href="search.html" />
    <link rel="next" title="Built-in Fitting Models in the models module" href="builtin_models.html" />
    <link rel="prev" title="Performing Fits and Analyzing Outputs" href="fitting.html" />
    <link href='https://fonts.googleapis.com/css?family=Open+Sans:300,400,700'
          rel='stylesheet' type='text/css' />
 
    <style type="text/css">
      table.right { float: right; margin-left: 20px; }
      table.right td { border: 1px solid #ccc; }
    </style>
    <script>
      // intelligent scrolling of the sidebar content
      $(window).scroll(function() {
        var sb = $('.sphinxsidebarwrapper');
        var win = $(window);
        var sbh = sb.height();
        var offset = $('.sphinxsidebar').position()['top'];
        var wintop = win.scrollTop();
        var winbot = wintop + win.innerHeight();
        var curtop = sb.position()['top'];
        var curbot = curtop + sbh;
        // does sidebar fit in window?
        if (sbh < win.innerHeight()) {
          // yes: easy case -- always keep at the top
          sb.css('top', $u.min([$u.max([0, wintop - offset - 10]),
                                $(document).height() - sbh - 200]));
        } else {
          // no: only scroll if top/bottom edge of sidebar is at
          // top/bottom edge of window
          if (curtop > wintop && curbot > winbot) {
            sb.css('top', $u.max([wintop - offset - 10, 0]));
          } else if (curtop < wintop && curbot < winbot) {
            sb.css('top', $u.min([winbot - sbh - offset - 20,
                                  $(document).height() - sbh - 200]));
          }
        }
      });
    </script>

  </head><body>
<div class="pageheader">
  <ul>
    <li><a href="contents.html">Contents</a></li>
    <li><a href="examples/index.html">Examples</a></li>
    <li><a href="installation.html">Installation</a></li>
    <li><a href="faq.html">FAQ</a></li>
    <li><a href="support.html">Support</a></li>
    <li><a href="https://github.com/lmfit/lmfit-py">Develop</a></li>
  </ul>
  <div>
    <a href="index.html">
      <img src="_static/lmfitheader.png" alt="LMFIT" />
    </a>
  </div>
</div>

    <div class="related" role="navigation" aria-label="related navigation">
      <h3>Navigation</h3>
      <ul>
        <li class="right" style="margin-right: 10px">
          <a href="genindex.html" title="General Index"
             accesskey="I">index</a></li>
        <li class="right" >
          <a href="builtin_models.html" title="Built-in Fitting Models in the models module"
             accesskey="N">next</a> |</li>
        <li class="right" >
          <a href="fitting.html" title="Performing Fits and Analyzing Outputs"
             accesskey="P">previous</a> |</li>
    <li>[ <a href="intro.html">intro</a> |</li>
    <li><a href="parameters.html">parameters</a> |</li>
    <li><a href="fitting.html">minimize</a> |</li>
    <li><a href="#">model</a> |</li>
    <li><a href="builtin_models.html">built-in models</a> |</li>
    <li><a href="confidence.html">confidence intervals</a> |</li>
    <li><a href="bounds.html">bounds</a> |</li>
    <li><a href="constraints.html">constraints</a> ]</li>
 
      </ul>
    </div>
      <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
        <div class="sphinxsidebarwrapper">
  <h3><a href="index.html">Table of Contents</a></h3>
  <ul>
<li><a class="reference internal" href="#">Modeling Data and Curve Fitting</a><ul>
<li><a class="reference internal" href="#motivation-and-simple-example-fit-data-to-gaussian-profile">Motivation and simple example: Fit data to Gaussian profile</a></li>
<li><a class="reference internal" href="#the-model-class">The <code class="xref py py-class docutils literal notranslate"><span class="pre">Model</span></code> class</a><ul>
<li><a class="reference internal" href="#model-class-methods"><code class="xref py py-class docutils literal notranslate"><span class="pre">Model</span></code> class Methods</a></li>
<li><a class="reference internal" href="#model-class-attributes"><code class="xref py py-class docutils literal notranslate"><span class="pre">Model</span></code> class Attributes</a></li>
<li><a class="reference internal" href="#determining-parameter-names-and-independent-variables-for-a-function">Determining parameter names and independent variables for a function</a></li>
<li><a class="reference internal" href="#explicitly-specifying-independent-vars">Explicitly specifying <code class="docutils literal notranslate"><span class="pre">independent_vars</span></code></a></li>
<li><a class="reference internal" href="#functions-with-keyword-arguments">Functions with keyword arguments</a></li>
<li><a class="reference internal" href="#defining-a-prefix-for-the-parameters">Defining a <code class="docutils literal notranslate"><span class="pre">prefix</span></code> for the Parameters</a></li>
<li><a class="reference internal" href="#initializing-model-parameters">Initializing model parameters</a><ul>
<li><a class="reference internal" href="#initializing-values-in-the-function-definition">Initializing values in the function definition</a></li>
<li><a class="reference internal" href="#initializing-values-with-model-make-params">Initializing values with <code class="xref py py-meth docutils literal notranslate"><span class="pre">Model.make_params()</span></code></a></li>
<li><a class="reference internal" href="#initializing-values-by-setting-parameter-hints">Initializing values by setting parameter hints</a></li>
<li><a class="reference internal" href="#initializing-values-when-using-a-model">Initializing values when using a model</a></li>
</ul>
</li>
<li><a class="reference internal" href="#using-parameter-hints">Using parameter hints</a></li>
<li><a class="reference internal" href="#saving-and-loading-models">Saving and Loading Models</a></li>
</ul>
</li>
<li><a class="reference internal" href="#the-modelresult-class">The <code class="xref py py-class docutils literal notranslate"><span class="pre">ModelResult</span></code> class</a><ul>
<li><a class="reference internal" href="#modelresult-methods"><code class="xref py py-class docutils literal notranslate"><span class="pre">ModelResult</span></code> methods</a></li>
<li><a class="reference internal" href="#modelresult-attributes"><code class="xref py py-class docutils literal notranslate"><span class="pre">ModelResult</span></code> attributes</a></li>
<li><a class="reference internal" href="#calculating-uncertainties-in-the-model-function">Calculating uncertainties in the model function</a></li>
<li><a class="reference internal" href="#saving-and-loading-modelresults">Saving and Loading ModelResults</a></li>
</ul>
</li>
<li><a class="reference internal" href="#composite-models-adding-or-multiplying-models">Composite Models : adding (or multiplying) Models</a></li>
</ul>
</li>
</ul>

  <h4>Previous topic</h4>
  <p class="topless"><a href="fitting.html"
                        title="previous chapter">Performing Fits and Analyzing Outputs</a></p>
  <h4>Next topic</h4>
  <p class="topless"><a href="builtin_models.html"
                        title="next chapter">Built-in Fitting Models in the <code class="xref py py-mod docutils literal notranslate"><span class="pre">models</span></code> module</a></p>
<div id="searchbox" style="display: none" role="search">
  <h3 id="searchlabel">Quick search</h3>
    <div class="searchformwrapper">
    <form class="search" action="search.html" method="get">
      <input type="text" name="q" aria-labelledby="searchlabel" />
      <input type="submit" value="Go" />
    </form>
    </div>
</div>
<script>$('#searchbox').show(0);</script>
        </div>
      </div>

    <div class="document">
      <div class="documentwrapper">
        <div class="bodywrapper">
          <div class="body" role="main">
            
  <div class="section" id="module-lmfit.model">
<span id="modeling-data-and-curve-fitting"></span><span id="model-chapter"></span><h1>Modeling Data and Curve Fitting<a class="headerlink" href="#module-lmfit.model" title="Permalink to this headline">¶</a></h1>
<p>A common use of least-squares minimization is <em>curve fitting</em>, where one
has a parametrized model function meant to explain some phenomena and wants
to adjust the numerical values for the model so that it most closely
matches some data. With <a class="reference external" href="https://docs.scipy.org/doc/scipy/reference/index.html#module-scipy" title="(in SciPy v1.6.0)"><code class="xref py py-mod docutils literal notranslate"><span class="pre">scipy</span></code></a>, such problems are typically solved
with <a class="reference external" href="https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.curve_fit.html">scipy.optimize.curve_fit</a>, which is a wrapper around
<a class="reference external" href="https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.leastsq.html">scipy.optimize.leastsq</a>. Since lmfit’s
<a class="reference internal" href="fitting.html#lmfit.minimizer.minimize" title="lmfit.minimizer.minimize"><code class="xref py py-func docutils literal notranslate"><span class="pre">minimize()</span></code></a> is also a high-level wrapper around
<a class="reference external" href="https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.leastsq.html">scipy.optimize.leastsq</a> it can be used for curve-fitting problems.
While it offers many benefits over <a class="reference external" href="https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.leastsq.html">scipy.optimize.leastsq</a>, using
<a class="reference internal" href="fitting.html#lmfit.minimizer.minimize" title="lmfit.minimizer.minimize"><code class="xref py py-func docutils literal notranslate"><span class="pre">minimize()</span></code></a> for many curve-fitting problems still
requires more effort than using <a class="reference external" href="https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.curve_fit.html">scipy.optimize.curve_fit</a>.</p>
<p>The <a class="reference internal" href="#lmfit.model.Model" title="lmfit.model.Model"><code class="xref py py-class docutils literal notranslate"><span class="pre">Model</span></code></a> class in lmfit provides a simple and flexible approach
to curve-fitting problems. Like <a class="reference external" href="https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.curve_fit.html">scipy.optimize.curve_fit</a>, a
<a class="reference internal" href="#lmfit.model.Model" title="lmfit.model.Model"><code class="xref py py-class docutils literal notranslate"><span class="pre">Model</span></code></a> uses a <em>model function</em> – a function that is meant to
calculate a model for some phenomenon – and then uses that to best match
an array of supplied data. Beyond that similarity, its interface is rather
different from <a class="reference external" href="https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.curve_fit.html">scipy.optimize.curve_fit</a>, for example in that it uses
<a class="reference internal" href="parameters.html#lmfit.parameter.Parameters" title="lmfit.parameter.Parameters"><code class="xref py py-class docutils literal notranslate"><span class="pre">Parameters</span></code></a>, but also offers several other
important advantages.</p>
<p>In addition to allowing you to turn any model function into a curve-fitting
method, lmfit also provides canonical definitions for many known line shapes
such as Gaussian or Lorentzian peaks and Exponential decays that are widely
used in many scientific domains. These are available in the <code class="xref py py-mod docutils literal notranslate"><span class="pre">models</span></code>
module that will be discussed in more detail in the next chapter
(<a class="reference internal" href="builtin_models.html#builtin-models-chapter"><span class="std std-ref">Built-in Fitting Models in the models module</span></a>). We mention it here as you may want to
consult that list before writing your own model. For now, we focus on
turning Python functions into high-level fitting models with the
<a class="reference internal" href="#lmfit.model.Model" title="lmfit.model.Model"><code class="xref py py-class docutils literal notranslate"><span class="pre">Model</span></code></a> class, and using these to fit data.</p>
<div class="section" id="motivation-and-simple-example-fit-data-to-gaussian-profile">
<h2>Motivation and simple example: Fit data to Gaussian profile<a class="headerlink" href="#motivation-and-simple-example-fit-data-to-gaussian-profile" title="Permalink to this headline">¶</a></h2>
<p>Let’s start with a simple and common example of fitting data to a Gaussian
peak. As we will see, there is a built-in <code class="xref py py-class docutils literal notranslate"><span class="pre">GaussianModel</span></code> class that
can help do this, but here we’ll build our own. We start with a simple
definition of the model function:</p>
<div class="jupyter_cell docutils container">
<div class="cell_output docutils container">
</div>
</div>
<div class="jupyter_cell jupyter_container docutils container">
<div class="cell_input code_cell docutils container">
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="kn">from</span> <span class="nn">numpy</span> <span class="kn">import</span> <span class="n">exp</span><span class="p">,</span> <span class="n">linspace</span><span class="p">,</span> <span class="n">random</span>

<span class="k">def</span> <span class="nf">gaussian</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">amp</span><span class="p">,</span> <span class="n">cen</span><span class="p">,</span> <span class="n">wid</span><span class="p">):</span>
    <span class="k">return</span> <span class="n">amp</span> <span class="o">*</span> <span class="n">exp</span><span class="p">(</span><span class="o">-</span><span class="p">(</span><span class="n">x</span><span class="o">-</span><span class="n">cen</span><span class="p">)</span><span class="o">**</span><span class="mi">2</span> <span class="o">/</span> <span class="n">wid</span><span class="p">)</span>
</pre></div>
</div>
</div>
<div class="cell_output docutils container">
</div>
</div>
<p>We want to use this function to fit to data <span class="math notranslate nohighlight">\(y(x)\)</span> represented by the
arrays <code class="docutils literal notranslate"><span class="pre">y</span></code> and <code class="docutils literal notranslate"><span class="pre">x</span></code>.  With <a class="reference external" href="https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.curve_fit.html">scipy.optimize.curve_fit</a>, this would be:</p>
<div class="jupyter_cell jupyter_container docutils container">
<div class="cell_input code_cell docutils container">
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="kn">from</span> <span class="nn">scipy.optimize</span> <span class="kn">import</span> <span class="n">curve_fit</span>

<span class="n">x</span> <span class="o">=</span> <span class="n">linspace</span><span class="p">(</span><span class="o">-</span><span class="mi">10</span><span class="p">,</span> <span class="mi">10</span><span class="p">,</span> <span class="mi">101</span><span class="p">)</span>
<span class="n">y</span> <span class="o">=</span> <span class="n">gaussian</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="mf">2.33</span><span class="p">,</span> <span class="mf">0.21</span><span class="p">,</span> <span class="mf">1.51</span><span class="p">)</span> <span class="o">+</span> <span class="n">random</span><span class="o">.</span><span class="n">normal</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="mf">0.2</span><span class="p">,</span> <span class="n">x</span><span class="o">.</span><span class="n">size</span><span class="p">)</span>

<span class="n">init_vals</span> <span class="o">=</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">]</span>  <span class="c1"># for [amp, cen, wid]</span>
<span class="n">best_vals</span><span class="p">,</span> <span class="n">covar</span> <span class="o">=</span> <span class="n">curve_fit</span><span class="p">(</span><span class="n">gaussian</span><span class="p">,</span> <span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">,</span> <span class="n">p0</span><span class="o">=</span><span class="n">init_vals</span><span class="p">)</span>
</pre></div>
</div>
</div>
<div class="cell_output docutils container">
</div>
</div>
<p>That is, we create data, make an initial guess of the model values, and run
<a class="reference external" href="https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.curve_fit.html">scipy.optimize.curve_fit</a> with the model function, data arrays, and
initial guesses. The results returned are the optimal values for the
parameters and the covariance matrix. It’s simple and useful, but it
misses the benefits of lmfit.</p>
<p>With lmfit, we create a <a class="reference internal" href="#lmfit.model.Model" title="lmfit.model.Model"><code class="xref py py-class docutils literal notranslate"><span class="pre">Model</span></code></a> that wraps the <code class="docutils literal notranslate"><span class="pre">gaussian</span></code> model
function, which automatically generates the appropriate residual function,
and determines the corresponding parameter names from the function
signature itself:</p>
<div class="jupyter_cell jupyter_container docutils container">
<div class="cell_input code_cell docutils container">
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="kn">from</span> <span class="nn">lmfit</span> <span class="kn">import</span> <span class="n">Model</span>

<span class="n">gmodel</span> <span class="o">=</span> <span class="n">Model</span><span class="p">(</span><span class="n">gaussian</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s1">&#39;parameter names: </span><span class="si">{}</span><span class="s1">&#39;</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">gmodel</span><span class="o">.</span><span class="n">param_names</span><span class="p">))</span>
<span class="nb">print</span><span class="p">(</span><span class="s1">&#39;independent variables: </span><span class="si">{}</span><span class="s1">&#39;</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">gmodel</span><span class="o">.</span><span class="n">independent_vars</span><span class="p">))</span>
</pre></div>
</div>
</div>
<div class="cell_output docutils container">
<div class="output stream highlight-none notranslate"><div class="highlight"><pre><span></span>parameter names: [&#39;amp&#39;, &#39;cen&#39;, &#39;wid&#39;]
independent variables: [&#39;x&#39;]
</pre></div>
</div>
</div>
</div>
<p>As you can see, the Model <code class="docutils literal notranslate"><span class="pre">gmodel</span></code> determined the names of the parameters
and the independent variables. By default, the first argument of the
function is taken as the independent variable, held in
<a class="reference internal" href="#lmfit.model.independent_vars" title="lmfit.model.independent_vars"><code class="xref py py-attr docutils literal notranslate"><span class="pre">independent_vars</span></code></a>, and the rest of the functions positional
arguments (and, in certain cases, keyword arguments – see below) are used
for Parameter names. Thus, for the <code class="docutils literal notranslate"><span class="pre">gaussian</span></code> function above, the
independent variable is <code class="docutils literal notranslate"><span class="pre">x</span></code>, and the parameters are named <code class="docutils literal notranslate"><span class="pre">amp</span></code>,
<code class="docutils literal notranslate"><span class="pre">cen</span></code>, and <code class="docutils literal notranslate"><span class="pre">wid</span></code>, and – all taken directly from the signature of the
model function. As we will see below, you can modify the default
assignment of independent variable / arguments and specify yourself what
the independent variable is and which function arguments should be identified
as parameter names.</p>
<p>The Parameters are <em>not</em> created when the model is created. The model knows
what the parameters should be named, but nothing about the scale and
range of your data. You will normally have to make these parameters and
assign initial values and other attributes. To help you do this, each
model has a <code class="xref py py-meth docutils literal notranslate"><span class="pre">make_params()</span></code> method that will generate parameters with
the expected names:</p>
<div class="jupyter_cell jupyter_container docutils container">
<div class="cell_input code_cell docutils container">
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">params</span> <span class="o">=</span> <span class="n">gmodel</span><span class="o">.</span><span class="n">make_params</span><span class="p">()</span>
</pre></div>
</div>
</div>
<div class="cell_output docutils container">
</div>
</div>
<p>This creates the <a class="reference internal" href="parameters.html#lmfit.parameter.Parameters" title="lmfit.parameter.Parameters"><code class="xref py py-class docutils literal notranslate"><span class="pre">Parameters</span></code></a> but does not
automatically give them initial values since it has no idea what the scale
should be. You can set initial values for parameters with keyword
arguments to <code class="xref py py-meth docutils literal notranslate"><span class="pre">make_params()</span></code>:</p>
<div class="jupyter_cell jupyter_container docutils container">
<div class="cell_input code_cell docutils container">
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">params</span> <span class="o">=</span> <span class="n">gmodel</span><span class="o">.</span><span class="n">make_params</span><span class="p">(</span><span class="n">cen</span><span class="o">=</span><span class="mf">0.3</span><span class="p">,</span> <span class="n">amp</span><span class="o">=</span><span class="mi">3</span><span class="p">,</span> <span class="n">wid</span><span class="o">=</span><span class="mf">1.25</span><span class="p">)</span>
</pre></div>
</div>
</div>
<div class="cell_output docutils container">
</div>
</div>
<p>or assign them (and other parameter properties) after the
<a class="reference internal" href="parameters.html#lmfit.parameter.Parameters" title="lmfit.parameter.Parameters"><code class="xref py py-class docutils literal notranslate"><span class="pre">Parameters</span></code></a> class has been created.</p>
<p>A <a class="reference internal" href="#lmfit.model.Model" title="lmfit.model.Model"><code class="xref py py-class docutils literal notranslate"><span class="pre">Model</span></code></a> has several methods associated with it. For example, one
can use the <code class="xref py py-meth docutils literal notranslate"><span class="pre">eval()</span></code> method to evaluate the model or the <code class="xref py py-meth docutils literal notranslate"><span class="pre">fit()</span></code>
method to fit data to this model with a <code class="xref py py-class docutils literal notranslate"><span class="pre">Parameter</span></code> object. Both of
these methods can take explicit keyword arguments for the parameter values.
For example, one could use <code class="xref py py-meth docutils literal notranslate"><span class="pre">eval()</span></code> to calculate the predicted
function:</p>
<div class="jupyter_cell jupyter_container docutils container">
<div class="cell_input code_cell docutils container">
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">x_eval</span> <span class="o">=</span> <span class="n">linspace</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">10</span><span class="p">,</span> <span class="mi">201</span><span class="p">)</span>
<span class="n">y_eval</span> <span class="o">=</span> <span class="n">gmodel</span><span class="o">.</span><span class="n">eval</span><span class="p">(</span><span class="n">params</span><span class="p">,</span> <span class="n">x</span><span class="o">=</span><span class="n">x_eval</span><span class="p">)</span>
</pre></div>
</div>
</div>
<div class="cell_output docutils container">
</div>
</div>
<p>or with:</p>
<div class="jupyter_cell jupyter_container docutils container">
<div class="cell_input code_cell docutils container">
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">y_eval</span> <span class="o">=</span> <span class="n">gmodel</span><span class="o">.</span><span class="n">eval</span><span class="p">(</span><span class="n">x</span><span class="o">=</span><span class="n">x_eval</span><span class="p">,</span> <span class="n">cen</span><span class="o">=</span><span class="mf">6.5</span><span class="p">,</span> <span class="n">amp</span><span class="o">=</span><span class="mi">100</span><span class="p">,</span> <span class="n">wid</span><span class="o">=</span><span class="mf">2.0</span><span class="p">)</span>
</pre></div>
</div>
</div>
<div class="cell_output docutils container">
</div>
</div>
<p>Admittedly, this a slightly long-winded way to calculate a Gaussian
function, given that you could have called your <code class="docutils literal notranslate"><span class="pre">gaussian</span></code> function
directly. But now that the model is set up, we can use its <code class="xref py py-meth docutils literal notranslate"><span class="pre">fit()</span></code>
method to fit this model to data, as with:</p>
<div class="jupyter_cell jupyter_container docutils container">
<div class="cell_input code_cell docutils container">
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">result</span> <span class="o">=</span> <span class="n">gmodel</span><span class="o">.</span><span class="n">fit</span><span class="p">(</span><span class="n">y</span><span class="p">,</span> <span class="n">params</span><span class="p">,</span> <span class="n">x</span><span class="o">=</span><span class="n">x</span><span class="p">)</span>
</pre></div>
</div>
</div>
<div class="cell_output docutils container">
</div>
</div>
<p>or with:</p>
<div class="jupyter_cell jupyter_container docutils container">
<div class="cell_input code_cell docutils container">
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">result</span> <span class="o">=</span> <span class="n">gmodel</span><span class="o">.</span><span class="n">fit</span><span class="p">(</span><span class="n">y</span><span class="p">,</span> <span class="n">x</span><span class="o">=</span><span class="n">x</span><span class="p">,</span> <span class="n">cen</span><span class="o">=</span><span class="mf">0.5</span><span class="p">,</span> <span class="n">amp</span><span class="o">=</span><span class="mi">10</span><span class="p">,</span> <span class="n">wid</span><span class="o">=</span><span class="mf">2.0</span><span class="p">)</span>
</pre></div>
</div>
</div>
<div class="cell_output docutils container">
</div>
</div>
<p>Putting everything together, included in the <code class="docutils literal notranslate"><span class="pre">examples</span></code> folder with the
source code, is:</p>
<div class="jupyter_cell jupyter_container docutils container">
<div class="cell_input code_cell docutils container">
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="c1"># &lt;examples/doc_model_gaussian.py&gt;</span>
<span class="kn">import</span> <span class="nn">matplotlib.pyplot</span> <span class="k">as</span> <span class="nn">plt</span>
<span class="kn">from</span> <span class="nn">numpy</span> <span class="kn">import</span> <span class="n">exp</span><span class="p">,</span> <span class="n">loadtxt</span><span class="p">,</span> <span class="n">pi</span><span class="p">,</span> <span class="n">sqrt</span>

<span class="kn">from</span> <span class="nn">lmfit</span> <span class="kn">import</span> <span class="n">Model</span>

<span class="n">data</span> <span class="o">=</span> <span class="n">loadtxt</span><span class="p">(</span><span class="s1">&#39;model1d_gauss.dat&#39;</span><span class="p">)</span>
<span class="n">x</span> <span class="o">=</span> <span class="n">data</span><span class="p">[:,</span> <span class="mi">0</span><span class="p">]</span>
<span class="n">y</span> <span class="o">=</span> <span class="n">data</span><span class="p">[:,</span> <span class="mi">1</span><span class="p">]</span>


<span class="k">def</span> <span class="nf">gaussian</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">amp</span><span class="p">,</span> <span class="n">cen</span><span class="p">,</span> <span class="n">wid</span><span class="p">):</span>
    <span class="sd">&quot;&quot;&quot;1-d gaussian: gaussian(x, amp, cen, wid)&quot;&quot;&quot;</span>
    <span class="k">return</span> <span class="p">(</span><span class="n">amp</span> <span class="o">/</span> <span class="p">(</span><span class="n">sqrt</span><span class="p">(</span><span class="mi">2</span><span class="o">*</span><span class="n">pi</span><span class="p">)</span> <span class="o">*</span> <span class="n">wid</span><span class="p">))</span> <span class="o">*</span> <span class="n">exp</span><span class="p">(</span><span class="o">-</span><span class="p">(</span><span class="n">x</span><span class="o">-</span><span class="n">cen</span><span class="p">)</span><span class="o">**</span><span class="mi">2</span> <span class="o">/</span> <span class="p">(</span><span class="mi">2</span><span class="o">*</span><span class="n">wid</span><span class="o">**</span><span class="mi">2</span><span class="p">))</span>


<span class="n">gmodel</span> <span class="o">=</span> <span class="n">Model</span><span class="p">(</span><span class="n">gaussian</span><span class="p">)</span>
<span class="n">result</span> <span class="o">=</span> <span class="n">gmodel</span><span class="o">.</span><span class="n">fit</span><span class="p">(</span><span class="n">y</span><span class="p">,</span> <span class="n">x</span><span class="o">=</span><span class="n">x</span><span class="p">,</span> <span class="n">amp</span><span class="o">=</span><span class="mi">5</span><span class="p">,</span> <span class="n">cen</span><span class="o">=</span><span class="mi">5</span><span class="p">,</span> <span class="n">wid</span><span class="o">=</span><span class="mi">1</span><span class="p">)</span>

<span class="nb">print</span><span class="p">(</span><span class="n">result</span><span class="o">.</span><span class="n">fit_report</span><span class="p">())</span>

<span class="n">plt</span><span class="o">.</span><span class="n">plot</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">,</span> <span class="s1">&#39;bo&#39;</span><span class="p">)</span>
<span class="n">plt</span><span class="o">.</span><span class="n">plot</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">result</span><span class="o">.</span><span class="n">init_fit</span><span class="p">,</span> <span class="s1">&#39;k--&#39;</span><span class="p">,</span> <span class="n">label</span><span class="o">=</span><span class="s1">&#39;initial fit&#39;</span><span class="p">)</span>
<span class="n">plt</span><span class="o">.</span><span class="n">plot</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">result</span><span class="o">.</span><span class="n">best_fit</span><span class="p">,</span> <span class="s1">&#39;r-&#39;</span><span class="p">,</span> <span class="n">label</span><span class="o">=</span><span class="s1">&#39;best fit&#39;</span><span class="p">)</span>
<span class="n">plt</span><span class="o">.</span><span class="n">legend</span><span class="p">(</span><span class="n">loc</span><span class="o">=</span><span class="s1">&#39;best&#39;</span><span class="p">)</span>
<span class="n">plt</span><span class="o">.</span><span class="n">show</span><span class="p">()</span>
<span class="c1"># &lt;end examples/doc_model_gaussian.py&gt;</span>
</pre></div>
</div>
</div>
<div class="cell_output docutils container">
</div>
</div>
<p>which is pretty compact and to the point. The returned <code class="docutils literal notranslate"><span class="pre">result</span></code> will be
a <a class="reference internal" href="#lmfit.model.ModelResult" title="lmfit.model.ModelResult"><code class="xref py py-class docutils literal notranslate"><span class="pre">ModelResult</span></code></a> object. As we will see below, this has many
components, including a <code class="xref py py-meth docutils literal notranslate"><span class="pre">fit_report()</span></code> method, which will show:</p>
<div class="jupyter_cell docutils container">
<div class="cell_output docutils container">
<div class="output stream highlight-none notranslate"><div class="highlight"><pre><span></span>[[Model]]
    Model(gaussian)
[[Fit Statistics]]
    # fitting method   = leastsq
    # function evals   = 33
    # data points      = 101
    # variables        = 3
    chi-square         = 3.40883599
    reduced chi-square = 0.03478404
    Akaike info crit   = -336.263713
    Bayesian info crit = -328.418352
[[Variables]]
    amp:  8.88021830 +/- 0.11359492 (1.28%) (init = 5)
    cen:  5.65866102 +/- 0.01030495 (0.18%) (init = 5)
    wid:  0.69765468 +/- 0.01030495 (1.48%) (init = 1)
[[Correlations]] (unreported correlations are &lt; 0.100)
    C(amp, wid) =  0.577
</pre></div>
</div>
</div>
</div>
<p>As the script shows, the result will also have <a class="reference internal" href="#lmfit.model.init_fit" title="lmfit.model.init_fit"><code class="xref py py-attr docutils literal notranslate"><span class="pre">init_fit</span></code></a> for the fit
with the initial parameter values and a <a class="reference internal" href="#lmfit.model.best_fit" title="lmfit.model.best_fit"><code class="xref py py-attr docutils literal notranslate"><span class="pre">best_fit</span></code></a> for the fit with
the best fit parameter values. These can be used to generate the following
plot:</p>
<div class="jupyter_cell docutils container">
<div class="cell_output docutils container">
<img alt="_images/model_12_0.svg" src="_images/model_12_0.svg" /></div>
</div>
<p>which shows the data in blue dots, the best fit as a solid red line, and
the initial fit as a dashed black line.</p>
<p>Note that the model fitting was really performed with:</p>
<div class="jupyter_cell jupyter_container docutils container">
<div class="cell_input code_cell docutils container">
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">gmodel</span> <span class="o">=</span> <span class="n">Model</span><span class="p">(</span><span class="n">gaussian</span><span class="p">)</span>
<span class="n">result</span> <span class="o">=</span> <span class="n">gmodel</span><span class="o">.</span><span class="n">fit</span><span class="p">(</span><span class="n">y</span><span class="p">,</span> <span class="n">params</span><span class="p">,</span> <span class="n">x</span><span class="o">=</span><span class="n">x</span><span class="p">,</span> <span class="n">amp</span><span class="o">=</span><span class="mi">5</span><span class="p">,</span> <span class="n">cen</span><span class="o">=</span><span class="mi">5</span><span class="p">,</span> <span class="n">wid</span><span class="o">=</span><span class="mi">1</span><span class="p">)</span>
</pre></div>
</div>
</div>
<div class="cell_output docutils container">
</div>
</div>
<p>These lines clearly express that we want to turn the <code class="docutils literal notranslate"><span class="pre">gaussian</span></code> function
into a fitting model, and then fit the <span class="math notranslate nohighlight">\(y(x)\)</span> data to this model,
starting with values of 5 for <code class="docutils literal notranslate"><span class="pre">amp</span></code>, 5 for <code class="docutils literal notranslate"><span class="pre">cen</span></code> and 1 for <code class="docutils literal notranslate"><span class="pre">wid</span></code>. In
addition, all the other features of lmfit are included:
<a class="reference internal" href="parameters.html#lmfit.parameter.Parameters" title="lmfit.parameter.Parameters"><code class="xref py py-class docutils literal notranslate"><span class="pre">Parameters</span></code></a> can have bounds and constraints and
the result is a rich object that can be reused to explore the model fit in
detail.</p>
</div>
<div class="section" id="the-model-class">
<h2>The <a class="reference internal" href="#lmfit.model.Model" title="lmfit.model.Model"><code class="xref py py-class docutils literal notranslate"><span class="pre">Model</span></code></a> class<a class="headerlink" href="#the-model-class" title="Permalink to this headline">¶</a></h2>
<p>The <a class="reference internal" href="#lmfit.model.Model" title="lmfit.model.Model"><code class="xref py py-class docutils literal notranslate"><span class="pre">Model</span></code></a> class provides a general way to wrap a pre-defined
function as a fitting model.</p>
<dl class="py class">
<dt id="lmfit.model.Model">
<em class="property">class </em><code class="sig-name descname">Model</code><span class="sig-paren">(</span><em class="sig-param"><span class="n">func</span></em>, <em class="sig-param"><span class="n">independent_vars</span><span class="o">=</span><span class="default_value">None</span></em>, <em class="sig-param"><span class="n">param_names</span><span class="o">=</span><span class="default_value">None</span></em>, <em class="sig-param"><span class="n">nan_policy</span><span class="o">=</span><span class="default_value">'raise'</span></em>, <em class="sig-param"><span class="n">prefix</span><span class="o">=</span><span class="default_value">''</span></em>, <em class="sig-param"><span class="n">name</span><span class="o">=</span><span class="default_value">None</span></em>, <em class="sig-param"><span class="o">**</span><span class="n">kws</span></em><span class="sig-paren">)</span><a class="headerlink" href="#lmfit.model.Model" title="Permalink to this definition">¶</a></dt>
<dd><p>Create a model from a user-supplied model function.</p>
<p>The model function will normally take an independent variable
(generally, the first argument) and a series of arguments that are
meant to be parameters for the model. It will return an array of
data to model some data as for a curve-fitting problem.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>func</strong> (<em>callable</em>) – Function to be wrapped.</p></li>
<li><p><strong>independent_vars</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#list" title="(in Python v3.9)"><code class="xref py py-obj docutils literal notranslate"><span class="pre">list</span></code></a> of <a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.9)"><code class="xref py py-obj docutils literal notranslate"><span class="pre">str</span></code></a>, optional) – Arguments to <cite>func</cite> that are independent variables (default is
None).</p></li>
<li><p><strong>param_names</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#list" title="(in Python v3.9)"><code class="xref py py-obj docutils literal notranslate"><span class="pre">list</span></code></a> of <a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.9)"><code class="xref py py-obj docutils literal notranslate"><span class="pre">str</span></code></a>, optional) – Names of arguments to <cite>func</cite> that are to be made into
parameters (default is None).</p></li>
<li><p><strong>nan_policy</strong> (<em>{'raise'</em><em>, </em><em>'propagate'</em><em>, </em><em>'omit'}</em><em>, </em><em>optional</em>) – How to handle NaN and missing values in data. See Notes below.</p></li>
<li><p><strong>prefix</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.9)"><em>str</em></a><em>, </em><em>optional</em>) – Prefix used for the model.</p></li>
<li><p><strong>name</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.9)"><em>str</em></a><em>, </em><em>optional</em>) – Name for the model. When None (default) the name is the same
as the model function (<cite>func</cite>).</p></li>
<li><p><strong>**kws</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#dict" title="(in Python v3.9)"><em>dict</em></a><em>, </em><em>optional</em>) – Additional keyword arguments to pass to model function.</p></li>
</ul>
</dd>
</dl>
<p class="rubric">Notes</p>
<p>1. Parameter names are inferred from the function arguments, and a
residual function is automatically constructed.</p>
<p>2. The model function must return an array that will be the same
size as the data being modeled.</p>
<p>3. <cite>nan_policy</cite> sets what to do when a NaN or missing value is
seen in the data. Should be one of:</p>
<blockquote>
<div><ul class="simple">
<li><p><cite>‘raise’</cite> : raise a <cite>ValueError</cite> (default)</p></li>
<li><p><cite>‘propagate’</cite> : do nothing</p></li>
<li><p><cite>‘omit’</cite> : drop missing data</p></li>
</ul>
</div></blockquote>
<p class="rubric">Examples</p>
<p>The model function will normally take an independent variable
(generally, the first argument) and a series of arguments that are
meant to be parameters for the model. Thus, a simple peak using a
Gaussian defined as:</p>
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">import</span> <span class="nn">numpy</span> <span class="k">as</span> <span class="nn">np</span>
<span class="gp">&gt;&gt;&gt; </span><span class="k">def</span> <span class="nf">gaussian</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">amp</span><span class="p">,</span> <span class="n">cen</span><span class="p">,</span> <span class="n">wid</span><span class="p">):</span>
<span class="gp">... </span>    <span class="k">return</span> <span class="n">amp</span> <span class="o">*</span> <span class="n">np</span><span class="o">.</span><span class="n">exp</span><span class="p">(</span><span class="o">-</span><span class="p">(</span><span class="n">x</span><span class="o">-</span><span class="n">cen</span><span class="p">)</span><span class="o">**</span><span class="mi">2</span> <span class="o">/</span> <span class="n">wid</span><span class="p">)</span>
</pre></div>
</div>
<p>can be turned into a Model with:</p>
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">gmodel</span> <span class="o">=</span> <span class="n">Model</span><span class="p">(</span><span class="n">gaussian</span><span class="p">)</span>
</pre></div>
</div>
<p>this will automatically discover the names of the independent
variables and parameters:</p>
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="nb">print</span><span class="p">(</span><span class="n">gmodel</span><span class="o">.</span><span class="n">param_names</span><span class="p">,</span> <span class="n">gmodel</span><span class="o">.</span><span class="n">independent_vars</span><span class="p">)</span>
<span class="go">[&#39;amp&#39;, &#39;cen&#39;, &#39;wid&#39;], [&#39;x&#39;]</span>
</pre></div>
</div>
</dd></dl>

<div class="section" id="model-class-methods">
<h3><a class="reference internal" href="#lmfit.model.Model" title="lmfit.model.Model"><code class="xref py py-class docutils literal notranslate"><span class="pre">Model</span></code></a> class Methods<a class="headerlink" href="#model-class-methods" title="Permalink to this headline">¶</a></h3>
<dl class="py method">
<dt id="lmfit.model.Model.eval">
<code class="sig-prename descclassname">Model.</code><code class="sig-name descname">eval</code><span class="sig-paren">(</span><em class="sig-param"><span class="n">params</span><span class="o">=</span><span class="default_value">None</span></em>, <em class="sig-param"><span class="o">**</span><span class="n">kwargs</span></em><span class="sig-paren">)</span><a class="headerlink" href="#lmfit.model.Model.eval" title="Permalink to this definition">¶</a></dt>
<dd><p>Evaluate the model with supplied parameters and keyword arguments.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>params</strong> (<a class="reference internal" href="parameters.html#lmfit.parameter.Parameters" title="lmfit.parameter.Parameters"><em>Parameters</em></a><em>, </em><em>optional</em>) – Parameters to use in Model.</p></li>
<li><p><strong>**kwargs</strong> (<em>optional</em>) – Additional keyword arguments to pass to model function.</p></li>
</ul>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p>Value of model given the parameters and other arguments.</p>
</dd>
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p><a class="reference external" href="https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html#numpy.ndarray" title="(in NumPy v1.20)">numpy.ndarray</a></p>
</dd>
</dl>
<p class="rubric">Notes</p>
<p>1. if <cite>params</cite> is None, the values for all parameters are expected
to be provided as keyword arguments. If <cite>params</cite> is given, and a
keyword argument for a parameter value is also given, the keyword
argument will be used.</p>
<p>2. all non-parameter arguments for the model function, <strong>including
all the independent variables</strong> will need to be passed in using
keyword arguments.</p>
</dd></dl>

<dl class="py method">
<dt id="lmfit.model.Model.fit">
<code class="sig-prename descclassname">Model.</code><code class="sig-name descname">fit</code><span class="sig-paren">(</span><em class="sig-param"><span class="n">data</span></em>, <em class="sig-param"><span class="n">params</span><span class="o">=</span><span class="default_value">None</span></em>, <em class="sig-param"><span class="n">weights</span><span class="o">=</span><span class="default_value">None</span></em>, <em class="sig-param"><span class="n">method</span><span class="o">=</span><span class="default_value">'leastsq'</span></em>, <em class="sig-param"><span class="n">iter_cb</span><span class="o">=</span><span class="default_value">None</span></em>, <em class="sig-param"><span class="n">scale_covar</span><span class="o">=</span><span class="default_value">True</span></em>, <em class="sig-param"><span class="n">verbose</span><span class="o">=</span><span class="default_value">False</span></em>, <em class="sig-param"><span class="n">fit_kws</span><span class="o">=</span><span class="default_value">None</span></em>, <em class="sig-param"><span class="n">nan_policy</span><span class="o">=</span><span class="default_value">None</span></em>, <em class="sig-param"><span class="n">calc_covar</span><span class="o">=</span><span class="default_value">True</span></em>, <em class="sig-param"><span class="n">max_nfev</span><span class="o">=</span><span class="default_value">None</span></em>, <em class="sig-param"><span class="o">**</span><span class="n">kwargs</span></em><span class="sig-paren">)</span><a class="headerlink" href="#lmfit.model.Model.fit" title="Permalink to this definition">¶</a></dt>
<dd><p>Fit the model to the data using the supplied Parameters.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>data</strong> (<em>array_like</em>) – Array of data to be fit.</p></li>
<li><p><strong>params</strong> (<a class="reference internal" href="parameters.html#lmfit.parameter.Parameters" title="lmfit.parameter.Parameters"><em>Parameters</em></a><em>, </em><em>optional</em>) – Parameters to use in fit (default is None).</p></li>
<li><p><strong>weights</strong> (<em>array_like</em><em>, </em><em>optional</em>) – Weights to use for the calculation of the fit residual
(default is None). Must have the same size as <cite>data</cite>.</p></li>
<li><p><strong>method</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.9)"><em>str</em></a><em>, </em><em>optional</em>) – Name of fitting method to use (default is <cite>‘leastsq’</cite>).</p></li>
<li><p><strong>iter_cb</strong> (<em>callable</em><em>, </em><em>optional</em>) – Callback function to call at each iteration (default is None).</p></li>
<li><p><strong>scale_covar</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.9)"><em>bool</em></a><em>, </em><em>optional</em>) – Whether to automatically scale the covariance matrix when
calculating uncertainties (default is True).</p></li>
<li><p><strong>verbose</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.9)"><em>bool</em></a><em>, </em><em>optional</em>) – Whether to print a message when a new parameter is added
because of a hint (default is True).</p></li>
<li><p><strong>fit_kws</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#dict" title="(in Python v3.9)"><em>dict</em></a><em>, </em><em>optional</em>) – Options to pass to the minimizer being used.</p></li>
<li><p><strong>nan_policy</strong> (<em>{'raise'</em><em>, </em><em>'propagate'</em><em>, </em><em>'omit'}</em><em>, </em><em>optional</em>) – What to do when encountering NaNs when fitting Model.</p></li>
<li><p><strong>calc_covar</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.9)"><em>bool</em></a><em>, </em><em>optional</em>) – Whether to calculate the covariance matrix (default is True)
for solvers other than <cite>‘leastsq’</cite> and <cite>‘least_squares’</cite>.
Requires the <code class="docutils literal notranslate"><span class="pre">numdifftools</span></code> package to be installed.</p></li>
<li><p><strong>max_nfev</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.9)"><em>int</em></a><em> or </em><a class="reference external" href="https://docs.python.org/3/library/constants.html#None" title="(in Python v3.9)"><em>None</em></a><em>, </em><em>optional</em>) – Maximum number of function evaluations (default is None). The
default value depends on the fitting method.</p></li>
<li><p><strong>**kwargs</strong> (<em>optional</em>) – Arguments to pass to the model function, possibly overriding
parameters.</p></li>
</ul>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p></p>
</dd>
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p><a class="reference internal" href="#lmfit.model.ModelResult" title="lmfit.model.ModelResult">ModelResult</a></p>
</dd>
</dl>
<p class="rubric">Notes</p>
<p>1. if <cite>params</cite> is None, the values for all parameters are expected
to be provided as keyword arguments. If <cite>params</cite> is given, and a
keyword argument for a parameter value is also given, the keyword
argument will be used.</p>
<p>2. all non-parameter arguments for the model function, <strong>including
all the independent variables</strong> will need to be passed in using
keyword arguments.</p>
<p>3. Parameters (however passed in), are copied on input, so the
original Parameter objects are unchanged, and the updated values
are in the returned <cite>ModelResult</cite>.</p>
<p class="rubric">Examples</p>
<p>Take <code class="docutils literal notranslate"><span class="pre">t</span></code> to be the independent variable and data to be the curve
we will fit. Use keyword arguments to set initial guesses:</p>
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">result</span> <span class="o">=</span> <span class="n">my_model</span><span class="o">.</span><span class="n">fit</span><span class="p">(</span><span class="n">data</span><span class="p">,</span> <span class="n">tau</span><span class="o">=</span><span class="mi">5</span><span class="p">,</span> <span class="n">N</span><span class="o">=</span><span class="mi">3</span><span class="p">,</span> <span class="n">t</span><span class="o">=</span><span class="n">t</span><span class="p">)</span>
</pre></div>
</div>
<p>Or, for more control, pass a Parameters object.</p>
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">result</span> <span class="o">=</span> <span class="n">my_model</span><span class="o">.</span><span class="n">fit</span><span class="p">(</span><span class="n">data</span><span class="p">,</span> <span class="n">params</span><span class="p">,</span> <span class="n">t</span><span class="o">=</span><span class="n">t</span><span class="p">)</span>
</pre></div>
</div>
<p>Keyword arguments override Parameters.</p>
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">result</span> <span class="o">=</span> <span class="n">my_model</span><span class="o">.</span><span class="n">fit</span><span class="p">(</span><span class="n">data</span><span class="p">,</span> <span class="n">params</span><span class="p">,</span> <span class="n">tau</span><span class="o">=</span><span class="mi">5</span><span class="p">,</span> <span class="n">t</span><span class="o">=</span><span class="n">t</span><span class="p">)</span>
</pre></div>
</div>
</dd></dl>

<dl class="py method">
<dt id="lmfit.model.Model.guess">
<code class="sig-prename descclassname">Model.</code><code class="sig-name descname">guess</code><span class="sig-paren">(</span><em class="sig-param"><span class="n">data</span></em>, <em class="sig-param"><span class="o">**</span><span class="n">kws</span></em><span class="sig-paren">)</span><a class="headerlink" href="#lmfit.model.Model.guess" title="Permalink to this definition">¶</a></dt>
<dd><p>Guess starting values for the parameters of a Model.</p>
<p>This is not implemented for all models, but is available for many
of the built-in models.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>data</strong> (<em>array_like</em>) – Array of data to use to guess parameter values.</p></li>
<li><p><strong>**kws</strong> (<em>optional</em>) – Additional keyword arguments, passed to model function.</p></li>
</ul>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p>Initial, guessed values for the parameters of a Model.</p>
</dd>
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p><a class="reference internal" href="parameters.html#lmfit.parameter.Parameters" title="lmfit.parameter.Parameters">Parameters</a></p>
</dd>
<dt class="field-even">Raises</dt>
<dd class="field-even"><p><a class="reference external" href="https://docs.python.org/3/library/exceptions.html#NotImplementedError" title="(in Python v3.9)"><strong>NotImplementedError</strong></a> – If the <cite>guess</cite> method is not implemented for a Model.</p>
</dd>
</dl>
<p class="rubric">Notes</p>
<p>Should be implemented for each model subclass to run
<cite>self.make_params()</cite>, update starting values and return a
Parameters object.</p>
</dd></dl>

<dl class="py method">
<dt id="lmfit.model.Model.make_params">
<code class="sig-prename descclassname">Model.</code><code class="sig-name descname">make_params</code><span class="sig-paren">(</span><em class="sig-param"><span class="n">verbose</span><span class="o">=</span><span class="default_value">False</span></em>, <em class="sig-param"><span class="o">**</span><span class="n">kwargs</span></em><span class="sig-paren">)</span><a class="headerlink" href="#lmfit.model.Model.make_params" title="Permalink to this definition">¶</a></dt>
<dd><p>Create a Parameters object for a Model.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>verbose</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.9)"><em>bool</em></a><em>, </em><em>optional</em>) – Whether to print out messages (default is False).</p></li>
<li><p><strong>**kwargs</strong> (<em>optional</em>) – Parameter names and initial values.</p></li>
</ul>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p><strong>params</strong> – Parameters object for the Model.</p>
</dd>
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p><a class="reference internal" href="parameters.html#lmfit.parameter.Parameters" title="lmfit.parameter.Parameters">Parameters</a></p>
</dd>
</dl>
<p class="rubric">Notes</p>
<p>1. The parameters may or may not have decent initial values for
each parameter.</p>
<p>2. This applies any default values or parameter hints that may
have been set.</p>
</dd></dl>

<dl class="py method">
<dt id="lmfit.model.Model.set_param_hint">
<code class="sig-prename descclassname">Model.</code><code class="sig-name descname">set_param_hint</code><span class="sig-paren">(</span><em class="sig-param"><span class="n">name</span></em>, <em class="sig-param"><span class="o">**</span><span class="n">kwargs</span></em><span class="sig-paren">)</span><a class="headerlink" href="#lmfit.model.Model.set_param_hint" title="Permalink to this definition">¶</a></dt>
<dd><p>Set <em>hints</em> to use when creating parameters with <cite>make_params()</cite>.</p>
<p>This is especially convenient for setting initial values. The
<cite>name</cite> can include the models <cite>prefix</cite> or not. The hint given can
also include optional bounds and constraints
<code class="docutils literal notranslate"><span class="pre">(value,</span> <span class="pre">vary,</span> <span class="pre">min,</span> <span class="pre">max,</span> <span class="pre">expr)</span></code>, which will be used by
<cite>make_params()</cite> when building default parameters.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>name</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.9)"><em>str</em></a>) – Parameter name.</p></li>
<li><p><strong>**kwargs</strong> (<em>optional</em>) – <p>Arbitrary keyword arguments, needs to be a Parameter attribute.
Can be any of the following:</p>
<ul>
<li><dl class="simple">
<dt>value<span class="classifier">float, optional</span></dt><dd><p>Numerical Parameter value.</p>
</dd>
</dl>
</li>
<li><dl class="simple">
<dt>vary<span class="classifier">bool, optional</span></dt><dd><p>Whether the Parameter is varied during a fit (default is
True).</p>
</dd>
</dl>
</li>
<li><dl class="simple">
<dt>min<span class="classifier">float, optional</span></dt><dd><p>Lower bound for value (default is <code class="docutils literal notranslate"><span class="pre">-numpy.inf</span></code>, no lower
bound).</p>
</dd>
</dl>
</li>
<li><dl class="simple">
<dt>max<span class="classifier">float, optional</span></dt><dd><p>Upper bound for value (default is <code class="docutils literal notranslate"><span class="pre">numpy.inf</span></code>, no upper
bound).</p>
</dd>
</dl>
</li>
<li><dl class="simple">
<dt>expr<span class="classifier">str, optional</span></dt><dd><p>Mathematical expression used to constrain the value during
the fit.</p>
</dd>
</dl>
</li>
</ul>
</p></li>
</ul>
</dd>
</dl>
<p class="rubric">Example</p>
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">model</span> <span class="o">=</span> <span class="n">GaussianModel</span><span class="p">()</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">model</span><span class="o">.</span><span class="n">set_param_hint</span><span class="p">(</span><span class="s1">&#39;sigma&#39;</span><span class="p">,</span> <span class="nb">min</span><span class="o">=</span><span class="mi">0</span><span class="p">)</span>
</pre></div>
</div>
<p>See <a class="reference internal" href="#model-param-hints-section"><span class="std std-ref">Using parameter hints</span></a>.</p>
</dd></dl>

<dl class="py method">
<dt id="lmfit.model.Model.print_param_hints">
<code class="sig-prename descclassname">Model.</code><code class="sig-name descname">print_param_hints</code><span class="sig-paren">(</span><em class="sig-param"><span class="n">colwidth</span><span class="o">=</span><span class="default_value">8</span></em><span class="sig-paren">)</span><a class="headerlink" href="#lmfit.model.Model.print_param_hints" title="Permalink to this definition">¶</a></dt>
<dd><p>Print a nicely aligned text-table of parameter hints.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>colwidth</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.9)"><em>int</em></a><em>, </em><em>optional</em>) – Width of each column, except for first and last columns.</p>
</dd>
</dl>
</dd></dl>

</div>
<div class="section" id="model-class-attributes">
<h3><a class="reference internal" href="#lmfit.model.Model" title="lmfit.model.Model"><code class="xref py py-class docutils literal notranslate"><span class="pre">Model</span></code></a> class Attributes<a class="headerlink" href="#model-class-attributes" title="Permalink to this headline">¶</a></h3>
<dl class="py attribute">
<dt id="lmfit.model.func">
<code class="sig-name descname">func</code><a class="headerlink" href="#lmfit.model.func" title="Permalink to this definition">¶</a></dt>
<dd><p>The model function used to calculate the model.</p>
</dd></dl>

<dl class="py attribute">
<dt id="lmfit.model.independent_vars">
<code class="sig-name descname">independent_vars</code><a class="headerlink" href="#lmfit.model.independent_vars" title="Permalink to this definition">¶</a></dt>
<dd><p>List of strings for names of the independent variables.</p>
</dd></dl>

<dl class="py attribute">
<dt id="lmfit.model.nan_policy">
<code class="sig-name descname">nan_policy</code><a class="headerlink" href="#lmfit.model.nan_policy" title="Permalink to this definition">¶</a></dt>
<dd><p>Describes what to do for NaNs that indicate missing values in the data.
The choices are:</p>
<blockquote>
<div><ul class="simple">
<li><p><code class="docutils literal notranslate"><span class="pre">'raise'</span></code>: Raise a <code class="docutils literal notranslate"><span class="pre">ValueError</span></code> (default)</p></li>
<li><p><code class="docutils literal notranslate"><span class="pre">'propagate'</span></code>: Do not check for NaNs or missing values. The fit will
try to ignore them.</p></li>
<li><p><code class="docutils literal notranslate"><span class="pre">'omit'</span></code>: Remove NaNs or missing observations in data. If pandas is
installed, <code class="xref py py-func docutils literal notranslate"><span class="pre">pandas.isnull()</span></code> is used, otherwise
<code class="xref py py-func docutils literal notranslate"><span class="pre">numpy.isnan()</span></code> is used.</p></li>
</ul>
</div></blockquote>
</dd></dl>

<dl class="py attribute">
<dt id="lmfit.model.name">
<code class="sig-name descname">name</code><a class="headerlink" href="#lmfit.model.name" title="Permalink to this definition">¶</a></dt>
<dd><p>Name of the model, used only in the string representation of the
model. By default this will be taken from the model function.</p>
</dd></dl>

<dl class="py attribute">
<dt id="lmfit.model.opts">
<code class="sig-name descname">opts</code><a class="headerlink" href="#lmfit.model.opts" title="Permalink to this definition">¶</a></dt>
<dd><p>Extra keyword arguments to pass to model function. Normally this will
be determined internally and should not be changed.</p>
</dd></dl>

<dl class="py attribute">
<dt id="lmfit.model.param_hints">
<code class="sig-name descname">param_hints</code><a class="headerlink" href="#lmfit.model.param_hints" title="Permalink to this definition">¶</a></dt>
<dd><p>Dictionary of parameter hints. See <a class="reference internal" href="#model-param-hints-section"><span class="std std-ref">Using parameter hints</span></a>.</p>
</dd></dl>

<dl class="py attribute">
<dt id="lmfit.model.param_names">
<code class="sig-name descname">param_names</code><a class="headerlink" href="#lmfit.model.param_names" title="Permalink to this definition">¶</a></dt>
<dd><p>List of strings of parameter names.</p>
</dd></dl>

<dl class="py attribute">
<dt id="lmfit.model.prefix">
<code class="sig-name descname">prefix</code><a class="headerlink" href="#lmfit.model.prefix" title="Permalink to this definition">¶</a></dt>
<dd><p>Prefix used for name-mangling of parameter names. The default is <code class="docutils literal notranslate"><span class="pre">''</span></code>.
If a particular <a class="reference internal" href="#lmfit.model.Model" title="lmfit.model.Model"><code class="xref py py-class docutils literal notranslate"><span class="pre">Model</span></code></a> has arguments <code class="docutils literal notranslate"><span class="pre">amplitude</span></code>,
<code class="docutils literal notranslate"><span class="pre">center</span></code>, and <code class="docutils literal notranslate"><span class="pre">sigma</span></code>, these would become the parameter names.
Using a prefix of <code class="docutils literal notranslate"><span class="pre">'g1_'</span></code> would convert these parameter names to
<code class="docutils literal notranslate"><span class="pre">g1_amplitude</span></code>, <code class="docutils literal notranslate"><span class="pre">g1_center</span></code>, and <code class="docutils literal notranslate"><span class="pre">g1_sigma</span></code>. This can be
essential to avoid name collision in composite models.</p>
</dd></dl>

</div>
<div class="section" id="determining-parameter-names-and-independent-variables-for-a-function">
<h3>Determining parameter names and independent variables for a function<a class="headerlink" href="#determining-parameter-names-and-independent-variables-for-a-function" title="Permalink to this headline">¶</a></h3>
<p>The <a class="reference internal" href="#lmfit.model.Model" title="lmfit.model.Model"><code class="xref py py-class docutils literal notranslate"><span class="pre">Model</span></code></a> created from the supplied function <code class="docutils literal notranslate"><span class="pre">func</span></code> will create
a <a class="reference internal" href="parameters.html#lmfit.parameter.Parameters" title="lmfit.parameter.Parameters"><code class="xref py py-class docutils literal notranslate"><span class="pre">Parameters</span></code></a> object, and names are inferred from the function
arguments, and a residual function is automatically constructed.</p>
<p>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.</p>
<p>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.</p>
</div>
<div class="section" id="explicitly-specifying-independent-vars">
<h3>Explicitly specifying <code class="docutils literal notranslate"><span class="pre">independent_vars</span></code><a class="headerlink" href="#explicitly-specifying-independent-vars" title="Permalink to this headline">¶</a></h3>
<p>As we saw for the Gaussian example above, creating a <a class="reference internal" href="#lmfit.model.Model" title="lmfit.model.Model"><code class="xref py py-class docutils literal notranslate"><span class="pre">Model</span></code></a> from a
function is fairly easy. Let’s try another one:</p>
<div class="jupyter_cell jupyter_container docutils container">
<div class="cell_input code_cell docutils container">
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="kn">import</span> <span class="nn">numpy</span> <span class="k">as</span> <span class="nn">np</span>
<span class="kn">from</span> <span class="nn">lmfit</span> <span class="kn">import</span> <span class="n">Model</span>


<span class="k">def</span> <span class="nf">decay</span><span class="p">(</span><span class="n">t</span><span class="p">,</span> <span class="n">tau</span><span class="p">,</span> <span class="n">N</span><span class="p">):</span>
   <span class="k">return</span> <span class="n">N</span><span class="o">*</span><span class="n">np</span><span class="o">.</span><span class="n">exp</span><span class="p">(</span><span class="o">-</span><span class="n">t</span><span class="o">/</span><span class="n">tau</span><span class="p">)</span>


<span class="n">decay_model</span> <span class="o">=</span> <span class="n">Model</span><span class="p">(</span><span class="n">decay</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s1">&#39;independent variables: </span><span class="si">{}</span><span class="s1">&#39;</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">decay_model</span><span class="o">.</span><span class="n">independent_vars</span><span class="p">))</span>

<span class="n">params</span> <span class="o">=</span> <span class="n">decay_model</span><span class="o">.</span><span class="n">make_params</span><span class="p">()</span>
<span class="nb">print</span><span class="p">(</span><span class="s1">&#39;</span><span class="se">\n</span><span class="s1">Parameters:&#39;</span><span class="p">)</span>
<span class="k">for</span> <span class="n">pname</span><span class="p">,</span> <span class="n">par</span> <span class="ow">in</span> <span class="n">params</span><span class="o">.</span><span class="n">items</span><span class="p">():</span>
    <span class="nb">print</span><span class="p">(</span><span class="n">pname</span><span class="p">,</span> <span class="n">par</span><span class="p">)</span>
</pre></div>
</div>
</div>
<div class="cell_output docutils container">
<div class="output stream highlight-none notranslate"><div class="highlight"><pre><span></span>independent variables: [&#39;t&#39;]

Parameters:
tau &lt;Parameter &#39;tau&#39;, value=-inf, bounds=[-inf:inf]&gt;
N &lt;Parameter &#39;N&#39;, value=-inf, bounds=[-inf:inf]&gt;
</pre></div>
</div>
</div>
</div>
<p>Here, <code class="docutils literal notranslate"><span class="pre">t</span></code> is assumed to be the independent variable because it is the
first argument to the function. The other function arguments are used to
create parameters for the model.</p>
<p>If you want <code class="docutils literal notranslate"><span class="pre">tau</span></code> to be the independent variable in the above example,
you can say so:</p>
<div class="jupyter_cell jupyter_container docutils container">
<div class="cell_input code_cell docutils container">
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">decay_model</span> <span class="o">=</span> <span class="n">Model</span><span class="p">(</span><span class="n">decay</span><span class="p">,</span> <span class="n">independent_vars</span><span class="o">=</span><span class="p">[</span><span class="s1">&#39;tau&#39;</span><span class="p">])</span>
<span class="nb">print</span><span class="p">(</span><span class="s1">&#39;independent variables: </span><span class="si">{}</span><span class="s1">&#39;</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">decay_model</span><span class="o">.</span><span class="n">independent_vars</span><span class="p">))</span>

<span class="n">params</span> <span class="o">=</span> <span class="n">decay_model</span><span class="o">.</span><span class="n">make_params</span><span class="p">()</span>
<span class="nb">print</span><span class="p">(</span><span class="s1">&#39;</span><span class="se">\n</span><span class="s1">Parameters:&#39;</span><span class="p">)</span>
<span class="k">for</span> <span class="n">pname</span><span class="p">,</span> <span class="n">par</span> <span class="ow">in</span> <span class="n">params</span><span class="o">.</span><span class="n">items</span><span class="p">():</span>
    <span class="nb">print</span><span class="p">(</span><span class="n">pname</span><span class="p">,</span> <span class="n">par</span><span class="p">)</span>
</pre></div>
</div>
</div>
<div class="cell_output docutils container">
<div class="output stream highlight-none notranslate"><div class="highlight"><pre><span></span>independent variables: [&#39;tau&#39;]

Parameters:
t &lt;Parameter &#39;t&#39;, value=-inf, bounds=[-inf:inf]&gt;
N &lt;Parameter &#39;N&#39;, value=-inf, bounds=[-inf:inf]&gt;
</pre></div>
</div>
</div>
</div>
<p>You can also supply multiple values for multi-dimensional functions with
multiple independent variables. In fact, the meaning of <em>independent
variable</em> here is simple, and based on how it treats arguments of the
function you are modeling:</p>
<dl class="simple">
<dt>independent variable</dt><dd><p>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 <a class="reference internal" href="#lmfit.model.Model.fit" title="lmfit.model.Model.fit"><code class="xref py py-meth docutils literal notranslate"><span class="pre">Model.fit()</span></code></a> or evaluation
with <a class="reference internal" href="#lmfit.model.Model.eval" title="lmfit.model.Model.eval"><code class="xref py py-meth docutils literal notranslate"><span class="pre">Model.eval()</span></code></a>.</p>
</dd>
</dl>
<p>Note that independent variables are not required to be arrays, or even
floating point numbers.</p>
</div>
<div class="section" id="functions-with-keyword-arguments">
<h3>Functions with keyword arguments<a class="headerlink" href="#functions-with-keyword-arguments" title="Permalink to this headline">¶</a></h3>
<p>If the model function had keyword parameters, these would be turned into
Parameters if the supplied default value was a valid number (but not
<code class="docutils literal notranslate"><span class="pre">None</span></code>, <code class="docutils literal notranslate"><span class="pre">True</span></code>, or <code class="docutils literal notranslate"><span class="pre">False</span></code>).</p>
<div class="jupyter_cell jupyter_container docutils container">
<div class="cell_input code_cell docutils container">
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">decay2</span><span class="p">(</span><span class="n">t</span><span class="p">,</span> <span class="n">tau</span><span class="p">,</span> <span class="n">N</span><span class="o">=</span><span class="mi">10</span><span class="p">,</span> <span class="n">check_positive</span><span class="o">=</span><span class="kc">False</span><span class="p">):</span>
    <span class="k">if</span> <span class="n">check_small</span><span class="p">:</span>
        <span class="n">arg</span> <span class="o">=</span> <span class="nb">abs</span><span class="p">(</span><span class="n">t</span><span class="p">)</span><span class="o">/</span><span class="nb">max</span><span class="p">(</span><span class="mf">1.e-9</span><span class="p">,</span> <span class="nb">abs</span><span class="p">(</span><span class="n">tau</span><span class="p">))</span>
    <span class="k">else</span><span class="p">:</span>
        <span class="n">arg</span> <span class="o">=</span> <span class="n">t</span><span class="o">/</span><span class="n">tau</span>
    <span class="k">return</span> <span class="n">N</span><span class="o">*</span><span class="n">np</span><span class="o">.</span><span class="n">exp</span><span class="p">(</span><span class="n">arg</span><span class="p">)</span>

<span class="n">mod</span> <span class="o">=</span> <span class="n">Model</span><span class="p">(</span><span class="n">decay2</span><span class="p">)</span>
<span class="n">params</span> <span class="o">=</span> <span class="n">mod</span><span class="o">.</span><span class="n">make_params</span><span class="p">()</span>
<span class="nb">print</span><span class="p">(</span><span class="s1">&#39;Parameters:&#39;</span><span class="p">)</span>
<span class="k">for</span> <span class="n">pname</span><span class="p">,</span> <span class="n">par</span> <span class="ow">in</span> <span class="n">params</span><span class="o">.</span><span class="n">items</span><span class="p">():</span>
    <span class="nb">print</span><span class="p">(</span><span class="n">pname</span><span class="p">,</span> <span class="n">par</span><span class="p">)</span>
</pre></div>
</div>
</div>
<div class="cell_output docutils container">
<div class="output stream highlight-none notranslate"><div class="highlight"><pre><span></span>Parameters:
tau &lt;Parameter &#39;tau&#39;, value=-inf, bounds=[-inf:inf]&gt;
N &lt;Parameter &#39;N&#39;, value=10, bounds=[-inf:inf]&gt;
</pre></div>
</div>
</div>
</div>
<p>Here, even though <code class="docutils literal notranslate"><span class="pre">N</span></code> is a keyword argument to the function, it is turned
into a parameter, with the default numerical value as its initial value.
By default, it is permitted to be varied in the fit – the 10 is taken as
an initial value, not a fixed value. On the other hand, the
<code class="docutils literal notranslate"><span class="pre">check_positive</span></code> keyword argument, was not converted to a parameter
because it has a boolean default value. In some sense,
<code class="docutils literal notranslate"><span class="pre">check_positive</span></code> becomes like an independent variable to the model.
However, because it has a default value it is not required to be given for
each model evaluation or fit, as independent variables are.</p>
</div>
<div class="section" id="defining-a-prefix-for-the-parameters">
<h3>Defining a <code class="docutils literal notranslate"><span class="pre">prefix</span></code> for the Parameters<a class="headerlink" href="#defining-a-prefix-for-the-parameters" title="Permalink to this headline">¶</a></h3>
<p>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
<a class="reference internal" href="#composite-models-section"><span class="std std-ref">Composite Models : adding (or multiplying) Models</span></a> or examples in the next chapter) would have
the same name. To avoid this, we can add a <code class="docutils literal notranslate"><span class="pre">prefix</span></code> to the
<a class="reference internal" href="#lmfit.model.Model" title="lmfit.model.Model"><code class="xref py py-class docutils literal notranslate"><span class="pre">Model</span></code></a> which will automatically do this mapping for us.</p>
<div class="jupyter_cell jupyter_container docutils container">
<div class="cell_input code_cell docutils container">
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">myfunc</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">amplitude</span><span class="o">=</span><span class="mi">1</span><span class="p">,</span> <span class="n">center</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">sigma</span><span class="o">=</span><span class="mi">1</span><span class="p">):</span>
    <span class="c1"># function definition, for now just ``pass``</span>
    <span class="k">pass</span>


<span class="n">mod</span> <span class="o">=</span> <span class="n">Model</span><span class="p">(</span><span class="n">myfunc</span><span class="p">,</span> <span class="n">prefix</span><span class="o">=</span><span class="s1">&#39;f1_&#39;</span><span class="p">)</span>
<span class="n">params</span> <span class="o">=</span> <span class="n">mod</span><span class="o">.</span><span class="n">make_params</span><span class="p">()</span>
<span class="nb">print</span><span class="p">(</span><span class="s1">&#39;Parameters:&#39;</span><span class="p">)</span>
<span class="k">for</span> <span class="n">pname</span><span class="p">,</span> <span class="n">par</span> <span class="ow">in</span> <span class="n">params</span><span class="o">.</span><span class="n">items</span><span class="p">():</span>
    <span class="nb">print</span><span class="p">(</span><span class="n">pname</span><span class="p">,</span> <span class="n">par</span><span class="p">)</span>
</pre></div>
</div>
</div>
<div class="cell_output docutils container">
<div class="output stream highlight-none notranslate"><div class="highlight"><pre><span></span>Parameters:
f1_amplitude &lt;Parameter &#39;f1_amplitude&#39;, value=1, bounds=[-inf:inf]&gt;
f1_center &lt;Parameter &#39;f1_center&#39;, value=0, bounds=[-inf:inf]&gt;
f1_sigma &lt;Parameter &#39;f1_sigma&#39;, value=1, bounds=[-inf:inf]&gt;
</pre></div>
</div>
</div>
</div>
<p>You would refer to these parameters as <code class="docutils literal notranslate"><span class="pre">f1_amplitude</span></code> and so forth, and
the model will know to map these to the <code class="docutils literal notranslate"><span class="pre">amplitude</span></code> argument of <code class="docutils literal notranslate"><span class="pre">myfunc</span></code>.</p>
</div>
<div class="section" id="initializing-model-parameters">
<h3>Initializing model parameters<a class="headerlink" href="#initializing-model-parameters" title="Permalink to this headline">¶</a></h3>
<p>As mentioned above, the parameters created by <a class="reference internal" href="#lmfit.model.Model.make_params" title="lmfit.model.Model.make_params"><code class="xref py py-meth docutils literal notranslate"><span class="pre">Model.make_params()</span></code></a> are
generally created with invalid initial values of <code class="docutils literal notranslate"><span class="pre">None</span></code>. These values
<strong>must</strong> be initialized in order for the model to be evaluated or used in a
fit. There are four different ways to do this initialization that can be
used in any combination:</p>
<blockquote>
<div><ol class="arabic simple">
<li><p>You can supply initial values in the definition of the model function.</p></li>
<li><p>You can initialize the parameters when creating parameters with <a class="reference internal" href="#lmfit.model.Model.make_params" title="lmfit.model.Model.make_params"><code class="xref py py-meth docutils literal notranslate"><span class="pre">Model.make_params()</span></code></a>.</p></li>
<li><p>You can give parameter hints with <a class="reference internal" href="#lmfit.model.Model.set_param_hint" title="lmfit.model.Model.set_param_hint"><code class="xref py py-meth docutils literal notranslate"><span class="pre">Model.set_param_hint()</span></code></a>.</p></li>
<li><p>You can supply initial values for the parameters when you use the
<a class="reference internal" href="#lmfit.model.Model.eval" title="lmfit.model.Model.eval"><code class="xref py py-meth docutils literal notranslate"><span class="pre">Model.eval()</span></code></a> or <a class="reference internal" href="#lmfit.model.Model.fit" title="lmfit.model.Model.fit"><code class="xref py py-meth docutils literal notranslate"><span class="pre">Model.fit()</span></code></a> methods.</p></li>
</ol>
</div></blockquote>
<p>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.</p>
<div class="section" id="initializing-values-in-the-function-definition">
<h4>Initializing values in the function definition<a class="headerlink" href="#initializing-values-in-the-function-definition" title="Permalink to this headline">¶</a></h4>
<p>To supply initial values for parameters in the definition of the model
function, you can simply supply a default value:</p>
<div class="jupyter_cell jupyter_container docutils container">
<div class="cell_input code_cell docutils container">
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">myfunc</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">a</span><span class="o">=</span><span class="mi">1</span><span class="p">,</span> <span class="n">b</span><span class="o">=</span><span class="mi">0</span><span class="p">):</span>
    <span class="k">return</span> <span class="n">a</span><span class="o">*</span><span class="n">x</span> <span class="o">+</span> <span class="mi">10</span><span class="o">*</span><span class="n">a</span> <span class="o">-</span> <span class="n">b</span>
</pre></div>
</div>
</div>
<div class="cell_output docutils container">
</div>
</div>
<p>instead of using:</p>
<div class="jupyter_cell jupyter_container docutils container">
<div class="cell_input code_cell docutils container">
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">myfunc</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">a</span><span class="p">,</span> <span class="n">b</span><span class="p">):</span>
    <span class="k">return</span> <span class="n">a</span><span class="o">*</span><span class="n">x</span> <span class="o">+</span> <span class="mi">10</span><span class="o">*</span><span class="n">a</span> <span class="o">-</span> <span class="n">b</span>
</pre></div>
</div>
</div>
<div class="cell_output docutils container">
</div>
</div>
<p>This has the advantage of working at the function level – all parameters
with keywords can be treated as options. It also means that some default
initial value will always be available for the parameter.</p>
</div>
<div class="section" id="initializing-values-with-model-make-params">
<h4>Initializing values with <a class="reference internal" href="#lmfit.model.Model.make_params" title="lmfit.model.Model.make_params"><code class="xref py py-meth docutils literal notranslate"><span class="pre">Model.make_params()</span></code></a><a class="headerlink" href="#initializing-values-with-model-make-params" title="Permalink to this headline">¶</a></h4>
<p>When creating parameters with <a class="reference internal" href="#lmfit.model.Model.make_params" title="lmfit.model.Model.make_params"><code class="xref py py-meth docutils literal notranslate"><span class="pre">Model.make_params()</span></code></a> you can specify initial
values. To do this, use keyword arguments for the parameter names and
initial values:</p>
<div class="jupyter_cell jupyter_container docutils container">
<div class="cell_input code_cell docutils container">
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">mod</span> <span class="o">=</span> <span class="n">Model</span><span class="p">(</span><span class="n">myfunc</span><span class="p">)</span>
<span class="n">pars</span> <span class="o">=</span> <span class="n">mod</span><span class="o">.</span><span class="n">make_params</span><span class="p">(</span><span class="n">a</span><span class="o">=</span><span class="mi">3</span><span class="p">,</span> <span class="n">b</span><span class="o">=</span><span class="mf">0.5</span><span class="p">)</span>
</pre></div>
</div>
</div>
<div class="cell_output docutils container">
</div>
</div>
</div>
<div class="section" id="initializing-values-by-setting-parameter-hints">
<h4>Initializing values by setting parameter hints<a class="headerlink" href="#initializing-values-by-setting-parameter-hints" title="Permalink to this headline">¶</a></h4>
<p>After a model has been created, but prior to creating parameters with
<a class="reference internal" href="#lmfit.model.Model.make_params" title="lmfit.model.Model.make_params"><code class="xref py py-meth docutils literal notranslate"><span class="pre">Model.make_params()</span></code></a>, you can set parameter hints. These 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 <a class="reference internal" href="#lmfit.model.Model.set_param_hint" title="lmfit.model.Model.set_param_hint"><code class="xref py py-meth docutils literal notranslate"><span class="pre">Model.set_param_hint()</span></code></a>,
as with:</p>
<div class="jupyter_cell jupyter_container docutils container">
<div class="cell_input code_cell docutils container">
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">mod</span> <span class="o">=</span> <span class="n">Model</span><span class="p">(</span><span class="n">myfunc</span><span class="p">)</span>
<span class="n">mod</span><span class="o">.</span><span class="n">set_param_hint</span><span class="p">(</span><span class="s1">&#39;a&#39;</span><span class="p">,</span> <span class="n">value</span><span class="o">=</span><span class="mf">1.0</span><span class="p">)</span>
<span class="n">mod</span><span class="o">.</span><span class="n">set_param_hint</span><span class="p">(</span><span class="s1">&#39;b&#39;</span><span class="p">,</span> <span class="n">value</span><span class="o">=</span><span class="mf">0.3</span><span class="p">,</span> <span class="nb">min</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="nb">max</span><span class="o">=</span><span class="mf">1.0</span><span class="p">)</span>
<span class="n">pars</span> <span class="o">=</span> <span class="n">mod</span><span class="o">.</span><span class="n">make_params</span><span class="p">()</span>
</pre></div>
</div>
</div>
<div class="cell_output docutils container">
</div>
</div>
<p>Parameter hints are discussed in more detail in section
<a class="reference internal" href="#model-param-hints-section"><span class="std std-ref">Using parameter hints</span></a>.</p>
</div>
<div class="section" id="initializing-values-when-using-a-model">
<h4>Initializing values when using a model<a class="headerlink" href="#initializing-values-when-using-a-model" title="Permalink to this headline">¶</a></h4>
<p>Finally, you can explicitly supply initial values when using a model. That
is, as with <a class="reference internal" href="#lmfit.model.Model.make_params" title="lmfit.model.Model.make_params"><code class="xref py py-meth docutils literal notranslate"><span class="pre">Model.make_params()</span></code></a>, you can include values as keyword
arguments to either the <a class="reference internal" href="#lmfit.model.Model.eval" title="lmfit.model.Model.eval"><code class="xref py py-meth docutils literal notranslate"><span class="pre">Model.eval()</span></code></a> or <a class="reference internal" href="#lmfit.model.Model.fit" title="lmfit.model.Model.fit"><code class="xref py py-meth docutils literal notranslate"><span class="pre">Model.fit()</span></code></a> methods:</p>
<div class="jupyter_cell jupyter_container docutils container">
<div class="cell_input code_cell docutils container">
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">x</span> <span class="o">=</span> <span class="n">linspace</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">10</span><span class="p">,</span> <span class="mi">100</span><span class="p">)</span>
<span class="n">y_eval</span> <span class="o">=</span> <span class="n">mod</span><span class="o">.</span><span class="n">eval</span><span class="p">(</span><span class="n">x</span><span class="o">=</span><span class="n">x</span><span class="p">,</span> <span class="n">a</span><span class="o">=</span><span class="mf">7.0</span><span class="p">,</span> <span class="n">b</span><span class="o">=-</span><span class="mf">2.0</span><span class="p">)</span>
<span class="n">y_sim</span> <span class="o">=</span> <span class="n">y_eval</span> <span class="o">+</span> <span class="n">random</span><span class="o">.</span><span class="n">normal</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="mf">0.2</span><span class="p">,</span> <span class="n">x</span><span class="o">.</span><span class="n">size</span><span class="p">)</span>
<span class="n">out</span> <span class="o">=</span> <span class="n">mod</span><span class="o">.</span><span class="n">fit</span><span class="p">(</span><span class="n">y_sim</span><span class="p">,</span> <span class="n">pars</span><span class="p">,</span> <span class="n">x</span><span class="o">=</span><span class="n">x</span><span class="p">,</span> <span class="n">a</span><span class="o">=</span><span class="mf">3.0</span><span class="p">,</span> <span class="n">b</span><span class="o">=</span><span class="mf">0.0</span><span class="p">)</span>
</pre></div>
</div>
</div>
<div class="cell_output docutils container">
</div>
</div>
<p>These approaches to initialization provide many opportunities for setting
initial values for parameters. The methods can be combined, so that you
can set parameter hints but then change the initial value explicitly with
<a class="reference internal" href="#lmfit.model.Model.fit" title="lmfit.model.Model.fit"><code class="xref py py-meth docutils literal notranslate"><span class="pre">Model.fit()</span></code></a>.</p>
</div>
</div>
<div class="section" id="using-parameter-hints">
<span id="model-param-hints-section"></span><h3>Using parameter hints<a class="headerlink" href="#using-parameter-hints" title="Permalink to this headline">¶</a></h3>
<p>After a model has been created, you can give it hints for how to create
parameters with <a class="reference internal" href="#lmfit.model.Model.make_params" title="lmfit.model.Model.make_params"><code class="xref py py-meth docutils literal notranslate"><span class="pre">Model.make_params()</span></code></a>.  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 <a class="reference internal" href="#lmfit.model.Model.set_param_hint" title="lmfit.model.Model.set_param_hint"><code class="xref py py-meth docutils literal notranslate"><span class="pre">Model.set_param_hint()</span></code></a>,
as with:</p>
<div class="jupyter_cell jupyter_container docutils container">
<div class="cell_input code_cell docutils container">
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">mod</span> <span class="o">=</span> <span class="n">Model</span><span class="p">(</span><span class="n">myfunc</span><span class="p">)</span>
<span class="n">mod</span><span class="o">.</span><span class="n">set_param_hint</span><span class="p">(</span><span class="s1">&#39;a&#39;</span><span class="p">,</span> <span class="n">value</span><span class="o">=</span><span class="mf">1.0</span><span class="p">)</span>
<span class="n">mod</span><span class="o">.</span><span class="n">set_param_hint</span><span class="p">(</span><span class="s1">&#39;b&#39;</span><span class="p">,</span> <span class="n">value</span><span class="o">=</span><span class="mf">0.3</span><span class="p">,</span> <span class="nb">min</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="nb">max</span><span class="o">=</span><span class="mf">1.0</span><span class="p">)</span>
</pre></div>
</div>
</div>
<div class="cell_output docutils container">
</div>
</div>
<p>Parameter hints are stored in a model’s <a class="reference internal" href="#lmfit.model.param_hints" title="lmfit.model.param_hints"><code class="xref py py-attr docutils literal notranslate"><span class="pre">param_hints</span></code></a> attribute,
which is simply a nested dictionary:</p>
<div class="jupyter_cell jupyter_container docutils container">
<div class="cell_input code_cell docutils container">
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="nb">print</span><span class="p">(</span><span class="s1">&#39;Parameter hints:&#39;</span><span class="p">)</span>
<span class="k">for</span> <span class="n">pname</span><span class="p">,</span> <span class="n">par</span> <span class="ow">in</span> <span class="n">mod</span><span class="o">.</span><span class="n">param_hints</span><span class="o">.</span><span class="n">items</span><span class="p">():</span>
    <span class="nb">print</span><span class="p">(</span><span class="n">pname</span><span class="p">,</span> <span class="n">par</span><span class="p">)</span>
</pre></div>
</div>
</div>
<div class="cell_output docutils container">
<div class="output stream highlight-none notranslate"><div class="highlight"><pre><span></span>Parameter hints:
a OrderedDict([(&#39;value&#39;, 1.0)])
b OrderedDict([(&#39;value&#39;, 0.3), (&#39;min&#39;, 0), (&#39;max&#39;, 1.0)])
</pre></div>
</div>
</div>
</div>
<p>You can change this dictionary directly, or with the <a class="reference internal" href="#lmfit.model.Model.set_param_hint" title="lmfit.model.Model.set_param_hint"><code class="xref py py-meth docutils literal notranslate"><span class="pre">Model.set_param_hint()</span></code></a>
method. Either way, these parameter hints are used by <a class="reference internal" href="#lmfit.model.Model.make_params" title="lmfit.model.Model.make_params"><code class="xref py py-meth docutils literal notranslate"><span class="pre">Model.make_params()</span></code></a>
when making parameters.</p>
<p>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:</p>
<div class="jupyter_cell jupyter_container docutils container">
<div class="cell_input code_cell docutils container">
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">mod</span> <span class="o">=</span> <span class="n">Model</span><span class="p">(</span><span class="n">gaussian</span><span class="p">)</span>
<span class="n">mod</span><span class="o">.</span><span class="n">set_param_hint</span><span class="p">(</span><span class="s1">&#39;fwhm&#39;</span><span class="p">,</span> <span class="n">expr</span><span class="o">=</span><span class="s1">&#39;2.3548*sigma&#39;</span><span class="p">)</span>
</pre></div>
</div>
</div>
<div class="cell_output docutils container">
</div>
</div>
</div>
<div class="section" id="saving-and-loading-models">
<span id="model-saveload-sec"></span><h3>Saving and Loading Models<a class="headerlink" href="#saving-and-loading-models" title="Permalink to this headline">¶</a></h3>
<div class="versionadded">
<p><span class="versionmodified added">New in version 0.9.8.</span></p>
</div>
<p>It is sometimes desirable to save a <a class="reference internal" href="#lmfit.model.Model" title="lmfit.model.Model"><code class="xref py py-class docutils literal notranslate"><span class="pre">Model</span></code></a> for later use outside of
the code used to define the model. Lmfit provides a <a class="reference internal" href="#lmfit.model.save_model" title="lmfit.model.save_model"><code class="xref py py-func docutils literal notranslate"><span class="pre">save_model()</span></code></a>
function that will save a <a class="reference internal" href="#lmfit.model.Model" title="lmfit.model.Model"><code class="xref py py-class docutils literal notranslate"><span class="pre">Model</span></code></a> to a file. There is also a
companion <a class="reference internal" href="#lmfit.model.load_model" title="lmfit.model.load_model"><code class="xref py py-func docutils literal notranslate"><span class="pre">load_model()</span></code></a> function that can read this file and
reconstruct a <a class="reference internal" href="#lmfit.model.Model" title="lmfit.model.Model"><code class="xref py py-class docutils literal notranslate"><span class="pre">Model</span></code></a> from it.</p>
<p>Saving a model turns out to be somewhat challenging. The main issue is that
Python is not normally able to <em>serialize</em> 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 <code class="docutils literal notranslate"><span class="pre">dill</span></code> package can
sometimes serialize functions, but with the limitation that it can be used
only in the same version of Python. In addition, class methods used as
model functions will not retain the rest of the class attributes and
methods, and so may not be usable. With all those warnings, it should be
emphasized that if you are willing to save or reuse the definition of the
model function as Python code, then saving the Parameters and rest of the
components that make up a model presents no problem.</p>
<p>If the <code class="docutils literal notranslate"><span class="pre">dill</span></code> package is installed, the model function will be saved using
it. But because saving the model function is not always reliable, saving a
model will always save the <em>name</em> of the model function. The <a class="reference internal" href="#lmfit.model.load_model" title="lmfit.model.load_model"><code class="xref py py-func docutils literal notranslate"><span class="pre">load_model()</span></code></a>
takes an optional <code class="xref py py-attr docutils literal notranslate"><span class="pre">funcdefs</span></code> argument that can contain a dictionary of
function definitions with the function names as keys and function objects as
values. If one of the dictionary keys matches the saved name, the
corresponding function object will be used as the model function. With this
approach, if you save a model and can provide the code used for the model
function, the model can be saved and reliably reloaded and used.</p>
<dl class="py function">
<dt id="lmfit.model.save_model">
<code class="sig-name descname">save_model</code><span class="sig-paren">(</span><em class="sig-param"><span class="n">model</span></em>, <em class="sig-param"><span class="n">fname</span></em><span class="sig-paren">)</span><a class="headerlink" href="#lmfit.model.save_model" title="Permalink to this definition">¶</a></dt>
<dd><p>Save a Model to a file.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>model</strong> (<a class="reference internal" href="#lmfit.model.Model" title="lmfit.model.Model"><em>Model</em></a>) – Model to be saved.</p></li>
<li><p><strong>fname</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.9)"><em>str</em></a>) – Name of file for saved Model.</p></li>
</ul>
</dd>
</dl>
</dd></dl>

<dl class="py function">
<dt id="lmfit.model.load_model">
<code class="sig-name descname">load_model</code><span class="sig-paren">(</span><em class="sig-param"><span class="n">fname</span></em>, <em class="sig-param"><span class="n">funcdefs</span><span class="o">=</span><span class="default_value">None</span></em><span class="sig-paren">)</span><a class="headerlink" href="#lmfit.model.load_model" title="Permalink to this definition">¶</a></dt>
<dd><p>Load a saved Model from a file.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>fname</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.9)"><em>str</em></a>) – Name of file containing saved Model.</p></li>
<li><p><strong>funcdefs</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#dict" title="(in Python v3.9)"><em>dict</em></a><em>, </em><em>optional</em>) – Dictionary of custom function names and definitions.</p></li>
</ul>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p>Model object loaded from file.</p>
</dd>
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p><a class="reference internal" href="#lmfit.model.Model" title="lmfit.model.Model">Model</a></p>
</dd>
</dl>
</dd></dl>

<p>As a simple example, one can save a model as:</p>
<div class="jupyter_cell jupyter_container docutils container">
<div class="cell_input code_cell docutils container">
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="c1"># &lt;examples/doc_model_savemodel.py&gt;</span>
<span class="kn">import</span> <span class="nn">numpy</span> <span class="k">as</span> <span class="nn">np</span>

<span class="kn">from</span> <span class="nn">lmfit.model</span> <span class="kn">import</span> <span class="n">Model</span><span class="p">,</span> <span class="n">save_model</span>


<span class="k">def</span> <span class="nf">mysine</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">amp</span><span class="p">,</span> <span class="n">freq</span><span class="p">,</span> <span class="n">shift</span><span class="p">):</span>
    <span class="k">return</span> <span class="n">amp</span> <span class="o">*</span> <span class="n">np</span><span class="o">.</span><span class="n">sin</span><span class="p">(</span><span class="n">x</span><span class="o">*</span><span class="n">freq</span> <span class="o">+</span> <span class="n">shift</span><span class="p">)</span>


<span class="n">sinemodel</span> <span class="o">=</span> <span class="n">Model</span><span class="p">(</span><span class="n">mysine</span><span class="p">)</span>
<span class="n">pars</span> <span class="o">=</span> <span class="n">sinemodel</span><span class="o">.</span><span class="n">make_params</span><span class="p">(</span><span class="n">amp</span><span class="o">=</span><span class="mi">1</span><span class="p">,</span> <span class="n">freq</span><span class="o">=</span><span class="mf">0.25</span><span class="p">,</span> <span class="n">shift</span><span class="o">=</span><span class="mi">0</span><span class="p">)</span>

<span class="n">save_model</span><span class="p">(</span><span class="n">sinemodel</span><span class="p">,</span> <span class="s1">&#39;sinemodel.sav&#39;</span><span class="p">)</span>
<span class="c1"># &lt;end examples/doc_model_savemodel.py&gt;</span>
</pre></div>
</div>
</div>
<div class="cell_output docutils container">
</div>
</div>
<p>To load that later, one might do:</p>
<div class="jupyter_cell jupyter_container docutils container">
<div class="cell_input code_cell docutils container">
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="c1"># &lt;examples/doc_model_loadmodel.py&gt;</span>
<span class="kn">import</span> <span class="nn">matplotlib.pyplot</span> <span class="k">as</span> <span class="nn">plt</span>
<span class="kn">import</span> <span class="nn">numpy</span> <span class="k">as</span> <span class="nn">np</span>

<span class="kn">from</span> <span class="nn">lmfit.model</span> <span class="kn">import</span> <span class="n">load_model</span>


<span class="k">def</span> <span class="nf">mysine</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">amp</span><span class="p">,</span> <span class="n">freq</span><span class="p">,</span> <span class="n">shift</span><span class="p">):</span>
    <span class="k">return</span> <span class="n">amp</span> <span class="o">*</span> <span class="n">np</span><span class="o">.</span><span class="n">sin</span><span class="p">(</span><span class="n">x</span><span class="o">*</span><span class="n">freq</span> <span class="o">+</span> <span class="n">shift</span><span class="p">)</span>


<span class="n">data</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">loadtxt</span><span class="p">(</span><span class="s1">&#39;sinedata.dat&#39;</span><span class="p">)</span>
<span class="n">x</span> <span class="o">=</span> <span class="n">data</span><span class="p">[:,</span> <span class="mi">0</span><span class="p">]</span>
<span class="n">y</span> <span class="o">=</span> <span class="n">data</span><span class="p">[:,</span> <span class="mi">1</span><span class="p">]</span>

<span class="n">model</span> <span class="o">=</span> <span class="n">load_model</span><span class="p">(</span><span class="s1">&#39;sinemodel.sav&#39;</span><span class="p">,</span> <span class="n">funcdefs</span><span class="o">=</span><span class="p">{</span><span class="s1">&#39;mysine&#39;</span><span class="p">:</span> <span class="n">mysine</span><span class="p">})</span>
<span class="n">params</span> <span class="o">=</span> <span class="n">model</span><span class="o">.</span><span class="n">make_params</span><span class="p">(</span><span class="n">amp</span><span class="o">=</span><span class="mi">3</span><span class="p">,</span> <span class="n">freq</span><span class="o">=</span><span class="mf">0.52</span><span class="p">,</span> <span class="n">shift</span><span class="o">=</span><span class="mi">0</span><span class="p">)</span>
<span class="n">params</span><span class="p">[</span><span class="s1">&#39;shift&#39;</span><span class="p">]</span><span class="o">.</span><span class="n">max</span> <span class="o">=</span> <span class="mi">1</span>
<span class="n">params</span><span class="p">[</span><span class="s1">&#39;shift&#39;</span><span class="p">]</span><span class="o">.</span><span class="n">min</span> <span class="o">=</span> <span class="o">-</span><span class="mi">1</span>
<span class="n">params</span><span class="p">[</span><span class="s1">&#39;amp&#39;</span><span class="p">]</span><span class="o">.</span><span class="n">min</span> <span class="o">=</span> <span class="mf">0.0</span>

<span class="n">result</span> <span class="o">=</span> <span class="n">model</span><span class="o">.</span><span class="n">fit</span><span class="p">(</span><span class="n">y</span><span class="p">,</span> <span class="n">params</span><span class="p">,</span> <span class="n">x</span><span class="o">=</span><span class="n">x</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="n">result</span><span class="o">.</span><span class="n">fit_report</span><span class="p">())</span>

<span class="n">plt</span><span class="o">.</span><span class="n">plot</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">,</span> <span class="s1">&#39;bo&#39;</span><span class="p">)</span>
<span class="n">plt</span><span class="o">.</span><span class="n">plot</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">result</span><span class="o">.</span><span class="n">best_fit</span><span class="p">,</span> <span class="s1">&#39;r-&#39;</span><span class="p">)</span>
<span class="n">plt</span><span class="o">.</span><span class="n">show</span><span class="p">()</span>
<span class="c1"># &lt;end examples/doc_model_loadmodel.py&gt;</span>
</pre></div>
</div>
</div>
<div class="cell_output docutils container">
</div>
</div>
<p>See also <a class="reference internal" href="#modelresult-saveload-sec"><span class="std std-ref">Saving and Loading ModelResults</span></a>.</p>
</div>
</div>
<div class="section" id="the-modelresult-class">
<h2>The <a class="reference internal" href="#lmfit.model.ModelResult" title="lmfit.model.ModelResult"><code class="xref py py-class docutils literal notranslate"><span class="pre">ModelResult</span></code></a> class<a class="headerlink" href="#the-modelresult-class" title="Permalink to this headline">¶</a></h2>
<p>A <a class="reference internal" href="#lmfit.model.ModelResult" title="lmfit.model.ModelResult"><code class="xref py py-class docutils literal notranslate"><span class="pre">ModelResult</span></code></a> (which had been called <code class="docutils literal notranslate"><span class="pre">ModelFit</span></code> prior to version
0.9) is the object returned by <a class="reference internal" href="#lmfit.model.Model.fit" title="lmfit.model.Model.fit"><code class="xref py py-meth docutils literal notranslate"><span class="pre">Model.fit()</span></code></a>. It is a subclass of
<a class="reference internal" href="fitting.html#lmfit.minimizer.Minimizer" title="lmfit.minimizer.Minimizer"><code class="xref py py-class docutils literal notranslate"><span class="pre">Minimizer</span></code></a>, and so contains many of the fit results.
Of course, it knows the <a class="reference internal" href="#lmfit.model.Model" title="lmfit.model.Model"><code class="xref py py-class docutils literal notranslate"><span class="pre">Model</span></code></a> and the set of
<a class="reference internal" href="parameters.html#lmfit.parameter.Parameters" title="lmfit.parameter.Parameters"><code class="xref py py-class docutils literal notranslate"><span class="pre">Parameters</span></code></a> used in the fit, and it has methods to
evaluate the model, to fit the data (or re-fit the data with changes to
the parameters, or fit with different or modified data) and to print out a
report for that fit.</p>
<p>While a <a class="reference internal" href="#lmfit.model.Model" title="lmfit.model.Model"><code class="xref py py-class docutils literal notranslate"><span class="pre">Model</span></code></a> encapsulates your model function, it is fairly
abstract and does not contain the parameters or data used in a particular
fit. A <a class="reference internal" href="#lmfit.model.ModelResult" title="lmfit.model.ModelResult"><code class="xref py py-class docutils literal notranslate"><span class="pre">ModelResult</span></code></a> <em>does</em> contain parameters and data as well as
methods to alter and re-do fits. Thus the <a class="reference internal" href="#lmfit.model.Model" title="lmfit.model.Model"><code class="xref py py-class docutils literal notranslate"><span class="pre">Model</span></code></a> is the idealized
model while the <a class="reference internal" href="#lmfit.model.ModelResult" title="lmfit.model.ModelResult"><code class="xref py py-class docutils literal notranslate"><span class="pre">ModelResult</span></code></a> is the messier, more complex (but perhaps
more useful) object that represents a fit with a set of parameters to data
with a model.</p>
<p>A <a class="reference internal" href="#lmfit.model.ModelResult" title="lmfit.model.ModelResult"><code class="xref py py-class docutils literal notranslate"><span class="pre">ModelResult</span></code></a> has several attributes holding values for fit
results, and several methods for working with fits. These include
statistics inherited from <a class="reference internal" href="fitting.html#lmfit.minimizer.Minimizer" title="lmfit.minimizer.Minimizer"><code class="xref py py-class docutils literal notranslate"><span class="pre">Minimizer</span></code></a> useful for
comparing different models, including <code class="docutils literal notranslate"><span class="pre">chisqr</span></code>, <code class="docutils literal notranslate"><span class="pre">redchi</span></code>, <code class="docutils literal notranslate"><span class="pre">aic</span></code>,
and <code class="docutils literal notranslate"><span class="pre">bic</span></code>.</p>
<dl class="py class">
<dt id="lmfit.model.ModelResult">
<em class="property">class </em><code class="sig-name descname">ModelResult</code><span class="sig-paren">(</span><em class="sig-param"><span class="n">model</span></em>, <em class="sig-param"><span class="n">params</span></em>, <em class="sig-param"><span class="n">data</span><span class="o">=</span><span class="default_value">None</span></em>, <em class="sig-param"><span class="n">weights</span><span class="o">=</span><span class="default_value">None</span></em>, <em class="sig-param"><span class="n">method</span><span class="o">=</span><span class="default_value">'leastsq'</span></em>, <em class="sig-param"><span class="n">fcn_args</span><span class="o">=</span><span class="default_value">None</span></em>, <em class="sig-param"><span class="n">fcn_kws</span><span class="o">=</span><span class="default_value">None</span></em>, <em class="sig-param"><span class="n">iter_cb</span><span class="o">=</span><span class="default_value">None</span></em>, <em class="sig-param"><span class="n">scale_covar</span><span class="o">=</span><span class="default_value">True</span></em>, <em class="sig-param"><span class="n">nan_policy</span><span class="o">=</span><span class="default_value">'raise'</span></em>, <em class="sig-param"><span class="n">calc_covar</span><span class="o">=</span><span class="default_value">True</span></em>, <em class="sig-param"><span class="n">max_nfev</span><span class="o">=</span><span class="default_value">None</span></em>, <em class="sig-param"><span class="o">**</span><span class="n">fit_kws</span></em><span class="sig-paren">)</span><a class="headerlink" href="#lmfit.model.ModelResult" title="Permalink to this definition">¶</a></dt>
<dd><p>Result from the Model fit.</p>
<p>This has many attributes and methods for viewing and working with the
results of a fit using Model. It inherits from Minimizer, so that it
can be used to modify and re-run the fit for the Model.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>model</strong> (<a class="reference internal" href="#lmfit.model.Model" title="lmfit.model.Model"><em>Model</em></a>) – Model to use.</p></li>
<li><p><strong>params</strong> (<a class="reference internal" href="parameters.html#lmfit.parameter.Parameters" title="lmfit.parameter.Parameters"><em>Parameters</em></a>) – Parameters with initial values for model.</p></li>
<li><p><strong>data</strong> (<em>array_like</em><em>, </em><em>optional</em>) – Data to be modeled.</p></li>
<li><p><strong>weights</strong> (<em>array_like</em><em>, </em><em>optional</em>) – Weights to multiply <code class="docutils literal notranslate"><span class="pre">(data-model)</span></code> for fit residual.</p></li>
<li><p><strong>method</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.9)"><em>str</em></a><em>, </em><em>optional</em>) – Name of minimization method to use (default is <cite>‘leastsq’</cite>).</p></li>
<li><p><strong>fcn_args</strong> (<em>sequence</em><em>, </em><em>optional</em>) – Positional arguments to send to model function.</p></li>
<li><p><strong>fcn_dict</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#dict" title="(in Python v3.9)"><em>dict</em></a><em>, </em><em>optional</em>) – Keyword arguments to send to model function.</p></li>
<li><p><strong>iter_cb</strong> (<em>callable</em><em>, </em><em>optional</em>) – Function to call on each iteration of fit.</p></li>
<li><p><strong>scale_covar</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.9)"><em>bool</em></a><em>, </em><em>optional</em>) – Whether to scale covariance matrix for uncertainty evaluation.</p></li>
<li><p><strong>nan_policy</strong> (<em>{'raise'</em><em>, </em><em>'propagate'</em><em>, </em><em>'omit'}</em><em>, </em><em>optional</em>) – What to do when encountering NaNs when fitting Model.</p></li>
<li><p><strong>calc_covar</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.9)"><em>bool</em></a><em>, </em><em>optional</em>) – Whether to calculate the covariance matrix (default is True)
for solvers other than <cite>‘leastsq’</cite> and <cite>‘least_squares’</cite>.
Requires the <code class="docutils literal notranslate"><span class="pre">numdifftools</span></code> package to be installed.</p></li>
<li><p><strong>max_nfev</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.9)"><em>int</em></a><em> or </em><a class="reference external" href="https://docs.python.org/3/library/constants.html#None" title="(in Python v3.9)"><em>None</em></a><em>, </em><em>optional</em>) – Maximum number of function evaluations (default is None). The
default value depends on the fitting method.</p></li>
<li><p><strong>**fit_kws</strong> (<em>optional</em>) – Keyword arguments to send to minimization routine.</p></li>
</ul>
</dd>
</dl>
</dd></dl>

<div class="section" id="modelresult-methods">
<h3><a class="reference internal" href="#lmfit.model.ModelResult" title="lmfit.model.ModelResult"><code class="xref py py-class docutils literal notranslate"><span class="pre">ModelResult</span></code></a> methods<a class="headerlink" href="#modelresult-methods" title="Permalink to this headline">¶</a></h3>
<dl class="py method">
<dt id="lmfit.model.ModelResult.eval">
<code class="sig-prename descclassname">ModelResult.</code><code class="sig-name descname">eval</code><span class="sig-paren">(</span><em class="sig-param"><span class="n">params</span><span class="o">=</span><span class="default_value">None</span></em>, <em class="sig-param"><span class="o">**</span><span class="n">kwargs</span></em><span class="sig-paren">)</span><a class="headerlink" href="#lmfit.model.ModelResult.eval" title="Permalink to this definition">¶</a></dt>
<dd><p>Evaluate model function.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>params</strong> (<a class="reference internal" href="parameters.html#lmfit.parameter.Parameters" title="lmfit.parameter.Parameters"><em>Parameters</em></a><em>, </em><em>optional</em>) – Parameters to use.</p></li>
<li><p><strong>**kwargs</strong> (<em>optional</em>) – Options to send to Model.eval().</p></li>
</ul>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p>Array for evaluated model.</p>
</dd>
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p><a class="reference external" href="https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html#numpy.ndarray" title="(in NumPy v1.20)">numpy.ndarray</a></p>
</dd>
</dl>
</dd></dl>

<dl class="py method">
<dt id="lmfit.model.ModelResult.eval_components">
<code class="sig-prename descclassname">ModelResult.</code><code class="sig-name descname">eval_components</code><span class="sig-paren">(</span><em class="sig-param"><span class="n">params</span><span class="o">=</span><span class="default_value">None</span></em>, <em class="sig-param"><span class="o">**</span><span class="n">kwargs</span></em><span class="sig-paren">)</span><a class="headerlink" href="#lmfit.model.ModelResult.eval_components" title="Permalink to this definition">¶</a></dt>
<dd><p>Evaluate each component of a composite model function.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>params</strong> (<a class="reference internal" href="parameters.html#lmfit.parameter.Parameters" title="lmfit.parameter.Parameters"><em>Parameters</em></a><em>, </em><em>optional</em>) – Parameters, defaults to ModelResult.params.</p></li>
<li><p><strong>**kwargs</strong> (<em>optional</em>) – Keyword arguments to pass to model function.</p></li>
</ul>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p>Keys are prefixes of component models, and values are the
estimated model value for each component of the model.</p>
</dd>
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p>OrderedDict</p>
</dd>
</dl>
</dd></dl>

<dl class="py method">
<dt id="lmfit.model.ModelResult.fit">
<code class="sig-prename descclassname">ModelResult.</code><code class="sig-name descname">fit</code><span class="sig-paren">(</span><em class="sig-param"><span class="n">data</span><span class="o">=</span><span class="default_value">None</span></em>, <em class="sig-param"><span class="n">params</span><span class="o">=</span><span class="default_value">None</span></em>, <em class="sig-param"><span class="n">weights</span><span class="o">=</span><span class="default_value">None</span></em>, <em class="sig-param"><span class="n">method</span><span class="o">=</span><span class="default_value">None</span></em>, <em class="sig-param"><span class="n">nan_policy</span><span class="o">=</span><span class="default_value">None</span></em>, <em class="sig-param"><span class="o">**</span><span class="n">kwargs</span></em><span class="sig-paren">)</span><a class="headerlink" href="#lmfit.model.ModelResult.fit" title="Permalink to this definition">¶</a></dt>
<dd><p>Re-perform fit for a Model, given data and params.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>data</strong> (<em>array_like</em><em>, </em><em>optional</em>) – Data to be modeled.</p></li>
<li><p><strong>params</strong> (<a class="reference internal" href="parameters.html#lmfit.parameter.Parameters" title="lmfit.parameter.Parameters"><em>Parameters</em></a><em>, </em><em>optional</em>) – Parameters with initial values for model.</p></li>
<li><p><strong>weights</strong> (<em>array_like</em><em>, </em><em>optional</em>) – Weights to multiply <code class="docutils literal notranslate"><span class="pre">(data-model)</span></code> for fit residual.</p></li>
<li><p><strong>method</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.9)"><em>str</em></a><em>, </em><em>optional</em>) – Name of minimization method to use (default is <cite>‘leastsq’</cite>).</p></li>
<li><p><strong>nan_policy</strong> (<em>{'raise'</em><em>, </em><em>'propagate'</em><em>, </em><em>'omit'}</em><em>, </em><em>optional</em>) – What to do when encountering NaNs when fitting Model.</p></li>
<li><p><strong>**kwargs</strong> (<em>optional</em>) – Keyword arguments to send to minimization routine.</p></li>
</ul>
</dd>
</dl>
</dd></dl>

<dl class="py method">
<dt id="lmfit.model.ModelResult.fit_report">
<code class="sig-prename descclassname">ModelResult.</code><code class="sig-name descname">fit_report</code><span class="sig-paren">(</span><em class="sig-param"><span class="n">modelpars</span><span class="o">=</span><span class="default_value">None</span></em>, <em class="sig-param"><span class="n">show_correl</span><span class="o">=</span><span class="default_value">True</span></em>, <em class="sig-param"><span class="n">min_correl</span><span class="o">=</span><span class="default_value">0.1</span></em>, <em class="sig-param"><span class="n">sort_pars</span><span class="o">=</span><span class="default_value">False</span></em><span class="sig-paren">)</span><a class="headerlink" href="#lmfit.model.ModelResult.fit_report" title="Permalink to this definition">¶</a></dt>
<dd><p>Return a printable fit report.</p>
<p>The report contains fit statistics and best-fit values with
uncertainties and correlations.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>modelpars</strong> (<a class="reference internal" href="parameters.html#lmfit.parameter.Parameters" title="lmfit.parameter.Parameters"><em>Parameters</em></a><em>, </em><em>optional</em>) – Known Model Parameters.</p></li>
<li><p><strong>show_correl</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.9)"><em>bool</em></a><em>, </em><em>optional</em>) – Whether to show list of sorted correlations (default is True).</p></li>
<li><p><strong>min_correl</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#float" title="(in Python v3.9)"><em>float</em></a><em>, </em><em>optional</em>) – Smallest correlation in absolute value to show (default is 0.1).</p></li>
<li><p><strong>sort_pars</strong> (<em>callable</em><em>, </em><em>optional</em>) – 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.</p></li>
</ul>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p>Multi-line text of fit report.</p>
</dd>
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p><a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.9)">str</a></p>
</dd>
</dl>
</dd></dl>

<dl class="py method">
<dt id="lmfit.model.ModelResult.conf_interval">
<code class="sig-prename descclassname">ModelResult.</code><code class="sig-name descname">conf_interval</code><span class="sig-paren">(</span><em class="sig-param"><span class="o">**</span><span class="n">kwargs</span></em><span class="sig-paren">)</span><a class="headerlink" href="#lmfit.model.ModelResult.conf_interval" title="Permalink to this definition">¶</a></dt>
<dd><p>Calculate the confidence intervals for the variable parameters.</p>
<p>Confidence intervals are calculated using the
<code class="xref py py-func docutils literal notranslate"><span class="pre">confidence.conf_interval()</span></code> function and keyword arguments
(<cite>**kwargs</cite>) are passed to that function. The result is stored in
the <a class="reference internal" href="#lmfit.model.ci_out" title="lmfit.model.ci_out"><code class="xref py py-attr docutils literal notranslate"><span class="pre">ci_out</span></code></a> attribute so that it can be accessed without
recalculating them.</p>
</dd></dl>

<dl class="py method">
<dt id="lmfit.model.ModelResult.ci_report">
<code class="sig-prename descclassname">ModelResult.</code><code class="sig-name descname">ci_report</code><span class="sig-paren">(</span><em class="sig-param"><span class="n">with_offset</span><span class="o">=</span><span class="default_value">True</span></em>, <em class="sig-param"><span class="n">ndigits</span><span class="o">=</span><span class="default_value">5</span></em>, <em class="sig-param"><span class="o">**</span><span class="n">kwargs</span></em><span class="sig-paren">)</span><a class="headerlink" href="#lmfit.model.ModelResult.ci_report" title="Permalink to this definition">¶</a></dt>
<dd><p>Return a formatted text report of the confidence intervals.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>with_offset</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.9)"><em>bool</em></a><em>, </em><em>optional</em>) – Whether to subtract best value from all other values (default
is True).</p></li>
<li><p><strong>ndigits</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.9)"><em>int</em></a><em>, </em><em>optional</em>) – Number of significant digits to show (default is 5).</p></li>
<li><p><strong>**kwargs</strong> (<em>optional</em>) – Keyword arguments that are passed to the <cite>conf_interval</cite>
function.</p></li>
</ul>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p>Text of formatted report on confidence intervals.</p>
</dd>
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p><a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.9)">str</a></p>
</dd>
</dl>
</dd></dl>

<dl class="py method">
<dt id="lmfit.model.ModelResult.eval_uncertainty">
<code class="sig-prename descclassname">ModelResult.</code><code class="sig-name descname">eval_uncertainty</code><span class="sig-paren">(</span><em class="sig-param"><span class="n">params</span><span class="o">=</span><span class="default_value">None</span></em>, <em class="sig-param"><span class="n">sigma</span><span class="o">=</span><span class="default_value">1</span></em>, <em class="sig-param"><span class="o">**</span><span class="n">kwargs</span></em><span class="sig-paren">)</span><a class="headerlink" href="#lmfit.model.ModelResult.eval_uncertainty" title="Permalink to this definition">¶</a></dt>
<dd><p>Evaluate the uncertainty of the <em>model function</em>.</p>
<p>This can be used to give confidence bands for the model from the
uncertainties in the best-fit parameters.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>params</strong> (<a class="reference internal" href="parameters.html#lmfit.parameter.Parameters" title="lmfit.parameter.Parameters"><em>Parameters</em></a><em>, </em><em>optional</em>) – Parameters, defaults to ModelResult.params.</p></li>
<li><p><strong>sigma</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#float" title="(in Python v3.9)"><em>float</em></a><em>, </em><em>optional</em>) – Confidence level, i.e. how many sigma (default is 1).</p></li>
<li><p><strong>**kwargs</strong> (<em>optional</em>) – Values of options, independent variables, etcetera.</p></li>
</ul>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p>Uncertainty at each value of the model.</p>
</dd>
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p><a class="reference external" href="https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html#numpy.ndarray" title="(in NumPy v1.20)">numpy.ndarray</a></p>
</dd>
</dl>
<p class="rubric">Notes</p>
<ol class="arabic simple">
<li><p>This is based on the excellent and clear example from
<a class="reference external" href="https://www.astro.rug.nl/software/kapteyn/kmpfittutorial.html#confidence-and-prediction-intervals">https://www.astro.rug.nl/software/kapteyn/kmpfittutorial.html#confidence-and-prediction-intervals</a>,
which references the original work of:
J. Wolberg, Data Analysis Using the Method of Least Squares, 2006, Springer</p></li>
<li><p>The value of sigma is number of <cite>sigma</cite> 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
&lt; 1, it is interpreted as the probability itself. That is,
<code class="docutils literal notranslate"><span class="pre">sigma=1</span></code> and <code class="docutils literal notranslate"><span class="pre">sigma=0.6827</span></code> will give the same results,
within precision errors.</p></li>
</ol>
<p class="rubric">Examples</p>
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">out</span> <span class="o">=</span> <span class="n">model</span><span class="o">.</span><span class="n">fit</span><span class="p">(</span><span class="n">data</span><span class="p">,</span> <span class="n">params</span><span class="p">,</span> <span class="n">x</span><span class="o">=</span><span class="n">x</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">dely</span> <span class="o">=</span> <span class="n">out</span><span class="o">.</span><span class="n">eval_uncertainty</span><span class="p">(</span><span class="n">x</span><span class="o">=</span><span class="n">x</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">plt</span><span class="o">.</span><span class="n">plot</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">data</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">plt</span><span class="o">.</span><span class="n">plot</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">out</span><span class="o">.</span><span class="n">best_fit</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">plt</span><span class="o">.</span><span class="n">fill_between</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">out</span><span class="o">.</span><span class="n">best_fit</span><span class="o">-</span><span class="n">dely</span><span class="p">,</span>
<span class="gp">... </span>                 <span class="n">out</span><span class="o">.</span><span class="n">best_fit</span><span class="o">+</span><span class="n">dely</span><span class="p">,</span> <span class="n">color</span><span class="o">=</span><span class="s1">&#39;#888888&#39;</span><span class="p">)</span>
</pre></div>
</div>
</dd></dl>

<dl class="py method">
<dt id="lmfit.model.ModelResult.plot">
<code class="sig-prename descclassname">ModelResult.</code><code class="sig-name descname">plot</code><span class="sig-paren">(</span><em class="sig-param"><span class="n">datafmt</span><span class="o">=</span><span class="default_value">'o'</span></em>, <em class="sig-param"><span class="n">fitfmt</span><span class="o">=</span><span class="default_value">'-'</span></em>, <em class="sig-param"><span class="n">initfmt</span><span class="o">=</span><span class="default_value">'--'</span></em>, <em class="sig-param"><span class="n">xlabel</span><span class="o">=</span><span class="default_value">None</span></em>, <em class="sig-param"><span class="n">ylabel</span><span class="o">=</span><span class="default_value">None</span></em>, <em class="sig-param"><span class="n">yerr</span><span class="o">=</span><span class="default_value">None</span></em>, <em class="sig-param"><span class="n">numpoints</span><span class="o">=</span><span class="default_value">None</span></em>, <em class="sig-param"><span class="n">fig</span><span class="o">=</span><span class="default_value">None</span></em>, <em class="sig-param"><span class="n">data_kws</span><span class="o">=</span><span class="default_value">None</span></em>, <em class="sig-param"><span class="n">fit_kws</span><span class="o">=</span><span class="default_value">None</span></em>, <em class="sig-param"><span class="n">init_kws</span><span class="o">=</span><span class="default_value">None</span></em>, <em class="sig-param"><span class="n">ax_res_kws</span><span class="o">=</span><span class="default_value">None</span></em>, <em class="sig-param"><span class="n">ax_fit_kws</span><span class="o">=</span><span class="default_value">None</span></em>, <em class="sig-param"><span class="n">fig_kws</span><span class="o">=</span><span class="default_value">None</span></em>, <em class="sig-param"><span class="n">show_init</span><span class="o">=</span><span class="default_value">False</span></em>, <em class="sig-param"><span class="n">parse_complex</span><span class="o">=</span><span class="default_value">'abs'</span></em><span class="sig-paren">)</span><a class="headerlink" href="#lmfit.model.ModelResult.plot" title="Permalink to this definition">¶</a></dt>
<dd><p>Plot the fit results and residuals using matplotlib.</p>
<p>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
<code class="docutils literal notranslate"><span class="pre">show_init=True</span></code>.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>datafmt</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.9)"><em>str</em></a><em>, </em><em>optional</em>) – Matplotlib format string for data points.</p></li>
<li><p><strong>fitfmt</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.9)"><em>str</em></a><em>, </em><em>optional</em>) – Matplotlib format string for fitted curve.</p></li>
<li><p><strong>initfmt</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.9)"><em>str</em></a><em>, </em><em>optional</em>) – Matplotlib format string for initial conditions for the fit.</p></li>
<li><p><strong>xlabel</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.9)"><em>str</em></a><em>, </em><em>optional</em>) – Matplotlib format string for labeling the x-axis.</p></li>
<li><p><strong>ylabel</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.9)"><em>str</em></a><em>, </em><em>optional</em>) – Matplotlib format string for labeling the y-axis.</p></li>
<li><p><strong>yerr</strong> (<a class="reference external" href="https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html#numpy.ndarray" title="(in NumPy v1.20)"><em>numpy.ndarray</em></a><em>, </em><em>optional</em>) – Array of uncertainties for data array.</p></li>
<li><p><strong>numpoints</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.9)"><em>int</em></a><em>, </em><em>optional</em>) – If provided, the final and initial fit curves are evaluated
not only at data points, but refined to contain <cite>numpoints</cite>
points in total.</p></li>
<li><p><strong>fig</strong> (<a class="reference external" href="https://matplotlib.org/api/_as_gen/matplotlib.figure.Figure.html#matplotlib.figure.Figure" title="(in Matplotlib v3.3.3)"><em>matplotlib.figure.Figure</em></a><em>, </em><em>optional</em>) – The figure to plot on. The default is None, which means use
the current pyplot figure or create one if there is none.</p></li>
<li><p><strong>data_kws</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#dict" title="(in Python v3.9)"><em>dict</em></a><em>, </em><em>optional</em>) – Keyword arguments passed to the plot function for data points.</p></li>
<li><p><strong>fit_kws</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#dict" title="(in Python v3.9)"><em>dict</em></a><em>, </em><em>optional</em>) – Keyword arguments passed to the plot function for fitted curve.</p></li>
<li><p><strong>init_kws</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#dict" title="(in Python v3.9)"><em>dict</em></a><em>, </em><em>optional</em>) – Keyword arguments passed to the plot function for the initial
conditions of the fit.</p></li>
<li><p><strong>ax_res_kws</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#dict" title="(in Python v3.9)"><em>dict</em></a><em>, </em><em>optional</em>) – Keyword arguments for the axes for the residuals plot.</p></li>
<li><p><strong>ax_fit_kws</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#dict" title="(in Python v3.9)"><em>dict</em></a><em>, </em><em>optional</em>) – Keyword arguments for the axes for the fit plot.</p></li>
<li><p><strong>fig_kws</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#dict" title="(in Python v3.9)"><em>dict</em></a><em>, </em><em>optional</em>) – Keyword arguments for a new figure, if a new one is created.</p></li>
<li><p><strong>show_init</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.9)"><em>bool</em></a><em>, </em><em>optional</em>) – Whether to show the initial conditions for the fit (default is
False).</p></li>
<li><p><strong>parse_complex</strong> (<em>{'abs'</em><em>, </em><em>'real'</em><em>, </em><em>'imag'</em><em>, </em><em>'angle'}</em><em>, </em><em>optional</em>) – How to reduce complex data for plotting. Options are one of:
<cite>‘abs’</cite> (default), <cite>‘real’</cite>, <cite>‘imag’</cite>, or <cite>‘angle’</cite>, which
correspond to the NumPy functions with the same name.</p></li>
</ul>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p>A tuple with matplotlib’s Figure and GridSpec objects.</p>
</dd>
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p><a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#tuple" title="(in Python v3.9)">tuple</a></p>
</dd>
</dl>
<div class="admonition seealso">
<p class="admonition-title">See also</p>
<dl class="simple">
<dt><a class="reference internal" href="#lmfit.model.ModelResult.plot_fit" title="lmfit.model.ModelResult.plot_fit"><code class="xref py py-obj docutils literal notranslate"><span class="pre">ModelResult.plot_fit</span></code></a></dt><dd><p>Plot the fit results using matplotlib.</p>
</dd>
<dt><a class="reference internal" href="#lmfit.model.ModelResult.plot_residuals" title="lmfit.model.ModelResult.plot_residuals"><code class="xref py py-obj docutils literal notranslate"><span class="pre">ModelResult.plot_residuals</span></code></a></dt><dd><p>Plot the fit residuals using matplotlib.</p>
</dd>
</dl>
</div>
<p class="rubric">Notes</p>
<p>The method combines <cite>ModelResult.plot_fit</cite> and
<cite>ModelResult.plot_residuals</cite>.</p>
<p>If <cite>yerr</cite> is specified or if the fit model included weights, then
<cite>matplotlib.axes.Axes.errorbar</cite> is used to plot the data. If
<cite>yerr</cite> is not specified and the fit includes weights, <cite>yerr</cite> set
to <code class="docutils literal notranslate"><span class="pre">1/self.weights</span></code>.</p>
<p>If model returns complex data, <cite>yerr</cite> is treated the same way that
weights are in this case.</p>
<p>If <cite>fig</cite> is None then <cite>matplotlib.pyplot.figure(**fig_kws)</cite> is
called, otherwise <cite>fig_kws</cite> is ignored.</p>
</dd></dl>

<dl class="py method">
<dt id="lmfit.model.ModelResult.plot_fit">
<code class="sig-prename descclassname">ModelResult.</code><code class="sig-name descname">plot_fit</code><span class="sig-paren">(</span><em class="sig-param"><span class="n">ax</span><span class="o">=</span><span class="default_value">None</span></em>, <em class="sig-param"><span class="n">datafmt</span><span class="o">=</span><span class="default_value">'o'</span></em>, <em class="sig-param"><span class="n">fitfmt</span><span class="o">=</span><span class="default_value">'-'</span></em>, <em class="sig-param"><span class="n">initfmt</span><span class="o">=</span><span class="default_value">'--'</span></em>, <em class="sig-param"><span class="n">xlabel</span><span class="o">=</span><span class="default_value">None</span></em>, <em class="sig-param"><span class="n">ylabel</span><span class="o">=</span><span class="default_value">None</span></em>, <em class="sig-param"><span class="n">yerr</span><span class="o">=</span><span class="default_value">None</span></em>, <em class="sig-param"><span class="n">numpoints</span><span class="o">=</span><span class="default_value">None</span></em>, <em class="sig-param"><span class="n">data_kws</span><span class="o">=</span><span class="default_value">None</span></em>, <em class="sig-param"><span class="n">fit_kws</span><span class="o">=</span><span class="default_value">None</span></em>, <em class="sig-param"><span class="n">init_kws</span><span class="o">=</span><span class="default_value">None</span></em>, <em class="sig-param"><span class="n">ax_kws</span><span class="o">=</span><span class="default_value">None</span></em>, <em class="sig-param"><span class="n">show_init</span><span class="o">=</span><span class="default_value">False</span></em>, <em class="sig-param"><span class="n">parse_complex</span><span class="o">=</span><span class="default_value">'abs'</span></em><span class="sig-paren">)</span><a class="headerlink" href="#lmfit.model.ModelResult.plot_fit" title="Permalink to this definition">¶</a></dt>
<dd><p>Plot the fit results using matplotlib, if available.</p>
<p>The plot will include the data points, the initial fit curve
(optional, with <code class="docutils literal notranslate"><span class="pre">show_init=True</span></code>), and the best-fit curve. If
the fit model included weights or if <cite>yerr</cite> is specified,
errorbars will also be plotted.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>ax</strong> (<a class="reference external" href="https://matplotlib.org/api/axes_api.html#matplotlib.axes.Axes" title="(in Matplotlib v3.3.3)"><em>matplotlib.axes.Axes</em></a><em>, </em><em>optional</em>) – The axes to plot on. The default in None, which means use the
current pyplot axis or create one if there is none.</p></li>
<li><p><strong>datafmt</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.9)"><em>str</em></a><em>, </em><em>optional</em>) – Matplotlib format string for data points.</p></li>
<li><p><strong>fitfmt</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.9)"><em>str</em></a><em>, </em><em>optional</em>) – Matplotlib format string for fitted curve.</p></li>
<li><p><strong>initfmt</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.9)"><em>str</em></a><em>, </em><em>optional</em>) – Matplotlib format string for initial conditions for the fit.</p></li>
<li><p><strong>xlabel</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.9)"><em>str</em></a><em>, </em><em>optional</em>) – Matplotlib format string for labeling the x-axis.</p></li>
<li><p><strong>ylabel</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.9)"><em>str</em></a><em>, </em><em>optional</em>) – Matplotlib format string for labeling the y-axis.</p></li>
<li><p><strong>yerr</strong> (<a class="reference external" href="https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html#numpy.ndarray" title="(in NumPy v1.20)"><em>numpy.ndarray</em></a><em>, </em><em>optional</em>) – Array of uncertainties for data array.</p></li>
<li><p><strong>numpoints</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.9)"><em>int</em></a><em>, </em><em>optional</em>) – If provided, the final and initial fit curves are evaluated
not only at data points, but refined to contain <cite>numpoints</cite>
points in total.</p></li>
<li><p><strong>data_kws</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#dict" title="(in Python v3.9)"><em>dict</em></a><em>, </em><em>optional</em>) – Keyword arguments passed to the plot function for data points.</p></li>
<li><p><strong>fit_kws</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#dict" title="(in Python v3.9)"><em>dict</em></a><em>, </em><em>optional</em>) – Keyword arguments passed to the plot function for fitted curve.</p></li>
<li><p><strong>init_kws</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#dict" title="(in Python v3.9)"><em>dict</em></a><em>, </em><em>optional</em>) – Keyword arguments passed to the plot function for the initial
conditions of the fit.</p></li>
<li><p><strong>ax_kws</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#dict" title="(in Python v3.9)"><em>dict</em></a><em>, </em><em>optional</em>) – Keyword arguments for a new axis, if a new one is created.</p></li>
<li><p><strong>show_init</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.9)"><em>bool</em></a><em>, </em><em>optional</em>) – Whether to show the initial conditions for the fit (default is
False).</p></li>
<li><p><strong>parse_complex</strong> (<em>{'abs'</em><em>, </em><em>'real'</em><em>, </em><em>'imag'</em><em>, </em><em>'angle'}</em><em>, </em><em>optional</em>) – How to reduce complex data for plotting. Options are one of:
<cite>‘abs’</cite> (default), <cite>‘real’</cite>, <cite>‘imag’</cite>, or <cite>‘angle’</cite>, which
correspond to the NumPy functions with the same name.</p></li>
</ul>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p></p>
</dd>
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p><a class="reference external" href="https://matplotlib.org/api/axes_api.html#matplotlib.axes.Axes" title="(in Matplotlib v3.3.3)">matplotlib.axes.Axes</a></p>
</dd>
</dl>
<div class="admonition seealso">
<p class="admonition-title">See also</p>
<dl class="simple">
<dt><a class="reference internal" href="#lmfit.model.ModelResult.plot_residuals" title="lmfit.model.ModelResult.plot_residuals"><code class="xref py py-obj docutils literal notranslate"><span class="pre">ModelResult.plot_residuals</span></code></a></dt><dd><p>Plot the fit residuals using matplotlib.</p>
</dd>
<dt><a class="reference internal" href="#lmfit.model.ModelResult.plot" title="lmfit.model.ModelResult.plot"><code class="xref py py-obj docutils literal notranslate"><span class="pre">ModelResult.plot</span></code></a></dt><dd><p>Plot the fit results and residuals using matplotlib.</p>
</dd>
</dl>
</div>
<p class="rubric">Notes</p>
<p>For details about plot format strings and keyword arguments see
documentation of <cite>matplotlib.axes.Axes.plot</cite>.</p>
<p>If <cite>yerr</cite> is specified or if the fit model included weights, then
<cite>matplotlib.axes.Axes.errorbar</cite> is used to plot the data. If
<cite>yerr</cite> is not specified and the fit includes weights, <cite>yerr</cite> set
to <code class="docutils literal notranslate"><span class="pre">1/self.weights</span></code>.</p>
<p>If model returns complex data, <cite>yerr</cite> is treated the same way that
weights are in this case.</p>
<p>If <cite>ax</cite> is None then <cite>matplotlib.pyplot.gca(**ax_kws)</cite> is called.</p>
</dd></dl>

<dl class="py method">
<dt id="lmfit.model.ModelResult.plot_residuals">
<code class="sig-prename descclassname">ModelResult.</code><code class="sig-name descname">plot_residuals</code><span class="sig-paren">(</span><em class="sig-param"><span class="n">ax</span><span class="o">=</span><span class="default_value">None</span></em>, <em class="sig-param"><span class="n">datafmt</span><span class="o">=</span><span class="default_value">'o'</span></em>, <em class="sig-param"><span class="n">yerr</span><span class="o">=</span><span class="default_value">None</span></em>, <em class="sig-param"><span class="n">data_kws</span><span class="o">=</span><span class="default_value">None</span></em>, <em class="sig-param"><span class="n">fit_kws</span><span class="o">=</span><span class="default_value">None</span></em>, <em class="sig-param"><span class="n">ax_kws</span><span class="o">=</span><span class="default_value">None</span></em>, <em class="sig-param"><span class="n">parse_complex</span><span class="o">=</span><span class="default_value">'abs'</span></em><span class="sig-paren">)</span><a class="headerlink" href="#lmfit.model.ModelResult.plot_residuals" title="Permalink to this definition">¶</a></dt>
<dd><p>Plot the fit residuals using matplotlib, if available.</p>
<p>If <cite>yerr</cite> is supplied or if the model included weights, errorbars
will also be plotted.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>ax</strong> (<a class="reference external" href="https://matplotlib.org/api/axes_api.html#matplotlib.axes.Axes" title="(in Matplotlib v3.3.3)"><em>matplotlib.axes.Axes</em></a><em>, </em><em>optional</em>) – The axes to plot on. The default in None, which means use the
current pyplot axis or create one if there is none.</p></li>
<li><p><strong>datafmt</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.9)"><em>str</em></a><em>, </em><em>optional</em>) – Matplotlib format string for data points.</p></li>
<li><p><strong>yerr</strong> (<a class="reference external" href="https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html#numpy.ndarray" title="(in NumPy v1.20)"><em>numpy.ndarray</em></a><em>, </em><em>optional</em>) – Array of uncertainties for data array.</p></li>
<li><p><strong>data_kws</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#dict" title="(in Python v3.9)"><em>dict</em></a><em>, </em><em>optional</em>) – Keyword arguments passed to the plot function for data points.</p></li>
<li><p><strong>fit_kws</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#dict" title="(in Python v3.9)"><em>dict</em></a><em>, </em><em>optional</em>) – Keyword arguments passed to the plot function for fitted curve.</p></li>
<li><p><strong>ax_kws</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#dict" title="(in Python v3.9)"><em>dict</em></a><em>, </em><em>optional</em>) – Keyword arguments for a new axis, if a new one is created.</p></li>
<li><p><strong>parse_complex</strong> (<em>{'abs'</em><em>, </em><em>'real'</em><em>, </em><em>'imag'</em><em>, </em><em>'angle'}</em><em>, </em><em>optional</em>) – How to reduce complex data for plotting. Options are one of:
<cite>‘abs’</cite> (default), <cite>‘real’</cite>, <cite>‘imag’</cite>, or <cite>‘angle’</cite>, which
correspond to the NumPy functions with the same name.</p></li>
</ul>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p></p>
</dd>
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p><a class="reference external" href="https://matplotlib.org/api/axes_api.html#matplotlib.axes.Axes" title="(in Matplotlib v3.3.3)">matplotlib.axes.Axes</a></p>
</dd>
</dl>
<div class="admonition seealso">
<p class="admonition-title">See also</p>
<dl class="simple">
<dt><a class="reference internal" href="#lmfit.model.ModelResult.plot_fit" title="lmfit.model.ModelResult.plot_fit"><code class="xref py py-obj docutils literal notranslate"><span class="pre">ModelResult.plot_fit</span></code></a></dt><dd><p>Plot the fit results using matplotlib.</p>
</dd>
<dt><a class="reference internal" href="#lmfit.model.ModelResult.plot" title="lmfit.model.ModelResult.plot"><code class="xref py py-obj docutils literal notranslate"><span class="pre">ModelResult.plot</span></code></a></dt><dd><p>Plot the fit results and residuals using matplotlib.</p>
</dd>
</dl>
</div>
<p class="rubric">Notes</p>
<p>For details about plot format strings and keyword arguments see
documentation of <cite>matplotlib.axes.Axes.plot</cite>.</p>
<p>If <cite>yerr</cite> is specified or if the fit model included weights, then
<cite>matplotlib.axes.Axes.errorbar</cite> is used to plot the data. If
<cite>yerr</cite> is not specified and the fit includes weights, <cite>yerr</cite> set
to <code class="docutils literal notranslate"><span class="pre">1/self.weights</span></code>.</p>
<p>If model returns complex data, <cite>yerr</cite> is treated the same way that
weights are in this case.</p>
<p>If <cite>ax</cite> is None then <cite>matplotlib.pyplot.gca(**ax_kws)</cite> is called.</p>
</dd></dl>

</div>
<div class="section" id="modelresult-attributes">
<h3><a class="reference internal" href="#lmfit.model.ModelResult" title="lmfit.model.ModelResult"><code class="xref py py-class docutils literal notranslate"><span class="pre">ModelResult</span></code></a> attributes<a class="headerlink" href="#modelresult-attributes" title="Permalink to this headline">¶</a></h3>
<dl class="py attribute">
<dt id="lmfit.model.aic">
<code class="sig-name descname">aic</code><a class="headerlink" href="#lmfit.model.aic" title="Permalink to this definition">¶</a></dt>
<dd><p>Floating point best-fit Akaike Information Criterion statistic
(see <a class="reference internal" href="fitting.html#fit-results-label"><span class="std std-ref">MinimizerResult – the optimization result</span></a>).</p>
</dd></dl>

<dl class="py attribute">
<dt id="lmfit.model.best_fit">
<code class="sig-name descname">best_fit</code><a class="headerlink" href="#lmfit.model.best_fit" title="Permalink to this definition">¶</a></dt>
<dd><p>numpy.ndarray result of model function, evaluated at provided
independent variables and with best-fit parameters.</p>
</dd></dl>

<dl class="py attribute">
<dt id="lmfit.model.best_values">
<code class="sig-name descname">best_values</code><a class="headerlink" href="#lmfit.model.best_values" title="Permalink to this definition">¶</a></dt>
<dd><p>Dictionary with parameter names as keys, and best-fit values as values.</p>
</dd></dl>

<dl class="py attribute">
<dt id="lmfit.model.bic">
<code class="sig-name descname">bic</code><a class="headerlink" href="#lmfit.model.bic" title="Permalink to this definition">¶</a></dt>
<dd><p>Floating point best-fit Bayesian Information Criterion statistic
(see <a class="reference internal" href="fitting.html#fit-results-label"><span class="std std-ref">MinimizerResult – the optimization result</span></a>).</p>
</dd></dl>

<dl class="py attribute">
<dt id="lmfit.model.chisqr">
<code class="sig-name descname">chisqr</code><a class="headerlink" href="#lmfit.model.chisqr" title="Permalink to this definition">¶</a></dt>
<dd><p>Floating point best-fit chi-square statistic (see <a class="reference internal" href="fitting.html#fit-results-label"><span class="std std-ref">MinimizerResult – the optimization result</span></a>).</p>
</dd></dl>

<dl class="py attribute">
<dt id="lmfit.model.ci_out">
<code class="sig-name descname">ci_out</code><a class="headerlink" href="#lmfit.model.ci_out" title="Permalink to this definition">¶</a></dt>
<dd><p>Confidence interval data (see <a class="reference internal" href="confidence.html#confidence-chapter"><span class="std std-ref">Calculation of confidence intervals</span></a>) or <code class="docutils literal notranslate"><span class="pre">None</span></code> if
the confidence intervals have not been calculated.</p>
</dd></dl>

<dl class="py attribute">
<dt id="lmfit.model.covar">
<code class="sig-name descname">covar</code><a class="headerlink" href="#lmfit.model.covar" title="Permalink to this definition">¶</a></dt>
<dd><p>numpy.ndarray (square) covariance matrix returned from fit.</p>
</dd></dl>

<dl class="py attribute">
<dt id="lmfit.model.data">
<code class="sig-name descname">data</code><a class="headerlink" href="#lmfit.model.data" title="Permalink to this definition">¶</a></dt>
<dd><p>numpy.ndarray of data to compare to model.</p>
</dd></dl>

<dl class="py attribute">
<dt id="lmfit.model.errorbars">
<code class="sig-name descname">errorbars</code><a class="headerlink" href="#lmfit.model.errorbars" title="Permalink to this definition">¶</a></dt>
<dd><p>Boolean for whether error bars were estimated by fit.</p>
</dd></dl>

<dl class="py attribute">
<dt id="lmfit.model.ier">
<code class="sig-name descname">ier</code><a class="headerlink" href="#lmfit.model.ier" title="Permalink to this definition">¶</a></dt>
<dd><p>Integer returned code from <a class="reference external" href="https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.leastsq.html">scipy.optimize.leastsq</a>.</p>
</dd></dl>

<dl class="py attribute">
<dt id="lmfit.model.init_fit">
<code class="sig-name descname">init_fit</code><a class="headerlink" href="#lmfit.model.init_fit" title="Permalink to this definition">¶</a></dt>
<dd><p>numpy.ndarray result of model function, evaluated at provided
independent variables and with initial parameters.</p>
</dd></dl>

<dl class="py attribute">
<dt id="lmfit.model.init_params">
<code class="sig-name descname">init_params</code><a class="headerlink" href="#lmfit.model.init_params" title="Permalink to this definition">¶</a></dt>
<dd><p>Initial parameters.</p>
</dd></dl>

<dl class="py attribute">
<dt id="lmfit.model.init_values">
<code class="sig-name descname">init_values</code><a class="headerlink" href="#lmfit.model.init_values" title="Permalink to this definition">¶</a></dt>
<dd><p>Dictionary with parameter names as keys, and initial values as values.</p>
</dd></dl>

<dl class="py attribute">
<dt id="lmfit.model.iter_cb">
<code class="sig-name descname">iter_cb</code><a class="headerlink" href="#lmfit.model.iter_cb" title="Permalink to this definition">¶</a></dt>
<dd><p>Optional callable function, to be called at each fit iteration. This
must take take arguments of <code class="docutils literal notranslate"><span class="pre">(params,</span> <span class="pre">iter,</span> <span class="pre">resid,</span> <span class="pre">*args,</span> <span class="pre">**kws)</span></code>, where
<code class="docutils literal notranslate"><span class="pre">params</span></code> will have the current parameter values, <code class="docutils literal notranslate"><span class="pre">iter</span></code> the
iteration, <code class="docutils literal notranslate"><span class="pre">resid</span></code> the current residual array, and <code class="docutils literal notranslate"><span class="pre">*args</span></code> and
<code class="docutils literal notranslate"><span class="pre">**kws</span></code> as passed to the objective function. See <a class="reference internal" href="fitting.html#fit-itercb-label"><span class="std std-ref">Using a Iteration Callback Function</span></a>.</p>
</dd></dl>

<dl class="py attribute">
<dt id="lmfit.model.jacfcn">
<code class="sig-name descname">jacfcn</code><a class="headerlink" href="#lmfit.model.jacfcn" title="Permalink to this definition">¶</a></dt>
<dd><p>Optional callable function, to be called to calculate Jacobian array.</p>
</dd></dl>

<dl class="py attribute">
<dt id="lmfit.model.lmdif_message">
<code class="sig-name descname">lmdif_message</code><a class="headerlink" href="#lmfit.model.lmdif_message" title="Permalink to this definition">¶</a></dt>
<dd><p>String message returned from <a class="reference external" href="https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.leastsq.html">scipy.optimize.leastsq</a>.</p>
</dd></dl>

<dl class="py attribute">
<dt id="lmfit.model.message">
<code class="sig-name descname">message</code><a class="headerlink" href="#lmfit.model.message" title="Permalink to this definition">¶</a></dt>
<dd><p>String message returned from <a class="reference internal" href="fitting.html#lmfit.minimizer.minimize" title="lmfit.minimizer.minimize"><code class="xref py py-func docutils literal notranslate"><span class="pre">minimize()</span></code></a>.</p>
</dd></dl>

<dl class="py attribute">
<dt id="lmfit.model.method">
<code class="sig-name descname">method</code><a class="headerlink" href="#lmfit.model.method" title="Permalink to this definition">¶</a></dt>
<dd><p>String naming fitting method for <a class="reference internal" href="fitting.html#lmfit.minimizer.minimize" title="lmfit.minimizer.minimize"><code class="xref py py-func docutils literal notranslate"><span class="pre">minimize()</span></code></a>.</p>
</dd></dl>

<dl class="py attribute">
<dt id="lmfit.model.call_kws">
<code class="sig-name descname">call_kws</code><a class="headerlink" href="#lmfit.model.call_kws" title="Permalink to this definition">¶</a></dt>
<dd><p>Dict of keyword arguments actually send to underlying solver with
<a class="reference internal" href="fitting.html#lmfit.minimizer.minimize" title="lmfit.minimizer.minimize"><code class="xref py py-func docutils literal notranslate"><span class="pre">minimize()</span></code></a>.</p>
</dd></dl>

<dl class="py attribute">
<dt id="lmfit.model.model">
<code class="sig-name descname">model</code><a class="headerlink" href="#lmfit.model.model" title="Permalink to this definition">¶</a></dt>
<dd><p>Instance of <a class="reference internal" href="#lmfit.model.Model" title="lmfit.model.Model"><code class="xref py py-class docutils literal notranslate"><span class="pre">Model</span></code></a> used for model.</p>
</dd></dl>

<dl class="py attribute">
<dt id="lmfit.model.ndata">
<code class="sig-name descname">ndata</code><a class="headerlink" href="#lmfit.model.ndata" title="Permalink to this definition">¶</a></dt>
<dd><p>Integer number of data points.</p>
</dd></dl>

<dl class="py attribute">
<dt id="lmfit.model.nfev">
<code class="sig-name descname">nfev</code><a class="headerlink" href="#lmfit.model.nfev" title="Permalink to this definition">¶</a></dt>
<dd><p>Integer number of function evaluations used for fit.</p>
</dd></dl>

<dl class="py attribute">
<dt id="lmfit.model.nfree">
<code class="sig-name descname">nfree</code><a class="headerlink" href="#lmfit.model.nfree" title="Permalink to this definition">¶</a></dt>
<dd><p>Integer number of free parameters in fit.</p>
</dd></dl>

<dl class="py attribute">
<dt id="lmfit.model.nvarys">
<code class="sig-name descname">nvarys</code><a class="headerlink" href="#lmfit.model.nvarys" title="Permalink to this definition">¶</a></dt>
<dd><p>Integer number of independent, freely varying variables in fit.</p>
</dd></dl>

<dl class="py attribute">
<dt id="lmfit.model.params">
<code class="sig-name descname">params</code><a class="headerlink" href="#lmfit.model.params" title="Permalink to this definition">¶</a></dt>
<dd><p>Parameters used in fit; will contain the best-fit values.</p>
</dd></dl>

<dl class="py attribute">
<dt id="lmfit.model.redchi">
<code class="sig-name descname">redchi</code><a class="headerlink" href="#lmfit.model.redchi" title="Permalink to this definition">¶</a></dt>
<dd><p>Floating point reduced chi-square statistic (see <a class="reference internal" href="fitting.html#fit-results-label"><span class="std std-ref">MinimizerResult – the optimization result</span></a>).</p>
</dd></dl>

<dl class="py attribute">
<dt id="lmfit.model.residual">
<code class="sig-name descname">residual</code><a class="headerlink" href="#lmfit.model.residual" title="Permalink to this definition">¶</a></dt>
<dd><p>numpy.ndarray for residual.</p>
</dd></dl>

<dl class="py attribute">
<dt id="lmfit.model.scale_covar">
<code class="sig-name descname">scale_covar</code><a class="headerlink" href="#lmfit.model.scale_covar" title="Permalink to this definition">¶</a></dt>
<dd><p>Boolean flag for whether to automatically scale covariance matrix.</p>
</dd></dl>

<dl class="py attribute">
<dt id="lmfit.model.success">
<code class="sig-name descname">success</code><a class="headerlink" href="#lmfit.model.success" title="Permalink to this definition">¶</a></dt>
<dd><p>Boolean value of whether fit succeeded.</p>
</dd></dl>

<dl class="py attribute">
<dt id="lmfit.model.weights">
<code class="sig-name descname">weights</code><a class="headerlink" href="#lmfit.model.weights" title="Permalink to this definition">¶</a></dt>
<dd><p>numpy.ndarray (or <code class="docutils literal notranslate"><span class="pre">None</span></code>) of weighting values to be used in fit. If not
<code class="docutils literal notranslate"><span class="pre">None</span></code>, it will be used as a multiplicative factor of the residual
array, so that <code class="docutils literal notranslate"><span class="pre">weights*(data</span> <span class="pre">-</span> <span class="pre">fit)</span></code> is minimized in the
least-squares sense.</p>
</dd></dl>

</div>
<div class="section" id="calculating-uncertainties-in-the-model-function">
<h3>Calculating uncertainties in the model function<a class="headerlink" href="#calculating-uncertainties-in-the-model-function" title="Permalink to this headline">¶</a></h3>
<p>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
<a class="reference internal" href="#lmfit.model.ModelResult.eval_uncertainty" title="lmfit.model.ModelResult.eval_uncertainty"><code class="xref py py-meth docutils literal notranslate"><span class="pre">ModelResult.eval_uncertainty()</span></code></a> method of the model result object to
evaluate the uncertainty in the model with a specified level for
<span class="math notranslate nohighlight">\(\sigma\)</span>.</p>
<p>That is, adding:</p>
<div class="jupyter_cell docutils container">
<div class="cell_output docutils container">
</div>
</div>
<div class="jupyter_cell jupyter_container docutils container">
<div class="cell_input code_cell docutils container">
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">dely</span> <span class="o">=</span> <span class="n">result</span><span class="o">.</span><span class="n">eval_uncertainty</span><span class="p">(</span><span class="n">sigma</span><span class="o">=</span><span class="mi">3</span><span class="p">)</span>
<span class="n">plt</span><span class="o">.</span><span class="n">fill_between</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">result</span><span class="o">.</span><span class="n">best_fit</span><span class="o">-</span><span class="n">dely</span><span class="p">,</span> <span class="n">result</span><span class="o">.</span><span class="n">best_fit</span><span class="o">+</span><span class="n">dely</span><span class="p">,</span> <span class="n">color</span><span class="o">=</span><span class="s2">&quot;#ABABAB&quot;</span><span class="p">,</span>
                 <span class="n">label</span><span class="o">=</span><span class="s1">&#39;3-$\sigma$ uncertainty band&#39;</span><span class="p">)</span>
</pre></div>
</div>
</div>
<div class="cell_output docutils container">
</div>
</div>
<p>to the example fit to the Gaussian at the beginning of this chapter will
give 3-<span class="math notranslate nohighlight">\(\sigma\)</span> bands for the best-fit Gaussian, and produce the
figure below.</p>
<div class="jupyter_cell docutils container">
<div class="cell_output docutils container">
<img alt="_images/model_30_0.svg" src="_images/model_30_0.svg" /></div>
</div>
</div>
<div class="section" id="saving-and-loading-modelresults">
<span id="modelresult-saveload-sec"></span><h3>Saving and Loading ModelResults<a class="headerlink" href="#saving-and-loading-modelresults" title="Permalink to this headline">¶</a></h3>
<div class="versionadded">
<p><span class="versionmodified added">New in version 0.9.8.</span></p>
</div>
<p>As with saving models (see section <a class="reference internal" href="#model-saveload-sec"><span class="std std-ref">Saving and Loading Models</span></a>), it is
sometimes desirable to save a <a class="reference internal" href="#lmfit.model.ModelResult" title="lmfit.model.ModelResult"><code class="xref py py-class docutils literal notranslate"><span class="pre">ModelResult</span></code></a>, either for later use or
to organize and compare different fit results. Lmfit provides a
<a class="reference internal" href="#lmfit.model.save_modelresult" title="lmfit.model.save_modelresult"><code class="xref py py-func docutils literal notranslate"><span class="pre">save_modelresult()</span></code></a> function that will save a <a class="reference internal" href="#lmfit.model.ModelResult" title="lmfit.model.ModelResult"><code class="xref py py-class docutils literal notranslate"><span class="pre">ModelResult</span></code></a> to
a file. There is also a companion <a class="reference internal" href="#lmfit.model.load_modelresult" title="lmfit.model.load_modelresult"><code class="xref py py-func docutils literal notranslate"><span class="pre">load_modelresult()</span></code></a> function that
can read this file and reconstruct a <a class="reference internal" href="#lmfit.model.ModelResult" title="lmfit.model.ModelResult"><code class="xref py py-class docutils literal notranslate"><span class="pre">ModelResult</span></code></a> from it.</p>
<p>As discussed in section <a class="reference internal" href="#model-saveload-sec"><span class="std std-ref">Saving and Loading Models</span></a>, there are challenges to
saving model functions that may make it difficult to restore a saved a
<a class="reference internal" href="#lmfit.model.ModelResult" title="lmfit.model.ModelResult"><code class="xref py py-class docutils literal notranslate"><span class="pre">ModelResult</span></code></a> in a way that can be used to perform a fit.
Use of the optional <code class="xref py py-attr docutils literal notranslate"><span class="pre">funcdefs</span></code> argument is generally the most
reliable way to ensure that a loaded <a class="reference internal" href="#lmfit.model.ModelResult" title="lmfit.model.ModelResult"><code class="xref py py-class docutils literal notranslate"><span class="pre">ModelResult</span></code></a> can be used to
evaluate the model function or redo the fit.</p>
<dl class="py function">
<dt id="lmfit.model.save_modelresult">
<code class="sig-name descname">save_modelresult</code><span class="sig-paren">(</span><em class="sig-param"><span class="n">modelresult</span></em>, <em class="sig-param"><span class="n">fname</span></em><span class="sig-paren">)</span><a class="headerlink" href="#lmfit.model.save_modelresult" title="Permalink to this definition">¶</a></dt>
<dd><p>Save a ModelResult to a file.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>modelresult</strong> (<a class="reference internal" href="#lmfit.model.ModelResult" title="lmfit.model.ModelResult"><em>ModelResult</em></a>) – ModelResult to be saved.</p></li>
<li><p><strong>fname</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.9)"><em>str</em></a>) – Name of file for saved ModelResult.</p></li>
</ul>
</dd>
</dl>
</dd></dl>

<dl class="py function">
<dt id="lmfit.model.load_modelresult">
<code class="sig-name descname">load_modelresult</code><span class="sig-paren">(</span><em class="sig-param"><span class="n">fname</span></em>, <em class="sig-param"><span class="n">funcdefs</span><span class="o">=</span><span class="default_value">None</span></em><span class="sig-paren">)</span><a class="headerlink" href="#lmfit.model.load_modelresult" title="Permalink to this definition">¶</a></dt>
<dd><p>Load a saved ModelResult from a file.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>fname</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.9)"><em>str</em></a>) – Name of file containing saved ModelResult.</p></li>
<li><p><strong>funcdefs</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#dict" title="(in Python v3.9)"><em>dict</em></a><em>, </em><em>optional</em>) – Dictionary of custom function names and definitions.</p></li>
</ul>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p>ModelResult object loaded from file.</p>
</dd>
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p><a class="reference internal" href="#lmfit.model.ModelResult" title="lmfit.model.ModelResult">ModelResult</a></p>
</dd>
</dl>
</dd></dl>

<p>An example of saving a <a class="reference internal" href="#lmfit.model.ModelResult" title="lmfit.model.ModelResult"><code class="xref py py-class docutils literal notranslate"><span class="pre">ModelResult</span></code></a> is:</p>
<div class="jupyter_cell jupyter_container docutils container">
<div class="cell_input code_cell docutils container">
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="c1"># &lt;examples/doc_model_savemodelresult.py&gt;</span>
<span class="kn">import</span> <span class="nn">numpy</span> <span class="k">as</span> <span class="nn">np</span>

<span class="kn">from</span> <span class="nn">lmfit.model</span> <span class="kn">import</span> <span class="n">save_modelresult</span>
<span class="kn">from</span> <span class="nn">lmfit.models</span> <span class="kn">import</span> <span class="n">GaussianModel</span>

<span class="n">data</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">loadtxt</span><span class="p">(</span><span class="s1">&#39;model1d_gauss.dat&#39;</span><span class="p">)</span>
<span class="n">x</span> <span class="o">=</span> <span class="n">data</span><span class="p">[:,</span> <span class="mi">0</span><span class="p">]</span>
<span class="n">y</span> <span class="o">=</span> <span class="n">data</span><span class="p">[:,</span> <span class="mi">1</span><span class="p">]</span>

<span class="n">gmodel</span> <span class="o">=</span> <span class="n">GaussianModel</span><span class="p">()</span>
<span class="n">result</span> <span class="o">=</span> <span class="n">gmodel</span><span class="o">.</span><span class="n">fit</span><span class="p">(</span><span class="n">y</span><span class="p">,</span> <span class="n">x</span><span class="o">=</span><span class="n">x</span><span class="p">,</span> <span class="n">amplitude</span><span class="o">=</span><span class="mi">5</span><span class="p">,</span> <span class="n">center</span><span class="o">=</span><span class="mi">5</span><span class="p">,</span> <span class="n">sigma</span><span class="o">=</span><span class="mi">1</span><span class="p">)</span>

<span class="n">save_modelresult</span><span class="p">(</span><span class="n">result</span><span class="p">,</span> <span class="s1">&#39;gauss_modelresult.sav&#39;</span><span class="p">)</span>

<span class="nb">print</span><span class="p">(</span><span class="n">result</span><span class="o">.</span><span class="n">fit_report</span><span class="p">())</span>
<span class="c1"># &lt;end examples/doc_model_savemodelresult.py&gt;</span>
</pre></div>
</div>
</div>
<div class="cell_output docutils container">
</div>
</div>
<p>To load that later, one might do:</p>
<div class="jupyter_cell jupyter_container docutils container">
<div class="cell_input code_cell docutils container">
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="c1"># &lt;examples/doc_model_loadmodelresult.py&gt;</span>
<span class="kn">import</span> <span class="nn">matplotlib.pyplot</span> <span class="k">as</span> <span class="nn">plt</span>
<span class="kn">import</span> <span class="nn">numpy</span> <span class="k">as</span> <span class="nn">np</span>

<span class="kn">from</span> <span class="nn">lmfit.model</span> <span class="kn">import</span> <span class="n">load_modelresult</span>

<span class="n">data</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">loadtxt</span><span class="p">(</span><span class="s1">&#39;model1d_gauss.dat&#39;</span><span class="p">)</span>
<span class="n">x</span> <span class="o">=</span> <span class="n">data</span><span class="p">[:,</span> <span class="mi">0</span><span class="p">]</span>
<span class="n">y</span> <span class="o">=</span> <span class="n">data</span><span class="p">[:,</span> <span class="mi">1</span><span class="p">]</span>

<span class="n">result</span> <span class="o">=</span> <span class="n">load_modelresult</span><span class="p">(</span><span class="s1">&#39;gauss_modelresult.sav&#39;</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="n">result</span><span class="o">.</span><span class="n">fit_report</span><span class="p">())</span>

<span class="n">plt</span><span class="o">.</span><span class="n">plot</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">,</span> <span class="s1">&#39;bo&#39;</span><span class="p">)</span>
<span class="n">plt</span><span class="o">.</span><span class="n">plot</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">result</span><span class="o">.</span><span class="n">best_fit</span><span class="p">,</span> <span class="s1">&#39;r-&#39;</span><span class="p">)</span>
<span class="n">plt</span><span class="o">.</span><span class="n">show</span><span class="p">()</span>
<span class="c1"># &lt;end examples/doc_model_loadmodelresult.py&gt;</span>
</pre></div>
</div>
</div>
<div class="cell_output docutils container">
</div>
</div>
</div>
</div>
<div class="section" id="composite-models-adding-or-multiplying-models">
<span id="composite-models-section"></span><span id="index-0"></span><h2>Composite Models : adding (or multiplying) Models<a class="headerlink" href="#composite-models-adding-or-multiplying-models" title="Permalink to this headline">¶</a></h2>
<p>One of the more interesting features of the <a class="reference internal" href="#lmfit.model.Model" title="lmfit.model.Model"><code class="xref py py-class docutils literal notranslate"><span class="pre">Model</span></code></a> class is that
Models can be added together or combined with basic algebraic operations
(add, subtract, multiply, and divide) to give a composite model. The
composite model will have parameters from each of the component models,
with all parameters being available to influence the whole model. This
ability to combine models will become even more useful in the next chapter,
when pre-built subclasses of <a class="reference internal" href="#lmfit.model.Model" title="lmfit.model.Model"><code class="xref py py-class docutils literal notranslate"><span class="pre">Model</span></code></a> are discussed. For now, we’ll
consider a simple example, and build a model of a Gaussian plus a line, as
to model a peak with a background. For such a simple problem, we could just
build a model that included both components:</p>
<div class="jupyter_cell jupyter_container docutils container">
<div class="cell_input code_cell docutils container">
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">gaussian_plus_line</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">amp</span><span class="p">,</span> <span class="n">cen</span><span class="p">,</span> <span class="n">wid</span><span class="p">,</span> <span class="n">slope</span><span class="p">,</span> <span class="n">intercept</span><span class="p">):</span>
    <span class="sd">&quot;&quot;&quot;line + 1-d gaussian&quot;&quot;&quot;</span>

    <span class="n">gauss</span> <span class="o">=</span> <span class="p">(</span><span class="n">amp</span> <span class="o">/</span> <span class="p">(</span><span class="n">sqrt</span><span class="p">(</span><span class="mi">2</span><span class="o">*</span><span class="n">pi</span><span class="p">)</span> <span class="o">*</span> <span class="n">wid</span><span class="p">))</span> <span class="o">*</span> <span class="n">exp</span><span class="p">(</span><span class="o">-</span><span class="p">(</span><span class="n">x</span><span class="o">-</span><span class="n">cen</span><span class="p">)</span><span class="o">**</span><span class="mi">2</span> <span class="o">/</span> <span class="p">(</span><span class="mi">2</span><span class="o">*</span><span class="n">wid</span><span class="o">**</span><span class="mi">2</span><span class="p">))</span>
    <span class="n">line</span> <span class="o">=</span> <span class="n">slope</span><span class="o">*</span><span class="n">x</span> <span class="o">+</span> <span class="n">intercept</span>
    <span class="k">return</span> <span class="n">gauss</span> <span class="o">+</span> <span class="n">line</span>
</pre></div>
</div>
</div>
<div class="cell_output docutils container">
</div>
</div>
<p>and use that with:</p>
<div class="jupyter_cell jupyter_container docutils container">
<div class="cell_input code_cell docutils container">
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">mod</span> <span class="o">=</span> <span class="n">Model</span><span class="p">(</span><span class="n">gaussian_plus_line</span><span class="p">)</span>
</pre></div>
</div>
</div>
<div class="cell_output docutils container">
</div>
</div>
<p>But we already had a function for a gaussian function, and maybe we’ll
discover that a linear background isn’t sufficient which would mean the
model function would have to be changed.</p>
<p>Instead, lmfit allows models to be combined into a <a class="reference internal" href="#lmfit.model.CompositeModel" title="lmfit.model.CompositeModel"><code class="xref py py-class docutils literal notranslate"><span class="pre">CompositeModel</span></code></a>.
As an alternative to including a linear background in our model function,
we could define a linear function:</p>
<div class="jupyter_cell jupyter_container docutils container">
<div class="cell_input code_cell docutils container">
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">line</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">slope</span><span class="p">,</span> <span class="n">intercept</span><span class="p">):</span>
    <span class="sd">&quot;&quot;&quot;a line&quot;&quot;&quot;</span>
    <span class="k">return</span> <span class="n">slope</span><span class="o">*</span><span class="n">x</span> <span class="o">+</span> <span class="n">intercept</span>
</pre></div>
</div>
</div>
<div class="cell_output docutils container">
</div>
</div>
<p>and build a composite model with just:</p>
<div class="jupyter_cell jupyter_container docutils container">
<div class="cell_input code_cell docutils container">
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">mod</span> <span class="o">=</span> <span class="n">Model</span><span class="p">(</span><span class="n">gaussian</span><span class="p">)</span> <span class="o">+</span> <span class="n">Model</span><span class="p">(</span><span class="n">line</span><span class="p">)</span>
</pre></div>
</div>
</div>
<div class="cell_output docutils container">
</div>
</div>
<p>This model has parameters for both component models, and can be used as:</p>
<div class="jupyter_cell jupyter_container docutils container">
<div class="cell_input code_cell docutils container">
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="c1"># &lt;examples/doc_model_two_components.py&gt;</span>
<span class="kn">import</span> <span class="nn">matplotlib.pyplot</span> <span class="k">as</span> <span class="nn">plt</span>
<span class="kn">from</span> <span class="nn">numpy</span> <span class="kn">import</span> <span class="n">exp</span><span class="p">,</span> <span class="n">loadtxt</span><span class="p">,</span> <span class="n">pi</span><span class="p">,</span> <span class="n">sqrt</span>

<span class="kn">from</span> <span class="nn">lmfit</span> <span class="kn">import</span> <span class="n">Model</span>

<span class="n">data</span> <span class="o">=</span> <span class="n">loadtxt</span><span class="p">(</span><span class="s1">&#39;model1d_gauss.dat&#39;</span><span class="p">)</span>
<span class="n">x</span> <span class="o">=</span> <span class="n">data</span><span class="p">[:,</span> <span class="mi">0</span><span class="p">]</span>
<span class="n">y</span> <span class="o">=</span> <span class="n">data</span><span class="p">[:,</span> <span class="mi">1</span><span class="p">]</span> <span class="o">+</span> <span class="mf">0.25</span><span class="o">*</span><span class="n">x</span> <span class="o">-</span> <span class="mf">1.0</span>


<span class="k">def</span> <span class="nf">gaussian</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">amp</span><span class="p">,</span> <span class="n">cen</span><span class="p">,</span> <span class="n">wid</span><span class="p">):</span>
    <span class="sd">&quot;&quot;&quot;1-d gaussian: gaussian(x, amp, cen, wid)&quot;&quot;&quot;</span>
    <span class="k">return</span> <span class="p">(</span><span class="n">amp</span> <span class="o">/</span> <span class="p">(</span><span class="n">sqrt</span><span class="p">(</span><span class="mi">2</span><span class="o">*</span><span class="n">pi</span><span class="p">)</span> <span class="o">*</span> <span class="n">wid</span><span class="p">))</span> <span class="o">*</span> <span class="n">exp</span><span class="p">(</span><span class="o">-</span><span class="p">(</span><span class="n">x</span><span class="o">-</span><span class="n">cen</span><span class="p">)</span><span class="o">**</span><span class="mi">2</span> <span class="o">/</span> <span class="p">(</span><span class="mi">2</span><span class="o">*</span><span class="n">wid</span><span class="o">**</span><span class="mi">2</span><span class="p">))</span>


<span class="k">def</span> <span class="nf">line</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">slope</span><span class="p">,</span> <span class="n">intercept</span><span class="p">):</span>
    <span class="sd">&quot;&quot;&quot;a line&quot;&quot;&quot;</span>
    <span class="k">return</span> <span class="n">slope</span><span class="o">*</span><span class="n">x</span> <span class="o">+</span> <span class="n">intercept</span>


<span class="n">mod</span> <span class="o">=</span> <span class="n">Model</span><span class="p">(</span><span class="n">gaussian</span><span class="p">)</span> <span class="o">+</span> <span class="n">Model</span><span class="p">(</span><span class="n">line</span><span class="p">)</span>
<span class="n">pars</span> <span class="o">=</span> <span class="n">mod</span><span class="o">.</span><span class="n">make_params</span><span class="p">(</span><span class="n">amp</span><span class="o">=</span><span class="mi">5</span><span class="p">,</span> <span class="n">cen</span><span class="o">=</span><span class="mi">5</span><span class="p">,</span> <span class="n">wid</span><span class="o">=</span><span class="mi">1</span><span class="p">,</span> <span class="n">slope</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">intercept</span><span class="o">=</span><span class="mi">1</span><span class="p">)</span>

<span class="n">result</span> <span class="o">=</span> <span class="n">mod</span><span class="o">.</span><span class="n">fit</span><span class="p">(</span><span class="n">y</span><span class="p">,</span> <span class="n">pars</span><span class="p">,</span> <span class="n">x</span><span class="o">=</span><span class="n">x</span><span class="p">)</span>

<span class="nb">print</span><span class="p">(</span><span class="n">result</span><span class="o">.</span><span class="n">fit_report</span><span class="p">())</span>

<span class="n">plt</span><span class="o">.</span><span class="n">plot</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">,</span> <span class="s1">&#39;bo&#39;</span><span class="p">)</span>
<span class="n">plt</span><span class="o">.</span><span class="n">plot</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">result</span><span class="o">.</span><span class="n">init_fit</span><span class="p">,</span> <span class="s1">&#39;k--&#39;</span><span class="p">,</span> <span class="n">label</span><span class="o">=</span><span class="s1">&#39;initial fit&#39;</span><span class="p">)</span>
<span class="n">plt</span><span class="o">.</span><span class="n">plot</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">result</span><span class="o">.</span><span class="n">best_fit</span><span class="p">,</span> <span class="s1">&#39;r-&#39;</span><span class="p">,</span> <span class="n">label</span><span class="o">=</span><span class="s1">&#39;best fit&#39;</span><span class="p">)</span>
<span class="n">plt</span><span class="o">.</span><span class="n">legend</span><span class="p">(</span><span class="n">loc</span><span class="o">=</span><span class="s1">&#39;best&#39;</span><span class="p">)</span>
<span class="n">plt</span><span class="o">.</span><span class="n">show</span><span class="p">()</span>
<span class="c1"># &lt;end examples/doc_model_two_components.py&gt;</span>
</pre></div>
</div>
</div>
<div class="cell_output docutils container">
</div>
</div>
<p>which prints out the results:</p>
<div class="jupyter_cell docutils container">
<div class="cell_output docutils container">
<div class="output stream highlight-none notranslate"><div class="highlight"><pre><span></span>[[Model]]
    (Model(gaussian) + Model(line))
[[Fit Statistics]]
    # fitting method   = leastsq
    # function evals   = 44
    # data points      = 101
    # variables        = 5
    chi-square         = 2.57855517
    reduced chi-square = 0.02685995
    Akaike info crit   = -360.457020
    Bayesian info crit = -347.381417
[[Variables]]
    amp:        8.45931062 +/- 0.12414515 (1.47%) (init = 5)
    cen:        5.65547873 +/- 0.00917678 (0.16%) (init = 5)
    wid:        0.67545524 +/- 0.00991686 (1.47%) (init = 1)
    slope:      0.26484404 +/- 0.00574892 (2.17%) (init = 0)
    intercept: -0.96860202 +/- 0.03352202 (3.46%) (init = 1)
[[Correlations]] (unreported correlations are &lt; 0.100)
    C(slope, intercept) = -0.795
    C(amp, wid)         =  0.666
    C(amp, intercept)   = -0.222
    C(amp, slope)       = -0.169
    C(cen, slope)       = -0.162
    C(wid, intercept)   = -0.148
    C(cen, intercept)   =  0.129
    C(wid, slope)       = -0.113
</pre></div>
</div>
</div>
</div>
<p>and shows the plot on the left.</p>
<div class="jupyter_cell docutils container">
<div class="cell_output docutils container">
<img alt="_images/model_39_0.svg" src="_images/model_39_0.svg" /></div>
</div>
<p>On the left, data is shown in blue dots, the total fit is shown in solid
red line, and the initial fit is shown as a black dashed line. The figure
on the right shows again the data in blue dots, the Gaussian component as
a black dashed line and the linear component as a red dashed line. It is
created using the following code:</p>
<div class="jupyter_cell jupyter_container docutils container">
<div class="cell_input code_cell docutils container">
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">comps</span> <span class="o">=</span> <span class="n">result</span><span class="o">.</span><span class="n">eval_components</span><span class="p">()</span>
<span class="n">plt</span><span class="o">.</span><span class="n">plot</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">,</span> <span class="s1">&#39;bo&#39;</span><span class="p">)</span>
<span class="n">plt</span><span class="o">.</span><span class="n">plot</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">comps</span><span class="p">[</span><span class="s1">&#39;gaussian&#39;</span><span class="p">],</span> <span class="s1">&#39;k--&#39;</span><span class="p">,</span> <span class="n">label</span><span class="o">=</span><span class="s1">&#39;Gaussian component&#39;</span><span class="p">)</span>
<span class="n">plt</span><span class="o">.</span><span class="n">plot</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">comps</span><span class="p">[</span><span class="s1">&#39;line&#39;</span><span class="p">],</span> <span class="s1">&#39;r--&#39;</span><span class="p">,</span> <span class="n">label</span><span class="o">=</span><span class="s1">&#39;Line component&#39;</span><span class="p">)</span>
</pre></div>
</div>
</div>
<div class="cell_output docutils container">
</div>
</div>
<p>The components were generated after the fit using the
<a class="reference internal" href="#lmfit.model.ModelResult.eval_components" title="lmfit.model.ModelResult.eval_components"><code class="xref py py-meth docutils literal notranslate"><span class="pre">ModelResult.eval_components()</span></code></a> method of the <code class="docutils literal notranslate"><span class="pre">result</span></code>, which returns
a dictionary of the components, using keys of the model name
(or <code class="docutils literal notranslate"><span class="pre">prefix</span></code> if that is set). This will use the parameter values in
<code class="docutils literal notranslate"><span class="pre">result.params</span></code> and the independent variables (<code class="docutils literal notranslate"><span class="pre">x</span></code>) used during the
fit. Note that while the <a class="reference internal" href="#lmfit.model.ModelResult" title="lmfit.model.ModelResult"><code class="xref py py-class docutils literal notranslate"><span class="pre">ModelResult</span></code></a> held in <code class="docutils literal notranslate"><span class="pre">result</span></code> does store the
best parameters and the best estimate of the model in <code class="docutils literal notranslate"><span class="pre">result.best_fit</span></code>,
the original model and parameters in <code class="docutils literal notranslate"><span class="pre">pars</span></code> are left unaltered.</p>
<p>You can apply this composite model to other data sets, or evaluate the
model at other values of <code class="docutils literal notranslate"><span class="pre">x</span></code>. You may want to do this to give a finer or
coarser spacing of data point, or to extrapolate the model outside the
fitting range. This can be done with:</p>
<div class="jupyter_cell jupyter_container docutils container">
<div class="cell_input code_cell docutils container">
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">xwide</span> <span class="o">=</span> <span class="n">linspace</span><span class="p">(</span><span class="o">-</span><span class="mi">5</span><span class="p">,</span> <span class="mi">25</span><span class="p">,</span> <span class="mi">3001</span><span class="p">)</span>
<span class="n">predicted</span> <span class="o">=</span> <span class="n">mod</span><span class="o">.</span><span class="n">eval</span><span class="p">(</span><span class="n">result</span><span class="o">.</span><span class="n">params</span><span class="p">,</span> <span class="n">x</span><span class="o">=</span><span class="n">xwide</span><span class="p">)</span>
</pre></div>
</div>
</div>
<div class="cell_output docutils container">
</div>
</div>
<p>In this example, the argument names for the model functions do not overlap.
If they had, the <code class="docutils literal notranslate"><span class="pre">prefix</span></code> argument to <a class="reference internal" href="#lmfit.model.Model" title="lmfit.model.Model"><code class="xref py py-class docutils literal notranslate"><span class="pre">Model</span></code></a> would have allowed
us to identify which parameter went with which component model. As we will
see in the next chapter, using composite models with the built-in models
provides a simple way to build up complex models.</p>
<dl class="py class">
<dt id="lmfit.model.CompositeModel">
<em class="property">class </em><code class="sig-name descname">CompositeModel</code><span class="sig-paren">(</span><em class="sig-param">left</em>, <em class="sig-param">right</em>, <em class="sig-param">op</em><span class="optional">[</span>, <em class="sig-param">**kws</em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#lmfit.model.CompositeModel" title="Permalink to this definition">¶</a></dt>
<dd><p>Combine two models (<cite>left</cite> and <cite>right</cite>) with binary operator (<cite>op</cite>).</p>
<p>Normally, one does not have to explicitly create a <cite>CompositeModel</cite>,
but can use normal Python operators <code class="docutils literal notranslate"><span class="pre">+</span></code>, <code class="docutils literal notranslate"><span class="pre">-</span></code>, <code class="docutils literal notranslate"><span class="pre">*</span></code>, and <code class="docutils literal notranslate"><span class="pre">/</span></code> to
combine components as in:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">mod</span> <span class="o">=</span> <span class="n">Model</span><span class="p">(</span><span class="n">fcn1</span><span class="p">)</span> <span class="o">+</span> <span class="n">Model</span><span class="p">(</span><span class="n">fcn2</span><span class="p">)</span> <span class="o">*</span> <span class="n">Model</span><span class="p">(</span><span class="n">fcn3</span><span class="p">)</span>
</pre></div>
</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>left</strong> (<a class="reference internal" href="#lmfit.model.Model" title="lmfit.model.Model"><em>Model</em></a>) – Left-hand model.</p></li>
<li><p><strong>right</strong> (<a class="reference internal" href="#lmfit.model.Model" title="lmfit.model.Model"><em>Model</em></a>) – Right-hand model.</p></li>
<li><p><strong>op</strong> (<em>callable binary operator</em>) – Operator to combine <cite>left</cite> and <cite>right</cite> models.</p></li>
<li><p><strong>**kws</strong> (<em>optional</em>) – Additional keywords are passed to <cite>Model</cite> when creating this
new model.</p></li>
</ul>
</dd>
</dl>
<p class="rubric">Notes</p>
<p>The two models must use the same independent variable.</p>
</dd></dl>

<p>Note that when using built-in Python binary operators, a
<a class="reference internal" href="#lmfit.model.CompositeModel" title="lmfit.model.CompositeModel"><code class="xref py py-class docutils literal notranslate"><span class="pre">CompositeModel</span></code></a> will automatically be constructed for you. That is,
doing:</p>
<div class="jupyter_cell docutils container">
<div class="cell_output docutils container">
</div>
</div>
<div class="jupyter_cell jupyter_container docutils container">
<div class="cell_input code_cell docutils container">
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">mod</span> <span class="o">=</span> <span class="n">Model</span><span class="p">(</span><span class="n">fcn1</span><span class="p">)</span> <span class="o">+</span> <span class="n">Model</span><span class="p">(</span><span class="n">fcn2</span><span class="p">)</span> <span class="o">*</span> <span class="n">Model</span><span class="p">(</span><span class="n">fcn3</span><span class="p">)</span>
</pre></div>
</div>
</div>
<div class="cell_output docutils container">
</div>
</div>
<p>will create a <a class="reference internal" href="#lmfit.model.CompositeModel" title="lmfit.model.CompositeModel"><code class="xref py py-class docutils literal notranslate"><span class="pre">CompositeModel</span></code></a>. Here, <code class="docutils literal notranslate"><span class="pre">left</span></code> will be <code class="docutils literal notranslate"><span class="pre">Model(fcn1)</span></code>,
<code class="docutils literal notranslate"><span class="pre">op</span></code> will be <code class="xref py py-meth docutils literal notranslate"><span class="pre">operator.add()</span></code>, and <code class="docutils literal notranslate"><span class="pre">right</span></code> will be another
CompositeModel that has a <code class="docutils literal notranslate"><span class="pre">left</span></code> attribute of <code class="docutils literal notranslate"><span class="pre">Model(fcn2)</span></code>, an <code class="docutils literal notranslate"><span class="pre">op</span></code> of
<code class="xref py py-meth docutils literal notranslate"><span class="pre">operator.mul()</span></code>, and a <code class="docutils literal notranslate"><span class="pre">right</span></code> of <code class="docutils literal notranslate"><span class="pre">Model(fcn3)</span></code>.</p>
<p>To use a binary operator other than <code class="docutils literal notranslate"><span class="pre">+</span></code>, <code class="docutils literal notranslate"><span class="pre">-</span></code>, <code class="docutils literal notranslate"><span class="pre">*</span></code>, or <code class="docutils literal notranslate"><span class="pre">/</span></code> you can
explicitly create a <a class="reference internal" href="#lmfit.model.CompositeModel" title="lmfit.model.CompositeModel"><code class="xref py py-class docutils literal notranslate"><span class="pre">CompositeModel</span></code></a> with the appropriate binary
operator. For example, to convolve two models, you could define a simple
convolution function, perhaps as:</p>
<div class="jupyter_cell jupyter_container docutils container">
<div class="cell_input code_cell docutils container">
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="kn">import</span> <span class="nn">numpy</span> <span class="k">as</span> <span class="nn">np</span>

<span class="k">def</span> <span class="nf">convolve</span><span class="p">(</span><span class="n">dat</span><span class="p">,</span> <span class="n">kernel</span><span class="p">):</span>
    <span class="sd">&quot;&quot;&quot;simple convolution of two arrays&quot;&quot;&quot;</span>
    <span class="n">npts</span> <span class="o">=</span> <span class="nb">min</span><span class="p">(</span><span class="nb">len</span><span class="p">(</span><span class="n">dat</span><span class="p">),</span> <span class="nb">len</span><span class="p">(</span><span class="n">kernel</span><span class="p">))</span>
    <span class="n">pad</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">ones</span><span class="p">(</span><span class="n">npts</span><span class="p">)</span>
    <span class="n">tmp</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">concatenate</span><span class="p">((</span><span class="n">pad</span><span class="o">*</span><span class="n">dat</span><span class="p">[</span><span class="mi">0</span><span class="p">],</span> <span class="n">dat</span><span class="p">,</span> <span class="n">pad</span><span class="o">*</span><span class="n">dat</span><span class="p">[</span><span class="o">-</span><span class="mi">1</span><span class="p">]))</span>
    <span class="n">out</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">convolve</span><span class="p">(</span><span class="n">tmp</span><span class="p">,</span> <span class="n">kernel</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">&#39;valid&#39;</span><span class="p">)</span>
    <span class="n">noff</span> <span class="o">=</span> <span class="nb">int</span><span class="p">((</span><span class="nb">len</span><span class="p">(</span><span class="n">out</span><span class="p">)</span> <span class="o">-</span> <span class="n">npts</span><span class="p">)</span> <span class="o">/</span> <span class="mi">2</span><span class="p">)</span>
    <span class="k">return</span> <span class="p">(</span><span class="n">out</span><span class="p">[</span><span class="n">noff</span><span class="p">:])[:</span><span class="n">npts</span><span class="p">]</span>
</pre></div>
</div>
</div>
<div class="cell_output docutils container">
</div>
</div>
<p>which extends the data in both directions so that the convolving kernel
function gives a valid result over the data range. Because this function
takes two array arguments and returns an array, it can be used as the
binary operator. A full script using this technique is here:</p>
<div class="jupyter_cell jupyter_container docutils container">
<div class="cell_input code_cell docutils container">
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="c1"># &lt;examples/doc_model_composite.py&gt;</span>
<span class="kn">import</span> <span class="nn">matplotlib.pyplot</span> <span class="k">as</span> <span class="nn">plt</span>
<span class="kn">import</span> <span class="nn">numpy</span> <span class="k">as</span> <span class="nn">np</span>

<span class="kn">from</span> <span class="nn">lmfit</span> <span class="kn">import</span> <span class="n">CompositeModel</span><span class="p">,</span> <span class="n">Model</span>
<span class="kn">from</span> <span class="nn">lmfit.lineshapes</span> <span class="kn">import</span> <span class="n">gaussian</span><span class="p">,</span> <span class="n">step</span>

<span class="c1"># create data from broadened step</span>
<span class="n">x</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">linspace</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">10</span><span class="p">,</span> <span class="mi">201</span><span class="p">)</span>
<span class="n">y</span> <span class="o">=</span> <span class="n">step</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">amplitude</span><span class="o">=</span><span class="mf">12.5</span><span class="p">,</span> <span class="n">center</span><span class="o">=</span><span class="mf">4.5</span><span class="p">,</span> <span class="n">sigma</span><span class="o">=</span><span class="mf">0.88</span><span class="p">,</span> <span class="n">form</span><span class="o">=</span><span class="s1">&#39;erf&#39;</span><span class="p">)</span>
<span class="n">np</span><span class="o">.</span><span class="n">random</span><span class="o">.</span><span class="n">seed</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span>
<span class="n">y</span> <span class="o">=</span> <span class="n">y</span> <span class="o">+</span> <span class="n">np</span><span class="o">.</span><span class="n">random</span><span class="o">.</span><span class="n">normal</span><span class="p">(</span><span class="n">scale</span><span class="o">=</span><span class="mf">0.35</span><span class="p">,</span> <span class="n">size</span><span class="o">=</span><span class="n">x</span><span class="o">.</span><span class="n">size</span><span class="p">)</span>


<span class="k">def</span> <span class="nf">jump</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">mid</span><span class="p">):</span>
    <span class="sd">&quot;&quot;&quot;Heaviside step function.&quot;&quot;&quot;</span>
    <span class="n">o</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">zeros</span><span class="p">(</span><span class="n">x</span><span class="o">.</span><span class="n">size</span><span class="p">)</span>
    <span class="n">imid</span> <span class="o">=</span> <span class="nb">max</span><span class="p">(</span><span class="n">np</span><span class="o">.</span><span class="n">where</span><span class="p">(</span><span class="n">x</span> <span class="o">&lt;=</span> <span class="n">mid</span><span class="p">)[</span><span class="mi">0</span><span class="p">])</span>
    <span class="n">o</span><span class="p">[</span><span class="n">imid</span><span class="p">:]</span> <span class="o">=</span> <span class="mf">1.0</span>
    <span class="k">return</span> <span class="n">o</span>


<span class="k">def</span> <span class="nf">convolve</span><span class="p">(</span><span class="n">arr</span><span class="p">,</span> <span class="n">kernel</span><span class="p">):</span>
    <span class="sd">&quot;&quot;&quot;Simple convolution of two arrays.&quot;&quot;&quot;</span>
    <span class="n">npts</span> <span class="o">=</span> <span class="nb">min</span><span class="p">(</span><span class="n">arr</span><span class="o">.</span><span class="n">size</span><span class="p">,</span> <span class="n">kernel</span><span class="o">.</span><span class="n">size</span><span class="p">)</span>
    <span class="n">pad</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">ones</span><span class="p">(</span><span class="n">npts</span><span class="p">)</span>
    <span class="n">tmp</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">concatenate</span><span class="p">((</span><span class="n">pad</span><span class="o">*</span><span class="n">arr</span><span class="p">[</span><span class="mi">0</span><span class="p">],</span> <span class="n">arr</span><span class="p">,</span> <span class="n">pad</span><span class="o">*</span><span class="n">arr</span><span class="p">[</span><span class="o">-</span><span class="mi">1</span><span class="p">]))</span>
    <span class="n">out</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">convolve</span><span class="p">(</span><span class="n">tmp</span><span class="p">,</span> <span class="n">kernel</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">&#39;valid&#39;</span><span class="p">)</span>
    <span class="n">noff</span> <span class="o">=</span> <span class="nb">int</span><span class="p">((</span><span class="nb">len</span><span class="p">(</span><span class="n">out</span><span class="p">)</span> <span class="o">-</span> <span class="n">npts</span><span class="p">)</span> <span class="o">/</span> <span class="mi">2</span><span class="p">)</span>
    <span class="k">return</span> <span class="n">out</span><span class="p">[</span><span class="n">noff</span><span class="p">:</span><span class="n">noff</span><span class="o">+</span><span class="n">npts</span><span class="p">]</span>


<span class="c1"># create Composite Model using the custom convolution operator</span>
<span class="n">mod</span> <span class="o">=</span> <span class="n">CompositeModel</span><span class="p">(</span><span class="n">Model</span><span class="p">(</span><span class="n">jump</span><span class="p">),</span> <span class="n">Model</span><span class="p">(</span><span class="n">gaussian</span><span class="p">),</span> <span class="n">convolve</span><span class="p">)</span>
<span class="n">pars</span> <span class="o">=</span> <span class="n">mod</span><span class="o">.</span><span class="n">make_params</span><span class="p">(</span><span class="n">amplitude</span><span class="o">=</span><span class="mi">1</span><span class="p">,</span> <span class="n">center</span><span class="o">=</span><span class="mf">3.5</span><span class="p">,</span> <span class="n">sigma</span><span class="o">=</span><span class="mf">1.5</span><span class="p">,</span> <span class="n">mid</span><span class="o">=</span><span class="mf">5.0</span><span class="p">)</span>

<span class="c1"># &#39;mid&#39; and &#39;center&#39; should be completely correlated, and &#39;mid&#39; is</span>
<span class="c1"># used as an integer index, so a very poor fit variable:</span>
<span class="n">pars</span><span class="p">[</span><span class="s1">&#39;mid&#39;</span><span class="p">]</span><span class="o">.</span><span class="n">vary</span> <span class="o">=</span> <span class="kc">False</span>

<span class="c1"># fit this model to data array y</span>
<span class="n">result</span> <span class="o">=</span> <span class="n">mod</span><span class="o">.</span><span class="n">fit</span><span class="p">(</span><span class="n">y</span><span class="p">,</span> <span class="n">params</span><span class="o">=</span><span class="n">pars</span><span class="p">,</span> <span class="n">x</span><span class="o">=</span><span class="n">x</span><span class="p">)</span>

<span class="nb">print</span><span class="p">(</span><span class="n">result</span><span class="o">.</span><span class="n">fit_report</span><span class="p">())</span>

<span class="c1"># generate components</span>
<span class="n">comps</span> <span class="o">=</span> <span class="n">result</span><span class="o">.</span><span class="n">eval_components</span><span class="p">(</span><span class="n">x</span><span class="o">=</span><span class="n">x</span><span class="p">)</span>

<span class="c1"># plot results</span>
<span class="n">fig</span><span class="p">,</span> <span class="n">axes</span> <span class="o">=</span> <span class="n">plt</span><span class="o">.</span><span class="n">subplots</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="n">figsize</span><span class="o">=</span><span class="p">(</span><span class="mf">12.8</span><span class="p">,</span> <span class="mf">4.8</span><span class="p">))</span>

<span class="n">axes</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="o">.</span><span class="n">plot</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">,</span> <span class="s1">&#39;bo&#39;</span><span class="p">)</span>
<span class="n">axes</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="o">.</span><span class="n">plot</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">result</span><span class="o">.</span><span class="n">init_fit</span><span class="p">,</span> <span class="s1">&#39;k--&#39;</span><span class="p">,</span> <span class="n">label</span><span class="o">=</span><span class="s1">&#39;initial fit&#39;</span><span class="p">)</span>
<span class="n">axes</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="o">.</span><span class="n">plot</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">result</span><span class="o">.</span><span class="n">best_fit</span><span class="p">,</span> <span class="s1">&#39;r-&#39;</span><span class="p">,</span> <span class="n">label</span><span class="o">=</span><span class="s1">&#39;best fit&#39;</span><span class="p">)</span>
<span class="n">axes</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="o">.</span><span class="n">legend</span><span class="p">(</span><span class="n">loc</span><span class="o">=</span><span class="s1">&#39;best&#39;</span><span class="p">)</span>

<span class="n">axes</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span><span class="o">.</span><span class="n">plot</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">,</span> <span class="s1">&#39;bo&#39;</span><span class="p">)</span>
<span class="n">axes</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span><span class="o">.</span><span class="n">plot</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="mi">10</span><span class="o">*</span><span class="n">comps</span><span class="p">[</span><span class="s1">&#39;jump&#39;</span><span class="p">],</span> <span class="s1">&#39;k--&#39;</span><span class="p">,</span> <span class="n">label</span><span class="o">=</span><span class="s1">&#39;Jump component&#39;</span><span class="p">)</span>
<span class="n">axes</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span><span class="o">.</span><span class="n">plot</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="mi">10</span><span class="o">*</span><span class="n">comps</span><span class="p">[</span><span class="s1">&#39;gaussian&#39;</span><span class="p">],</span> <span class="s1">&#39;r-&#39;</span><span class="p">,</span> <span class="n">label</span><span class="o">=</span><span class="s1">&#39;Gaussian component&#39;</span><span class="p">)</span>
<span class="n">axes</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span><span class="o">.</span><span class="n">legend</span><span class="p">(</span><span class="n">loc</span><span class="o">=</span><span class="s1">&#39;best&#39;</span><span class="p">)</span>

<span class="n">plt</span><span class="o">.</span><span class="n">show</span><span class="p">()</span>
<span class="c1"># &lt;end examples/doc_model_composite.py&gt;</span>
</pre></div>
</div>
</div>
<div class="cell_output docutils container">
</div>
</div>
<p>which prints out the results:</p>
<div class="jupyter_cell docutils container">
<div class="cell_output docutils container">
<div class="output stream highlight-none notranslate"><div class="highlight"><pre><span></span>[[Model]]
    (Model(jump) &lt;function convolve at 0x13024be50&gt; Model(gaussian))
[[Fit Statistics]]
    # fitting method   = leastsq
    # function evals   = 25
    # data points      = 201
    # variables        = 3
    chi-square         = 24.7562335
    reduced chi-square = 0.12503148
    Akaike info crit   = -414.939746
    Bayesian info crit = -405.029832
[[Variables]]
    mid:        5 (fixed)
    amplitude:  0.62508459 +/- 0.00189732 (0.30%) (init = 1)
    center:     4.50853671 +/- 0.00973231 (0.22%) (init = 3.5)
    sigma:      0.59576118 +/- 0.01348582 (2.26%) (init = 1.5)
[[Correlations]] (unreported correlations are &lt; 0.100)
    C(amplitude, center) =  0.329
    C(amplitude, sigma)  =  0.268
</pre></div>
</div>
</div>
</div>
<p>and shows the plots:</p>
<div class="jupyter_cell docutils container">
<div class="cell_output docutils container">
<img alt="_images/model_47_0.svg" src="_images/model_47_0.svg" /></div>
</div>
<p>Using composite models with built-in or custom operators allows you to
build complex models from testable sub-components.</p>
</div>
</div>


            <div class="clearer"></div>
          </div>
        </div>
      </div>
      <div class="clearer"></div>
    </div>
    <div class="related" role="navigation" aria-label="related navigation">
      <h3>Navigation</h3>
      <ul>
        <li class="right" style="margin-right: 10px">
          <a href="genindex.html" title="General Index"
             >index</a></li>
        <li class="right" >
          <a href="builtin_models.html" title="Built-in Fitting Models in the models module"
             >next</a> |</li>
        <li class="right" >
          <a href="fitting.html" title="Performing Fits and Analyzing Outputs"
             >previous</a> |</li>
    <li>[ <a href="intro.html">intro</a> |</li>
    <li><a href="parameters.html">parameters</a> |</li>
    <li><a href="fitting.html">minimize</a> |</li>
    <li><a href="#">model</a> |</li>
    <li><a href="builtin_models.html">built-in models</a> |</li>
    <li><a href="confidence.html">confidence intervals</a> |</li>
    <li><a href="bounds.html">bounds</a> |</li>
    <li><a href="constraints.html">constraints</a> ]</li>
 
      </ul>
    </div>
    <div class="footer" role="contentinfo">
        &#169; Copyright 2021, Matthew Newville, Till Stensitzki, Renee Otten, and others.
      Created using <a href="https://www.sphinx-doc.org/">Sphinx</a> 3.4.3.
    </div>
  </body>
</html>

Showing with 0 additions and 0 deletions (0 / 0 diffs computed)

Computing file changes ...