Change import pytensor.tensor as at to as pt everywhere in the docs

Author: jessegrabowski

doc/glossary.rst

@@ -6,7 +6,7 @@ Glossary
 .. testsetup::
 
    import pytensor
-   import pytensor.tensor as at
+   import pytensor.tensor as pt
 
 .. glossary::
 
@@ -31,7 +31,7 @@ Glossary
         A variable with an immutable value.
         For example, when you type
 
-        >>> x = at.ivector()
+        >>> x = pt.ivector()
         >>> y = x + 3
 
         Then a `constant` is created to represent the ``3`` in the graph.
@@ -151,7 +151,7 @@ Glossary
         The the main data structure you work with when using PyTensor.
         For example,
 
-        >>> x = at.ivector()
+        >>> x = pt.ivector()
         >>> y = -x**2
 
         ``x`` and ``y`` are both :class:`Variable`\s, i.e. instances of the :class:`Variable` class.

doc/introduction.rst

@@ -69,8 +69,8 @@ its features, but it illustrates concretely what PyTensor is.
     from pytensor import tensor as at
 
     # declare two symbolic floating-point scalars
-    a = at.dscalar()
-    b = at.dscalar()
+    a = pt.dscalar()
+    b = pt.dscalar()
 
     # create a simple expression
     c = a + b

doc/library/compile/io.rst

@@ -83,7 +83,7 @@ defining an arity-2 function ``inc``.
 >>> import pytensor.tensor as at
 >>> from pytensor import function
 >>> from pytensor.compile.io import In
->>> u, x, s = at.scalars('u', 'x', 's')
+>>> u, x, s = pt.scalars('u', 'x', 's')
 >>> inc = function([u, In(x, value=3), In(s, update=(s+x*u), value=10.0)], [])
 
 Since we provided a ``value`` for ``s`` and ``x``, we can call it with just a value for ``u`` like this:
@@ -184,7 +184,7 @@ To show some examples of these access methods...
 
 
 >>> from pytensor import tensor as at, function
->>> a, b, c = at.scalars('xys') # set the internal names of graph nodes
+>>> 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)], [])
 
@@ -238,10 +238,10 @@ Example:
 >>> import pytensor
 >>> from pytensor import tensor as at
 >>> from pytensor.compile.io import In
->>> x = at.scalar()
->>> y = at.scalar('y')
->>> z = at.scalar('z')
->>> w = at.scalar('w')
+>>> x = pt.scalar()
+>>> y = pt.scalar('y')
+>>> z = pt.scalar('z')
+>>> w = pt.scalar('w')
 
 >>> fn = pytensor.function(inputs=[x, y, In(z, value=42), ((w, w+x), 0)],
 ...                      outputs=x + y + z)
@@ -308,7 +308,7 @@ If a list of ``Variable`` or ``Out`` instances is given as argument, then the co
 
 >>> import numpy
 >>> from pytensor.compile.io import Out
->>> x, y, s = at.matrices('xys')
+>>> x, y, s = pt.matrices('xys')
 
 >>> # print a list of 2 ndarrays
 >>> fn1 = pytensor.function([x], [x+x, Out((x+x).T, borrow=True)])

doc/library/d3viz/index.ipynb

@@ -70,7 +70,7 @@
    },
    "outputs": [],
    "source": [
-    "import pytensor as th\n",
+    "import pytensor\n",
     "import pytensor.tensor as at\n",
     "import numpy as np"
    ]
@@ -96,16 +96,16 @@
     "nhiddens = 50\n",
     "\n",
     "rng = np.random.RandomState(0)\n",
-    "x = at.dmatrix('x')\n",
-    "wh = th.shared(rng.normal(0, 1, (nfeatures, nhiddens)), borrow=True)\n",
-    "bh = th.shared(np.zeros(nhiddens), borrow=True)\n",
-    "h = at.sigmoid(at.dot(x, wh) + bh)\n",
+    "x = pt.dmatrix('x')\n",
+    "wh = pytensor.shared(rng.normal(0, 1, (nfeatures, nhiddens)), borrow=True)\n",
+    "bh = pytensor.shared(np.zeros(nhiddens), borrow=True)\n",
+    "h = pt.sigmoid(pt.dot(x, wh) + bh)\n",
     "\n",
-    "wy = th.shared(rng.normal(0, 1, (nhiddens, noutputs)))\n",
-    "by = th.shared(np.zeros(noutputs), borrow=True)\n",
-    "y = at.special.softmax(at.dot(h, wy) + by)\n",
+    "wy = pytensor.shared(rng.normal(0, 1, (nhiddens, noutputs)))\n",
+    "by = pytensor.shared(np.zeros(noutputs), borrow=True)\n",
+    "y = pt.special.softmax(pt.dot(h, wy) + by)\n",
     "\n",
-    "predict = th.function([x], y)"
+    "predict = pytensor.function([x], y)"
    ]
   },
   {
@@ -276,7 +276,7 @@
    },
    "outputs": [],
    "source": [
-    "predict_profiled = th.function([x], y, profile=True)\n",
+    "predict_profiled = pytensor.function([x], y, profile=True)\n",
     "\n",
     "x_val = rng.normal(0, 1, (ninputs, nfeatures))\n",
     "y_val = predict_profiled(x_val)"
@@ -388,12 +388,12 @@
    },
    "outputs": [],
    "source": [
-    "x, y, z = at.scalars('xyz')\n",
-    "e = at.sigmoid((x + y + z)**2)\n",
-    "op = th.compile.builders.OpFromGraph([x, y, z], [e])\n",
+    "x, y, z = pt.scalars('xyz')\n",
+    "e = pt.sigmoid((x + y + z)**2)\n",
+    "op = pytensor.compile.builders.OpFromGraph([x, y, z], [e])\n",
     "\n",
     "e2 = op(x, y, z) + op(z, y, x)\n",
-    "f = th.function([x, y, z], e2)"
+    "f = pytensor.function([x, y, z], e2)"
    ]
   },
   {
@@ -433,13 +433,13 @@
    },
    "outputs": [],
    "source": [
-    "x, y, z = at.scalars('xyz')\n",
+    "x, y, z = pt.scalars('xyz')\n",
     "e = x * y\n",
-    "op = th.compile.builders.OpFromGraph([x, y], [e])\n",
+    "op = pytensor.compile.builders.OpFromGraph([x, y], [e])\n",
     "e2 = op(x, y) + z\n",
-    "op2 = th.compile.builders.OpFromGraph([x, y, z], [e2])\n",
+    "op2 = pytensor.compile.builders.OpFromGraph([x, y, z], [e2])\n",
     "e3 = op2(x, y, z) + z\n",
-    "f = th.function([x, y, z], [e3])"
+    "f = pytensor.function([x, y, z], [e3])"
    ]
   },
   {

doc/library/d3viz/index.rst

@@ -49,8 +49,8 @@ hidden layer and a softmax output layer.
 
 .. code:: python
 
-    import pytensor as th
-    import pytensor.tensor as at
+    import pytensor
+    import pytensor.tensor as pt
     import numpy as np
 
     ninputs = 1000
@@ -59,16 +59,16 @@ hidden layer and a softmax output layer.
     nhiddens = 50
 
     rng = np.random.RandomState(0)
-    x = at.dmatrix('x')
-    wh = th.shared(rng.normal(0, 1, (nfeatures, nhiddens)), borrow=True)
-    bh = th.shared(np.zeros(nhiddens), borrow=True)
-    h = at.sigmoid(at.dot(x, wh) + bh)
+    x = pt.dmatrix('x')
+    wh = pytensor.shared(rng.normal(0, 1, (nfeatures, nhiddens)), borrow=True)
+    bh = pytensor.shared(np.zeros(nhiddens), borrow=True)
+    h = pt.sigmoid(pt.dot(x, wh) + bh)
 
-    wy = th.shared(rng.normal(0, 1, (nhiddens, noutputs)))
-    by = th.shared(np.zeros(noutputs), borrow=True)
-    y = at.special.softmax(at.dot(h, wy) + by)
+    wy = pytensor.shared(rng.normal(0, 1, (nhiddens, noutputs)))
+    by = pytensor.shared(np.zeros(noutputs), borrow=True)
+    y = pt.special.softmax(pt.dot(h, wy) + by)
 
-    predict = th.function([x], y)
+    predict = pytensor.function([x], y)
 
 The function ``predict`` outputs the probability of 10 classes. You can
 visualize it with :py:func:`pytensor.printing.pydotprint` as follows:
@@ -151,7 +151,7 @@ random data:
 
 .. code:: python
 
-    predict_profiled = th.function([x], y, profile=True)
+    predict_profiled = pytensor.function([x], y, profile=True)
 
     x_val = rng.normal(0, 1, (ninputs, nfeatures))
     y_val = predict_profiled(x_val)
@@ -209,12 +209,12 @@ node defines a nested graph, which will be visualized accordingly by ``d3viz``.
 
 .. code:: python
 
-    x, y, z = at.scalars('xyz')
-    e = at.sigmoid((x + y + z)**2)
-    op = th.compile.builders.OpFromGraph([x, y, z], [e])
+    x, y, z = pt.scalars('xyz')
+    e = pt.sigmoid((x + y + z)**2)
+    op = pytensor.compile.builders.OpFromGraph([x, y, z], [e])
 
     e2 = op(x, y, z) + op(z, y, x)
-    f = th.function([x, y, z], e2)
+    f = pytensor.function([x, y, z], e2)
 
 .. code:: python
 
@@ -238,13 +238,13 @@ the following example.
 
 .. code:: python
 
-    x, y, z = at.scalars('xyz')
+    x, y, z = pt.scalars('xyz')
     e = x * y
-    op = th.compile.builders.OpFromGraph([x, y], [e])
+    op = pytensor.compile.builders.OpFromGraph([x, y], [e])
     e2 = op(x, y) + z
-    op2 = th.compile.builders.OpFromGraph([x, y, z], [e2])
+    op2 = pytensor.compile.builders.OpFromGraph([x, y, z], [e2])
     e3 = op2(x, y, z) + z
-    f = th.function([x, y, z], [e3])
+    f = pytensor.function([x, y, z], [e3])
 
 .. code:: python
 

doc/library/printing.rst

@@ -23,8 +23,8 @@ Intermediate values in a computation cannot be printed in
 the normal python way with the print statement, because PyTensor has no *statements*.
 Instead there is the :class:`Print` Op.
 
->>> from pytensor import tensor as at, function, printing
->>> x = at.dvector()
+>>> from pytensor import tensor as pt, function, printing
+>>> x = pt.dvector()
 >>> hello_world_op = printing.Print('hello world')
 >>> printed_x = hello_world_op(x)
 >>> f = function([x], printed_x)
@@ -53,7 +53,7 @@ PyTensor also provides :func:`pytensor.printing.pydotprint` that creates a png i
 
 >>> from pytensor import pp, grad,
 >>> from pytensor import tensor as at
->>> x = at.dscalar('x')
+>>> x = pt.dscalar('x')
 >>> y = x ** 2
 >>> gy = grad(y, x)
 >>> pp(gy)  # print out the gradient prior to rewriting
@@ -62,7 +62,7 @@ PyTensor also provides :func:`pytensor.printing.pydotprint` that creates a png i
 >>> pp(f.maker.fgraph.outputs[0])
 '(TensorConstant{2.0} * x)'
 
-The parameter in at.dscalar('x') in the first line is the name of this variable
+The parameter in pt.dscalar('x') in the first line is the name of this variable
 in the graph. This name is used when printing the graph to make it more readable.
 If no name is provided the variable x is printed as its type as returned by
 ``x.type()``. In this example - ``<TensorType(float64, ())>``.