Here's an example with a pipeline. @jnothman would you please check if it's [almost] what you had in mind?

@NicolasHug you were interested in this one as well IIRC.

from sklearn.model_selection import GroupKFold, cross_validate
from sklearn.feature_selection import SelectKBest
from sklearn.pipeline import make_pipeline
from sklearn.linear_model import LogisticRegressionCV
from sklearn.metrics import accuracy_score
from sklearn.metrics import make_scorer
import numpy as np
from sklearn.datasets import make_classification
X, y = make_classification()
sw = np.random.rand(len(X))
sw2 = [5, 6]
brand = ['my brand']

from sklearn.base import BaseEstimator, ClassifierMixin, TransformerMixin
from sklearn.utils.validation import _validate_required_props
from sklearn.svm import SVC

class MyEst(ClassifierMixin, BaseEstimator):
    def __init__(self):
        self._props_request = {'fit': ['sample_weight', 'brand']}

    def fit(self, X, y, **fit_params):
        _validate_required_props(self, fit_params, 'fit')
        self._estimator = SVC().fit(X, y, fit_params['sample_weight'])
        print("{} recieved params {} of lengths {}".format(
            self.__class__.__name__,
            list(fit_params.keys()), [len(v) for v in fit_params.values()]))

class MyTrs(TransformerMixin, BaseEstimator):
    def __init__(self):
        self._props_request = {'fit': ['sample_weight']}

    def fit(self, X, y=None, **fit_params):
        _validate_required_props(self, fit_params, 'fit')
        self._estimator = SelectKBest().fit(X, y)
        print("{} recieved params {} of lengths {}".format(
            self.__class__.__name__,
            list(fit_params.keys()), [len(v) for v in fit_params.values()]))
        return self

    def transform(self, X, y=None):
        return self._estimator.transform(X)

clf = make_pipeline(MyTrs(), MyEst())
clf.fit(X, y, sample_weight=sw, brand=brand)

MyTrs recieved params ['sample_weight'] of lengths [100]
MyEst recieved params ['sample_weight', 'brand'] of lengths [100, 1]

Pipeline(memory=None, steps=[('mytrs', MyTrs()), ('myest', MyEst())],
         verbose=False)

trs = MyTrs().set_props_request(
    None).set_props_request(
    {'fit': {'new_param': 'my_sw'}})
clf = make_pipeline(trs, MyEst())
clf.fit(X, y, sample_weight=sw, brand=brand, my_sw=sw2)

MyTrs recieved params ['new_param'] of lengths [2]
MyEst recieved params ['sample_weight', 'brand'] of lengths [100, 1]

Pipeline(memory=None, steps=[('mytrs', MyTrs()), ('myest', MyEst())],
         verbose=False)

clf.fit(X, y, brand=brand)

---------------------------------------------------------------------------

ValueError                                Traceback (most recent call last)

<ipython-input-6-b2a96948c309> in <module>
----> 1 clf.fit(X, y, brand=brand)


~/Projects/sklearn/scikit-learn/sklearn/pipeline.py in fit(self, X, y, **fit_params)
    364             This estimator
    365         """
--> 366         Xt, fit_params = self._fit(X, y, **fit_params)
    367         with _print_elapsed_time('Pipeline',
    368                                  self._log_message(len(self.steps) - 1)):


~/Projects/sklearn/scikit-learn/sklearn/pipeline.py in _fit(self, X, y, **fit_params)
    288         fit_transform_one_cached = memory.cache(_fit_transform_one)
    289 
--> 290         _validate_required_props(self, fit_params, 'fit')
    291 
    292         for (step_idx,


~/Projects/sklearn/scikit-learn/sklearn/utils/validation.py in _validate_required_props(obj, given_props, method)
   1337     given_props = set(given_props.keys())
   1338     if required_props != given_props:
-> 1339         raise ValueError("Requested properties are: {}, but {} "
   1340                          "provided".format(list(required_props),
   1341                                            list(given_props)))


ValueError: Requested properties are: ['brand', 'my_sw', 'sample_weight'], but ['brand'] provided

That example looks nice! I think I had not envisaged that all requested props were required, i.e. an estimator could request sample_weight by default but only receive it if available. What are your thoughts on that?

What I'm not sure about is whether we need to specify that the request is for fit. I suppose that makes things more flexible.

I have looked at your modification to clone. Okay. But I've not yet looked at much else

I think I had not envisaged that all requested props were required, i.e. an estimator could request sample_weight by default but only receive it if available. What are your thoughts on that?

I also first thought of having it as "please give me that prop if you have it" rather than "I really need it". The reason I have it as a mandatory requirement, is that it kinda removes the chances of a meta estimator not passing a required prop by mistake. My gut feeling was that it removes some of those bugs.

What I'm not sure about is whether we need to specify that the request is for fit. I suppose that makes things more flexible.

I think your other proposals had a more flexible system for routing the props around. Especially when it comes to fit/score/split distinction. Also, I thought this makes it easier to have some props going to transform/predict as well.

The reason I have it as a mandatory requirement, is that it kinda removes the chances of a meta estimator not passing a required prop by mistake. My gut feeling was that it removes some of those bugs.

But this would be a mistake in meta-estimator implementation which should not be the user's problem?

This looks good!

Edit: previous comment was irrelevant after I finally read all of #4497 and #SLEP006. My initial conception (and hacky implementation in personal project) looked very similar to the single argument, no routing approach.

Now for some comments (sorry if these are still uninformed):

• single argument vs. kwargs: I feel strongly that the single argument approach is best.
• routing vs. blind passing of all: I see pros and cons to each, but I think it should be possible to implement in a non-exclusive manner. Ex, if the key starts with route_ it gets routed (however that ends up working) and if not it always gets passed. That would also allow for the simpler behavior to be implemented immediately and the routing to be done separately once that basic infrastructure is in place.
• unexpected behavior changes: very good points were raised in #4497 regarding changes in behavior without changes in data. I think that is definitely a concern, but I cannot immediately think of a way around that.

I guess my main question/point is: can this be done in two phases? Phase 1 would be implementing the basic infrastructure (i.e. changing a lot of signatures thought the API) so that sample_props gets passed correctly. Changes would also have to be made to fold in sample_weight and other existing sample properties. Phase 2 would be routing, requesting/requiring, etc.

That said, how can I be of use to get this done?