Ignore warning about std_dev==0 in ufloat_params (backport #1556) (#1558)

As of Uncertainties 3.2.3, `ufloat()` warns when passed a standard
deviation of 0 because that can lead to problems (see the discussion
[here](lmfit/uncertainties#283).  The
recommendation is to use a plain float instead but we want
`ufloat_params` to return all `UFloats` so that `.n` and `.s` always
exist and the user doesn't need to handle type checking on curve data
results, so here we just ignore the warning.

A standard deviation of 0 is usually not a problem. Uncertainties
propagates errors for all of its variables even when they have 0
standard deviation. If the propagation of one variable leads to a `nan`
or `inf` value, the standard deviation will take on that value even
though, since the variable's standard deviation was 0, the error
propagation could have been skipped for that variable.<hr>This is an
automatic backport of pull request #1556 done by
[Mergify](https://mergify.com).

Co-authored-by: Will Shanks <willshanks@us.ibm.com>

Author: mergify[bot]

qiskit_experiments/curve_analysis/curve_analysis.py

@@ -505,14 +505,28 @@ def _run_curve_fit(
 
             try:
                 with np.errstate(all="ignore"):
-                    new = lmfit.minimize(
-                        fcn=lambda x: np.concatenate([p(x) for p in partial_weighted_residuals]),
-                        params=guess_params,
-                        method=self.options.fit_method,
-                        scale_covar=not valid_uncertainty,
-                        nan_policy="omit",
-                        **fit_option.fitter_opts,
-                    )
+                    with warnings.catch_warnings():
+                        # Temporary workaround to avoid lmfit generate an
+                        # Uncertainties warning about std_dev==0 when there are
+                        # fixed parameters in the fit.
+                        #
+                        # This warning filter can be removed after
+                        # https://github.com/lmfit/lmfit-py/pull/1000 is
+                        # released.
+                        warnings.filterwarnings(
+                            "ignore",
+                            message="Using UFloat objects with std_dev==0.*",
+                        )
+                        new = lmfit.minimize(
+                            fcn=lambda x: np.concatenate(
+                                [p(x) for p in partial_weighted_residuals]
+                            ),
+                            params=guess_params,
+                            method=self.options.fit_method,
+                            scale_covar=not valid_uncertainty,
+                            nan_policy="omit",
+                            **fit_option.fitter_opts,
+                        )
             except Exception:  # pylint: disable=broad-except
                 continue
 

qiskit_experiments/curve_analysis/curve_data.py

@@ -15,6 +15,7 @@
 """
 import dataclasses
 import itertools
+import warnings
 from typing import Any, Dict, Union, List, Tuple, Optional, Iterable
 
 import numpy as np
@@ -132,7 +133,24 @@ def ufloat_params(self) -> Dict[str, uncertainties.UFloat]:
                     uind = self.var_names.index(name)
                     ufloat_params[name] = ufloat_fitvals[uind]
                 except ValueError:
-                    ufloat_params[name] = uncertainties.ufloat(self.params[name], std_dev=0.0)
+                    with warnings.catch_warnings():
+                        # As of Uncertainties 3.2.3, ufloat() warns about std_dev=0
+                        # We want to return UFloats uniformly (not a mix of
+                        # UFloats and plain floats) so we need to ignore this
+                        # warning and trust the user not to use the results
+                        # with std_dev==0 in a way that causes problems.
+                        #
+                        # In Uncertainties 3.2.3, the module of the warning is
+                        # uncertainties.core. Once
+                        # https://github.com/lmfit/uncertainties/pull/305 is
+                        # released, the module will be curve_data.py in
+                        # qiskit_experiments and the uncertainties part can be
+                        # removed from the module expression.
+                        warnings.filterwarnings(
+                            "ignore",
+                            module=r"(qiskit_experiments|uncertainties)\.",
+                        )
+                        ufloat_params[name] = uncertainties.ufloat(self.params[name], std_dev=0.0)
 
         setattr(self, "_ufloat_params", ufloat_params)
         return ufloat_params

releasenotes/notes/uncertainties-stddev0-warning-aea55aada131d8b1.yaml

@@ -0,0 +1,16 @@
+---
+fixes:
+  - |
+    Warnings from the `Uncertainties
+    <https://uncertainties.readthedocs.io/en/latest/>`__ library related to a
+    standard deviation of zero have been suppressed where a standard deviation
+    of zero is expected and can not be avoided. One case involves the fixed fit
+    parameters included in :class:`.CurveFitResult`. Since these are fixed
+    parameters, they have no uncertainty. The other case involves the `lmfit
+    <https://lmfit.github.io/lmfit-py/>`__ library's handling of fixed fit
+    parameters and will be addressed by lmfit directly in the future. In some
+    cases, Uncertainties will propagate the error in a variable and produce a
+    non-finite result when the error should be zero since the variable zero
+    error. For example, the operation ``y ** 0.5`` could lead to 0 with ``inf``
+    standard deviation rather than 0 standard deviation when the nominal value
+    and standard deviation of ``y`` are both 0.