pytensor 2.18.1__tar.gz → 2.18.3__tar.gz

{pytensor-2.18.1 → pytensor-2.18.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pytensor
-Version: 2.18.1
+Version: 2.18.3
 Summary: Optimizing compiler for evaluating mathematical expressions on CPUs and GPUs.
 Author-email: pymc-devs <pymc.devs@gmail.com>
 License: .. _license:

{pytensor-2.18.1 → pytensor-2.18.3}/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])

{pytensor-2.18.1 → pytensor-2.18.3}/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,8 +797,8 @@ 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)
 
@@ -806,8 +806,8 @@ 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))

{pytensor-2.18.1 → pytensor-2.18.3}/doc/extending/extending_pytensor_solution_1.py

@@ -14,8 +14,8 @@ from pytensor.tensor.type import TensorType
 
 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 @@ class ProdOp(Op):
 
 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 @@ class SumDiffOp(Op):
     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,8 +193,8 @@ 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):
@@ -206,8 +202,8 @@ def numpy_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):

{pytensor-2.18.1 → pytensor-2.18.3}/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)

{pytensor-2.18.1 → pytensor-2.18.3}/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**

{pytensor-2.18.1 → pytensor-2.18.3}/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

{pytensor-2.18.1 → pytensor-2.18.3}/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::
 

{pytensor-2.18.1 → pytensor-2.18.3}/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.

{pytensor-2.18.1 → pytensor-2.18.3}/doc/introduction.rst

@@ -66,11 +66,11 @@ 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 = at.dscalar()
-    b = at.dscalar()
+    a = pt.dscalar()
+    b = pt.dscalar()
 
     # create a simple expression
     c = a + b

{pytensor-2.18.1 → pytensor-2.18.3}/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')
 

{pytensor-2.18.1 → pytensor-2.18.3}/doc/library/compile/io.rst

@@ -80,10 +80,10 @@ 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 = 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:
@@ -183,8 +183,8 @@ 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
->>> a, b, c = at.scalars('xys') # set the internal names of graph nodes
+>>> 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,12 +236,12 @@ 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 = 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)])

{pytensor-2.18.1 → pytensor-2.18.3}/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)

{pytensor-2.18.1 → pytensor-2.18.3}/doc/library/d3viz/index.ipynb

@@ -70,8 +70,8 @@
    },
    "outputs": [],
    "source": [
-    "import pytensor as th\n",
-    "import pytensor.tensor as at\n",
+    "import pytensor\n",
+    "import pytensor.tensor as pt\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])"
    ]
   },
   {

{pytensor-2.18.1 → pytensor-2.18.3}/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
 

{pytensor-2.18.1 → pytensor-2.18.3}/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)
@@ -52,8 +52,8 @@ 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
->>> x = at.dscalar('x')
+>>> from pytensor import tensor as pt
+>>> 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, ())>``.