⬆️ UPGRADE: Autoupdate pre-commit config

Author: twiecki

.pre-commit-config.yaml

@@ -24,7 +24,7 @@ repos:
     - id: pyupgrade
       args: [--py37-plus]
 - repo: https://github.com/psf/black
-  rev: 21.12b0
+  rev: 22.1.0
   hooks:
     - id: black
 - repo: https://github.com/PyCQA/pylint

benchmarks/benchmarks/benchmarks.py

@@ -32,9 +32,9 @@ def glm_hierarchical_model(random_seed=123):
 
     n_counties = len(data.county.unique())
     with pm.Model() as model:
-        mu_a = pm.Normal("mu_a", mu=0.0, sd=100 ** 2)
+        mu_a = pm.Normal("mu_a", mu=0.0, sd=100**2)
         sigma_a = pm.HalfCauchy("sigma_a", 5)
-        mu_b = pm.Normal("mu_b", mu=0.0, sd=100 ** 2)
+        mu_b = pm.Normal("mu_b", mu=0.0, sd=100**2)
         sigma_b = pm.HalfCauchy("sigma_b", 5)
         a = pm.Normal("a", mu=0, sd=1, shape=n_counties)
         b = pm.Normal("b", mu=0, sd=1, shape=n_counties)
@@ -70,7 +70,7 @@ def mixture_model(random_seed=1234):
     # Initialization can be poorly specified, this is a hack to make it work
     start = {
         "mu": mu_true.copy(),
-        "tau_log__": np.log(1.0 / sigma ** 2),
+        "tau_log__": np.log(1.0 / sigma**2),
         "w_stickbreaking__": np.array([-0.03, 0.44]),
     }
     return model, start
@@ -137,8 +137,8 @@ def time_drug_evaluation(self):
             group2_mean = pm.Normal("group2_mean", y_mean, sd=y_std)
             group1_std = pm.Uniform("group1_std", lower=sigma_low, upper=sigma_high)
             group2_std = pm.Uniform("group2_std", lower=sigma_low, upper=sigma_high)
-            lambda_1 = group1_std ** -2
-            lambda_2 = group2_std ** -2
+            lambda_1 = group1_std**-2
+            lambda_2 = group2_std**-2
 
             nu = pm.Exponential("ν_minus_one", 1 / 29.0) + 1
 
@@ -147,7 +147,7 @@ def time_drug_evaluation(self):
             diff_of_means = pm.Deterministic("difference of means", group1_mean - group2_mean)
             pm.Deterministic("difference of stds", group1_std - group2_std)
             pm.Deterministic(
-                "effect size", diff_of_means / np.sqrt((group1_std ** 2 + group2_std ** 2) / 2)
+                "effect size", diff_of_means / np.sqrt((group1_std**2 + group2_std**2) / 2)
             )
             pm.sample(
                 draws=20000, cores=4, chains=4, progressbar=False, compute_convergence_checks=False

pymc/bart/pgbart.py

@@ -76,10 +76,10 @@ def __init__(self, vars=None, num_particles=40, max_stages=100, batch="auto", mo
         # if data is binary
         Y_unique = np.unique(self.Y)
         if Y_unique.size == 2 and np.all(Y_unique == [0, 1]):
-            self.mu_std = 6 / (self.k * self.m ** 0.5)
+            self.mu_std = 6 / (self.k * self.m**0.5)
         # maybe we need to check for count data
         else:
-            self.mu_std = (2 * self.Y.std()) / (self.k * self.m ** 0.5)
+            self.mu_std = (2 * self.Y.std()) / (self.k * self.m**0.5)
 
         self.num_observations = self.X.shape[0]
         self.num_variates = self.X.shape[1]
@@ -354,7 +354,7 @@ def compute_prior_probability(alpha):
     prior_leaf_prob = [0]
     depth = 1
     while prior_leaf_prob[-1] < 1:
-        prior_leaf_prob.append(1 - alpha ** depth)
+        prior_leaf_prob.append(1 - alpha**depth)
         depth += 1
     return prior_leaf_prob
 

pymc/distributions/continuous.py

@@ -235,7 +235,7 @@ def get_tau_sigma(tau=None, sigma=None):
             else:
                 assert np.all(np.asarray(sigma) > 0)
                 sigma_ = sigma
-            tau = sigma_ ** -2.0
+            tau = sigma_**-2.0
 
     else:
         if sigma is not None:
@@ -247,7 +247,7 @@ def get_tau_sigma(tau=None, sigma=None):
                 assert np.all(np.asarray(tau) > 0)
                 tau_ = tau
 
-            sigma = tau_ ** -0.5
+            sigma = tau_**-0.5
 
     return floatX(tau), floatX(sigma)
 
@@ -1240,7 +1240,7 @@ def get_alpha_beta(self, alpha=None, beta=None, mu=None, sigma=None):
         if (alpha is not None) and (beta is not None):
             pass
         elif (mu is not None) and (sigma is not None):
-            kappa = mu * (1 - mu) / sigma ** 2 - 1
+            kappa = mu * (1 - mu) / sigma**2 - 1
             alpha = mu * kappa
             beta = (1 - mu) * kappa
         else:
@@ -1375,7 +1375,7 @@ def logp(value, a, b):
         -------
         TensorVariable
         """
-        res = at.log(a) + at.log(b) + (a - 1) * at.log(value) + (b - 1) * at.log(1 - value ** a)
+        res = at.log(a) + at.log(b) + (a - 1) * at.log(value) + (b - 1) * at.log(1 - value**a)
         res = at.switch(
             at.or_(at.lt(value, 0), at.gt(value, 1)),
             -np.inf,
@@ -1409,7 +1409,7 @@ def logcdf(value, a, b):
             -np.inf,
             at.switch(
                 at.lt(value, 1),
-                at.log1mexp(b * at.log1p(-(value ** a))),
+                at.log1mexp(b * at.log1p(-(value**a))),
                 0,
             ),
         )
@@ -1608,9 +1608,9 @@ class AsymmetricLaplaceRV(RandomVariable):
     @classmethod
     def rng_fn(cls, rng, b, kappa, mu, size=None) -> np.ndarray:
         u = rng.uniform(size=size)
-        switch = kappa ** 2 / (1 + kappa ** 2)
+        switch = kappa**2 / (1 + kappa**2)
         non_positive_x = mu + kappa * np.log(u * (1 / switch)) / b
-        positive_x = mu - np.log((1 - u) * (1 + kappa ** 2)) / (kappa * b)
+        positive_x = mu - np.log((1 - u) * (1 + kappa**2)) / (kappa * b)
         draws = non_positive_x * (u <= switch) + positive_x * (u > switch)
         return np.asarray(draws)
 
@@ -1691,7 +1691,7 @@ def logp(value, b, kappa, mu):
         TensorVariable
         """
         value = value - mu
-        res = at.log(b / (kappa + (kappa ** -1))) + (
+        res = at.log(b / (kappa + (kappa**-1))) + (
             -value * b * at.sgn(value) * (kappa ** at.sgn(value))
         )
 
@@ -1781,7 +1781,7 @@ def dist(cls, mu=0, sigma=None, tau=None, sd=None, *args, **kwargs):
         return super().dist([mu, sigma], *args, **kwargs)
 
     def get_moment(rv, size, mu, sigma):
-        mean = at.exp(mu + 0.5 * sigma ** 2)
+        mean = at.exp(mu + 0.5 * sigma**2)
         if not rv_size_is_none(size):
             mean = at.full(size, mean)
         return mean
@@ -1955,7 +1955,7 @@ def logcdf(value, nu, mu, sigma):
         _, sigma = get_tau_sigma(sigma=sigma)
 
         t = (value - mu) / sigma
-        sqrt_t2_nu = at.sqrt(t ** 2 + nu)
+        sqrt_t2_nu = at.sqrt(t**2 + nu)
         x = (t + sqrt_t2_nu) / (2.0 * sqrt_t2_nu)
 
         res = at.log(at.betainc(nu / 2.0, nu / 2.0, x))
@@ -2307,8 +2307,8 @@ def get_alpha_beta(cls, alpha=None, beta=None, mu=None, sigma=None):
                 sigma = check_parameters(sigma, sigma > 0, msg="sigma > 0")
             else:
                 assert np.all(np.asarray(sigma) > 0)
-            alpha = mu ** 2 / sigma ** 2
-            beta = mu / sigma ** 2
+            alpha = mu**2 / sigma**2
+            beta = mu / sigma**2
         else:
             raise ValueError(
                 "Incompatible parameterization. Either use "
@@ -2435,8 +2435,8 @@ def _get_alpha_beta(cls, alpha, beta, mu, sigma):
                 sigma = check_parameters(sigma, sigma > 0, msg="sigma > 0")
             else:
                 assert np.all(np.asarray(sigma) > 0)
-            alpha = (2 * sigma ** 2 + mu ** 2) / sigma ** 2
-            beta = mu * (mu ** 2 + sigma ** 2) / sigma ** 2
+            alpha = (2 * sigma**2 + mu**2) / sigma**2
+            beta = mu * (mu**2 + sigma**2) / sigma**2
         else:
             raise ValueError(
                 "Incompatible parameterization. Either use "
@@ -2759,8 +2759,8 @@ def logp(value, nu, sigma):
             at.log(2)
             + gammaln((nu + 1.0) / 2.0)
             - gammaln(nu / 2.0)
-            - 0.5 * at.log(nu * np.pi * sigma ** 2)
-            - (nu + 1.0) / 2.0 * at.log1p(value ** 2 / (nu * sigma ** 2))
+            - 0.5 * at.log(nu * np.pi * sigma**2)
+            - (nu + 1.0) / 2.0 * at.log1p(value**2 / (nu * sigma**2))
         )
 
         res = at.switch(
@@ -2898,7 +2898,7 @@ def logp(value, mu, sigma, nu):
                 -at.log(nu)
                 + (mu - value) / nu
                 + 0.5 * (sigma / nu) ** 2
-                + normal_lcdf(mu + (sigma ** 2) / nu, sigma, value)
+                + normal_lcdf(mu + (sigma**2) / nu, sigma, value)
             ),
             log_normal(value, mean=mu, sigma=sigma),
         )
@@ -2939,7 +2939,7 @@ def logcdf(value, mu, sigma, nu):
                 (
                     (mu - value) / nu
                     + 0.5 * (sigma / nu) ** 2
-                    + normal_lcdf(mu + (sigma ** 2) / nu, sigma, value)
+                    + normal_lcdf(mu + (sigma**2) / nu, sigma, value)
                 ),
             ),
             normal_lcdf(mu, sigma, value),
@@ -3103,7 +3103,7 @@ def dist(cls, alpha=1, mu=0.0, sigma=None, tau=None, sd=None, *args, **kwargs):
         return super().dist([mu, sigma, alpha], *args, **kwargs)
 
     def get_moment(rv, size, mu, sigma, alpha):
-        mean = mu + sigma * (2 / np.pi) ** 0.5 * alpha / (1 + alpha ** 2) ** 0.5
+        mean = mu + sigma * (2 / np.pi) ** 0.5 * alpha / (1 + alpha**2) ** 0.5
         if not rv_size_is_none(size):
             mean = at.full(size, mean)
         return mean
@@ -3437,7 +3437,7 @@ def get_nu_b(cls, nu, b, sigma):
         raise ValueError("Rice distribution must specify either nu" " or b.")
 
     def get_moment(rv, size, nu, sigma):
-        nu_sigma_ratio = -(nu ** 2) / (2 * sigma ** 2)
+        nu_sigma_ratio = -(nu**2) / (2 * sigma**2)
         mean = (
             sigma
             * np.sqrt(np.pi / 2)
@@ -3939,7 +3939,7 @@ def logcdf(value, mu, sigma):
         TensorVariable
         """
         scaled = (value - mu) / sigma
-        res = at.log(at.erfc(at.exp(-scaled / 2) * (2 ** -0.5)))
+        res = at.log(at.erfc(at.exp(-scaled / 2) * (2**-0.5)))
         return check_parameters(
             res,
             0 < sigma,

pymc/distributions/dist_math.py

@@ -213,7 +213,7 @@ def log_normal(x, mean, **kwargs):
     else:
         std = tau ** (-1)
     std += f(eps)
-    return f(c) - at.log(at.abs_(std)) - (x - mean) ** 2 / (2.0 * std ** 2)
+    return f(c) - at.log(at.abs_(std)) - (x - mean) ** 2 / (2.0 * std**2)
 
 
 def MvNormalLogp():
@@ -455,20 +455,20 @@ def log_i0(x):
     return at.switch(
         at.lt(x, 5),
         at.log1p(
-            x ** 2.0 / 4.0
-            + x ** 4.0 / 64.0
-            + x ** 6.0 / 2304.0
-            + x ** 8.0 / 147456.0
-            + x ** 10.0 / 14745600.0
-            + x ** 12.0 / 2123366400.0
+            x**2.0 / 4.0
+            + x**4.0 / 64.0
+            + x**6.0 / 2304.0
+            + x**8.0 / 147456.0
+            + x**10.0 / 14745600.0
+            + x**12.0 / 2123366400.0
         ),
         x
         - 0.5 * at.log(2.0 * np.pi * x)
         + at.log1p(
             1.0 / (8.0 * x)
-            + 9.0 / (128.0 * x ** 2.0)
-            + 225.0 / (3072.0 * x ** 3.0)
-            + 11025.0 / (98304.0 * x ** 4.0)
+            + 9.0 / (128.0 * x**2.0)
+            + 225.0 / (3072.0 * x**3.0)
+            + 11025.0 / (98304.0 * x**4.0)
         ),
     )
 

pymc/distributions/multivariate.py

@@ -151,7 +151,7 @@ def quaddist_chol(delta, chol_mat):
     chol_cov = at.switch(ok, chol_mat, 1)
 
     delta_trans = solve_lower(chol_cov, delta.T).T
-    quaddist = (delta_trans ** 2).sum(axis=-1)
+    quaddist = (delta_trans**2).sum(axis=-1)
     logdet = at.sum(at.log(diag))
     return quaddist, logdet, ok
 
@@ -165,7 +165,7 @@ def quaddist_tau(delta, chol_mat):
     chol_tau = at.switch(ok, chol_mat, 1)
 
     delta_trans = at.dot(delta, chol_tau)
-    quaddist = (delta_trans ** 2).sum(axis=-1)
+    quaddist = (delta_trans**2).sum(axis=-1)
     logdet = -at.sum(at.log(diag))
     return quaddist, logdet, ok
 
@@ -1095,14 +1095,14 @@ def _lkj_normalizing_constant(eta, n):
         result = gammaln(2.0 * at.arange(1, int((n - 1) / 2) + 1)).sum()
         if n % 2 == 1:
             result += (
-                0.25 * (n ** 2 - 1) * at.log(np.pi)
+                0.25 * (n**2 - 1) * at.log(np.pi)
                 - 0.25 * (n - 1) ** 2 * at.log(2.0)
                 - (n - 1) * gammaln(int((n + 1) / 2))
             )
         else:
             result += (
                 0.25 * n * (n - 2) * at.log(np.pi)
-                + 0.25 * (3 * n ** 2 - 4 * n) * at.log(2.0)
+                + 0.25 * (3 * n**2 - 4 * n) * at.log(2.0)
                 + n * gammaln(n / 2)
                 - (n - 1) * gammaln(n)
             )
@@ -1227,7 +1227,7 @@ def logp(value, n, eta, sd_dist):
             raise ValueError("LKJCholeskyCov logp is only implemented for vector values (ndim=1)")
 
         diag_idxs = at.cumsum(at.arange(1, n + 1)) - 1
-        cumsum = at.cumsum(value ** 2)
+        cumsum = at.cumsum(value**2)
         variance = at.zeros(at.atleast_1d(n))
         variance = at.inc_subtensor(variance[0], value[0] ** 2)
         variance = at.inc_subtensor(variance[1:], cumsum[diag_idxs[1:]] - cumsum[diag_idxs[:-1]])
@@ -1480,7 +1480,7 @@ def _random_corr_matrix(cls, rng, n, eta, flat_size):
         r12 = 2.0 * stats.beta.rvs(a=beta, b=beta, size=flat_size, random_state=rng) - 1.0
         P = np.full((flat_size, n, n), np.eye(n))
         P[..., 0, 1] = r12
-        P[..., 1, 1] = np.sqrt(1.0 - r12 ** 2)
+        P[..., 1, 1] = np.sqrt(1.0 - r12**2)
         for mp1 in range(2, n):
             beta -= 0.5
             y = stats.beta.rvs(a=mp1 / 2.0, b=beta, size=flat_size, random_state=rng)
@@ -1852,7 +1852,7 @@ def rng_fn(self, rng, mu, sigma, *covs, size=None):
         cov = reduce(linalg.kron, covs)
 
         if sigma:
-            cov = cov + sigma ** 2 * np.eye(cov.shape[0])
+            cov = cov + sigma**2 * np.eye(cov.shape[0])
 
         x = multivariate_normal.rng_fn(rng=rng, mean=mu, cov=cov, size=size)
         return x
@@ -2015,7 +2015,7 @@ def logp(value, mu, sigma, *covs):
 
         eigs_sep = list(map(at.as_tensor_variable, eigs_sep))
         eigs = kron_diag(*eigs_sep)  # Combine separate eigs
-        eigs += sigma ** 2
+        eigs += sigma**2
         N = eigs.shape[0]
 
         sqrt_quad = kron_dot(QTs, delta.T)

pymc/distributions/timeseries.py

@@ -49,7 +49,7 @@ def __init__(self, k, tau_e, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.k = k = at.as_tensor_variable(k)
         self.tau_e = tau_e = at.as_tensor_variable(tau_e)
-        self.tau = tau_e * (1 - k ** 2)
+        self.tau = tau_e * (1 - k**2)
         self.mode = at.as_tensor_variable(0.0)
 
     def logp(self, x):
@@ -67,7 +67,7 @@ def logp(self, x):
         """
         k = self.k
         tau_e = self.tau_e  # innovation precision
-        tau = tau_e * (1 - k ** 2)  # ar1 precision
+        tau = tau_e * (1 - k**2)  # ar1 precision
 
         x_im1 = x[:-1]
         x_i = x[1:]

pymc/gp/gp.py

@@ -1175,7 +1175,7 @@ def _build_conditional(self, Xnew, diag, pred_noise):
         QTs = list(map(at.transpose, Qs))
         eigs = kron_diag(*eigs_sep)  # Combine separate eigs
         if sigma is not None:
-            eigs += sigma ** 2
+            eigs += sigma**2
 
         Km = self.cov_func(Xnew, diag=diag)
         Knm = self.cov_func(X, Xnew)

pymc/model.py

@@ -1016,7 +1016,7 @@ def compute_initial_point(self, seed=None) -> Dict[str, np.ndarray]:
             Maps names of transformed variables to numeric initial values in the transformed space.
         """
         if seed is None:
-            seed = self.rng_seeder.randint(2 ** 30, dtype=np.int64)
+            seed = self.rng_seeder.randint(2**30, dtype=np.int64)
         fn = make_initial_point_fn(model=self, return_transformed=True)
         return Point(fn(seed), model=self)
 
@@ -1043,7 +1043,7 @@ def next_rng(self) -> RandomStateSharedVariable:
         The new ``RandomStateSharedVariable`` is also added to
         ``Model.rng_seq``.
         """
-        new_seed = self.rng_seeder.randint(2 ** 30, dtype=np.int64)
+        new_seed = self.rng_seeder.randint(2**30, dtype=np.int64)
         next_rng = aesara.shared(np.random.RandomState(new_seed), borrow=True)
         next_rng.tag.is_rng = True