Suppress more numpy warnings from uncertainties

qiskit_experiments/curve_analysis/curve_analysis.py

@@ -231,7 +231,11 @@ def _run_data_processing(
             )
         processed_values = self.options.data_processor(to_process)
         source["yval"] = unp.nominal_values(processed_values).flatten()
-        source["yerr"] = unp.std_devs(processed_values).flatten()
+        with np.errstate(invalid="ignore"):
+            # For averaged data, the processed std dev will be NaN.
+            # Setting std_devs to NaN will trigger floating point exceptions
+            # which we can ignore. See https://stackoverflow.com/q/75656026
+            source["yerr"] = unp.std_devs(processed_values).flatten()
         source["category"] = category
 
         table = ScatterTable(data=source)

qiskit_experiments/curve_analysis/curve_data.py

@@ -235,10 +235,13 @@ def ufloat_params(self) -> Dict[str, uncertainties.UFloat]:
                 )
             else:
                 # Invalid covariance matrix. Std dev is set to nan, i.e. not computed.
-                ufloat_fitvals = uarray(
-                    nominal_values=[self.params[name] for name in self.var_names],
-                    std_devs=np.full(len(self.var_names), np.nan),
-                )
+                with np.errstate(invalid="ignore"):
+                    # Setting std_devs to NaN will trigger floating point exceptions
+                    # which we can ignore. See https://stackoverflow.com/q/75656026
+                    ufloat_fitvals = uarray(
+                        nominal_values=[self.params[name] for name in self.var_names],
+                        std_devs=np.full(len(self.var_names), np.nan),
+                    )
             # Combine fixed params and fitting variables into a single dictionary
             # Fixed parameter has zero std_dev
             ufloat_params = {}

qiskit_experiments/data_processing/nodes.py

@@ -85,7 +85,10 @@ def _process(self, data: np.ndarray) -> np.ndarray:
 
         reduced_array = np.mean(data, axis=ax)
         nominals = unp.nominal_values(reduced_array)
-        errors = unp.std_devs(reduced_array)
+        with np.errstate(invalid="ignore"):
+            # Setting std_devs to NaN will trigger floating point exceptions
+            # which we can ignore. See https://stackoverflow.com/q/75656026
+            errors = unp.std_devs(reduced_array)
 
         if np.any(np.isnan(errors)):
             # replace empty elements with SEM
@@ -781,7 +784,10 @@ def _process(self, data: np.ndarray) -> np.ndarray:
             p_mean = alpha_posterior[0] / alpha_sum
             p_var = p_mean * (1 - p_mean) / (alpha_sum + 1)
 
-            probabilities[idx] = ufloat(nominal_value=p_mean, std_dev=np.sqrt(p_var))
+            with np.errstate(invalid="ignore"):
+                # Setting std_devs to NaN will trigger floating point exceptions
+                # which we can ignore. See https://stackoverflow.com/q/75656026
+                probabilities[idx] = ufloat(nominal_value=p_mean, std_dev=np.sqrt(p_var))
 
         return probabilities
 

test/data_processing/test_data_processing.py

@@ -418,10 +418,13 @@ def test_json_trained(self):
             unp.nominal_values(loaded_out),
         )
 
-        np.testing.assert_array_almost_equal(
-            unp.std_devs(ref_out),
-            unp.std_devs(loaded_out),
-        )
+        with np.errstate(invalid="ignore"):
+            # Setting std_devs to NaN will trigger floating point exceptions
+            # which we can ignore. See https://stackoverflow.com/q/75656026
+            np.testing.assert_array_almost_equal(
+                unp.std_devs(ref_out),
+                unp.std_devs(loaded_out),
+            )
 
 
 class TestIQSingleAvg(BaseDataProcessorTest):

test/data_processing/test_nodes.py

@@ -43,7 +43,10 @@ class TestAveraging(BaseDataProcessorTest):
 
     def test_simple(self):
         """Simple test of averaging. Standard error of mean is generated."""
-        datum = unp.uarray([[1, 2], [3, 4], [5, 6]], np.full((3, 2), np.nan))
+        with np.errstate(invalid="ignore"):
+            # Setting std_devs to NaN will trigger floating point exceptions
+            # which we can ignore. See https://stackoverflow.com/q/75656026
+            datum = unp.uarray([[1, 2], [3, 4], [5, 6]], np.full((3, 2), np.nan))
 
         node = AverageData(axis=1)
         processed_data = node(data=datum)
@@ -85,16 +88,19 @@ def test_with_error(self):
 
     def test_with_error_partly_non_error(self):
         """Compute error propagation. Some elements have no error."""
-        datum = unp.uarray(
-            [
-                [1, 2, 3, 4, 5, 6],
-                [1, 2, 3, 4, 5, 6],
-            ],
-            [
-                [0.1, 0.2, 0.3, 0.4, 0.5, 0.6],
-                [np.nan, 0.2, 0.3, 0.4, 0.5, 0.6],
-            ],
-        )
+        with np.errstate(invalid="ignore"):
+            # Setting std_devs to NaN will trigger floating point exceptions
+            # which we can ignore. See https://stackoverflow.com/q/75656026
+            datum = unp.uarray(
+                [
+                    [1, 2, 3, 4, 5, 6],
+                    [1, 2, 3, 4, 5, 6],
+                ],
+                [
+                    [0.1, 0.2, 0.3, 0.4, 0.5, 0.6],
+                    [np.nan, 0.2, 0.3, 0.4, 0.5, 0.6],
+                ],
+            )
 
         node = AverageData(axis=1)
         processed_data = node(data=datum)
@@ -130,7 +136,10 @@ def test_iq_averaging(self):
         )
         iq_std = np.full_like(iq_data, np.nan)
 
-        self.create_experiment_data(unp.uarray(iq_data, iq_std), single_shot=True)
+        with np.errstate(invalid="ignore"):
+            # Setting std_devs to NaN will trigger floating point exceptions
+            # which we can ignore. See https://stackoverflow.com/q/75656026
+            self.create_experiment_data(unp.uarray(iq_data, iq_std), single_shot=True)
 
         avg_iq = AverageData(axis=0)
         processed_data = avg_iq(data=np.asarray(self.iq_experiment.data(0)["memory"]))
@@ -188,11 +197,14 @@ def test_simple(self):
             decimal=-8,
         )
 
-        np.testing.assert_array_almost_equal(
-            unp.std_devs(processed),
-            unp.std_devs(expected),
-            decimal=-8,
-        )
+        with np.errstate(invalid="ignore"):
+            # Setting std_devs to NaN will trigger floating point exceptions
+            # which we can ignore. See https://stackoverflow.com/q/75656026
+            np.testing.assert_array_almost_equal(
+                unp.std_devs(processed),
+                unp.std_devs(expected),
+                decimal=-8,
+            )
 
 
 class TestNormalize(QiskitExperimentsTestCase):