Remove scalar_ prefix from several Ops (#1683)

* Initial plan

* Rename ScalarMaximum/ScalarMinimum to Maximum/Minimum

* Apply ruff formatting fixes

* Remove custom names when class name matches desired name

* Remove scalar_ prefix from log1mexp, xlogx, xlogy0 and fix numba imports

* Fix xtensor test to use backward compat aliases in skip list

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>

Author: Copilot

pytensor/link/mlx/dispatch/elemwise.py

@@ -25,11 +25,11 @@
     IsNan,
     Log,
     Log1p,
+    Maximum,
+    Minimum,
     Mul,
     Neg,
     Pow,
-    ScalarMaximum,
-    ScalarMinimum,
     Sign,
     Sin,
     Sqr,
@@ -105,15 +105,15 @@ def any_reduce(x):
     return any_reduce
 
 
-@mlx_funcify_CAReduce_scalar_op.register(ScalarMaximum)
+@mlx_funcify_CAReduce_scalar_op.register(Maximum)
 def mlx_funcify_CARreduce_Maximum(scalar_op, axis):
     def max_reduce(x):
         return mx.max(x, axis=axis)
 
     return max_reduce
 
 
-@mlx_funcify_CAReduce_scalar_op.register(ScalarMinimum)
+@mlx_funcify_CAReduce_scalar_op.register(Minimum)
 def mlx_funcify_CARreduce_Minimum(scalar_op, axis):
     def min_reduce(x):
         return mx.min(x, axis=axis)
@@ -354,13 +354,13 @@ def mlx_funcify_Elemwise_scalar_OR(scalar_op):
     return mx.bitwise_or
 
 
-@mlx_funcify_Elemwise_scalar_op.register(ScalarMaximum)
-def mlx_funcify_Elemwise_scalar_ScalarMaximum(scalar_op):
+@mlx_funcify_Elemwise_scalar_op.register(Maximum)
+def mlx_funcify_Elemwise_scalar_Maximum(scalar_op):
     return mx.maximum
 
 
-@mlx_funcify_Elemwise_scalar_op.register(ScalarMinimum)
-def mlx_funcify_Elemwise_scalar_ScalarMinimum(scalar_op):
+@mlx_funcify_Elemwise_scalar_op.register(Minimum)
+def mlx_funcify_Elemwise_scalar_Minimum(scalar_op):
     return mx.minimum
 
 

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.blas import BatchedDot
@@ -104,16 +104,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}
@@ -459,7 +459,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
@@ -523,7 +523,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

@@ -1855,7 +1855,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)
@@ -1895,10 +1895,14 @@ def L_op(self, inputs, outputs, gout):
         return (gx, gy)
 
 
-scalar_maximum = ScalarMaximum(upcast_out, name="maximum")
+maximum = Maximum(upcast_out)
 
+# Backward compatibility
+ScalarMaximum = Maximum
+scalar_maximum = maximum
 
-class ScalarMinimum(BinaryScalarOp):
+
+class Minimum(BinaryScalarOp):
     commutative = True
     associative = True
     nfunc_spec = ("minimum", 2, 1)
@@ -1937,7 +1941,11 @@ def L_op(self, inputs, outputs, gout):
         return (gx, gy)
 
 
-scalar_minimum = ScalarMinimum(upcast_out, name="minimum")
+minimum = Minimum(upcast_out)
+
+# Backward compatibility
+ScalarMinimum = Minimum
+scalar_minimum = minimum
 
 
 class Add(ScalarOp):

pytensor/scalar/math.py

@@ -32,8 +32,8 @@
     isinf,
     log,
     log1p,
+    maximum,
     reciprocal,
-    scalar_maximum,
     sqrt,
     switch,
     true_div,
@@ -1315,7 +1315,7 @@ def c_code_cache_version(self):
             return v
 
 
-softplus = Softplus(upgrade_to_float, name="scalar_softplus")
+softplus = Softplus(upgrade_to_float)
 
 
 class Log1mexp(UnaryScalarOp):
@@ -1360,7 +1360,7 @@ def c_code(self, node, name, inp, out, sub):
             raise NotImplementedError("only floating point is implemented")
 
 
-log1mexp = Log1mexp(upgrade_to_float, name="scalar_log1mexp")
+log1mexp = Log1mexp(upgrade_to_float)
 
 
 class BetaInc(ScalarOp):
@@ -1585,9 +1585,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(
@@ -1833,7 +1831,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/blas.py

@@ -948,8 +948,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/inplace.py

@@ -357,12 +357,12 @@ def second_inplace(a):
 pprint.assign(fill_inplace, printing.FunctionPrinter(["fill="]))
 
 
-@scalar_elemwise(symbolname="scalar_maximum_inplace")
+@scalar_elemwise
 def maximum_inplace(a, b):
     """elementwise addition (inplace on `a`)"""
 
 
-@scalar_elemwise(symbolname="scalar_minimum_inplace")
+@scalar_elemwise
 def minimum_inplace(a, b):
     """elementwise addition (inplace on `a`)"""
 

pytensor/tensor/math.py

@@ -399,7 +399,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)
@@ -457,7 +457,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)
@@ -2755,7 +2755,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
 
@@ -2791,7 +2791,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/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:

pytensor/tensor/xlogx.py

@@ -31,7 +31,7 @@ def c_code(self, node, name, inputs, outputs, sub):
         raise NotImplementedError("only floatingpoint is implemented")
 
 
-scalar_xlogx = XlogX(ps.upgrade_to_float, name="scalar_xlogx")
+scalar_xlogx = XlogX(ps.upgrade_to_float)
 xlogx = Elemwise(scalar_xlogx, name="xlogx")
 
 
@@ -62,5 +62,5 @@ def c_code(self, node, name, inputs, outputs, sub):
         raise NotImplementedError("only floatingpoint is implemented")
 
 
-scalar_xlogy0 = XlogY0(ps.upgrade_to_float, name="scalar_xlogy0")
+scalar_xlogy0 = XlogY0(ps.upgrade_to_float)
 xlogy0 = Elemwise(scalar_xlogy0, name="xlogy0")

pytensor/xtensor/math.py

@@ -388,11 +388,11 @@ def reciprocal(): ...
 def round(): ...
 
 
-@_as_xelemwise(ps.scalar_maximum)
+@_as_xelemwise(ps.maximum)
 def maximum(): ...
 
 
-@_as_xelemwise(ps.scalar_minimum)
+@_as_xelemwise(ps.minimum)
 def minimum(): ...