Initializing new random instances for each estimator instead of passing around the same one

### Describe the issue linked to the documentation

After reading the detailed and helpful section on ["Controlling randomness"](https://scikit-learn.org/stable/common_pitfalls.html#controlling-randomness), my understanding is that the benefit of passing an `np.random.RandomState` instance to each estimator is the different randomness for different folds during the CV process, which passing an integer would not provide. In the sample code, the random instance is defined globally and then passed to the `random_state` parameter of all function calls. The drawback of this is that the order of operations now matters (as mentioned in the documentation) and the addition of any code that uses the same globally defined random instance variable will advance the random number generator and change the results of any code that is run afterwards, which can be quite confusing and not ideal for reproducibility.

Instead of defining this random state globally and re-using it, would it not be more beneficial to pass a new instance to each estimator? It seems to me that this would combine the benefits of the CV exploring different randomness in each fold, and having the code reproducible regardless of insertion of new code that uses the same random instance.


### Suggest a potential alternative/fix

Instead of the current recommendation in the docs:

```py
rng = RandomState(0)  # from numpy.random import RandomState
X, y = make_classification(random_state=rng)
rf = RandomForestClassifier(random_state=rng)
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=rng)
rf.fit(X_train, y_train).score(X_test, y_test)
```

I would expect this to combine the benefits I mentioned above:

```py
rng_init = 0
X, y = make_classification(random_state=RandomState(rng_init))
rf = RandomForestClassifier(random_state=RandomState(rng_init))
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=RandomState(rng_init))
rf.fit(X_train, y_train).score(X_test, y_test)
```

Apart from the increased verbosity, is there any downside to this approach (or is it even the same as passing an `int` so it has the same downsides)? If not, would you be open to a PR mentioning this in the docs? I am not that well-versed with pseudo random number generators in general, so while I know that the sequence generated by the number generator can be beneficial for some application, I don't know if there are any benefits to advancing this sequence as a global variable between different estimator call or if it is more important within each estimator and it is therefore fine to reinitialize the sequence as I suggest above.

And in this particular example, isn't only to the estimator we need to pass the `RandomState` instance (so the call to `make_classification` and `train_test_split` could receive an `int` instead which would make it less verbose)?

COMMENT:
> The top comment made me think of https://scikit-learn.org/stable/common_pitfalls.html#id2 which highlights the difference between passing and integer and a sequence when performing cross-validation. Basically, when you clone an estimator that uses a integer as seed, the cloned estimator and the original will see the same sequence of random numbers. This matters when you do grid search (where estimators are cloned for each new parameter value). As the docs state, it probably makes sense to not use an integer in this case.

I think this documentation is out of date. The section on cloning says:
> Moreover, `a` and `b` will influence each-other since they share the same internal RNG: calling `a.fit` will consume `b`’s RNG, and calling `b.fit` will consume `a`’s RNG, since they are the same. 

However, I tried the code provided therein, and it seems like RNG are somehow cloned together with an estimator. Am I missing anything?

```python
from sklearn import clone
from sklearn.datasets import make_classification
from sklearn.ensemble import RandomForestClassifier
import numpy as np

X, y = make_classification(n_samples=100, random_state=0)
rng = np.random.RandomState(0)
a = RandomForestClassifier(random_state=rng)
b = clone(a)
print(repr(a.random_state)) # RandomState(MT19937) at 0x7EFF69071A40
print(repr(b.random_state)) # RandomState(MT19937) at 0x7EFF688ED840 # Expected the same address
print(a.random_state.randint(10, size=10)) # [5 0 3 3 7 9 3 5 2 4]
print(b.random_state.randint(10, size=10)) # [5 0 3 3 7 9 3 5 2 4] # Expected a different sequence
```

I tried this on version `1.0.2` and on a two-week-old dev build. Should I open a DOC issue?

------ 

P.S. This behaviour (when RNG is automatically cloned) is desirable for reproducibility: we don't want parallel jobs affect each other unpredictably and uncontrollably. Does this sound right? Also, I wonder if using a single RNG instance creates a bottle neck in multithreading or multiprocessing.

Labels: Documentation