Remove SciPy conditional logic

Author: brandonwillard

aesara/sandbox/linalg/ops.py

@@ -17,7 +17,7 @@
 from aesara.tensor.math import pow as aet_pow
 from aesara.tensor.math import prod
 from aesara.tensor.nlinalg import MatrixInverse, det, matrix_inverse, trace
-from aesara.tensor.slinalg import Cholesky, Solve, cholesky, imported_scipy, solve
+from aesara.tensor.slinalg import Cholesky, Solve, cholesky, solve
 
 
 logger = logging.getLogger(__name__)
@@ -229,8 +229,6 @@ def transinv_to_invtrans(fgraph, node):
 @register_stabilize
 @local_optimizer([Dot, Dot22])
 def inv_as_solve(fgraph, node):
-    if not imported_scipy:
-        return False
     if isinstance(node.op, (Dot, Dot22)):
         l, r = node.inputs
         if l.owner and l.owner.op == matrix_inverse:

aesara/scalar/math.py

@@ -7,6 +7,8 @@
 import os
 
 import numpy as np
+import scipy.special
+import scipy.stats
 
 from aesara.configdefaults import config
 from aesara.gradient import grad_not_implemented
@@ -25,26 +27,11 @@
 )
 
 
-imported_scipy_special = False
-try:
-    import scipy.special
-    import scipy.stats
-
-    imported_scipy_special = True
-# Importing scipy.special may raise ValueError.
-# See http://projects.scipy.org/scipy/ticket/1739
-except (ImportError, ValueError):
-    pass
-
-
 class Erf(UnaryScalarOp):
     nfunc_spec = ("scipy.special.erf", 1, 1)
 
     def impl(self, x):
-        if imported_scipy_special:
-            return scipy.special.erf(x)
-        else:
-            super().impl(x)
+        return scipy.special.erf(x)
 
     def L_op(self, inputs, outputs, grads):
         (x,) = inputs
@@ -78,10 +65,7 @@ class Erfc(UnaryScalarOp):
     nfunc_spec = ("scipy.special.erfc", 1, 1)
 
     def impl(self, x):
-        if imported_scipy_special:
-            return scipy.special.erfc(x)
-        else:
-            super().impl(x)
+        return scipy.special.erfc(x)
 
     def L_op(self, inputs, outputs, grads):
         (x,) = inputs
@@ -130,10 +114,7 @@ class Erfcx(UnaryScalarOp):
     nfunc_spec = ("scipy.special.erfcx", 1, 1)
 
     def impl(self, x):
-        if imported_scipy_special:
-            return scipy.special.erfcx(x)
-        else:
-            super().impl(x)
+        return scipy.special.erfcx(x)
 
     def L_op(self, inputs, outputs, grads):
         (x,) = inputs
@@ -195,10 +176,7 @@ class Erfinv(UnaryScalarOp):
     nfunc_spec = ("scipy.special.erfinv", 1, 1)
 
     def impl(self, x):
-        if imported_scipy_special:
-            return scipy.special.erfinv(x)
-        else:
-            super().impl(x)
+        return scipy.special.erfinv(x)
 
     def L_op(self, inputs, outputs, grads):
         (x,) = inputs
@@ -232,10 +210,7 @@ class Erfcinv(UnaryScalarOp):
     nfunc_spec = ("scipy.special.erfcinv", 1, 1)
 
     def impl(self, x):
-        if imported_scipy_special:
-            return scipy.special.erfcinv(x)
-        else:
-            super().impl(x)
+        return scipy.special.erfcinv(x)
 
     def L_op(self, inputs, outputs, grads):
         (x,) = inputs
@@ -273,10 +248,7 @@ def st_impl(x):
         return scipy.special.gamma(x)
 
     def impl(self, x):
-        if imported_scipy_special:
-            return Gamma.st_impl(x)
-        else:
-            super().impl(x)
+        return Gamma.st_impl(x)
 
     def L_op(self, inputs, outputs, gout):
         (x,) = inputs
@@ -315,10 +287,7 @@ def st_impl(x):
         return scipy.special.gammaln(x)
 
     def impl(self, x):
-        if imported_scipy_special:
-            return GammaLn.st_impl(x)
-        else:
-            super().impl(x)
+        return GammaLn.st_impl(x)
 
     def L_op(self, inputs, outputs, grads):
         (x,) = inputs
@@ -362,10 +331,7 @@ def st_impl(x):
         return scipy.special.psi(x)
 
     def impl(self, x):
-        if imported_scipy_special:
-            return Psi.st_impl(x)
-        else:
-            super().impl(x)
+        return Psi.st_impl(x)
 
     def L_op(self, inputs, outputs, grads):
         (x,) = inputs
@@ -456,10 +422,7 @@ def st_impl(x):
         return scipy.special.polygamma(1, x)
 
     def impl(self, x):
-        if imported_scipy_special:
-            return TriGamma.st_impl(x)
-        else:
-            super().impl(x)
+        return TriGamma.st_impl(x)
 
     def grad(self, inputs, outputs_gradients):
         raise NotImplementedError()
@@ -545,10 +508,7 @@ def st_impl(x, k):
         return scipy.stats.chi2.sf(x, k)
 
     def impl(self, x, k):
-        if imported_scipy_special:
-            return Chi2SF.st_impl(x, k)
-        else:
-            super().impl(x, k)
+        return Chi2SF.st_impl(x, k)
 
     def c_support_code(self, **kwargs):
         with open(os.path.join(os.path.dirname(__file__), "c_code", "gamma.c")) as f:
@@ -589,10 +549,7 @@ def st_impl(k, x):
         return scipy.special.gammainc(k, x)
 
     def impl(self, k, x):
-        if imported_scipy_special:
-            return GammaInc.st_impl(k, x)
-        else:
-            super().impl(k, x)
+        return GammaInc.st_impl(k, x)
 
     def c_support_code(self, **kwargs):
         with open(os.path.join(os.path.dirname(__file__), "c_code", "gamma.c")) as f:
@@ -633,10 +590,7 @@ def st_impl(k, x):
         return scipy.special.gammaincc(x, k)
 
     def impl(self, k, x):
-        if imported_scipy_special:
-            return GammaIncC.st_impl(k, x)
-        else:
-            super().impl(k, x)
+        return GammaIncC.st_impl(k, x)
 
     def c_support_code(self, **kwargs):
         with open(os.path.join(os.path.dirname(__file__), "c_code", "gamma.c")) as f:
@@ -677,10 +631,7 @@ def st_impl(k, x):
         return scipy.special.gammaincc(k, x) * scipy.special.gamma(k)
 
     def impl(self, k, x):
-        if imported_scipy_special:
-            return GammaU.st_impl(k, x)
-        else:
-            super().impl(k, x)
+        return GammaU.st_impl(k, x)
 
     def c_support_code(self, **kwargs):
         with open(os.path.join(os.path.dirname(__file__), "c_code", "gamma.c")) as f:
@@ -721,10 +672,7 @@ def st_impl(k, x):
         return scipy.special.gammainc(k, x) * scipy.special.gamma(k)
 
     def impl(self, k, x):
-        if imported_scipy_special:
-            return GammaL.st_impl(k, x)
-        else:
-            super().impl(k, x)
+        return GammaL.st_impl(k, x)
 
     def c_support_code(self, **kwargs):
         with open(os.path.join(os.path.dirname(__file__), "c_code", "gamma.c")) as f:
@@ -765,10 +713,7 @@ def st_impl(v, x):
         return scipy.special.jv(v, x)
 
     def impl(self, v, x):
-        if imported_scipy_special:
-            return self.st_impl(v, x)
-        else:
-            super().impl(v, x)
+        return self.st_impl(v, x)
 
     def grad(self, inputs, grads):
         v, x = inputs
@@ -794,10 +739,7 @@ def st_impl(x):
         return scipy.special.j1(x)
 
     def impl(self, x):
-        if imported_scipy_special:
-            return self.st_impl(x)
-        else:
-            super().impl(x)
+        return self.st_impl(x)
 
     def grad(self, inputs, grads):
         (x,) = inputs
@@ -828,10 +770,7 @@ def st_impl(x):
         return scipy.special.j0(x)
 
     def impl(self, x):
-        if imported_scipy_special:
-            return self.st_impl(x)
-        else:
-            super().impl(x)
+        return self.st_impl(x)
 
     def grad(self, inp, grads):
         (x,) = inp
@@ -862,10 +801,7 @@ def st_impl(v, x):
         return scipy.special.iv(v, x)
 
     def impl(self, v, x):
-        if imported_scipy_special:
-            return self.st_impl(v, x)
-        else:
-            super().impl(v, x)
+        return self.st_impl(v, x)
 
     def grad(self, inputs, grads):
         v, x = inputs
@@ -891,10 +827,7 @@ def st_impl(x):
         return scipy.special.i1(x)
 
     def impl(self, x):
-        if imported_scipy_special:
-            return self.st_impl(x)
-        else:
-            super().impl(x)
+        return self.st_impl(x)
 
     def grad(self, inputs, grads):
         (x,) = inputs
@@ -917,10 +850,7 @@ def st_impl(x):
         return scipy.special.i0(x)
 
     def impl(self, x):
-        if imported_scipy_special:
-            return self.st_impl(x)
-        else:
-            super().impl(x)
+        return self.st_impl(x)
 
     def grad(self, inp, grads):
         (x,) = inp
@@ -939,10 +869,7 @@ class Sigmoid(UnaryScalarOp):
     nfunc_spec = ("scipy.special.expit", 1, 1)
 
     def impl(self, x):
-        if imported_scipy_special:
-            return scipy.special.expit(x)
-        else:
-            super().impl(x)
+        return scipy.special.expit(x)
 
     def grad(self, inp, grads):
         (x,) = inp

aesara/sparse/type.py

@@ -1,13 +1,5 @@
 import numpy as np
-
-
-try:
-    import scipy.sparse
-
-    imported_scipy = True
-except ImportError:
-    imported_scipy = False
-
+import scipy.sparse
 
 import aesara
 from aesara.graph.type import Type
@@ -54,12 +46,11 @@ class SparseType(Type):
 
     """
 
-    if imported_scipy:
-        format_cls = {
-            "csr": scipy.sparse.csr_matrix,
-            "csc": scipy.sparse.csc_matrix,
-            "bsr": scipy.sparse.bsr_matrix,
-        }
+    format_cls = {
+        "csr": scipy.sparse.csr_matrix,
+        "csc": scipy.sparse.csc_matrix,
+        "bsr": scipy.sparse.bsr_matrix,
+    }
     dtype_set = {
         "int8",
         "int16",
@@ -81,10 +72,6 @@ class SparseType(Type):
     Constant = None
 
     def __init__(self, format, dtype):
-        if not imported_scipy:
-            raise Exception(
-                "You can't make SparseType object as SciPy" " is not available."
-            )
         dtype = str(dtype)
         if dtype in self.dtype_set:
             self.dtype = dtype

aesara/tensor/nnet/abstract_conv.py

@@ -15,6 +15,8 @@
 import warnings
 
 import numpy as np
+from scipy.signal.signaltools import _bvalfromboundary, _valfrommode, convolve
+from scipy.signal.sigtools import _convolve2d
 
 import aesara
 from aesara import tensor as aet
@@ -31,15 +33,6 @@
 from aesara.tensor.var import TensorConstant, TensorVariable
 
 
-try:
-    from scipy.signal.signaltools import _bvalfromboundary, _valfrommode, convolve
-    from scipy.signal.sigtools import _convolve2d
-
-    imported_scipy_signal = True
-except ImportError:
-    imported_scipy_signal = False
-
-
 __docformat__ = "restructuredtext en"
 _logger = logging.getLogger("aesara.tensor.nnet.abstract_conv")
 
@@ -2342,11 +2335,6 @@ def conv(
         """
         Basic slow Python 2D or 3D convolution for DebugMode
         """
-        if not imported_scipy_signal:
-            raise NotImplementedError(
-                "AbstractConv perform requires the python package"
-                " for scipy.signal to be installed."
-            )
         if not (mode in ("valid", "full")):
             raise ValueError(
                 "invalid mode {}, which must be either "