sklearn.preprocessing.StandardScaler() needs a degrees of freedom tunable parameter for scale_

### Describe the workflow you want to enable

I'm scaling a dataset using the standard procedure.

```
from sklearn.preprocessing import StandardScaler

sc = StandardScaler()
sc.fit(data)
sc.transform(data)
```

I'm comparing the results I get with the results from the R function `scale()`. They are subtly different. Tracking down the difference, it turns out sklearn uses a different definition for the standard deviation, one that differs from R in the degrees of freedom assumed. sklearn assumes ddof=0, while R assumes ddof=1.

https://stackoverflow.com/questions/27296387/difference-between-r-scale-and-sklearn-preprocessing-scale/72758497

I do not wish to debate which approach is "more correct". I am fine with sklearn continuing with the current approach as the default. I only want to suggest that, for those who think the slight DoF correction is necessary, `StandardScaler()` should provide an option to tune the degrees of freedom, either in the initial `StandardScaler()` call, or later in the `fit()` call, or wherever it is deemed more appropriate.

### Describe your proposed solution

Basically, leave the default as-is. Introduce a new parameter, let's call it `ddof`, with a default value of 0, but allow the user to specify a different value for it if they need it.

Or have a boolean switch, by default False, which when True enables the Bessel correction, which is the same as using N-1 instead of N for the standard deviation.

I do not know enough about the sklearn internals to judge which solution is better.

### Describe alternatives you've considered, if relevant

This workaround forces `StandardScaler()` to use ddof=1, but it's an extra step and it computes the STD twice. With large datasets, that would slow down the computation and it's wasteful.

```
from sklearn.preprocessing import StandardScaler
import numpy as np

sc = StandardScaler()
sc.fit(data)
sc.scale_ = np.std(data, axis=0, ddof=1).to_list()
sc.transform(data)
```

### Additional context

https://en.wikipedia.org/wiki/Bessel%27s_correction

COMMENT:
Thank you for circling back to this.  

I teach science (not primarily coding) to undergraduate students.  Students majoring in science may not be required to take classes in computer science, but machine learning is increasingly relevant in science.  So, we are starting to look at teaching simple coding and machine learning in science classes, and easy-to-use Python packages such as scikit-learn could be helpful.  

For scientific applications, we require high precision.  Ignoring this correction limits precision at a number of digits equal to that of the number of entries in the training set.  Scaling occurs early in the workflow, so precision and accuracy are further degraded before the end. *Update: To your point below, yes, I understand that this is part of preprocessing.*

For example, I asked one student to reproduce the process used by the Environmental Protection Agency to predict the base-10 logarithm of biodegradation half-life for new toxins (http://dx.doi.org/10.13140/RG.2.2.34751.92320/1).  The training set has 112 entries (the number 112 has 3 digits), so ignoring this correction leads to a noticeable loss of accuracy. *Update: To your point below, I did not mean to imply that scaling affects predictions using tree based models or unpenalized linear models.  We happened to notice an impact when using the k-nearest neighbors model, following this published method.*

(Note: The code used by the EPA is written in Matlab.  Of course we could use that if we only wanted answers, but we also want code that remains accessible to students while demonstrating the steps in a simple, relevant machine learning process.)

Obviously we can just use np.std and even wrap it in a FunctionTransformer, and this one student will just do that for right now.  

However, personally I am still in early stages of testing this approach.  I hope to minimize workarounds, because what may seem like a simple workaround to experts could be distracting for students.  

Thank you for your time and consideration.

*Update: I certainly appreciate that you have a vast understanding, test suite, and so forth and I did not mean to cause offense.  I meant only to provide our use case here, as requested.*

Labels: New Feature, module:preprocessing, Needs Decision - Include Feature