Talip7/scikit-learn-issues-multilabel huggingface dataset:
DOC Improve the docstring of log loss to cover the multiclass case

### Describe the issue linked to the documentation

The docstring of the `log_loss` function (also known as the "cross-entropy loss") only gives the mathematical description of the loss when `y_true` is a binary variable (binary cross-entropy).

### Suggest a potential alternative/fix

We should also give the formula for the multiclass case (categorical cross-entropy) with `y_true` being one-hot encoded as done in:

https://ml-cheatsheet.readthedocs.io/en/latest/loss_functions.html#cross-entropy

![Screenshot from 2022-04-06 11-45-59](https://user-images.githubusercontent.com/89061/161950527-1722b378-44af-4192-8162-d789c1ef2970.png)

for instance.

Actually this formula is given in the user guide:

https://scikit-learn.org/stable/modules/model_evaluation.html#log-loss

I think the docstring should be improved accordingly.

The user guide could also be improved to give a code-snippet example for the multiclass case.

```python
>>> log_loss(
...     np.array([[0, 1, 0], [1, 0, 0]]),
...     np.array([[0.1, 0.8, 0.1], [0.9, 0.1, 0]]),
... )
0.164...
```

COMMENT:
Hi @lorentzenchr , I've opened a PR to make the documentation more consistent, could you help take a look if you got time, thank you!

Labels: Documentation, Enhancement, module:metrics
DOC Improve the docstring of log loss to cover the multiclass case

### Describe the issue linked to the documentation

The docstring of the `log_loss` function (also known as the "cross-entropy loss") only gives the mathematical description of the loss when `y_true` is a binary variable (binary cross-entropy).

### Suggest a potential alternative/fix

We should also give the formula for the multiclass case (categorical cross-entropy) with `y_true` being one-hot encoded as done in:

https://ml-cheatsheet.readthedocs.io/en/latest/loss_functions.html#cross-entropy

![Screenshot from 2022-04-06 11-45-59](https://user-images.githubusercontent.com/89061/161950527-1722b378-44af-4192-8162-d789c1ef2970.png)

for instance.

Actually this formula is given in the user guide:

https://scikit-learn.org/stable/modules/model_evaluation.html#log-loss

I think the docstring should be improved accordingly.

The user guide could also be improved to give a code-snippet example for the multiclass case.

```python
>>> log_loss(
...     np.array([[0, 1, 0], [1, 0, 0]]),
...     np.array([[0.1, 0.8, 0.1], [0.9, 0.1, 0]]),
... )
0.164...
```

COMMENT:
I close as the multiclass logloss is documented.

Labels: Documentation, Enhancement, module:metrics
Doc Examples Bug: `plot_column_transformer_mixed_types`, missing categorical SimpleImputer

### Describe the issue linked to the documentation

The [`plot_column_transformer_mixed_types`](https://github.com/scikit-learn/scikit-learn/blob/582fa30a31ffd1d2afc6325ec3506418e35b88c2/examples/compose/plot_column_transformer_mixed_types.py) example says that it will use  a simpleimputer for the categorical pipeline:

https://github.com/scikit-learn/scikit-learn/blob/582fa30a31ffd1d2afc6325ec3506418e35b88c2/examples/compose/plot_column_transformer_mixed_types.py#L14-L16

But it actually doesn't:

https://github.com/scikit-learn/scikit-learn/blob/582fa30a31ffd1d2afc6325ec3506418e35b88c2/examples/compose/plot_column_transformer_mixed_types.py#L76



### Suggest a potential alternative/fix

I'll submit a PR adding the simpleimputer.

COMMENT:
`OneHotEncoder` does not require `SimpleImputer` to add a new missing category anymore. `OneHotEncoder` now encodes missing categories by default.

```python
import numpy as np
from sklearn.preprocessing import OneHotEncoder

X = np.asarray([["dog"], ["cat"], [np.nan]])
ohe = OneHotEncoder(sparse=False)
print(ohe.fit_transform(X))
# [[0. 1. 0.]
#  [1. 0. 0.]
#  [0. 0. 1.]]

print(ohe.get_feature_names_out())
# ['x0_cat' 'x0_dog' 'x0_nan']
```

 In this case, I think we should update the example's docstring.

Labels: Documentation
Doc Examples Bug: `plot_column_transformer_mixed_types`, missing categorical SimpleImputer

### Describe the issue linked to the documentation

The [`plot_column_transformer_mixed_types`](https://github.com/scikit-learn/scikit-learn/blob/582fa30a31ffd1d2afc6325ec3506418e35b88c2/examples/compose/plot_column_transformer_mixed_types.py) example says that it will use  a simpleimputer for the categorical pipeline:

https://github.com/scikit-learn/scikit-learn/blob/582fa30a31ffd1d2afc6325ec3506418e35b88c2/examples/compose/plot_column_transformer_mixed_types.py#L14-L16

But it actually doesn't:

https://github.com/scikit-learn/scikit-learn/blob/582fa30a31ffd1d2afc6325ec3506418e35b88c2/examples/compose/plot_column_transformer_mixed_types.py#L76



### Suggest a potential alternative/fix

I'll submit a PR adding the simpleimputer.

COMMENT:
Oh cool

Labels: Documentation
Doc Examples Bug: `plot_column_transformer_mixed_types`, missing categorical SimpleImputer

### Describe the issue linked to the documentation

The [`plot_column_transformer_mixed_types`](https://github.com/scikit-learn/scikit-learn/blob/582fa30a31ffd1d2afc6325ec3506418e35b88c2/examples/compose/plot_column_transformer_mixed_types.py) example says that it will use  a simpleimputer for the categorical pipeline:

https://github.com/scikit-learn/scikit-learn/blob/582fa30a31ffd1d2afc6325ec3506418e35b88c2/examples/compose/plot_column_transformer_mixed_types.py#L14-L16

But it actually doesn't:

https://github.com/scikit-learn/scikit-learn/blob/582fa30a31ffd1d2afc6325ec3506418e35b88c2/examples/compose/plot_column_transformer_mixed_types.py#L76



### Suggest a potential alternative/fix

I'll submit a PR adding the simpleimputer.

COMMENT:
Indeed, I see it now in https://github.com/scikit-learn/scikit-learn/blob/main/doc/modules/preprocessing.rst:

```
[:class:`OneHotEncoder`](https://github.com/scikit-learn/scikit-learn/blob/main/doc/modules/preprocessing.rst#id64) supports categorical features with missing values by considering the missing values as an additional category:

>>> X = [['male', 'Safari'],
...      ['female', None],
...      [np.nan, 'Firefox']]
>>> enc = preprocessing.OneHotEncoder(handle_unknown='error').fit(X)
>>> enc.categories_
[array(['female', 'male', nan], dtype=object),
 array(['Firefox', 'Safari', None], dtype=object)]
>>> enc.transform(X).toarray()
array([[0., 1., 0., 0., 1., 0.],
       [1., 0., 0., 0., 0., 1.],
       [0., 0., 1., 1., 0., 0.]])
If a feature contains both np.nan and None, they will be considered separate categories:

>>> X = [['Safari'], [None], [np.nan], ['Firefox']]
>>> enc = preprocessing.OneHotEncoder(handle_unknown='error').fit(X)
>>> enc.categories_
[array(['Firefox', 'Safari', None, nan], dtype=object)]
>>> enc.transform(X).toarray()
array([[0., 1., 0., 0.],
       [0., 0., 1., 0.],
       [0., 0., 0., 1.],
       [1., 0., 0., 0.]])
```

Labels: Documentation
GaussianMixture sample() ValueError on Models with 1 Component Fitted on <32 samples

### Describe the bug

If you fit a GaussianMixture model with one component on less than 32 samples, a ValueError is thrown when trying to generate a random sample from the model. If you use a model with more than one component, you are able to fit it on as low as two samples and still generate a random sample from the model. Likewise, no ValueError is thrown if you use 32 samples to fit a model with one component.

### Steps/Code to Reproduce

https://gist.github.com/luhlir/8db41552d086ecaa441bb534312bfeb4

### Expected Results

No error is thrown

### Actual Results

This is the ValueError produced

Traceback (most recent call last):
  File "gaussian_mixture_bug.py", line 17, in <module>
    print(c.sample())   # This will throw a ValueError
  File "./lib/python3.9/site-packages/sklearn/mixture/_base.py", line 438, in sample
    n_samples_comp = rng.multinomial(n_samples, self.weights_)
  File "mtrand.pyx", line 4249, in numpy.random.mtrand.RandomState.multinomial
  File "_common.pyx", line 376, in numpy.random._common.check_array_constraint
  File "_common.pyx", line 362, in numpy.random._common._check_array_cons_bounded_0_1
ValueError: pvals < 0, pvals > 1 or pvals contains NaNs

### Versions

```shell
System:
    python: 3.9.6 (v3.9.6:db3ff76da1, Jun 28 2021, 11:14:58)  [Clang 12.0.5 (clang-1205.0.22.9)]
   machine: macOS-12.2.1-x86_64-i386-64bit

Python dependencies:
          pip: 21.3.1
   setuptools: 57.0.0
      sklearn: 1.0.2
        numpy: 1.22.1
        scipy: 1.8.0
       Cython: None
       pandas: None
   matplotlib: None
       joblib: 1.1.0
threadpoolctl: 3.1.0

Built with OpenMP: True
```

COMMENT:
@luhlir Thank you for bringing this up and for providing a very nice minimal reproduction. I'm addressing this in #23034.

Labels: Bug, Needs Triage
LabelEncoder based on value_counts

### Describe the workflow you want to enable

sklearn.preprocessing.LabelEncoder sorts classes_ based on alphabet. Would be good to have the parameter mapping='value_counts' to sort the classes based on the number of appearences (normalized) in training sample.

If you give ok to the approach, happy to do a PR

### Describe your proposed solution
```py
>>> le = preprocessing.LabelEncoder(classes_sort='value_counts')
>>> le.fit(["paris", "paris", "tokyo", "amsterdam"])
LabelEncoder()
>>> list(le.classes_dict_)
{'paris': 0.5, 'tokyo': 0.25, amsterdam: 0.25}
>>> le.transform(["tokyo", "tokyo", "paris"])
array([0.25, 0.25, 0.5]...)
```
### Describe alternatives you've considered, if relevant
instead of the value_count, use the index for the mapper.
```py
le.classes_dict_
{'paris': 0, 'tokyo': 1, amsterdam: 1}
```
or impose different index 
```py
 le.fit(["paris", "paris", "tokyo", "amsterdam","barcelona","barcelona"]).classes_dict_
{paris: 0, barcelona: 1, tokyo: 2, amsterdam: 3}
```



### Additional context

_No response_

COMMENT:
To better understand your use case, can you describe a machine learning workflow where using the counts is useful compared to the current approach of lexicon ordering?

Labels: New Feature, module:preprocessing
LabelEncoder based on value_counts

### Describe the workflow you want to enable

sklearn.preprocessing.LabelEncoder sorts classes_ based on alphabet. Would be good to have the parameter mapping='value_counts' to sort the classes based on the number of appearences (normalized) in training sample.

If you give ok to the approach, happy to do a PR

### Describe your proposed solution
```py
>>> le = preprocessing.LabelEncoder(classes_sort='value_counts')
>>> le.fit(["paris", "paris", "tokyo", "amsterdam"])
LabelEncoder()
>>> list(le.classes_dict_)
{'paris': 0.5, 'tokyo': 0.25, amsterdam: 0.25}
>>> le.transform(["tokyo", "tokyo", "paris"])
array([0.25, 0.25, 0.5]...)
```
### Describe alternatives you've considered, if relevant
instead of the value_count, use the index for the mapper.
```py
le.classes_dict_
{'paris': 0, 'tokyo': 1, amsterdam: 1}
```
or impose different index 
```py
 le.fit(["paris", "paris", "tokyo", "amsterdam","barcelona","barcelona"]).classes_dict_
{paris: 0, barcelona: 1, tokyo: 2, amsterdam: 3}
```



### Additional context

_No response_

COMMENT:
well, indeed a even better approach would be to have 2 params, `values_sort:srt=lexicon|value_count|mapper` and `mapper:dict=None`

if values_sort='lexicon' then is using current approach (just to clarify that i don't want to deprecate current approach, just give more options for sorting and see what fits best)
if values_sort='value_count' then sorting approach define above in the ticket
if values_sort='mapper' then the sorting and the values are based on the dict given in `mapper`

about your question,
by construction, using value-count instead of lexicon would make more popular categories more close to popular ones, and less popular more close to less ones.
examples:
cities (in this case you could further improve passing distances as mapper, or creating 2 encoders, each one with coordinates)
first/last names

Labels: New Feature, module:preprocessing
LabelEncoder based on value_counts

### Describe the workflow you want to enable

sklearn.preprocessing.LabelEncoder sorts classes_ based on alphabet. Would be good to have the parameter mapping='value_counts' to sort the classes based on the number of appearences (normalized) in training sample.

If you give ok to the approach, happy to do a PR

### Describe your proposed solution
```py
>>> le = preprocessing.LabelEncoder(classes_sort='value_counts')
>>> le.fit(["paris", "paris", "tokyo", "amsterdam"])
LabelEncoder()
>>> list(le.classes_dict_)
{'paris': 0.5, 'tokyo': 0.25, amsterdam: 0.25}
>>> le.transform(["tokyo", "tokyo", "paris"])
array([0.25, 0.25, 0.5]...)
```
### Describe alternatives you've considered, if relevant
instead of the value_count, use the index for the mapper.
```py
le.classes_dict_
{'paris': 0, 'tokyo': 1, amsterdam: 1}
```
or impose different index 
```py
 le.fit(["paris", "paris", "tokyo", "amsterdam","barcelona","barcelona"]).classes_dict_
{paris: 0, barcelona: 1, tokyo: 2, amsterdam: 3}
```



### Additional context

_No response_

COMMENT:
`LabelEncoder` is used to encode the labels (`y`). Since you mentioned categories, I suspect this feature is more suited for `OrdinalEncoder`?

In any case, do you have a reference that demonstrates how using value count for sorting the encoding is useful in a machine learning model? Note that the reference should meet [scikit-learn's inclusion criteria](https://scikit-learn.org/dev/faq.html#what-are-the-inclusion-criteria-for-new-algorithms). Since every new feature has a maintenance cost, we aim to only include well-established techniques.

Labels: New Feature, module:preprocessing
LabelEncoder based on value_counts

### Describe the workflow you want to enable

sklearn.preprocessing.LabelEncoder sorts classes_ based on alphabet. Would be good to have the parameter mapping='value_counts' to sort the classes based on the number of appearences (normalized) in training sample.

If you give ok to the approach, happy to do a PR

### Describe your proposed solution
```py
>>> le = preprocessing.LabelEncoder(classes_sort='value_counts')
>>> le.fit(["paris", "paris", "tokyo", "amsterdam"])
LabelEncoder()
>>> list(le.classes_dict_)
{'paris': 0.5, 'tokyo': 0.25, amsterdam: 0.25}
>>> le.transform(["tokyo", "tokyo", "paris"])
array([0.25, 0.25, 0.5]...)
```
### Describe alternatives you've considered, if relevant
instead of the value_count, use the index for the mapper.
```py
le.classes_dict_
{'paris': 0, 'tokyo': 1, amsterdam: 1}
```
or impose different index 
```py
 le.fit(["paris", "paris", "tokyo", "amsterdam","barcelona","barcelona"]).classes_dict_
{paris: 0, barcelona: 1, tokyo: 2, amsterdam: 3}
```



### Additional context

_No response_

COMMENT:
yep, you're right, this feature is suited for `OrdinalEnconder` (`X`).

About references,
i found this kaggle repos [1](https://www.kaggle.com/code/bhavikapanara/frequency-encoding/notebook) and [2](https://www.kaggle.com/code/prashanththangavel/advanced-feature-engineering-feature-encoding/notebook)

and some results in the web [1](https://towardsdatascience.com/feature-engineering-deep-dive-into-encoding-and-binning-techniques-5618d55a6b38) and [2](https://www.geeksforgeeks.org/feature-encoding-techniques-machine-learning/)

but none of them seems to fit [scikit-learn's inclusion criteria](https://scikit-learn.org/dev/faq.html#what-are-the-inclusion-criteria-for-new-algorithms). How shall we proceed then?

Labels: New Feature, module:preprocessing
LabelEncoder based on value_counts

### Describe the workflow you want to enable

sklearn.preprocessing.LabelEncoder sorts classes_ based on alphabet. Would be good to have the parameter mapping='value_counts' to sort the classes based on the number of appearences (normalized) in training sample.

If you give ok to the approach, happy to do a PR

### Describe your proposed solution
```py
>>> le = preprocessing.LabelEncoder(classes_sort='value_counts')
>>> le.fit(["paris", "paris", "tokyo", "amsterdam"])
LabelEncoder()
>>> list(le.classes_dict_)
{'paris': 0.5, 'tokyo': 0.25, amsterdam: 0.25}
>>> le.transform(["tokyo", "tokyo", "paris"])
array([0.25, 0.25, 0.5]...)
```
### Describe alternatives you've considered, if relevant
instead of the value_count, use the index for the mapper.
```py
le.classes_dict_
{'paris': 0, 'tokyo': 1, amsterdam: 1}
```
or impose different index 
```py
 le.fit(["paris", "paris", "tokyo", "amsterdam","barcelona","barcelona"]).classes_dict_
{paris: 0, barcelona: 1, tokyo: 2, amsterdam: 3}
```



### Additional context

_No response_

COMMENT:
> How shall we proceed then?

Without a reference showing that the feature is a well-established technique, it would be hard to include into scikit-learn itself. The feature could fit in a scikit-learn-contrib project such as https://github.com/scikit-learn-contrib/category_encoders.

With that in mind, I am closing this issue. Thank you for the feature proposal.

Labels: New Feature, module:preprocessing
LabelEncoder based on value_counts

### Describe the workflow you want to enable

sklearn.preprocessing.LabelEncoder sorts classes_ based on alphabet. Would be good to have the parameter mapping='value_counts' to sort the classes based on the number of appearences (normalized) in training sample.

If you give ok to the approach, happy to do a PR

### Describe your proposed solution
```py
>>> le = preprocessing.LabelEncoder(classes_sort='value_counts')
>>> le.fit(["paris", "paris", "tokyo", "amsterdam"])
LabelEncoder()
>>> list(le.classes_dict_)
{'paris': 0.5, 'tokyo': 0.25, amsterdam: 0.25}
>>> le.transform(["tokyo", "tokyo", "paris"])
array([0.25, 0.25, 0.5]...)
```
### Describe alternatives you've considered, if relevant
instead of the value_count, use the index for the mapper.
```py
le.classes_dict_
{'paris': 0, 'tokyo': 1, amsterdam: 1}
```
or impose different index 
```py
 le.fit(["paris", "paris", "tokyo", "amsterdam","barcelona","barcelona"]).classes_dict_
{paris: 0, barcelona: 1, tokyo: 2, amsterdam: 3}
```



### Additional context

_No response_

COMMENT:
checking it, is already there `category_encoders.count.CountEncoder` [link](http://contrib.scikit-learn.org/category_encoders/count.html?highlight=countencoder#category_encoders.count.CountEncoder)

Labels: New Feature, module:preprocessing
DateEncoder

### Describe the workflow you want to enable

Would be cool to have a preprocessor that maps dates (str or unixtime) to its' respective date parts: dayofmonth, dayofweek, hour,etc.

There's any reason this is not included in sklearn?
In case not, I could do a PR

### Describe your proposed solution

>>> from sklearn import preprocessing
>>> de = preprocessing.DateEncoder(datepart=['month','hour'], cyclic=True)
>>> de.fit(['2022-04-01 17:17:09.175803', '2022-04-01 17:17:09.175803', '2022-04-01 17:17:09.175803'])
DateEncoder()
>>> de.datepart_
array(['month','hour'])
>>> de.transform(['2022-04-01 17:17:09.175803', '2022-01-01 18:17:09.175803', '2022-03-01 02:17:09.175803'])
array([ [cos(04/12), sin(04/12), cos(17/24), sin(17/24)],
[cos(01/12), sin(01/12), cos(18/24), sin(18/24)],
[cos(03/12), sin(03/12), cos(02/24), sin(02/24)]
)


### Describe alternatives you've considered, if relevant

_No response_

### Additional context

_No response_

COMMENT:
This is a duplicate of https://github.com/scikit-learn/scikit-learn/issues/21968
I am closing since the discussion should happen on this PR.
@iuiu34 do not hesitate to let a message on the original issue with an explanation of your potential use case.

Labels: New Feature, Needs Triage
Add Pre-fitted Model to `VotingClassifier`

### Describe the workflow you want to enable

Allow passing trained models to `VotingClassifier`, and use these trained models directly for prediction, without refitting.

The current `VotingClassifier` requires fitting all inputted estimators on the given training data, even if these estimators have already been trained. This is inconvenient if we want to create an ensemble classifier from estimators trained with different datasets (or with different partitions of the dataset).

### Describe your proposed solution

Maybe adding a new `prefit` parameter to `VotingClassifier`, allow the user to specify whether fitting is needed.

A similar solution has been implemented in #22215 for `StackingClassifier `and `StackingRegressor`

### Additional context
This workflow is also mentioned in #12297, as there seems to be no update, here I am requesting it as a new feature.

This feature can be implemented at the user-level, code from [stackoverflow, mors](https://stackoverflow.com/questions/42920148/using-sklearn-voting-ensemble-with-partial-fit)

```
from sklearn.ensemble import VotingClassifier
from sklearn.preprocessing import LabelEncoder

clf_list = [clf1, clf2, clf3]

eclf = VotingClassifier(estimators = [('1' ,clf1), ('2', clf2), ('3', clf3)], voting='soft')

eclf.estimators_ = clf_list
eclf.le_ = LabelEncoder().fit(y)
eclf.classes_ = seclf.le_.classes_

# Now it will work without calling fit
eclf.predict(X,y)
```

If this feature is approved, I can work on it.

COMMENT:
As you noted, there is already an open issue: https://github.com/scikit-learn/scikit-learn/issues/12297 for this feature.

As documented in the [triaging docs](https://scikit-learn.org/dev/developers/bug_triaging.html#triaging-operations-for-members-of-the-core-and-contributor-experience-teams), I am closing this issue because it is a duplicate of #12297. You are welcome to continue the discussion there.

Labels: New Feature, Needs Triage
test_ridge_regression_vstacked_X is not stable

https://dev.azure.com/scikit-learn/scikit-learn/_build/results?buildId=40346&view=logs&jobId=97641769-79fb-5590-9088-a30ce9b850b9&j=97641769-79fb-5590-9088-a30ce9b850b9&t=4745baa1-36b5-56c8-9a8e-6480742db1a6

introduced in #22910. 
@lorentzenchr was it tested on "all" random seeds ? (`SKLEARN_TESTS_GLOBAL_RANDOM_SEED=all`)

COMMENT:
> was it tested on "all" random seeds ?

Yes, locally on my machine.

Labels: module:linear_model, module:test-suite
test_ridge_regression_vstacked_X is not stable

https://dev.azure.com/scikit-learn/scikit-learn/_build/results?buildId=40346&view=logs&jobId=97641769-79fb-5590-9088-a30ce9b850b9&j=97641769-79fb-5590-9088-a30ce9b850b9&t=4745baa1-36b5-56c8-9a8e-6480742db1a6

introduced in #22910. 
@lorentzenchr was it tested on "all" random seeds ? (`SKLEARN_TESTS_GLOBAL_RANDOM_SEED=all`)

COMMENT:
`SKLEARN_TESTS_GLOBAL_RANDOM_SEED="all" pytest sklearn/linear_model/tests/test_ridge.py` now also has one failing test for me. I'll fix it.

Labels: module:linear_model, module:test-suite
test_ridge_regression_vstacked_X is not stable

https://dev.azure.com/scikit-learn/scikit-learn/_build/results?buildId=40346&view=logs&jobId=97641769-79fb-5590-9088-a30ce9b850b9&j=97641769-79fb-5590-9088-a30ce9b850b9&t=4745baa1-36b5-56c8-9a8e-6480742db1a6

introduced in #22910. 
@lorentzenchr was it tested on "all" random seeds ? (`SKLEARN_TESTS_GLOBAL_RANDOM_SEED=all`)

COMMENT:
But for me, it fails in `test_ridge_fit_intercept_sparse[94-False-lbfgs]`, on the Azure CI link, it fails in `test_ridge_regression_vstacked_X[wide-5-True-sag]`.

Labels: module:linear_model, module:test-suite
test_ridge_regression_vstacked_X is not stable

https://dev.azure.com/scikit-learn/scikit-learn/_build/results?buildId=40346&view=logs&jobId=97641769-79fb-5590-9088-a30ce9b850b9&j=97641769-79fb-5590-9088-a30ce9b850b9&t=4745baa1-36b5-56c8-9a8e-6480742db1a6

introduced in #22910. 
@lorentzenchr was it tested on "all" random seeds ? (`SKLEARN_TESTS_GLOBAL_RANDOM_SEED=all`)

COMMENT:
Really weird, I restarted the run and now it passes. I didn't find any anything non deterministic in test_ridge_regression_vstacked_X. Is it possible that Ridge(solver="sag") is not completely deterministic even on fixed random_state ?

Labels: module:linear_model, module:test-suite