Hello @jnothman, I'd like to work on this issue.

Are you talking about modification like this--

def transform(self,X,y=None):
if y is not None:
warning.warn("Parameter y is Deprecated for this method as it is not required and will be removed in future version")

@GaelVaroquaux please clarify examples. IMO:

• I can't think of any case y is used in transform atm
• It is certainly not forwarded by Pipeline or FeatureUnion
• We have inconsistency as to whether y=None is included in transform's signature
• But I think including it in transform's signature when it is generally unused confuses users and people writing their own transformers.
• The documentation has transform with a single positional arg as the prototype.

Hello @jnothman, I think it is authentic before starting working on a PR is to ask weather some one else is working on or not. I had started working on this issue and was going to make a PR, in the mean time @tzano directly make a PR.

Is work is still do be done in this issue.

I argued for this before, but @GaelVaroquaux wanted to wait on a ruling on what we're gonna do in terms of a new interface before deprecating anything. I'm still totally for it.

Fixed

@jnothman
@GaelVaroquaux

"I can't think of any case y is used in transform atm"

"So, I agree that transform cannot accept y."

I have a use case for a transform accepting 'y'.

During the training phase:

Fit(X,y):

• for a given feature X['feature'], fit model that predicts that feature based on 'y' (and maybe other features)

Transform(X,y):

• if an instance of the given feature is determined to be an outlier, replace it with the value predicted by the model created in 'fit' (which requires 'y').

...Then, during the predict phase:

Transform(X,y==None):

• there is no 'y', so do nothing

To summarise: during training, you use a model based on 'y' to predict 'x', and use it to replace outliers in X.
This may allow you to train a more reasonable classifier.

Then, during predict, you do nothing in the transform, since 'y' is what you are predicting.

For this, you want the option of being able to pass in 'y' during the training phase, but not passing it in during the predict phase.

Edit: but maybe there is a better way of doing this? I just wanted everything to be in the pipeline, rather than doing this step separately.

@matlotpib isn't this what fit_transform allows for? Or am I missing something?

I am using FunctionTransformer for the first time, and I absolutely need y for my purposes. What I wish to do is remove "non-modal" (i.e. atypical) target values. I have a training set where I can assume that these uncommon target values are bad data. Only one of the mode values should be permitted for a particular combination of features (by default the identity of a person, but the interface allows selecting other fields to define "equivalent" persons).

def _modal_filter(X, y, fields='_member_key'):
    df = X.copy()
    df['TARGET'] = y
    df = modal_filter(df, fields)
    df.drop([c for c in df.columns if c.startswith(('TARGET', '_'))], 
            axis=1, inplace=True)
    return df

def ModalFilter(fields):
    fn = partial(_modal_filter, fields=fields)
    return FunctionTransformer(fn, validate=False, pass_y=True)

If I cannot pass in y, there does not seem to be any way to accommodate this in a pipeline. You can see that the underlying function modal_filter() works fine. but accepts a DataFrame that has a TARGET column in it. This is a good function, but cannot be pipelined directly (as far as I can see)

y is needed in this case: you want to make a FunctionTransformer that either calls CountEncoder, or TargetEncoder, the choice is passed in with method='target_encoder' (default). Both encoders are from catagory_encoders. TargetEncoder encodes X but not y. It just uses y to do the encoding.