fix Deprecated NumPy 1.X errors in CI (#8497)

This PR raises `Deprecated NumPy 1.X` warnings as errors. This PR
subsequently fixes said errors.

We don't want to use deprecated 1.X code in our code base as it has
reached end of life for NumPy and will no longer be maintained by them.

---------

Co-authored-by: JerryChen97 <[email protected]>

Author: andrijapau

doc/releases/changelog-dev.md

@@ -149,6 +149,9 @@
 
 <h3>Internal changes ⚙️</h3>
 
+* Fix all NumPy 1.X `DeprecationWarnings` in our source code.
+  [(#8497)](https://github.com/PennyLaneAI/pennylane/pull/8497)
+  
 * Update versions for `pylint`, `isort` and `black` in `format.yml`
   [(#8506)](https://github.com/PennyLaneAI/pennylane/pull/8506)
 

pennylane/gradients/parameter_shift_cv.py

@@ -465,7 +465,13 @@ def processing_fn(results):
                 g = math.zeros_like(math.atleast_1d(results[0]), like=interface)
 
                 if grad_value:
-                    g = math.scatter_element_add(g, obs_ind, grad_value, like=interface)
+                    grad_value_isscalar = math.ndim(grad_value[0]) == 0
+                    g = math.scatter_element_add(
+                        g,
+                        obs_ind,
+                        grad_value[0] if grad_value_isscalar else grad_value,
+                        like=interface,
+                    )
 
                 grads.append(g[0] if isscalar else g)
                 continue

pennylane/optimize/qnspsa.py

@@ -443,7 +443,7 @@ def _apply_blocking(self, cost, args, kwargs, params_next):
 
         # self.k has been updated earlier
         ind = (self.k - 2) % self.last_n_steps.size
-        self.last_n_steps[ind] = loss_curr
+        self.last_n_steps[ind] = loss_curr.item()
 
         tol = (
             2 * self.last_n_steps.std()

pennylane/transforms/dynamic_one_shot.py

@@ -23,6 +23,7 @@
 import numpy as np
 
 import pennylane as qml
+from pennylane import math
 from pennylane.exceptions import QuantumFunctionError
 from pennylane.measurements import (
     CountsMP,
@@ -236,18 +237,18 @@ def _measurement_with_no_shots(measurement):
 
 def _get_is_valid_has_valid(mcm_samples, all_mcms, interface):
     # Can't use boolean dtype array with tf, hence why conditionally setting items to 0 or 1
-    has_postselect = qml.math.array(
+    has_postselect = math.array(
         [[op.postselect is not None for op in all_mcms]],
         like=interface,
         dtype=mcm_samples.dtype,
     )
-    postselect = qml.math.array(
+    postselect = math.array(
         [[0 if op.postselect is None else op.postselect for op in all_mcms]],
         like=interface,
         dtype=mcm_samples.dtype,
     )
-    is_valid = qml.math.all(mcm_samples * has_postselect == postselect, axis=1)
-    has_valid = qml.math.any(is_valid)
+    is_valid = math.all(mcm_samples * has_postselect == postselect, axis=1)
+    has_valid = math.any(is_valid)
     return is_valid, has_valid
 
 
@@ -270,15 +271,15 @@ def parse_native_mid_circuit_measurements(
         tuple(TensorLike): The results of the simulation.
     """
     assert results is not None  # condition needed to not break signature
-    interface = qml.math.get_deep_interface(results)
+    interface = math.get_deep_interface(results)
     interface = "numpy" if interface == "builtins" else interface
     interface = "tensorflow" if interface == "tf" else interface
 
     all_mcms = [op for op in circuit.operations if is_mcm(op)]
-    mcm_samples = qml.math.hstack(
-        tuple(qml.math.reshape(qml.math.vstack(res), (-1, 1)) for res in results[-len(all_mcms) :])
+    mcm_samples = math.hstack(
+        tuple(math.reshape(math.vstack(res), (-1, 1)) for res in results[-len(all_mcms) :])
     )
-    mcm_samples = qml.math.array(mcm_samples, like=interface)
+    mcm_samples = math.array(mcm_samples, like=interface)
 
     is_valid, has_valid = _get_is_valid_has_valid(mcm_samples, all_mcms, interface)
 
@@ -327,10 +328,10 @@ def _handle_measurement_qjit(
     if isinstance(m, CountsMP):
         res = (
             result[0][0],
-            qml.math.sum(result[1] * qml.math.reshape(is_valid, (-1, 1)), axis=0),
+            math.sum(result[1] * math.reshape(is_valid, (-1, 1)), axis=0),
         )
         return res, m_count + 1
-    result = qml.math.squeeze(result)
+    result = math.squeeze(result)
     return gather_non_mcm(m, result, is_valid, postselect_mode=postselect_mode), m_count + 1
 
 
@@ -375,17 +376,17 @@ def gather_mcm_qjit(measurement, samples, is_valid, postselect_mode=None):  # pr
             break
     if not found:
         raise LookupError("MCM not found")
-    meas = qml.math.squeeze(meas)
+    meas = math.squeeze(meas)
     if isinstance(measurement, (CountsMP, ProbabilityMP)):
-        interface = qml.math.get_interface(is_valid)
-        sum_valid = qml.math.sum(is_valid)
-        count_1 = qml.math.sum(meas * is_valid)
+        interface = math.get_interface(is_valid)
+        sum_valid = math.sum(is_valid)
+        count_1 = math.sum(meas * is_valid)
         if isinstance(measurement, CountsMP):
-            return qml.math.array([0, 1], like=interface), qml.math.array(
+            return math.array([0, 1], like=interface), math.array(
                 [sum_valid - count_1, count_1], like=interface
             )
         if isinstance(measurement, ProbabilityMP):
-            counts = qml.math.array([sum_valid - count_1, count_1], like=interface)
+            counts = math.array([sum_valid - count_1, count_1], like=interface)
             return counts / sum_valid
     return gather_non_mcm(measurement, meas, is_valid, postselect_mode=postselect_mode)
 
@@ -433,63 +434,61 @@ def _gather_counts(measurement: CountsMP, samples, is_valid, postselect_mode=Non
 
 @gather_non_mcm.register
 def _gather_samples(measurement: SampleMP, samples, is_valid, postselect_mode=None):
-    samples = qml.math.concatenate(samples) if isinstance(samples, (list, tuple)) else samples
+    samples = math.concatenate(samples) if isinstance(samples, (list, tuple)) else samples
     if postselect_mode == "pad-invalid-samples" and samples.ndim == 2:
-        is_valid = qml.math.reshape(is_valid, (-1, 1))
+        is_valid = math.reshape(is_valid, (-1, 1))
     if postselect_mode == "pad-invalid-samples":
-        return qml.math.where(is_valid, samples, fill_in_value)
+        return math.where(is_valid, samples, fill_in_value)
     return samples[is_valid]
 
 
 # pylint: disable=unused-arguement
 @gather_non_mcm.register
 def _gather_expval(measurement: ExpectationMP, samples, is_valid, postselect_mode=None):
-    samples = qml.math.stack(samples)
+    samples = math.stack(samples)
     if (
-        qml.math.get_interface(is_valid) == "tensorflow"
+        math.get_interface(is_valid) == "tensorflow"
     ):  # pragma: no cover (TensorFlow tests were disabled during deprecation)
         # Tensorflow requires arrays that are used for arithmetic with each other to have the
         # same dtype. We don't cast if measuring samples as float tf.Tensors cannot be used to
         # index other tf.Tensors (is_valid is used to index valid samples).
-        is_valid = qml.math.cast_like(is_valid, samples)
-    return qml.math.sum(qml.math.squeeze(samples) * is_valid) / qml.math.sum(is_valid)
+        is_valid = math.cast_like(is_valid, samples)
+    return math.sum(math.squeeze(samples) * is_valid) / math.sum(is_valid)
 
 
 # pylint: disable=unused-arguement
 @gather_non_mcm.register
 def _gather_probability(measurement: ProbabilityMP, samples, is_valid, postselect_mode=None):
-    samples = qml.math.stack(samples, axis=0)
+    samples = math.stack(samples, axis=0)
     if (
-        qml.math.get_interface(is_valid) == "tensorflow"
+        math.get_interface(is_valid) == "tensorflow"
     ):  # pragma: no cover (TensorFlow tests were disabled during deprecation)
         # Tensorflow requires arrays that are used for arithmetic with each other to have the
         # same dtype. We don't cast if measuring samples as float tf.Tensors cannot be used to
         # index other tf.Tensors (is_valid is used to index valid samples).
-        is_valid = qml.math.cast_like(is_valid, samples)
-    return qml.math.sum(samples * qml.math.reshape(is_valid, (-1, 1)), axis=0) / qml.math.sum(
-        is_valid
-    )
+        is_valid = math.cast_like(is_valid, samples)
+    return math.sum(samples * math.reshape(is_valid, (-1, 1)), axis=0) / math.sum(is_valid)
 
 
 @gather_non_mcm.register
 def _gather_variance(measurement: VarianceMP, samples, is_valid, postselect_mode=None):
-    samples = qml.math.stack(samples)
+    samples = math.stack(samples)
     if (
-        interface := qml.math.get_interface(is_valid)
+        interface := math.get_interface(is_valid)
     ) == "tensorflow":  # pragma: no cover (TensorFlow tests were disabled during deprecation)
         # Tensorflow requires arrays that are used for arithmetic with each other to have the
         # same dtype. We don't cast if measuring samples as float tf.Tensors cannot be used to
         # index other tf.Tensors (is_valid is used to index valid samples).
-        is_valid = qml.math.cast_like(is_valid, samples)
-    samples = qml.math.squeeze(samples)
-    expval = qml.math.sum(samples * is_valid) / qml.math.sum(is_valid)
+        is_valid = math.cast_like(is_valid, samples)
+    samples = math.squeeze(samples)
+    expval = math.sum(samples * is_valid) / math.sum(is_valid)
     if (
         interface == "tensorflow"
     ):  # pragma: no cover (TensorFlow tests were disabled during deprecation)
         # Casting needed for tensorflow
-        samples = qml.math.cast_like(samples, expval)
-        is_valid = qml.math.cast_like(is_valid, expval)
-    return qml.math.sum((samples - expval) ** 2 * is_valid) / qml.math.sum(is_valid)
+        samples = math.cast_like(samples, expval)
+        is_valid = math.cast_like(is_valid, expval)
+    return math.sum((samples - expval) ** 2 * is_valid) / math.sum(is_valid)
 
 
 def gather_mcm(measurement: MeasurementProcess, samples, is_valid, postselect_mode=None):
@@ -505,44 +504,42 @@ def gather_mcm(measurement: MeasurementProcess, samples, is_valid, postselect_mo
         TensorLike: The combined measurement outcome
     """
 
-    interface = qml.math.get_deep_interface(is_valid)
+    interface = math.get_deep_interface(is_valid)
     mv = measurement.mv
     # The following block handles measurement value lists, like ``qml.counts(op=[mcm0, mcm1, mcm2])``.
     if isinstance(measurement, (CountsMP, ProbabilityMP, SampleMP)) and isinstance(mv, Sequence):
         mcm_samples = [m.concretize(samples) for m in mv]
-        mcm_samples = qml.math.concatenate(mcm_samples, axis=1)
+        mcm_samples = math.concatenate(mcm_samples, axis=1)
         if isinstance(measurement, ProbabilityMP):
             values = [list(m.branches.values()) for m in mv]
             values = list(itertools.product(*values))
-            values = [qml.math.array([v], like=interface, dtype=mcm_samples.dtype) for v in values]
+            values = [math.array([v], like=interface, dtype=mcm_samples.dtype) for v in values]
             # Need to use boolean functions explicitly as Tensorflow does not allow integer math
             # on boolean arrays
             counts = [
-                qml.math.count_nonzero(
-                    qml.math.logical_and(qml.math.all(mcm_samples == v, axis=1), is_valid)
-                )
+                math.count_nonzero(math.logical_and(math.all(mcm_samples == v, axis=1), is_valid))
                 for v in values
             ]
-            counts = qml.math.array(counts, like=interface)
-            return counts / qml.math.sum(counts)
+            counts = math.array(counts, like=interface)
+            return counts / math.sum(counts)
         if isinstance(measurement, CountsMP):
             mcm_samples = [{"".join(str(int(v)) for v in tuple(s)): 1} for s in mcm_samples]
         return gather_non_mcm(measurement, mcm_samples, is_valid, postselect_mode=postselect_mode)
 
-    mcm_samples = qml.math.array(mv.concretize(samples), like=interface)
+    mcm_samples = math.array(mv.concretize(samples), like=interface)
     if isinstance(measurement, ProbabilityMP):
         # Need to use boolean functions explicitly as Tensorflow does not allow integer math
         # on boolean arrays
-        mcm_samples = qml.math.squeeze(mcm_samples)
+        mcm_samples = math.squeeze(mcm_samples)
         counts = [
-            qml.math.count_nonzero(qml.math.logical_and((mcm_samples == v), is_valid))
+            math.count_nonzero(math.logical_and((mcm_samples == v), is_valid))
             for v in list(mv.branches.values())
         ]
-        counts = qml.math.array(counts, like=interface)
-        return counts / qml.math.sum(counts)
+        counts = math.array(counts, like=interface)
+        return counts / math.sum(counts)
     if isinstance(measurement, CountsMP):
-        mcm_samples = [{float(s): 1} for s in mcm_samples]
+        mcm_samples = [{float(s.item()): 1} for s in mcm_samples]
     results = gather_non_mcm(measurement, mcm_samples, is_valid, postselect_mode=postselect_mode)
     if isinstance(measurement, SampleMP):
-        results = qml.math.squeeze(results)
+        results = math.squeeze(results)
     return results

pennylane/transforms/intermediate_reps/rowcol.py

@@ -39,7 +39,7 @@
     F_2 = galois.GF(2)  # pragma: no cover
     has_galois = True  # pragma: no cover
 
-except ImportError:
+except ModuleNotFoundError:
     has_galois = False
 
 

tests/pytest.ini

@@ -31,6 +31,7 @@ filterwarnings =
     error::pennylane.exceptions.PennyLaneDeprecationWarning
     # Suppress expected AutoGraphWarnings that arise from the tests
     error:AutoGraph will not transform the function:pennylane.capture.autograph.AutoGraphWarning
+    error:.*Deprecated NumPy 1\..*:DeprecationWarning
     error:Both 'shots=' parameter and 'set_shots' transform are specified. :UserWarning
 #addopts = --benchmark-disable
 xfail_strict=true