RFC: Addresses PR comments

thomasjpfan · thomasjpfan · commit 81e3e68b3056 · 2018-08-23T12:21:35.000-04:00
diff --git a/sklearn/compose/_column_transformer.py b/sklearn/compose/_column_transformer.py
@@ -376,45 +376,46 @@ def _fit_transform(self, X, y, func, fitted=False):
             else:
                 raise
 
-    def _calculate_inverse_indices(self, X):
+    def _calculate_inverse_indices(self, X, Xs):
         """
         Private function to calcuate indicies for inverse_transform
         """
         # checks for overlap
-        all_indexes = set()
+        all_indices = set()
         input_indices = []
         for name, trans, cols in self.transformers:
             col_indices = _get_column_indices(X, cols)
             col_indices_set = set(col_indices)
-            if not all_indexes.isdisjoint(col_indices_set):
-                self._invert_error = ("Unable to invert: transformers "
-                                      "contain overlaping columns")
+            if not all_indices.isdisjoint(col_indices_set):
+                self._invert_error = (
+                    "transformers contain overlapping columns")
                 return
             if trans == 'drop':
-                self._invert_error = "'{}' drops columns".format(name)
+                self._invert_error = ("dropping columns is not supported. "
+                                      "'{}' drops columns".format(name))
                 return
             input_indices.append(col_indices)
-            all_indexes.update(col_indices_set)
+            all_indices.update(col_indices_set)
 
         # check remainder
         remainder_indices = self._remainder.indices
         if (remainder_indices is not None
                 and self._remainder.transformer == 'drop'):
-            self._invert_error = "remainder drops columns"
+            self._invert_error = ("dropping columns is not supported. "
+                                  "remainder drops columns")
             return
 
         if remainder_indices is not None:
             input_indices.append(remainder_indices)
 
         self._input_indices = input_indices
         self._n_features_in = X.shape[1]
-        self._X_columns = X.columns if hasattr(X, 'columns') else None
+        self._X_columns = getattr(X, 'columns', None)
         self._X_is_sparse = sparse.issparse(X)
         self._invert_error = ""
         self._output_indices = []
         cur_index = 0
 
-        Xs = self._fit_transform(X[0:1], None, _transform_one, fitted=True)
         for X_transform in Xs:
             X_features = X_transform.shape[-1]
             self._output_indices.append(
@@ -492,7 +493,7 @@ def fit_transform(self, X, y=None):
             self.sparse_output_ = False
 
         self._update_fitted_transformers(transformers)
-        self._calculate_inverse_indices(X)
+        self._calculate_inverse_indices(X, Xs)
         self._validate_output(Xs)
 
         return _hstack(list(Xs), self.sparse_output_)
@@ -555,12 +556,12 @@ def inverse_transform(self, X):
                 trans = FunctionTransformer(
                     validate=False, accept_sparse=True, check_inverse=False)
 
-            inv_transformers.append((name, trans, sub, get_weight(name)))
+            inv_transformers.append((trans, sub, get_weight(name)))
 
         Xs = Parallel(n_jobs=self.n_jobs)(
             delayed(_inverse_transform_one)(
                 trans, X_sel, weight)
-            for _, trans, X_sel, weight in inv_transformers)
+            for trans, X_sel, weight in inv_transformers)
 
         if not Xs:
             # All transformers are None
@@ -570,7 +571,7 @@ def inverse_transform(self, X):
             inverse_Xs = sparse.lil_matrix((Xs[0].shape[0],
                                             self._n_features_in))
         else:
-            inverse_Xs = np.zeros((Xs[0].shape[0], self._n_features_in))
+            inverse_Xs = np.empty((Xs[0].shape[0], self._n_features_in))
         for indices, inverse_X in zip(self._input_indices, Xs):
             if sparse.issparse(inverse_X):
                 if self._X_is_sparse:
diff --git a/sklearn/compose/tests/test_column_transformer.py b/sklearn/compose/tests/test_column_transformer.py
@@ -159,7 +159,8 @@ def test_column_transformer_inverse_transform_with_drop():
                             ('trans2', 'drop', [1])])
     res = ct.fit_transform(X_array)
 
-    error_msg = "Unable to invert: 'trans2' drops columns"
+    error_msg = ("Unable to invert: dropping columns is "
+                 "not supported. 'trans2' drops columns")
     with pytest.raises(ValueError, match=error_msg):
         ct.inverse_transform(res)
 
@@ -170,7 +171,7 @@ def test_column_transformer_inverse_transform_with_overlaping_slices():
                             ('trans2', Trans(), [0])])
     res = ct.fit_transform(X_array)
 
-    error_msg = "Unable to invert: transformers contain overlaping columns"
+    error_msg = "Unable to invert: transformers contain overlapping columns"
     with pytest.raises(ValueError, match=error_msg):
         ct.inverse_transform(res)
 
@@ -180,7 +181,8 @@ def test_column_transformer_inverse_transform_with_remainder_drops():
     ct = ColumnTransformer([('trans1', Trans(), [0])])
     res = ct.fit_transform(X_array)
 
-    error_msg = "Unable to invert: remainder drops columns"
+    error_msg = ("Unable to invert: dropping columns is not supported. "
+                 "remainder drops columns")
     with pytest.raises(ValueError, match=error_msg):
         ct.inverse_transform(res)
 
