replace aesara.tensor acroynm to at

Author: farhanreynaldo

RELEASE-NOTES.md

@@ -2,7 +2,7 @@
 
 ## PyMC3 vNext (4.0.0)
 ### Breaking Changes
-- ⚠ Theano-PyMC has been replaced with Aesara, so all external references to `theano`, `tt`, and `pymc3.theanof` need to be replaced with `aesara`, `aet`, and `pymc3.aesaraf` (see [4471](https://github.com/pymc-devs/pymc3/pull/4471)).
+- ⚠ Theano-PyMC has been replaced with Aesara, so all external references to `theano`, `tt`, and `pymc3.theanof` need to be replaced with `aesara`, `at`, and `pymc3.aesaraf` (see [4471](https://github.com/pymc-devs/pymc3/pull/4471)).
 - ArviZ `plots` and `stats` *wrappers* were removed. The functions are now just available by their original names (see [#4549](https://github.com/pymc-devs/pymc3/pull/4471) and `3.11.2` release notes).
 - ...
 

benchmarks/benchmarks/benchmarks.py

@@ -15,7 +15,7 @@
 import timeit
 
 import aesara
-import aesara.tensor as aet
+import aesara.tensor as at
 import arviz as az
 import numpy as np
 import pandas as pd
@@ -61,8 +61,8 @@ def mixture_model(random_seed=1234):
         mu = pm.Normal("mu", mu=0.0, sd=10.0, shape=w_true.shape)
         enforce_order = pm.Potential(
             "enforce_order",
-            aet.switch(mu[0] - mu[1] <= 0, 0.0, -np.inf)
-            + aet.switch(mu[1] - mu[2] <= 0, 0.0, -np.inf),
+            at.switch(mu[0] - mu[1] <= 0, 0.0, -np.inf)
+            + at.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/Advanced_usage_of_Aesara_in_PyMC3.rst

@@ -14,7 +14,7 @@ Shared variables allow us to use values in Aesara functions that are
 not considered an input to the function, but can still be changed
 later. They are very similar to global variables in may ways::
 
-    a = aet.scalar('a')
+    a = at.scalar('a')
     # Create a new shared variable with initial value of 0.1
     b = aesara.shared(0.1)
     func = aesara.function([a], a * b)
@@ -184,13 +184,13 @@ We get
 Now, we use this to define a Aesara `Op`, that also computes the gradient::
 
     import aesara
-    import aesara.tensor as aet
+    import aesara.tensor as at
     import aesara.tests.unittest_tools
     from aesara.graph.op import Op
 
     class MuFromTheta(Op):
-        itypes = [aet.dscalar]
-        otypes = [aet.dscalar]
+        itypes = [at.dscalar]
+        otypes = [at.dscalar]
 
         def perform(self, node, inputs, outputs):
             theta, = inputs
@@ -201,7 +201,7 @@ Now, we use this to define a Aesara `Op`, that also computes the gradient::
             theta, = inputs
             mu = self(theta)
             thetamu = theta * mu
-            return [- g[0] * mu ** 2 / (1 + thetamu + aet.exp(-thetamu))]
+            return [- g[0] * mu ** 2 / (1 + thetamu + at.exp(-thetamu))]
 
 If you value your sanity, always check that the gradient is ok::
 
@@ -213,11 +213,11 @@ We can now define our model using this new `Op`::
 
     import pymc3 as pm
 
-    aet_mu_from_theta = MuFromTheta()
+    at_mu_from_theta = MuFromTheta()
 
     with pm.Model() as model:
         theta = pm.HalfNormal('theta', sigma=1)
-        mu = pm.Deterministic('mu', aet_mu_from_theta(theta))
+        mu = pm.Deterministic('mu', at_mu_from_theta(theta))
         pm.Normal('y', mu=mu, sigma=0.1, observed=[0.2, 0.21, 0.3])
 
         trace = pm.sample()

docs/source/PyMC3_and_Aesara.rst

@@ -34,25 +34,25 @@ First, we need to define symbolic variables for our inputs (this
 is similar to eg SymPy's `Symbol`)::
 
     import aesara
-    import aesara.tensor as aet
+    import aesara.tensor as at
     # We don't specify the dtype of our input variables, so it
     # defaults to using float64 without any special config.
-    a = aet.scalar('a')
-    x = aet.vector('x')
-    # `aet.ivector` creates a symbolic vector of integers.
-    y = aet.ivector('y')
+    a = at.scalar('a')
+    x = at.vector('x')
+    # `at.ivector` creates a symbolic vector of integers.
+    y = at.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 = aet.exp(inner).sum()
+    out = at.exp(inner).sum()
 
 .. note::
 
-   In this example we use `aet.exp` to create a symbolic representation
+   In this example we use `at.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 Aesara variables can be operated on
 like NumPy arrays. Most NumPy functions are available in `aesara.tensor`
-(which is typically imported as `aet`). A lot of linear algebra operations
-can be found in `aet.nlinalg` and `aet.slinalg` (the NumPy and SciPy
+(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
 operations respectively). Some support for sparse matrices is available
 in `aesara.sparse`. For a detailed overview of available operations,
 see `the aesara api docs <https://aesara.readthedocs.io/en/latest/library/tensor/index.html>`_.
@@ -88,9 +88,9 @@ NumPy arrays are operations involving conditional execution.
 
 Code like this won't work as expected::
 
-    a = aet.vector('a')
+    a = at.vector('a')
     if (a > 0).all():
-        b = aet.sqrt(a)
+        b = at.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 = aet.vector('a')
-    b = aet.sqrt(a)
+    a = at.vector('a')
+    b = at.sqrt(a)
 
-To get the desired behaviour, we can use `aet.switch`::
+To get the desired behaviour, we can use `at.switch`::
 
-    a = aet.vector('a')
-    b = aet.switch((a > 0).all(), aet.sqrt(a), -a)
+    a = at.vector('a')
+    b = at.switch((a > 0).all(), at.sqrt(a), -a)
 
 Indexing also works similarly to NumPy::
 
-    a = aet.vector('a')
+    a = at.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 `aet.set_subtensor`::
+Changing elements of an array is possible using `at.set_subtensor`::
 
-    a = aet.vector('a')
-    b = aet.set_subtensor(a[:10], 1)
+    a = at.vector('a')
+    b = at.set_subtensor(a[:10], 1)
 
     # is roughly equivalent to this (although aesara avoids
     # the copy if `a` isn't used anymore)
@@ -167,7 +167,7 @@ this is happening::
     # in exactly this way!
     model = pm.Model()
 
-    mu = aet.scalar('mu')
+    mu = at.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 = aet.scalar('mu')
+    mu = at.scalar('mu')
     model.add_free_variable(mu)
     model.add_logp_term(pm.Normal.dist(0, 1).logp(mu))
 
-    sd_log__ = aet.scalar('sd_log__')
+    sd_log__ = at.scalar('sd_log__')
     model.add_free_variable(sd_log__)
     model.add_logp_term(corrected_logp_half_normal(sd_log__))
 
-    sd = aet.exp(sd_log__)
+    sd = at.exp(sd_log__)
     model.add_deterministic_variable(sd)
 
     model.add_logp_term(pm.Normal.dist(mu, sd).logp(data))
@@ -214,8 +214,8 @@ Aesara operation on them::
 
     design_matrix = np.array([[...]])
     with pm.Model() as model:
-        # beta is a aet.dvector
+        # beta is a at.dvector
         beta = pm.Normal('beta', 0, 1, shape=len(design_matrix))
-        predict = aet.dot(design_matrix, beta)
+        predict = at.dot(design_matrix, beta)
         sd = pm.HalfCauchy('sd', beta=2.5)
         pm.Normal('y', mu=predict, sigma=sd, observed=data)

docs/source/developer_guide.rst

@@ -417,11 +417,11 @@ usually created in order to optimise performance. But getting a
     class Exp(tr.ElemwiseTransform):
         name = "exp"
         def backward(self, x):
-            return aet.log(x)
+            return at.log(x)
         def forward(self, x):
-            return aet.exp(x)
+            return at.exp(x)
         def jacobian_det(self, x):
-            return -aet.log(x)
+            return -at.log(x)
 
     lognorm = Exp().apply(pm.Normal.dist(0., 1.))
     lognorm
@@ -562,7 +562,7 @@ sum them together to get the model logp:
         """Aesara scalar of log-probability of the model"""
         with self:
             factors = [var.logpt for var in self.basic_RVs] + self.potentials
-            logp = aet.sum([aet.sum(factor) for factor in factors])
+            logp = at.sum([at.sum(factor) for factor in factors])
             ...
             return logp
 
@@ -660,7 +660,7 @@ does not edit or rewrite the graph directly.
             self._vars_joined, self._logpt_joined = self._build_joined(
                 self._logpt, grad_vars, self._ordering.vmap)
 
-            grad = aet.grad(self._logpt_joined, self._vars_joined)
+            grad = at.grad(self._logpt_joined, self._vars_joined)
             grad.name = '__grad'
 
             inputs = [self._vars_joined]
@@ -670,7 +670,7 @@ does not edit or rewrite the graph directly.
 
 
         def _build_joined(self, logpt, args, vmap):
-            args_joined = aet.vector('__args_joined')
+            args_joined = at.vector('__args_joined')
             args_joined.tag.test_value = np.zeros(self.size, dtype=self.dtype)
 
             joined_slices = {}