Change import pytensor.tensor as at to as pt everywhere

Change `import pytensor.scalar as aes` to `as ps` everywhere

Change `import pytensor.tensor.random as aer` to `as ptr` everywhere

Change test variables with `_at` suffix or `at_` prefix to `_pt` and `pt_`, respectively

Author: jessegrabowski

doc/extending/creating_a_numba_jax_op.rst

@@ -135,16 +135,16 @@ Here's a small example of a test for :class:`Eye`:
 
 .. code:: python
 
-   import pytensor.tensor as at
+   import pytensor.tensor as pt
 
    def test_jax_Eye():
        """Test JAX conversion of the `Eye` `Op`."""
 
        # Create a symbolic input for `Eye`
-       x_at = at.scalar()
+       x_at = pt.scalar()
 
        # Create a variable that is the output of an `Eye` `Op`
-       eye_var = at.eye(x_at)
+       eye_var = pt.eye(x_at)
 
        # Create an PyTensor `FunctionGraph`
        out_fg = FunctionGraph(outputs=[eye_var])

doc/extending/creating_an_op.rst

@@ -786,7 +786,7 @@ signature:
 .. testcode:: asop
 
     import pytensor
-    import pytensor.tensor as at
+    import pytensor.tensor as pt
     import numpy as np
     from pytensor import function
     from pytensor.compile.ops import as_op
@@ -797,17 +797,17 @@ signature:
         return [ashp[:-1] + bshp[-1:]]
 
 
-    @as_op(itypes=[at.matrix, at.matrix],
-           otypes=[at.matrix], infer_shape=infer_shape_numpy_dot)
+    @as_op(itypes=[pt.matrix, pt.matrix],
+           otypes=[pt.matrix], infer_shape=infer_shape_numpy_dot)
     def numpy_dot(a, b):
        return np.dot(a, b)
 
 You can try it as follows:
 
 .. testcode:: asop
 
-    x = at.matrix()
-    y = at.matrix()
+    x = pt.matrix()
+    y = pt.matrix()
     f = function([x, y], numpy_dot(x, y))
     inp1 = np.random.random_sample((5, 4))
     inp2 = np.random.random_sample((4, 7))

doc/extending/graph_rewriting.rst

@@ -443,7 +443,7 @@ The following is an example that distributes dot products across additions.
 .. code::
 
     import pytensor
-    import pytensor.tensor as at
+    import pytensor.tensor as pt
     from pytensor.graph.rewriting.kanren import KanrenRelationSub
     from pytensor.graph.rewriting.basic import EquilibriumGraphRewriter
     from pytensor.graph.rewriting.utils import rewrite_graph
@@ -462,7 +462,7 @@ The following is an example that distributes dot products across additions.
     )
 
     # Tell `kanren` that `add` is associative
-    fact(associative, at.add)
+    fact(associative, pt.add)
 
 
     def dot_distributeo(in_lv, out_lv):
@@ -473,13 +473,13 @@ The following is an example that distributes dot products across additions.
             # Make sure the input is a `_dot`
             eq(in_lv, etuple(_dot, A_lv, add_term_lv)),
             # Make sure the term being `_dot`ed is an `add`
-            heado(at.add, add_term_lv),
+            heado(pt.add, add_term_lv),
             # Flatten the associative pairings of `add` operations
             assoc_flatten(add_term_lv, add_flat_lv),
             # Get the flattened `add` arguments
             tailo(add_cdr_lv, add_flat_lv),
             # Add all the `_dot`ed arguments and set the output
-            conso(at.add, dot_cdr_lv, out_lv),
+            conso(pt.add, dot_cdr_lv, out_lv),
             # Apply the `_dot` to all the flattened `add` arguments
             mapo(lambda x, y: conso(_dot, etuple(A_lv, x), y), add_cdr_lv, dot_cdr_lv),
         )
@@ -490,10 +490,10 @@ The following is an example that distributes dot products across additions.
 
 Below, we apply `dot_distribute_rewrite` to a few example graphs.  First we create simple test graph:
 
->>> x_at = at.vector("x")
->>> y_at = at.vector("y")
->>> A_at = at.matrix("A")
->>> test_at = A_at.dot(x_at + y_at)
+>>> x_at = pt.vector("x")
+>>> y_at = pt.vector("y")
+>>> A_at = pt.matrix("A")
+>>> test_at = A_pt.dot(x_at + y_at)
 >>> print(pytensor.pprint(test_at))
 (A @ (x + y))
 
@@ -506,18 +506,18 @@ Next we apply the rewrite to the graph:
 We see that the dot product has been distributed, as desired.  Now, let's try a
 few more test cases:
 
->>> z_at = at.vector("z")
->>> w_at = at.vector("w")
->>> test_at = A_at.dot((x_at + y_at) + (z_at + w_at))
+>>> z_at = pt.vector("z")
+>>> w_at = pt.vector("w")
+>>> test_at = A_pt.dot((x_at + y_at) + (z_at + w_at))
 >>> print(pytensor.pprint(test_at))
 (A @ ((x + y) + (z + w)))
 >>> res = rewrite_graph(test_at, include=[], custom_rewrite=dot_distribute_rewrite, clone=False)
 >>> print(pytensor.pprint(res))
 (((A @ x) + (A @ y)) + ((A @ z) + (A @ w)))
 
->>> B_at = at.matrix("B")
->>> w_at = at.vector("w")
->>> test_at = A_at.dot(x_at + (y_at + B_at.dot(z_at + w_at)))
+>>> B_at = pt.matrix("B")
+>>> w_at = pt.vector("w")
+>>> test_at = A_pt.dot(x_at + (y_at + B_pt.dot(z_at + w_at)))
 >>> print(pytensor.pprint(test_at))
 (A @ (x + (y + ((B @ z) + (B @ w)))))
 >>> res = rewrite_graph(test_at, include=[], custom_rewrite=dot_distribute_rewrite, clone=False)

doc/extending/graphstructures.rst

@@ -28,10 +28,10 @@ The following illustrates these elements:
 
 .. testcode::
 
-   import pytensor.tensor as at
+   import pytensor.tensor as pt
 
-   x = at.dmatrix('x')
-   y = at.dmatrix('y')
+   x = pt.dmatrix('x')
+   y = pt.dmatrix('y')
    z = x + y
 
 **Diagram**

doc/extending/unittest.rst

@@ -98,13 +98,13 @@ Example:
 .. code-block:: python
 
     import numpy as np
-    import pytensor.tensor as at
+    import pytensor.tensor as pt
 
 
     def test_dot_validity():
-        a = at.dmatrix('a')
-        b = at.dmatrix('b')
-        c = at.dot(a, b)
+        a = pt.dmatrix('a')
+        b = pt.dmatrix('b')
+        c = pt.dot(a, b)
 
         c_fn = pytensor.function([a, b], [c])
 
@@ -187,7 +187,7 @@ symbolic variable:
 
     def test_verify_exprgrad():
         def fun(x,y,z):
-            return (x + at.cos(y)) / (4 * z)**2
+            return (x + pt.cos(y)) / (4 * z)**2
 
         x_val = np.asarray([[1], [1.1], [1.2]])
         y_val = np.asarray([0.1, 0.2])
@@ -207,7 +207,7 @@ Here is an example showing how to use :func:`verify_grad` on an :class:`Op` inst
         """
         a_val = np.asarray([[0,1,2],[3,4,5]], dtype='float64')
         rng = np.random.default_rng(42)
-        pytensor.gradient.verify_grad(at.Flatten(), [a_val], rng=rng)
+        pytensor.gradient.verify_grad(pt.Flatten(), [a_val], rng=rng)
 
 .. note::
 

doc/library/compile/io.rst

@@ -80,7 +80,7 @@ A non-None `value` argument makes an In() instance an optional parameter
 of the compiled function.  For example, in the following code we are
 defining an arity-2 function ``inc``.
 
->>> import pytensor.tensor as at
+>>> import pytensor.tensor as pt
 >>> from pytensor import function
 >>> from pytensor.compile.io import In
 >>> u, x, s = pt.scalars('u', 'x', 's')

doc/library/compile/nanguardmode.rst

@@ -25,12 +25,12 @@ of abnormal values: NaNs, Infs, and abnormally big values.
 
     import numpy as np
     import pytensor
-    import pytensor.tensor as at
+    import pytensor.tensor as pt
     from pytensor.compile.nanguardmode import NanGuardMode
 
-    x = at.matrix()
+    x = pt.matrix()
     w = pytensor.shared(np.random.standard_normal((5, 7)).astype(pytensor.config.floatX))
-    y = at.dot(x, w)
+    y = pt.dot(x, w)
     fun = pytensor.function(
         [x], y,
         mode=NanGuardMode(nan_is_error=True, inf_is_error=True, big_is_error=True)

doc/library/d3viz/index.ipynb

@@ -71,7 +71,7 @@
    "outputs": [],
    "source": [
     "import pytensor\n",
-    "import pytensor.tensor as at\n",
+    "import pytensor.tensor as pt\n",
     "import numpy as np"
    ]
   },

doc/library/scan.rst

@@ -164,7 +164,7 @@ downcast** of the latter.
 
     import numpy as np
     import pytensor
-    import pytensor.tensor as at
+    import pytensor.tensor as pt
 
     up_to = pt.iscalar("up_to")
 
@@ -257,7 +257,7 @@ the following:
 .. testcode:: scan1
 
     import pytensor
-    import pytensor.tensor as at
+    import pytensor.tensor as pt
     import numpy as np
 
     rng = np.random.default_rng(203940)

doc/library/tensor/basic.rst

@@ -10,7 +10,7 @@ Basic Tensor Functionality
 
    import numpy as np
    import pytensor
-   import pytensor.tensor as at
+   import pytensor.tensor as pt
    from pytensor.tensor.type import scalar, iscalar, TensorType, dmatrix, ivector, fmatrix
    from pytensor.tensor import set_subtensor, inc_subtensor, batched_dot
    from pytensor import shared
@@ -1220,7 +1220,7 @@ Casting
 
     .. testcode:: cast
 
-        import pytensor.tensor as at
+        import pytensor.tensor as pt
         x = pt.matrix()
         x_as_int = pt.cast(x, 'int32')
 
@@ -1256,7 +1256,7 @@ The six usual equality and inequality operators share the same interface.
 
   .. testcode:: oper
 
-    import pytensor.tensor as at
+    import pytensor.tensor as pt
     x,y = pt.dmatrices('x','y')
     z = pt.le(x,y)
 
@@ -1349,7 +1349,7 @@ Condition
 
     .. testcode:: switch
 
-      import pytensor.tensor as at
+      import pytensor.tensor as pt
       a,b = pt.dmatrices('a','b')
       x,y = pt.dmatrices('x','y')
       z = pt.switch(pt.lt(a,b), x, y)
@@ -1420,7 +1420,7 @@ Here is an example using the bit-wise ``and_`` via the ``&`` operator:
 
 .. testcode:: bitwise
 
-    import pytensor.tensor as at
+    import pytensor.tensor as pt
     x,y = pt.imatrices('x','y')
     z = x & y
 

pytensor/breakpoint.py

@@ -36,11 +36,11 @@ class PdbBreakpoint(Op):
     .. code-block:: python
 
         import pytensor
-        import pytensor.tensor as at
+        import pytensor.tensor as pt
         from pytensor.breakpoint import PdbBreakpoint
 
-        input = at.fvector()
-        target = at.fvector()
+        input = pt.fvector()
+        target = pt.fvector()
 
         # Mean squared error between input and target
         mse = (input - target) ** 2
@@ -49,7 +49,7 @@ class PdbBreakpoint(Op):
         # than 100. The breakpoint will monitor the inputs, targets as well
         # as the individual error values
         breakpointOp = PdbBreakpoint("MSE too high")
-        condition = at.gt(mse.sum(), 100)
+        condition = pt.gt(mse.sum(), 100)
         mse, monitored_input, monitored_target = breakpointOp(condition, mse,
                                                               input, target)
 

pytensor/compile/builders.py

@@ -5,7 +5,7 @@
 from functools import partial
 from typing import Optional, cast
 
-import pytensor.tensor as at
+import pytensor.tensor as pt
 from pytensor import function
 from pytensor.compile.function.pfunc import rebuild_collect_shared
 from pytensor.compile.mode import optdb
@@ -207,7 +207,7 @@ class OpFromGraph(Op, HasInnerGraph):
 
         from pytensor import function, tensor as at
         from pytensor.compile.builders import OpFromGraph
-        x, y, z = at.scalars('xyz')
+        x, y, z = pt.scalars('xyz')
         e = x + y * z
         op = OpFromGraph([x, y, z], [e])
         # op behaves like a normal pytensor op
@@ -223,7 +223,7 @@ class OpFromGraph(Op, HasInnerGraph):
         from pytensor import config, function, tensor as at
         from pytensor.compile.builders import OpFromGraph
 
-        x, y, z = at.scalars('xyz')
+        x, y, z = pt.scalars('xyz')
         s = pytensor.shared(np.random.random((2, 2)).astype(config.floatX))
         e = x + y * z + s
         op = OpFromGraph([x, y, z], [e])
@@ -238,7 +238,7 @@ class OpFromGraph(Op, HasInnerGraph):
         from pytensor import function, tensor as at, grad
         from pytensor.compile.builders import OpFromGraph
 
-        x, y, z = at.scalars('xyz')
+        x, y, z = pt.scalars('xyz')
         e = x + y * z
         def rescale_dy(inps, grads):
             x, y, z = inps
@@ -289,7 +289,7 @@ def _filter_grad_var(grad, inp):
             if hasattr(inp, "zeros_like"):
                 return inp.zeros_like(), grad
             else:
-                return at.constant(0.0), grad
+                return pt.constant(0.0), grad
         else:
             return grad, None
 

pytensor/graph/basic.py

@@ -383,10 +383,10 @@ class Variable(Node, Generic[_TypeType, OptionalApplyType]):
     .. code-block:: python
 
         import pytensor
-        import pytensor.tensor as at
+        import pytensor.tensor as pt
 
-        a = at.constant(1.5)            # declare a symbolic constant
-        b = at.fscalar()                # declare a symbolic floating-point scalar
+        a = pt.constant(1.5)            # declare a symbolic constant
+        b = pt.fscalar()                # declare a symbolic floating-point scalar
 
         c = a + b                       # create a simple expression
 
@@ -565,9 +565,9 @@ def eval(self, inputs_to_values=None):
         --------
 
         >>> import numpy as np
-        >>> import pytensor.tensor as at
-        >>> x = at.dscalar('x')
-        >>> y = at.dscalar('y')
+        >>> import pytensor.tensor as pt
+        >>> x = pt.dscalar('x')
+        >>> y = pt.dscalar('y')
         >>> z = x + y
         >>> np.allclose(z.eval({x : 16.3, y : 12.1}), 28.4)
         True

pytensor/graph/rewriting/kanren.py

@@ -24,15 +24,15 @@ class KanrenRelationSub(NodeRewriter):
 
         from kanren import eq, conso, var
 
-        import pytensor.tensor as at
+        import pytensor.tensor as pt
         from pytensor.graph.rewriting.kanren import KanrenRelationSub
 
 
         def relation(in_lv, out_lv):
-            # A `kanren` goal that changes `at.log` terms to `at.exp`
+            # A `kanren` goal that changes `pt.log` terms to `pt.exp`
             cdr_lv = var()
-            return eq(conso(at.log, cdr_lv, in_lv),
-                    conso(at.exp, cdr_lv, out_lv))
+            return eq(conso(pt.log, cdr_lv, in_lv),
+                    conso(pt.exp, cdr_lv, out_lv))
 
 
         kanren_sub_opt = KanrenRelationSub(relation)