Why must a scikit-learn estimator's __init__ store every argument unchanged?

## The rule A scikit-learn estimator's `__init__` does one thing: it assigns each argument to an attribute of exactly the same name, verbatim. No type coercion, no validation, no defaults filled in, no derived values, no reading files, no touching data. `def __init__(self, alpha=1.0): self.alpha = alpha`. That is the whole of it. This looks like a stylistic convention. It is not — it is what makes the rest of the library work. ## How get_params actually works `BaseEstimator.get_params` is generic code that has never seen your class. It cannot know which attributes are hyperparameters and which are scratch state. So it uses the only reliable declaration available: the signature of `__init__`. It calls `inspect.signature` on the constructor, takes every parameter except `self`, and then does `getattr(self, name)` for each. Two consequences follow immediately. First, the *name* matters: if the argument is `alpha` but you store `self.a = alpha`, `get_params` raises an `AttributeError`, because it looks for `self.alpha`. Second, the *value* matters: `get_params` reports whatever the attribute currently holds, not what the caller passed. `get_params(deep=True)` is the default and additionally walks any parameter value that is itself an estimator, exposing its parameters under `name__subname`. `deep=False` gives you only this estimator's own parameters. ## What clone does with those values `sklearn.base.clone(estimator)` produces a fresh, unfitted estimator with the same configuration. Its implementation is roughly: take `get_params(deep=False)`, clone each value, construct `Klass(**those_params)`, then call `get_params(deep=False)` on the *new* object and check that each value is the same object it just passed in. The check is an identity check, not equality. Now put a conversion in the constructor. `self.alpha = float(alpha) * 2` with `alpha=1.0` stores `2.0`. `get_params` reports `alpha=2.0`. `clone` constructs `Klass(alpha=2.0)`, which stores `4.0`. `2.0 is not 4.0`, so clone raises `RuntimeError` complaining that the constructor either does not set or modifies the parameter. Even a benign-looking `self.tags = list(tags)` fails: the copy is equal but not identical. ## Why this matters everywhere Every place scikit-learn needs "the same model, freshly configured" goes through clone: each fold of a cross-validation, each candidate of a hyperparameter search, each step when a pipeline is fitted, each base estimator inside an ensemble or a one-vs-rest wrapper. An estimator that cannot be cloned works perfectly when you call `fit` and `predict` by hand, and then blows up — or, worse, silently uses wrong hyperparameters — the moment you hand it to any of that machinery. That gap between "works in my notebook" and "fails under cross-validation" is exactly what interviewers are probing. ## The varargs rules, which differ The two forms of variadic argument fail differently, and knowing which is which is a good signal. - `def __init__(self, *args)`: `get_params` raises `RuntimeError` outright, telling you that scikit-learn estimators must always specify their parameters in the signature of `__init__`. - `def __init__(self, **kwargs)`: no error. The `**kwargs` parameter is simply skipped, so any hyperparameter passed through it is invisible to `get_params`. It is not reported, not searched over, and not restored by clone — the clone silently comes back with constructor defaults. Silent is worse than loud. ## Where the work goes instead Everything you were tempted to put in `__init__` goes in `fit`: - **Validation.** Raise on a bad `alpha` inside `fit`, not in the constructor. This is why `LogisticRegression(C=-1)` constructs happily and only complains when you fit it. Built-in estimators drive this from a private `_parameter_constraints` mechanism invoked during fit; a custom estimator can just check its arguments at the top of `fit`. - **Coercion.** `check_array` / `validate_data` on `X` inside `fit`; converting a list hyperparameter to an array inside `fit` and storing the result as `self.alpha_`. - **Derived state.** Anything computed from the hyperparameters or the data is fitted state and takes a trailing underscore, keeping it clearly separate from the untouched constructor parameters. `set_params(**params)` is the mirror image: it validates names against `get_params` and does plain `setattr`, which is why it can also reach nested estimators with the `component__param` syntax. Because it only sets attributes, a constructor that computed things would be bypassed entirely by `set_params` — another reason the constructor must stay inert. ## Checklist for a custom estimator's constructor Every argument is an explicit keyword parameter with a default; every assignment is `self.name = name`; no `*args`; nothing else in the body. If you can delete the body and regenerate it mechanically from the signature, it is correct.