Remove Scalar prefix from Maximum, Minimum, and Softplus

Author: ricardoV94

pytensor/compile/profiling.py

@@ -1480,8 +1480,8 @@ def print_tips(self, file):
             ps.XOR,
             ps.AND,
             ps.Invert,
-            ps.ScalarMaximum,
-            ps.ScalarMinimum,
+            ps.Maximum,
+            ps.Minimum,
             ps.Add,
             ps.Mul,
             ps.Sub,

pytensor/link/numba/dispatch/elemwise.py

@@ -26,13 +26,13 @@
     XOR,
     Add,
     IntDiv,
+    Maximum,
+    Minimum,
     Mul,
-    ScalarMaximum,
-    ScalarMinimum,
     Sub,
     TrueDiv,
     get_scalar_type,
-    scalar_maximum,
+    maximum,
 )
 from pytensor.scalar.basic import add as add_as
 from pytensor.tensor.elemwise import CAReduce, DimShuffle, Elemwise
@@ -103,16 +103,16 @@ def scalar_in_place_fn_IntDiv(op, idx, res, arr):
     return f"{res}[{idx}] //= {arr}"
 
 
-@scalar_in_place_fn.register(ScalarMaximum)
-def scalar_in_place_fn_ScalarMaximum(op, idx, res, arr):
+@scalar_in_place_fn.register(Maximum)
+def scalar_in_place_fn_Maximum(op, idx, res, arr):
     return f"""
 if {res}[{idx}] < {arr}:
     {res}[{idx}] = {arr}
 """
 
 
-@scalar_in_place_fn.register(ScalarMinimum)
-def scalar_in_place_fn_ScalarMinimum(op, idx, res, arr):
+@scalar_in_place_fn.register(Minimum)
+def scalar_in_place_fn_Minimum(op, idx, res, arr):
     return f"""
 if {res}[{idx}] > {arr}:
     {res}[{idx}] = {arr}
@@ -458,7 +458,7 @@ def numba_funcify_Softmax(op, node, **kwargs):
     if axis is not None:
         axis = normalize_axis_index(axis, x_at.ndim)
         reduce_max_py = create_multiaxis_reducer(
-            scalar_maximum, -np.inf, axis, x_at.ndim, x_dtype, keepdims=True
+            maximum, -np.inf, axis, x_at.ndim, x_dtype, keepdims=True
         )
         reduce_sum_py = create_multiaxis_reducer(
             add_as, 0.0, (axis,), x_at.ndim, x_dtype, keepdims=True
@@ -522,7 +522,7 @@ def numba_funcify_LogSoftmax(op, node, **kwargs):
     if axis is not None:
         axis = normalize_axis_index(axis, x_at.ndim)
         reduce_max_py = create_multiaxis_reducer(
-            scalar_maximum,
+            maximum,
             -np.inf,
             (axis,),
             x_at.ndim,

pytensor/scalar/basic.py

@@ -1868,7 +1868,7 @@ def c_code(self, node, name, inputs, outputs, sub):
 ##############
 # Arithmetic
 ##############
-class ScalarMaximum(BinaryScalarOp):
+class Maximum(BinaryScalarOp):
     commutative = True
     associative = True
     nfunc_spec = ("maximum", 2, 1)
@@ -1908,10 +1908,10 @@ def L_op(self, inputs, outputs, gout):
         return (gx, gy)
 
 
-scalar_maximum = ScalarMaximum(upcast_out, name="maximum")
+maximum = Maximum(upcast_out, name="maximum")
 
 
-class ScalarMinimum(BinaryScalarOp):
+class Minimum(BinaryScalarOp):
     commutative = True
     associative = True
     nfunc_spec = ("minimum", 2, 1)
@@ -1950,7 +1950,7 @@ def L_op(self, inputs, outputs, gout):
         return (gx, gy)
 
 
-scalar_minimum = ScalarMinimum(upcast_out, name="minimum")
+minimum = Minimum(upcast_out, name="minimum")
 
 
 class Add(ScalarOp):

pytensor/scalar/math.py

@@ -32,8 +32,8 @@
     isinf,
     log,
     log1p,
+    maximum,
     reciprocal,
-    scalar_maximum,
     sqrt,
     switch,
     true_div,
@@ -1305,7 +1305,7 @@ def c_code_cache_version(self):
             return v
 
 
-softplus = Softplus(upgrade_to_float, name="scalar_softplus")
+softplus = Softplus(upgrade_to_float, name="softplus")
 
 
 class Log1mexp(UnaryScalarOp):
@@ -1575,9 +1575,7 @@ def inner_loop(
             derivative_new = K * (F1 * dK + F2)
 
             errapx = scalar_abs(derivative - derivative_new)
-            d_errapx = errapx / scalar_maximum(
-                err_threshold, scalar_abs(derivative_new)
-            )
+            d_errapx = errapx / maximum(err_threshold, scalar_abs(derivative_new))
 
             min_iters_cond = n > (min_iters - 1)
             derivative = switch(
@@ -1823,7 +1821,7 @@ def inner_loop(*args):
         if len(grad_incs) == 1:
             [max_abs_grad_inc] = grad_incs
         else:
-            max_abs_grad_inc = reduce(scalar_maximum, abs_grad_incs)
+            max_abs_grad_inc = reduce(maximum, abs_grad_incs)
 
         return (
             (*grads, *log_gs, *log_gs_signs, log_t, log_t_sign, sign_zk, k),

pytensor/tensor/basic.py

@@ -262,8 +262,8 @@ def _obj_is_wrappable_as_tensor(x):
     ps.Mul,
     ps.IntDiv,
     ps.TrueDiv,
-    ps.ScalarMinimum,
-    ps.ScalarMaximum,
+    ps.Minimum,
+    ps.Maximum,
 )
 
 

pytensor/tensor/blas.py

@@ -947,8 +947,8 @@ def infer_shape(self, fgraph, node, input_shapes):
         z_shape, _, x_shape, y_shape, _ = input_shapes
         return [
             (
-                pytensor.scalar.scalar_maximum(z_shape[0], x_shape[0]),
-                pytensor.scalar.scalar_maximum(z_shape[1], y_shape[1]),
+                pytensor.scalar.maximum(z_shape[0], x_shape[0]),
+                pytensor.scalar.maximum(z_shape[1], y_shape[1]),
             )
         ]
 

pytensor/tensor/math.py

@@ -406,7 +406,7 @@ class Max(NonZeroDimsCAReduce):
     nfunc_spec = ("max", 1, 1)
 
     def __init__(self, axis):
-        super().__init__(ps.scalar_maximum, axis)
+        super().__init__(ps.maximum, axis)
 
     def clone(self, **kwargs):
         axis = kwargs.get("axis", self.axis)
@@ -464,7 +464,7 @@ class Min(NonZeroDimsCAReduce):
     nfunc_spec = ("min", 1, 1)
 
     def __init__(self, axis):
-        super().__init__(ps.scalar_minimum, axis)
+        super().__init__(ps.minimum, axis)
 
     def clone(self, **kwargs):
         axis = kwargs.get("axis", self.axis)
@@ -2757,7 +2757,7 @@ def median(x: TensorLike, axis=None) -> TensorVariable:
     return ifelse(even_k, even_median, odd_median, name="median")
 
 
-@scalar_elemwise(symbolname="scalar_maximum")
+@scalar_elemwise
 def maximum(x, y):
     """elemwise maximum. See max for the maximum in one tensor
 
@@ -2793,7 +2793,7 @@ def maximum(x, y):
     # see decorator for function body
 
 
-@scalar_elemwise(symbolname="scalar_minimum")
+@scalar_elemwise
 def minimum(x, y):
     """elemwise minimum. See min for the minimum in one tensor
 

pytensor/tensor/rewriting/math.py

@@ -1450,7 +1450,7 @@ def local_useless_elemwise_comparison(fgraph, node):
 
     # Elemwise[{minimum,maximum}](X, X) -> X
     if (
-        isinstance(node.op.scalar_op, ps.ScalarMinimum | ps.ScalarMaximum)
+        isinstance(node.op.scalar_op, ps.Minimum | ps.Maximum)
         and node.inputs[0] is node.inputs[1]
     ):
         res = node.inputs[0]
@@ -1493,7 +1493,7 @@ def local_useless_elemwise_comparison(fgraph, node):
         return [res]
 
     # Elemwise[maximum](X.shape[i], 0) -> X.shape[i]
-    if isinstance(node.op.scalar_op, ps.ScalarMaximum):
+    if isinstance(node.op.scalar_op, ps.Maximum):
         for idx in range(2):
             if (
                 node.inputs[idx].owner
@@ -1512,7 +1512,7 @@ def local_useless_elemwise_comparison(fgraph, node):
                 return [res]
 
     # Elemwise[minimum](X.shape[i], 0) -> 0
-    if isinstance(node.op.scalar_op, ps.ScalarMinimum):
+    if isinstance(node.op.scalar_op, ps.Minimum):
         for idx in range(2):
             if (
                 node.inputs[idx].owner

pytensor/tensor/rewriting/uncanonicalize.py

@@ -60,7 +60,7 @@ def local_max_to_min(fgraph, node):
         if (
             max.owner
             and isinstance(max.owner.op, CAReduce)
-            and max.owner.op.scalar_op == ps.scalar_maximum
+            and max.owner.op.scalar_op == ps.maximum
         ):
             neg_node = max.owner.inputs[0]
             if neg_node.owner and neg_node.owner.op == neg:

tests/tensor/rewriting/test_math.py

@@ -3829,10 +3829,7 @@ def check_max_log_sum_exp(x, axis, dimshuffle_op=None):
 
     fgraph = f.maker.fgraph.toposort()
     for node in fgraph:
-        if (
-            hasattr(node.op, "scalar_op")
-            and node.op.scalar_op == ps.basic.scalar_maximum
-        ):
+        if hasattr(node.op, "scalar_op") and node.op.scalar_op == ps.basic.maximum:
             return
 
         # In mode FAST_COMPILE, the rewrites don't replace the

tests/tensor/test_elemwise.py

@@ -544,14 +544,14 @@ def with_mode(
             elif scalar_op == ps.mul:
                 for axis in sorted(tosum, reverse=True):
                     zv = np.multiply.reduce(zv, axis)
-            elif scalar_op == ps.scalar_maximum:
+            elif scalar_op == ps.maximum:
                 # There is no identity value for the maximum function
                 # So we can't support shape of dimensions 0.
                 if np.prod(zv.shape) == 0:
                     continue
                 for axis in sorted(tosum, reverse=True):
                     zv = np.maximum.reduce(zv, axis)
-            elif scalar_op == ps.scalar_minimum:
+            elif scalar_op == ps.minimum:
                 # There is no identity value for the minimum function
                 # So we can't support shape of dimensions 0.
                 if np.prod(zv.shape) == 0:
@@ -594,7 +594,7 @@ def with_mode(
                 tosum = list(range(len(xsh)))
             f = pytensor.function([x], e.shape, mode=mode, on_unused_input="ignore")
             if not (
-                scalar_op in [ps.scalar_maximum, ps.scalar_minimum]
+                scalar_op in [ps.maximum, ps.minimum]
                 and (xsh == () or np.prod(xsh) == 0)
             ):
                 assert all(f(xv) == zv.shape)
@@ -606,8 +606,8 @@ def test_perform(self):
         for dtype in ["bool", "floatX", "complex64", "complex128", "int8", "uint8"]:
             self.with_mode(Mode(linker="py"), ps.add, dtype=dtype)
             self.with_mode(Mode(linker="py"), ps.mul, dtype=dtype)
-            self.with_mode(Mode(linker="py"), ps.scalar_maximum, dtype=dtype)
-            self.with_mode(Mode(linker="py"), ps.scalar_minimum, dtype=dtype)
+            self.with_mode(Mode(linker="py"), ps.maximum, dtype=dtype)
+            self.with_mode(Mode(linker="py"), ps.minimum, dtype=dtype)
             self.with_mode(Mode(linker="py"), ps.and_, dtype=dtype, tensor_op=pt_all)
             self.with_mode(Mode(linker="py"), ps.or_, dtype=dtype, tensor_op=pt_any)
         for dtype in ["int8", "uint8"]:
@@ -619,12 +619,8 @@ def test_perform_nan(self):
         for dtype in ["floatX", "complex64", "complex128"]:
             self.with_mode(Mode(linker="py"), ps.add, dtype=dtype, test_nan=True)
             self.with_mode(Mode(linker="py"), ps.mul, dtype=dtype, test_nan=True)
-            self.with_mode(
-                Mode(linker="py"), ps.scalar_maximum, dtype=dtype, test_nan=True
-            )
-            self.with_mode(
-                Mode(linker="py"), ps.scalar_minimum, dtype=dtype, test_nan=True
-            )
+            self.with_mode(Mode(linker="py"), ps.maximum, dtype=dtype, test_nan=True)
+            self.with_mode(Mode(linker="py"), ps.minimum, dtype=dtype, test_nan=True)
             self.with_mode(
                 Mode(linker="py"),
                 ps.or_,
@@ -659,8 +655,8 @@ def test_c(self):
             self.with_mode(Mode(linker="c"), ps.add, dtype=dtype)
             self.with_mode(Mode(linker="c"), ps.mul, dtype=dtype)
         for dtype in ["bool", "floatX", "int8", "uint8"]:
-            self.with_mode(Mode(linker="c"), ps.scalar_minimum, dtype=dtype)
-            self.with_mode(Mode(linker="c"), ps.scalar_maximum, dtype=dtype)
+            self.with_mode(Mode(linker="c"), ps.minimum, dtype=dtype)
+            self.with_mode(Mode(linker="c"), ps.maximum, dtype=dtype)
             self.with_mode(Mode(linker="c"), ps.and_, dtype=dtype, tensor_op=pt_all)
             self.with_mode(Mode(linker="c"), ps.or_, dtype=dtype, tensor_op=pt_any)
         for dtype in ["bool", "int8", "uint8"]:
@@ -678,12 +674,8 @@ def test_c_nan(self):
             self.with_mode(Mode(linker="c"), ps.add, dtype=dtype, test_nan=True)
             self.with_mode(Mode(linker="c"), ps.mul, dtype=dtype, test_nan=True)
         for dtype in ["floatX"]:
-            self.with_mode(
-                Mode(linker="c"), ps.scalar_minimum, dtype=dtype, test_nan=True
-            )
-            self.with_mode(
-                Mode(linker="c"), ps.scalar_maximum, dtype=dtype, test_nan=True
-            )
+            self.with_mode(Mode(linker="c"), ps.minimum, dtype=dtype, test_nan=True)
+            self.with_mode(Mode(linker="c"), ps.maximum, dtype=dtype, test_nan=True)
 
     def test_infer_shape(self, dtype=None, pre_scalar_op=None):
         if dtype is None: