Renamed aliases from at to pt

Author: shreyas3156

benchmarks/benchmarks/benchmarks.py

@@ -18,7 +18,7 @@
 import numpy as np
 import pandas as pd
 import pytensor
-import pytensor.tensor as at
+import pytensor.tensor as pt
 
 import pymc as pm
 
@@ -61,8 +61,8 @@ def mixture_model(random_seed=1234):
         mu = pm.Normal("mu", mu=0.0, sigma=10.0, shape=w_true.shape)
         enforce_order = pm.Potential(
             "enforce_order",
-            at.switch(mu[0] - mu[1] <= 0, 0.0, -np.inf)
-            + at.switch(mu[1] - mu[2] <= 0, 0.0, -np.inf),
+            pt.switch(mu[0] - mu[1] <= 0, 0.0, -np.inf)
+            + pt.switch(mu[1] - mu[2] <= 0, 0.0, -np.inf),
         )
         tau = pm.Gamma("tau", alpha=1.0, beta=1.0, shape=w_true.shape)
         pm.NormalMixture("x_obs", w=w, mu=mu, tau=tau, observed=x)

docs/source/PyMC_and_PyTensor.rst

@@ -34,25 +34,25 @@ First, we need to define symbolic variables for our inputs (this
 is similar to eg SymPy's `Symbol`)::
 
     import pytensor
-    import pytensor.tensor as at
+    import pytensor.tensor as pt
     # We don't specify the dtype of our input variables, so it
     # defaults to using float64 without any special config.
-    a = at.scalar('a')
-    x = at.vector('x')
-    # `at.ivector` creates a symbolic vector of integers.
-    y = at.ivector('y')
+    a = pt.scalar('a')
+    x = pt.vector('x')
+    # `pt.ivector` creates a symbolic vector of integers.
+    y = pt.ivector('y')
 
 Next, we use those variables to build up a symbolic representation
 of the output of our function. Note that no computation is actually
 being done at this point. We only record what operations we need to
 do to compute the output::
 
     inner = a * x**3 + y**2
-    out = at.exp(inner).sum()
+    out = pt.exp(inner).sum()
 
 .. note::
 
-   In this example we use `at.exp` to create a symbolic representation
+   In this example we use `pt.exp` to create a symbolic representation
    of the exponential of `inner`. Somewhat surprisingly, it
    would also have worked if we used `np.exp`. This is because numpy
    gives objects it operates on a chance to define the results of
@@ -77,8 +77,8 @@ We can call this function with actual arrays as many times as we want::
 
 For the most part the symbolic PyTensor variables can be operated on
 like NumPy arrays. Most NumPy functions are available in `pytensor.tensor`
-(which is typically imported as `at`). A lot of linear algebra operations
-can be found in `at.nlinalg` and `at.slinalg` (the NumPy and SciPy
+(which is typically imported as `pt`). A lot of linear algebra operations
+can be found in `pt.nlinalg` and `pt.slinalg` (the NumPy and SciPy
 operations respectively). Some support for sparse matrices is available
 in `pytensor.sparse`. For a detailed overview of available operations,
 see :mod:`the pytensor api docs <pytensor.tensor>`.
@@ -88,9 +88,9 @@ NumPy arrays are operations involving conditional execution.
 
 Code like this won't work as expected::
 
-    a = at.vector('a')
+    a = pt.vector('a')
     if (a > 0).all():
-        b = at.sqrt(a)
+        b = pt.sqrt(a)
     else:
         b = -a
 
@@ -100,28 +100,28 @@ and according to the rules for this conversion, things that aren't empty
 containers or zero are converted to `True`. So the code is equivalent
 to this::
 
-    a = at.vector('a')
-    b = at.sqrt(a)
+    a = pt.vector('a')
+    b = pt.sqrt(a)
 
-To get the desired behaviour, we can use `at.switch`::
+To get the desired behaviour, we can use `pt.switch`::
 
-    a = at.vector('a')
-    b = at.switch((a > 0).all(), at.sqrt(a), -a)
+    a = pt.vector('a')
+    b = pt.switch((a > 0).all(), pt.sqrt(a), -a)
 
 Indexing also works similarly to NumPy::
 
-    a = at.vector('a')
+    a = pt.vector('a')
     # Access the 10th element. This will fail when a function build
     # from this expression is executed with an array that is too short.
     b = a[10]
 
     # Extract a subvector
     b = a[[1, 2, 10]]
 
-Changing elements of an array is possible using `at.set_subtensor`::
+Changing elements of an array is possible using `pt.set_subtensor`::
 
-    a = at.vector('a')
-    b = at.set_subtensor(a[:10], 1)
+    a = pt.vector('a')
+    b = pt.set_subtensor(a[:10], 1)
 
     # is roughly equivalent to this (although pytensor avoids
     # the copy if `a` isn't used anymore)
@@ -167,7 +167,7 @@ this is happening::
     # in exactly this way!
     model = pm.Model()
 
-    mu = at.scalar('mu')
+    mu = pt.scalar('mu')
     model.add_free_variable(mu)
     model.add_logp_term(pm.Normal.dist(0, 1).logp(mu))
 
@@ -195,15 +195,15 @@ is roughly equivalent to this::
 
     # For illustration only, not real code!
     model = pm.Model()
-    mu = at.scalar('mu')
+    mu = pt.scalar('mu')
     model.add_free_variable(mu)
     model.add_logp_term(pm.Normal.dist(0, 1).logp(mu))
 
-    sd_log__ = at.scalar('sd_log__')
+    sd_log__ = pt.scalar('sd_log__')
     model.add_free_variable(sd_log__)
     model.add_logp_term(corrected_logp_half_normal(sd_log__))
 
-    sigma = at.exp(sd_log__)
+    sigma = pt.exp(sd_log__)
     model.add_deterministic_variable(sigma)
 
     model.add_logp_term(pm.Normal.dist(mu, sigma).logp(data))
@@ -214,8 +214,8 @@ PyTensor operation on them::
 
     design_matrix = np.array([[...]])
     with pm.Model() as model:
-        # beta is a at.dvector
+        # beta is a pt.dvector
         beta = pm.Normal('beta', 0, 1, shape=len(design_matrix))
-        predict = at.dot(design_matrix, beta)
+        predict = pt.dot(design_matrix, beta)
         sigma = pm.HalfCauchy('sigma', beta=2.5)
         pm.Normal('y', mu=predict, sigma=sigma, observed=data)

docs/source/contributing/implementing_distribution.md

@@ -129,7 +129,7 @@ Here is how the example continues:
 
 ```python
 
-import pytensor.tensor as at
+import pytensor.tensor as pt
 from pymc.pytensorf import floatX, intX
 from pymc.distributions.continuous import PositiveContinuous
 from pymc.distributions.dist_math import check_parameters
@@ -146,12 +146,12 @@ class Blah(PositiveContinuous):
     # We pass the standard parametrizations to super().dist
     @classmethod
     def dist(cls, param1, param2=None, alt_param2=None, **kwargs):
-        param1 = at.as_tensor_variable(intX(param1))
+        param1 = pt.as_tensor_variable(intX(param1))
         if param2 is not None and alt_param2 is not None:
             raise ValueError("Only one of param2 and alt_param2 is allowed.")
         if alt_param2 is not None:
             param2 = 1 / alt_param2
-        param2 = at.as_tensor_variable(floatX(param2))
+        param2 = pt.as_tensor_variable(floatX(param2))
 
         # The first value-only argument should be a list of the parameters that
         # the rv_op needs in order to be instantiated
@@ -161,19 +161,19 @@ class Blah(PositiveContinuous):
     # the variable, given the implicit `rv`, `size` and `param1` ... `paramN`.
     # This is typically a "representative" point such as the the mean or mode.
     def moment(rv, size, param1, param2):
-        moment, _ = at.broadcast_arrays(param1, param2)
+        moment, _ = pt.broadcast_arrays(param1, param2)
         if not rv_size_is_none(size):
-            moment = at.full(size, moment)
+            moment = pt.full(size, moment)
         return moment
 
     # Logp returns a symbolic expression for the elementwise log-pdf or log-pmf evaluation
     # of the variable given the `value` of the variable and the parameters `param1` ... `paramN`.
     def logp(value, param1, param2):
-        logp_expression = value * (param1 + at.log(param2))
+        logp_expression = value * (param1 + pt.log(param2))
 
         # A switch is often used to enforce the distribution support domain
-        bounded_logp_expression = at.switch(
-            at.gt(value >= 0),
+        bounded_logp_expression = pt.switch(
+            pt.gt(value >= 0),
             logp_expression,
             -np.inf,
         )

docs/source/glossary.md

@@ -128,9 +128,9 @@ tensor_like
   Any scalar or sequence that can be interpreted as a {class}`~pytensor.tensor.TensorVariable`. In addition to TensorVariables, this includes NumPy ndarrays, scalars, lists and tuples (possibly nested). Any argument accepted by `pytensor.tensor.as_tensor_variable` is tensor_like.
 
   ```{jupyter-execute}
-  import pytensor.tensor as at
+  import pytensor.tensor as pt
 
-  at.as_tensor_variable([[1, 2.0], [0, 0]])
+  pt.as_tensor_variable([[1, 2.0], [0, 0]])
   ```
 
 :::::

pymc/data.py

@@ -22,7 +22,7 @@
 import numpy as np
 import pandas as pd
 import pytensor
-import pytensor.tensor as at
+import pytensor.tensor as pt
 import xarray as xr
 
 from pytensor.compile.sharedvalue import SharedVariable
@@ -164,7 +164,7 @@ def assert_all_scalars_equal(scalar, *scalars):
     else:
         return Assert(
             "All variables shape[0] in Minibatch should be equal, check your Minibatch(data1, data2, ...) code"
-        )(scalar, at.all([scalar == s for s in scalars]))
+        )(scalar, pt.all([scalar == s for s in scalars]))
 
 
 def Minibatch(variable: TensorVariable, *variables: TensorVariable, batch_size: int):
@@ -185,7 +185,7 @@ def Minibatch(variable: TensorVariable, *variables: TensorVariable, batch_size:
     >>> mdata1, mdata2 = Minibatch(data1, data2, batch_size=10)
     """
 
-    tensor, *tensors = tuple(map(at.as_tensor, (variable, *variables)))
+    tensor, *tensors = tuple(map(pt.as_tensor, (variable, *variables)))
     upper = assert_all_scalars_equal(*[t.shape[0] for t in (tensor, *tensors)])
     slc = minibatch_index(0, upper, size=batch_size)
     for i, v in enumerate((tensor, *tensors)):
@@ -435,7 +435,7 @@ def Data(
     if mutable:
         x = pytensor.shared(arr, name, **kwargs)
     else:
-        x = at.as_tensor_variable(arr, name, **kwargs)
+        x = pt.as_tensor_variable(arr, name, **kwargs)
 
     if isinstance(dims, str):
         dims = (dims,)

pymc/distributions/bound.py

@@ -14,7 +14,7 @@
 import warnings
 
 import numpy as np
-import pytensor.tensor as at
+import pytensor.tensor as pt
 
 from pytensor.tensor import as_tensor_variable
 from pytensor.tensor.random.op import RandomVariable
@@ -72,8 +72,8 @@ def logp(value, distribution, lower, upper):
         -------
         TensorVariable
         """
-        res = at.switch(
-            at.or_(at.lt(value, lower), at.gt(value, upper)),
+        res = pt.switch(
+            pt.or_(pt.lt(value, lower), pt.gt(value, upper)),
             -np.inf,
             logp(distribution, value),
         )
@@ -126,8 +126,8 @@ def logp(value, distribution, lower, upper):
         -------
         TensorVariable
         """
-        res = at.switch(
-            at.or_(at.lt(value, lower), at.gt(value, upper)),
+        res = pt.switch(
+            pt.or_(pt.lt(value, lower), pt.gt(value, upper)),
             -np.inf,
             logp(distribution, value),
         )

pymc/distributions/censored.py

@@ -12,7 +12,7 @@
 #   See the License for the specific language governing permissions and
 #   limitations under the License.
 import numpy as np
-import pytensor.tensor as at
+import pytensor.tensor as pt
 
 from pytensor.tensor import TensorVariable
 from pytensor.tensor.random.op import RandomVariable
@@ -101,16 +101,16 @@ def dist(cls, dist, lower, upper, **kwargs):
 
     @classmethod
     def rv_op(cls, dist, lower=None, upper=None, size=None):
-        lower = at.constant(-np.inf) if lower is None else at.as_tensor_variable(lower)
-        upper = at.constant(np.inf) if upper is None else at.as_tensor_variable(upper)
+        lower = pt.constant(-np.inf) if lower is None else pt.as_tensor_variable(lower)
+        upper = pt.constant(np.inf) if upper is None else pt.as_tensor_variable(upper)
 
         # When size is not specified, dist may have to be broadcasted according to lower/upper
-        dist_shape = size if size is not None else at.broadcast_shape(dist, lower, upper)
+        dist_shape = size if size is not None else pt.broadcast_shape(dist, lower, upper)
         dist = change_dist_size(dist, dist_shape)
 
         # Censoring is achieved by clipping the base distribution between lower and upper
         dist_, lower_, upper_ = dist.type(), lower.type(), upper.type()
-        censored_rv_ = at.clip(dist_, lower_, upper_)
+        censored_rv_ = pt.clip(dist_, lower_, upper_)
 
         return CensoredRV(
             inputs=[dist_, lower_, upper_],
@@ -129,22 +129,22 @@ def change_censored_size(cls, dist, new_size, expand=False):
 
 @_moment.register(CensoredRV)
 def moment_censored(op, rv, dist, lower, upper):
-    moment = at.switch(
-        at.eq(lower, -np.inf),
-        at.switch(
-            at.isinf(upper),
+    moment = pt.switch(
+        pt.eq(lower, -np.inf),
+        pt.switch(
+            pt.isinf(upper),
             # lower = -inf, upper = inf
             0,
             # lower = -inf, upper = x
             upper - 1,
         ),
-        at.switch(
-            at.eq(upper, np.inf),
+        pt.switch(
+            pt.eq(upper, np.inf),
             # lower = x, upper = inf
             lower + 1,
             # lower = x, upper = x
             (lower + upper) / 2,
         ),
     )
-    moment = at.full_like(dist, moment)
+    moment = pt.full_like(dist, moment)
     return moment