More renaming

Author: jessegrabowski

doc/extending/extending_pytensor_solution_1.py

@@ -14,8 +14,8 @@
 
 class ProdOp(Op):
     def make_node(self, x, y):
-        x = at.as_tensor_variable(x)
-        y = at.as_tensor_variable(y)
+        x = pt.as_tensor_variable(x)
+        y = pt.as_tensor_variable(y)
         outdim = x.type.ndim
         output = TensorType(
             dtype=pytensor.scalar.upcast(x.dtype, y.dtype), shape=(None,) * outdim
@@ -39,8 +39,8 @@ def grad(self, inputs, output_grads):
 
 class SumDiffOp(Op):
     def make_node(self, x, y):
-        x = at.as_tensor_variable(x)
-        y = at.as_tensor_variable(y)
+        x = pt.as_tensor_variable(x)
+        y = pt.as_tensor_variable(y)
         outdim = x.type.ndim
         output1 = TensorType(
             dtype=pytensor.scalar.upcast(x.dtype, y.dtype), shape=(None,) * outdim
@@ -62,20 +62,16 @@ def infer_shape(self, fgraph, node, i0_shapes):
     def grad(self, inputs, output_grads):
         og1, og2 = output_grads
         if og1 is None:
-            og1 = at.zeros_like(og2)
+            og1 = pt.zeros_like(og2)
         if og2 is None:
-            og2 = at.zeros_like(og1)
+            og2 = pt.zeros_like(og1)
         return [og1 + og2, og1 - og2]
 
 
 # 3. Testing apparatus
-
-import numpy as np
-
 from tests import unittest_tools as utt
-from pytensor import tensor as at
+from pytensor import tensor as pt
 from pytensor.graph.basic import Apply
-from pytensor.graph.op import Op
 from pytensor.tensor.type import dmatrix, matrix
 
 
@@ -182,8 +178,8 @@ def infer_shape_numpy_dot(fgraph, node, input_shapes):
 
 
 @as_op(
-    itypes=[at.fmatrix, at.fmatrix],
-    otypes=[at.fmatrix],
+    itypes=[pt.fmatrix, pt.fmatrix],
+    otypes=[pt.fmatrix],
     infer_shape=infer_shape_numpy_dot,
 )
 def numpy_add(a, b):
@@ -197,17 +193,17 @@ def infer_shape_numpy_add_sub(fgraph, node, input_shapes):
 
 
 @as_op(
-    itypes=[at.fmatrix, at.fmatrix],
-    otypes=[at.fmatrix],
+    itypes=[pt.fmatrix, pt.fmatrix],
+    otypes=[pt.fmatrix],
     infer_shape=infer_shape_numpy_add_sub,
 )
 def numpy_add(a, b):
     return np.add(a, b)
 
 
 @as_op(
-    itypes=[at.fmatrix, at.fmatrix],
-    otypes=[at.fmatrix],
+    itypes=[pt.fmatrix, pt.fmatrix],
+    otypes=[pt.fmatrix],
     infer_shape=infer_shape_numpy_add_sub,
 )
 def numpy_sub(a, b):

doc/extending/tips.rst

@@ -20,10 +20,10 @@ simple function:
 
 .. code::
 
-   from pytensor import tensor as at
+   from pytensor import tensor as pt
 
    def sum_square_difference(a, b):
-       return at.sum((a - b)**2)
+       return pt.sum((a - b)**2)
 
 Even without taking PyTensor's rewrites into account, it is likely
 to work just as well as a custom implementation. It also supports all

doc/introduction.rst

@@ -66,7 +66,7 @@ its features, but it illustrates concretely what PyTensor is.
 .. code-block:: python
 
     import pytensor
-    from pytensor import tensor as at
+    from pytensor import tensor as pt
 
     # declare two symbolic floating-point scalars
     a = pt.dscalar()

doc/library/compile/debugmode.rst

@@ -28,10 +28,10 @@ a cluster.
 .. testcode::
 
     import pytensor
-    from pytensor import tensor as at
+    from pytensor import tensor as pt
     from pytensor.compile.debugmode import DebugMode
 
-    x = at.dscalar('x')
+    x = pt.dscalar('x')
 
     f = pytensor.function([x], 10*x, mode='DebugMode')
 

doc/library/compile/io.rst

@@ -183,7 +183,7 @@ method to access values by indexing a Function directly by typing
 To show some examples of these access methods...
 
 
->>> from pytensor import tensor as at, function
+>>> from pytensor import tensor as pt, function
 >>> a, b, c = pt.scalars('xys') # set the internal names of graph nodes
 >>> # Note that the name of c is 's', not 'c'!
 >>> fn = function([a, b, ((c, c+a+b), 10.0)], [])
@@ -236,7 +236,7 @@ Every element of the inputs list will be upgraded to an In instance if necessary
 Example:
 
 >>> import pytensor
->>> from pytensor import tensor as at
+>>> from pytensor import tensor as pt
 >>> from pytensor.compile.io import In
 >>> x = pt.scalar()
 >>> y = pt.scalar('y')

doc/library/printing.rst

@@ -52,7 +52,7 @@ PyTensor also provides :func:`pytensor.printing.pydotprint` that creates a png i
 1) The first is :func:`pytensor.pp`.
 
 >>> from pytensor import pp, grad,
->>> from pytensor import tensor as at
+>>> from pytensor import tensor as pt
 >>> x = pt.dscalar('x')
 >>> y = x ** 2
 >>> gy = grad(y, x)

doc/library/scan.rst

@@ -460,7 +460,7 @@ construct a function that computes one iteration step :
 .. testsetup:: scan3
 
    import pytensor
-   from pytensor import tensor as at
+   from pytensor import tensor as pt
 
 .. testcode:: scan3
 

doc/sandbox/logistic_regression_example.rst

@@ -13,25 +13,25 @@ BUT, YOU GOTTA RUN THIS CODE AND MAKE SURE IT STILL WORKS NICELY, HEY?
     def build_logistic_regression_model(n_in, n_out, l2_coef=30.0)
         # DECLARE SOME VARIABLES
 
-        import tensor as at
+        import pytensor.tensor as pt
 
-        x = at.matrix()  #our points, one point per row
-        y = at.matrix()  #store our labels as place codes (label 3 of 5 is vector [00100])
+        x = pt.matrix()  #our points, one point per row
+        y = pt.matrix()  #store our labels as place codes (label 3 of 5 is vector [00100])
 
-        w = at.matrix()  #the linear transform to apply to our input points
-        b = at.vector()  #a vector of biases, which make our transform affine instead of linear
+        w = pt.matrix()  #the linear transform to apply to our input points
+        b = pt.vector()  #a vector of biases, which make our transform affine instead of linear
 
-        stepsize = at.scalar('stepsize')  # a stepsize for gradient descent
+        stepsize = pt.scalar('stepsize')  # a stepsize for gradient descent
 
         # REGRESSION MODEL AND COSTS TO MINIMIZE
 
-        prediction = at.softmax(at.dot(x, w) + b)
-        cross_entropy = at.sum(y * at.log(prediction), axis=1)
-        cost = at.sum(cross_entropy) + l2_coef * at.sum(at.sum(w*w))
+        prediction = pt.softmax(pt.dot(x, w) + b)
+        cross_entropy = pt.sum(y * pt.log(prediction), axis=1)
+        cost = pt.sum(cross_entropy) + l2_coef * pt.sum(pt.sum(w*w))
 
         # GET THE GRADIENTS NECESSARY TO FIT OUR PARAMETERS
 
-        grad_w, grad_b = at.grad(cost, [w, b])
+        grad_w, grad_b = pt.grad(cost, [w, b])
 
         #
         # GET THE GRADIENTS NECESSARY TO FIT OUR PARAMETERS

doc/tutorial/conditions.rst

@@ -20,7 +20,7 @@ IfElse vs Switch
 
 .. testcode::
 
-   from pytensor import tensor as at
+   from pytensor import tensor as pt
    from pytensor.ifelse import ifelse
    import pytensor, time, numpy
 

pytensor/compile/builders.py

@@ -205,7 +205,7 @@ class OpFromGraph(Op, HasInnerGraph):
 
     .. code-block:: python
 
-        from pytensor import function, tensor as at
+        from pytensor import function, tensor as pt
         from pytensor.compile.builders import OpFromGraph
         x, y, z = pt.scalars('xyz')
         e = x + y * z
@@ -220,7 +220,7 @@ class OpFromGraph(Op, HasInnerGraph):
 
         import numpy as np
         import pytensor
-        from pytensor import config, function, tensor as at
+        from pytensor import config, function, tensor as pt
         from pytensor.compile.builders import OpFromGraph
 
         x, y, z = pt.scalars('xyz')
@@ -235,7 +235,7 @@ class OpFromGraph(Op, HasInnerGraph):
 
     .. code-block:: python
 
-        from pytensor import function, tensor as at, grad
+        from pytensor import function, tensor as pt, grad
         from pytensor.compile.builders import OpFromGraph
 
         x, y, z = pt.scalars('xyz')

pytensor/scan/checkpoints.py

@@ -1,4 +1,4 @@
-import pytensor.tensor.basic as at
+import pytensor.tensor.basic as ptb
 from pytensor.scan.basic import scan
 from pytensor.tensor.basic import Join
 from pytensor.tensor.math import ceil, eq
@@ -117,12 +117,12 @@ def scan_checkpoints(
         n_steps = sequences[0].shape[0]
 
     # Compute the number of steps of the outer scan
-    o_n_steps = at.cast(ceil(n_steps / save_every_N), "int64")
+    o_n_steps = ptb.cast(ceil(n_steps / save_every_N), "int64")
 
     # Compute the number of steps of the inner scan
-    i_n_steps = save_every_N * at.ones((o_n_steps,), "int64")
+    i_n_steps = save_every_N * ptb.ones((o_n_steps,), "int64")
     mod = n_steps % save_every_N
-    last_n_steps = at.switch(eq(mod, 0), save_every_N, mod)
+    last_n_steps = ptb.switch(eq(mod, 0), save_every_N, mod)
     i_n_steps = set_subtensor(i_n_steps[-1], last_n_steps)
 
     # Pad the sequences if needed
@@ -131,7 +131,7 @@ def scan_checkpoints(
         join = Join(view=0)
         for i, s in enumerate(sequences):
             n = s.shape[0] % save_every_N
-            z = at.zeros((n, s.shape[1:]), dtype=s.dtype)
+            z = ptb.zeros((n, s.shape[1:]), dtype=s.dtype)
             sequences[i] = join(0, [s, z])
 
     # Establish the input variables of the outer scan

pytensor/scan/op.py

@@ -55,7 +55,7 @@
 
 import pytensor
 import pytensor.link.utils as link_utils
-from pytensor import tensor as at
+from pytensor import tensor as pt
 from pytensor.compile.builders import construct_nominal_fgraph, infer_shape
 from pytensor.compile.function.pfunc import pfunc
 from pytensor.compile.io import In, Out
@@ -2568,7 +2568,7 @@ def compute_all_gradients(known_grads):
         # mask inputs that get no gradients
         for dx in range(len(dC_dinps_t)):
             if not dC_dinps_t[dx]:
-                dC_dinps_t[dx] = at.zeros_like(diff_inputs[dx])
+                dC_dinps_t[dx] = pt.zeros_like(diff_inputs[dx])
             else:
                 disconnected_dC_dinps_t[dx] = False
                 for Xt, Xt_placeholder in zip(diff_outputs[info.n_mit_mot_outs :], Xts):
@@ -2696,7 +2696,7 @@ def compute_all_gradients(known_grads):
         for idx, taps in enumerate(info.mit_mot_in_slices):
             if isinstance(dC_douts[idx].type, DisconnectedType):
                 out = outs[idx]
-                outer_inp_mitmot.append(at.zeros_like(out))
+                outer_inp_mitmot.append(pt.zeros_like(out))
             else:
                 outer_inp_mitmot.append(dC_douts[idx][::-1])
             mitmot_inp_taps.append([])
@@ -2723,7 +2723,7 @@ def compute_all_gradients(known_grads):
                     # We cannot use Null in the inner graph, so we
                     # use a zero tensor of the appropriate shape instead.
                     inner_out_mitmot.append(
-                        at.zeros(diff_inputs[ins_pos].shape, dtype=config.floatX)
+                        pt.zeros(diff_inputs[ins_pos].shape, dtype=config.floatX)
                     )
                     undefined_msg = dC_dinps_t[ins_pos].type.why_null
                 else:
@@ -2792,7 +2792,7 @@ def compute_all_gradients(known_grads):
                     # We cannot use Null in the inner graph, so we
                     # use a zero tensor of the appropriate shape instead.
                     inner_out_mitmot.append(
-                        at.zeros(diff_inputs[ins_pos].shape, dtype=config.floatX)
+                        pt.zeros(diff_inputs[ins_pos].shape, dtype=config.floatX)
                     )
                     undefined_msg = dC_dinps_t[ins_pos].type.why_null
                 else:
@@ -2834,11 +2834,11 @@ def compute_all_gradients(known_grads):
                     # floatX instead, as it is a dummy value that will not
                     # be used anyway.
                     outer_inp_mitmot.append(
-                        at.zeros(outs[idx + offset].shape, dtype=config.floatX)
+                        pt.zeros(outs[idx + offset].shape, dtype=config.floatX)
                     )
                 else:
                     outer_inp_mitmot.append(
-                        at.zeros(
+                        pt.zeros(
                             outs[idx + offset].shape, dtype=dC_dinps_t[ins_pos].dtype
                         )
                     )
@@ -2847,7 +2847,7 @@ def compute_all_gradients(known_grads):
                 # We cannot use Null in the inner graph, so we
                 # use a zero tensor of the appropriate shape instead.
                 inner_out_mitmot.append(
-                    at.zeros(diff_inputs[ins_pos].shape, dtype=config.floatX)
+                    pt.zeros(diff_inputs[ins_pos].shape, dtype=config.floatX)
                 )
             else:
                 inner_out_mitmot.append(dC_dinps_t[ins_pos])
@@ -2887,7 +2887,7 @@ def compute_all_gradients(known_grads):
                 type_outs.append(vl.type.why_null)
                 # Replace the inner output with a zero tensor of
                 # the right shape
-                inner_out_sitsot[_p] = at.zeros(
+                inner_out_sitsot[_p] = pt.zeros(
                     diff_inputs[ins_pos + _p].shape, dtype=config.floatX
                 )
             elif through_shared:
@@ -2906,7 +2906,7 @@ def compute_all_gradients(known_grads):
                 type_outs.append(vl.type.why_null)
                 # Replace the inner output with a zero tensor of
                 # the right shape
-                inner_out_nitsot[_p] = at.zeros(
+                inner_out_nitsot[_p] = pt.zeros(
                     diff_inputs[_p].shape, dtype=config.floatX
                 )
 
@@ -2924,19 +2924,19 @@ def compute_all_gradients(known_grads):
             if isinstance(y.type, NullType):
                 # Cannot use dC_dXtm1s.dtype, so we use floatX instead.
                 outer_inp_sitsot.append(
-                    at.zeros(
+                    pt.zeros(
                         [grad_steps + 1] + [x.shape[i] for i in range(x.ndim)],
                         dtype=config.floatX,
                     )
                 )
                 # replace y by a zero tensor of the right shape
-                inner_inp_sitsot[_idx] = at.zeros(
+                inner_inp_sitsot[_idx] = pt.zeros(
                     diff_inputs[ins_pos + _idx].shape, dtype=config.floatX
                 )
 
             else:
                 outer_inp_sitsot.append(
-                    at.zeros(
+                    pt.zeros(
                         [grad_steps + 1] + [x.shape[i] for i in range(x.ndim)],
                         dtype=y.dtype,
                     )
@@ -3008,8 +3008,8 @@ def compute_all_gradients(known_grads):
                     shp = (n_zeros,)
                     if x.ndim > 1:
                         shp = shp + tuple(x.shape[i] for i in range(1, x.ndim))
-                    z = at.zeros(shp, dtype=x.dtype)
-                    x = at.concatenate([x[::-1], z], axis=0)
+                    z = pt.zeros(shp, dtype=x.dtype)
+                    x = pt.concatenate([x[::-1], z], axis=0)
                     gradients.append(x)
                 else:
                     gradients.append(x[::-1])
@@ -3036,8 +3036,8 @@ def compute_all_gradients(known_grads):
                     shp = (n_zeros,)
                     if x.ndim > 1:
                         shp = shp + tuple(x.shape[i] for i in range(1, x.ndim))
-                    z = at.zeros(shp, dtype=x.dtype)
-                    x = at.concatenate([x[::-1], z], axis=0)
+                    z = pt.zeros(shp, dtype=x.dtype)
+                    x = pt.concatenate([x[::-1], z], axis=0)
                     gradients.append(x)
                 else:
                     gradients.append(x[::-1])