Changes due to new numpy scalar promotion rules

1. Changed autocaster due to new promotion rules

With "weak promotion" of python types in Numpy 2.0,
the statement `1.1 == np.asarray(1.1).astype('float32')` is True,
whereas in Numpy 1.26, it was false.

However, in numpy 1.26, `1.1 == np.asarray([1.1]).astype('float32')`
was true, so the scalar behavior and array behavior are the same
in Numpy 2.0, while they were different in numpy 1.26.

Essentially, in Numpy 2.0, if python floats are used in operations
with numpy floats or arrays, then the type of the numpy object will
be used (i.e. the python value will be treated as the type of the numpy
objects).

To preserve the behavior of `NumpyAutocaster` from numpy <= 1.26, I've
added an explicit conversion of the value to be converted to a numpy
type using `np.asarray` during the check that decides what dtype to
cast to.

2. Updates due to new numpy conversion rules for out-of-bounds python
ints

In numpy 2.0, out of bounds python ints will not be automatically
converted, and will raise an `OverflowError` instead.
For instance, converting 255 to int8 will raise an error, instead of
returning -1.

To explicitly force conversion, we must use
`np.asarray(value).astype(dtype)`, rather than
`np.asarray(value, dtype=dtype)`.

The code in `TensorType.filter` has been changed to the new recommended
way to downcast, and the error type caught by some tests has been
changed to OverflowError from TypeError

Author: brendan-m-murphy

pytensor/scalar/basic.py

@@ -184,7 +184,9 @@ def __call__(self, x):
 
         for dtype in try_dtypes:
             x_ = np.asarray(x).astype(dtype=dtype)
-            if np.all(x == x_):
+            if np.all(
+                np.asarray(x) == x_
+            ):  # use np.asarray(x) to match TensorType.filter
                 break
         # returns either an exact x_==x, or the last cast x_
         return x_

pytensor/tensor/type.py

@@ -177,7 +177,7 @@ def filter(self, data, strict=False, allow_downcast=None) -> np.ndarray:
         else:
             if allow_downcast:
                 # Convert to self.dtype, regardless of the type of data
-                data = np.asarray(data, dtype=self.dtype)
+                data = np.asarray(data).astype(self.dtype)
                 # TODO: consider to pad shape with ones to make it consistent
                 # with self.broadcastable... like vector->row type thing
             else:

tests/compile/function/test_function.py

@@ -26,6 +26,12 @@
 floatX = "float32"
 
 
+if np.lib.NumpyVersion(np.__version__) >= "2.0.0rc1":
+    uint_overflow_error = OverflowError
+else:
+    uint_overflow_error = TypeError
+
+
 def test_function_dump():
     v = vector()
     fct1 = function([v], v + 1)
@@ -166,12 +172,12 @@ def test_in_allow_downcast_int(self):
         # Value too big for a, silently ignored
         assert np.array_equal(f([2**20], np.ones(1, dtype="int8"), 1), [2])
 
-        # Value too big for b, raises TypeError
-        with pytest.raises(TypeError):
+        # Value too big for b, raises OverflowError (in numpy >= 2.0... TypeError in numpy < 2.0)
+        with pytest.raises(uint_overflow_error):
             f([3], [312], 1)
 
-        # Value too big for c, raises TypeError
-        with pytest.raises(TypeError):
+        # Value too big for c, raises OverflowError
+        with pytest.raises(uint_overflow_error):
             f([3], [6], 806)
 
     def test_in_allow_downcast_floatX(self):

tests/compile/function/test_pfunc.py

@@ -34,6 +34,12 @@ def data_of(s):
     return s.container.storage[0]
 
 
+if np.lib.NumpyVersion(np.__version__) >= "2.0.0rc1":
+    uint_overflow_error = OverflowError
+else:
+    uint_overflow_error = TypeError
+
+
 class TestPfunc:
     def test_errors(self):
         a = lscalar()
@@ -237,12 +243,12 @@ def test_param_allow_downcast_int(self):
         # Value too big for a, silently ignored
         assert np.all(f([2**20], np.ones(1, dtype="int8"), 1) == 2)
 
-        # Value too big for b, raises TypeError
-        with pytest.raises(TypeError):
+        # Value too big for b, raises OverflowError in numpy >= 2.0, TypeError in numpy <2.0
+        with pytest.raises(uint_overflow_error):
             f([3], [312], 1)
 
-        # Value too big for c, raises TypeError
-        with pytest.raises(TypeError):
+        # Value too big for c, raises OverflowError in numpy >= 2.0, TypeError in numpy <2.0
+        with pytest.raises(uint_overflow_error):
             f([3], [6], 806)
 
     def test_param_allow_downcast_floatX(self):
@@ -334,6 +340,7 @@ def test_allow_input_downcast_int(self):
         h = pfunc([a, b, c], (a + b + c))  # Default: allow_input_downcast=None
         # Everything here should behave like with False
         assert np.all(h([3], [6], 0) == 9)
+
         with pytest.raises(TypeError):
             h([3], np.array([6], dtype="int16"), 0)
 

tests/tensor/test_basic.py

@@ -3198,7 +3198,6 @@ def test_autocast_custom():
         assert (dvector() + 1.1).dtype == "float64"
         assert (fvector() + np.float32(1.1)).dtype == "float32"
         assert (fvector() + np.float64(1.1)).dtype == "float64"
-        assert (fvector() + 1.1).dtype == config.floatX
         assert (lvector() + np.int64(1)).dtype == "int64"
         assert (lvector() + np.int32(1)).dtype == "int64"
         assert (lvector() + np.int16(1)).dtype == "int64"

tests/tensor/test_io.py

@@ -49,7 +49,7 @@ def test_memmap(self):
         path = Variable(Generic(), None)
         x = load(path, "int32", (None,), mmap_mode="c")
         fn = function([path], x)
-        assert type(fn(self.filename)) == np.memmap
+        assert isinstance(fn(self.filename), np.memmap)
 
     def teardown_method(self):
         (pytensor.config.compiledir / "_test.npy").unlink()