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:
> What would I pass to random_state in this case, a numpy Generator?

An integer. In your case, just passing `rng_init`. Internally, we are going to call `np.random.RandomState(rng_init)`.

Labels: Documentation