Support inverse_transform in ColumnTransformer

Since ColumnTransformer is primarily used to apply basic preprocessing, it would be extremely helpful if it (and FeatureUnion while we’re at it) supported inverse_transform (where each of its constituent estimators does too). This also would replace some functionality we might otherwise support with categorical_features or ignored_features etc parameters (H/T @qinhanmin2014).

In order for it to support inverse_transform, it would need to have an index of which columns in the output came from which transformers, which is what I intended to solve in #1952. This is not hard as long as fit_transform, rather than fit, is called, or as long as all the constituent transformers support get_feature_names. Maybe we could force a run of transform when fit is called in order to check the output size.

(Alternatively, it might be nice to have a consistent API for a transformer to declare its output size, which n_components_ does for a handful of estimators.)

[arkanoid87]

I need to apply a different scaling factor to every column of my dataset. In particular I need to rescale columns dt.dayofyear, dt.month, dt.quarter and dt.hour to sine and cosine for ML. All my transform functions are reversible so I tried (without reading in depth the manual) to apply ColumnTransform + Pipeline but then I realised that the first was not passing the invert_transform functions described into the FunctionTransformers in my Pipelines.

So I coded this bare encoder where I pass a list of encoders matching the columns order in my dataset and it seems working

class ColumnScaler():
    def __init__(self, encoders=None):
        self.encoders = encoders
    
    def fit(self, X):
        X = check_array(X)
        columns = X.T
        encoders = self.encoders
        for column, encoder in zip(columns, encoders):
            encoder.fit(column.reshape(column.shape[0],1)), 
    
    def transform(self, X):
        X = check_array(X)
        result = np.column_stack(map(
            lambda column, encoder: encoder.transform(column.reshape(column.shape[0],1)), 
            X.T,
            self.encoders
        ))
        return result
    
    def inverse_transform(self, X):
        X = check_array(X)
        result = np.column_stack(map(
            lambda column, encoder: encoder.inverse_transform(column.reshape(column.shape[0],1)), 
            X.T,
            self.encoders
        ))
        return result

like this

def cycle_pipeline():
    return Pipeline([
        ('MinMaxScaler', MinMaxScaler(feature_range=(0, 360))),
        ('deg2rad', FunctionTransformer(func=np.deg2rad, inverse_func=np.rad2deg, validate=True)),
        ('sin', FunctionTransformer(func=np.sin, inverse_func=np.arcsin, validate=True)),
    ])
    
encoders = [
    MinMaxScaler(),
    MinMaxScaler(),
    MinMaxScaler(),
    MinMaxScaler(),
    cycle_pipeline(),
    cycle_pipeline(),
    cycle_pipeline(),
    cycle_pipeline(),
    cycle_pipeline(),
    cycle_pipeline(),
    cycle_pipeline(),
    cycle_pipeline()
]
scaler = ColumnScaler(encoders)
scaler.fit(data_copy)

[gilbertovilarunc]

Is it solved? Reaally need this feature!