Merge branch 'obliquepr' of github.com:neurodata/scikit-learn into obliquepr

adam2392 · adam2392 · commit 458220edd6c0 · 2022-03-16T14:21:31.000-04:00
diff --git a/doc/modules/model_evaluation.rst b/doc/modules/model_evaluation.rst
@@ -2196,7 +2196,7 @@ error (MAPE) estimated over :math:`n_{\text{samples}}` is defined as
 
 .. math::
 
-  \text{MAPE}(y, \hat{y}) = \frac{1}{n_{\text{samples}}} \sum_{i=0}^{n_{\text{samples}}-1} \frac{{}\left| y_i - \hat{y}_i \right|}{max(\epsilon, \left| y_i \right|)}
+  \text{MAPE}(y, \hat{y}) = \frac{1}{n_{\text{samples}}} \sum_{i=0}^{n_{\text{samples}}-1} \frac{{}\left| y_i - \hat{y}_i \right|}{\max(\epsilon, \left| y_i \right|)}
 
 where :math:`\epsilon` is an arbitrary small yet strictly positive number to
 avoid undefined results when y is zero.
@@ -2267,7 +2267,7 @@ defined as
 
 .. math::
 
-  \text{Max Error}(y, \hat{y}) = max(| y_i - \hat{y}_i |)
+  \text{Max Error}(y, \hat{y}) = \max(| y_i - \hat{y}_i |)
 
 Here is a small example of usage of the :func:`max_error` function::
 
diff --git a/examples/ensemble/plot_bias_variance.py b/examples/ensemble/plot_bias_variance.py
@@ -12,7 +12,8 @@
 predictions of the estimator differ from the predictions of the best possible
 estimator for the problem (i.e., the Bayes model). The variance term measures
 the variability of the predictions of the estimator when fit over different
-instances LS of the problem. Finally, the noise measures the irreducible part
+random instances of the same problem. Each problem instance is noted "LS", for
+"Learning Sample", in the following. Finally, the noise measures the irreducible part
 of the error which is due the variability in the data.
 
 The upper left figure illustrates the predictions (in dark red) of a single
diff --git a/sklearn/inspection/_partial_dependence.py b/sklearn/inspection/_partial_dependence.py
@@ -146,8 +146,8 @@ def _partial_dependence_brute(est, grid, features, X, response_method):
             else:
                 raise ValueError("The estimator has no decision_function method.")
 
+    X_eval = X.copy()
     for new_values in grid:
-        X_eval = X.copy()
         for i, variable in enumerate(features):
             if hasattr(X_eval, "iloc"):
                 X_eval.iloc[:, variable] = new_values[i]
diff --git a/sklearn/random_projection.py b/sklearn/random_projection.py
@@ -305,13 +305,11 @@ def __init__(
         n_components="auto",
         *,
         eps=0.1,
-        dense_output=False,
         compute_inverse_components=False,
         random_state=None,
     ):
         self.n_components = n_components
         self.eps = eps
-        self.dense_output = dense_output
         self.compute_inverse_components = compute_inverse_components
         self.random_state = random_state
 
@@ -405,45 +403,11 @@ def fit(self, X, y=None):
             self.n_components_, n_features
         ).astype(X.dtype, copy=False)
 
-        # Check contract
-        assert self.components_.shape == (self.n_components_, n_features), (
-            "An error has occurred the self.components_ matrix has "
-            " not the proper shape."
-        )
-
         if self.compute_inverse_components:
             self.inverse_components_ = self._compute_inverse_components()
 
         return self
 
-    def transform(self, X):
-        """Project the data by using matrix product with the random matrix.
-
-        Parameters
-        ----------
-        X : {ndarray, sparse matrix} of shape (n_samples, n_features)
-            The input data to project into a smaller dimensional space.
-
-        Returns
-        -------
-        X_new : {ndarray, sparse matrix} of shape (n_samples, n_components)
-            Projected array.
-        """
-        check_is_fitted(self)
-        X = self._validate_data(
-            X, accept_sparse=["csr", "csc"], reset=False, dtype=[np.float64, np.float32]
-        )
-
-        if X.shape[1] != self.components_.shape[1]:
-            raise ValueError(
-                "Impossible to perform projection:"
-                "X at fit stage had a different number of features. "
-                "(%s != %s)" % (X.shape[1], self.components_.shape[1])
-            )
-
-        X_new = safe_sparse_dot(X, self.components_.T, dense_output=self.dense_output)
-        return X_new
-
     @property
     def _n_features_out(self):
         """Number of transformed output features.
@@ -582,13 +546,12 @@ def __init__(
         super().__init__(
             n_components=n_components,
             eps=eps,
-            dense_output=True,
             compute_inverse_components=compute_inverse_components,
             random_state=random_state,
         )
 
     def _make_random_matrix(self, n_components, n_features):
-        """ Generate the random projection matrix.
+        """Generate the random projection matrix.
 
         Parameters
         ----------
@@ -600,16 +563,34 @@ def _make_random_matrix(self, n_components, n_features):
 
         Returns
         -------
-        components : {ndarray, sparse matrix} of shape \
-                (n_components, n_features)
-            The generated random matrix. Sparse matrix will be of CSR format.
-
+        components : ndarray of shape (n_components, n_features)
+            The generated random matrix.
         """
         random_state = check_random_state(self.random_state)
         return _gaussian_random_matrix(
             n_components, n_features, random_state=random_state
         )
 
+    def transform(self, X):
+        """Project the data by using matrix product with the random matrix.
+
+        Parameters
+        ----------
+        X : {ndarray, sparse matrix} of shape (n_samples, n_features)
+            The input data to project into a smaller dimensional space.
+
+        Returns
+        -------
+        X_new : ndarray of shape (n_samples, n_components)
+            Projected array.
+        """
+        check_is_fitted(self)
+        X = self._validate_data(
+            X, accept_sparse=["csr", "csc"], reset=False, dtype=[np.float64, np.float32]
+        )
+
+        return X @ self.components_.T
+
 
 class SparseRandomProjection(BaseRandomProjection):
     """Reduce dimensionality through sparse random projection.
@@ -759,15 +740,15 @@ def __init__(
         super().__init__(
             n_components=n_components,
             eps=eps,
-            dense_output=dense_output,
             compute_inverse_components=compute_inverse_components,
             random_state=random_state,
         )
 
+        self.dense_output = dense_output
         self.density = density
 
     def _make_random_matrix(self, n_components, n_features):
-        """ Generate the random projection matrix
+        """Generate the random projection matrix
 
         Parameters
         ----------
@@ -779,13 +760,33 @@ def _make_random_matrix(self, n_components, n_features):
 
         Returns
         -------
-        components : {ndarray, sparse matrix} of shape \
-                (n_components, n_features)
-            The generated random matrix. Sparse matrix will be of CSR format.
+        components : sparse matrix of shape (n_components, n_features)
+            The generated random matrix in CSR format.
 
         """
         random_state = check_random_state(self.random_state)
         self.density_ = _check_density(self.density, n_features)
         return _sparse_random_matrix(
             n_components, n_features, density=self.density_, random_state=random_state
         )
+
+    def transform(self, X):
+        """Project the data by using matrix product with the random matrix.
+
+        Parameters
+        ----------
+        X : {ndarray, sparse matrix} of shape (n_samples, n_features)
+            The input data to project into a smaller dimensional space.
+
+        Returns
+        -------
+        X_new : {ndarray, sparse matrix} of shape (n_samples, n_components)
+            Projected array. It is a sparse matrix only when the input is sparse and
+            `dense_output = False`.
+        """
+        check_is_fitted(self)
+        X = self._validate_data(
+            X, accept_sparse=["csr", "csc"], reset=False, dtype=[np.float64, np.float32]
+        )
+
+        return safe_sparse_dot(X, self.components_.T, dense_output=self.dense_output)
