Fix most pylint messages in randvars

marvinpfoertner · marvinpfoertner · commit 67fe61d17be3 · 2021-11-30T17:56:34.000+01:00
diff --git a/src/probnum/randvars/_arithmetic.py b/src/probnum/randvars/_arithmetic.py
@@ -180,29 +180,32 @@ def _generic_rv_add(rv1: _RandomVariable, rv2: _RandomVariable) -> _RandomVariab
 # Constant - Constant Arithmetic
 ########################################################################################
 
-_add_fns[(_Constant, _Constant)] = _Constant._binary_operator_factory(operator.add)
-_sub_fns[(_Constant, _Constant)] = _Constant._binary_operator_factory(operator.sub)
-_mul_fns[(_Constant, _Constant)] = _Constant._binary_operator_factory(operator.mul)
-_matmul_fns[(_Constant, _Constant)] = _Constant._binary_operator_factory(
+_constant_constant_operator_factory = (
+    _Constant._binary_operator_factory  # pylint: disable=protected-access
+)
+
+_add_fns[(_Constant, _Constant)] = _constant_constant_operator_factory(operator.add)
+_sub_fns[(_Constant, _Constant)] = _constant_constant_operator_factory(operator.sub)
+_mul_fns[(_Constant, _Constant)] = _constant_constant_operator_factory(operator.mul)
+_matmul_fns[(_Constant, _Constant)] = _constant_constant_operator_factory(
     operator.matmul
 )
-_truediv_fns[(_Constant, _Constant)] = _Constant._binary_operator_factory(
+_truediv_fns[(_Constant, _Constant)] = _constant_constant_operator_factory(
     operator.truediv
 )
-_floordiv_fns[(_Constant, _Constant)] = _Constant._binary_operator_factory(
+_floordiv_fns[(_Constant, _Constant)] = _constant_constant_operator_factory(
     operator.floordiv
 )
-_mod_fns[(_Constant, _Constant)] = _Constant._binary_operator_factory(operator.mod)
-_divmod_fns[(_Constant, _Constant)] = _Constant._binary_operator_factory(divmod)
-_pow_fns[(_Constant, _Constant)] = _Constant._binary_operator_factory(operator.pow)
+_mod_fns[(_Constant, _Constant)] = _constant_constant_operator_factory(operator.mod)
+_divmod_fns[(_Constant, _Constant)] = _constant_constant_operator_factory(divmod)
+_pow_fns[(_Constant, _Constant)] = _constant_constant_operator_factory(operator.pow)
 
 ########################################################################################
 # Normal - Normal Arithmetic
 ########################################################################################
 
-_add_fns[(_Normal, _Normal)] = _Normal._add_normal
-_sub_fns[(_Normal, _Normal)] = _Normal._sub_normal
-
+_add_fns[(_Normal, _Normal)] = _Normal._add_normal  # pylint: disable=protected-access
+_sub_fns[(_Normal, _Normal)] = _Normal._sub_normal  # pylint: disable=protected-access
 
 ########################################################################################
 # Normal - Constant Arithmetic
@@ -254,16 +257,16 @@ def _mul_normal_constant(
             return _Constant(
                 support=backend.zeros_like(norm_rv.mean),
             )
+
+        if norm_rv.cov_cholesky_is_precomputed:
+            cov_cholesky = constant_rv.support * norm_rv.cov_cholesky
         else:
-            if norm_rv.cov_cholesky_is_precomputed:
-                cov_cholesky = constant_rv.support * norm_rv.cov_cholesky
-            else:
-                cov_cholesky = None
-            return _Normal(
-                mean=constant_rv.support * norm_rv.mean,
-                cov=(constant_rv.support ** 2) * norm_rv.cov,
-                cov_cholesky=cov_cholesky,
-            )
+            cov_cholesky = None
+        return _Normal(
+            mean=constant_rv.support * norm_rv.mean,
+            cov=(constant_rv.support ** 2) * norm_rv.cov,
+            cov_cholesky=cov_cholesky,
+        )
 
     return NotImplemented
 
@@ -275,7 +278,8 @@ def _mul_normal_constant(
 def _matmul_normal_constant(norm_rv: _Normal, constant_rv: _Constant) -> _Normal:
     """Normal random variable multiplied with a vector or matrix.
 
-    Computes the distribution of the random variable :math:`Y = XA`, where :math:`X` is a matrix- or multi-variate normal random variable and :math:`A` a constant.
+    Computes the distribution of the random variable :math:`Y = XA`, where :math:`X` is
+    a matrix- or multi-variate normal random variable and :math:`A` a constant.
     """
     if norm_rv.ndim == 1 or (norm_rv.ndim == 2 and norm_rv.shape[0] == 1):
         if norm_rv.cov_cholesky_is_precomputed:
@@ -292,25 +296,25 @@ def _matmul_normal_constant(norm_rv: _Normal, constant_rv: _Constant) -> _Normal
             cov = cov.reshape((1, 1))
 
         return _Normal(mean=mean, cov=cov, cov_cholesky=cov_cholesky)
+
+    # This part does not do the Cholesky update,
+    # because of performance configurations: currently, there is no way of switching
+    # the Cholesky updates off, which might affect (large, potentially sparse)
+    # covariance matrices of matrix-variate Normal RVs. See Issue #335.
+    if constant_rv.support.ndim == 1:
+        constant_rv_support = constant_rv.support[:, None]
     else:
-        # This part does not do the Cholesky update,
-        # because of performance configurations: currently, there is no way of switching
-        # the Cholesky updates off, which might affect (large, potentially sparse) covariance matrices
-        # of matrix-variate Normal RVs. See Issue #335.
-        if constant_rv.support.ndim == 1:
-            constant_rv_support = constant_rv.support[:, None]
-        else:
-            constant_rv_support = constant_rv.support
+        constant_rv_support = constant_rv.support
 
-        cov_update = _linear_operators.Kronecker(
-            _linear_operators.Identity(norm_rv.shape[0]), constant_rv_support.T
-        )
+    cov_update = _linear_operators.Kronecker(
+        _linear_operators.Identity(norm_rv.shape[0]), constant_rv_support.T
+    )
 
-        # Cov(rvec(XA)) = Cov((I (x) A.T)rvec(X)) = (I (x) A.T)Cov(rvec(X))(I (x) A.T).T
-        return _Normal(
-            mean=norm_rv.mean @ constant_rv.support,
-            cov=cov_update @ (norm_rv.cov @ cov_update.T),
-        )
+    # Cov(rvec(XA)) = Cov((I (x) A.T)rvec(X)) = (I (x) A.T)Cov(rvec(X))(I (x) A.T).T
+    return _Normal(
+        mean=norm_rv.mean @ constant_rv.support,
+        cov=cov_update @ (norm_rv.cov @ cov_update.T),
+    )
 
 
 _matmul_fns[(_Normal, _Constant)] = _matmul_normal_constant
@@ -319,7 +323,8 @@ def _matmul_normal_constant(norm_rv: _Normal, constant_rv: _Constant) -> _Normal
 def _matmul_constant_normal(constant_rv: _Constant, norm_rv: _Normal) -> _Normal:
     """Matrix-multiplication with a normal random variable.
 
-    Computes the distribution of the random variable :math:`Y = AX`, where :math:`X` is a matrix- or multi-variate normal random variable and :math:`A` a constant.
+    Computes the distribution of the random variable :math:`Y = AX`, where :math:`X` is
+    a matrix- or multi-variate normal random variable and :math:`A` a constant.
     """
     if norm_rv.ndim == 1 or (norm_rv.ndim == 2 and norm_rv.shape[1] == 1):
         if norm_rv.cov_cholesky_is_precomputed:
@@ -333,26 +338,26 @@ def _matmul_constant_normal(constant_rv: _Constant, norm_rv: _Normal) -> _Normal
             cov=constant_rv.support @ (norm_rv.cov @ constant_rv.support.T),
             cov_cholesky=cov_cholesky,
         )
+
+    # This part does not do the Cholesky update,
+    # because of performance configurations: currently, there is no way of switching
+    # the Cholesky updates off, which might affect (large, potentially sparse)
+    # covariance matrices of matrix-variate Normal RVs. See Issue #335.
+    if constant_rv.support.ndim == 1:
+        constant_rv_support = constant_rv.support[None, :]
     else:
-        # This part does not do the Cholesky update,
-        # because of performance configurations: currently, there is no way of switching
-        # the Cholesky updates off, which might affect (large, potentially sparse) covariance matrices
-        # of matrix-variate Normal RVs. See Issue #335.
-        if constant_rv.support.ndim == 1:
-            constant_rv_support = constant_rv.support[None, :]
-        else:
-            constant_rv_support = constant_rv.support
+        constant_rv_support = constant_rv.support
 
-        cov_update = _linear_operators.Kronecker(
-            constant_rv_support,
-            _linear_operators.Identity(norm_rv.shape[1]),
-        )
+    cov_update = _linear_operators.Kronecker(
+        constant_rv_support,
+        _linear_operators.Identity(norm_rv.shape[1]),
+    )
 
-        # Cov(rvec(AX)) = Cov((A (x) I)rvec(X)) = (A (x) I)Cov(rvec(X))(A (x) I).T
-        return _Normal(
-            mean=constant_rv.support @ norm_rv.mean,
-            cov=cov_update @ (norm_rv.cov @ cov_update.T),
-        )
+    # Cov(rvec(AX)) = Cov((A (x) I)rvec(X)) = (A (x) I)Cov(rvec(X))(A (x) I).T
+    return _Normal(
+        mean=constant_rv.support @ norm_rv.mean,
+        cov=cov_update @ (norm_rv.cov @ cov_update.T),
+    )
 
 
 _matmul_fns[(_Constant, _Normal)] = _matmul_constant_normal
diff --git a/src/probnum/randvars/_categorical.py b/src/probnum/randvars/_categorical.py
@@ -3,6 +3,9 @@
 
 import numpy as np
 
+from probnum import backend
+from probnum.typing import SeedType, ShapeType
+
 from ._random_variable import DiscreteRandomVariable
 
 
@@ -24,6 +27,12 @@ def __init__(
         probabilities: np.ndarray,
         support: Optional[np.ndarray] = None,
     ):
+        if backend.BACKEND != backend.Backend.NUMPY:
+            raise NotImplementedError(
+                "The `Categorical` random variable only supports the `numpy` backend "
+                "at the moment."
+            )
+
         # The set of events is names "support" to be aligned with the method
         # DiscreteRandomVariable.in_support().
 
@@ -39,7 +48,9 @@ def __init__(
             "num_categories": num_categories,
         }
 
-        def _sample_categorical(rng, size=()):
+        def _sample_categorical(
+            seed: np.random.SeedSequence, sample_shape: ShapeType = ()
+        ):
             """Sample from a categorical distribution.
 
             While on first sight, one might think that this
@@ -49,10 +60,12 @@ def _sample_categorical(rng, size=()):
             arrays with `ndim > 1`, but `self.support` can be just that.
             This detour via the `mask` avoids this problem.
             """
-
+            rng = np.random.default_rng(seed)
             indices = rng.choice(
-                np.arange(len(self.support)), size=size, p=self.probabilities
-            ).reshape(size)
+                np.arange(len(self.support)),
+                size=sample_shape,
+                p=self.probabilities,
+            ).reshape(sample_shape)
             return self.support[indices]
 
         def _pmf_categorical(x):
@@ -64,7 +77,8 @@ def _pmf_categorical(x):
             x = np.asarray(x)
             if x.dtype != self.dtype:
                 raise ValueError(
-                    "The data type of x does not match with the data type of the support."
+                    "The data type of x does not match with the data type of the "
+                    "support."
                 )
 
             mask = (x == self.support).nonzero()[0]
@@ -93,7 +107,7 @@ def support(self) -> np.ndarray:
         """Support of the categorical distribution."""
         return self._support
 
-    def resample(self, rng: np.random.Generator) -> "Categorical":
+    def resample(self, seed: SeedType) -> "Categorical":
         """Resample the support of the categorical random variable.
 
         Return a new categorical random variable (RV), where the support
@@ -103,16 +117,17 @@ def resample(self, rng: np.random.Generator) -> "Categorical":
 
         Parameters
         ----------
-        rng :
-            Random number generator.
+        seed
+            Seed for random number generation
 
         Returns
         -------
         Categorical
-            Categorical random variable with resampled support (according to self.probabilities).
+            Categorical random variable with resampled support (according to
+            self.probabilities).
         """
         num_events = len(self.support)
-        new_support = self.sample(rng=rng, size=num_events)
+        new_support = self.sample(seed, sample_shape=num_events)
         new_probabilities = np.ones(self.probabilities.shape) / num_events
         return Categorical(
             support=new_support,
diff --git a/src/probnum/randvars/_random_variable.py b/src/probnum/randvars/_random_variable.py
@@ -390,7 +390,7 @@ def in_support(self, x: ArrayType) -> ArrayType:
 
         self._check_return_value(
             "in_support",
-            input=x,
+            input_value=x,
             return_value=in_support,
             expected_shape=x.shape[: -self.ndim],
             expected_dtype=backend.bool,
@@ -440,7 +440,7 @@ def cdf(self, x: ArrayType) -> ArrayType:
 
         self._check_return_value(
             "cdf",
-            input=x,
+            input_value=x,
             return_value=cdf,
             expected_shape=x.shape[: -self.ndim],
             expected_dtype=backend.double,
@@ -471,7 +471,7 @@ def logcdf(self, x: ArrayType) -> ArrayType:
 
         self._check_return_value(
             "logcdf",
-            input=x,
+            input_value=x,
             return_value=logcdf,
             expected_shape=x.shape[: -self.ndim],
             expected_dtype=backend.double,
@@ -505,7 +505,7 @@ def quantile(self, p: ArrayType) -> ArrayType:
 
         self._check_return_value(
             "quantile",
-            input=p,
+            input_value=p,
             return_value=quantile,
             expected_shape=p.shape + self.shape,
             expected_dtype=self.dtype,
@@ -758,27 +758,30 @@ def _check_property_value(
     def _check_return_value(
         self,
         method_name: str,
-        input: ArrayType,
+        input_value: ArrayType,
         return_value: ArrayType,
         expected_shape: Optional[ShapeType] = None,
         expected_dtype: Optional[backend.dtype] = None,
     ):
+        # pylint: disable=too-many-arguments
+
         if expected_shape is not None:
             if return_value.shape != expected_shape:
                 raise ValueError(
                     f"The return value of the function `{method_name}` does not have "
-                    f"the correct shape for an input with shape {input.shape} and a "
-                    f"random variable with shape {self.shape}. Expected "
+                    f"the correct shape for an input with shape {input_value.shape} "
+                    f"and a random variable with shape {self.shape}. Expected "
                     f"{expected_shape} but got {return_value.shape}."
                 )
 
         if expected_dtype is not None:
             if return_value.dtype != expected_dtype:
                 raise ValueError(
                     f"The return value of the function `{method_name}` does not have "
-                    f"the correct dtype for an input with dtype {str(input.dtype)} and "
-                    f"a random variable with dtype {str(self.dtype)}. Expexted "
-                    f"{str(expected_dtype)} but got {str(return_value.dtype)}."
+                    f"the correct dtype for an input with dtype "
+                    f"{str(input_value.dtype)} and a random variable with dtype "
+                    f"{str(self.dtype)}. Expected {str(expected_dtype)} but got "
+                    f"{str(return_value.dtype)}."
                 )
 
 
@@ -953,7 +956,7 @@ def pmf(self, x: ArrayType) -> ArrayType:
 
         self._check_return_value(
             "pmf",
-            input=x,
+            input_value=x,
             return_value=pmf,
             expected_shape=x.shape[: -self.ndim],
             expected_dtype=backend.double,
@@ -984,7 +987,7 @@ def logpmf(self, x: ArrayType) -> ArrayType:
 
         self._check_return_value(
             "logpmf",
-            input=x,
+            input_value=x,
             return_value=logpmf,
             expected_shape=x.shape[: -self.ndim],
             expected_dtype=backend.double,
@@ -1162,7 +1165,7 @@ def pdf(self, x: ArrayType) -> ArrayType:
 
         self._check_return_value(
             "pdf",
-            input=x,
+            input_value=x,
             return_value=pdf,
             expected_shape=x.shape[: -self.ndim],
             expected_dtype=backend.double,
@@ -1193,7 +1196,7 @@ def logpdf(self, x: ArrayType) -> ArrayType:
 
         self._check_return_value(
             "logpdf",
-            input=x,
+            input_value=x,
             return_value=logpdf,
             expected_shape=x.shape[: -self.ndim],
             expected_dtype=backend.double,
diff --git a/src/probnum/randvars/_sym_mat_normal.py b/src/probnum/randvars/_sym_mat_normal.py
