Add files using upload-large-folder tool

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sklearn/datasets/descr/linnerud.rst

@@ -0,0 +1,24 @@
+.. _linnerrud_dataset:
+
+Linnerrud dataset
+-----------------
+
+**Data Set Characteristics:**
+
+:Number of Instances: 20
+:Number of Attributes: 3
+:Missing Attribute Values: None
+
+The Linnerud dataset is a multi-output regression dataset. It consists of three
+exercise (data) and three physiological (target) variables collected from
+twenty middle-aged men in a fitness club:
+
+- *physiological* - CSV containing 20 observations on 3 physiological variables:
+   Weight, Waist and Pulse.
+- *exercise* - CSV containing 20 observations on 3 exercise variables:
+   Chins, Situps and Jumps.
+
+.. dropdown:: References
+
+   * Tenenhaus, M. (1998). La regression PLS: theorie et pratique. Paris:
+     Editions Technic.

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sklearn/datasets/descr/olivetti_faces.rst

@@ -0,0 +1,44 @@
+.. _olivetti_faces_dataset:
+
+The Olivetti faces dataset
+--------------------------
+
+`This dataset contains a set of face images`_ taken between April 1992 and
+April 1994 at AT&T Laboratories Cambridge. The
+:func:`sklearn.datasets.fetch_olivetti_faces` function is the data
+fetching / caching function that downloads the data
+archive from AT&T.
+
+.. _This dataset contains a set of face images: https://cam-orl.co.uk/facedatabase.html
+
+As described on the original website:
+
+    There are ten different images of each of 40 distinct subjects. For some
+    subjects, the images were taken at different times, varying the lighting,
+    facial expressions (open / closed eyes, smiling / not smiling) and facial
+    details (glasses / no glasses). All the images were taken against a dark
+    homogeneous background with the subjects in an upright, frontal position
+    (with tolerance for some side movement).
+
+**Data Set Characteristics:**
+
+=================   =====================
+Classes                                40
+Samples total                         400
+Dimensionality                       4096
+Features            real, between 0 and 1
+=================   =====================
+
+The image is quantized to 256 grey levels and stored as unsigned 8-bit
+integers; the loader will convert these to floating point values on the
+interval [0, 1], which are easier to work with for many algorithms.
+
+The "target" for this database is an integer from 0 to 39 indicating the
+identity of the person pictured; however, with only 10 examples per class, this
+relatively small dataset is more interesting from an unsupervised or
+semi-supervised perspective.
+
+The original dataset consisted of 92 x 112, while the version available here
+consists of 64x64 images.
+
+When using these images, please give credit to AT&T Laboratories Cambridge.

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sklearn/datasets/descr/rcv1.rst

@@ -0,0 +1,72 @@
+.. _rcv1_dataset:
+
+RCV1 dataset
+------------
+
+Reuters Corpus Volume I (RCV1) is an archive of over 800,000 manually
+categorized newswire stories made available by Reuters, Ltd. for research
+purposes. The dataset is extensively described in [1]_.
+
+**Data Set Characteristics:**
+
+==============     =====================
+Classes                              103
+Samples total                     804414
+Dimensionality                     47236
+Features           real, between 0 and 1
+==============     =====================
+
+:func:`sklearn.datasets.fetch_rcv1` will load the following
+version: RCV1-v2, vectors, full sets, topics multilabels::
+
+    >>> from sklearn.datasets import fetch_rcv1
+    >>> rcv1 = fetch_rcv1()
+
+It returns a dictionary-like object, with the following attributes:
+
+``data``:
+The feature matrix is a scipy CSR sparse matrix, with 804414 samples and
+47236 features. Non-zero values contains cosine-normalized, log TF-IDF vectors.
+A nearly chronological split is proposed in [1]_: The first 23149 samples are
+the training set. The last 781265 samples are the testing set. This follows
+the official LYRL2004 chronological split. The array has 0.16% of non zero
+values::
+
+    >>> rcv1.data.shape
+    (804414, 47236)
+
+``target``:
+The target values are stored in a scipy CSR sparse matrix, with 804414 samples
+and 103 categories. Each sample has a value of 1 in its categories, and 0 in
+others. The array has 3.15% of non zero values::
+
+    >>> rcv1.target.shape
+    (804414, 103)
+
+``sample_id``:
+Each sample can be identified by its ID, ranging (with gaps) from 2286
+to 810596::
+
+    >>> rcv1.sample_id[:3]
+    array([2286, 2287, 2288], dtype=uint32)
+
+``target_names``:
+The target values are the topics of each sample. Each sample belongs to at
+least one topic, and to up to 17 topics. There are 103 topics, each
+represented by a string. Their corpus frequencies span five orders of
+magnitude, from 5 occurrences for 'GMIL', to 381327 for 'CCAT'::
+
+    >>> rcv1.target_names[:3].tolist()  # doctest: +SKIP
+    ['E11', 'ECAT', 'M11']
+
+The dataset will be downloaded from the `rcv1 homepage`_ if necessary.
+The compressed size is about 656 MB.
+
+.. _rcv1 homepage: http://jmlr.csail.mit.edu/papers/volume5/lewis04a/
+
+
+.. rubric:: References
+
+.. [1] Lewis, D. D., Yang, Y., Rose, T. G., & Li, F. (2004).
+       RCV1: A new benchmark collection for text categorization research.
+       The Journal of Machine Learning Research, 5, 361-397.

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sklearn/datasets/descr/species_distributions.rst

@@ -0,0 +1,40 @@
+.. _species_distribution_dataset:
+
+Species distribution dataset
+----------------------------
+
+This dataset represents the geographic distribution of two species in Central and
+South America. The two species are:
+
+- `"Bradypus variegatus" <http://www.iucnredlist.org/details/3038/0>`_ ,
+  the Brown-throated Sloth.
+
+- `"Microryzomys minutus" <http://www.iucnredlist.org/details/13408/0>`_ ,
+  also known as the Forest Small Rice Rat, a rodent that lives in Peru,
+  Colombia, Ecuador, Peru, and Venezuela.
+
+The dataset is not a typical dataset since a :class:`~sklearn.datasets.base.Bunch`
+containing the attributes `data` and `target` is not returned. Instead, we have
+information allowing to create a "density" map of the different species.
+
+The grid for the map can be built using the attributes `x_left_lower_corner`,
+`y_left_lower_corner`, `Nx`, `Ny` and `grid_size`, which respectively correspond
+to the x and y coordinates of the lower left corner of the grid, the number of
+points along the x- and y-axis and the size of the step on the grid.
+
+The density at each location of the grid is contained in the `coverage` attribute.
+
+Finally, the `train` and `test` attributes contain information regarding the location
+of a species at a specific location.
+
+The dataset is provided by Phillips et. al. (2006).
+
+.. rubric:: References
+
+* `"Maximum entropy modeling of species geographic distributions"
+  <http://rob.schapire.net/papers/ecolmod.pdf>`_ S. J. Phillips,
+  R. P. Anderson, R. E. Schapire - Ecological Modelling, 190:231-259, 2006.
+
+.. rubric:: Examples
+
+* :ref:`sphx_glr_auto_examples_applications_plot_species_distribution_modeling.py`

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sklearn/datasets/descr/twenty_newsgroups.rst

@@ -0,0 +1,248 @@
+.. _20newsgroups_dataset:
+
+The 20 newsgroups text dataset
+------------------------------
+
+The 20 newsgroups dataset comprises around 18000 newsgroups posts on
+20 topics split in two subsets: one for training (or development)
+and the other one for testing (or for performance evaluation). The split
+between the train and test set is based upon a messages posted before
+and after a specific date.
+
+This module contains two loaders. The first one,
+:func:`sklearn.datasets.fetch_20newsgroups`,
+returns a list of the raw texts that can be fed to text feature
+extractors such as :class:`~sklearn.feature_extraction.text.CountVectorizer`
+with custom parameters so as to extract feature vectors.
+The second one, :func:`sklearn.datasets.fetch_20newsgroups_vectorized`,
+returns ready-to-use features, i.e., it is not necessary to use a feature
+extractor.
+
+**Data Set Characteristics:**
+
+=================   ==========
+Classes                     20
+Samples total            18846
+Dimensionality               1
+Features                  text
+=================   ==========
+
+.. dropdown:: Usage
+
+  The :func:`sklearn.datasets.fetch_20newsgroups` function is a data
+  fetching / caching functions that downloads the data archive from
+  the original `20 newsgroups website <http://people.csail.mit.edu/jrennie/20Newsgroups/>`__,
+  extracts the archive contents
+  in the ``~/scikit_learn_data/20news_home`` folder and calls the
+  :func:`sklearn.datasets.load_files` on either the training or
+  testing set folder, or both of them::
+
+    >>> from sklearn.datasets import fetch_20newsgroups
+    >>> newsgroups_train = fetch_20newsgroups(subset='train')
+
+    >>> from pprint import pprint
+    >>> pprint(list(newsgroups_train.target_names))
+    ['alt.atheism',
+     'comp.graphics',
+     'comp.os.ms-windows.misc',
+     'comp.sys.ibm.pc.hardware',
+     'comp.sys.mac.hardware',
+     'comp.windows.x',
+     'misc.forsale',
+     'rec.autos',
+     'rec.motorcycles',
+     'rec.sport.baseball',
+     'rec.sport.hockey',
+     'sci.crypt',
+     'sci.electronics',
+     'sci.med',
+     'sci.space',
+     'soc.religion.christian',
+     'talk.politics.guns',
+     'talk.politics.mideast',
+     'talk.politics.misc',
+     'talk.religion.misc']
+
+  The real data lies in the ``filenames`` and ``target`` attributes. The target
+  attribute is the integer index of the category::
+
+    >>> newsgroups_train.filenames.shape
+    (11314,)
+    >>> newsgroups_train.target.shape
+    (11314,)
+    >>> newsgroups_train.target[:10]
+    array([ 7,  4,  4,  1, 14, 16, 13,  3,  2,  4])
+
+  It is possible to load only a sub-selection of the categories by passing the
+  list of the categories to load to the
+  :func:`sklearn.datasets.fetch_20newsgroups` function::
+
+    >>> cats = ['alt.atheism', 'sci.space']
+    >>> newsgroups_train = fetch_20newsgroups(subset='train', categories=cats)
+
+    >>> list(newsgroups_train.target_names)
+    ['alt.atheism', 'sci.space']
+    >>> newsgroups_train.filenames.shape
+    (1073,)
+    >>> newsgroups_train.target.shape
+    (1073,)
+    >>> newsgroups_train.target[:10]
+    array([0, 1, 1, 1, 0, 1, 1, 0, 0, 0])
+
+.. dropdown:: Converting text to vectors
+
+  In order to feed predictive or clustering models with the text data,
+  one first need to turn the text into vectors of numerical values suitable
+  for statistical analysis. This can be achieved with the utilities of the
+  ``sklearn.feature_extraction.text`` as demonstrated in the following
+  example that extract `TF-IDF <https://en.wikipedia.org/wiki/Tf-idf>`__ vectors
+  of unigram tokens from a subset of 20news::
+
+    >>> from sklearn.feature_extraction.text import TfidfVectorizer
+    >>> categories = ['alt.atheism', 'talk.religion.misc',
+    ...               'comp.graphics', 'sci.space']
+    >>> newsgroups_train = fetch_20newsgroups(subset='train',
+    ...                                       categories=categories)
+    >>> vectorizer = TfidfVectorizer()
+    >>> vectors = vectorizer.fit_transform(newsgroups_train.data)
+    >>> vectors.shape
+    (2034, 34118)
+
+  The extracted TF-IDF vectors are very sparse, with an average of 159 non-zero
+  components by sample in a more than 30000-dimensional space
+  (less than .5% non-zero features)::
+
+    >>> vectors.nnz / float(vectors.shape[0])
+    159.01327...
+
+  :func:`sklearn.datasets.fetch_20newsgroups_vectorized` is a function which
+  returns ready-to-use token counts features instead of file names.
+
+.. dropdown:: Filtering text for more realistic training
+
+  It is easy for a classifier to overfit on particular things that appear in the
+  20 Newsgroups data, such as newsgroup headers. Many classifiers achieve very
+  high F-scores, but their results would not generalize to other documents that
+  aren't from this window of time.
+
+  For example, let's look at the results of a multinomial Naive Bayes classifier,
+  which is fast to train and achieves a decent F-score::
+
+    >>> from sklearn.naive_bayes import MultinomialNB
+    >>> from sklearn import metrics
+    >>> newsgroups_test = fetch_20newsgroups(subset='test',
+    ...                                      categories=categories)
+    >>> vectors_test = vectorizer.transform(newsgroups_test.data)
+    >>> clf = MultinomialNB(alpha=.01)
+    >>> clf.fit(vectors, newsgroups_train.target)
+    MultinomialNB(alpha=0.01, class_prior=None, fit_prior=True)
+
+    >>> pred = clf.predict(vectors_test)
+    >>> metrics.f1_score(newsgroups_test.target, pred, average='macro')
+    0.88213...
+
+  (The example :ref:`sphx_glr_auto_examples_text_plot_document_classification_20newsgroups.py` shuffles
+  the training and test data, instead of segmenting by time, and in that case
+  multinomial Naive Bayes gets a much higher F-score of 0.88. Are you suspicious
+  yet of what's going on inside this classifier?)
+
+  Let's take a look at what the most informative features are:
+
+    >>> import numpy as np
+    >>> def show_top10(classifier, vectorizer, categories):
+    ...     feature_names = vectorizer.get_feature_names_out()
+    ...     for i, category in enumerate(categories):
+    ...         top10 = np.argsort(classifier.coef_[i])[-10:]
+    ...         print("%s: %s" % (category, " ".join(feature_names[top10])))
+    ...
+    >>> show_top10(clf, vectorizer, newsgroups_train.target_names)
+    alt.atheism: edu it and in you that is of to the
+    comp.graphics: edu in graphics it is for and of to the
+    sci.space: edu it that is in and space to of the
+    talk.religion.misc: not it you in is that and to of the
+
+
+  You can now see many things that these features have overfit to:
+
+  - Almost every group is distinguished by whether headers such as
+    ``NNTP-Posting-Host:`` and ``Distribution:`` appear more or less often.
+  - Another significant feature involves whether the sender is affiliated with
+    a university, as indicated either by their headers or their signature.
+  - The word "article" is a significant feature, based on how often people quote
+    previous posts like this: "In article [article ID], [name] <[e-mail address]>
+    wrote:"
+  - Other features match the names and e-mail addresses of particular people who
+    were posting at the time.
+
+  With such an abundance of clues that distinguish newsgroups, the classifiers
+  barely have to identify topics from text at all, and they all perform at the
+  same high level.
+
+  For this reason, the functions that load 20 Newsgroups data provide a
+  parameter called **remove**, telling it what kinds of information to strip out
+  of each file. **remove** should be a tuple containing any subset of
+  ``('headers', 'footers', 'quotes')``, telling it to remove headers, signature
+  blocks, and quotation blocks respectively.
+
+    >>> newsgroups_test = fetch_20newsgroups(subset='test',
+    ...                                      remove=('headers', 'footers', 'quotes'),
+    ...                                      categories=categories)
+    >>> vectors_test = vectorizer.transform(newsgroups_test.data)
+    >>> pred = clf.predict(vectors_test)
+    >>> metrics.f1_score(pred, newsgroups_test.target, average='macro')
+    0.77310...
+
+  This classifier lost over a lot of its F-score, just because we removed
+  metadata that has little to do with topic classification.
+  It loses even more if we also strip this metadata from the training data:
+
+    >>> newsgroups_train = fetch_20newsgroups(subset='train',
+    ...                                       remove=('headers', 'footers', 'quotes'),
+    ...                                       categories=categories)
+    >>> vectors = vectorizer.fit_transform(newsgroups_train.data)
+    >>> clf = MultinomialNB(alpha=.01)
+    >>> clf.fit(vectors, newsgroups_train.target)
+    MultinomialNB(alpha=0.01, class_prior=None, fit_prior=True)
+
+    >>> vectors_test = vectorizer.transform(newsgroups_test.data)
+    >>> pred = clf.predict(vectors_test)
+    >>> metrics.f1_score(newsgroups_test.target, pred, average='macro')
+    0.76995...
+
+  Some other classifiers cope better with this harder version of the task. Try the
+  :ref:`sphx_glr_auto_examples_model_selection_plot_grid_search_text_feature_extraction.py`
+  example with and without the `remove` option to compare the results.
+
+.. rubric:: Data Considerations
+
+The Cleveland Indians is a major league baseball team based in Cleveland,
+Ohio, USA. In December 2020, it was reported that "After several months of
+discussion sparked by the death of George Floyd and a national reckoning over
+race and colonialism, the Cleveland Indians have decided to change their
+name." Team owner Paul Dolan "did make it clear that the team will not make
+its informal nickname -- the Tribe -- its new team name." "It's not going to
+be a half-step away from the Indians," Dolan said."We will not have a Native
+American-themed name."
+
+https://www.mlb.com/news/cleveland-indians-team-name-change
+
+.. rubric:: Recommendation
+
+- When evaluating text classifiers on the 20 Newsgroups data, you
+  should strip newsgroup-related metadata. In scikit-learn, you can do this
+  by setting ``remove=('headers', 'footers', 'quotes')``. The F-score will be
+  lower because it is more realistic.
+- This text dataset contains data which may be inappropriate for certain NLP
+  applications. An example is listed in the "Data Considerations" section
+  above. The challenge with using current text datasets in NLP for tasks such
+  as sentence completion, clustering, and other applications is that text
+  that is culturally biased and inflammatory will propagate biases. This
+  should be taken into consideration when using the dataset, reviewing the
+  output, and the bias should be documented.
+
+.. rubric:: Examples
+
+* :ref:`sphx_glr_auto_examples_model_selection_plot_grid_search_text_feature_extraction.py`
+* :ref:`sphx_glr_auto_examples_text_plot_document_classification_20newsgroups.py`
+* :ref:`sphx_glr_auto_examples_text_plot_hashing_vs_dict_vectorizer.py`
+* :ref:`sphx_glr_auto_examples_text_plot_document_clustering.py`

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sklearn/datasets/descr/wine_data.rst

@@ -0,0 +1,94 @@
+.. _wine_dataset:
+
+Wine recognition dataset
+------------------------
+
+**Data Set Characteristics:**
+
+:Number of Instances: 178
+:Number of Attributes: 13 numeric, predictive attributes and the class
+:Attribute Information:
+    - Alcohol
+    - Malic acid
+    - Ash
+    - Alcalinity of ash
+    - Magnesium
+    - Total phenols
+    - Flavanoids
+    - Nonflavanoid phenols
+    - Proanthocyanins
+    - Color intensity
+    - Hue
+    - OD280/OD315 of diluted wines
+    - Proline
+    - class:
+        - class_0
+        - class_1
+        - class_2
+
+:Summary Statistics:
+
+============================= ==== ===== ======= =====
+                                Min   Max   Mean     SD
+============================= ==== ===== ======= =====
+Alcohol:                      11.0  14.8    13.0   0.8
+Malic Acid:                   0.74  5.80    2.34  1.12
+Ash:                          1.36  3.23    2.36  0.27
+Alcalinity of Ash:            10.6  30.0    19.5   3.3
+Magnesium:                    70.0 162.0    99.7  14.3
+Total Phenols:                0.98  3.88    2.29  0.63
+Flavanoids:                   0.34  5.08    2.03  1.00
+Nonflavanoid Phenols:         0.13  0.66    0.36  0.12
+Proanthocyanins:              0.41  3.58    1.59  0.57
+Colour Intensity:              1.3  13.0     5.1   2.3
+Hue:                          0.48  1.71    0.96  0.23
+OD280/OD315 of diluted wines: 1.27  4.00    2.61  0.71
+Proline:                       278  1680     746   315
+============================= ==== ===== ======= =====
+
+:Missing Attribute Values: None
+:Class Distribution: class_0 (59), class_1 (71), class_2 (48)
+:Creator: R.A. Fisher
+:Donor: Michael Marshall (MARSHALL%PLU@io.arc.nasa.gov)
+:Date: July, 1988
+
+This is a copy of UCI ML Wine recognition datasets.
+https://archive.ics.uci.edu/ml/machine-learning-databases/wine/wine.data
+
+The data is the results of a chemical analysis of wines grown in the same
+region in Italy by three different cultivators. There are thirteen different
+measurements taken for different constituents found in the three types of
+wine.
+
+Original Owners:
+
+Forina, M. et al, PARVUS -
+An Extendible Package for Data Exploration, Classification and Correlation.
+Institute of Pharmaceutical and Food Analysis and Technologies,
+Via Brigata Salerno, 16147 Genoa, Italy.
+
+Citation:
+
+Lichman, M. (2013). UCI Machine Learning Repository
+[https://archive.ics.uci.edu/ml]. Irvine, CA: University of California,
+School of Information and Computer Science.
+
+.. dropdown:: References
+
+    (1) S. Aeberhard, D. Coomans and O. de Vel,
+    Comparison of Classifiers in High Dimensional Settings,
+    Tech. Rep. no. 92-02, (1992), Dept. of Computer Science and Dept. of
+    Mathematics and Statistics, James Cook University of North Queensland.
+    (Also submitted to Technometrics).
+
+    The data was used with many others for comparing various
+    classifiers. The classes are separable, though only RDA
+    has achieved 100% correct classification.
+    (RDA : 100%, QDA 99.4%, LDA 98.9%, 1NN 96.1% (z-transformed data))
+    (All results using the leave-one-out technique)
+
+    (2) S. Aeberhard, D. Coomans and O. de Vel,
+    "THE CLASSIFICATION PERFORMANCE OF RDA"
+    Tech. Rep. no. 92-01, (1992), Dept. of Computer Science and Dept. of
+    Mathematics and Statistics, James Cook University of North Queensland.
+    (Also submitted to Journal of Chemometrics).

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sklearn/datasets/images/README.txt

@@ -0,0 +1,18 @@
+Image: china.jpg
+Released under a creative commons license. [1]
+Attribution: Some rights reserved by danielbuechele [2]
+Retrieved 21st August, 2011 from [3] by Robert Layton
+
+[1] https://creativecommons.org/licenses/by/2.0/
+[2] https://www.flickr.com/photos/danielbuechele/
+[3] https://www.flickr.com/photos/danielbuechele/6061409035/sizes/z/in/photostream/
+
+
+Image: flower.jpg
+Released under a creative commons license. [1]
+Attribution: Some rights reserved by danielbuechele [2]
+Retrieved 21st August, 2011 from [3] by Robert Layton
+
+[1] https://creativecommons.org/licenses/by/2.0/
+[2] https://www.flickr.com/photos/vultilion/
+[3] https://www.flickr.com/photos/vultilion/6056698931/sizes/z/in/photostream/

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sklearn/datasets/images/__init__.py

@@ -0,0 +1,2 @@
+# Authors: The scikit-learn developers
+# SPDX-License-Identifier: BSD-3-Clause

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sklearn/datasets/tests/data/svmlight_classification.txt

@@ -0,0 +1,9 @@
+# comment
+# note: the next line contains a tab
+1.0 3:2.5 	   11:-5.2 16:1.5 # and an inline comment
+2.0 6:1.0 13:-3
+# another comment
+3.0 21:27
+4.0 2:1.234567890123456e10 # double precision value
+1.0     # empty line, all zeros
+2.0 3:0 # explicit zeros

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sklearn/datasets/tests/data/svmlight_invalid.txt

@@ -0,0 +1,3 @@
+python 2:2.5 10:-5.2 15:1.5
+2.0 5:1.0 12:-3
+3.0 20:27

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sklearn/datasets/tests/data/svmlight_invalid_order.txt

@@ -0,0 +1 @@
+-1 5:2.5 2:-5.2 15:1.5

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sklearn/datasets/tests/data/svmlight_multilabel.txt

@@ -0,0 +1,5 @@
+# multilabel dataset in SVMlight format
+1,0 2:2.5   10:-5.2 15:1.5
+2 5:1.0 12:-3
+ 2:3.5 11:26
+1,2 20:27

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sklearn/datasets/tests/test_20news.py

@@ -0,0 +1,143 @@
+"""Test the 20news downloader, if the data is available,
+or if specifically requested via environment variable
+(e.g. for CI jobs)."""
+
+from functools import partial
+from unittest.mock import patch
+
+import numpy as np
+import pytest
+import scipy.sparse as sp
+
+from sklearn.datasets.tests.test_common import (
+    check_as_frame,
+    check_pandas_dependency_message,
+    check_return_X_y,
+)
+from sklearn.preprocessing import normalize
+from sklearn.utils._testing import assert_allclose_dense_sparse
+
+
+def test_20news(fetch_20newsgroups_fxt):
+    data = fetch_20newsgroups_fxt(subset="all", shuffle=False)
+    assert data.DESCR.startswith(".. _20newsgroups_dataset:")
+
+    # Extract a reduced dataset
+    data2cats = fetch_20newsgroups_fxt(
+        subset="all", categories=data.target_names[-1:-3:-1], shuffle=False
+    )
+    # Check that the ordering of the target_names is the same
+    # as the ordering in the full dataset
+    assert data2cats.target_names == data.target_names[-2:]
+    # Assert that we have only 0 and 1 as labels
+    assert np.unique(data2cats.target).tolist() == [0, 1]
+
+    # Check that the number of filenames is consistent with data/target
+    assert len(data2cats.filenames) == len(data2cats.target)
+    assert len(data2cats.filenames) == len(data2cats.data)
+
+    # Check that the first entry of the reduced dataset corresponds to
+    # the first entry of the corresponding category in the full dataset
+    entry1 = data2cats.data[0]
+    category = data2cats.target_names[data2cats.target[0]]
+    label = data.target_names.index(category)
+    entry2 = data.data[np.where(data.target == label)[0][0]]
+    assert entry1 == entry2
+
+    # check that return_X_y option
+    X, y = fetch_20newsgroups_fxt(subset="all", shuffle=False, return_X_y=True)
+    assert len(X) == len(data.data)
+    assert y.shape == data.target.shape
+
+
+def test_20news_length_consistency(fetch_20newsgroups_fxt):
+    """Checks the length consistencies within the bunch
+
+    This is a non-regression test for a bug present in 0.16.1.
+    """
+    # Extract the full dataset
+    data = fetch_20newsgroups_fxt(subset="all")
+    assert len(data["data"]) == len(data.data)
+    assert len(data["target"]) == len(data.target)
+    assert len(data["filenames"]) == len(data.filenames)
+
+
+def test_20news_vectorized(fetch_20newsgroups_vectorized_fxt):
+    # test subset = train
+    bunch = fetch_20newsgroups_vectorized_fxt(subset="train")
+    assert sp.issparse(bunch.data) and bunch.data.format == "csr"
+    assert bunch.data.shape == (11314, 130107)
+    assert bunch.target.shape[0] == 11314
+    assert bunch.data.dtype == np.float64
+    assert bunch.DESCR.startswith(".. _20newsgroups_dataset:")
+
+    # test subset = test
+    bunch = fetch_20newsgroups_vectorized_fxt(subset="test")
+    assert sp.issparse(bunch.data) and bunch.data.format == "csr"
+    assert bunch.data.shape == (7532, 130107)
+    assert bunch.target.shape[0] == 7532
+    assert bunch.data.dtype == np.float64
+    assert bunch.DESCR.startswith(".. _20newsgroups_dataset:")
+
+    # test return_X_y option
+    fetch_func = partial(fetch_20newsgroups_vectorized_fxt, subset="test")
+    check_return_X_y(bunch, fetch_func)
+
+    # test subset = all
+    bunch = fetch_20newsgroups_vectorized_fxt(subset="all")
+    assert sp.issparse(bunch.data) and bunch.data.format == "csr"
+    assert bunch.data.shape == (11314 + 7532, 130107)
+    assert bunch.target.shape[0] == 11314 + 7532
+    assert bunch.data.dtype == np.float64
+    assert bunch.DESCR.startswith(".. _20newsgroups_dataset:")
+
+
+def test_20news_normalization(fetch_20newsgroups_vectorized_fxt):
+    X = fetch_20newsgroups_vectorized_fxt(normalize=False)
+    X_ = fetch_20newsgroups_vectorized_fxt(normalize=True)
+    X_norm = X_["data"][:100]
+    X = X["data"][:100]
+
+    assert_allclose_dense_sparse(X_norm, normalize(X))
+    assert np.allclose(np.linalg.norm(X_norm.todense(), axis=1), 1)
+
+
+def test_20news_as_frame(fetch_20newsgroups_vectorized_fxt):
+    pd = pytest.importorskip("pandas")
+
+    bunch = fetch_20newsgroups_vectorized_fxt(as_frame=True)
+    check_as_frame(bunch, fetch_20newsgroups_vectorized_fxt)
+
+    frame = bunch.frame
+    assert frame.shape == (11314, 130108)
+    assert all([isinstance(col, pd.SparseDtype) for col in bunch.data.dtypes])
+
+    # Check a small subset of features
+    for expected_feature in [
+        "beginner",
+        "beginners",
+        "beginning",
+        "beginnings",
+        "begins",
+        "begley",
+        "begone",
+    ]:
+        assert expected_feature in frame.keys()
+    assert "category_class" in frame.keys()
+    assert bunch.target.name == "category_class"
+
+
+def test_as_frame_no_pandas(fetch_20newsgroups_vectorized_fxt, hide_available_pandas):
+    check_pandas_dependency_message(fetch_20newsgroups_vectorized_fxt)
+
+
+def test_outdated_pickle(fetch_20newsgroups_vectorized_fxt):
+    with patch("os.path.exists") as mock_is_exist:
+        with patch("joblib.load") as mock_load:
+            # mock that the dataset was cached
+            mock_is_exist.return_value = True
+            # mock that we have an outdated pickle with only X and y returned
+            mock_load.return_value = ("X", "y")
+            err_msg = "The cached dataset located in"
+            with pytest.raises(ValueError, match=err_msg):
+                fetch_20newsgroups_vectorized_fxt(as_frame=True)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sklearn/datasets/tests/test_arff_parser.py

@@ -0,0 +1,284 @@
+import textwrap
+from io import BytesIO
+
+import pytest
+
+from sklearn.datasets._arff_parser import (
+    _liac_arff_parser,
+    _pandas_arff_parser,
+    _post_process_frame,
+    load_arff_from_gzip_file,
+)
+
+
+@pytest.mark.parametrize(
+    "feature_names, target_names",
+    [
+        (
+            [
+                "col_int_as_integer",
+                "col_int_as_numeric",
+                "col_float_as_real",
+                "col_float_as_numeric",
+            ],
+            ["col_categorical", "col_string"],
+        ),
+        (
+            [
+                "col_int_as_integer",
+                "col_int_as_numeric",
+                "col_float_as_real",
+                "col_float_as_numeric",
+            ],
+            ["col_categorical"],
+        ),
+        (
+            [
+                "col_int_as_integer",
+                "col_int_as_numeric",
+                "col_float_as_real",
+                "col_float_as_numeric",
+            ],
+            [],
+        ),
+    ],
+)
+def test_post_process_frame(feature_names, target_names):
+    """Check the behaviour of the post-processing function for splitting a dataframe."""
+    pd = pytest.importorskip("pandas")
+
+    X_original = pd.DataFrame(
+        {
+            "col_int_as_integer": [1, 2, 3],
+            "col_int_as_numeric": [1, 2, 3],
+            "col_float_as_real": [1.0, 2.0, 3.0],
+            "col_float_as_numeric": [1.0, 2.0, 3.0],
+            "col_categorical": ["a", "b", "c"],
+            "col_string": ["a", "b", "c"],
+        }
+    )
+
+    X, y = _post_process_frame(X_original, feature_names, target_names)
+    assert isinstance(X, pd.DataFrame)
+    if len(target_names) >= 2:
+        assert isinstance(y, pd.DataFrame)
+    elif len(target_names) == 1:
+        assert isinstance(y, pd.Series)
+    else:
+        assert y is None
+
+
+def test_load_arff_from_gzip_file_error_parser():
+    """An error will be raised if the parser is not known."""
+    # None of the input parameters are required to be accurate since the check
+    # of the parser will be carried out first.
+
+    err_msg = "Unknown parser: 'xxx'. Should be 'liac-arff' or 'pandas'"
+    with pytest.raises(ValueError, match=err_msg):
+        load_arff_from_gzip_file("xxx", "xxx", "xxx", "xxx", "xxx", "xxx")
+
+
+@pytest.mark.parametrize("parser_func", [_liac_arff_parser, _pandas_arff_parser])
+def test_pandas_arff_parser_strip_single_quotes(parser_func):
+    """Check that we properly strip single quotes from the data."""
+    pd = pytest.importorskip("pandas")
+
+    arff_file = BytesIO(
+        textwrap.dedent(
+            """
+            @relation 'toy'
+            @attribute 'cat_single_quote' {'A', 'B', 'C'}
+            @attribute 'str_single_quote' string
+            @attribute 'str_nested_quote' string
+            @attribute 'class' numeric
+            @data
+            'A','some text','\"expect double quotes\"',0
+            """
+        ).encode("utf-8")
+    )
+
+    columns_info = {
+        "cat_single_quote": {
+            "data_type": "nominal",
+            "name": "cat_single_quote",
+        },
+        "str_single_quote": {
+            "data_type": "string",
+            "name": "str_single_quote",
+        },
+        "str_nested_quote": {
+            "data_type": "string",
+            "name": "str_nested_quote",
+        },
+        "class": {
+            "data_type": "numeric",
+            "name": "class",
+        },
+    }
+
+    feature_names = [
+        "cat_single_quote",
+        "str_single_quote",
+        "str_nested_quote",
+    ]
+    target_names = ["class"]
+
+    # We don't strip single quotes for string columns with the pandas parser.
+    expected_values = {
+        "cat_single_quote": "A",
+        "str_single_quote": (
+            "some text" if parser_func is _liac_arff_parser else "'some text'"
+        ),
+        "str_nested_quote": (
+            '"expect double quotes"'
+            if parser_func is _liac_arff_parser
+            else "'\"expect double quotes\"'"
+        ),
+        "class": 0,
+    }
+
+    _, _, frame, _ = parser_func(
+        arff_file,
+        output_arrays_type="pandas",
+        openml_columns_info=columns_info,
+        feature_names_to_select=feature_names,
+        target_names_to_select=target_names,
+    )
+
+    assert frame.columns.tolist() == feature_names + target_names
+    pd.testing.assert_series_equal(frame.iloc[0], pd.Series(expected_values, name=0))
+
+
+@pytest.mark.parametrize("parser_func", [_liac_arff_parser, _pandas_arff_parser])
+def test_pandas_arff_parser_strip_double_quotes(parser_func):
+    """Check that we properly strip double quotes from the data."""
+    pd = pytest.importorskip("pandas")
+
+    arff_file = BytesIO(
+        textwrap.dedent(
+            """
+            @relation 'toy'
+            @attribute 'cat_double_quote' {"A", "B", "C"}
+            @attribute 'str_double_quote' string
+            @attribute 'str_nested_quote' string
+            @attribute 'class' numeric
+            @data
+            "A","some text","\'expect double quotes\'",0
+            """
+        ).encode("utf-8")
+    )
+
+    columns_info = {
+        "cat_double_quote": {
+            "data_type": "nominal",
+            "name": "cat_double_quote",
+        },
+        "str_double_quote": {
+            "data_type": "string",
+            "name": "str_double_quote",
+        },
+        "str_nested_quote": {
+            "data_type": "string",
+            "name": "str_nested_quote",
+        },
+        "class": {
+            "data_type": "numeric",
+            "name": "class",
+        },
+    }
+
+    feature_names = [
+        "cat_double_quote",
+        "str_double_quote",
+        "str_nested_quote",
+    ]
+    target_names = ["class"]
+
+    expected_values = {
+        "cat_double_quote": "A",
+        "str_double_quote": "some text",
+        "str_nested_quote": "'expect double quotes'",
+        "class": 0,
+    }
+
+    _, _, frame, _ = parser_func(
+        arff_file,
+        output_arrays_type="pandas",
+        openml_columns_info=columns_info,
+        feature_names_to_select=feature_names,
+        target_names_to_select=target_names,
+    )
+
+    assert frame.columns.tolist() == feature_names + target_names
+    pd.testing.assert_series_equal(frame.iloc[0], pd.Series(expected_values, name=0))
+
+
+@pytest.mark.parametrize(
+    "parser_func",
+    [
+        # internal quotes are not considered to follow the ARFF spec in LIAC ARFF
+        pytest.param(_liac_arff_parser, marks=pytest.mark.xfail),
+        _pandas_arff_parser,
+    ],
+)
+def test_pandas_arff_parser_strip_no_quotes(parser_func):
+    """Check that we properly parse with no quotes characters."""
+    pd = pytest.importorskip("pandas")
+
+    arff_file = BytesIO(
+        textwrap.dedent(
+            """
+            @relation 'toy'
+            @attribute 'cat_without_quote' {A, B, C}
+            @attribute 'str_without_quote' string
+            @attribute 'str_internal_quote' string
+            @attribute 'class' numeric
+            @data
+            A,some text,'internal' quote,0
+            """
+        ).encode("utf-8")
+    )
+
+    columns_info = {
+        "cat_without_quote": {
+            "data_type": "nominal",
+            "name": "cat_without_quote",
+        },
+        "str_without_quote": {
+            "data_type": "string",
+            "name": "str_without_quote",
+        },
+        "str_internal_quote": {
+            "data_type": "string",
+            "name": "str_internal_quote",
+        },
+        "class": {
+            "data_type": "numeric",
+            "name": "class",
+        },
+    }
+
+    feature_names = [
+        "cat_without_quote",
+        "str_without_quote",
+        "str_internal_quote",
+    ]
+    target_names = ["class"]
+
+    expected_values = {
+        "cat_without_quote": "A",
+        "str_without_quote": "some text",
+        "str_internal_quote": "'internal' quote",
+        "class": 0,
+    }
+
+    _, _, frame, _ = parser_func(
+        arff_file,
+        output_arrays_type="pandas",
+        openml_columns_info=columns_info,
+        feature_names_to_select=feature_names,
+        target_names_to_select=target_names,
+    )
+
+    assert frame.columns.tolist() == feature_names + target_names
+    pd.testing.assert_series_equal(frame.iloc[0], pd.Series(expected_values, name=0))

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sklearn/datasets/tests/test_base.py

@@ -0,0 +1,658 @@
+import hashlib
+import io
+import os
+import re
+import shutil
+import tempfile
+import warnings
+from functools import partial
+from importlib import resources
+from pathlib import Path
+from pickle import dumps, loads
+from unittest.mock import Mock
+from urllib.error import HTTPError
+from urllib.parse import urlparse
+
+import numpy as np
+import pytest
+
+from sklearn.datasets import (
+    clear_data_home,
+    fetch_file,
+    get_data_home,
+    load_breast_cancer,
+    load_diabetes,
+    load_digits,
+    load_files,
+    load_iris,
+    load_linnerud,
+    load_sample_image,
+    load_sample_images,
+    load_wine,
+)
+from sklearn.datasets._base import (
+    RemoteFileMetadata,
+    _derive_folder_and_filename_from_url,
+    _fetch_remote,
+    load_csv_data,
+    load_gzip_compressed_csv_data,
+)
+from sklearn.datasets.tests.test_common import check_as_frame
+from sklearn.preprocessing import scale
+from sklearn.utils import Bunch
+
+
+class _DummyPath:
+    """Minimal class that implements the os.PathLike interface."""
+
+    def __init__(self, path):
+        self.path = path
+
+    def __fspath__(self):
+        return self.path
+
+
+def _remove_dir(path):
+    if os.path.isdir(path):
+        shutil.rmtree(path)
+
+
+@pytest.fixture(scope="module")
+def data_home(tmpdir_factory):
+    tmp_file = str(tmpdir_factory.mktemp("scikit_learn_data_home_test"))
+    yield tmp_file
+    _remove_dir(tmp_file)
+
+
+@pytest.fixture(scope="module")
+def load_files_root(tmpdir_factory):
+    tmp_file = str(tmpdir_factory.mktemp("scikit_learn_load_files_test"))
+    yield tmp_file
+    _remove_dir(tmp_file)
+
+
+@pytest.fixture
+def test_category_dir_1(load_files_root):
+    test_category_dir1 = tempfile.mkdtemp(dir=load_files_root)
+    sample_file = tempfile.NamedTemporaryFile(dir=test_category_dir1, delete=False)
+    sample_file.write(b"Hello World!\n")
+    sample_file.close()
+    yield str(test_category_dir1)
+    _remove_dir(test_category_dir1)
+
+
+@pytest.fixture
+def test_category_dir_2(load_files_root):
+    test_category_dir2 = tempfile.mkdtemp(dir=load_files_root)
+    yield str(test_category_dir2)
+    _remove_dir(test_category_dir2)
+
+
+@pytest.mark.parametrize("path_container", [None, Path, _DummyPath])
+def test_data_home(path_container, data_home):
+    # get_data_home will point to a pre-existing folder
+    if path_container is not None:
+        data_home = path_container(data_home)
+    data_home = get_data_home(data_home=data_home)
+    assert data_home == data_home
+    assert os.path.exists(data_home)
+
+    # clear_data_home will delete both the content and the folder it-self
+    if path_container is not None:
+        data_home = path_container(data_home)
+    clear_data_home(data_home=data_home)
+    assert not os.path.exists(data_home)
+
+    # if the folder is missing it will be created again
+    data_home = get_data_home(data_home=data_home)
+    assert os.path.exists(data_home)
+
+
+def test_default_empty_load_files(load_files_root):
+    res = load_files(load_files_root)
+    assert len(res.filenames) == 0
+    assert len(res.target_names) == 0
+    assert res.DESCR is None
+
+
+def test_default_load_files(test_category_dir_1, test_category_dir_2, load_files_root):
+    res = load_files(load_files_root)
+    assert len(res.filenames) == 1
+    assert len(res.target_names) == 2
+    assert res.DESCR is None
+    assert res.data == [b"Hello World!\n"]
+
+
+def test_load_files_w_categories_desc_and_encoding(
+    test_category_dir_1, test_category_dir_2, load_files_root
+):
+    category = os.path.abspath(test_category_dir_1).split(os.sep).pop()
+    res = load_files(
+        load_files_root, description="test", categories=[category], encoding="utf-8"
+    )
+
+    assert len(res.filenames) == 1
+    assert len(res.target_names) == 1
+    assert res.DESCR == "test"
+    assert res.data == ["Hello World!\n"]
+
+
+def test_load_files_wo_load_content(
+    test_category_dir_1, test_category_dir_2, load_files_root
+):
+    res = load_files(load_files_root, load_content=False)
+    assert len(res.filenames) == 1
+    assert len(res.target_names) == 2
+    assert res.DESCR is None
+    assert res.get("data") is None
+
+
+@pytest.mark.parametrize("allowed_extensions", ([".txt"], [".txt", ".json"]))
+def test_load_files_allowed_extensions(tmp_path, allowed_extensions):
+    """Check the behaviour of `allowed_extension` in `load_files`."""
+    d = tmp_path / "sub"
+    d.mkdir()
+    files = ("file1.txt", "file2.json", "file3.json", "file4.md")
+    paths = [d / f for f in files]
+    for p in paths:
+        p.write_bytes(b"hello")
+    res = load_files(tmp_path, allowed_extensions=allowed_extensions)
+    assert set([str(p) for p in paths if p.suffix in allowed_extensions]) == set(
+        res.filenames
+    )
+
+
+@pytest.mark.parametrize(
+    "filename, expected_n_samples, expected_n_features, expected_target_names",
+    [
+        ("wine_data.csv", 178, 13, ["class_0", "class_1", "class_2"]),
+        ("iris.csv", 150, 4, ["setosa", "versicolor", "virginica"]),
+        ("breast_cancer.csv", 569, 30, ["malignant", "benign"]),
+    ],
+)
+def test_load_csv_data(
+    filename, expected_n_samples, expected_n_features, expected_target_names
+):
+    actual_data, actual_target, actual_target_names = load_csv_data(filename)
+    assert actual_data.shape[0] == expected_n_samples
+    assert actual_data.shape[1] == expected_n_features
+    assert actual_target.shape[0] == expected_n_samples
+    np.testing.assert_array_equal(actual_target_names, expected_target_names)
+
+
+def test_load_csv_data_with_descr():
+    data_file_name = "iris.csv"
+    descr_file_name = "iris.rst"
+
+    res_without_descr = load_csv_data(data_file_name=data_file_name)
+    res_with_descr = load_csv_data(
+        data_file_name=data_file_name, descr_file_name=descr_file_name
+    )
+    assert len(res_with_descr) == 4
+    assert len(res_without_descr) == 3
+
+    np.testing.assert_array_equal(res_with_descr[0], res_without_descr[0])
+    np.testing.assert_array_equal(res_with_descr[1], res_without_descr[1])
+    np.testing.assert_array_equal(res_with_descr[2], res_without_descr[2])
+
+    assert res_with_descr[-1].startswith(".. _iris_dataset:")
+
+
+@pytest.mark.parametrize(
+    "filename, kwargs, expected_shape",
+    [
+        ("diabetes_data_raw.csv.gz", {}, [442, 10]),
+        ("diabetes_target.csv.gz", {}, [442]),
+        ("digits.csv.gz", {"delimiter": ","}, [1797, 65]),
+    ],
+)
+def test_load_gzip_compressed_csv_data(filename, kwargs, expected_shape):
+    actual_data = load_gzip_compressed_csv_data(filename, **kwargs)
+    assert actual_data.shape == tuple(expected_shape)
+
+
+def test_load_gzip_compressed_csv_data_with_descr():
+    data_file_name = "diabetes_target.csv.gz"
+    descr_file_name = "diabetes.rst"
+
+    expected_data = load_gzip_compressed_csv_data(data_file_name=data_file_name)
+    actual_data, descr = load_gzip_compressed_csv_data(
+        data_file_name=data_file_name,
+        descr_file_name=descr_file_name,
+    )
+
+    np.testing.assert_array_equal(actual_data, expected_data)
+    assert descr.startswith(".. _diabetes_dataset:")
+
+
+def test_load_sample_images():
+    try:
+        res = load_sample_images()
+        assert len(res.images) == 2
+        assert len(res.filenames) == 2
+        images = res.images
+
+        # assert is china image
+        assert np.all(images[0][0, 0, :] == np.array([174, 201, 231], dtype=np.uint8))
+        # assert is flower image
+        assert np.all(images[1][0, 0, :] == np.array([2, 19, 13], dtype=np.uint8))
+        assert res.DESCR
+    except ImportError:
+        warnings.warn("Could not load sample images, PIL is not available.")
+
+
+def test_load_sample_image():
+    try:
+        china = load_sample_image("china.jpg")
+        assert china.dtype == "uint8"
+        assert china.shape == (427, 640, 3)
+    except ImportError:
+        warnings.warn("Could not load sample images, PIL is not available.")
+
+
+def test_load_diabetes_raw():
+    """Test to check that we load a scaled version by default but that we can
+    get an unscaled version when setting `scaled=False`."""
+    diabetes_raw = load_diabetes(scaled=False)
+    assert diabetes_raw.data.shape == (442, 10)
+    assert diabetes_raw.target.size == 442
+    assert len(diabetes_raw.feature_names) == 10
+    assert diabetes_raw.DESCR
+
+    diabetes_default = load_diabetes()
+
+    np.testing.assert_allclose(
+        scale(diabetes_raw.data) / (442**0.5), diabetes_default.data, atol=1e-04
+    )
+
+
+@pytest.mark.parametrize(
+    "loader_func, data_shape, target_shape, n_target, has_descr, filenames",
+    [
+        (load_breast_cancer, (569, 30), (569,), 2, True, ["filename"]),
+        (load_wine, (178, 13), (178,), 3, True, []),
+        (load_iris, (150, 4), (150,), 3, True, ["filename"]),
+        (
+            load_linnerud,
+            (20, 3),
+            (20, 3),
+            3,
+            True,
+            ["data_filename", "target_filename"],
+        ),
+        (load_diabetes, (442, 10), (442,), None, True, []),
+        (load_digits, (1797, 64), (1797,), 10, True, []),
+        (partial(load_digits, n_class=9), (1617, 64), (1617,), 10, True, []),
+    ],
+)
+def test_loader(loader_func, data_shape, target_shape, n_target, has_descr, filenames):
+    bunch = loader_func()
+
+    assert isinstance(bunch, Bunch)
+    assert bunch.data.shape == data_shape
+    assert bunch.target.shape == target_shape
+    if hasattr(bunch, "feature_names"):
+        assert len(bunch.feature_names) == data_shape[1]
+    if n_target is not None:
+        assert len(bunch.target_names) == n_target
+    if has_descr:
+        assert bunch.DESCR
+    if filenames:
+        assert "data_module" in bunch
+        assert all(
+            [
+                f in bunch
+                and (resources.files(bunch["data_module"]) / bunch[f]).is_file()
+                for f in filenames
+            ]
+        )
+
+
+@pytest.mark.parametrize(
+    "loader_func, data_dtype, target_dtype",
+    [
+        (load_breast_cancer, np.float64, int),
+        (load_diabetes, np.float64, np.float64),
+        (load_digits, np.float64, int),
+        (load_iris, np.float64, int),
+        (load_linnerud, np.float64, np.float64),
+        (load_wine, np.float64, int),
+    ],
+)
+def test_toy_dataset_frame_dtype(loader_func, data_dtype, target_dtype):
+    default_result = loader_func()
+    check_as_frame(
+        default_result,
+        loader_func,
+        expected_data_dtype=data_dtype,
+        expected_target_dtype=target_dtype,
+    )
+
+
+def test_loads_dumps_bunch():
+    bunch = Bunch(x="x")
+    bunch_from_pkl = loads(dumps(bunch))
+    bunch_from_pkl.x = "y"
+    assert bunch_from_pkl["x"] == bunch_from_pkl.x
+
+
+def test_bunch_pickle_generated_with_0_16_and_read_with_0_17():
+    bunch = Bunch(key="original")
+    # This reproduces a problem when Bunch pickles have been created
+    # with scikit-learn 0.16 and are read with 0.17. Basically there
+    # is a surprising behaviour because reading bunch.key uses
+    # bunch.__dict__ (which is non empty for 0.16 Bunch objects)
+    # whereas assigning into bunch.key uses bunch.__setattr__. See
+    # https://github.com/scikit-learn/scikit-learn/issues/6196 for
+    # more details
+    bunch.__dict__["key"] = "set from __dict__"
+    bunch_from_pkl = loads(dumps(bunch))
+    # After loading from pickle the __dict__ should have been ignored
+    assert bunch_from_pkl.key == "original"
+    assert bunch_from_pkl["key"] == "original"
+    # Making sure that changing the attr does change the value
+    # associated with __getitem__ as well
+    bunch_from_pkl.key = "changed"
+    assert bunch_from_pkl.key == "changed"
+    assert bunch_from_pkl["key"] == "changed"
+
+
+def test_bunch_dir():
+    # check that dir (important for autocomplete) shows attributes
+    data = load_iris()
+    assert "data" in dir(data)
+
+
+def test_load_boston_error():
+    """Check that we raise the ethical warning when trying to import `load_boston`."""
+    msg = "The Boston housing prices dataset has an ethical problem"
+    with pytest.raises(ImportError, match=msg):
+        from sklearn.datasets import load_boston  # noqa: F401
+
+    # other non-existing function should raise the usual import error
+    msg = "cannot import name 'non_existing_function' from 'sklearn.datasets'"
+    with pytest.raises(ImportError, match=msg):
+        from sklearn.datasets import non_existing_function  # noqa: F401
+
+
+def test_fetch_remote_raise_warnings_with_invalid_url(monkeypatch):
+    """Check retry mechanism in _fetch_remote."""
+
+    url = "https://scikit-learn.org/this_file_does_not_exist.tar.gz"
+    invalid_remote_file = RemoteFileMetadata("invalid_file", url, None)
+    urlretrieve_mock = Mock(
+        side_effect=HTTPError(
+            url=url, code=404, msg="Not Found", hdrs=None, fp=io.BytesIO()
+        )
+    )
+    monkeypatch.setattr("sklearn.datasets._base.urlretrieve", urlretrieve_mock)
+
+    with pytest.warns(UserWarning, match="Retry downloading") as record:
+        with pytest.raises(HTTPError, match="HTTP Error 404"):
+            _fetch_remote(invalid_remote_file, n_retries=3, delay=0)
+
+        assert urlretrieve_mock.call_count == 4
+
+        for r in record:
+            assert str(r.message) == f"Retry downloading from url: {url}"
+        assert len(record) == 3
+
+
+def test_derive_folder_and_filename_from_url():
+    folder, filename = _derive_folder_and_filename_from_url(
+        "https://example.com/file.tar.gz"
+    )
+    assert folder == "example.com"
+    assert filename == "file.tar.gz"
+
+    folder, filename = _derive_folder_and_filename_from_url(
+        "https://example.com/نمونه نماینده.data"
+    )
+    assert folder == "example.com"
+    assert filename == "نمونه-نماینده.data"
+
+    folder, filename = _derive_folder_and_filename_from_url(
+        "https://example.com/path/to-/.file.tar.gz"
+    )
+    assert folder == "example.com/path_to"
+    assert filename == "file.tar.gz"
+
+    folder, filename = _derive_folder_and_filename_from_url("https://example.com/")
+    assert folder == "example.com"
+    assert filename == "downloaded_file"
+
+    folder, filename = _derive_folder_and_filename_from_url("https://example.com")
+    assert folder == "example.com"
+    assert filename == "downloaded_file"
+
+    folder, filename = _derive_folder_and_filename_from_url(
+        "https://example.com/path/@to/data.json?param=value"
+    )
+    assert folder == "example.com/path_to"
+    assert filename == "data.json"
+
+    folder, filename = _derive_folder_and_filename_from_url(
+        "https://example.com/path/@@to._/-_.data.json.#anchor"
+    )
+    assert folder == "example.com/path_to"
+    assert filename == "data.json"
+
+    folder, filename = _derive_folder_and_filename_from_url(
+        "https://example.com//some_file.txt"
+    )
+    assert folder == "example.com"
+    assert filename == "some_file.txt"
+
+    folder, filename = _derive_folder_and_filename_from_url(
+        "http://example/../some_file.txt"
+    )
+    assert folder == "example"
+    assert filename == "some_file.txt"
+
+    folder, filename = _derive_folder_and_filename_from_url(
+        "https://example.com/!.'.,/some_file.txt"
+    )
+    assert folder == "example.com"
+    assert filename == "some_file.txt"
+
+    folder, filename = _derive_folder_and_filename_from_url(
+        "https://example.com/a/!.'.,/b/some_file.txt"
+    )
+    assert folder == "example.com/a_b"
+    assert filename == "some_file.txt"
+
+    folder, filename = _derive_folder_and_filename_from_url("https://example.com/!.'.,")
+    assert folder == "example.com"
+    assert filename == "downloaded_file"
+
+    with pytest.raises(ValueError, match="Invalid URL"):
+        _derive_folder_and_filename_from_url("https:/../")
+
+
+def _mock_urlretrieve(server_side):
+    def _urlretrieve_mock(url, local_path):
+        server_root = Path(server_side)
+        file_path = urlparse(url).path.strip("/")
+        if not (server_root / file_path).exists():
+            raise HTTPError(url, 404, "Not Found", None, None)
+        shutil.copy(server_root / file_path, local_path)
+
+    return Mock(side_effect=_urlretrieve_mock)
+
+
+def test_fetch_file_using_data_home(monkeypatch, tmpdir):
+    tmpdir = Path(tmpdir)
+    server_side = tmpdir / "server_side"
+    server_side.mkdir()
+    data_file = server_side / "data.jsonl"
+    server_data = '{"a": 1, "b": 2}\n'
+    data_file.write_text(server_data, encoding="utf-8")
+
+    server_subfolder = server_side / "subfolder"
+    server_subfolder.mkdir()
+    other_data_file = server_subfolder / "other_file.txt"
+    other_data_file.write_text("Some important text data.", encoding="utf-8")
+
+    data_home = tmpdir / "data_home"
+    data_home.mkdir()
+
+    urlretrieve_mock = _mock_urlretrieve(server_side)
+    monkeypatch.setattr("sklearn.datasets._base.urlretrieve", urlretrieve_mock)
+
+    monkeypatch.setattr(
+        "sklearn.datasets._base.get_data_home", Mock(return_value=data_home)
+    )
+    fetched_file_path = fetch_file(
+        "https://example.com/data.jsonl",
+    )
+    assert fetched_file_path == data_home / "example.com" / "data.jsonl"
+    assert fetched_file_path.read_text(encoding="utf-8") == server_data
+
+    fetched_file_path = fetch_file(
+        "https://example.com/subfolder/other_file.txt",
+    )
+    assert (
+        fetched_file_path == data_home / "example.com" / "subfolder" / "other_file.txt"
+    )
+    assert fetched_file_path.read_text(encoding="utf-8") == other_data_file.read_text(
+        "utf-8"
+    )
+
+    expected_warning_msg = re.escape(
+        "Retry downloading from url: https://example.com/subfolder/invalid.txt"
+    )
+    with pytest.raises(HTTPError):
+        with pytest.warns(match=expected_warning_msg):
+            fetch_file(
+                "https://example.com/subfolder/invalid.txt",
+                delay=0,
+            )
+
+    local_subfolder = data_home / "example.com" / "subfolder"
+    assert sorted(local_subfolder.iterdir()) == [local_subfolder / "other_file.txt"]
+
+
+def test_fetch_file_without_sha256(monkeypatch, tmpdir):
+    server_side = tmpdir.mkdir("server_side")
+    data_file = Path(server_side / "data.jsonl")
+    server_data = '{"a": 1, "b": 2}\n'
+    data_file.write_text(server_data, encoding="utf-8")
+
+    client_side = tmpdir.mkdir("client_side")
+
+    urlretrieve_mock = _mock_urlretrieve(server_side)
+    monkeypatch.setattr("sklearn.datasets._base.urlretrieve", urlretrieve_mock)
+
+    # The first call should trigger a download:
+    fetched_file_path = fetch_file(
+        "https://example.com/data.jsonl",
+        folder=client_side,
+    )
+    assert fetched_file_path == client_side / "data.jsonl"
+    assert fetched_file_path.read_text(encoding="utf-8") == server_data
+    assert urlretrieve_mock.call_count == 1
+
+    # Fetching again the same file to the same folder should do nothing:
+    fetched_file_path = fetch_file(
+        "https://example.com/data.jsonl",
+        folder=client_side,
+    )
+    assert fetched_file_path == client_side / "data.jsonl"
+    assert fetched_file_path.read_text(encoding="utf-8") == server_data
+    assert urlretrieve_mock.call_count == 1
+
+    # Deleting and calling again should re-download
+    fetched_file_path.unlink()
+    fetched_file_path = fetch_file(
+        "https://example.com/data.jsonl",
+        folder=client_side,
+    )
+    assert fetched_file_path == client_side / "data.jsonl"
+    assert fetched_file_path.read_text(encoding="utf-8") == server_data
+    assert urlretrieve_mock.call_count == 2
+
+
+def test_fetch_file_with_sha256(monkeypatch, tmpdir):
+    server_side = tmpdir.mkdir("server_side")
+    data_file = Path(server_side / "data.jsonl")
+    server_data = '{"a": 1, "b": 2}\n'
+    data_file.write_text(server_data, encoding="utf-8")
+    expected_sha256 = hashlib.sha256(data_file.read_bytes()).hexdigest()
+
+    client_side = tmpdir.mkdir("client_side")
+
+    urlretrieve_mock = _mock_urlretrieve(server_side)
+    monkeypatch.setattr("sklearn.datasets._base.urlretrieve", urlretrieve_mock)
+
+    # The first call should trigger a download.
+    fetched_file_path = fetch_file(
+        "https://example.com/data.jsonl", folder=client_side, sha256=expected_sha256
+    )
+    assert fetched_file_path == client_side / "data.jsonl"
+    assert fetched_file_path.read_text(encoding="utf-8") == server_data
+    assert urlretrieve_mock.call_count == 1
+
+    # Fetching again the same file to the same folder should do nothing when
+    # the sha256 match:
+    fetched_file_path = fetch_file(
+        "https://example.com/data.jsonl", folder=client_side, sha256=expected_sha256
+    )
+    assert fetched_file_path == client_side / "data.jsonl"
+    assert fetched_file_path.read_text(encoding="utf-8") == server_data
+    assert urlretrieve_mock.call_count == 1
+
+    # Corrupting the local data should yield a warning and trigger a new download:
+    fetched_file_path.write_text("corrupted contents", encoding="utf-8")
+    expected_msg = (
+        r"SHA256 checksum of existing local file data.jsonl "
+        rf"\(.*\) differs from expected \({expected_sha256}\): "
+        r"re-downloading from https://example.com/data.jsonl \."
+    )
+    with pytest.warns(match=expected_msg):
+        fetched_file_path = fetch_file(
+            "https://example.com/data.jsonl", folder=client_side, sha256=expected_sha256
+        )
+        assert fetched_file_path == client_side / "data.jsonl"
+        assert fetched_file_path.read_text(encoding="utf-8") == server_data
+        assert urlretrieve_mock.call_count == 2
+
+    # Calling again should do nothing:
+    fetched_file_path = fetch_file(
+        "https://example.com/data.jsonl", folder=client_side, sha256=expected_sha256
+    )
+    assert fetched_file_path == client_side / "data.jsonl"
+    assert fetched_file_path.read_text(encoding="utf-8") == server_data
+    assert urlretrieve_mock.call_count == 2
+
+    # Deleting the local file and calling again should redownload without warning:
+    fetched_file_path.unlink()
+    fetched_file_path = fetch_file(
+        "https://example.com/data.jsonl", folder=client_side, sha256=expected_sha256
+    )
+    assert fetched_file_path == client_side / "data.jsonl"
+    assert fetched_file_path.read_text(encoding="utf-8") == server_data
+    assert urlretrieve_mock.call_count == 3
+
+    # Calling without a sha256 should also work without redownloading:
+    fetched_file_path = fetch_file(
+        "https://example.com/data.jsonl",
+        folder=client_side,
+    )
+    assert fetched_file_path == client_side / "data.jsonl"
+    assert fetched_file_path.read_text(encoding="utf-8") == server_data
+    assert urlretrieve_mock.call_count == 3
+
+    # Calling with a wrong sha256 should raise an informative exception:
+    non_matching_sha256 = "deadbabecafebeef"
+    expected_warning_msg = "differs from expected"
+    expected_error_msg = re.escape(
+        f"The SHA256 checksum of data.jsonl ({expected_sha256}) differs from "
+        f"expected ({non_matching_sha256})."
+    )
+    with pytest.raises(OSError, match=expected_error_msg):
+        with pytest.warns(match=expected_warning_msg):
+            fetch_file(
+                "https://example.com/data.jsonl",
+                folder=client_side,
+                sha256=non_matching_sha256,
+            )

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sklearn/datasets/tests/test_california_housing.py

@@ -0,0 +1,38 @@
+"""Test the california_housing loader, if the data is available,
+or if specifically requested via environment variable
+(e.g. for CI jobs)."""
+
+from functools import partial
+
+import pytest
+
+from sklearn.datasets.tests.test_common import check_return_X_y
+
+
+def test_fetch(fetch_california_housing_fxt):
+    data = fetch_california_housing_fxt()
+    assert (20640, 8) == data.data.shape
+    assert (20640,) == data.target.shape
+    assert data.DESCR.startswith(".. _california_housing_dataset:")
+
+    # test return_X_y option
+    fetch_func = partial(fetch_california_housing_fxt)
+    check_return_X_y(data, fetch_func)
+
+
+def test_fetch_asframe(fetch_california_housing_fxt):
+    pd = pytest.importorskip("pandas")
+    bunch = fetch_california_housing_fxt(as_frame=True)
+    frame = bunch.frame
+    assert hasattr(bunch, "frame") is True
+    assert frame.shape == (20640, 9)
+    assert isinstance(bunch.data, pd.DataFrame)
+    assert isinstance(bunch.target, pd.Series)
+
+
+def test_pandas_dependency_message(fetch_california_housing_fxt, hide_available_pandas):
+    # Check that pandas is imported lazily and that an informative error
+    # message is raised when pandas is missing:
+    expected_msg = "fetch_california_housing with as_frame=True requires pandas"
+    with pytest.raises(ImportError, match=expected_msg):
+        fetch_california_housing_fxt(as_frame=True)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sklearn/datasets/tests/test_common.py

@@ -0,0 +1,136 @@
+"""Test loaders for common functionality."""
+
+import inspect
+import os
+
+import numpy as np
+import pytest
+
+import sklearn.datasets
+
+
+def is_pillow_installed():
+    try:
+        import PIL  # noqa: F401
+
+        return True
+    except ImportError:
+        return False
+
+
+FETCH_PYTEST_MARKERS = {
+    "return_X_y": {
+        "fetch_20newsgroups": pytest.mark.xfail(
+            reason="X is a list and does not have a shape argument"
+        ),
+        "fetch_openml": pytest.mark.xfail(
+            reason="fetch_opeml requires a dataset name or id"
+        ),
+        "fetch_lfw_people": pytest.mark.skipif(
+            not is_pillow_installed(), reason="pillow is not installed"
+        ),
+    },
+    "as_frame": {
+        "fetch_openml": pytest.mark.xfail(
+            reason="fetch_opeml requires a dataset name or id"
+        ),
+    },
+}
+
+
+def check_pandas_dependency_message(fetch_func):
+    try:
+        import pandas  # noqa: F401
+
+        pytest.skip("This test requires pandas to not be installed")
+    except ImportError:
+        # Check that pandas is imported lazily and that an informative error
+        # message is raised when pandas is missing:
+        name = fetch_func.__name__
+        expected_msg = f"{name} with as_frame=True requires pandas"
+        with pytest.raises(ImportError, match=expected_msg):
+            fetch_func(as_frame=True)
+
+
+def check_return_X_y(bunch, dataset_func):
+    X_y_tuple = dataset_func(return_X_y=True)
+    assert isinstance(X_y_tuple, tuple)
+    assert X_y_tuple[0].shape == bunch.data.shape
+    assert X_y_tuple[1].shape == bunch.target.shape
+
+
+def check_as_frame(
+    bunch, dataset_func, expected_data_dtype=None, expected_target_dtype=None
+):
+    pd = pytest.importorskip("pandas")
+    frame_bunch = dataset_func(as_frame=True)
+    assert hasattr(frame_bunch, "frame")
+    assert isinstance(frame_bunch.frame, pd.DataFrame)
+    assert isinstance(frame_bunch.data, pd.DataFrame)
+    assert frame_bunch.data.shape == bunch.data.shape
+    if frame_bunch.target.ndim > 1:
+        assert isinstance(frame_bunch.target, pd.DataFrame)
+    else:
+        assert isinstance(frame_bunch.target, pd.Series)
+    assert frame_bunch.target.shape[0] == bunch.target.shape[0]
+    if expected_data_dtype is not None:
+        assert np.all(frame_bunch.data.dtypes == expected_data_dtype)
+    if expected_target_dtype is not None:
+        assert np.all(frame_bunch.target.dtypes == expected_target_dtype)
+
+    # Test for return_X_y and as_frame=True
+    frame_X, frame_y = dataset_func(as_frame=True, return_X_y=True)
+    assert isinstance(frame_X, pd.DataFrame)
+    if frame_y.ndim > 1:
+        assert isinstance(frame_X, pd.DataFrame)
+    else:
+        assert isinstance(frame_y, pd.Series)
+
+
+def _skip_network_tests():
+    return os.environ.get("SKLEARN_SKIP_NETWORK_TESTS", "1") == "1"
+
+
+def _generate_func_supporting_param(param, dataset_type=("load", "fetch")):
+    markers_fetch = FETCH_PYTEST_MARKERS.get(param, {})
+    for name, obj in inspect.getmembers(sklearn.datasets):
+        if not inspect.isfunction(obj):
+            continue
+
+        is_dataset_type = any([name.startswith(t) for t in dataset_type])
+        is_support_param = param in inspect.signature(obj).parameters
+        if is_dataset_type and is_support_param:
+            # check if we should skip if we don't have network support
+            marks = [
+                pytest.mark.skipif(
+                    condition=name.startswith("fetch") and _skip_network_tests(),
+                    reason="Skip because fetcher requires internet network",
+                )
+            ]
+            if name in markers_fetch:
+                marks.append(markers_fetch[name])
+
+            yield pytest.param(name, obj, marks=marks)
+
+
+@pytest.mark.parametrize(
+    "name, dataset_func", _generate_func_supporting_param("return_X_y")
+)
+def test_common_check_return_X_y(name, dataset_func):
+    bunch = dataset_func()
+    check_return_X_y(bunch, dataset_func)
+
+
+@pytest.mark.parametrize(
+    "name, dataset_func", _generate_func_supporting_param("as_frame")
+)
+def test_common_check_as_frame(name, dataset_func):
+    bunch = dataset_func()
+    check_as_frame(bunch, dataset_func)
+
+
+@pytest.mark.parametrize(
+    "name, dataset_func", _generate_func_supporting_param("as_frame")
+)
+def test_common_check_pandas_dependency(name, dataset_func):
+    check_pandas_dependency_message(dataset_func)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sklearn/datasets/tests/test_covtype.py

@@ -0,0 +1,55 @@
+"""Test the covtype loader, if the data is available,
+or if specifically requested via environment variable
+(e.g. for CI jobs)."""
+
+from functools import partial
+
+import pytest
+
+from sklearn.datasets.tests.test_common import check_return_X_y
+
+
+def test_fetch(fetch_covtype_fxt, global_random_seed):
+    data1 = fetch_covtype_fxt(shuffle=True, random_state=global_random_seed)
+    data2 = fetch_covtype_fxt(shuffle=True, random_state=global_random_seed + 1)
+
+    X1, X2 = data1["data"], data2["data"]
+    assert (581012, 54) == X1.shape
+    assert X1.shape == X2.shape
+
+    assert X1.sum() == X2.sum()
+
+    y1, y2 = data1["target"], data2["target"]
+    assert (X1.shape[0],) == y1.shape
+    assert (X1.shape[0],) == y2.shape
+
+    descr_prefix = ".. _covtype_dataset:"
+    assert data1.DESCR.startswith(descr_prefix)
+    assert data2.DESCR.startswith(descr_prefix)
+
+    # test return_X_y option
+    fetch_func = partial(fetch_covtype_fxt)
+    check_return_X_y(data1, fetch_func)
+
+
+def test_fetch_asframe(fetch_covtype_fxt):
+    pytest.importorskip("pandas")
+
+    bunch = fetch_covtype_fxt(as_frame=True)
+    assert hasattr(bunch, "frame")
+    frame = bunch.frame
+    assert frame.shape == (581012, 55)
+    assert bunch.data.shape == (581012, 54)
+    assert bunch.target.shape == (581012,)
+
+    column_names = set(frame.columns)
+
+    # enumerated names are added correctly
+    assert set(f"Wilderness_Area_{i}" for i in range(4)) < column_names
+    assert set(f"Soil_Type_{i}" for i in range(40)) < column_names
+
+
+def test_pandas_dependency_message(fetch_covtype_fxt, hide_available_pandas):
+    expected_msg = "fetch_covtype with as_frame=True requires pandas"
+    with pytest.raises(ImportError, match=expected_msg):
+        fetch_covtype_fxt(as_frame=True)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sklearn/datasets/tests/test_kddcup99.py

@@ -0,0 +1,89 @@
+"""Test  kddcup99 loader, if the data is available,
+or if specifically requested via environment variable
+(e.g. for CI jobs).
+
+Only 'percent10' mode is tested, as the full data
+is too big to use in unit-testing.
+"""
+
+from functools import partial
+
+import pytest
+
+from sklearn.datasets.tests.test_common import (
+    check_as_frame,
+    check_pandas_dependency_message,
+    check_return_X_y,
+)
+
+
+@pytest.mark.parametrize("as_frame", [True, False])
+@pytest.mark.parametrize(
+    "subset, n_samples, n_features",
+    [
+        (None, 494021, 41),
+        ("SA", 100655, 41),
+        ("SF", 73237, 4),
+        ("http", 58725, 3),
+        ("smtp", 9571, 3),
+    ],
+)
+def test_fetch_kddcup99_percent10(
+    fetch_kddcup99_fxt, as_frame, subset, n_samples, n_features
+):
+    data = fetch_kddcup99_fxt(subset=subset, as_frame=as_frame)
+    assert data.data.shape == (n_samples, n_features)
+    assert data.target.shape == (n_samples,)
+    if as_frame:
+        assert data.frame.shape == (n_samples, n_features + 1)
+    assert data.DESCR.startswith(".. _kddcup99_dataset:")
+
+
+def test_fetch_kddcup99_return_X_y(fetch_kddcup99_fxt):
+    fetch_func = partial(fetch_kddcup99_fxt, subset="smtp")
+    data = fetch_func()
+    check_return_X_y(data, fetch_func)
+
+
+def test_fetch_kddcup99_as_frame(fetch_kddcup99_fxt):
+    bunch = fetch_kddcup99_fxt()
+    check_as_frame(bunch, fetch_kddcup99_fxt)
+
+
+def test_fetch_kddcup99_shuffle(fetch_kddcup99_fxt):
+    dataset = fetch_kddcup99_fxt(
+        random_state=0,
+        subset="SA",
+        percent10=True,
+    )
+    dataset_shuffled = fetch_kddcup99_fxt(
+        random_state=0,
+        subset="SA",
+        shuffle=True,
+        percent10=True,
+    )
+    assert set(dataset["target"]) == set(dataset_shuffled["target"])
+    assert dataset_shuffled.data.shape == dataset.data.shape
+    assert dataset_shuffled.target.shape == dataset.target.shape
+
+
+def test_pandas_dependency_message(fetch_kddcup99_fxt, hide_available_pandas):
+    check_pandas_dependency_message(fetch_kddcup99_fxt)
+
+
+def test_corrupted_file_error_message(fetch_kddcup99_fxt, tmp_path):
+    """Check that a nice error message is raised when cache is corrupted."""
+    kddcup99_dir = tmp_path / "kddcup99_10-py3"
+    kddcup99_dir.mkdir()
+    samples_path = kddcup99_dir / "samples"
+
+    with samples_path.open("wb") as f:
+        f.write(b"THIS IS CORRUPTED")
+
+    msg = (
+        "The cache for fetch_kddcup99 is invalid, please "
+        f"delete {kddcup99_dir} and run the fetch_kddcup99 again"
+    )
+
+    with pytest.raises(OSError, match=msg):
+        fetch_kddcup99_fxt(data_home=str(tmp_path))

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sklearn/datasets/tests/test_lfw.py

@@ -0,0 +1,229 @@
+"""This test for the LFW require medium-size data downloading and processing
+
+If the data has not been already downloaded by running the examples,
+the tests won't run (skipped).
+
+If the test are run, the first execution will be long (typically a bit
+more than a couple of minutes) but as the dataset loader is leveraging
+joblib, successive runs will be fast (less than 200ms).
+"""
+
+import random
+from functools import partial
+
+import numpy as np
+import pytest
+
+from sklearn.datasets import fetch_lfw_pairs, fetch_lfw_people
+from sklearn.datasets.tests.test_common import check_return_X_y
+from sklearn.utils._testing import assert_array_equal
+
+FAKE_NAMES = [
+    "Abdelatif_Smith",
+    "Abhati_Kepler",
+    "Camara_Alvaro",
+    "Chen_Dupont",
+    "John_Lee",
+    "Lin_Bauman",
+    "Onur_Lopez",
+]
+
+
+@pytest.fixture(scope="module")
+def mock_empty_data_home(tmp_path_factory):
+    data_dir = tmp_path_factory.mktemp("scikit_learn_empty_test")
+
+    yield data_dir
+
+
+@pytest.fixture(scope="module")
+def mock_data_home(tmp_path_factory):
+    """Test fixture run once and common to all tests of this module"""
+    Image = pytest.importorskip("PIL.Image")
+
+    data_dir = tmp_path_factory.mktemp("scikit_learn_lfw_test")
+    lfw_home = data_dir / "lfw_home"
+    lfw_home.mkdir(parents=True, exist_ok=True)
+
+    random_state = random.Random(42)
+    np_rng = np.random.RandomState(42)
+
+    # generate some random jpeg files for each person
+    counts = {}
+    for name in FAKE_NAMES:
+        folder_name = lfw_home / "lfw_funneled" / name
+        folder_name.mkdir(parents=True, exist_ok=True)
+
+        n_faces = np_rng.randint(1, 5)
+        counts[name] = n_faces
+        for i in range(n_faces):
+            file_path = folder_name / (name + "_%04d.jpg" % i)
+            uniface = np_rng.randint(0, 255, size=(250, 250, 3))
+            img = Image.fromarray(uniface.astype(np.uint8))
+            img.save(file_path)
+
+    # add some random file pollution to test robustness
+    (lfw_home / "lfw_funneled" / ".test.swp").write_bytes(
+        b"Text file to be ignored by the dataset loader."
+    )
+
+    # generate some pairing metadata files using the same format as LFW
+    with open(lfw_home / "pairsDevTrain.txt", "wb") as f:
+        f.write(b"10\n")
+        more_than_two = [name for name, count in counts.items() if count >= 2]
+        for i in range(5):
+            name = random_state.choice(more_than_two)
+            first, second = random_state.sample(range(counts[name]), 2)
+            f.write(("%s\t%d\t%d\n" % (name, first, second)).encode())
+
+        for i in range(5):
+            first_name, second_name = random_state.sample(FAKE_NAMES, 2)
+            first_index = np_rng.choice(np.arange(counts[first_name]))
+            second_index = np_rng.choice(np.arange(counts[second_name]))
+            f.write(
+                (
+                    "%s\t%d\t%s\t%d\n"
+                    % (first_name, first_index, second_name, second_index)
+                ).encode()
+            )
+
+    (lfw_home / "pairsDevTest.txt").write_bytes(
+        b"Fake place holder that won't be tested"
+    )
+    (lfw_home / "pairs.txt").write_bytes(b"Fake place holder that won't be tested")
+
+    yield data_dir
+
+
+def test_load_empty_lfw_people(mock_empty_data_home):
+    with pytest.raises(OSError):
+        fetch_lfw_people(data_home=mock_empty_data_home, download_if_missing=False)
+
+
+def test_load_fake_lfw_people(mock_data_home):
+    lfw_people = fetch_lfw_people(
+        data_home=mock_data_home, min_faces_per_person=3, download_if_missing=False
+    )
+
+    # The data is croped around the center as a rectangular bounding box
+    # around the face. Colors are converted to gray levels:
+    assert lfw_people.images.shape == (10, 62, 47)
+    assert lfw_people.data.shape == (10, 2914)
+
+    # the target is array of person integer ids
+    assert_array_equal(lfw_people.target, [2, 0, 1, 0, 2, 0, 2, 1, 1, 2])
+
+    # names of the persons can be found using the target_names array
+    expected_classes = ["Abdelatif Smith", "Abhati Kepler", "Onur Lopez"]
+    assert_array_equal(lfw_people.target_names, expected_classes)
+
+    # It is possible to ask for the original data without any croping or color
+    # conversion and not limit on the number of picture per person
+    lfw_people = fetch_lfw_people(
+        data_home=mock_data_home,
+        resize=None,
+        slice_=None,
+        color=True,
+        download_if_missing=False,
+    )
+    assert lfw_people.images.shape == (17, 250, 250, 3)
+    assert lfw_people.DESCR.startswith(".. _labeled_faces_in_the_wild_dataset:")
+
+    # the ids and class names are the same as previously
+    assert_array_equal(
+        lfw_people.target, [0, 0, 1, 6, 5, 6, 3, 6, 0, 3, 6, 1, 2, 4, 5, 1, 2]
+    )
+    assert_array_equal(
+        lfw_people.target_names,
+        [
+            "Abdelatif Smith",
+            "Abhati Kepler",
+            "Camara Alvaro",
+            "Chen Dupont",
+            "John Lee",
+            "Lin Bauman",
+            "Onur Lopez",
+        ],
+    )
+
+    # test return_X_y option
+    fetch_func = partial(
+        fetch_lfw_people,
+        data_home=mock_data_home,
+        resize=None,
+        slice_=None,
+        color=True,
+        download_if_missing=False,
+    )
+    check_return_X_y(lfw_people, fetch_func)
+
+
+def test_load_fake_lfw_people_too_restrictive(mock_data_home):
+    with pytest.raises(ValueError):
+        fetch_lfw_people(
+            data_home=mock_data_home,
+            min_faces_per_person=100,
+            download_if_missing=False,
+        )
+
+
+def test_load_empty_lfw_pairs(mock_empty_data_home):
+    with pytest.raises(OSError):
+        fetch_lfw_pairs(data_home=mock_empty_data_home, download_if_missing=False)
+
+
+def test_load_fake_lfw_pairs(mock_data_home):
+    lfw_pairs_train = fetch_lfw_pairs(
+        data_home=mock_data_home, download_if_missing=False
+    )
+
+    # The data is croped around the center as a rectangular bounding box
+    # around the face. Colors are converted to gray levels:
+    assert lfw_pairs_train.pairs.shape == (10, 2, 62, 47)
+
+    # the target is whether the person is the same or not
+    assert_array_equal(lfw_pairs_train.target, [1, 1, 1, 1, 1, 0, 0, 0, 0, 0])
+
+    # names of the persons can be found using the target_names array
+    expected_classes = ["Different persons", "Same person"]
+    assert_array_equal(lfw_pairs_train.target_names, expected_classes)
+
+    # It is possible to ask for the original data without any croping or color
+    # conversion
+    lfw_pairs_train = fetch_lfw_pairs(
+        data_home=mock_data_home,
+        resize=None,
+        slice_=None,
+        color=True,
+        download_if_missing=False,
+    )
+    assert lfw_pairs_train.pairs.shape == (10, 2, 250, 250, 3)
+
+    # the ids and class names are the same as previously
+    assert_array_equal(lfw_pairs_train.target, [1, 1, 1, 1, 1, 0, 0, 0, 0, 0])
+    assert_array_equal(lfw_pairs_train.target_names, expected_classes)
+
+    assert lfw_pairs_train.DESCR.startswith(".. _labeled_faces_in_the_wild_dataset:")
+
+
+def test_fetch_lfw_people_internal_cropping(mock_data_home):
+    """Check that we properly crop the images.
+
+    Non-regression test for:
+    https://github.com/scikit-learn/scikit-learn/issues/24942
+    """
+    # If cropping was not done properly and we don't resize the images, the images would
+    # have their original size (250x250) and the image would not fit in the NumPy array
+    # pre-allocated based on `slice_` parameter.
+    slice_ = (slice(70, 195), slice(78, 172))
+    lfw = fetch_lfw_people(
+        data_home=mock_data_home,
+        min_faces_per_person=3,
+        download_if_missing=False,
+        resize=None,
+        slice_=slice_,
+    )
+    assert lfw.images[0].shape == (
+        slice_[0].stop - slice_[0].start,
+        slice_[1].stop - slice_[1].start,
+    )

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sklearn/datasets/tests/test_olivetti_faces.py

@@ -0,0 +1,26 @@
+"""Test Olivetti faces fetcher, if the data is available,
+or if specifically requested via environment variable
+(e.g. for CI jobs)."""
+
+import numpy as np
+
+from sklearn.datasets.tests.test_common import check_return_X_y
+from sklearn.utils import Bunch
+from sklearn.utils._testing import assert_array_equal
+
+
+def test_olivetti_faces(fetch_olivetti_faces_fxt):
+    data = fetch_olivetti_faces_fxt(shuffle=True, random_state=0)
+
+    assert isinstance(data, Bunch)
+    for expected_keys in ("data", "images", "target", "DESCR"):
+        assert expected_keys in data.keys()
+
+    assert data.data.shape == (400, 4096)
+    assert data.images.shape == (400, 64, 64)
+    assert data.target.shape == (400,)
+    assert_array_equal(np.unique(np.sort(data.target)), np.arange(40))
+    assert data.DESCR.startswith(".. _olivetti_faces_dataset:")
+
+    # test the return_X_y option
+    check_return_X_y(data, fetch_olivetti_faces_fxt)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sklearn/datasets/tests/test_openml.py

@@ -0,0 +1,1636 @@
+"""Test the openml loader."""
+
+import gzip
+import json
+import os
+import re
+from functools import partial
+from importlib import resources
+from io import BytesIO
+from urllib.error import HTTPError
+
+import numpy as np
+import pytest
+import scipy.sparse
+
+import sklearn
+from sklearn import config_context
+from sklearn.datasets import fetch_openml as fetch_openml_orig
+from sklearn.datasets._openml import (
+    _get_local_path,
+    _open_openml_url,
+    _retry_with_clean_cache,
+)
+from sklearn.utils import Bunch
+from sklearn.utils._optional_dependencies import check_pandas_support
+from sklearn.utils._testing import (
+    SkipTest,
+    assert_allclose,
+    assert_array_equal,
+)
+
+OPENML_TEST_DATA_MODULE = "sklearn.datasets.tests.data.openml"
+# if True, urlopen will be monkey patched to only use local files
+test_offline = True
+_MONKEY_PATCH_LOCAL_OPENML_PATH = "data/v1/download/{}"
+
+
+class _MockHTTPResponse:
+    def __init__(self, data, is_gzip):
+        self.data = data
+        self.is_gzip = is_gzip
+
+    def read(self, amt=-1):
+        return self.data.read(amt)
+
+    def close(self):
+        self.data.close()
+
+    def info(self):
+        if self.is_gzip:
+            return {"Content-Encoding": "gzip"}
+        return {}
+
+    def __iter__(self):
+        return iter(self.data)
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        return False
+
+
+# Disable the disk-based cache when testing `fetch_openml`:
+# the mock data in sklearn/datasets/tests/data/openml/ is not always consistent
+# with the version on openml.org. If one were to load the dataset outside of
+# the tests, it may result in data that does not represent openml.org.
+fetch_openml = partial(fetch_openml_orig, data_home=None)
+
+
+def _monkey_patch_webbased_functions(context, data_id, gzip_response):
+    # monkey patches the urlopen function. Important note: Do NOT use this
+    # in combination with a regular cache directory, as the files that are
+    # stored as cache should not be mixed up with real openml datasets
+    url_prefix_data_description = "https://api.openml.org/api/v1/json/data/"
+    url_prefix_data_features = "https://api.openml.org/api/v1/json/data/features/"
+    url_prefix_download_data = "https://www.openml.org/data/v1/download"
+    url_prefix_data_list = "https://api.openml.org/api/v1/json/data/list/"
+
+    path_suffix = ".gz"
+    read_fn = gzip.open
+
+    data_module = OPENML_TEST_DATA_MODULE + "." + f"id_{data_id}"
+
+    def _file_name(url, suffix):
+        output = (
+            re.sub(r"\W", "-", url[len("https://api.openml.org/") :])
+            + suffix
+            + path_suffix
+        )
+        # Shorten the filenames to have better compatibility with windows 10
+        # and filenames > 260 characters
+        return (
+            output.replace("-json-data-list", "-jdl")
+            .replace("-json-data-features", "-jdf")
+            .replace("-json-data-qualities", "-jdq")
+            .replace("-json-data", "-jd")
+            .replace("-data_name", "-dn")
+            .replace("-download", "-dl")
+            .replace("-limit", "-l")
+            .replace("-data_version", "-dv")
+            .replace("-status", "-s")
+            .replace("-deactivated", "-dact")
+            .replace("-active", "-act")
+        )
+
+    def _mock_urlopen_shared(url, has_gzip_header, expected_prefix, suffix):
+        assert url.startswith(expected_prefix), (
+            f"{expected_prefix!r} does not match {url!r}"
+        )
+
+        data_file_name = _file_name(url, suffix)
+        data_file_path = resources.files(data_module) / data_file_name
+
+        with data_file_path.open("rb") as f:
+            if has_gzip_header and gzip_response:
+                fp = BytesIO(f.read())
+                return _MockHTTPResponse(fp, True)
+            else:
+                decompressed_f = read_fn(f, "rb")
+                fp = BytesIO(decompressed_f.read())
+                return _MockHTTPResponse(fp, False)
+
+    def _mock_urlopen_data_description(url, has_gzip_header):
+        return _mock_urlopen_shared(
+            url=url,
+            has_gzip_header=has_gzip_header,
+            expected_prefix=url_prefix_data_description,
+            suffix=".json",
+        )
+
+    def _mock_urlopen_data_features(url, has_gzip_header):
+        return _mock_urlopen_shared(
+            url=url,
+            has_gzip_header=has_gzip_header,
+            expected_prefix=url_prefix_data_features,
+            suffix=".json",
+        )
+
+    def _mock_urlopen_download_data(url, has_gzip_header):
+        # For simplicity the mock filenames don't contain the filename, i.e.
+        # the last part of the data description url after the last /.
+        # For example for id_1, data description download url is:
+        # gunzip -c sklearn/datasets/tests/data/openml/id_1/api-v1-jd-1.json.gz | grep '"url"  # noqa: E501
+        # "https:\/\/www.openml.org\/data\/v1\/download\/1\/anneal.arff"
+        # but the mock filename does not contain anneal.arff and is:
+        # sklearn/datasets/tests/data/openml/id_1/data-v1-dl-1.arff.gz.
+        # We only keep the part of the url before the last /
+        url_without_filename = url.rsplit("/", 1)[0]
+
+        return _mock_urlopen_shared(
+            url=url_without_filename,
+            has_gzip_header=has_gzip_header,
+            expected_prefix=url_prefix_download_data,
+            suffix=".arff",
+        )
+
+    def _mock_urlopen_data_list(url, has_gzip_header):
+        assert url.startswith(url_prefix_data_list), (
+            f"{url_prefix_data_list!r} does not match {url!r}"
+        )
+
+        data_file_name = _file_name(url, ".json")
+        data_file_path = resources.files(data_module) / data_file_name
+
+        # load the file itself, to simulate a http error
+        with data_file_path.open("rb") as f:
+            decompressed_f = read_fn(f, "rb")
+            decoded_s = decompressed_f.read().decode("utf-8")
+            json_data = json.loads(decoded_s)
+        if "error" in json_data:
+            raise HTTPError(
+                url=None, code=412, msg="Simulated mock error", hdrs=None, fp=BytesIO()
+            )
+
+        with data_file_path.open("rb") as f:
+            if has_gzip_header:
+                fp = BytesIO(f.read())
+                return _MockHTTPResponse(fp, True)
+            else:
+                decompressed_f = read_fn(f, "rb")
+                fp = BytesIO(decompressed_f.read())
+                return _MockHTTPResponse(fp, False)
+
+    def _mock_urlopen(request, *args, **kwargs):
+        url = request.get_full_url()
+        has_gzip_header = request.get_header("Accept-encoding") == "gzip"
+        if url.startswith(url_prefix_data_list):
+            return _mock_urlopen_data_list(url, has_gzip_header)
+        elif url.startswith(url_prefix_data_features):
+            return _mock_urlopen_data_features(url, has_gzip_header)
+        elif url.startswith(url_prefix_download_data):
+            return _mock_urlopen_download_data(url, has_gzip_header)
+        elif url.startswith(url_prefix_data_description):
+            return _mock_urlopen_data_description(url, has_gzip_header)
+        else:
+            raise ValueError("Unknown mocking URL pattern: %s" % url)
+
+    # XXX: Global variable
+    if test_offline:
+        context.setattr(sklearn.datasets._openml, "urlopen", _mock_urlopen)
+
+
+###############################################################################
+# Test the behaviour of `fetch_openml` depending of the input parameters.
+
+
+@pytest.mark.parametrize(
+    "data_id, dataset_params, n_samples, n_features, n_targets",
+    [
+        # iris
+        (61, {"data_id": 61}, 150, 4, 1),
+        (61, {"name": "iris", "version": 1}, 150, 4, 1),
+        # anneal
+        (2, {"data_id": 2}, 11, 38, 1),
+        (2, {"name": "anneal", "version": 1}, 11, 38, 1),
+        # cpu
+        (561, {"data_id": 561}, 209, 7, 1),
+        (561, {"name": "cpu", "version": 1}, 209, 7, 1),
+        # emotions
+        (40589, {"data_id": 40589}, 13, 72, 6),
+        # adult-census
+        (1119, {"data_id": 1119}, 10, 14, 1),
+        (1119, {"name": "adult-census"}, 10, 14, 1),
+        # miceprotein
+        (40966, {"data_id": 40966}, 7, 77, 1),
+        (40966, {"name": "MiceProtein"}, 7, 77, 1),
+        # titanic
+        (40945, {"data_id": 40945}, 1309, 13, 1),
+    ],
+)
+@pytest.mark.parametrize("parser", ["liac-arff", "pandas"])
+@pytest.mark.parametrize("gzip_response", [True, False])
+def test_fetch_openml_as_frame_true(
+    monkeypatch,
+    data_id,
+    dataset_params,
+    n_samples,
+    n_features,
+    n_targets,
+    parser,
+    gzip_response,
+):
+    """Check the behaviour of `fetch_openml` with `as_frame=True`.
+
+    Fetch by ID and/or name (depending if the file was previously cached).
+    """
+    pd = pytest.importorskip("pandas")
+
+    _monkey_patch_webbased_functions(monkeypatch, data_id, gzip_response=gzip_response)
+    bunch = fetch_openml(
+        as_frame=True,
+        cache=False,
+        parser=parser,
+        **dataset_params,
+    )
+
+    assert int(bunch.details["id"]) == data_id
+    assert isinstance(bunch, Bunch)
+
+    assert isinstance(bunch.frame, pd.DataFrame)
+    assert bunch.frame.shape == (n_samples, n_features + n_targets)
+
+    assert isinstance(bunch.data, pd.DataFrame)
+    assert bunch.data.shape == (n_samples, n_features)
+
+    if n_targets == 1:
+        assert isinstance(bunch.target, pd.Series)
+        assert bunch.target.shape == (n_samples,)
+    else:
+        assert isinstance(bunch.target, pd.DataFrame)
+        assert bunch.target.shape == (n_samples, n_targets)
+
+    assert bunch.categories is None
+
+
+@pytest.mark.parametrize(
+    "data_id, dataset_params, n_samples, n_features, n_targets",
+    [
+        # iris
+        (61, {"data_id": 61}, 150, 4, 1),
+        (61, {"name": "iris", "version": 1}, 150, 4, 1),
+        # anneal
+        (2, {"data_id": 2}, 11, 38, 1),
+        (2, {"name": "anneal", "version": 1}, 11, 38, 1),
+        # cpu
+        (561, {"data_id": 561}, 209, 7, 1),
+        (561, {"name": "cpu", "version": 1}, 209, 7, 1),
+        # emotions
+        (40589, {"data_id": 40589}, 13, 72, 6),
+        # adult-census
+        (1119, {"data_id": 1119}, 10, 14, 1),
+        (1119, {"name": "adult-census"}, 10, 14, 1),
+        # miceprotein
+        (40966, {"data_id": 40966}, 7, 77, 1),
+        (40966, {"name": "MiceProtein"}, 7, 77, 1),
+    ],
+)
+@pytest.mark.parametrize("parser", ["liac-arff", "pandas"])
+def test_fetch_openml_as_frame_false(
+    monkeypatch,
+    data_id,
+    dataset_params,
+    n_samples,
+    n_features,
+    n_targets,
+    parser,
+):
+    """Check the behaviour of `fetch_openml` with `as_frame=False`.
+
+    Fetch both by ID and/or name + version.
+    """
+    pytest.importorskip("pandas")
+
+    _monkey_patch_webbased_functions(monkeypatch, data_id, gzip_response=True)
+    bunch = fetch_openml(
+        as_frame=False,
+        cache=False,
+        parser=parser,
+        **dataset_params,
+    )
+    assert int(bunch.details["id"]) == data_id
+    assert isinstance(bunch, Bunch)
+
+    assert bunch.frame is None
+
+    assert isinstance(bunch.data, np.ndarray)
+    assert bunch.data.shape == (n_samples, n_features)
+
+    assert isinstance(bunch.target, np.ndarray)
+    if n_targets == 1:
+        assert bunch.target.shape == (n_samples,)
+    else:
+        assert bunch.target.shape == (n_samples, n_targets)
+
+    assert isinstance(bunch.categories, dict)
+
+
+@pytest.mark.parametrize("data_id", [61, 1119, 40945])
+def test_fetch_openml_consistency_parser(monkeypatch, data_id):
+    """Check the consistency of the LIAC-ARFF and pandas parsers."""
+    pd = pytest.importorskip("pandas")
+
+    _monkey_patch_webbased_functions(monkeypatch, data_id, gzip_response=True)
+    bunch_liac = fetch_openml(
+        data_id=data_id,
+        as_frame=True,
+        cache=False,
+        parser="liac-arff",
+    )
+    bunch_pandas = fetch_openml(
+        data_id=data_id,
+        as_frame=True,
+        cache=False,
+        parser="pandas",
+    )
+
+    # The data frames for the input features should match up to some numerical
+    # dtype conversions (e.g. float64 <=> Int64) due to limitations of the
+    # LIAC-ARFF parser.
+    data_liac, data_pandas = bunch_liac.data, bunch_pandas.data
+
+    def convert_numerical_dtypes(series):
+        pandas_series = data_pandas[series.name]
+        if pd.api.types.is_numeric_dtype(pandas_series):
+            return series.astype(pandas_series.dtype)
+        else:
+            return series
+
+    data_liac_with_fixed_dtypes = data_liac.apply(convert_numerical_dtypes)
+    pd.testing.assert_frame_equal(data_liac_with_fixed_dtypes, data_pandas)
+
+    # Let's also check that the .frame attributes also match
+    frame_liac, frame_pandas = bunch_liac.frame, bunch_pandas.frame
+
+    # Note that the .frame attribute is a superset of the .data attribute:
+    pd.testing.assert_frame_equal(frame_pandas[bunch_pandas.feature_names], data_pandas)
+
+    # However the remaining columns, typically the target(s), are not necessarily
+    # dtyped similarly by both parsers due to limitations of the LIAC-ARFF parser.
+    # Therefore, extra dtype conversions are required for those columns:
+
+    def convert_numerical_and_categorical_dtypes(series):
+        pandas_series = frame_pandas[series.name]
+        if pd.api.types.is_numeric_dtype(pandas_series):
+            return series.astype(pandas_series.dtype)
+        elif isinstance(pandas_series.dtype, pd.CategoricalDtype):
+            # Compare categorical features by converting categorical liac uses
+            # strings to denote the categories, we rename the categories to make
+            # them comparable to the pandas parser. Fixing this behavior in
+            # LIAC-ARFF would allow to check the consistency in the future but
+            # we do not plan to maintain the LIAC-ARFF on the long term.
+            return series.cat.rename_categories(pandas_series.cat.categories)
+        else:
+            return series
+
+    frame_liac_with_fixed_dtypes = frame_liac.apply(
+        convert_numerical_and_categorical_dtypes
+    )
+    pd.testing.assert_frame_equal(frame_liac_with_fixed_dtypes, frame_pandas)
+
+
+@pytest.mark.parametrize("parser", ["liac-arff", "pandas"])
+def test_fetch_openml_equivalence_array_dataframe(monkeypatch, parser):
+    """Check the equivalence of the dataset when using `as_frame=False` and
+    `as_frame=True`.
+    """
+    pytest.importorskip("pandas")
+
+    data_id = 61
+    _monkey_patch_webbased_functions(monkeypatch, data_id, gzip_response=True)
+    bunch_as_frame_true = fetch_openml(
+        data_id=data_id,
+        as_frame=True,
+        cache=False,
+        parser=parser,
+    )
+
+    bunch_as_frame_false = fetch_openml(
+        data_id=data_id,
+        as_frame=False,
+        cache=False,
+        parser=parser,
+    )
+
+    assert_allclose(bunch_as_frame_false.data, bunch_as_frame_true.data)
+    assert_array_equal(bunch_as_frame_false.target, bunch_as_frame_true.target)
+
+
+@pytest.mark.parametrize("parser", ["liac-arff", "pandas"])
+def test_fetch_openml_iris_pandas(monkeypatch, parser):
+    """Check fetching on a numerical only dataset with string labels."""
+    pd = pytest.importorskip("pandas")
+    CategoricalDtype = pd.api.types.CategoricalDtype
+    data_id = 61
+    data_shape = (150, 4)
+    target_shape = (150,)
+    frame_shape = (150, 5)
+
+    target_dtype = CategoricalDtype(
+        ["Iris-setosa", "Iris-versicolor", "Iris-virginica"]
+    )
+    data_dtypes = [np.float64] * 4
+    data_names = ["sepallength", "sepalwidth", "petallength", "petalwidth"]
+    target_name = "class"
+
+    _monkey_patch_webbased_functions(monkeypatch, data_id, True)
+
+    bunch = fetch_openml(
+        data_id=data_id,
+        as_frame=True,
+        cache=False,
+        parser=parser,
+    )
+    data = bunch.data
+    target = bunch.target
+    frame = bunch.frame
+
+    assert isinstance(data, pd.DataFrame)
+    assert np.all(data.dtypes == data_dtypes)
+    assert data.shape == data_shape
+    assert np.all(data.columns == data_names)
+    assert np.all(bunch.feature_names == data_names)
+    assert bunch.target_names == [target_name]
+
+    assert isinstance(target, pd.Series)
+    assert target.dtype == target_dtype
+    assert target.shape == target_shape
+    assert target.name == target_name
+    assert target.index.is_unique
+
+    assert isinstance(frame, pd.DataFrame)
+    assert frame.shape == frame_shape
+    assert np.all(frame.dtypes == data_dtypes + [target_dtype])
+    assert frame.index.is_unique
+
+
+@pytest.mark.parametrize("parser", ["liac-arff", "pandas"])
+@pytest.mark.parametrize("target_column", ["petalwidth", ["petalwidth", "petallength"]])
+def test_fetch_openml_forcing_targets(monkeypatch, parser, target_column):
+    """Check that we can force the target to not be the default target."""
+    pd = pytest.importorskip("pandas")
+
+    data_id = 61
+    _monkey_patch_webbased_functions(monkeypatch, data_id, True)
+    bunch_forcing_target = fetch_openml(
+        data_id=data_id,
+        as_frame=True,
+        cache=False,
+        target_column=target_column,
+        parser=parser,
+    )
+    bunch_default = fetch_openml(
+        data_id=data_id,
+        as_frame=True,
+        cache=False,
+        parser=parser,
+    )
+
+    pd.testing.assert_frame_equal(bunch_forcing_target.frame, bunch_default.frame)
+    if isinstance(target_column, list):
+        pd.testing.assert_index_equal(
+            bunch_forcing_target.target.columns, pd.Index(target_column)
+        )
+        assert bunch_forcing_target.data.shape == (150, 3)
+    else:
+        assert bunch_forcing_target.target.name == target_column
+        assert bunch_forcing_target.data.shape == (150, 4)
+
+
+@pytest.mark.parametrize("data_id", [61, 2, 561, 40589, 1119])
+@pytest.mark.parametrize("parser", ["liac-arff", "pandas"])
+def test_fetch_openml_equivalence_frame_return_X_y(monkeypatch, data_id, parser):
+    """Check the behaviour of `return_X_y=True` when `as_frame=True`."""
+    pd = pytest.importorskip("pandas")
+
+    _monkey_patch_webbased_functions(monkeypatch, data_id, gzip_response=True)
+    bunch = fetch_openml(
+        data_id=data_id,
+        as_frame=True,
+        cache=False,
+        return_X_y=False,
+        parser=parser,
+    )
+    X, y = fetch_openml(
+        data_id=data_id,
+        as_frame=True,
+        cache=False,
+        return_X_y=True,
+        parser=parser,
+    )
+
+    pd.testing.assert_frame_equal(bunch.data, X)
+    if isinstance(y, pd.Series):
+        pd.testing.assert_series_equal(bunch.target, y)
+    else:
+        pd.testing.assert_frame_equal(bunch.target, y)
+
+
+@pytest.mark.parametrize("data_id", [61, 561, 40589, 1119])
+@pytest.mark.parametrize("parser", ["liac-arff", "pandas"])
+def test_fetch_openml_equivalence_array_return_X_y(monkeypatch, data_id, parser):
+    """Check the behaviour of `return_X_y=True` when `as_frame=False`."""
+    pytest.importorskip("pandas")
+
+    _monkey_patch_webbased_functions(monkeypatch, data_id, gzip_response=True)
+    bunch = fetch_openml(
+        data_id=data_id,
+        as_frame=False,
+        cache=False,
+        return_X_y=False,
+        parser=parser,
+    )
+    X, y = fetch_openml(
+        data_id=data_id,
+        as_frame=False,
+        cache=False,
+        return_X_y=True,
+        parser=parser,
+    )
+
+    assert_array_equal(bunch.data, X)
+    assert_array_equal(bunch.target, y)
+
+
+def test_fetch_openml_difference_parsers(monkeypatch):
+    """Check the difference between liac-arff and pandas parser."""
+    pytest.importorskip("pandas")
+
+    data_id = 1119
+    _monkey_patch_webbased_functions(monkeypatch, data_id, gzip_response=True)
+    # When `as_frame=False`, the categories will be ordinally encoded with
+    # liac-arff parser while this is not the case with pandas parser.
+    as_frame = False
+    bunch_liac_arff = fetch_openml(
+        data_id=data_id,
+        as_frame=as_frame,
+        cache=False,
+        parser="liac-arff",
+    )
+    bunch_pandas = fetch_openml(
+        data_id=data_id,
+        as_frame=as_frame,
+        cache=False,
+        parser="pandas",
+    )
+
+    assert bunch_liac_arff.data.dtype.kind == "f"
+    assert bunch_pandas.data.dtype == "O"
+
+
+###############################################################################
+# Test the ARFF parsing on several dataset to check if detect the correct
+# types (categories, integers, floats).
+
+
+@pytest.fixture(scope="module")
+def datasets_column_names():
+    """Returns the columns names for each dataset."""
+    return {
+        61: ["sepallength", "sepalwidth", "petallength", "petalwidth", "class"],
+        2: [
+            "family",
+            "product-type",
+            "steel",
+            "carbon",
+            "hardness",
+            "temper_rolling",
+            "condition",
+            "formability",
+            "strength",
+            "non-ageing",
+            "surface-finish",
+            "surface-quality",
+            "enamelability",
+            "bc",
+            "bf",
+            "bt",
+            "bw%2Fme",
+            "bl",
+            "m",
+            "chrom",
+            "phos",
+            "cbond",
+            "marvi",
+            "exptl",
+            "ferro",
+            "corr",
+            "blue%2Fbright%2Fvarn%2Fclean",
+            "lustre",
+            "jurofm",
+            "s",
+            "p",
+            "shape",
+            "thick",
+            "width",
+            "len",
+            "oil",
+            "bore",
+            "packing",
+            "class",
+        ],
+        561: ["vendor", "MYCT", "MMIN", "MMAX", "CACH", "CHMIN", "CHMAX", "class"],
+        40589: [
+            "Mean_Acc1298_Mean_Mem40_Centroid",
+            "Mean_Acc1298_Mean_Mem40_Rolloff",
+            "Mean_Acc1298_Mean_Mem40_Flux",
+            "Mean_Acc1298_Mean_Mem40_MFCC_0",
+            "Mean_Acc1298_Mean_Mem40_MFCC_1",
+            "Mean_Acc1298_Mean_Mem40_MFCC_2",
+            "Mean_Acc1298_Mean_Mem40_MFCC_3",
+            "Mean_Acc1298_Mean_Mem40_MFCC_4",
+            "Mean_Acc1298_Mean_Mem40_MFCC_5",
+            "Mean_Acc1298_Mean_Mem40_MFCC_6",
+            "Mean_Acc1298_Mean_Mem40_MFCC_7",
+            "Mean_Acc1298_Mean_Mem40_MFCC_8",
+            "Mean_Acc1298_Mean_Mem40_MFCC_9",
+            "Mean_Acc1298_Mean_Mem40_MFCC_10",
+            "Mean_Acc1298_Mean_Mem40_MFCC_11",
+            "Mean_Acc1298_Mean_Mem40_MFCC_12",
+            "Mean_Acc1298_Std_Mem40_Centroid",
+            "Mean_Acc1298_Std_Mem40_Rolloff",
+            "Mean_Acc1298_Std_Mem40_Flux",
+            "Mean_Acc1298_Std_Mem40_MFCC_0",
+            "Mean_Acc1298_Std_Mem40_MFCC_1",
+            "Mean_Acc1298_Std_Mem40_MFCC_2",
+            "Mean_Acc1298_Std_Mem40_MFCC_3",
+            "Mean_Acc1298_Std_Mem40_MFCC_4",
+            "Mean_Acc1298_Std_Mem40_MFCC_5",
+            "Mean_Acc1298_Std_Mem40_MFCC_6",
+            "Mean_Acc1298_Std_Mem40_MFCC_7",
+            "Mean_Acc1298_Std_Mem40_MFCC_8",
+            "Mean_Acc1298_Std_Mem40_MFCC_9",
+            "Mean_Acc1298_Std_Mem40_MFCC_10",
+            "Mean_Acc1298_Std_Mem40_MFCC_11",
+            "Mean_Acc1298_Std_Mem40_MFCC_12",
+            "Std_Acc1298_Mean_Mem40_Centroid",
+            "Std_Acc1298_Mean_Mem40_Rolloff",
+            "Std_Acc1298_Mean_Mem40_Flux",
+            "Std_Acc1298_Mean_Mem40_MFCC_0",
+            "Std_Acc1298_Mean_Mem40_MFCC_1",
+            "Std_Acc1298_Mean_Mem40_MFCC_2",
+            "Std_Acc1298_Mean_Mem40_MFCC_3",
+            "Std_Acc1298_Mean_Mem40_MFCC_4",
+            "Std_Acc1298_Mean_Mem40_MFCC_5",
+            "Std_Acc1298_Mean_Mem40_MFCC_6",
+            "Std_Acc1298_Mean_Mem40_MFCC_7",
+            "Std_Acc1298_Mean_Mem40_MFCC_8",
+            "Std_Acc1298_Mean_Mem40_MFCC_9",
+            "Std_Acc1298_Mean_Mem40_MFCC_10",
+            "Std_Acc1298_Mean_Mem40_MFCC_11",
+            "Std_Acc1298_Mean_Mem40_MFCC_12",
+            "Std_Acc1298_Std_Mem40_Centroid",
+            "Std_Acc1298_Std_Mem40_Rolloff",
+            "Std_Acc1298_Std_Mem40_Flux",
+            "Std_Acc1298_Std_Mem40_MFCC_0",
+            "Std_Acc1298_Std_Mem40_MFCC_1",
+            "Std_Acc1298_Std_Mem40_MFCC_2",
+            "Std_Acc1298_Std_Mem40_MFCC_3",
+            "Std_Acc1298_Std_Mem40_MFCC_4",
+            "Std_Acc1298_Std_Mem40_MFCC_5",
+            "Std_Acc1298_Std_Mem40_MFCC_6",
+            "Std_Acc1298_Std_Mem40_MFCC_7",
+            "Std_Acc1298_Std_Mem40_MFCC_8",
+            "Std_Acc1298_Std_Mem40_MFCC_9",
+            "Std_Acc1298_Std_Mem40_MFCC_10",
+            "Std_Acc1298_Std_Mem40_MFCC_11",
+            "Std_Acc1298_Std_Mem40_MFCC_12",
+            "BH_LowPeakAmp",
+            "BH_LowPeakBPM",
+            "BH_HighPeakAmp",
+            "BH_HighPeakBPM",
+            "BH_HighLowRatio",
+            "BHSUM1",
+            "BHSUM2",
+            "BHSUM3",
+            "amazed.suprised",
+            "happy.pleased",
+            "relaxing.calm",
+            "quiet.still",
+            "sad.lonely",
+            "angry.aggresive",
+        ],
+        1119: [
+            "age",
+            "workclass",
+            "fnlwgt:",
+            "education:",
+            "education-num:",
+            "marital-status:",
+            "occupation:",
+            "relationship:",
+            "race:",
+            "sex:",
+            "capital-gain:",
+            "capital-loss:",
+            "hours-per-week:",
+            "native-country:",
+            "class",
+        ],
+        40966: [
+            "DYRK1A_N",
+            "ITSN1_N",
+            "BDNF_N",
+            "NR1_N",
+            "NR2A_N",
+            "pAKT_N",
+            "pBRAF_N",
+            "pCAMKII_N",
+            "pCREB_N",
+            "pELK_N",
+            "pERK_N",
+            "pJNK_N",
+            "PKCA_N",
+            "pMEK_N",
+            "pNR1_N",
+            "pNR2A_N",
+            "pNR2B_N",
+            "pPKCAB_N",
+            "pRSK_N",
+            "AKT_N",
+            "BRAF_N",
+            "CAMKII_N",
+            "CREB_N",
+            "ELK_N",
+            "ERK_N",
+            "GSK3B_N",
+            "JNK_N",
+            "MEK_N",
+            "TRKA_N",
+            "RSK_N",
+            "APP_N",
+            "Bcatenin_N",
+            "SOD1_N",
+            "MTOR_N",
+            "P38_N",
+            "pMTOR_N",
+            "DSCR1_N",
+            "AMPKA_N",
+            "NR2B_N",
+            "pNUMB_N",
+            "RAPTOR_N",
+            "TIAM1_N",
+            "pP70S6_N",
+            "NUMB_N",
+            "P70S6_N",
+            "pGSK3B_N",
+            "pPKCG_N",
+            "CDK5_N",
+            "S6_N",
+            "ADARB1_N",
+            "AcetylH3K9_N",
+            "RRP1_N",
+            "BAX_N",
+            "ARC_N",
+            "ERBB4_N",
+            "nNOS_N",
+            "Tau_N",
+            "GFAP_N",
+            "GluR3_N",
+            "GluR4_N",
+            "IL1B_N",
+            "P3525_N",
+            "pCASP9_N",
+            "PSD95_N",
+            "SNCA_N",
+            "Ubiquitin_N",
+            "pGSK3B_Tyr216_N",
+            "SHH_N",
+            "BAD_N",
+            "BCL2_N",
+            "pS6_N",
+            "pCFOS_N",
+            "SYP_N",
+            "H3AcK18_N",
+            "EGR1_N",
+            "H3MeK4_N",
+            "CaNA_N",
+            "class",
+        ],
+        40945: [
+            "pclass",
+            "survived",
+            "name",
+            "sex",
+            "age",
+            "sibsp",
+            "parch",
+            "ticket",
+            "fare",
+            "cabin",
+            "embarked",
+            "boat",
+            "body",
+            "home.dest",
+        ],
+    }
+
+
+@pytest.fixture(scope="module")
+def datasets_missing_values():
+    return {
+        61: {},
+        2: {
+            "family": 11,
+            "temper_rolling": 9,
+            "condition": 2,
+            "formability": 4,
+            "non-ageing": 10,
+            "surface-finish": 11,
+            "enamelability": 11,
+            "bc": 11,
+            "bf": 10,
+            "bt": 11,
+            "bw%2Fme": 8,
+            "bl": 9,
+            "m": 11,
+            "chrom": 11,
+            "phos": 11,
+            "cbond": 10,
+            "marvi": 11,
+            "exptl": 11,
+            "ferro": 11,
+            "corr": 11,
+            "blue%2Fbright%2Fvarn%2Fclean": 11,
+            "lustre": 8,
+            "jurofm": 11,
+            "s": 11,
+            "p": 11,
+            "oil": 10,
+            "packing": 11,
+        },
+        561: {},
+        40589: {},
+        1119: {},
+        40966: {"BCL2_N": 7},
+        40945: {
+            "age": 263,
+            "fare": 1,
+            "cabin": 1014,
+            "embarked": 2,
+            "boat": 823,
+            "body": 1188,
+            "home.dest": 564,
+        },
+    }
+
+
+@pytest.mark.parametrize(
+    "data_id, parser, expected_n_categories, expected_n_floats, expected_n_ints",
+    [
+        # iris dataset
+        (61, "liac-arff", 1, 4, 0),
+        (61, "pandas", 1, 4, 0),
+        # anneal dataset
+        (2, "liac-arff", 33, 6, 0),
+        (2, "pandas", 33, 2, 4),
+        # cpu dataset
+        (561, "liac-arff", 1, 7, 0),
+        (561, "pandas", 1, 0, 7),
+        # emotions dataset
+        (40589, "liac-arff", 6, 72, 0),
+        (40589, "pandas", 6, 69, 3),
+        # adult-census dataset
+        (1119, "liac-arff", 9, 6, 0),
+        (1119, "pandas", 9, 0, 6),
+        # miceprotein
+        (40966, "liac-arff", 1, 77, 0),
+        (40966, "pandas", 1, 77, 0),
+        # titanic
+        (40945, "liac-arff", 3, 6, 0),
+        (40945, "pandas", 3, 3, 3),
+    ],
+)
+@pytest.mark.parametrize("gzip_response", [True, False])
+def test_fetch_openml_types_inference(
+    monkeypatch,
+    data_id,
+    parser,
+    expected_n_categories,
+    expected_n_floats,
+    expected_n_ints,
+    gzip_response,
+    datasets_column_names,
+    datasets_missing_values,
+):
+    """Check that `fetch_openml` infer the right number of categories, integers, and
+    floats."""
+    pd = pytest.importorskip("pandas")
+    CategoricalDtype = pd.api.types.CategoricalDtype
+
+    _monkey_patch_webbased_functions(monkeypatch, data_id, gzip_response=gzip_response)
+
+    bunch = fetch_openml(
+        data_id=data_id,
+        as_frame=True,
+        cache=False,
+        parser=parser,
+    )
+    frame = bunch.frame
+
+    n_categories = len(
+        [dtype for dtype in frame.dtypes if isinstance(dtype, CategoricalDtype)]
+    )
+    n_floats = len([dtype for dtype in frame.dtypes if dtype.kind == "f"])
+    n_ints = len([dtype for dtype in frame.dtypes if dtype.kind == "i"])
+
+    assert n_categories == expected_n_categories
+    assert n_floats == expected_n_floats
+    assert n_ints == expected_n_ints
+
+    assert frame.columns.tolist() == datasets_column_names[data_id]
+
+    frame_feature_to_n_nan = frame.isna().sum().to_dict()
+    for name, n_missing in frame_feature_to_n_nan.items():
+        expected_missing = datasets_missing_values[data_id].get(name, 0)
+        assert n_missing == expected_missing
+
+
+###############################################################################
+# Test some more specific behaviour
+
+
+@pytest.mark.parametrize(
+    "params, err_msg",
+    [
+        (
+            {"parser": "unknown"},
+            "The 'parser' parameter of fetch_openml must be a str among",
+        ),
+        (
+            {"as_frame": "unknown"},
+            "The 'as_frame' parameter of fetch_openml must be an instance",
+        ),
+    ],
+)
+def test_fetch_openml_validation_parameter(monkeypatch, params, err_msg):
+    data_id = 1119
+    _monkey_patch_webbased_functions(monkeypatch, data_id, True)
+    with pytest.raises(ValueError, match=err_msg):
+        fetch_openml(data_id=data_id, **params)
+
+
+@pytest.mark.parametrize(
+    "params",
+    [
+        {"as_frame": True, "parser": "auto"},
+        {"as_frame": "auto", "parser": "auto"},
+        {"as_frame": False, "parser": "pandas"},
+        {"as_frame": False, "parser": "auto"},
+    ],
+)
+def test_fetch_openml_requires_pandas_error(monkeypatch, params):
+    """Check that we raise the proper errors when we require pandas."""
+    data_id = 1119
+    try:
+        check_pandas_support("test_fetch_openml_requires_pandas")
+    except ImportError:
+        _monkey_patch_webbased_functions(monkeypatch, data_id, True)
+        err_msg = "requires pandas to be installed. Alternatively, explicitly"
+        with pytest.raises(ImportError, match=err_msg):
+            fetch_openml(data_id=data_id, **params)
+    else:
+        raise SkipTest("This test requires pandas to not be installed.")
+
+
+@pytest.mark.filterwarnings("ignore:Version 1 of dataset Australian is inactive")
+@pytest.mark.parametrize(
+    "params, err_msg",
+    [
+        (
+            {"parser": "pandas"},
+            "Sparse ARFF datasets cannot be loaded with parser='pandas'",
+        ),
+        (
+            {"as_frame": True},
+            "Sparse ARFF datasets cannot be loaded with as_frame=True.",
+        ),
+        (
+            {"parser": "pandas", "as_frame": True},
+            "Sparse ARFF datasets cannot be loaded with as_frame=True.",
+        ),
+    ],
+)
+def test_fetch_openml_sparse_arff_error(monkeypatch, params, err_msg):
+    """Check that we raise the expected error for sparse ARFF datasets and
+    a wrong set of incompatible parameters.
+    """
+    pytest.importorskip("pandas")
+    data_id = 292
+
+    _monkey_patch_webbased_functions(monkeypatch, data_id, True)
+    with pytest.raises(ValueError, match=err_msg):
+        fetch_openml(
+            data_id=data_id,
+            cache=False,
+            **params,
+        )
+
+
+@pytest.mark.filterwarnings("ignore:Version 1 of dataset Australian is inactive")
+@pytest.mark.parametrize(
+    "data_id, data_type",
+    [
+        (61, "dataframe"),  # iris dataset version 1
+        (292, "sparse"),  # Australian dataset version 1
+    ],
+)
+def test_fetch_openml_auto_mode(monkeypatch, data_id, data_type):
+    """Check the auto mode of `fetch_openml`."""
+    pd = pytest.importorskip("pandas")
+
+    _monkey_patch_webbased_functions(monkeypatch, data_id, True)
+    data = fetch_openml(data_id=data_id, as_frame="auto", cache=False)
+    klass = pd.DataFrame if data_type == "dataframe" else scipy.sparse.csr_matrix
+    assert isinstance(data.data, klass)
+
+
+def test_convert_arff_data_dataframe_warning_low_memory_pandas(monkeypatch):
+    """Check that we raise a warning regarding the working memory when using
+    LIAC-ARFF parser."""
+    pytest.importorskip("pandas")
+
+    data_id = 1119
+    _monkey_patch_webbased_functions(monkeypatch, data_id, True)
+
+    msg = "Could not adhere to working_memory config."
+    with pytest.warns(UserWarning, match=msg):
+        with config_context(working_memory=1e-6):
+            fetch_openml(
+                data_id=data_id,
+                as_frame=True,
+                cache=False,
+                parser="liac-arff",
+            )
+
+
+@pytest.mark.parametrize("gzip_response", [True, False])
+def test_fetch_openml_iris_warn_multiple_version(monkeypatch, gzip_response):
+    """Check that a warning is raised when multiple versions exist and no version is
+    requested."""
+    data_id = 61
+    data_name = "iris"
+
+    _monkey_patch_webbased_functions(monkeypatch, data_id, gzip_response)
+
+    msg = re.escape(
+        "Multiple active versions of the dataset matching the name"
+        " iris exist. Versions may be fundamentally different, "
+        "returning version 1. Available versions:\n"
+        "- version 1, status: active\n"
+        "  url: https://www.openml.org/search?type=data&id=61\n"
+        "- version 3, status: active\n"
+        "  url: https://www.openml.org/search?type=data&id=969\n"
+    )
+    with pytest.warns(UserWarning, match=msg):
+        fetch_openml(
+            name=data_name,
+            as_frame=False,
+            cache=False,
+            parser="liac-arff",
+        )
+
+
+@pytest.mark.parametrize("gzip_response", [True, False])
+def test_fetch_openml_no_target(monkeypatch, gzip_response):
+    """Check that we can get a dataset without target."""
+    data_id = 61
+    target_column = None
+    expected_observations = 150
+    expected_features = 5
+
+    _monkey_patch_webbased_functions(monkeypatch, data_id, gzip_response)
+    data = fetch_openml(
+        data_id=data_id,
+        target_column=target_column,
+        cache=False,
+        as_frame=False,
+        parser="liac-arff",
+    )
+    assert data.data.shape == (expected_observations, expected_features)
+    assert data.target is None
+
+
+@pytest.mark.parametrize("gzip_response", [True, False])
+@pytest.mark.parametrize("parser", ["liac-arff", "pandas"])
+def test_missing_values_pandas(monkeypatch, gzip_response, parser):
+    """check that missing values in categories are compatible with pandas
+    categorical"""
+    pytest.importorskip("pandas")
+
+    data_id = 42585
+    _monkey_patch_webbased_functions(monkeypatch, data_id, gzip_response=gzip_response)
+    penguins = fetch_openml(
+        data_id=data_id,
+        cache=False,
+        as_frame=True,
+        parser=parser,
+    )
+
+    cat_dtype = penguins.data.dtypes["sex"]
+    # there are nans in the categorical
+    assert penguins.data["sex"].isna().any()
+    assert_array_equal(cat_dtype.categories, ["FEMALE", "MALE", "_"])
+
+
+@pytest.mark.parametrize("gzip_response", [True, False])
+@pytest.mark.parametrize(
+    "dataset_params",
+    [
+        {"data_id": 40675},
+        {"data_id": None, "name": "glass2", "version": 1},
+    ],
+)
+def test_fetch_openml_inactive(monkeypatch, gzip_response, dataset_params):
+    """Check that we raise a warning when the dataset is inactive."""
+    data_id = 40675
+    _monkey_patch_webbased_functions(monkeypatch, data_id, gzip_response)
+    msg = "Version 1 of dataset glass2 is inactive,"
+    with pytest.warns(UserWarning, match=msg):
+        glass2 = fetch_openml(
+            cache=False, as_frame=False, parser="liac-arff", **dataset_params
+        )
+    assert glass2.data.shape == (163, 9)
+    assert glass2.details["id"] == "40675"
+
+
+@pytest.mark.parametrize("gzip_response", [True, False])
+@pytest.mark.parametrize(
+    "data_id, params, err_type, err_msg",
+    [
+        (40675, {"name": "glass2"}, ValueError, "No active dataset glass2 found"),
+        (
+            61,
+            {"data_id": 61, "target_column": ["sepalwidth", "class"]},
+            ValueError,
+            "Can only handle homogeneous multi-target datasets",
+        ),
+        (
+            40945,
+            {"data_id": 40945, "as_frame": False},
+            ValueError,
+            (
+                "STRING attributes are not supported for array representation. Try"
+                " as_frame=True"
+            ),
+        ),
+        (
+            2,
+            {"data_id": 2, "target_column": "family", "as_frame": True},
+            ValueError,
+            "Target column 'family'",
+        ),
+        (
+            2,
+            {"data_id": 2, "target_column": "family", "as_frame": False},
+            ValueError,
+            "Target column 'family'",
+        ),
+        (
+            61,
+            {"data_id": 61, "target_column": "undefined"},
+            KeyError,
+            "Could not find target_column='undefined'",
+        ),
+        (
+            61,
+            {"data_id": 61, "target_column": ["undefined", "class"]},
+            KeyError,
+            "Could not find target_column='undefined'",
+        ),
+    ],
+)
+@pytest.mark.parametrize("parser", ["liac-arff", "pandas"])
+def test_fetch_openml_error(
+    monkeypatch, gzip_response, data_id, params, err_type, err_msg, parser
+):
+    _monkey_patch_webbased_functions(monkeypatch, data_id, gzip_response)
+    if params.get("as_frame", True) or parser == "pandas":
+        pytest.importorskip("pandas")
+    with pytest.raises(err_type, match=err_msg):
+        fetch_openml(cache=False, parser=parser, **params)
+
+
+@pytest.mark.parametrize(
+    "params, err_type, err_msg",
+    [
+        (
+            {"data_id": -1, "name": None, "version": "version"},
+            ValueError,
+            "The 'version' parameter of fetch_openml must be an int in the range",
+        ),
+        (
+            {"data_id": -1, "name": "nAmE"},
+            ValueError,
+            "The 'data_id' parameter of fetch_openml must be an int in the range",
+        ),
+        (
+            {"data_id": -1, "name": "nAmE", "version": "version"},
+            ValueError,
+            "The 'version' parameter of fetch_openml must be an int",
+        ),
+        (
+            {},
+            ValueError,
+            "Neither name nor data_id are provided. Please provide name or data_id.",
+        ),
+    ],
+)
+def test_fetch_openml_raises_illegal_argument(params, err_type, err_msg):
+    with pytest.raises(err_type, match=err_msg):
+        fetch_openml(**params)
+
+
+@pytest.mark.parametrize("gzip_response", [True, False])
+def test_warn_ignore_attribute(monkeypatch, gzip_response):
+    data_id = 40966
+    expected_row_id_msg = "target_column='{}' has flag is_row_identifier."
+    expected_ignore_msg = "target_column='{}' has flag is_ignore."
+    _monkey_patch_webbased_functions(monkeypatch, data_id, gzip_response)
+    # single column test
+    target_col = "MouseID"
+    msg = expected_row_id_msg.format(target_col)
+    with pytest.warns(UserWarning, match=msg):
+        fetch_openml(
+            data_id=data_id,
+            target_column=target_col,
+            cache=False,
+            as_frame=False,
+            parser="liac-arff",
+        )
+    target_col = "Genotype"
+    msg = expected_ignore_msg.format(target_col)
+    with pytest.warns(UserWarning, match=msg):
+        fetch_openml(
+            data_id=data_id,
+            target_column=target_col,
+            cache=False,
+            as_frame=False,
+            parser="liac-arff",
+        )
+    # multi column test
+    target_col = "MouseID"
+    msg = expected_row_id_msg.format(target_col)
+    with pytest.warns(UserWarning, match=msg):
+        fetch_openml(
+            data_id=data_id,
+            target_column=[target_col, "class"],
+            cache=False,
+            as_frame=False,
+            parser="liac-arff",
+        )
+    target_col = "Genotype"
+    msg = expected_ignore_msg.format(target_col)
+    with pytest.warns(UserWarning, match=msg):
+        fetch_openml(
+            data_id=data_id,
+            target_column=[target_col, "class"],
+            cache=False,
+            as_frame=False,
+            parser="liac-arff",
+        )
+
+
+@pytest.mark.parametrize("gzip_response", [True, False])
+def test_dataset_with_openml_error(monkeypatch, gzip_response):
+    data_id = 1
+    _monkey_patch_webbased_functions(monkeypatch, data_id, gzip_response)
+    msg = "OpenML registered a problem with the dataset. It might be unusable. Error:"
+    with pytest.warns(UserWarning, match=msg):
+        fetch_openml(data_id=data_id, cache=False, as_frame=False, parser="liac-arff")
+
+
+@pytest.mark.parametrize("gzip_response", [True, False])
+def test_dataset_with_openml_warning(monkeypatch, gzip_response):
+    data_id = 3
+    _monkey_patch_webbased_functions(monkeypatch, data_id, gzip_response)
+    msg = "OpenML raised a warning on the dataset. It might be unusable. Warning:"
+    with pytest.warns(UserWarning, match=msg):
+        fetch_openml(data_id=data_id, cache=False, as_frame=False, parser="liac-arff")
+
+
+def test_fetch_openml_overwrite_default_params_read_csv(monkeypatch):
+    """Check that we can overwrite the default parameters of `read_csv`."""
+    pytest.importorskip("pandas")
+    data_id = 1590
+    _monkey_patch_webbased_functions(monkeypatch, data_id=data_id, gzip_response=False)
+
+    common_params = {
+        "data_id": data_id,
+        "as_frame": True,
+        "cache": False,
+        "parser": "pandas",
+    }
+
+    # By default, the initial spaces are skipped. We checked that setting the parameter
+    # `skipinitialspace` to False will have an effect.
+    adult_without_spaces = fetch_openml(**common_params)
+    adult_with_spaces = fetch_openml(
+        **common_params, read_csv_kwargs={"skipinitialspace": False}
+    )
+    assert all(
+        cat.startswith(" ") for cat in adult_with_spaces.frame["class"].cat.categories
+    )
+    assert not any(
+        cat.startswith(" ")
+        for cat in adult_without_spaces.frame["class"].cat.categories
+    )
+
+
+###############################################################################
+# Test cache, retry mechanisms, checksum, etc.
+
+
+@pytest.mark.parametrize("gzip_response", [True, False])
+def test_open_openml_url_cache(monkeypatch, gzip_response, tmpdir):
+    data_id = 61
+
+    _monkey_patch_webbased_functions(monkeypatch, data_id, gzip_response)
+    openml_path = _MONKEY_PATCH_LOCAL_OPENML_PATH.format(data_id) + "/filename.arff"
+    url = f"https://www.openml.org/{openml_path}"
+    cache_directory = str(tmpdir.mkdir("scikit_learn_data"))
+    # first fill the cache
+    response1 = _open_openml_url(url, cache_directory)
+    # assert file exists
+    location = _get_local_path(openml_path, cache_directory)
+    assert os.path.isfile(location)
+    # redownload, to utilize cache
+    response2 = _open_openml_url(url, cache_directory)
+    assert response1.read() == response2.read()
+
+
+@pytest.mark.parametrize("write_to_disk", [True, False])
+def test_open_openml_url_unlinks_local_path(monkeypatch, tmpdir, write_to_disk):
+    data_id = 61
+    openml_path = _MONKEY_PATCH_LOCAL_OPENML_PATH.format(data_id) + "/filename.arff"
+    url = f"https://www.openml.org/{openml_path}"
+    cache_directory = str(tmpdir.mkdir("scikit_learn_data"))
+    location = _get_local_path(openml_path, cache_directory)
+
+    def _mock_urlopen(request, *args, **kwargs):
+        if write_to_disk:
+            with open(location, "w") as f:
+                f.write("")
+        raise ValueError("Invalid request")
+
+    monkeypatch.setattr(sklearn.datasets._openml, "urlopen", _mock_urlopen)
+
+    with pytest.raises(ValueError, match="Invalid request"):
+        _open_openml_url(url, cache_directory)
+
+    assert not os.path.exists(location)
+
+
+def test_retry_with_clean_cache(tmpdir):
+    data_id = 61
+    openml_path = _MONKEY_PATCH_LOCAL_OPENML_PATH.format(data_id)
+    cache_directory = str(tmpdir.mkdir("scikit_learn_data"))
+    location = _get_local_path(openml_path, cache_directory)
+    os.makedirs(os.path.dirname(location))
+
+    with open(location, "w") as f:
+        f.write("")
+
+    @_retry_with_clean_cache(openml_path, cache_directory)
+    def _load_data():
+        # The first call will raise an error since location exists
+        if os.path.exists(location):
+            raise Exception("File exist!")
+        return 1
+
+    warn_msg = "Invalid cache, redownloading file"
+    with pytest.warns(RuntimeWarning, match=warn_msg):
+        result = _load_data()
+    assert result == 1
+
+
+def test_retry_with_clean_cache_http_error(tmpdir):
+    data_id = 61
+    openml_path = _MONKEY_PATCH_LOCAL_OPENML_PATH.format(data_id)
+    cache_directory = str(tmpdir.mkdir("scikit_learn_data"))
+
+    @_retry_with_clean_cache(openml_path, cache_directory)
+    def _load_data():
+        raise HTTPError(
+            url=None, code=412, msg="Simulated mock error", hdrs=None, fp=BytesIO()
+        )
+
+    error_msg = "Simulated mock error"
+    with pytest.raises(HTTPError, match=error_msg):
+        _load_data()
+
+
+@pytest.mark.parametrize("gzip_response", [True, False])
+def test_fetch_openml_cache(monkeypatch, gzip_response, tmpdir):
+    def _mock_urlopen_raise(request, *args, **kwargs):
+        raise ValueError(
+            "This mechanism intends to test correct cache"
+            "handling. As such, urlopen should never be "
+            "accessed. URL: %s" % request.get_full_url()
+        )
+
+    data_id = 61
+    cache_directory = str(tmpdir.mkdir("scikit_learn_data"))
+    _monkey_patch_webbased_functions(monkeypatch, data_id, gzip_response)
+    X_fetched, y_fetched = fetch_openml(
+        data_id=data_id,
+        cache=True,
+        data_home=cache_directory,
+        return_X_y=True,
+        as_frame=False,
+        parser="liac-arff",
+    )
+
+    monkeypatch.setattr(sklearn.datasets._openml, "urlopen", _mock_urlopen_raise)
+
+    X_cached, y_cached = fetch_openml(
+        data_id=data_id,
+        cache=True,
+        data_home=cache_directory,
+        return_X_y=True,
+        as_frame=False,
+        parser="liac-arff",
+    )
+    np.testing.assert_array_equal(X_fetched, X_cached)
+    np.testing.assert_array_equal(y_fetched, y_cached)
+
+
+@pytest.mark.parametrize(
+    "as_frame, parser",
+    [
+        (True, "liac-arff"),
+        (False, "liac-arff"),
+        (True, "pandas"),
+        (False, "pandas"),
+    ],
+)
+def test_fetch_openml_verify_checksum(monkeypatch, as_frame, tmpdir, parser):
+    """Check that the checksum is working as expected."""
+    if as_frame or parser == "pandas":
+        pytest.importorskip("pandas")
+
+    data_id = 2
+    _monkey_patch_webbased_functions(monkeypatch, data_id, True)
+
+    # create a temporary modified arff file
+    original_data_module = OPENML_TEST_DATA_MODULE + "." + f"id_{data_id}"
+    original_data_file_name = "data-v1-dl-1666876.arff.gz"
+    original_data_path = resources.files(original_data_module) / original_data_file_name
+    corrupt_copy_path = tmpdir / "test_invalid_checksum.arff"
+    with original_data_path.open("rb") as orig_file:
+        orig_gzip = gzip.open(orig_file, "rb")
+        data = bytearray(orig_gzip.read())
+        data[len(data) - 1] = 37
+
+    with gzip.GzipFile(corrupt_copy_path, "wb") as modified_gzip:
+        modified_gzip.write(data)
+
+    # Requests are already mocked by monkey_patch_webbased_functions.
+    # We want to reuse that mock for all requests except file download,
+    # hence creating a thin mock over the original mock
+    mocked_openml_url = sklearn.datasets._openml.urlopen
+
+    def swap_file_mock(request, *args, **kwargs):
+        url = request.get_full_url()
+        if url.endswith("data/v1/download/1666876/anneal.arff"):
+            with open(corrupt_copy_path, "rb") as f:
+                corrupted_data = f.read()
+            return _MockHTTPResponse(BytesIO(corrupted_data), is_gzip=True)
+        else:
+            return mocked_openml_url(request)
+
+    monkeypatch.setattr(sklearn.datasets._openml, "urlopen", swap_file_mock)
+
+    # validate failed checksum
+    with pytest.raises(ValueError) as exc:
+        sklearn.datasets.fetch_openml(
+            data_id=data_id, cache=False, as_frame=as_frame, parser=parser
+        )
+    # exception message should have file-path
+    assert exc.match("1666876")
+
+
+def test_open_openml_url_retry_on_network_error(monkeypatch):
+    def _mock_urlopen_network_error(request, *args, **kwargs):
+        raise HTTPError(
+            url=None, code=404, msg="Simulated network error", hdrs=None, fp=BytesIO()
+        )
+
+    monkeypatch.setattr(
+        sklearn.datasets._openml, "urlopen", _mock_urlopen_network_error
+    )
+
+    invalid_openml_url = "https://api.openml.org/invalid-url"
+
+    with pytest.warns(
+        UserWarning,
+        match=re.escape(
+            "A network error occurred while downloading"
+            f" {invalid_openml_url}. Retrying..."
+        ),
+    ) as record:
+        with pytest.raises(HTTPError, match="Simulated network error") as exc_info:
+            _open_openml_url(invalid_openml_url, None, delay=0)
+        assert len(record) == 3
+        # Avoid a ResourceWarning on Python 3.14 and later.
+        exc_info.value.close()
+
+
+###############################################################################
+# Non-regressiont tests
+
+
+@pytest.mark.parametrize("gzip_response", [True, False])
+@pytest.mark.parametrize("parser", ("liac-arff", "pandas"))
+def test_fetch_openml_with_ignored_feature(monkeypatch, gzip_response, parser):
+    """Check that we can load the "zoo" dataset.
+    Non-regression test for:
+    https://github.com/scikit-learn/scikit-learn/issues/14340
+    """
+    if parser == "pandas":
+        pytest.importorskip("pandas")
+    data_id = 62
+    _monkey_patch_webbased_functions(monkeypatch, data_id, gzip_response)
+
+    dataset = sklearn.datasets.fetch_openml(
+        data_id=data_id, cache=False, as_frame=False, parser=parser
+    )
+    assert dataset is not None
+    # The dataset has 17 features, including 1 ignored (animal),
+    # so we assert that we don't have the ignored feature in the final Bunch
+    assert dataset["data"].shape == (101, 16)
+    assert "animal" not in dataset["feature_names"]
+
+
+def test_fetch_openml_strip_quotes(monkeypatch):
+    """Check that we strip the single quotes when used as a string delimiter.
+
+    Non-regression test for:
+    https://github.com/scikit-learn/scikit-learn/issues/23381
+    """
+    pd = pytest.importorskip("pandas")
+    data_id = 40966
+    _monkey_patch_webbased_functions(monkeypatch, data_id=data_id, gzip_response=False)
+
+    common_params = {"as_frame": True, "cache": False, "data_id": data_id}
+    mice_pandas = fetch_openml(parser="pandas", **common_params)
+    mice_liac_arff = fetch_openml(parser="liac-arff", **common_params)
+    pd.testing.assert_series_equal(mice_pandas.target, mice_liac_arff.target)
+    assert not mice_pandas.target.str.startswith("'").any()
+    assert not mice_pandas.target.str.endswith("'").any()
+
+    # similar behaviour should be observed when the column is not the target
+    mice_pandas = fetch_openml(parser="pandas", target_column="NUMB_N", **common_params)
+    mice_liac_arff = fetch_openml(
+        parser="liac-arff", target_column="NUMB_N", **common_params
+    )
+    pd.testing.assert_series_equal(
+        mice_pandas.frame["class"], mice_liac_arff.frame["class"]
+    )
+    assert not mice_pandas.frame["class"].str.startswith("'").any()
+    assert not mice_pandas.frame["class"].str.endswith("'").any()
+
+
+def test_fetch_openml_leading_whitespace(monkeypatch):
+    """Check that we can strip leading whitespace in pandas parser.
+
+    Non-regression test for:
+    https://github.com/scikit-learn/scikit-learn/issues/25311
+    """
+    pd = pytest.importorskip("pandas")
+    data_id = 1590
+    _monkey_patch_webbased_functions(monkeypatch, data_id=data_id, gzip_response=False)
+
+    common_params = {"as_frame": True, "cache": False, "data_id": data_id}
+    adult_pandas = fetch_openml(parser="pandas", **common_params)
+    adult_liac_arff = fetch_openml(parser="liac-arff", **common_params)
+    pd.testing.assert_series_equal(
+        adult_pandas.frame["class"], adult_liac_arff.frame["class"]
+    )
+
+
+def test_fetch_openml_quotechar_escapechar(monkeypatch):
+    """Check that we can handle escapechar and single/double quotechar.
+
+    Non-regression test for:
+    https://github.com/scikit-learn/scikit-learn/issues/25478
+    """
+    pd = pytest.importorskip("pandas")
+    data_id = 42074
+    _monkey_patch_webbased_functions(monkeypatch, data_id=data_id, gzip_response=False)
+
+    common_params = {"as_frame": True, "cache": False, "data_id": data_id}
+    adult_pandas = fetch_openml(parser="pandas", **common_params)
+    adult_liac_arff = fetch_openml(parser="liac-arff", **common_params)
+    pd.testing.assert_frame_equal(adult_pandas.frame, adult_liac_arff.frame)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sklearn/datasets/tests/test_rcv1.py

@@ -0,0 +1,71 @@
+"""Test the rcv1 loader, if the data is available,
+or if specifically requested via environment variable
+(e.g. for CI jobs)."""
+
+from functools import partial
+
+import numpy as np
+import scipy.sparse as sp
+
+from sklearn.datasets.tests.test_common import check_return_X_y
+from sklearn.utils._testing import assert_almost_equal, assert_array_equal
+
+
+def test_fetch_rcv1(fetch_rcv1_fxt, global_random_seed):
+    data1 = fetch_rcv1_fxt(shuffle=False)
+    X1, Y1 = data1.data, data1.target
+    cat_list, s1 = data1.target_names.tolist(), data1.sample_id
+
+    # test sparsity
+    assert sp.issparse(X1)
+    assert sp.issparse(Y1)
+    assert 60915113 == X1.data.size
+    assert 2606875 == Y1.data.size
+
+    # test shapes
+    assert (804414, 47236) == X1.shape
+    assert (804414, 103) == Y1.shape
+    assert (804414,) == s1.shape
+    assert 103 == len(cat_list)
+
+    # test descr
+    assert data1.DESCR.startswith(".. _rcv1_dataset:")
+
+    # test ordering of categories
+    first_categories = ["C11", "C12", "C13", "C14", "C15", "C151"]
+    assert_array_equal(first_categories, cat_list[:6])
+
+    # test number of sample for some categories
+    some_categories = ("GMIL", "E143", "CCAT")
+    number_non_zero_in_cat = (5, 1206, 381327)
+    for num, cat in zip(number_non_zero_in_cat, some_categories):
+        j = cat_list.index(cat)
+        assert num == Y1[:, j].data.size
+
+    # test shuffling and subset
+    data2 = fetch_rcv1_fxt(
+        shuffle=True, subset="train", random_state=global_random_seed
+    )
+    X2, Y2 = data2.data, data2.target
+    s2 = data2.sample_id
+
+    # test return_X_y option
+    fetch_func = partial(fetch_rcv1_fxt, shuffle=False, subset="train")
+    check_return_X_y(data2, fetch_func)
+
+    # The first 23149 samples are the training samples
+    assert_array_equal(np.sort(s1[:23149]), np.sort(s2))
+
+    # test some precise values
+    some_sample_ids = (2286, 3274, 14042)
+    for sample_id in some_sample_ids:
+        idx1 = s1.tolist().index(sample_id)
+        idx2 = s2.tolist().index(sample_id)
+
+        feature_values_1 = X1[idx1, :].toarray()
+        feature_values_2 = X2[idx2, :].toarray()
+        assert_almost_equal(feature_values_1, feature_values_2)
+
+        target_values_1 = Y1[idx1, :].toarray()
+        target_values_2 = Y2[idx2, :].toarray()
+        assert_almost_equal(target_values_1, target_values_2)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sklearn/datasets/tests/test_samples_generator.py

@@ -0,0 +1,744 @@
+import re
+from collections import defaultdict
+from functools import partial
+
+import numpy as np
+import pytest
+import scipy.sparse as sp
+
+from sklearn.datasets import (
+    make_biclusters,
+    make_blobs,
+    make_checkerboard,
+    make_circles,
+    make_classification,
+    make_friedman1,
+    make_friedman2,
+    make_friedman3,
+    make_hastie_10_2,
+    make_low_rank_matrix,
+    make_moons,
+    make_multilabel_classification,
+    make_regression,
+    make_s_curve,
+    make_sparse_coded_signal,
+    make_sparse_spd_matrix,
+    make_sparse_uncorrelated,
+    make_spd_matrix,
+    make_swiss_roll,
+)
+from sklearn.utils._testing import (
+    assert_allclose,
+    assert_allclose_dense_sparse,
+    assert_almost_equal,
+    assert_array_almost_equal,
+    assert_array_equal,
+)
+from sklearn.utils.validation import assert_all_finite
+
+
+def test_make_classification():
+    weights = [0.1, 0.25]
+    X, y = make_classification(
+        n_samples=100,
+        n_features=20,
+        n_informative=5,
+        n_redundant=1,
+        n_repeated=1,
+        n_classes=3,
+        n_clusters_per_class=1,
+        hypercube=False,
+        shift=None,
+        scale=None,
+        weights=weights,
+        random_state=0,
+    )
+
+    assert weights == [0.1, 0.25]
+    assert X.shape == (100, 20), "X shape mismatch"
+    assert y.shape == (100,), "y shape mismatch"
+    assert np.unique(y).shape == (3,), "Unexpected number of classes"
+    assert sum(y == 0) == 10, "Unexpected number of samples in class #0"
+    assert sum(y == 1) == 25, "Unexpected number of samples in class #1"
+    assert sum(y == 2) == 65, "Unexpected number of samples in class #2"
+
+    # Test for n_features > 30
+    X, y = make_classification(
+        n_samples=2000,
+        n_features=31,
+        n_informative=31,
+        n_redundant=0,
+        n_repeated=0,
+        hypercube=True,
+        scale=0.5,
+        random_state=0,
+    )
+
+    assert X.shape == (2000, 31), "X shape mismatch"
+    assert y.shape == (2000,), "y shape mismatch"
+    assert (
+        np.unique(X.view([("", X.dtype)] * X.shape[1]))
+        .view(X.dtype)
+        .reshape(-1, X.shape[1])
+        .shape[0]
+        == 2000
+    ), "Unexpected number of unique rows"
+
+
+def test_make_classification_informative_features():
+    """Test the construction of informative features in make_classification
+
+    Also tests `n_clusters_per_class`, `n_classes`, `hypercube` and
+    fully-specified `weights`.
+    """
+    # Create very separate clusters; check that vertices are unique and
+    # correspond to classes
+    class_sep = 1e6
+    make = partial(
+        make_classification,
+        class_sep=class_sep,
+        n_redundant=0,
+        n_repeated=0,
+        flip_y=0,
+        shift=0,
+        scale=1,
+        shuffle=False,
+    )
+
+    for n_informative, weights, n_clusters_per_class in [
+        (2, [1], 1),
+        (2, [1 / 3] * 3, 1),
+        (2, [1 / 4] * 4, 1),
+        (2, [1 / 2] * 2, 2),
+        (2, [3 / 4, 1 / 4], 2),
+        (10, [1 / 3] * 3, 10),
+        (64, [1], 1),
+    ]:
+        n_classes = len(weights)
+        n_clusters = n_classes * n_clusters_per_class
+        n_samples = n_clusters * 50
+
+        for hypercube in (False, True):
+            X, y = make(
+                n_samples=n_samples,
+                n_classes=n_classes,
+                weights=weights,
+                n_features=n_informative,
+                n_informative=n_informative,
+                n_clusters_per_class=n_clusters_per_class,
+                hypercube=hypercube,
+                random_state=0,
+            )
+
+            assert X.shape == (n_samples, n_informative)
+            assert y.shape == (n_samples,)
+
+            # Cluster by sign, viewed as strings to allow uniquing
+            signs = np.sign(X)
+            signs = signs.view(dtype="|S{0}".format(signs.strides[0])).ravel()
+            unique_signs, cluster_index = np.unique(signs, return_inverse=True)
+
+            assert len(unique_signs) == n_clusters, (
+                "Wrong number of clusters, or not in distinct quadrants"
+            )
+
+            clusters_by_class = defaultdict(set)
+            for cluster, cls in zip(cluster_index, y):
+                clusters_by_class[cls].add(cluster)
+            for clusters in clusters_by_class.values():
+                assert len(clusters) == n_clusters_per_class, (
+                    "Wrong number of clusters per class"
+                )
+            assert len(clusters_by_class) == n_classes, "Wrong number of classes"
+
+            assert_array_almost_equal(
+                np.bincount(y) / len(y) // weights,
+                [1] * n_classes,
+                err_msg="Wrong number of samples per class",
+            )
+
+            # Ensure on vertices of hypercube
+            for cluster in range(len(unique_signs)):
+                centroid = X[cluster_index == cluster].mean(axis=0)
+                if hypercube:
+                    assert_array_almost_equal(
+                        np.abs(centroid) / class_sep,
+                        np.ones(n_informative),
+                        decimal=5,
+                        err_msg="Clusters are not centered on hypercube vertices",
+                    )
+                else:
+                    with pytest.raises(AssertionError):
+                        assert_array_almost_equal(
+                            np.abs(centroid) / class_sep,
+                            np.ones(n_informative),
+                            decimal=5,
+                            err_msg=(
+                                "Clusters should not be centered on hypercube vertices"
+                            ),
+                        )
+
+    with pytest.raises(ValueError):
+        make(n_features=2, n_informative=2, n_classes=5, n_clusters_per_class=1)
+    with pytest.raises(ValueError):
+        make(n_features=2, n_informative=2, n_classes=3, n_clusters_per_class=2)
+
+
+def test_make_classification_return_x_y():
+    """
+    Test that make_classification returns a Bunch when return_X_y is False.
+
+    Also that bunch.X is the same as X
+    """
+
+    kwargs = {
+        "n_samples": 100,
+        "n_features": 20,
+        "n_informative": 5,
+        "n_redundant": 1,
+        "n_repeated": 1,
+        "n_classes": 3,
+        "n_clusters_per_class": 2,
+        "weights": None,
+        "flip_y": 0.01,
+        "class_sep": 1.0,
+        "hypercube": True,
+        "shift": 0.0,
+        "scale": 1.0,
+        "shuffle": True,
+        "random_state": 42,
+        "return_X_y": True,
+    }
+
+    X, y = make_classification(**kwargs)
+
+    kwargs["return_X_y"] = False
+    bunch = make_classification(**kwargs)
+
+    assert (
+        hasattr(bunch, "DESCR")
+        and hasattr(bunch, "parameters")
+        and hasattr(bunch, "feature_info")
+        and hasattr(bunch, "X")
+        and hasattr(bunch, "y")
+    )
+
+    def count(str_):
+        return bunch.feature_info.count(str_)
+
+    assert np.array_equal(X, bunch.X)
+    assert np.array_equal(y, bunch.y)
+    assert bunch.DESCR == make_classification.__doc__
+    assert bunch.parameters == kwargs
+    assert count("informative") == kwargs["n_informative"]
+    assert count("redundant") == kwargs["n_redundant"]
+    assert count("repeated") == kwargs["n_repeated"]
+
+
+@pytest.mark.parametrize(
+    "weights, err_type, err_msg",
+    [
+        ([], ValueError, "Weights specified but incompatible with number of classes."),
+        (
+            [0.25, 0.75, 0.1],
+            ValueError,
+            "Weights specified but incompatible with number of classes.",
+        ),
+        (
+            np.array([]),
+            ValueError,
+            "Weights specified but incompatible with number of classes.",
+        ),
+        (
+            np.array([0.25, 0.75, 0.1]),
+            ValueError,
+            "Weights specified but incompatible with number of classes.",
+        ),
+        (
+            np.random.random(3),
+            ValueError,
+            "Weights specified but incompatible with number of classes.",
+        ),
+    ],
+)
+def test_make_classification_weights_type(weights, err_type, err_msg):
+    with pytest.raises(err_type, match=err_msg):
+        make_classification(weights=weights)
+
+
+@pytest.mark.parametrize("kwargs", [{}, {"n_classes": 3, "n_informative": 3}])
+def test_make_classification_weights_array_or_list_ok(kwargs):
+    X1, y1 = make_classification(weights=[0.1, 0.9], random_state=0, **kwargs)
+    X2, y2 = make_classification(weights=np.array([0.1, 0.9]), random_state=0, **kwargs)
+    assert_almost_equal(X1, X2)
+    assert_almost_equal(y1, y2)
+
+
+def test_make_multilabel_classification_return_sequences():
+    for allow_unlabeled, min_length in zip((True, False), (0, 1)):
+        X, Y = make_multilabel_classification(
+            n_samples=100,
+            n_features=20,
+            n_classes=3,
+            random_state=0,
+            return_indicator=False,
+            allow_unlabeled=allow_unlabeled,
+        )
+        assert X.shape == (100, 20), "X shape mismatch"
+        if not allow_unlabeled:
+            assert max([max(y) for y in Y]) == 2
+        assert min([len(y) for y in Y]) == min_length
+        assert max([len(y) for y in Y]) <= 3
+
+
+def test_make_multilabel_classification_return_indicator():
+    for allow_unlabeled, min_length in zip((True, False), (0, 1)):
+        X, Y = make_multilabel_classification(
+            n_samples=25,
+            n_features=20,
+            n_classes=3,
+            random_state=0,
+            allow_unlabeled=allow_unlabeled,
+        )
+        assert X.shape == (25, 20), "X shape mismatch"
+        assert Y.shape == (25, 3), "Y shape mismatch"
+        assert np.all(np.sum(Y, axis=0) > min_length)
+
+    # Also test return_distributions and return_indicator with True
+    X2, Y2, p_c, p_w_c = make_multilabel_classification(
+        n_samples=25,
+        n_features=20,
+        n_classes=3,
+        random_state=0,
+        allow_unlabeled=allow_unlabeled,
+        return_distributions=True,
+    )
+
+    assert_array_almost_equal(X, X2)
+    assert_array_equal(Y, Y2)
+    assert p_c.shape == (3,)
+    assert_almost_equal(p_c.sum(), 1)
+    assert p_w_c.shape == (20, 3)
+    assert_almost_equal(p_w_c.sum(axis=0), [1] * 3)
+
+
+def test_make_multilabel_classification_return_indicator_sparse():
+    for allow_unlabeled, min_length in zip((True, False), (0, 1)):
+        X, Y = make_multilabel_classification(
+            n_samples=25,
+            n_features=20,
+            n_classes=3,
+            random_state=0,
+            return_indicator="sparse",
+            allow_unlabeled=allow_unlabeled,
+        )
+        assert X.shape == (25, 20), "X shape mismatch"
+        assert Y.shape == (25, 3), "Y shape mismatch"
+        assert sp.issparse(Y)
+
+
+def test_make_hastie_10_2():
+    X, y = make_hastie_10_2(n_samples=100, random_state=0)
+    assert X.shape == (100, 10), "X shape mismatch"
+    assert y.shape == (100,), "y shape mismatch"
+    assert np.unique(y).shape == (2,), "Unexpected number of classes"
+
+
+def test_make_regression(global_random_seed):
+    X, y, c = make_regression(
+        n_samples=200,
+        n_features=10,
+        n_informative=3,
+        effective_rank=5,
+        coef=True,
+        bias=0.0,
+        noise=1.0,
+        random_state=global_random_seed,
+    )
+
+    assert X.shape == (200, 10), "X shape mismatch"
+    assert y.shape == (200,), "y shape mismatch"
+    assert c.shape == (10,), "coef shape mismatch"
+    assert sum(c != 0.0) == 3, "Unexpected number of informative features"
+
+    # Test that y ~= np.dot(X, c) + bias + N(0, 1.0).
+    assert_almost_equal(np.std(y - np.dot(X, c)), 1.0, decimal=1)
+
+    # Test with small number of features.
+    X, y = make_regression(n_samples=100, n_features=1)  # n_informative=3
+    assert X.shape == (100, 1)
+
+
+def test_make_regression_multitarget(global_random_seed):
+    X, y, c = make_regression(
+        n_samples=100,
+        n_features=10,
+        n_informative=3,
+        n_targets=3,
+        coef=True,
+        noise=1.0,
+        random_state=global_random_seed,
+    )
+
+    assert X.shape == (100, 10), "X shape mismatch"
+    assert y.shape == (100, 3), "y shape mismatch"
+    assert c.shape == (10, 3), "coef shape mismatch"
+    assert_array_equal(sum(c != 0.0), 3, "Unexpected number of informative features")
+
+    # Test that y ~= np.dot(X, c) + bias + N(0, 1.0)
+    assert_almost_equal(np.std(y - np.dot(X, c)), 1.0, decimal=1)
+
+
+def test_make_blobs(global_random_seed):
+    cluster_stds = np.array([0.05, 0.2, 0.4])
+    cluster_centers = np.array([[0.0, 0.0], [1.0, 1.0], [0.0, 1.0]])
+    X, y = make_blobs(
+        random_state=global_random_seed,
+        n_samples=50,
+        n_features=2,
+        centers=cluster_centers,
+        cluster_std=cluster_stds,
+    )
+
+    assert X.shape == (50, 2), "X shape mismatch"
+    assert y.shape == (50,), "y shape mismatch"
+    assert np.unique(y).shape == (3,), "Unexpected number of blobs"
+    for i, (ctr, std) in enumerate(zip(cluster_centers, cluster_stds)):
+        assert_almost_equal((X[y == i] - ctr).std(), std, 1, "Unexpected std")
+
+
+def test_make_blobs_n_samples_list():
+    n_samples = [50, 30, 20]
+    X, y = make_blobs(n_samples=n_samples, n_features=2, random_state=0)
+
+    assert X.shape == (sum(n_samples), 2), "X shape mismatch"
+    assert all(np.bincount(y, minlength=len(n_samples)) == n_samples), (
+        "Incorrect number of samples per blob"
+    )
+
+
+def test_make_blobs_n_samples_list_with_centers(global_random_seed):
+    n_samples = [20, 20, 20]
+    centers = np.array([[0.0, 0.0], [1.0, 1.0], [0.0, 1.0]])
+    cluster_stds = np.array([0.05, 0.2, 0.4])
+    X, y = make_blobs(
+        n_samples=n_samples,
+        centers=centers,
+        cluster_std=cluster_stds,
+        random_state=global_random_seed,
+    )
+
+    assert X.shape == (sum(n_samples), 2), "X shape mismatch"
+    assert all(np.bincount(y, minlength=len(n_samples)) == n_samples), (
+        "Incorrect number of samples per blob"
+    )
+    for i, (ctr, std) in enumerate(zip(centers, cluster_stds)):
+        assert_almost_equal((X[y == i] - ctr).std(), std, 1, "Unexpected std")
+
+
+@pytest.mark.parametrize(
+    "n_samples", [[5, 3, 0], np.array([5, 3, 0]), tuple([5, 3, 0])]
+)
+def test_make_blobs_n_samples_centers_none(n_samples):
+    centers = None
+    X, y = make_blobs(n_samples=n_samples, centers=centers, random_state=0)
+
+    assert X.shape == (sum(n_samples), 2), "X shape mismatch"
+    assert all(np.bincount(y, minlength=len(n_samples)) == n_samples), (
+        "Incorrect number of samples per blob"
+    )
+
+
+def test_make_blobs_return_centers():
+    n_samples = [10, 20]
+    n_features = 3
+    X, y, centers = make_blobs(
+        n_samples=n_samples, n_features=n_features, return_centers=True, random_state=0
+    )
+
+    assert centers.shape == (len(n_samples), n_features)
+
+
+def test_make_blobs_error():
+    n_samples = [20, 20, 20]
+    centers = np.array([[0.0, 0.0], [1.0, 1.0], [0.0, 1.0]])
+    cluster_stds = np.array([0.05, 0.2, 0.4])
+    wrong_centers_msg = re.escape(
+        "Length of `n_samples` not consistent with number of centers. "
+        f"Got n_samples = {n_samples} and centers = {centers[:-1]}"
+    )
+    with pytest.raises(ValueError, match=wrong_centers_msg):
+        make_blobs(n_samples, centers=centers[:-1])
+    wrong_std_msg = re.escape(
+        "Length of `clusters_std` not consistent with number of centers. "
+        f"Got centers = {centers} and cluster_std = {cluster_stds[:-1]}"
+    )
+    with pytest.raises(ValueError, match=wrong_std_msg):
+        make_blobs(n_samples, centers=centers, cluster_std=cluster_stds[:-1])
+    wrong_type_msg = "Parameter `centers` must be array-like. Got {!r} instead".format(
+        3
+    )
+    with pytest.raises(ValueError, match=wrong_type_msg):
+        make_blobs(n_samples, centers=3)
+
+
+def test_make_friedman1(global_random_seed):
+    X, y = make_friedman1(
+        n_samples=5, n_features=10, noise=0.0, random_state=global_random_seed
+    )
+
+    assert X.shape == (5, 10), "X shape mismatch"
+    assert y.shape == (5,), "y shape mismatch"
+
+    assert_array_almost_equal(
+        y,
+        10 * np.sin(np.pi * X[:, 0] * X[:, 1])
+        + 20 * (X[:, 2] - 0.5) ** 2
+        + 10 * X[:, 3]
+        + 5 * X[:, 4],
+    )
+
+
+def test_make_friedman2(global_random_seed):
+    X, y = make_friedman2(n_samples=5, noise=0.0, random_state=global_random_seed)
+
+    assert X.shape == (5, 4), "X shape mismatch"
+    assert y.shape == (5,), "y shape mismatch"
+
+    assert_array_almost_equal(
+        y, (X[:, 0] ** 2 + (X[:, 1] * X[:, 2] - 1 / (X[:, 1] * X[:, 3])) ** 2) ** 0.5
+    )
+
+
+def test_make_friedman3(global_random_seed):
+    X, y = make_friedman3(n_samples=5, noise=0.0, random_state=global_random_seed)
+
+    assert X.shape == (5, 4), "X shape mismatch"
+    assert y.shape == (5,), "y shape mismatch"
+
+    assert_array_almost_equal(
+        y, np.arctan((X[:, 1] * X[:, 2] - 1 / (X[:, 1] * X[:, 3])) / X[:, 0])
+    )
+
+
+def test_make_low_rank_matrix():
+    X = make_low_rank_matrix(
+        n_samples=50,
+        n_features=25,
+        effective_rank=5,
+        tail_strength=0.01,
+        random_state=0,
+    )
+
+    assert X.shape == (50, 25), "X shape mismatch"
+
+    from numpy.linalg import svd
+
+    u, s, v = svd(X)
+    assert sum(s) - 5 < 0.1, "X rank is not approximately 5"
+
+
+def test_make_sparse_coded_signal(global_random_seed):
+    Y, D, X = make_sparse_coded_signal(
+        n_samples=5,
+        n_components=8,
+        n_features=10,
+        n_nonzero_coefs=3,
+        random_state=global_random_seed,
+    )
+    assert Y.shape == (5, 10), "Y shape mismatch"
+    assert D.shape == (8, 10), "D shape mismatch"
+    assert X.shape == (5, 8), "X shape mismatch"
+    for row in X:
+        assert len(np.flatnonzero(row)) == 3, "Non-zero coefs mismatch"
+    assert_allclose(Y, X @ D)
+    assert_allclose(np.sqrt((D**2).sum(axis=1)), np.ones(D.shape[0]))
+
+
+def test_make_sparse_uncorrelated():
+    X, y = make_sparse_uncorrelated(n_samples=5, n_features=10, random_state=0)
+
+    assert X.shape == (5, 10), "X shape mismatch"
+    assert y.shape == (5,), "y shape mismatch"
+
+
+def test_make_spd_matrix(global_random_seed):
+    X = make_spd_matrix(n_dim=5, random_state=global_random_seed)
+
+    assert X.shape == (5, 5), "X shape mismatch"
+    assert_array_almost_equal(X, X.T)
+
+    from numpy.linalg import eig
+
+    eigenvalues, _ = eig(X)
+    assert np.all(eigenvalues > 0), "X is not positive-definite"
+
+
+@pytest.mark.parametrize("norm_diag", [True, False])
+@pytest.mark.parametrize(
+    "sparse_format", [None, "bsr", "coo", "csc", "csr", "dia", "dok", "lil"]
+)
+def test_make_sparse_spd_matrix(norm_diag, sparse_format, global_random_seed):
+    n_dim = 5
+    X = make_sparse_spd_matrix(
+        n_dim=n_dim,
+        norm_diag=norm_diag,
+        sparse_format=sparse_format,
+        random_state=global_random_seed,
+    )
+
+    assert X.shape == (n_dim, n_dim), "X shape mismatch"
+    if sparse_format is None:
+        assert not sp.issparse(X)
+        assert_allclose(X, X.T)
+        Xarr = X
+    else:
+        assert sp.issparse(X) and X.format == sparse_format
+        assert_allclose_dense_sparse(X, X.T)
+        Xarr = X.toarray()
+
+    from numpy.linalg import eig
+
+    # Do not use scipy.sparse.linalg.eigs because it cannot find all eigenvalues
+    eigenvalues, _ = eig(Xarr)
+    assert np.all(eigenvalues > 0), "X is not positive-definite"
+
+    if norm_diag:
+        # Check that leading diagonal elements are 1
+        assert_array_almost_equal(Xarr.diagonal(), np.ones(n_dim))
+
+
+@pytest.mark.parametrize("hole", [False, True])
+def test_make_swiss_roll(global_random_seed, hole):
+    X, t = make_swiss_roll(
+        n_samples=5, noise=0.0, random_state=global_random_seed, hole=hole
+    )
+
+    assert X.shape == (5, 3)
+    assert t.shape == (5,)
+    assert_array_almost_equal(X[:, 0], t * np.cos(t))
+    assert_array_almost_equal(X[:, 2], t * np.sin(t))
+
+
+def test_make_s_curve(global_random_seed):
+    X, t = make_s_curve(n_samples=5, noise=0.0, random_state=global_random_seed)
+
+    assert X.shape == (5, 3), "X shape mismatch"
+    assert t.shape == (5,), "t shape mismatch"
+    assert_array_almost_equal(X[:, 0], np.sin(t))
+    assert_array_almost_equal(X[:, 2], np.sign(t) * (np.cos(t) - 1))
+
+
+def test_make_biclusters():
+    X, rows, cols = make_biclusters(
+        shape=(100, 100), n_clusters=4, shuffle=True, random_state=0
+    )
+    assert X.shape == (100, 100), "X shape mismatch"
+    assert rows.shape == (4, 100), "rows shape mismatch"
+    assert cols.shape == (
+        4,
+        100,
+    ), "columns shape mismatch"
+    assert_all_finite(X)
+    assert_all_finite(rows)
+    assert_all_finite(cols)
+
+    X2, _, _ = make_biclusters(
+        shape=(100, 100), n_clusters=4, shuffle=True, random_state=0
+    )
+    assert_array_almost_equal(X, X2)
+
+
+def test_make_checkerboard():
+    X, rows, cols = make_checkerboard(
+        shape=(100, 100), n_clusters=(20, 5), shuffle=True, random_state=0
+    )
+    assert X.shape == (100, 100), "X shape mismatch"
+    assert rows.shape == (100, 100), "rows shape mismatch"
+    assert cols.shape == (
+        100,
+        100,
+    ), "columns shape mismatch"
+
+    X, rows, cols = make_checkerboard(
+        shape=(100, 100), n_clusters=2, shuffle=True, random_state=0
+    )
+    assert_all_finite(X)
+    assert_all_finite(rows)
+    assert_all_finite(cols)
+
+    X1, _, _ = make_checkerboard(
+        shape=(100, 100), n_clusters=2, shuffle=True, random_state=0
+    )
+    X2, _, _ = make_checkerboard(
+        shape=(100, 100), n_clusters=2, shuffle=True, random_state=0
+    )
+    assert_array_almost_equal(X1, X2)
+
+
+def test_make_moons(global_random_seed):
+    X, y = make_moons(3, shuffle=False, random_state=global_random_seed)
+    for x, label in zip(X, y):
+        center = [0.0, 0.0] if label == 0 else [1.0, 0.5]
+        dist_sqr = ((x - center) ** 2).sum()
+        assert_almost_equal(
+            dist_sqr, 1.0, err_msg="Point is not on expected unit circle"
+        )
+
+
+def test_make_moons_unbalanced():
+    X, y = make_moons(n_samples=(7, 5))
+    assert np.sum(y == 0) == 7 and np.sum(y == 1) == 5, (
+        "Number of samples in a moon is wrong"
+    )
+    assert X.shape == (12, 2), "X shape mismatch"
+    assert y.shape == (12,), "y shape mismatch"
+
+    with pytest.raises(
+        ValueError,
+        match=r"`n_samples` can be either an int or a two-element tuple.",
+    ):
+        make_moons(n_samples=(10,))
+
+
+def test_make_circles():
+    factor = 0.3
+
+    for n_samples, n_outer, n_inner in [(7, 3, 4), (8, 4, 4)]:
+        # Testing odd and even case, because in the past make_circles always
+        # created an even number of samples.
+        X, y = make_circles(n_samples, shuffle=False, noise=None, factor=factor)
+        assert X.shape == (n_samples, 2), "X shape mismatch"
+        assert y.shape == (n_samples,), "y shape mismatch"
+        center = [0.0, 0.0]
+        for x, label in zip(X, y):
+            dist_sqr = ((x - center) ** 2).sum()
+            dist_exp = 1.0 if label == 0 else factor**2
+            dist_exp = 1.0 if label == 0 else factor**2
+            assert_almost_equal(
+                dist_sqr, dist_exp, err_msg="Point is not on expected circle"
+            )
+
+        assert X[y == 0].shape == (
+            n_outer,
+            2,
+        ), "Samples not correctly distributed across circles."
+        assert X[y == 1].shape == (
+            n_inner,
+            2,
+        ), "Samples not correctly distributed across circles."
+
+
+def test_make_circles_unbalanced():
+    X, y = make_circles(n_samples=(2, 8))
+
+    assert np.sum(y == 0) == 2, "Number of samples in inner circle is wrong"
+    assert np.sum(y == 1) == 8, "Number of samples in outer circle is wrong"
+    assert X.shape == (10, 2), "X shape mismatch"
+    assert y.shape == (10,), "y shape mismatch"
+
+    with pytest.raises(
+        ValueError,
+        match="When a tuple, n_samples must have exactly two elements.",
+    ):
+        make_circles(n_samples=(10,))

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sklearn/datasets/tests/test_svmlight_format.py

@@ -0,0 +1,613 @@
+import gzip
+import os
+import shutil
+from bz2 import BZ2File
+from importlib import resources
+from io import BytesIO
+from tempfile import NamedTemporaryFile
+
+import numpy as np
+import pytest
+import scipy.sparse as sp
+
+import sklearn
+from sklearn.datasets import dump_svmlight_file, load_svmlight_file, load_svmlight_files
+from sklearn.utils._testing import (
+    assert_allclose,
+    assert_array_almost_equal,
+    assert_array_equal,
+    create_memmap_backed_data,
+)
+from sklearn.utils.fixes import CSR_CONTAINERS
+
+TEST_DATA_MODULE = "sklearn.datasets.tests.data"
+datafile = "svmlight_classification.txt"
+multifile = "svmlight_multilabel.txt"
+invalidfile = "svmlight_invalid.txt"
+invalidfile2 = "svmlight_invalid_order.txt"
+
+
+def _svmlight_local_test_file_path(filename):
+    return resources.files(TEST_DATA_MODULE) / filename
+
+
+def _load_svmlight_local_test_file(filename, **kwargs):
+    """
+    Helper to load resource `filename` with `importlib.resources`
+    """
+    data_path = _svmlight_local_test_file_path(filename)
+    with data_path.open("rb") as f:
+        return load_svmlight_file(f, **kwargs)
+
+
+def test_load_svmlight_file():
+    X, y = _load_svmlight_local_test_file(datafile)
+
+    # test X's shape
+    assert X.indptr.shape[0] == 7
+    assert X.shape[0] == 6
+    assert X.shape[1] == 21
+    assert y.shape[0] == 6
+
+    # test X's non-zero values
+    for i, j, val in (
+        (0, 2, 2.5),
+        (0, 10, -5.2),
+        (0, 15, 1.5),
+        (1, 5, 1.0),
+        (1, 12, -3),
+        (2, 20, 27),
+    ):
+        assert X[i, j] == val
+
+    # tests X's zero values
+    assert X[0, 3] == 0
+    assert X[0, 5] == 0
+    assert X[1, 8] == 0
+    assert X[1, 16] == 0
+    assert X[2, 18] == 0
+
+    # test can change X's values
+    X[0, 2] *= 2
+    assert X[0, 2] == 5
+
+    # test y
+    assert_array_equal(y, [1, 2, 3, 4, 1, 2])
+
+
+def test_load_svmlight_file_fd():
+    # test loading from file descriptor
+
+    # GH20081: testing equality between path-based and
+    # fd-based load_svmlight_file
+
+    data_path = resources.files(TEST_DATA_MODULE) / datafile
+    data_path = str(data_path)
+    X1, y1 = load_svmlight_file(data_path)
+
+    fd = os.open(data_path, os.O_RDONLY)
+    try:
+        X2, y2 = load_svmlight_file(fd)
+        assert_array_almost_equal(X1.data, X2.data)
+        assert_array_almost_equal(y1, y2)
+    finally:
+        os.close(fd)
+
+
+def test_load_svmlight_pathlib():
+    # test loading from file descriptor
+    data_path = _svmlight_local_test_file_path(datafile)
+    X1, y1 = load_svmlight_file(str(data_path))
+    X2, y2 = load_svmlight_file(data_path)
+
+    assert_allclose(X1.data, X2.data)
+    assert_allclose(y1, y2)
+
+
+def test_load_svmlight_file_multilabel():
+    X, y = _load_svmlight_local_test_file(multifile, multilabel=True)
+    assert y == [(0, 1), (2,), (), (1, 2)]
+
+
+def test_load_svmlight_files():
+    data_path = _svmlight_local_test_file_path(datafile)
+    X_train, y_train, X_test, y_test = load_svmlight_files(
+        [str(data_path)] * 2, dtype=np.float32
+    )
+    assert_array_equal(X_train.toarray(), X_test.toarray())
+    assert_array_almost_equal(y_train, y_test)
+    assert X_train.dtype == np.float32
+    assert X_test.dtype == np.float32
+
+    X1, y1, X2, y2, X3, y3 = load_svmlight_files([str(data_path)] * 3, dtype=np.float64)
+    assert X1.dtype == X2.dtype
+    assert X2.dtype == X3.dtype
+    assert X3.dtype == np.float64
+
+
+def test_load_svmlight_file_n_features():
+    X, y = _load_svmlight_local_test_file(datafile, n_features=22)
+
+    # test X'shape
+    assert X.indptr.shape[0] == 7
+    assert X.shape[0] == 6
+    assert X.shape[1] == 22
+
+    # test X's non-zero values
+    for i, j, val in ((0, 2, 2.5), (0, 10, -5.2), (1, 5, 1.0), (1, 12, -3)):
+        assert X[i, j] == val
+
+    # 21 features in file
+    with pytest.raises(ValueError):
+        _load_svmlight_local_test_file(datafile, n_features=20)
+
+
+def test_load_compressed():
+    X, y = _load_svmlight_local_test_file(datafile)
+
+    with NamedTemporaryFile(prefix="sklearn-test", suffix=".gz") as tmp:
+        tmp.close()  # necessary under windows
+        with _svmlight_local_test_file_path(datafile).open("rb") as f:
+            with gzip.open(tmp.name, "wb") as fh_out:
+                shutil.copyfileobj(f, fh_out)
+        Xgz, ygz = load_svmlight_file(tmp.name)
+        # because we "close" it manually and write to it,
+        # we need to remove it manually.
+        os.remove(tmp.name)
+    assert_array_almost_equal(X.toarray(), Xgz.toarray())
+    assert_array_almost_equal(y, ygz)
+
+    with NamedTemporaryFile(prefix="sklearn-test", suffix=".bz2") as tmp:
+        tmp.close()  # necessary under windows
+        with _svmlight_local_test_file_path(datafile).open("rb") as f:
+            with BZ2File(tmp.name, "wb") as fh_out:
+                shutil.copyfileobj(f, fh_out)
+        Xbz, ybz = load_svmlight_file(tmp.name)
+        # because we "close" it manually and write to it,
+        # we need to remove it manually.
+        os.remove(tmp.name)
+    assert_array_almost_equal(X.toarray(), Xbz.toarray())
+    assert_array_almost_equal(y, ybz)
+
+
+def test_load_invalid_file():
+    with pytest.raises(ValueError):
+        _load_svmlight_local_test_file(invalidfile)
+
+
+def test_load_invalid_order_file():
+    with pytest.raises(ValueError):
+        _load_svmlight_local_test_file(invalidfile2)
+
+
+def test_load_zero_based():
+    f = BytesIO(b"-1 4:1.\n1 0:1\n")
+    with pytest.raises(ValueError):
+        load_svmlight_file(f, zero_based=False)
+
+
+def test_load_zero_based_auto():
+    data1 = b"-1 1:1 2:2 3:3\n"
+    data2 = b"-1 0:0 1:1\n"
+
+    f1 = BytesIO(data1)
+    X, y = load_svmlight_file(f1, zero_based="auto")
+    assert X.shape == (1, 3)
+
+    f1 = BytesIO(data1)
+    f2 = BytesIO(data2)
+    X1, y1, X2, y2 = load_svmlight_files([f1, f2], zero_based="auto")
+    assert X1.shape == (1, 4)
+    assert X2.shape == (1, 4)
+
+
+def test_load_with_qid():
+    # load svmfile with qid attribute
+    data = b"""
+    3 qid:1 1:0.53 2:0.12
+    2 qid:1 1:0.13 2:0.1
+    7 qid:2 1:0.87 2:0.12"""
+    X, y = load_svmlight_file(BytesIO(data), query_id=False)
+    assert_array_equal(y, [3, 2, 7])
+    assert_array_equal(X.toarray(), [[0.53, 0.12], [0.13, 0.1], [0.87, 0.12]])
+    res1 = load_svmlight_files([BytesIO(data)], query_id=True)
+    res2 = load_svmlight_file(BytesIO(data), query_id=True)
+    for X, y, qid in (res1, res2):
+        assert_array_equal(y, [3, 2, 7])
+        assert_array_equal(qid, [1, 1, 2])
+        assert_array_equal(X.toarray(), [[0.53, 0.12], [0.13, 0.1], [0.87, 0.12]])
+
+
+@pytest.mark.skip(
+    "testing the overflow of 32 bit sparse indexing requires a large amount of memory"
+)
+def test_load_large_qid():
+    """
+    load large libsvm / svmlight file with qid attribute. Tests 64-bit query ID
+    """
+    data = b"\n".join(
+        (
+            "3 qid:{0} 1:0.53 2:0.12\n2 qid:{0} 1:0.13 2:0.1".format(i).encode()
+            for i in range(1, 40 * 1000 * 1000)
+        )
+    )
+    X, y, qid = load_svmlight_file(BytesIO(data), query_id=True)
+    assert_array_equal(y[-4:], [3, 2, 3, 2])
+    assert_array_equal(np.unique(qid), np.arange(1, 40 * 1000 * 1000))
+
+
+def test_load_invalid_file2():
+    with pytest.raises(ValueError):
+        data_path = _svmlight_local_test_file_path(datafile)
+        invalid_path = _svmlight_local_test_file_path(invalidfile)
+        load_svmlight_files([str(data_path), str(invalid_path), str(data_path)])
+
+
+def test_not_a_filename():
+    # in python 3 integers are valid file opening arguments (taken as unix
+    # file descriptors)
+    with pytest.raises(TypeError):
+        load_svmlight_file(0.42)
+
+
+def test_invalid_filename():
+    with pytest.raises(OSError):
+        load_svmlight_file("trou pic nic douille")
+
+
+@pytest.mark.parametrize("csr_container", CSR_CONTAINERS)
+def test_dump(csr_container):
+    X_sparse, y_dense = _load_svmlight_local_test_file(datafile)
+    X_dense = X_sparse.toarray()
+    y_sparse = csr_container(np.atleast_2d(y_dense))
+
+    # slicing a csr_matrix can unsort its .indices, so test that we sort
+    # those correctly
+    X_sliced = X_sparse[np.arange(X_sparse.shape[0])]
+    y_sliced = y_sparse[np.arange(y_sparse.shape[0])]
+
+    for X in (X_sparse, X_dense, X_sliced):
+        for y in (y_sparse, y_dense, y_sliced):
+            for zero_based in (True, False):
+                for dtype in [np.float32, np.float64, np.int32, np.int64]:
+                    f = BytesIO()
+                    # we need to pass a comment to get the version info in;
+                    # LibSVM doesn't grok comments so they're not put in by
+                    # default anymore.
+
+                    if sp.issparse(y) and y.shape[0] == 1:
+                        # make sure y's shape is: (n_samples, n_labels)
+                        # when it is sparse
+                        y = y.T
+
+                    # Note: with dtype=np.int32 we are performing unsafe casts,
+                    # where X.astype(dtype) overflows. The result is
+                    # then platform dependent and X_dense.astype(dtype) may be
+                    # different from X_sparse.astype(dtype).asarray().
+                    X_input = X.astype(dtype)
+
+                    dump_svmlight_file(
+                        X_input, y, f, comment="test", zero_based=zero_based
+                    )
+                    f.seek(0)
+
+                    comment = f.readline()
+                    comment = str(comment, "utf-8")
+
+                    assert "scikit-learn %s" % sklearn.__version__ in comment
+
+                    comment = f.readline()
+                    comment = str(comment, "utf-8")
+
+                    assert ["one", "zero"][zero_based] + "-based" in comment
+
+                    X2, y2 = load_svmlight_file(f, dtype=dtype, zero_based=zero_based)
+                    assert X2.dtype == dtype
+                    assert_array_equal(X2.sorted_indices().indices, X2.indices)
+
+                    X2_dense = X2.toarray()
+                    if sp.issparse(X_input):
+                        X_input_dense = X_input.toarray()
+                    else:
+                        X_input_dense = X_input
+
+                    if dtype == np.float32:
+                        # allow a rounding error at the last decimal place
+                        assert_array_almost_equal(X_input_dense, X2_dense, 4)
+                        assert_array_almost_equal(
+                            y_dense.astype(dtype, copy=False), y2, 4
+                        )
+                    else:
+                        # allow a rounding error at the last decimal place
+                        assert_array_almost_equal(X_input_dense, X2_dense, 15)
+                        assert_array_almost_equal(
+                            y_dense.astype(dtype, copy=False), y2, 15
+                        )
+
+
+@pytest.mark.parametrize("csr_container", CSR_CONTAINERS)
+def test_dump_multilabel(csr_container):
+    X = [[1, 0, 3, 0, 5], [0, 0, 0, 0, 0], [0, 5, 0, 1, 0]]
+    y_dense = [[0, 1, 0], [1, 0, 1], [1, 1, 0]]
+    y_sparse = csr_container(y_dense)
+    for y in [y_dense, y_sparse]:
+        f = BytesIO()
+        dump_svmlight_file(X, y, f, multilabel=True)
+        f.seek(0)
+        # make sure it dumps multilabel correctly
+        assert f.readline() == b"1 0:1 2:3 4:5\n"
+        assert f.readline() == b"0,2 \n"
+        assert f.readline() == b"0,1 1:5 3:1\n"
+
+
+def test_dump_concise():
+    one = 1
+    two = 2.1
+    three = 3.01
+    exact = 1.000000000000001
+    # loses the last decimal place
+    almost = 1.0000000000000001
+    X = [
+        [one, two, three, exact, almost],
+        [1e9, 2e18, 3e27, 0, 0],
+        [0, 0, 0, 0, 0],
+        [0, 0, 0, 0, 0],
+        [0, 0, 0, 0, 0],
+    ]
+    y = [one, two, three, exact, almost]
+    f = BytesIO()
+    dump_svmlight_file(X, y, f)
+    f.seek(0)
+    # make sure it's using the most concise format possible
+    assert f.readline() == b"1 0:1 1:2.1 2:3.01 3:1.000000000000001 4:1\n"
+    assert f.readline() == b"2.1 0:1000000000 1:2e+18 2:3e+27\n"
+    assert f.readline() == b"3.01 \n"
+    assert f.readline() == b"1.000000000000001 \n"
+    assert f.readline() == b"1 \n"
+    f.seek(0)
+    # make sure it's correct too :)
+    X2, y2 = load_svmlight_file(f)
+    assert_array_almost_equal(X, X2.toarray())
+    assert_array_almost_equal(y, y2)
+
+
+def test_dump_comment():
+    X, y = _load_svmlight_local_test_file(datafile)
+    X = X.toarray()
+
+    f = BytesIO()
+    ascii_comment = "This is a comment\nspanning multiple lines."
+    dump_svmlight_file(X, y, f, comment=ascii_comment, zero_based=False)
+    f.seek(0)
+
+    X2, y2 = load_svmlight_file(f, zero_based=False)
+    assert_array_almost_equal(X, X2.toarray())
+    assert_array_almost_equal(y, y2)
+
+    # XXX we have to update this to support Python 3.x
+    utf8_comment = b"It is true that\n\xc2\xbd\xc2\xb2 = \xc2\xbc"
+    f = BytesIO()
+    with pytest.raises(UnicodeDecodeError):
+        dump_svmlight_file(X, y, f, comment=utf8_comment)
+
+    unicode_comment = utf8_comment.decode("utf-8")
+    f = BytesIO()
+    dump_svmlight_file(X, y, f, comment=unicode_comment, zero_based=False)
+    f.seek(0)
+
+    X2, y2 = load_svmlight_file(f, zero_based=False)
+    assert_array_almost_equal(X, X2.toarray())
+    assert_array_almost_equal(y, y2)
+
+    f = BytesIO()
+    with pytest.raises(ValueError):
+        dump_svmlight_file(X, y, f, comment="I've got a \0.")
+
+
+def test_dump_invalid():
+    X, y = _load_svmlight_local_test_file(datafile)
+
+    f = BytesIO()
+    y2d = [y]
+    with pytest.raises(ValueError):
+        dump_svmlight_file(X, y2d, f)
+
+    f = BytesIO()
+    with pytest.raises(ValueError):
+        dump_svmlight_file(X, y[:-1], f)
+
+
+def test_dump_query_id():
+    # test dumping a file with query_id
+    X, y = _load_svmlight_local_test_file(datafile)
+    X = X.toarray()
+    query_id = np.arange(X.shape[0]) // 2
+    f = BytesIO()
+    dump_svmlight_file(X, y, f, query_id=query_id, zero_based=True)
+
+    f.seek(0)
+    X1, y1, query_id1 = load_svmlight_file(f, query_id=True, zero_based=True)
+    assert_array_almost_equal(X, X1.toarray())
+    assert_array_almost_equal(y, y1)
+    assert_array_almost_equal(query_id, query_id1)
+
+
+def test_load_with_long_qid():
+    # load svmfile with longint qid attribute
+    data = b"""
+    1 qid:0 0:1 1:2 2:3
+    0 qid:72048431380967004 0:1440446648 1:72048431380967004 2:236784985
+    0 qid:-9223372036854775807 0:1440446648 1:72048431380967004 2:236784985
+    3 qid:9223372036854775807  0:1440446648 1:72048431380967004 2:236784985"""
+    X, y, qid = load_svmlight_file(BytesIO(data), query_id=True)
+
+    true_X = [
+        [1, 2, 3],
+        [1440446648, 72048431380967004, 236784985],
+        [1440446648, 72048431380967004, 236784985],
+        [1440446648, 72048431380967004, 236784985],
+    ]
+
+    true_y = [1, 0, 0, 3]
+    trueQID = [0, 72048431380967004, -9223372036854775807, 9223372036854775807]
+    assert_array_equal(y, true_y)
+    assert_array_equal(X.toarray(), true_X)
+    assert_array_equal(qid, trueQID)
+
+    f = BytesIO()
+    dump_svmlight_file(X, y, f, query_id=qid, zero_based=True)
+    f.seek(0)
+    X, y, qid = load_svmlight_file(f, query_id=True, zero_based=True)
+    assert_array_equal(y, true_y)
+    assert_array_equal(X.toarray(), true_X)
+    assert_array_equal(qid, trueQID)
+
+    f.seek(0)
+    X, y = load_svmlight_file(f, query_id=False, zero_based=True)
+    assert_array_equal(y, true_y)
+    assert_array_equal(X.toarray(), true_X)
+
+
+@pytest.mark.parametrize("csr_container", CSR_CONTAINERS)
+def test_load_zeros(csr_container):
+    f = BytesIO()
+    true_X = csr_container(np.zeros(shape=(3, 4)))
+    true_y = np.array([0, 1, 0])
+    dump_svmlight_file(true_X, true_y, f)
+
+    for zero_based in ["auto", True, False]:
+        f.seek(0)
+        X, y = load_svmlight_file(f, n_features=4, zero_based=zero_based)
+        assert_array_almost_equal(y, true_y)
+        assert_array_almost_equal(X.toarray(), true_X.toarray())
+
+
+@pytest.mark.parametrize("sparsity", [0, 0.1, 0.5, 0.99, 1])
+@pytest.mark.parametrize("n_samples", [13, 101])
+@pytest.mark.parametrize("n_features", [2, 7, 41])
+@pytest.mark.parametrize("csr_container", CSR_CONTAINERS)
+def test_load_with_offsets(sparsity, n_samples, n_features, csr_container):
+    rng = np.random.RandomState(0)
+    X = rng.uniform(low=0.0, high=1.0, size=(n_samples, n_features))
+    if sparsity:
+        X[X < sparsity] = 0.0
+    X = csr_container(X)
+    y = rng.randint(low=0, high=2, size=n_samples)
+
+    f = BytesIO()
+    dump_svmlight_file(X, y, f)
+    f.seek(0)
+
+    size = len(f.getvalue())
+
+    # put some marks that are likely to happen anywhere in a row
+    mark_0 = 0
+    mark_1 = size // 3
+    length_0 = mark_1 - mark_0
+    mark_2 = 4 * size // 5
+    length_1 = mark_2 - mark_1
+
+    # load the original sparse matrix into 3 independent CSR matrices
+    X_0, y_0 = load_svmlight_file(
+        f, n_features=n_features, offset=mark_0, length=length_0
+    )
+    X_1, y_1 = load_svmlight_file(
+        f, n_features=n_features, offset=mark_1, length=length_1
+    )
+    X_2, y_2 = load_svmlight_file(f, n_features=n_features, offset=mark_2)
+
+    y_concat = np.concatenate([y_0, y_1, y_2])
+    X_concat = sp.vstack([X_0, X_1, X_2])
+    assert_array_almost_equal(y, y_concat)
+    assert_array_almost_equal(X.toarray(), X_concat.toarray())
+
+
+@pytest.mark.parametrize("csr_container", CSR_CONTAINERS)
+def test_load_offset_exhaustive_splits(csr_container):
+    rng = np.random.RandomState(0)
+    X = np.array(
+        [
+            [0, 0, 0, 0, 0, 0],
+            [1, 2, 3, 4, 0, 6],
+            [1, 2, 3, 4, 0, 6],
+            [0, 0, 0, 0, 0, 0],
+            [1, 0, 3, 0, 0, 0],
+            [0, 0, 0, 0, 0, 1],
+            [1, 0, 0, 0, 0, 0],
+        ]
+    )
+    X = csr_container(X)
+    n_samples, n_features = X.shape
+    y = rng.randint(low=0, high=2, size=n_samples)
+    query_id = np.arange(n_samples) // 2
+
+    f = BytesIO()
+    dump_svmlight_file(X, y, f, query_id=query_id)
+    f.seek(0)
+
+    size = len(f.getvalue())
+
+    # load the same data in 2 parts with all the possible byte offsets to
+    # locate the split so has to test for particular boundary cases
+    for mark in range(size):
+        f.seek(0)
+        X_0, y_0, q_0 = load_svmlight_file(
+            f, n_features=n_features, query_id=True, offset=0, length=mark
+        )
+        X_1, y_1, q_1 = load_svmlight_file(
+            f, n_features=n_features, query_id=True, offset=mark, length=-1
+        )
+        q_concat = np.concatenate([q_0, q_1])
+        y_concat = np.concatenate([y_0, y_1])
+        X_concat = sp.vstack([X_0, X_1])
+        assert_array_almost_equal(y, y_concat)
+        assert_array_equal(query_id, q_concat)
+        assert_array_almost_equal(X.toarray(), X_concat.toarray())
+
+
+def test_load_with_offsets_error():
+    with pytest.raises(ValueError, match="n_features is required"):
+        _load_svmlight_local_test_file(datafile, offset=3, length=3)
+
+
+@pytest.mark.parametrize("csr_container", CSR_CONTAINERS)
+def test_multilabel_y_explicit_zeros(tmp_path, csr_container):
+    """
+    Ensure that if y contains explicit zeros (i.e. elements of y.data equal to
+    0) then those explicit zeros are not encoded.
+    """
+    save_path = str(tmp_path / "svm_explicit_zero")
+    rng = np.random.RandomState(42)
+    X = rng.randn(3, 5).astype(np.float64)
+    indptr = np.array([0, 2, 3, 6])
+    indices = np.array([0, 2, 2, 0, 1, 2])
+    # The first and last element are explicit zeros.
+    data = np.array([0, 1, 1, 1, 1, 0])
+    y = csr_container((data, indices, indptr), shape=(3, 3))
+    # y as a dense array would look like
+    # [[0, 0, 1],
+    #  [0, 0, 1],
+    #  [1, 1, 0]]
+
+    dump_svmlight_file(X, y, save_path, multilabel=True)
+
+    _, y_load = load_svmlight_file(save_path, multilabel=True)
+    y_true = [(2.0,), (2.0,), (0.0, 1.0)]
+    assert y_load == y_true
+
+
+def test_dump_read_only(tmp_path):
+    """Ensure that there is no ValueError when dumping a read-only `X`.
+
+    Non-regression test for:
+    https://github.com/scikit-learn/scikit-learn/issues/28026
+    """
+    rng = np.random.RandomState(42)
+    X = rng.randn(5, 2)
+    y = rng.randn(5)
+
+    # Convert to memmap-backed which are read-only
+    X, y = create_memmap_backed_data([X, y])
+
+    save_path = str(tmp_path / "svm_read_only")
+    dump_svmlight_file(X, y, save_path)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sklearn/decomposition/__init__.py

@@ -0,0 +1,54 @@
+"""Matrix decomposition algorithms.
+
+These include PCA, NMF, ICA, and more. Most of the algorithms of this module can be
+regarded as dimensionality reduction techniques.
+"""
+
+# Authors: The scikit-learn developers
+# SPDX-License-Identifier: BSD-3-Clause
+
+from ..utils.extmath import randomized_svd
+from ._dict_learning import (
+    DictionaryLearning,
+    MiniBatchDictionaryLearning,
+    SparseCoder,
+    dict_learning,
+    dict_learning_online,
+    sparse_encode,
+)
+from ._factor_analysis import FactorAnalysis
+from ._fastica import FastICA, fastica
+from ._incremental_pca import IncrementalPCA
+from ._kernel_pca import KernelPCA
+from ._lda import LatentDirichletAllocation
+from ._nmf import (
+    NMF,
+    MiniBatchNMF,
+    non_negative_factorization,
+)
+from ._pca import PCA
+from ._sparse_pca import MiniBatchSparsePCA, SparsePCA
+from ._truncated_svd import TruncatedSVD
+
+__all__ = [
+    "NMF",
+    "PCA",
+    "DictionaryLearning",
+    "FactorAnalysis",
+    "FastICA",
+    "IncrementalPCA",
+    "KernelPCA",
+    "LatentDirichletAllocation",
+    "MiniBatchDictionaryLearning",
+    "MiniBatchNMF",
+    "MiniBatchSparsePCA",
+    "SparseCoder",
+    "SparsePCA",
+    "TruncatedSVD",
+    "dict_learning",
+    "dict_learning_online",
+    "fastica",
+    "non_negative_factorization",
+    "randomized_svd",
+    "sparse_encode",
+]

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sklearn/decomposition/_base.py

@@ -0,0 +1,202 @@
+"""Principal Component Analysis Base Classes"""
+
+# Authors: The scikit-learn developers
+# SPDX-License-Identifier: BSD-3-Clause
+
+from abc import ABCMeta, abstractmethod
+
+import numpy as np
+from scipy import linalg
+
+from ..base import BaseEstimator, ClassNamePrefixFeaturesOutMixin, TransformerMixin
+from ..utils._array_api import _fill_or_add_to_diagonal, device, get_namespace
+from ..utils.validation import check_is_fitted, validate_data
+
+
+class _BasePCA(
+    ClassNamePrefixFeaturesOutMixin, TransformerMixin, BaseEstimator, metaclass=ABCMeta
+):
+    """Base class for PCA methods.
+
+    Warning: This class should not be used directly.
+    Use derived classes instead.
+    """
+
+    def get_covariance(self):
+        """Compute data covariance with the generative model.
+
+        ``cov = components_.T * S**2 * components_ + sigma2 * eye(n_features)``
+        where S**2 contains the explained variances, and sigma2 contains the
+        noise variances.
+
+        Returns
+        -------
+        cov : array of shape=(n_features, n_features)
+            Estimated covariance of data.
+        """
+        xp, _ = get_namespace(self.components_)
+
+        components_ = self.components_
+        exp_var = self.explained_variance_
+        if self.whiten:
+            components_ = components_ * xp.sqrt(exp_var[:, np.newaxis])
+        exp_var_diff = exp_var - self.noise_variance_
+        exp_var_diff = xp.where(
+            exp_var > self.noise_variance_,
+            exp_var_diff,
+            xp.asarray(0.0, device=device(exp_var), dtype=exp_var.dtype),
+        )
+        cov = (components_.T * exp_var_diff) @ components_
+        _fill_or_add_to_diagonal(cov, self.noise_variance_, xp)
+        return cov
+
+    def get_precision(self):
+        """Compute data precision matrix with the generative model.
+
+        Equals the inverse of the covariance but computed with
+        the matrix inversion lemma for efficiency.
+
+        Returns
+        -------
+        precision : array, shape=(n_features, n_features)
+            Estimated precision of data.
+        """
+        xp, is_array_api_compliant = get_namespace(self.components_)
+
+        n_features = self.components_.shape[1]
+
+        # handle corner cases first
+        if self.n_components_ == 0:
+            return xp.eye(n_features) / self.noise_variance_
+
+        if is_array_api_compliant:
+            linalg_inv = xp.linalg.inv
+        else:
+            linalg_inv = linalg.inv
+
+        if self.noise_variance_ == 0.0:
+            return linalg_inv(self.get_covariance())
+
+        # Get precision using matrix inversion lemma
+        components_ = self.components_
+        exp_var = self.explained_variance_
+        if self.whiten:
+            components_ = components_ * xp.sqrt(exp_var[:, np.newaxis])
+        exp_var_diff = exp_var - self.noise_variance_
+        exp_var_diff = xp.where(
+            exp_var > self.noise_variance_,
+            exp_var_diff,
+            xp.asarray(0.0, device=device(exp_var)),
+        )
+        precision = components_ @ components_.T / self.noise_variance_
+        _fill_or_add_to_diagonal(precision, 1.0 / exp_var_diff, xp)
+        precision = components_.T @ linalg_inv(precision) @ components_
+        precision /= -(self.noise_variance_**2)
+        _fill_or_add_to_diagonal(precision, 1.0 / self.noise_variance_, xp)
+        return precision
+
+    @abstractmethod
+    def fit(self, X, y=None):
+        """Placeholder for fit. Subclasses should implement this method!
+
+        Fit the model with X.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+            Training data, where `n_samples` is the number of samples and
+            `n_features` is the number of features.
+
+        Returns
+        -------
+        self : object
+            Returns the instance itself.
+        """
+
+    def transform(self, X):
+        """Apply dimensionality reduction to X.
+
+        X is projected on the first principal components previously extracted
+        from a training set.
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} of shape (n_samples, n_features)
+            New data, where `n_samples` is the number of samples
+            and `n_features` is the number of features.
+
+        Returns
+        -------
+        X_new : array-like of shape (n_samples, n_components)
+            Projection of X in the first principal components, where `n_samples`
+            is the number of samples and `n_components` is the number of the components.
+        """
+        xp, _ = get_namespace(X, self.components_, self.explained_variance_)
+
+        check_is_fitted(self)
+
+        X = validate_data(
+            self,
+            X,
+            dtype=[xp.float64, xp.float32],
+            accept_sparse=("csr", "csc"),
+            reset=False,
+        )
+        return self._transform(X, xp=xp, x_is_centered=False)
+
+    def _transform(self, X, xp, x_is_centered=False):
+        X_transformed = X @ self.components_.T
+        if not x_is_centered:
+            # Apply the centering after the projection.
+            # For dense X this avoids copying or mutating the data passed by
+            # the caller.
+            # For sparse X it keeps sparsity and avoids having to wrap X into
+            # a linear operator.
+            X_transformed -= xp.reshape(self.mean_, (1, -1)) @ self.components_.T
+        if self.whiten:
+            # For some solvers (such as "arpack" and "covariance_eigh"), on
+            # rank deficient data, some components can have a variance
+            # arbitrarily close to zero, leading to non-finite results when
+            # whitening. To avoid this problem we clip the variance below.
+            scale = xp.sqrt(self.explained_variance_)
+            min_scale = xp.finfo(scale.dtype).eps
+            scale[scale < min_scale] = min_scale
+            X_transformed /= scale
+        return X_transformed
+
+    def inverse_transform(self, X):
+        """Transform data back to its original space.
+
+        In other words, return an input `X_original` whose transform would be X.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_components)
+            New data, where `n_samples` is the number of samples
+            and `n_components` is the number of components.
+
+        Returns
+        -------
+        X_original : array-like of shape (n_samples, n_features)
+            Original data, where `n_samples` is the number of samples
+            and `n_features` is the number of features.
+
+        Notes
+        -----
+        If whitening is enabled, inverse_transform will compute the
+        exact inverse operation, which includes reversing whitening.
+        """
+        xp, _ = get_namespace(X)
+
+        if self.whiten:
+            scaled_components = (
+                xp.sqrt(self.explained_variance_[:, np.newaxis]) * self.components_
+            )
+            return X @ scaled_components + self.mean_
+        else:
+            return X @ self.components_ + self.mean_
+
+    @property
+    def _n_features_out(self):
+        """Number of transformed output features."""
+        return self.components_.shape[0]

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sklearn/decomposition/_cdnmf_fast.pyx

@@ -0,0 +1,38 @@
+# Authors: The scikit-learn developers
+# SPDX-License-Identifier: BSD-3-Clause
+
+from cython cimport floating
+from libc.math cimport fabs
+
+
+def _update_cdnmf_fast(floating[:, ::1] W, floating[:, :] HHt,
+                       floating[:, :] XHt, Py_ssize_t[::1] permutation):
+    cdef:
+        floating violation = 0
+        Py_ssize_t n_components = W.shape[1]
+        Py_ssize_t n_samples = W.shape[0]  # n_features for H update
+        floating grad, pg, hess
+        Py_ssize_t i, r, s, t
+
+    with nogil:
+        for s in range(n_components):
+            t = permutation[s]
+
+            for i in range(n_samples):
+                # gradient = GW[t, i] where GW = np.dot(W, HHt) - XHt
+                grad = -XHt[i, t]
+
+                for r in range(n_components):
+                    grad += HHt[t, r] * W[i, r]
+
+                # projected gradient
+                pg = min(0., grad) if W[i, t] == 0 else grad
+                violation += fabs(pg)
+
+                # Hessian
+                hess = HHt[t, t]
+
+                if hess != 0:
+                    W[i, t] = max(W[i, t] - grad / hess, 0.)
+
+    return violation

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sklearn/decomposition/_dict_learning.py

@@ -0,0 +1,2329 @@
+"""Dictionary learning."""
+
+# Authors: The scikit-learn developers
+# SPDX-License-Identifier: BSD-3-Clause
+
+import itertools
+import sys
+import time
+from numbers import Integral, Real
+
+import numpy as np
+from joblib import effective_n_jobs
+from scipy import linalg
+
+from ..base import (
+    BaseEstimator,
+    ClassNamePrefixFeaturesOutMixin,
+    TransformerMixin,
+    _fit_context,
+)
+from ..linear_model import Lars, Lasso, LassoLars, orthogonal_mp_gram
+from ..utils import check_array, check_random_state, gen_batches, gen_even_slices
+from ..utils._param_validation import Interval, StrOptions, validate_params
+from ..utils.extmath import _randomized_svd, row_norms, svd_flip
+from ..utils.parallel import Parallel, delayed
+from ..utils.validation import check_is_fitted, validate_data
+
+
+def _check_positive_coding(method, positive):
+    if positive and method in ["omp", "lars"]:
+        raise ValueError(
+            "Positive constraint not supported for '{}' coding method.".format(method)
+        )
+
+
+def _sparse_encode_precomputed(
+    X,
+    dictionary,
+    *,
+    gram=None,
+    cov=None,
+    algorithm="lasso_lars",
+    regularization=None,
+    copy_cov=True,
+    init=None,
+    max_iter=1000,
+    verbose=0,
+    positive=False,
+):
+    """Generic sparse coding with precomputed Gram and/or covariance matrices.
+
+    Each row of the result is the solution to a Lasso problem.
+
+    Parameters
+    ----------
+    X : ndarray of shape (n_samples, n_features)
+        Data matrix.
+
+    dictionary : ndarray of shape (n_components, n_features)
+        The dictionary matrix against which to solve the sparse coding of
+        the data. Some of the algorithms assume normalized rows.
+
+    gram : ndarray of shape (n_components, n_components), default=None
+        Precomputed Gram matrix, `dictionary * dictionary'`
+        gram can be `None` if method is 'threshold'.
+
+    cov : ndarray of shape (n_components, n_samples), default=None
+        Precomputed covariance, `dictionary * X'`.
+
+    algorithm : {'lasso_lars', 'lasso_cd', 'lars', 'omp', 'threshold'}, \
+            default='lasso_lars'
+        The algorithm used:
+
+        * `'lars'`: uses the least angle regression method
+          (`linear_model.lars_path`);
+        * `'lasso_lars'`: uses Lars to compute the Lasso solution;
+        * `'lasso_cd'`: uses the coordinate descent method to compute the
+          Lasso solution (`linear_model.Lasso`). lasso_lars will be faster if
+          the estimated components are sparse;
+        * `'omp'`: uses orthogonal matching pursuit to estimate the sparse
+          solution;
+        * `'threshold'`: squashes to zero all coefficients less than
+          regularization from the projection `dictionary * data'`.
+
+    regularization : int or float, default=None
+        The regularization parameter. It corresponds to alpha when
+        algorithm is `'lasso_lars'`, `'lasso_cd'` or `'threshold'`.
+        Otherwise it corresponds to `n_nonzero_coefs`.
+
+    init : ndarray of shape (n_samples, n_components), default=None
+        Initialization value of the sparse code. Only used if
+        `algorithm='lasso_cd'`.
+
+    max_iter : int, default=1000
+        Maximum number of iterations to perform if `algorithm='lasso_cd'` or
+        `'lasso_lars'`.
+
+    copy_cov : bool, default=True
+        Whether to copy the precomputed covariance matrix; if `False`, it may
+        be overwritten.
+
+    verbose : int, default=0
+        Controls the verbosity; the higher, the more messages.
+
+    positive: bool, default=False
+        Whether to enforce a positivity constraint on the sparse code.
+
+        .. versionadded:: 0.20
+
+    Returns
+    -------
+    code : ndarray of shape (n_components, n_features)
+        The sparse codes.
+    """
+    n_samples, n_features = X.shape
+    n_components = dictionary.shape[0]
+
+    if algorithm == "lasso_lars":
+        alpha = float(regularization) / n_features  # account for scaling
+        try:
+            err_mgt = np.seterr(all="ignore")
+
+            # Not passing in verbose=max(0, verbose-1) because Lars.fit already
+            # corrects the verbosity level.
+            lasso_lars = LassoLars(
+                alpha=alpha,
+                fit_intercept=False,
+                verbose=verbose,
+                precompute=gram,
+                fit_path=False,
+                positive=positive,
+                max_iter=max_iter,
+            )
+            lasso_lars.fit(dictionary.T, X.T, Xy=cov)
+            new_code = lasso_lars.coef_
+        finally:
+            np.seterr(**err_mgt)
+
+    elif algorithm == "lasso_cd":
+        alpha = float(regularization) / n_features  # account for scaling
+
+        # TODO: Make verbosity argument for Lasso?
+        # sklearn.linear_model.coordinate_descent.enet_path has a verbosity
+        # argument that we could pass in from Lasso.
+        clf = Lasso(
+            alpha=alpha,
+            fit_intercept=False,
+            precompute=gram,
+            max_iter=max_iter,
+            warm_start=True,
+            positive=positive,
+        )
+
+        if init is not None:
+            # In some workflows using coordinate descent algorithms:
+            #  - users might provide NumPy arrays with read-only buffers
+            #  - `joblib` might memmap arrays making their buffer read-only
+            # TODO: move this handling (which is currently too broad)
+            # closer to the actual private function which need buffers to be writable.
+            if not init.flags["WRITEABLE"]:
+                init = np.array(init)
+            clf.coef_ = init
+
+        clf.fit(dictionary.T, X.T, check_input=False)
+        new_code = clf.coef_
+
+    elif algorithm == "lars":
+        try:
+            err_mgt = np.seterr(all="ignore")
+
+            # Not passing in verbose=max(0, verbose-1) because Lars.fit already
+            # corrects the verbosity level.
+            lars = Lars(
+                fit_intercept=False,
+                verbose=verbose,
+                precompute=gram,
+                n_nonzero_coefs=int(regularization),
+                fit_path=False,
+            )
+            lars.fit(dictionary.T, X.T, Xy=cov)
+            new_code = lars.coef_
+        finally:
+            np.seterr(**err_mgt)
+
+    elif algorithm == "threshold":
+        new_code = (np.sign(cov) * np.maximum(np.abs(cov) - regularization, 0)).T
+        if positive:
+            np.clip(new_code, 0, None, out=new_code)
+
+    elif algorithm == "omp":
+        new_code = orthogonal_mp_gram(
+            Gram=gram,
+            Xy=cov,
+            n_nonzero_coefs=int(regularization),
+            tol=None,
+            norms_squared=row_norms(X, squared=True),
+            copy_Xy=copy_cov,
+        ).T
+
+    return new_code.reshape(n_samples, n_components)
+
+
+@validate_params(
+    {
+        "X": ["array-like"],
+        "dictionary": ["array-like"],
+        "gram": ["array-like", None],
+        "cov": ["array-like", None],
+        "algorithm": [
+            StrOptions({"lasso_lars", "lasso_cd", "lars", "omp", "threshold"})
+        ],
+        "n_nonzero_coefs": [Interval(Integral, 1, None, closed="left"), None],
+        "alpha": [Interval(Real, 0, None, closed="left"), None],
+        "copy_cov": ["boolean"],
+        "init": ["array-like", None],
+        "max_iter": [Interval(Integral, 0, None, closed="left")],
+        "n_jobs": [Integral, None],
+        "check_input": ["boolean"],
+        "verbose": ["verbose"],
+        "positive": ["boolean"],
+    },
+    prefer_skip_nested_validation=True,
+)
+# XXX : could be moved to the linear_model module
+def sparse_encode(
+    X,
+    dictionary,
+    *,
+    gram=None,
+    cov=None,
+    algorithm="lasso_lars",
+    n_nonzero_coefs=None,
+    alpha=None,
+    copy_cov=True,
+    init=None,
+    max_iter=1000,
+    n_jobs=None,
+    check_input=True,
+    verbose=0,
+    positive=False,
+):
+    """Sparse coding.
+
+    Each row of the result is the solution to a sparse coding problem.
+    The goal is to find a sparse array `code` such that::
+
+        X ~= code * dictionary
+
+    Read more in the :ref:`User Guide <SparseCoder>`.
+
+    Parameters
+    ----------
+    X : array-like of shape (n_samples, n_features)
+        Data matrix.
+
+    dictionary : array-like of shape (n_components, n_features)
+        The dictionary matrix against which to solve the sparse coding of
+        the data. Some of the algorithms assume normalized rows for meaningful
+        output.
+
+    gram : array-like of shape (n_components, n_components), default=None
+        Precomputed Gram matrix, `dictionary * dictionary'`.
+
+    cov : array-like of shape (n_components, n_samples), default=None
+        Precomputed covariance, `dictionary' * X`.
+
+    algorithm : {'lasso_lars', 'lasso_cd', 'lars', 'omp', 'threshold'}, \
+            default='lasso_lars'
+        The algorithm used:
+
+        * `'lars'`: uses the least angle regression method
+          (`linear_model.lars_path`);
+        * `'lasso_lars'`: uses Lars to compute the Lasso solution;
+        * `'lasso_cd'`: uses the coordinate descent method to compute the
+          Lasso solution (`linear_model.Lasso`). lasso_lars will be faster if
+          the estimated components are sparse;
+        * `'omp'`: uses orthogonal matching pursuit to estimate the sparse
+          solution;
+        * `'threshold'`: squashes to zero all coefficients less than
+          regularization from the projection `dictionary * data'`.
+
+    n_nonzero_coefs : int, default=None
+        Number of nonzero coefficients to target in each column of the
+        solution. This is only used by `algorithm='lars'` and `algorithm='omp'`
+        and is overridden by `alpha` in the `omp` case. If `None`, then
+        `n_nonzero_coefs=int(n_features / 10)`.
+
+    alpha : float, default=None
+        If `algorithm='lasso_lars'` or `algorithm='lasso_cd'`, `alpha` is the
+        penalty applied to the L1 norm.
+        If `algorithm='threshold'`, `alpha` is the absolute value of the
+        threshold below which coefficients will be squashed to zero.
+        If `algorithm='omp'`, `alpha` is the tolerance parameter: the value of
+        the reconstruction error targeted. In this case, it overrides
+        `n_nonzero_coefs`.
+        If `None`, default to 1.
+
+    copy_cov : bool, default=True
+        Whether to copy the precomputed covariance matrix; if `False`, it may
+        be overwritten.
+
+    init : ndarray of shape (n_samples, n_components), default=None
+        Initialization value of the sparse codes. Only used if
+        `algorithm='lasso_cd'`.
+
+    max_iter : int, default=1000
+        Maximum number of iterations to perform if `algorithm='lasso_cd'` or
+        `'lasso_lars'`.
+
+    n_jobs : int, default=None
+        Number of parallel jobs to run.
+        ``None`` means 1 unless in a :obj:`joblib.parallel_backend` context.
+        ``-1`` means using all processors. See :term:`Glossary <n_jobs>`
+        for more details.
+
+    check_input : bool, default=True
+        If `False`, the input arrays X and dictionary will not be checked.
+
+    verbose : int, default=0
+        Controls the verbosity; the higher, the more messages.
+
+    positive : bool, default=False
+        Whether to enforce positivity when finding the encoding.
+
+        .. versionadded:: 0.20
+
+    Returns
+    -------
+    code : ndarray of shape (n_samples, n_components)
+        The sparse codes.
+
+    See Also
+    --------
+    sklearn.linear_model.lars_path : Compute Least Angle Regression or Lasso
+        path using LARS algorithm.
+    sklearn.linear_model.orthogonal_mp : Solves Orthogonal Matching Pursuit problems.
+    sklearn.linear_model.Lasso : Train Linear Model with L1 prior as regularizer.
+    SparseCoder : Find a sparse representation of data from a fixed precomputed
+        dictionary.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from sklearn.decomposition import sparse_encode
+    >>> X = np.array([[-1, -1, -1], [0, 0, 3]])
+    >>> dictionary = np.array(
+    ...     [[0, 1, 0],
+    ...      [-1, -1, 2],
+    ...      [1, 1, 1],
+    ...      [0, 1, 1],
+    ...      [0, 2, 1]],
+    ...    dtype=np.float64
+    ... )
+    >>> sparse_encode(X, dictionary, alpha=1e-10)
+    array([[ 0.,  0., -1.,  0.,  0.],
+           [ 0.,  1.,  1.,  0.,  0.]])
+    """
+    if check_input:
+        if algorithm == "lasso_cd":
+            dictionary = check_array(
+                dictionary, order="C", dtype=[np.float64, np.float32]
+            )
+            X = check_array(X, order="C", dtype=[np.float64, np.float32])
+        else:
+            dictionary = check_array(dictionary)
+            X = check_array(X)
+
+    if dictionary.shape[1] != X.shape[1]:
+        raise ValueError(
+            "Dictionary and X have different numbers of features:"
+            "dictionary.shape: {} X.shape{}".format(dictionary.shape, X.shape)
+        )
+
+    _check_positive_coding(algorithm, positive)
+
+    return _sparse_encode(
+        X,
+        dictionary,
+        gram=gram,
+        cov=cov,
+        algorithm=algorithm,
+        n_nonzero_coefs=n_nonzero_coefs,
+        alpha=alpha,
+        copy_cov=copy_cov,
+        init=init,
+        max_iter=max_iter,
+        n_jobs=n_jobs,
+        verbose=verbose,
+        positive=positive,
+    )
+
+
+def _sparse_encode(
+    X,
+    dictionary,
+    *,
+    gram=None,
+    cov=None,
+    algorithm="lasso_lars",
+    n_nonzero_coefs=None,
+    alpha=None,
+    copy_cov=True,
+    init=None,
+    max_iter=1000,
+    n_jobs=None,
+    verbose=0,
+    positive=False,
+):
+    """Sparse coding without input/parameter validation."""
+
+    n_samples, n_features = X.shape
+    n_components = dictionary.shape[0]
+
+    if algorithm in ("lars", "omp"):
+        regularization = n_nonzero_coefs
+        if regularization is None:
+            regularization = min(max(n_features / 10, 1), n_components)
+    else:
+        regularization = alpha
+        if regularization is None:
+            regularization = 1.0
+
+    if gram is None and algorithm != "threshold":
+        gram = np.dot(dictionary, dictionary.T)
+
+    if cov is None and algorithm != "lasso_cd":
+        copy_cov = False
+        cov = np.dot(dictionary, X.T)
+
+    if effective_n_jobs(n_jobs) == 1 or algorithm == "threshold":
+        code = _sparse_encode_precomputed(
+            X,
+            dictionary,
+            gram=gram,
+            cov=cov,
+            algorithm=algorithm,
+            regularization=regularization,
+            copy_cov=copy_cov,
+            init=init,
+            max_iter=max_iter,
+            verbose=verbose,
+            positive=positive,
+        )
+        return code
+
+    # Enter parallel code block
+    n_samples = X.shape[0]
+    n_components = dictionary.shape[0]
+    code = np.empty((n_samples, n_components))
+    slices = list(gen_even_slices(n_samples, effective_n_jobs(n_jobs)))
+
+    code_views = Parallel(n_jobs=n_jobs, verbose=verbose)(
+        delayed(_sparse_encode_precomputed)(
+            X[this_slice],
+            dictionary,
+            gram=gram,
+            cov=cov[:, this_slice] if cov is not None else None,
+            algorithm=algorithm,
+            regularization=regularization,
+            copy_cov=copy_cov,
+            init=init[this_slice] if init is not None else None,
+            max_iter=max_iter,
+            verbose=verbose,
+            positive=positive,
+        )
+        for this_slice in slices
+    )
+    for this_slice, this_view in zip(slices, code_views):
+        code[this_slice] = this_view
+    return code
+
+
+def _update_dict(
+    dictionary,
+    Y,
+    code,
+    A=None,
+    B=None,
+    verbose=False,
+    random_state=None,
+    positive=False,
+):
+    """Update the dense dictionary factor in place.
+
+    Parameters
+    ----------
+    dictionary : ndarray of shape (n_components, n_features)
+        Value of the dictionary at the previous iteration.
+
+    Y : ndarray of shape (n_samples, n_features)
+        Data matrix.
+
+    code : ndarray of shape (n_samples, n_components)
+        Sparse coding of the data against which to optimize the dictionary.
+
+    A : ndarray of shape (n_components, n_components), default=None
+        Together with `B`, sufficient stats of the online model to update the
+        dictionary.
+
+    B : ndarray of shape (n_features, n_components), default=None
+        Together with `A`, sufficient stats of the online model to update the
+        dictionary.
+
+    verbose: bool, default=False
+        Degree of output the procedure will print.
+
+    random_state : int, RandomState instance or None, default=None
+        Used for randomly initializing the dictionary. Pass an int for
+        reproducible results across multiple function calls.
+        See :term:`Glossary <random_state>`.
+
+    positive : bool, default=False
+        Whether to enforce positivity when finding the dictionary.
+
+        .. versionadded:: 0.20
+    """
+    n_samples, n_components = code.shape
+    random_state = check_random_state(random_state)
+
+    if A is None:
+        A = code.T @ code
+    if B is None:
+        B = Y.T @ code
+
+    n_unused = 0
+
+    for k in range(n_components):
+        if A[k, k] > 1e-6:
+            # 1e-6 is arbitrary but consistent with the spams implementation
+            dictionary[k] += (B[:, k] - A[k] @ dictionary) / A[k, k]
+        else:
+            # kth atom is almost never used -> sample a new one from the data
+            newd = Y[random_state.choice(n_samples)]
+
+            # add small noise to avoid making the sparse coding ill conditioned
+            noise_level = 0.01 * (newd.std() or 1)  # avoid 0 std
+            noise = random_state.normal(0, noise_level, size=len(newd))
+
+            dictionary[k] = newd + noise
+            code[:, k] = 0
+            n_unused += 1
+
+        if positive:
+            np.clip(dictionary[k], 0, None, out=dictionary[k])
+
+        # Projection on the constraint set ||V_k|| <= 1
+        dictionary[k] /= max(linalg.norm(dictionary[k]), 1)
+
+    if verbose and n_unused > 0:
+        print(f"{n_unused} unused atoms resampled.")
+
+
+def _dict_learning(
+    X,
+    n_components,
+    *,
+    alpha,
+    max_iter,
+    tol,
+    method,
+    n_jobs,
+    dict_init,
+    code_init,
+    callback,
+    verbose,
+    random_state,
+    return_n_iter,
+    positive_dict,
+    positive_code,
+    method_max_iter,
+):
+    """Main dictionary learning algorithm"""
+    t0 = time.time()
+    # Init the code and the dictionary with SVD of Y
+    if code_init is not None and dict_init is not None:
+        code = np.array(code_init, order="F")
+        # Don't copy V, it will happen below
+        dictionary = dict_init
+    else:
+        code, S, dictionary = linalg.svd(X, full_matrices=False)
+        # flip the initial code's sign to enforce deterministic output
+        code, dictionary = svd_flip(code, dictionary)
+        dictionary = S[:, np.newaxis] * dictionary
+    r = len(dictionary)
+    if n_components <= r:  # True even if n_components=None
+        code = code[:, :n_components]
+        dictionary = dictionary[:n_components, :]
+    else:
+        code = np.c_[code, np.zeros((len(code), n_components - r))]
+        dictionary = np.r_[
+            dictionary, np.zeros((n_components - r, dictionary.shape[1]))
+        ]
+
+    # Fortran-order dict better suited for the sparse coding which is the
+    # bottleneck of this algorithm.
+    dictionary = np.asfortranarray(dictionary)
+
+    errors = []
+    current_cost = np.nan
+
+    if verbose == 1:
+        print("[dict_learning]", end=" ")
+
+    # If max_iter is 0, number of iterations returned should be zero
+    ii = -1
+
+    for ii in range(max_iter):
+        dt = time.time() - t0
+        if verbose == 1:
+            sys.stdout.write(".")
+            sys.stdout.flush()
+        elif verbose:
+            print(
+                "Iteration % 3i (elapsed time: % 3is, % 4.1fmn, current cost % 7.3f)"
+                % (ii, dt, dt / 60, current_cost)
+            )
+
+        # Update code
+        code = sparse_encode(
+            X,
+            dictionary,
+            algorithm=method,
+            alpha=alpha,
+            init=code,
+            n_jobs=n_jobs,
+            positive=positive_code,
+            max_iter=method_max_iter,
+            verbose=verbose,
+        )
+
+        # Update dictionary in place
+        _update_dict(
+            dictionary,
+            X,
+            code,
+            verbose=verbose,
+            random_state=random_state,
+            positive=positive_dict,
+        )
+
+        # Cost function
+        current_cost = 0.5 * np.sum((X - code @ dictionary) ** 2) + alpha * np.sum(
+            np.abs(code)
+        )
+        errors.append(current_cost)
+
+        if ii > 0:
+            dE = errors[-2] - errors[-1]
+            # assert(dE >= -tol * errors[-1])
+            if dE < tol * errors[-1]:
+                if verbose == 1:
+                    # A line return
+                    print("")
+                elif verbose:
+                    print("--- Convergence reached after %d iterations" % ii)
+                break
+        if ii % 5 == 0 and callback is not None:
+            callback(locals())
+
+    if return_n_iter:
+        return code, dictionary, errors, ii + 1
+    else:
+        return code, dictionary, errors
+
+
+@validate_params(
+    {
+        "X": ["array-like"],
+        "return_code": ["boolean"],
+        "method": [StrOptions({"cd", "lars"})],
+        "method_max_iter": [Interval(Integral, 0, None, closed="left")],
+    },
+    prefer_skip_nested_validation=False,
+)
+def dict_learning_online(
+    X,
+    n_components=2,
+    *,
+    alpha=1,
+    max_iter=100,
+    return_code=True,
+    dict_init=None,
+    callback=None,
+    batch_size=256,
+    verbose=False,
+    shuffle=True,
+    n_jobs=None,
+    method="lars",
+    random_state=None,
+    positive_dict=False,
+    positive_code=False,
+    method_max_iter=1000,
+    tol=1e-3,
+    max_no_improvement=10,
+):
+    """Solve a dictionary learning matrix factorization problem online.
+
+    Finds the best dictionary and the corresponding sparse code for
+    approximating the data matrix X by solving::
+
+        (U^*, V^*) = argmin 0.5 || X - U V ||_Fro^2 + alpha * || U ||_1,1
+                     (U,V)
+                     with || V_k ||_2 = 1 for all  0 <= k < n_components
+
+    where V is the dictionary and U is the sparse code. ||.||_Fro stands for
+    the Frobenius norm and ||.||_1,1 stands for the entry-wise matrix norm
+    which is the sum of the absolute values of all the entries in the matrix.
+    This is accomplished by repeatedly iterating over mini-batches by slicing
+    the input data.
+
+    Read more in the :ref:`User Guide <DictionaryLearning>`.
+
+    Parameters
+    ----------
+    X : array-like of shape (n_samples, n_features)
+        Data matrix.
+
+    n_components : int or None, default=2
+        Number of dictionary atoms to extract. If None, then ``n_components``
+        is set to ``n_features``.
+
+    alpha : float, default=1
+        Sparsity controlling parameter.
+
+    max_iter : int, default=100
+        Maximum number of iterations over the complete dataset before
+        stopping independently of any early stopping criterion heuristics.
+
+        .. versionadded:: 1.1
+
+    return_code : bool, default=True
+        Whether to also return the code U or just the dictionary `V`.
+
+    dict_init : ndarray of shape (n_components, n_features), default=None
+        Initial values for the dictionary for warm restart scenarios.
+        If `None`, the initial values for the dictionary are created
+        with an SVD decomposition of the data via
+        :func:`~sklearn.utils.extmath.randomized_svd`.
+
+    callback : callable, default=None
+        A callable that gets invoked at the end of each iteration.
+
+    batch_size : int, default=256
+        The number of samples to take in each batch.
+
+        .. versionchanged:: 1.3
+           The default value of `batch_size` changed from 3 to 256 in version 1.3.
+
+    verbose : bool, default=False
+        To control the verbosity of the procedure.
+
+    shuffle : bool, default=True
+        Whether to shuffle the data before splitting it in batches.
+
+    n_jobs : int, default=None
+        Number of parallel jobs to run.
+        ``None`` means 1 unless in a :obj:`joblib.parallel_backend` context.
+        ``-1`` means using all processors. See :term:`Glossary <n_jobs>`
+        for more details.
+
+    method : {'lars', 'cd'}, default='lars'
+        * `'lars'`: uses the least angle regression method to solve the lasso
+          problem (`linear_model.lars_path`);
+        * `'cd'`: uses the coordinate descent method to compute the
+          Lasso solution (`linear_model.Lasso`). Lars will be faster if
+          the estimated components are sparse.
+
+    random_state : int, RandomState instance or None, default=None
+        Used for initializing the dictionary when ``dict_init`` is not
+        specified, randomly shuffling the data when ``shuffle`` is set to
+        ``True``, and updating the dictionary. Pass an int for reproducible
+        results across multiple function calls.
+        See :term:`Glossary <random_state>`.
+
+    positive_dict : bool, default=False
+        Whether to enforce positivity when finding the dictionary.
+
+        .. versionadded:: 0.20
+
+    positive_code : bool, default=False
+        Whether to enforce positivity when finding the code.
+
+        .. versionadded:: 0.20
+
+    method_max_iter : int, default=1000
+        Maximum number of iterations to perform when solving the lasso problem.
+
+        .. versionadded:: 0.22
+
+    tol : float, default=1e-3
+        Control early stopping based on the norm of the differences in the
+        dictionary between 2 steps.
+
+        To disable early stopping based on changes in the dictionary, set
+        `tol` to 0.0.
+
+        .. versionadded:: 1.1
+
+    max_no_improvement : int, default=10
+        Control early stopping based on the consecutive number of mini batches
+        that does not yield an improvement on the smoothed cost function.
+
+        To disable convergence detection based on cost function, set
+        `max_no_improvement` to None.
+
+        .. versionadded:: 1.1
+
+    Returns
+    -------
+    code : ndarray of shape (n_samples, n_components),
+        The sparse code (only returned if `return_code=True`).
+
+    dictionary : ndarray of shape (n_components, n_features),
+        The solutions to the dictionary learning problem.
+
+    n_iter : int
+        Number of iterations run. Returned only if `return_n_iter` is
+        set to `True`.
+
+    See Also
+    --------
+    dict_learning : Solve a dictionary learning matrix factorization problem.
+    DictionaryLearning : Find a dictionary that sparsely encodes data.
+    MiniBatchDictionaryLearning : A faster, less accurate, version of the dictionary
+        learning algorithm.
+    SparsePCA : Sparse Principal Components Analysis.
+    MiniBatchSparsePCA : Mini-batch Sparse Principal Components Analysis.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from sklearn.datasets import make_sparse_coded_signal
+    >>> from sklearn.decomposition import dict_learning_online
+    >>> X, _, _ = make_sparse_coded_signal(
+    ...     n_samples=30, n_components=15, n_features=20, n_nonzero_coefs=10,
+    ...     random_state=42,
+    ... )
+    >>> U, V = dict_learning_online(
+    ...     X, n_components=15, alpha=0.2, max_iter=20, batch_size=3, random_state=42
+    ... )
+
+    We can check the level of sparsity of `U`:
+
+    >>> np.mean(U == 0)
+    np.float64(0.53)
+
+    We can compare the average squared euclidean norm of the reconstruction
+    error of the sparse coded signal relative to the squared euclidean norm of
+    the original signal:
+
+    >>> X_hat = U @ V
+    >>> np.mean(np.sum((X_hat - X) ** 2, axis=1) / np.sum(X ** 2, axis=1))
+    np.float64(0.053)
+    """
+    transform_algorithm = "lasso_" + method
+
+    est = MiniBatchDictionaryLearning(
+        n_components=n_components,
+        alpha=alpha,
+        max_iter=max_iter,
+        n_jobs=n_jobs,
+        fit_algorithm=method,
+        batch_size=batch_size,
+        shuffle=shuffle,
+        dict_init=dict_init,
+        random_state=random_state,
+        transform_algorithm=transform_algorithm,
+        transform_alpha=alpha,
+        positive_code=positive_code,
+        positive_dict=positive_dict,
+        transform_max_iter=method_max_iter,
+        verbose=verbose,
+        callback=callback,
+        tol=tol,
+        max_no_improvement=max_no_improvement,
+    ).fit(X)
+
+    if not return_code:
+        return est.components_
+    else:
+        code = est.transform(X)
+        return code, est.components_
+
+
+@validate_params(
+    {
+        "X": ["array-like"],
+        "method": [StrOptions({"lars", "cd"})],
+        "return_n_iter": ["boolean"],
+        "method_max_iter": [Interval(Integral, 0, None, closed="left")],
+    },
+    prefer_skip_nested_validation=False,
+)
+def dict_learning(
+    X,
+    n_components,
+    *,
+    alpha,
+    max_iter=100,
+    tol=1e-8,
+    method="lars",
+    n_jobs=None,
+    dict_init=None,
+    code_init=None,
+    callback=None,
+    verbose=False,
+    random_state=None,
+    return_n_iter=False,
+    positive_dict=False,
+    positive_code=False,
+    method_max_iter=1000,
+):
+    """Solve a dictionary learning matrix factorization problem.
+
+    Finds the best dictionary and the corresponding sparse code for
+    approximating the data matrix X by solving::
+
+        (U^*, V^*) = argmin 0.5 || X - U V ||_Fro^2 + alpha * || U ||_1,1
+                     (U,V)
+                    with || V_k ||_2 = 1 for all  0 <= k < n_components
+
+    where V is the dictionary and U is the sparse code. ||.||_Fro stands for
+    the Frobenius norm and ||.||_1,1 stands for the entry-wise matrix norm
+    which is the sum of the absolute values of all the entries in the matrix.
+
+    Read more in the :ref:`User Guide <DictionaryLearning>`.
+
+    Parameters
+    ----------
+    X : array-like of shape (n_samples, n_features)
+        Data matrix.
+
+    n_components : int
+        Number of dictionary atoms to extract.
+
+    alpha : int or float
+        Sparsity controlling parameter.
+
+    max_iter : int, default=100
+        Maximum number of iterations to perform.
+
+    tol : float, default=1e-8
+        Tolerance for the stopping condition.
+
+    method : {'lars', 'cd'}, default='lars'
+        The method used:
+
+        * `'lars'`: uses the least angle regression method to solve the lasso
+           problem (`linear_model.lars_path`);
+        * `'cd'`: uses the coordinate descent method to compute the
+          Lasso solution (`linear_model.Lasso`). Lars will be faster if
+          the estimated components are sparse.
+
+    n_jobs : int, default=None
+        Number of parallel jobs to run.
+        ``None`` means 1 unless in a :obj:`joblib.parallel_backend` context.
+        ``-1`` means using all processors. See :term:`Glossary <n_jobs>`
+        for more details.
+
+    dict_init : ndarray of shape (n_components, n_features), default=None
+        Initial value for the dictionary for warm restart scenarios. Only used
+        if `code_init` and `dict_init` are not None.
+
+    code_init : ndarray of shape (n_samples, n_components), default=None
+        Initial value for the sparse code for warm restart scenarios. Only used
+        if `code_init` and `dict_init` are not None.
+
+    callback : callable, default=None
+        Callable that gets invoked every five iterations.
+
+    verbose : bool, default=False
+        To control the verbosity of the procedure.
+
+    random_state : int, RandomState instance or None, default=None
+        Used for randomly initializing the dictionary. Pass an int for
+        reproducible results across multiple function calls.
+        See :term:`Glossary <random_state>`.
+
+    return_n_iter : bool, default=False
+        Whether or not to return the number of iterations.
+
+    positive_dict : bool, default=False
+        Whether to enforce positivity when finding the dictionary.
+
+        .. versionadded:: 0.20
+
+    positive_code : bool, default=False
+        Whether to enforce positivity when finding the code.
+
+        .. versionadded:: 0.20
+
+    method_max_iter : int, default=1000
+        Maximum number of iterations to perform.
+
+        .. versionadded:: 0.22
+
+    Returns
+    -------
+    code : ndarray of shape (n_samples, n_components)
+        The sparse code factor in the matrix factorization.
+
+    dictionary : ndarray of shape (n_components, n_features),
+        The dictionary factor in the matrix factorization.
+
+    errors : array
+        Vector of errors at each iteration.
+
+    n_iter : int
+        Number of iterations run. Returned only if `return_n_iter` is
+        set to True.
+
+    See Also
+    --------
+    dict_learning_online : Solve a dictionary learning matrix factorization
+        problem online.
+    DictionaryLearning : Find a dictionary that sparsely encodes data.
+    MiniBatchDictionaryLearning : A faster, less accurate version
+        of the dictionary learning algorithm.
+    SparsePCA : Sparse Principal Components Analysis.
+    MiniBatchSparsePCA : Mini-batch Sparse Principal Components Analysis.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from sklearn.datasets import make_sparse_coded_signal
+    >>> from sklearn.decomposition import dict_learning
+    >>> X, _, _ = make_sparse_coded_signal(
+    ...     n_samples=30, n_components=15, n_features=20, n_nonzero_coefs=10,
+    ...     random_state=42,
+    ... )
+    >>> U, V, errors = dict_learning(X, n_components=15, alpha=0.1, random_state=42)
+
+    We can check the level of sparsity of `U`:
+
+    >>> np.mean(U == 0)
+    np.float64(0.62)
+
+    We can compare the average squared euclidean norm of the reconstruction
+    error of the sparse coded signal relative to the squared euclidean norm of
+    the original signal:
+
+    >>> X_hat = U @ V
+    >>> np.mean(np.sum((X_hat - X) ** 2, axis=1) / np.sum(X ** 2, axis=1))
+    np.float64(0.0192)
+    """
+    estimator = DictionaryLearning(
+        n_components=n_components,
+        alpha=alpha,
+        max_iter=max_iter,
+        tol=tol,
+        fit_algorithm=method,
+        n_jobs=n_jobs,
+        dict_init=dict_init,
+        callback=callback,
+        code_init=code_init,
+        verbose=verbose,
+        random_state=random_state,
+        positive_code=positive_code,
+        positive_dict=positive_dict,
+        transform_max_iter=method_max_iter,
+    ).set_output(transform="default")
+    code = estimator.fit_transform(X)
+    if return_n_iter:
+        return (
+            code,
+            estimator.components_,
+            estimator.error_,
+            estimator.n_iter_,
+        )
+    return code, estimator.components_, estimator.error_
+
+
+class _BaseSparseCoding(ClassNamePrefixFeaturesOutMixin, TransformerMixin):
+    """Base class from SparseCoder and DictionaryLearning algorithms."""
+
+    def __init__(
+        self,
+        transform_algorithm,
+        transform_n_nonzero_coefs,
+        transform_alpha,
+        split_sign,
+        n_jobs,
+        positive_code,
+        transform_max_iter,
+    ):
+        self.transform_algorithm = transform_algorithm
+        self.transform_n_nonzero_coefs = transform_n_nonzero_coefs
+        self.transform_alpha = transform_alpha
+        self.transform_max_iter = transform_max_iter
+        self.split_sign = split_sign
+        self.n_jobs = n_jobs
+        self.positive_code = positive_code
+
+    def _transform(self, X, dictionary):
+        """Private method allowing to accommodate both DictionaryLearning and
+        SparseCoder."""
+        X = validate_data(self, X, reset=False)
+
+        if hasattr(self, "alpha") and self.transform_alpha is None:
+            transform_alpha = self.alpha
+        else:
+            transform_alpha = self.transform_alpha
+
+        code = sparse_encode(
+            X,
+            dictionary,
+            algorithm=self.transform_algorithm,
+            n_nonzero_coefs=self.transform_n_nonzero_coefs,
+            alpha=transform_alpha,
+            max_iter=self.transform_max_iter,
+            n_jobs=self.n_jobs,
+            positive=self.positive_code,
+        )
+
+        if self.split_sign:
+            # feature vector is split into a positive and negative side
+            n_samples, n_features = code.shape
+            split_code = np.empty((n_samples, 2 * n_features))
+            split_code[:, :n_features] = np.maximum(code, 0)
+            split_code[:, n_features:] = -np.minimum(code, 0)
+            code = split_code
+
+        return code
+
+    def transform(self, X):
+        """Encode the data as a sparse combination of the dictionary atoms.
+
+        Coding method is determined by the object parameter
+        `transform_algorithm`.
+
+        Parameters
+        ----------
+        X : ndarray of shape (n_samples, n_features)
+            Test data to be transformed, must have the same number of
+            features as the data used to train the model.
+
+        Returns
+        -------
+        X_new : ndarray of shape (n_samples, n_components)
+            Transformed data.
+        """
+        check_is_fitted(self)
+        return self._transform(X, self.components_)
+
+    def _inverse_transform(self, code, dictionary):
+        """Private method allowing to accommodate both DictionaryLearning and
+        SparseCoder."""
+        code = check_array(code)
+        # compute number of expected features in code
+        expected_n_components = dictionary.shape[0]
+        if self.split_sign:
+            expected_n_components += expected_n_components
+        if not code.shape[1] == expected_n_components:
+            raise ValueError(
+                "The number of components in the code is different from the "
+                "number of components in the dictionary."
+                f"Expected {expected_n_components}, got {code.shape[1]}."
+            )
+        if self.split_sign:
+            n_samples, n_features = code.shape
+            n_features //= 2
+            code = code[:, :n_features] - code[:, n_features:]
+
+        return code @ dictionary
+
+    def inverse_transform(self, X):
+        """Transform data back to its original space.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_components)
+            Data to be transformed back. Must have the same number of
+            components as the data used to train the model.
+
+        Returns
+        -------
+        X_original : ndarray of shape (n_samples, n_features)
+            Transformed data.
+        """
+        check_is_fitted(self)
+        return self._inverse_transform(X, self.components_)
+
+
+class SparseCoder(_BaseSparseCoding, BaseEstimator):
+    """Sparse coding.
+
+    Finds a sparse representation of data against a fixed, precomputed
+    dictionary.
+
+    Each row of the result is the solution to a sparse coding problem.
+    The goal is to find a sparse array `code` such that::
+
+        X ~= code * dictionary
+
+    Read more in the :ref:`User Guide <SparseCoder>`.
+
+    Parameters
+    ----------
+    dictionary : ndarray of shape (n_components, n_features)
+        The dictionary atoms used for sparse coding. Lines are assumed to be
+        normalized to unit norm.
+
+    transform_algorithm : {'lasso_lars', 'lasso_cd', 'lars', 'omp', \
+            'threshold'}, default='omp'
+        Algorithm used to transform the data:
+
+        - `'lars'`: uses the least angle regression method
+          (`linear_model.lars_path`);
+        - `'lasso_lars'`: uses Lars to compute the Lasso solution;
+        - `'lasso_cd'`: uses the coordinate descent method to compute the
+          Lasso solution (linear_model.Lasso). `'lasso_lars'` will be faster if
+          the estimated components are sparse;
+        - `'omp'`: uses orthogonal matching pursuit to estimate the sparse
+          solution;
+        - `'threshold'`: squashes to zero all coefficients less than alpha from
+          the projection ``dictionary * X'``.
+
+    transform_n_nonzero_coefs : int, default=None
+        Number of nonzero coefficients to target in each column of the
+        solution. This is only used by `algorithm='lars'` and `algorithm='omp'`
+        and is overridden by `alpha` in the `omp` case. If `None`, then
+        `transform_n_nonzero_coefs=int(n_features / 10)`.
+
+    transform_alpha : float, default=None
+        If `algorithm='lasso_lars'` or `algorithm='lasso_cd'`, `alpha` is the
+        penalty applied to the L1 norm.
+        If `algorithm='threshold'`, `alpha` is the absolute value of the
+        threshold below which coefficients will be squashed to zero.
+        If `algorithm='omp'`, `alpha` is the tolerance parameter: the value of
+        the reconstruction error targeted. In this case, it overrides
+        `n_nonzero_coefs`.
+        If `None`, default to 1.
+
+    split_sign : bool, default=False
+        Whether to split the sparse feature vector into the concatenation of
+        its negative part and its positive part. This can improve the
+        performance of downstream classifiers.
+
+    n_jobs : int, default=None
+        Number of parallel jobs to run.
+        ``None`` means 1 unless in a :obj:`joblib.parallel_backend` context.
+        ``-1`` means using all processors. See :term:`Glossary <n_jobs>`
+        for more details.
+
+    positive_code : bool, default=False
+        Whether to enforce positivity when finding the code.
+
+        .. versionadded:: 0.20
+
+    transform_max_iter : int, default=1000
+        Maximum number of iterations to perform if `algorithm='lasso_cd'` or
+        `lasso_lars`.
+
+        .. versionadded:: 0.22
+
+    Attributes
+    ----------
+    n_components_ : int
+        Number of atoms.
+
+    n_features_in_ : int
+        Number of features seen during :term:`fit`.
+
+        .. versionadded:: 0.24
+
+    feature_names_in_ : ndarray of shape (`n_features_in_`,)
+        Names of features seen during :term:`fit`. Defined only when `X`
+        has feature names that are all strings.
+
+        .. versionadded:: 1.0
+
+    See Also
+    --------
+    DictionaryLearning : Find a dictionary that sparsely encodes data.
+    MiniBatchDictionaryLearning : A faster, less accurate, version of the
+        dictionary learning algorithm.
+    MiniBatchSparsePCA : Mini-batch Sparse Principal Components Analysis.
+    SparsePCA : Sparse Principal Components Analysis.
+    sparse_encode : Sparse coding where each row of the result is the solution
+        to a sparse coding problem.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from sklearn.decomposition import SparseCoder
+    >>> X = np.array([[-1, -1, -1], [0, 0, 3]])
+    >>> dictionary = np.array(
+    ...     [[0, 1, 0],
+    ...      [-1, -1, 2],
+    ...      [1, 1, 1],
+    ...      [0, 1, 1],
+    ...      [0, 2, 1]],
+    ...    dtype=np.float64
+    ... )
+    >>> coder = SparseCoder(
+    ...     dictionary=dictionary, transform_algorithm='lasso_lars',
+    ...     transform_alpha=1e-10,
+    ... )
+    >>> coder.transform(X)
+    array([[ 0.,  0., -1.,  0.,  0.],
+           [ 0.,  1.,  1.,  0.,  0.]])
+    """
+
+    def __init__(
+        self,
+        dictionary,
+        *,
+        transform_algorithm="omp",
+        transform_n_nonzero_coefs=None,
+        transform_alpha=None,
+        split_sign=False,
+        n_jobs=None,
+        positive_code=False,
+        transform_max_iter=1000,
+    ):
+        super().__init__(
+            transform_algorithm,
+            transform_n_nonzero_coefs,
+            transform_alpha,
+            split_sign,
+            n_jobs,
+            positive_code,
+            transform_max_iter,
+        )
+        self.dictionary = dictionary
+
+    def fit(self, X, y=None):
+        """Do nothing and return the estimator unchanged.
+
+        This method is just there to implement the usual API and hence
+        work in pipelines.
+
+        Parameters
+        ----------
+        X : Ignored
+            Not used, present for API consistency by convention.
+
+        y : Ignored
+            Not used, present for API consistency by convention.
+
+        Returns
+        -------
+        self : object
+            Returns the instance itself.
+        """
+        return self
+
+    def transform(self, X, y=None):
+        """Encode the data as a sparse combination of the dictionary atoms.
+
+        Coding method is determined by the object parameter
+        `transform_algorithm`.
+
+        Parameters
+        ----------
+        X : ndarray of shape (n_samples, n_features)
+            Training vector, where `n_samples` is the number of samples
+            and `n_features` is the number of features.
+
+        y : Ignored
+            Not used, present for API consistency by convention.
+
+        Returns
+        -------
+        X_new : ndarray of shape (n_samples, n_components)
+            Transformed data.
+        """
+        return super()._transform(X, self.dictionary)
+
+    def inverse_transform(self, X):
+        """Transform data back to its original space.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_components)
+            Data to be transformed back. Must have the same number of
+            components as the data used to train the model.
+
+        Returns
+        -------
+        X_original : ndarray of shape (n_samples, n_features)
+            Transformed data.
+        """
+        return self._inverse_transform(X, self.dictionary)
+
+    def __sklearn_tags__(self):
+        tags = super().__sklearn_tags__()
+        tags.requires_fit = False
+        tags.transformer_tags.preserves_dtype = ["float64", "float32"]
+        return tags
+
+    @property
+    def n_components_(self):
+        """Number of atoms."""
+        return self.dictionary.shape[0]
+
+    @property
+    def n_features_in_(self):
+        """Number of features seen during `fit`."""
+        return self.dictionary.shape[1]
+
+    @property
+    def _n_features_out(self):
+        """Number of transformed output features."""
+        return self.n_components_
+
+
+class DictionaryLearning(_BaseSparseCoding, BaseEstimator):
+    """Dictionary learning.
+
+    Finds a dictionary (a set of atoms) that performs well at sparsely
+    encoding the fitted data.
+
+    Solves the optimization problem::
+
+        (U^*,V^*) = argmin 0.5 || X - U V ||_Fro^2 + alpha * || U ||_1,1
+                    (U,V)
+                    with || V_k ||_2 <= 1 for all  0 <= k < n_components
+
+    ||.||_Fro stands for the Frobenius norm and ||.||_1,1 stands for
+    the entry-wise matrix norm which is the sum of the absolute values
+    of all the entries in the matrix.
+
+    Read more in the :ref:`User Guide <DictionaryLearning>`.
+
+    Parameters
+    ----------
+    n_components : int, default=None
+        Number of dictionary elements to extract. If None, then ``n_components``
+        is set to ``n_features``.
+
+    alpha : float, default=1.0
+        Sparsity controlling parameter.
+
+    max_iter : int, default=1000
+        Maximum number of iterations to perform.
+
+    tol : float, default=1e-8
+        Tolerance for numerical error.
+
+    fit_algorithm : {'lars', 'cd'}, default='lars'
+        * `'lars'`: uses the least angle regression method to solve the lasso
+          problem (:func:`~sklearn.linear_model.lars_path`);
+        * `'cd'`: uses the coordinate descent method to compute the
+          Lasso solution (:class:`~sklearn.linear_model.Lasso`). Lars will be
+          faster if the estimated components are sparse.
+
+        .. versionadded:: 0.17
+           *cd* coordinate descent method to improve speed.
+
+    transform_algorithm : {'lasso_lars', 'lasso_cd', 'lars', 'omp', \
+            'threshold'}, default='omp'
+        Algorithm used to transform the data:
+
+        - `'lars'`: uses the least angle regression method
+          (:func:`~sklearn.linear_model.lars_path`);
+        - `'lasso_lars'`: uses Lars to compute the Lasso solution.
+        - `'lasso_cd'`: uses the coordinate descent method to compute the
+          Lasso solution (:class:`~sklearn.linear_model.Lasso`). `'lasso_lars'`
+          will be faster if the estimated components are sparse.
+        - `'omp'`: uses orthogonal matching pursuit to estimate the sparse
+          solution.
+        - `'threshold'`: squashes to zero all coefficients less than alpha from
+          the projection ``dictionary * X'``.
+
+        .. versionadded:: 0.17
+           *lasso_cd* coordinate descent method to improve speed.
+
+    transform_n_nonzero_coefs : int, default=None
+        Number of nonzero coefficients to target in each column of the
+        solution. This is only used by `algorithm='lars'` and
+        `algorithm='omp'`. If `None`, then
+        `transform_n_nonzero_coefs=int(n_features / 10)`.
+
+    transform_alpha : float, default=None
+        If `algorithm='lasso_lars'` or `algorithm='lasso_cd'`, `alpha` is the
+        penalty applied to the L1 norm.
+        If `algorithm='threshold'`, `alpha` is the absolute value of the
+        threshold below which coefficients will be squashed to zero.
+        If `None`, defaults to `alpha`.
+
+        .. versionchanged:: 1.2
+            When None, default value changed from 1.0 to `alpha`.
+
+    n_jobs : int or None, default=None
+        Number of parallel jobs to run.
+        ``None`` means 1 unless in a :obj:`joblib.parallel_backend` context.
+        ``-1`` means using all processors. See :term:`Glossary <n_jobs>`
+        for more details.
+
+    code_init : ndarray of shape (n_samples, n_components), default=None
+        Initial value for the code, for warm restart. Only used if `code_init`
+        and `dict_init` are not None.
+
+    dict_init : ndarray of shape (n_components, n_features), default=None
+        Initial values for the dictionary, for warm restart. Only used if
+        `code_init` and `dict_init` are not None.
+
+    callback : callable, default=None
+        Callable that gets invoked every five iterations.
+
+        .. versionadded:: 1.3
+
+    verbose : bool, default=False
+        To control the verbosity of the procedure.
+
+    split_sign : bool, default=False
+        Whether to split the sparse feature vector into the concatenation of
+        its negative part and its positive part. This can improve the
+        performance of downstream classifiers.
+
+    random_state : int, RandomState instance or None, default=None
+        Used for initializing the dictionary when ``dict_init`` is not
+        specified, randomly shuffling the data when ``shuffle`` is set to
+        ``True``, and updating the dictionary. Pass an int for reproducible
+        results across multiple function calls.
+        See :term:`Glossary <random_state>`.
+
+    positive_code : bool, default=False
+        Whether to enforce positivity when finding the code.
+
+        .. versionadded:: 0.20
+
+    positive_dict : bool, default=False
+        Whether to enforce positivity when finding the dictionary.
+
+        .. versionadded:: 0.20
+
+    transform_max_iter : int, default=1000
+        Maximum number of iterations to perform if `algorithm='lasso_cd'` or
+        `'lasso_lars'`.
+
+        .. versionadded:: 0.22
+
+    Attributes
+    ----------
+    components_ : ndarray of shape (n_components, n_features)
+        dictionary atoms extracted from the data
+
+    error_ : array
+        vector of errors at each iteration
+
+    n_features_in_ : int
+        Number of features seen during :term:`fit`.
+
+        .. versionadded:: 0.24
+
+    feature_names_in_ : ndarray of shape (`n_features_in_`,)
+        Names of features seen during :term:`fit`. Defined only when `X`
+        has feature names that are all strings.
+
+        .. versionadded:: 1.0
+
+    n_iter_ : int
+        Number of iterations run.
+
+    See Also
+    --------
+    MiniBatchDictionaryLearning: A faster, less accurate, version of the
+        dictionary learning algorithm.
+    MiniBatchSparsePCA : Mini-batch Sparse Principal Components Analysis.
+    SparseCoder : Find a sparse representation of data from a fixed,
+        precomputed dictionary.
+    SparsePCA : Sparse Principal Components Analysis.
+
+    References
+    ----------
+
+    J. Mairal, F. Bach, J. Ponce, G. Sapiro, 2009: Online dictionary learning
+    for sparse coding (https://www.di.ens.fr/~fbach/mairal_icml09.pdf)
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from sklearn.datasets import make_sparse_coded_signal
+    >>> from sklearn.decomposition import DictionaryLearning
+    >>> X, dictionary, code = make_sparse_coded_signal(
+    ...     n_samples=30, n_components=15, n_features=20, n_nonzero_coefs=10,
+    ...     random_state=42,
+    ... )
+    >>> dict_learner = DictionaryLearning(
+    ...     n_components=15, transform_algorithm='lasso_lars', transform_alpha=0.1,
+    ...     random_state=42,
+    ... )
+    >>> X_transformed = dict_learner.fit(X).transform(X)
+
+    We can check the level of sparsity of `X_transformed`:
+
+    >>> np.mean(X_transformed == 0)
+    np.float64(0.527)
+
+    We can compare the average squared euclidean norm of the reconstruction
+    error of the sparse coded signal relative to the squared euclidean norm of
+    the original signal:
+
+    >>> X_hat = X_transformed @ dict_learner.components_
+    >>> np.mean(np.sum((X_hat - X) ** 2, axis=1) / np.sum(X ** 2, axis=1))
+    np.float64(0.056)
+    """
+
+    _parameter_constraints: dict = {
+        "n_components": [Interval(Integral, 1, None, closed="left"), None],
+        "alpha": [Interval(Real, 0, None, closed="left")],
+        "max_iter": [Interval(Integral, 0, None, closed="left")],
+        "tol": [Interval(Real, 0, None, closed="left")],
+        "fit_algorithm": [StrOptions({"lars", "cd"})],
+        "transform_algorithm": [
+            StrOptions({"lasso_lars", "lasso_cd", "lars", "omp", "threshold"})
+        ],
+        "transform_n_nonzero_coefs": [Interval(Integral, 1, None, closed="left"), None],
+        "transform_alpha": [Interval(Real, 0, None, closed="left"), None],
+        "n_jobs": [Integral, None],
+        "code_init": [np.ndarray, None],
+        "dict_init": [np.ndarray, None],
+        "callback": [callable, None],
+        "verbose": ["verbose"],
+        "split_sign": ["boolean"],
+        "random_state": ["random_state"],
+        "positive_code": ["boolean"],
+        "positive_dict": ["boolean"],
+        "transform_max_iter": [Interval(Integral, 0, None, closed="left")],
+    }
+
+    def __init__(
+        self,
+        n_components=None,
+        *,
+        alpha=1,
+        max_iter=1000,
+        tol=1e-8,
+        fit_algorithm="lars",
+        transform_algorithm="omp",
+        transform_n_nonzero_coefs=None,
+        transform_alpha=None,
+        n_jobs=None,
+        code_init=None,
+        dict_init=None,
+        callback=None,
+        verbose=False,
+        split_sign=False,
+        random_state=None,
+        positive_code=False,
+        positive_dict=False,
+        transform_max_iter=1000,
+    ):
+        super().__init__(
+            transform_algorithm,
+            transform_n_nonzero_coefs,
+            transform_alpha,
+            split_sign,
+            n_jobs,
+            positive_code,
+            transform_max_iter,
+        )
+        self.n_components = n_components
+        self.alpha = alpha
+        self.max_iter = max_iter
+        self.tol = tol
+        self.fit_algorithm = fit_algorithm
+        self.code_init = code_init
+        self.dict_init = dict_init
+        self.callback = callback
+        self.verbose = verbose
+        self.random_state = random_state
+        self.positive_dict = positive_dict
+
+    def fit(self, X, y=None):
+        """Fit the model from data in X.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+            Training vector, where `n_samples` is the number of samples
+            and `n_features` is the number of features.
+
+        y : Ignored
+            Not used, present for API consistency by convention.
+
+        Returns
+        -------
+        self : object
+            Returns the instance itself.
+        """
+        self.fit_transform(X)
+        return self
+
+    @_fit_context(prefer_skip_nested_validation=True)
+    def fit_transform(self, X, y=None):
+        """Fit the model from data in X and return the transformed data.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+            Training vector, where `n_samples` is the number of samples
+            and `n_features` is the number of features.
+
+        y : Ignored
+            Not used, present for API consistency by convention.
+
+        Returns
+        -------
+        V : ndarray of shape (n_samples, n_components)
+            Transformed data.
+        """
+        _check_positive_coding(method=self.fit_algorithm, positive=self.positive_code)
+
+        method = "lasso_" + self.fit_algorithm
+
+        random_state = check_random_state(self.random_state)
+        X = validate_data(self, X)
+
+        if self.n_components is None:
+            n_components = X.shape[1]
+        else:
+            n_components = self.n_components
+
+        V, U, E, self.n_iter_ = _dict_learning(
+            X,
+            n_components,
+            alpha=self.alpha,
+            tol=self.tol,
+            max_iter=self.max_iter,
+            method=method,
+            method_max_iter=self.transform_max_iter,
+            n_jobs=self.n_jobs,
+            code_init=self.code_init,
+            dict_init=self.dict_init,
+            callback=self.callback,
+            verbose=self.verbose,
+            random_state=random_state,
+            return_n_iter=True,
+            positive_dict=self.positive_dict,
+            positive_code=self.positive_code,
+        )
+        self.components_ = U
+        self.error_ = E
+
+        return V
+
+    @property
+    def _n_features_out(self):
+        """Number of transformed output features."""
+        return self.components_.shape[0]
+
+    def __sklearn_tags__(self):
+        tags = super().__sklearn_tags__()
+        tags.transformer_tags.preserves_dtype = ["float64", "float32"]
+        return tags
+
+
+class MiniBatchDictionaryLearning(_BaseSparseCoding, BaseEstimator):
+    """Mini-batch dictionary learning.
+
+    Finds a dictionary (a set of atoms) that performs well at sparsely
+    encoding the fitted data.
+
+    Solves the optimization problem::
+
+       (U^*,V^*) = argmin 0.5 || X - U V ||_Fro^2 + alpha * || U ||_1,1
+                    (U,V)
+                    with || V_k ||_2 <= 1 for all  0 <= k < n_components
+
+    ||.||_Fro stands for the Frobenius norm and ||.||_1,1 stands for
+    the entry-wise matrix norm which is the sum of the absolute values
+    of all the entries in the matrix.
+
+    Read more in the :ref:`User Guide <DictionaryLearning>`.
+
+    Parameters
+    ----------
+    n_components : int, default=None
+        Number of dictionary elements to extract.
+
+    alpha : float, default=1
+        Sparsity controlling parameter.
+
+    max_iter : int, default=1_000
+        Maximum number of iterations over the complete dataset before
+        stopping independently of any early stopping criterion heuristics.
+
+        .. versionadded:: 1.1
+
+    fit_algorithm : {'lars', 'cd'}, default='lars'
+        The algorithm used:
+
+        - `'lars'`: uses the least angle regression method to solve the lasso
+          problem (`linear_model.lars_path`)
+        - `'cd'`: uses the coordinate descent method to compute the
+          Lasso solution (`linear_model.Lasso`). Lars will be faster if
+          the estimated components are sparse.
+
+    n_jobs : int, default=None
+        Number of parallel jobs to run.
+        ``None`` means 1 unless in a :obj:`joblib.parallel_backend` context.
+        ``-1`` means using all processors. See :term:`Glossary <n_jobs>`
+        for more details.
+
+    batch_size : int, default=256
+        Number of samples in each mini-batch.
+
+        .. versionchanged:: 1.3
+           The default value of `batch_size` changed from 3 to 256 in version 1.3.
+
+    shuffle : bool, default=True
+        Whether to shuffle the samples before forming batches.
+
+    dict_init : ndarray of shape (n_components, n_features), default=None
+        Initial value of the dictionary for warm restart scenarios.
+
+    transform_algorithm : {'lasso_lars', 'lasso_cd', 'lars', 'omp', \
+            'threshold'}, default='omp'
+        Algorithm used to transform the data:
+
+        - `'lars'`: uses the least angle regression method
+          (`linear_model.lars_path`);
+        - `'lasso_lars'`: uses Lars to compute the Lasso solution.
+        - `'lasso_cd'`: uses the coordinate descent method to compute the
+          Lasso solution (`linear_model.Lasso`). `'lasso_lars'` will be faster
+          if the estimated components are sparse.
+        - `'omp'`: uses orthogonal matching pursuit to estimate the sparse
+          solution.
+        - `'threshold'`: squashes to zero all coefficients less than alpha from
+          the projection ``dictionary * X'``.
+
+    transform_n_nonzero_coefs : int, default=None
+        Number of nonzero coefficients to target in each column of the
+        solution. This is only used by `algorithm='lars'` and
+        `algorithm='omp'`. If `None`, then
+        `transform_n_nonzero_coefs=int(n_features / 10)`.
+
+    transform_alpha : float, default=None
+        If `algorithm='lasso_lars'` or `algorithm='lasso_cd'`, `alpha` is the
+        penalty applied to the L1 norm.
+        If `algorithm='threshold'`, `alpha` is the absolute value of the
+        threshold below which coefficients will be squashed to zero.
+        If `None`, defaults to `alpha`.
+
+        .. versionchanged:: 1.2
+            When None, default value changed from 1.0 to `alpha`.
+
+    verbose : bool or int, default=False
+        To control the verbosity of the procedure.
+
+    split_sign : bool, default=False
+        Whether to split the sparse feature vector into the concatenation of
+        its negative part and its positive part. This can improve the
+        performance of downstream classifiers.
+
+    random_state : int, RandomState instance or None, default=None
+        Used for initializing the dictionary when ``dict_init`` is not
+        specified, randomly shuffling the data when ``shuffle`` is set to
+        ``True``, and updating the dictionary. Pass an int for reproducible
+        results across multiple function calls.
+        See :term:`Glossary <random_state>`.
+
+    positive_code : bool, default=False
+        Whether to enforce positivity when finding the code.
+
+        .. versionadded:: 0.20
+
+    positive_dict : bool, default=False
+        Whether to enforce positivity when finding the dictionary.
+
+        .. versionadded:: 0.20
+
+    transform_max_iter : int, default=1000
+        Maximum number of iterations to perform if `algorithm='lasso_cd'` or
+        `'lasso_lars'`.
+
+        .. versionadded:: 0.22
+
+    callback : callable, default=None
+        A callable that gets invoked at the end of each iteration.
+
+        .. versionadded:: 1.1
+
+    tol : float, default=1e-3
+        Control early stopping based on the norm of the differences in the
+        dictionary between 2 steps.
+
+        To disable early stopping based on changes in the dictionary, set
+        `tol` to 0.0.
+
+        .. versionadded:: 1.1
+
+    max_no_improvement : int, default=10
+        Control early stopping based on the consecutive number of mini batches
+        that does not yield an improvement on the smoothed cost function.
+
+        To disable convergence detection based on cost function, set
+        `max_no_improvement` to None.
+
+        .. versionadded:: 1.1
+
+    Attributes
+    ----------
+    components_ : ndarray of shape (n_components, n_features)
+        Components extracted from the data.
+
+    n_features_in_ : int
+        Number of features seen during :term:`fit`.
+
+        .. versionadded:: 0.24
+
+    feature_names_in_ : ndarray of shape (`n_features_in_`,)
+        Names of features seen during :term:`fit`. Defined only when `X`
+        has feature names that are all strings.
+
+        .. versionadded:: 1.0
+
+    n_iter_ : int
+        Number of iterations over the full dataset.
+
+    n_steps_ : int
+        Number of mini-batches processed.
+
+        .. versionadded:: 1.1
+
+    See Also
+    --------
+    DictionaryLearning : Find a dictionary that sparsely encodes data.
+    MiniBatchSparsePCA : Mini-batch Sparse Principal Components Analysis.
+    SparseCoder : Find a sparse representation of data from a fixed,
+        precomputed dictionary.
+    SparsePCA : Sparse Principal Components Analysis.
+
+    References
+    ----------
+
+    J. Mairal, F. Bach, J. Ponce, G. Sapiro, 2009: Online dictionary learning
+    for sparse coding (https://www.di.ens.fr/~fbach/mairal_icml09.pdf)
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from sklearn.datasets import make_sparse_coded_signal
+    >>> from sklearn.decomposition import MiniBatchDictionaryLearning
+    >>> X, dictionary, code = make_sparse_coded_signal(
+    ...     n_samples=30, n_components=15, n_features=20, n_nonzero_coefs=10,
+    ...     random_state=42)
+    >>> dict_learner = MiniBatchDictionaryLearning(
+    ...     n_components=15, batch_size=3, transform_algorithm='lasso_lars',
+    ...     transform_alpha=0.1, max_iter=20, random_state=42)
+    >>> X_transformed = dict_learner.fit_transform(X)
+
+    We can check the level of sparsity of `X_transformed`:
+
+    >>> np.mean(X_transformed == 0) > 0.5
+    np.True_
+
+    We can compare the average squared euclidean norm of the reconstruction
+    error of the sparse coded signal relative to the squared euclidean norm of
+    the original signal:
+
+    >>> X_hat = X_transformed @ dict_learner.components_
+    >>> np.mean(np.sum((X_hat - X) ** 2, axis=1) / np.sum(X ** 2, axis=1))
+    np.float64(0.052)
+    """
+
+    _parameter_constraints: dict = {
+        "n_components": [Interval(Integral, 1, None, closed="left"), None],
+        "alpha": [Interval(Real, 0, None, closed="left")],
+        "max_iter": [Interval(Integral, 0, None, closed="left")],
+        "fit_algorithm": [StrOptions({"cd", "lars"})],
+        "n_jobs": [None, Integral],
+        "batch_size": [Interval(Integral, 1, None, closed="left")],
+        "shuffle": ["boolean"],
+        "dict_init": [None, np.ndarray],
+        "transform_algorithm": [
+            StrOptions({"lasso_lars", "lasso_cd", "lars", "omp", "threshold"})
+        ],
+        "transform_n_nonzero_coefs": [Interval(Integral, 1, None, closed="left"), None],
+        "transform_alpha": [Interval(Real, 0, None, closed="left"), None],
+        "verbose": ["verbose"],
+        "split_sign": ["boolean"],
+        "random_state": ["random_state"],
+        "positive_code": ["boolean"],
+        "positive_dict": ["boolean"],
+        "transform_max_iter": [Interval(Integral, 0, None, closed="left")],
+        "callback": [None, callable],
+        "tol": [Interval(Real, 0, None, closed="left")],
+        "max_no_improvement": [Interval(Integral, 0, None, closed="left"), None],
+    }
+
+    def __init__(
+        self,
+        n_components=None,
+        *,
+        alpha=1,
+        max_iter=1_000,
+        fit_algorithm="lars",
+        n_jobs=None,
+        batch_size=256,
+        shuffle=True,
+        dict_init=None,
+        transform_algorithm="omp",
+        transform_n_nonzero_coefs=None,
+        transform_alpha=None,
+        verbose=False,
+        split_sign=False,
+        random_state=None,
+        positive_code=False,
+        positive_dict=False,
+        transform_max_iter=1000,
+        callback=None,
+        tol=1e-3,
+        max_no_improvement=10,
+    ):
+        super().__init__(
+            transform_algorithm,
+            transform_n_nonzero_coefs,
+            transform_alpha,
+            split_sign,
+            n_jobs,
+            positive_code,
+            transform_max_iter,
+        )
+        self.n_components = n_components
+        self.alpha = alpha
+        self.max_iter = max_iter
+        self.fit_algorithm = fit_algorithm
+        self.dict_init = dict_init
+        self.verbose = verbose
+        self.shuffle = shuffle
+        self.batch_size = batch_size
+        self.split_sign = split_sign
+        self.random_state = random_state
+        self.positive_dict = positive_dict
+        self.callback = callback
+        self.max_no_improvement = max_no_improvement
+        self.tol = tol
+
+    def _check_params(self, X):
+        # n_components
+        self._n_components = self.n_components
+        if self._n_components is None:
+            self._n_components = X.shape[1]
+
+        # fit_algorithm
+        _check_positive_coding(self.fit_algorithm, self.positive_code)
+        self._fit_algorithm = "lasso_" + self.fit_algorithm
+
+        # batch_size
+        self._batch_size = min(self.batch_size, X.shape[0])
+
+    def _initialize_dict(self, X, random_state):
+        """Initialization of the dictionary."""
+        if self.dict_init is not None:
+            dictionary = self.dict_init
+        else:
+            # Init V with SVD of X
+            _, S, dictionary = _randomized_svd(
+                X, self._n_components, random_state=random_state
+            )
+            dictionary = S[:, np.newaxis] * dictionary
+
+        if self._n_components <= len(dictionary):
+            dictionary = dictionary[: self._n_components, :]
+        else:
+            dictionary = np.concatenate(
+                (
+                    dictionary,
+                    np.zeros(
+                        (self._n_components - len(dictionary), dictionary.shape[1]),
+                        dtype=dictionary.dtype,
+                    ),
+                )
+            )
+
+        dictionary = check_array(dictionary, order="F", dtype=X.dtype, copy=False)
+        dictionary = np.require(dictionary, requirements="W")
+
+        return dictionary
+
+    def _update_inner_stats(self, X, code, batch_size, step):
+        """Update the inner stats inplace."""
+        if step < batch_size - 1:
+            theta = (step + 1) * batch_size
+        else:
+            theta = batch_size**2 + step + 1 - batch_size
+        beta = (theta + 1 - batch_size) / (theta + 1)
+
+        self._A *= beta
+        self._A += code.T @ code / batch_size
+        self._B *= beta
+        self._B += X.T @ code / batch_size
+
+    def _minibatch_step(self, X, dictionary, random_state, step):
+        """Perform the update on the dictionary for one minibatch."""
+        batch_size = X.shape[0]
+
+        # Compute code for this batch
+        code = _sparse_encode(
+            X,
+            dictionary,
+            algorithm=self._fit_algorithm,
+            alpha=self.alpha,
+            n_jobs=self.n_jobs,
+            positive=self.positive_code,
+            max_iter=self.transform_max_iter,
+            verbose=self.verbose,
+        )
+
+        batch_cost = (
+            0.5 * ((X - code @ dictionary) ** 2).sum()
+            + self.alpha * np.sum(np.abs(code))
+        ) / batch_size
+
+        # Update inner stats
+        self._update_inner_stats(X, code, batch_size, step)
+
+        # Update dictionary
+        _update_dict(
+            dictionary,
+            X,
+            code,
+            self._A,
+            self._B,
+            verbose=self.verbose,
+            random_state=random_state,
+            positive=self.positive_dict,
+        )
+
+        return batch_cost
+
+    def _check_convergence(
+        self, X, batch_cost, new_dict, old_dict, n_samples, step, n_steps
+    ):
+        """Helper function to encapsulate the early stopping logic.
+
+        Early stopping is based on two factors:
+        - A small change of the dictionary between two minibatch updates. This is
+          controlled by the tol parameter.
+        - No more improvement on a smoothed estimate of the objective function for a
+          a certain number of consecutive minibatch updates. This is controlled by
+          the max_no_improvement parameter.
+        """
+        batch_size = X.shape[0]
+
+        # counts steps starting from 1 for user friendly verbose mode.
+        step = step + 1
+
+        # Ignore 100 first steps or 1 epoch to avoid initializing the ewa_cost with a
+        # too bad value
+        if step <= min(100, n_samples / batch_size):
+            if self.verbose:
+                print(f"Minibatch step {step}/{n_steps}: mean batch cost: {batch_cost}")
+            return False
+
+        # Compute an Exponentially Weighted Average of the cost function to
+        # monitor the convergence while discarding minibatch-local stochastic
+        # variability: https://en.wikipedia.org/wiki/Moving_average
+        if self._ewa_cost is None:
+            self._ewa_cost = batch_cost
+        else:
+            alpha = batch_size / (n_samples + 1)
+            alpha = min(alpha, 1)
+            self._ewa_cost = self._ewa_cost * (1 - alpha) + batch_cost * alpha
+
+        if self.verbose:
+            print(
+                f"Minibatch step {step}/{n_steps}: mean batch cost: "
+                f"{batch_cost}, ewa cost: {self._ewa_cost}"
+            )
+
+        # Early stopping based on change of dictionary
+        dict_diff = linalg.norm(new_dict - old_dict) / self._n_components
+        if self.tol > 0 and dict_diff <= self.tol:
+            if self.verbose:
+                print(f"Converged (small dictionary change) at step {step}/{n_steps}")
+            return True
+
+        # Early stopping heuristic due to lack of improvement on smoothed
+        # cost function
+        if self._ewa_cost_min is None or self._ewa_cost < self._ewa_cost_min:
+            self._no_improvement = 0
+            self._ewa_cost_min = self._ewa_cost
+        else:
+            self._no_improvement += 1
+
+        if (
+            self.max_no_improvement is not None
+            and self._no_improvement >= self.max_no_improvement
+        ):
+            if self.verbose:
+                print(
+                    "Converged (lack of improvement in objective function) "
+                    f"at step {step}/{n_steps}"
+                )
+            return True
+
+        return False
+
+    @_fit_context(prefer_skip_nested_validation=True)
+    def fit(self, X, y=None):
+        """Fit the model from data in X.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+            Training vector, where `n_samples` is the number of samples
+            and `n_features` is the number of features.
+
+        y : Ignored
+            Not used, present for API consistency by convention.
+
+        Returns
+        -------
+        self : object
+            Returns the instance itself.
+        """
+        X = validate_data(
+            self, X, dtype=[np.float64, np.float32], order="C", copy=False
+        )
+
+        self._check_params(X)
+        self._random_state = check_random_state(self.random_state)
+
+        dictionary = self._initialize_dict(X, self._random_state)
+        old_dict = dictionary.copy()
+
+        if self.shuffle:
+            X_train = X.copy()
+            self._random_state.shuffle(X_train)
+        else:
+            X_train = X
+
+        n_samples, n_features = X_train.shape
+
+        if self.verbose:
+            print("[dict_learning]")
+
+        # Inner stats
+        self._A = np.zeros(
+            (self._n_components, self._n_components), dtype=X_train.dtype
+        )
+        self._B = np.zeros((n_features, self._n_components), dtype=X_train.dtype)
+
+        # Attributes to monitor the convergence
+        self._ewa_cost = None
+        self._ewa_cost_min = None
+        self._no_improvement = 0
+
+        batches = gen_batches(n_samples, self._batch_size)
+        batches = itertools.cycle(batches)
+        n_steps_per_iter = int(np.ceil(n_samples / self._batch_size))
+        n_steps = self.max_iter * n_steps_per_iter
+
+        i = -1  # to allow max_iter = 0
+
+        for i, batch in zip(range(n_steps), batches):
+            X_batch = X_train[batch]
+
+            batch_cost = self._minibatch_step(
+                X_batch, dictionary, self._random_state, i
+            )
+
+            if self._check_convergence(
+                X_batch, batch_cost, dictionary, old_dict, n_samples, i, n_steps
+            ):
+                break
+
+            # XXX callback param added for backward compat in #18975 but a common
+            # unified callback API should be preferred
+            if self.callback is not None:
+                self.callback(locals())
+
+            old_dict[:] = dictionary
+
+        self.n_steps_ = i + 1
+        self.n_iter_ = np.ceil(self.n_steps_ / n_steps_per_iter)
+        self.components_ = dictionary
+
+        return self
+
+    @_fit_context(prefer_skip_nested_validation=True)
+    def partial_fit(self, X, y=None):
+        """Update the model using the data in X as a mini-batch.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+            Training vector, where `n_samples` is the number of samples
+            and `n_features` is the number of features.
+
+        y : Ignored
+            Not used, present for API consistency by convention.
+
+        Returns
+        -------
+        self : object
+            Return the instance itself.
+        """
+        has_components = hasattr(self, "components_")
+
+        X = validate_data(
+            self, X, dtype=[np.float64, np.float32], order="C", reset=not has_components
+        )
+
+        if not has_components:
+            # This instance has not been fitted yet (fit or partial_fit)
+            self._check_params(X)
+            self._random_state = check_random_state(self.random_state)
+
+            dictionary = self._initialize_dict(X, self._random_state)
+
+            self.n_steps_ = 0
+
+            self._A = np.zeros((self._n_components, self._n_components), dtype=X.dtype)
+            self._B = np.zeros((X.shape[1], self._n_components), dtype=X.dtype)
+        else:
+            dictionary = self.components_
+
+        self._minibatch_step(X, dictionary, self._random_state, self.n_steps_)
+
+        self.components_ = dictionary
+        self.n_steps_ += 1
+
+        return self
+
+    @property
+    def _n_features_out(self):
+        """Number of transformed output features."""
+        return self.components_.shape[0]
+
+    def __sklearn_tags__(self):
+        tags = super().__sklearn_tags__()
+        tags.transformer_tags.preserves_dtype = ["float64", "float32"]
+        return tags

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sklearn/decomposition/_factor_analysis.py

@@ -0,0 +1,457 @@
+"""Factor Analysis.
+
+A latent linear variable model.
+
+FactorAnalysis is similar to probabilistic PCA implemented by PCA.score
+While PCA assumes Gaussian noise with the same variance for each
+feature, the FactorAnalysis model assumes different variances for
+each of them.
+
+This implementation is based on David Barber's Book,
+Bayesian Reasoning and Machine Learning,
+http://www.cs.ucl.ac.uk/staff/d.barber/brml,
+Algorithm 21.1
+"""
+
+# Authors: The scikit-learn developers
+# SPDX-License-Identifier: BSD-3-Clause
+
+import warnings
+from math import log, sqrt
+from numbers import Integral, Real
+
+import numpy as np
+from scipy import linalg
+
+from ..base import (
+    BaseEstimator,
+    ClassNamePrefixFeaturesOutMixin,
+    TransformerMixin,
+    _fit_context,
+)
+from ..exceptions import ConvergenceWarning
+from ..utils import check_random_state
+from ..utils._param_validation import Interval, StrOptions
+from ..utils.extmath import _randomized_svd, fast_logdet, squared_norm
+from ..utils.validation import check_is_fitted, validate_data
+
+
+class FactorAnalysis(ClassNamePrefixFeaturesOutMixin, TransformerMixin, BaseEstimator):
+    """Factor Analysis (FA).
+
+    A simple linear generative model with Gaussian latent variables.
+
+    The observations are assumed to be caused by a linear transformation of
+    lower dimensional latent factors and added Gaussian noise.
+    Without loss of generality the factors are distributed according to a
+    Gaussian with zero mean and unit covariance. The noise is also zero mean
+    and has an arbitrary diagonal covariance matrix.
+
+    If we would restrict the model further, by assuming that the Gaussian
+    noise is even isotropic (all diagonal entries are the same) we would obtain
+    :class:`PCA`.
+
+    FactorAnalysis performs a maximum likelihood estimate of the so-called
+    `loading` matrix, the transformation of the latent variables to the
+    observed ones, using SVD based approach.
+
+    Read more in the :ref:`User Guide <FA>`.
+
+    .. versionadded:: 0.13
+
+    Parameters
+    ----------
+    n_components : int, default=None
+        Dimensionality of latent space, the number of components
+        of ``X`` that are obtained after ``transform``.
+        If None, n_components is set to the number of features.
+
+    tol : float, default=1e-2
+        Stopping tolerance for log-likelihood increase.
+
+    copy : bool, default=True
+        Whether to make a copy of X. If ``False``, the input X gets overwritten
+        during fitting.
+
+    max_iter : int, default=1000
+        Maximum number of iterations.
+
+    noise_variance_init : array-like of shape (n_features,), default=None
+        The initial guess of the noise variance for each feature.
+        If None, it defaults to np.ones(n_features).
+
+    svd_method : {'lapack', 'randomized'}, default='randomized'
+        Which SVD method to use. If 'lapack' use standard SVD from
+        scipy.linalg, if 'randomized' use fast ``randomized_svd`` function.
+        Defaults to 'randomized'. For most applications 'randomized' will
+        be sufficiently precise while providing significant speed gains.
+        Accuracy can also be improved by setting higher values for
+        `iterated_power`. If this is not sufficient, for maximum precision
+        you should choose 'lapack'.
+
+    iterated_power : int, default=3
+        Number of iterations for the power method. 3 by default. Only used
+        if ``svd_method`` equals 'randomized'.
+
+    rotation : {'varimax', 'quartimax'}, default=None
+        If not None, apply the indicated rotation. Currently, varimax and
+        quartimax are implemented. See
+        `"The varimax criterion for analytic rotation in factor analysis"
+        <https://link.springer.com/article/10.1007%2FBF02289233>`_
+        H. F. Kaiser, 1958.
+
+        .. versionadded:: 0.24
+
+    random_state : int or RandomState instance, default=0
+        Only used when ``svd_method`` equals 'randomized'. Pass an int for
+        reproducible results across multiple function calls.
+        See :term:`Glossary <random_state>`.
+
+    Attributes
+    ----------
+    components_ : ndarray of shape (n_components, n_features)
+        Components with maximum variance.
+
+    loglike_ : list of shape (n_iterations,)
+        The log likelihood at each iteration.
+
+    noise_variance_ : ndarray of shape (n_features,)
+        The estimated noise variance for each feature.
+
+    n_iter_ : int
+        Number of iterations run.
+
+    mean_ : ndarray of shape (n_features,)
+        Per-feature empirical mean, estimated from the training set.
+
+    n_features_in_ : int
+        Number of features seen during :term:`fit`.
+
+        .. versionadded:: 0.24
+
+    feature_names_in_ : ndarray of shape (`n_features_in_`,)
+        Names of features seen during :term:`fit`. Defined only when `X`
+        has feature names that are all strings.
+
+        .. versionadded:: 1.0
+
+    See Also
+    --------
+    PCA: Principal component analysis is also a latent linear variable model
+        which however assumes equal noise variance for each feature.
+        This extra assumption makes probabilistic PCA faster as it can be
+        computed in closed form.
+    FastICA: Independent component analysis, a latent variable model with
+        non-Gaussian latent variables.
+
+    References
+    ----------
+    - David Barber, Bayesian Reasoning and Machine Learning,
+      Algorithm 21.1.
+
+    - Christopher M. Bishop: Pattern Recognition and Machine Learning,
+      Chapter 12.2.4.
+
+    Examples
+    --------
+    >>> from sklearn.datasets import load_digits
+    >>> from sklearn.decomposition import FactorAnalysis
+    >>> X, _ = load_digits(return_X_y=True)
+    >>> transformer = FactorAnalysis(n_components=7, random_state=0)
+    >>> X_transformed = transformer.fit_transform(X)
+    >>> X_transformed.shape
+    (1797, 7)
+    """
+
+    _parameter_constraints: dict = {
+        "n_components": [Interval(Integral, 0, None, closed="left"), None],
+        "tol": [Interval(Real, 0.0, None, closed="left")],
+        "copy": ["boolean"],
+        "max_iter": [Interval(Integral, 1, None, closed="left")],
+        "noise_variance_init": ["array-like", None],
+        "svd_method": [StrOptions({"randomized", "lapack"})],
+        "iterated_power": [Interval(Integral, 0, None, closed="left")],
+        "rotation": [StrOptions({"varimax", "quartimax"}), None],
+        "random_state": ["random_state"],
+    }
+
+    def __init__(
+        self,
+        n_components=None,
+        *,
+        tol=1e-2,
+        copy=True,
+        max_iter=1000,
+        noise_variance_init=None,
+        svd_method="randomized",
+        iterated_power=3,
+        rotation=None,
+        random_state=0,
+    ):
+        self.n_components = n_components
+        self.copy = copy
+        self.tol = tol
+        self.max_iter = max_iter
+        self.svd_method = svd_method
+
+        self.noise_variance_init = noise_variance_init
+        self.iterated_power = iterated_power
+        self.random_state = random_state
+        self.rotation = rotation
+
+    @_fit_context(prefer_skip_nested_validation=True)
+    def fit(self, X, y=None):
+        """Fit the FactorAnalysis model to X using SVD based approach.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+            Training data.
+
+        y : Ignored
+            Ignored parameter.
+
+        Returns
+        -------
+        self : object
+            FactorAnalysis class instance.
+        """
+        X = validate_data(
+            self, X, copy=self.copy, dtype=np.float64, force_writeable=True
+        )
+
+        n_samples, n_features = X.shape
+        n_components = self.n_components
+        if n_components is None:
+            n_components = n_features
+
+        self.mean_ = np.mean(X, axis=0)
+        X -= self.mean_
+
+        # some constant terms
+        nsqrt = sqrt(n_samples)
+        llconst = n_features * log(2.0 * np.pi) + n_components
+        var = np.var(X, axis=0)
+
+        if self.noise_variance_init is None:
+            psi = np.ones(n_features, dtype=X.dtype)
+        else:
+            if len(self.noise_variance_init) != n_features:
+                raise ValueError(
+                    "noise_variance_init dimension does not "
+                    "with number of features : %d != %d"
+                    % (len(self.noise_variance_init), n_features)
+                )
+            psi = np.array(self.noise_variance_init)
+
+        loglike = []
+        old_ll = -np.inf
+        SMALL = 1e-12
+
+        # we'll modify svd outputs to return unexplained variance
+        # to allow for unified computation of loglikelihood
+        if self.svd_method == "lapack":
+
+            def my_svd(X):
+                _, s, Vt = linalg.svd(X, full_matrices=False, check_finite=False)
+                return (
+                    s[:n_components],
+                    Vt[:n_components],
+                    squared_norm(s[n_components:]),
+                )
+
+        else:  # svd_method == "randomized"
+            random_state = check_random_state(self.random_state)
+
+            def my_svd(X):
+                _, s, Vt = _randomized_svd(
+                    X,
+                    n_components,
+                    random_state=random_state,
+                    n_iter=self.iterated_power,
+                )
+                return s, Vt, squared_norm(X) - squared_norm(s)
+
+        for i in range(self.max_iter):
+            # SMALL helps numerics
+            sqrt_psi = np.sqrt(psi) + SMALL
+            s, Vt, unexp_var = my_svd(X / (sqrt_psi * nsqrt))
+            s **= 2
+            # Use 'maximum' here to avoid sqrt problems.
+            W = np.sqrt(np.maximum(s - 1.0, 0.0))[:, np.newaxis] * Vt
+            del Vt
+            W *= sqrt_psi
+
+            # loglikelihood
+            ll = llconst + np.sum(np.log(s))
+            ll += unexp_var + np.sum(np.log(psi))
+            ll *= -n_samples / 2.0
+            loglike.append(ll)
+            if (ll - old_ll) < self.tol:
+                break
+            old_ll = ll
+
+            psi = np.maximum(var - np.sum(W**2, axis=0), SMALL)
+        else:
+            warnings.warn(
+                "FactorAnalysis did not converge."
+                " You might want"
+                " to increase the number of iterations.",
+                ConvergenceWarning,
+            )
+
+        self.components_ = W
+        if self.rotation is not None:
+            self.components_ = self._rotate(W)
+        self.noise_variance_ = psi
+        self.loglike_ = loglike
+        self.n_iter_ = i + 1
+        return self
+
+    def transform(self, X):
+        """Apply dimensionality reduction to X using the model.
+
+        Compute the expected mean of the latent variables.
+        See Barber, 21.2.33 (or Bishop, 12.66).
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+            Training data.
+
+        Returns
+        -------
+        X_new : ndarray of shape (n_samples, n_components)
+            The latent variables of X.
+        """
+        check_is_fitted(self)
+
+        X = validate_data(self, X, reset=False)
+        Ih = np.eye(len(self.components_))
+
+        X_transformed = X - self.mean_
+
+        Wpsi = self.components_ / self.noise_variance_
+        cov_z = linalg.inv(Ih + np.dot(Wpsi, self.components_.T))
+        tmp = np.dot(X_transformed, Wpsi.T)
+        X_transformed = np.dot(tmp, cov_z)
+
+        return X_transformed
+
+    def get_covariance(self):
+        """Compute data covariance with the FactorAnalysis model.
+
+        ``cov = components_.T * components_ + diag(noise_variance)``
+
+        Returns
+        -------
+        cov : ndarray of shape (n_features, n_features)
+            Estimated covariance of data.
+        """
+        check_is_fitted(self)
+
+        cov = np.dot(self.components_.T, self.components_)
+        cov.flat[:: len(cov) + 1] += self.noise_variance_  # modify diag inplace
+        return cov
+
+    def get_precision(self):
+        """Compute data precision matrix with the FactorAnalysis model.
+
+        Returns
+        -------
+        precision : ndarray of shape (n_features, n_features)
+            Estimated precision of data.
+        """
+        check_is_fitted(self)
+
+        n_features = self.components_.shape[1]
+
+        # handle corner cases first
+        if self.n_components == 0:
+            return np.diag(1.0 / self.noise_variance_)
+        if self.n_components == n_features:
+            return linalg.inv(self.get_covariance())
+
+        # Get precision using matrix inversion lemma
+        components_ = self.components_
+        precision = np.dot(components_ / self.noise_variance_, components_.T)
+        precision.flat[:: len(precision) + 1] += 1.0
+        precision = np.dot(components_.T, np.dot(linalg.inv(precision), components_))
+        precision /= self.noise_variance_[:, np.newaxis]
+        precision /= -self.noise_variance_[np.newaxis, :]
+        precision.flat[:: len(precision) + 1] += 1.0 / self.noise_variance_
+        return precision
+
+    def score_samples(self, X):
+        """Compute the log-likelihood of each sample.
+
+        Parameters
+        ----------
+        X : ndarray of shape (n_samples, n_features)
+            The data.
+
+        Returns
+        -------
+        ll : ndarray of shape (n_samples,)
+            Log-likelihood of each sample under the current model.
+        """
+        check_is_fitted(self)
+        X = validate_data(self, X, reset=False)
+        Xr = X - self.mean_
+        precision = self.get_precision()
+        n_features = X.shape[1]
+        log_like = -0.5 * (Xr * (np.dot(Xr, precision))).sum(axis=1)
+        log_like -= 0.5 * (n_features * log(2.0 * np.pi) - fast_logdet(precision))
+        return log_like
+
+    def score(self, X, y=None):
+        """Compute the average log-likelihood of the samples.
+
+        Parameters
+        ----------
+        X : ndarray of shape (n_samples, n_features)
+            The data.
+
+        y : Ignored
+            Ignored parameter.
+
+        Returns
+        -------
+        ll : float
+            Average log-likelihood of the samples under the current model.
+        """
+        return np.mean(self.score_samples(X))
+
+    def _rotate(self, components, n_components=None, tol=1e-6):
+        "Rotate the factor analysis solution."
+        # note that tol is not exposed
+        return _ortho_rotation(components.T, method=self.rotation, tol=tol)[
+            : self.n_components
+        ]
+
+    @property
+    def _n_features_out(self):
+        """Number of transformed output features."""
+        return self.components_.shape[0]
+
+
+def _ortho_rotation(components, method="varimax", tol=1e-6, max_iter=100):
+    """Return rotated components."""
+    nrow, ncol = components.shape
+    rotation_matrix = np.eye(ncol)
+    var = 0
+
+    for _ in range(max_iter):
+        comp_rot = np.dot(components, rotation_matrix)
+        if method == "varimax":
+            tmp = comp_rot * np.transpose((comp_rot**2).sum(axis=0) / nrow)
+        elif method == "quartimax":
+            tmp = 0
+        u, s, v = np.linalg.svd(np.dot(components.T, comp_rot**3 - tmp))
+        rotation_matrix = np.dot(u, v)
+        var_new = np.sum(s)
+        if var != 0 and var_new < var * (1 + tol):
+            break
+        var = var_new
+
+    return np.dot(components, rotation_matrix).T

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sklearn/decomposition/_fastica.py

@@ -0,0 +1,804 @@
+"""
+Python implementation of the fast ICA algorithms.
+
+Reference: Tables 8.3 and 8.4 page 196 in the book:
+Independent Component Analysis, by  Hyvarinen et al.
+"""
+
+# Authors: The scikit-learn developers
+# SPDX-License-Identifier: BSD-3-Clause
+
+import warnings
+from numbers import Integral, Real
+
+import numpy as np
+from scipy import linalg
+
+from ..base import (
+    BaseEstimator,
+    ClassNamePrefixFeaturesOutMixin,
+    TransformerMixin,
+    _fit_context,
+)
+from ..exceptions import ConvergenceWarning
+from ..utils import as_float_array, check_array, check_random_state
+from ..utils._param_validation import Interval, Options, StrOptions, validate_params
+from ..utils.validation import check_is_fitted, validate_data
+
+__all__ = ["FastICA", "fastica"]
+
+
+def _gs_decorrelation(w, W, j):
+    """
+    Orthonormalize w wrt the first j rows of W.
+
+    Parameters
+    ----------
+    w : ndarray of shape (n,)
+        Array to be orthogonalized
+
+    W : ndarray of shape (p, n)
+        Null space definition
+
+    j : int < p
+        The no of (from the first) rows of Null space W wrt which w is
+        orthogonalized.
+
+    Notes
+    -----
+    Assumes that W is orthogonal
+    w changed in place
+    """
+    w -= np.linalg.multi_dot([w, W[:j].T, W[:j]])
+    return w
+
+
+def _sym_decorrelation(W):
+    """Symmetric decorrelation
+    i.e. W <- (W * W.T) ^{-1/2} * W
+    """
+    s, u = linalg.eigh(np.dot(W, W.T))
+    # Avoid sqrt of negative values because of rounding errors. Note that
+    # np.sqrt(tiny) is larger than tiny and therefore this clipping also
+    # prevents division by zero in the next step.
+    s = np.clip(s, a_min=np.finfo(W.dtype).tiny, a_max=None)
+
+    # u (resp. s) contains the eigenvectors (resp. square roots of
+    # the eigenvalues) of W * W.T
+    return np.linalg.multi_dot([u * (1.0 / np.sqrt(s)), u.T, W])
+
+
+def _ica_def(X, tol, g, fun_args, max_iter, w_init):
+    """Deflationary FastICA using fun approx to neg-entropy function
+
+    Used internally by FastICA.
+    """
+
+    n_components = w_init.shape[0]
+    W = np.zeros((n_components, n_components), dtype=X.dtype)
+    n_iter = []
+
+    # j is the index of the extracted component
+    for j in range(n_components):
+        w = w_init[j, :].copy()
+        w /= np.sqrt((w**2).sum())
+
+        for i in range(max_iter):
+            gwtx, g_wtx = g(np.dot(w.T, X), fun_args)
+
+            w1 = (X * gwtx).mean(axis=1) - g_wtx.mean() * w
+
+            _gs_decorrelation(w1, W, j)
+
+            w1 /= np.sqrt((w1**2).sum())
+
+            lim = np.abs(np.abs((w1 * w).sum()) - 1)
+            w = w1
+            if lim < tol:
+                break
+
+        n_iter.append(i + 1)
+        W[j, :] = w
+
+    return W, max(n_iter)
+
+
+def _ica_par(X, tol, g, fun_args, max_iter, w_init):
+    """Parallel FastICA.
+
+    Used internally by FastICA --main loop
+
+    """
+    W = _sym_decorrelation(w_init)
+    del w_init
+    p_ = float(X.shape[1])
+    for ii in range(max_iter):
+        gwtx, g_wtx = g(np.dot(W, X), fun_args)
+        W1 = _sym_decorrelation(np.dot(gwtx, X.T) / p_ - g_wtx[:, np.newaxis] * W)
+        del gwtx, g_wtx
+        # builtin max, abs are faster than numpy counter parts.
+        # np.einsum allows having the lowest memory footprint.
+        # It is faster than np.diag(np.dot(W1, W.T)).
+        lim = max(abs(abs(np.einsum("ij,ij->i", W1, W)) - 1))
+        W = W1
+        if lim < tol:
+            break
+    else:
+        warnings.warn(
+            (
+                "FastICA did not converge. Consider increasing "
+                "tolerance or the maximum number of iterations."
+            ),
+            ConvergenceWarning,
+        )
+
+    return W, ii + 1
+
+
+# Some standard non-linear functions.
+# XXX: these should be optimized, as they can be a bottleneck.
+def _logcosh(x, fun_args=None):
+    alpha = fun_args.get("alpha", 1.0)  # comment it out?
+
+    x *= alpha
+    gx = np.tanh(x, x)  # apply the tanh inplace
+    g_x = np.empty(x.shape[0], dtype=x.dtype)
+    # XXX compute in chunks to avoid extra allocation
+    for i, gx_i in enumerate(gx):  # please don't vectorize.
+        g_x[i] = (alpha * (1 - gx_i**2)).mean()
+    return gx, g_x
+
+
+def _exp(x, fun_args):
+    exp = np.exp(-(x**2) / 2)
+    gx = x * exp
+    g_x = (1 - x**2) * exp
+    return gx, g_x.mean(axis=-1)
+
+
+def _cube(x, fun_args):
+    return x**3, (3 * x**2).mean(axis=-1)
+
+
+@validate_params(
+    {
+        "X": ["array-like"],
+        "return_X_mean": ["boolean"],
+        "compute_sources": ["boolean"],
+        "return_n_iter": ["boolean"],
+    },
+    prefer_skip_nested_validation=False,
+)
+def fastica(
+    X,
+    n_components=None,
+    *,
+    algorithm="parallel",
+    whiten="unit-variance",
+    fun="logcosh",
+    fun_args=None,
+    max_iter=200,
+    tol=1e-04,
+    w_init=None,
+    whiten_solver="svd",
+    random_state=None,
+    return_X_mean=False,
+    compute_sources=True,
+    return_n_iter=False,
+):
+    """Perform Fast Independent Component Analysis.
+
+    The implementation is based on [1]_.
+
+    Read more in the :ref:`User Guide <ICA>`.
+
+    Parameters
+    ----------
+    X : array-like of shape (n_samples, n_features)
+        Training vector, where `n_samples` is the number of samples and
+        `n_features` is the number of features.
+
+    n_components : int, default=None
+        Number of components to use. If None is passed, all are used.
+
+    algorithm : {'parallel', 'deflation'}, default='parallel'
+        Specify which algorithm to use for FastICA.
+
+    whiten : str or bool, default='unit-variance'
+        Specify the whitening strategy to use.
+
+        - If 'arbitrary-variance', a whitening with variance
+          arbitrary is used.
+        - If 'unit-variance', the whitening matrix is rescaled to ensure that
+          each recovered source has unit variance.
+        - If False, the data is already considered to be whitened, and no
+          whitening is performed.
+
+        .. versionchanged:: 1.3
+            The default value of `whiten` changed to 'unit-variance' in 1.3.
+
+    fun : {'logcosh', 'exp', 'cube'} or callable, default='logcosh'
+        The functional form of the G function used in the
+        approximation to neg-entropy. Could be either 'logcosh', 'exp',
+        or 'cube'.
+        You can also provide your own function. It should return a tuple
+        containing the value of the function, and of its derivative, in the
+        point. The derivative should be averaged along its last dimension.
+        Example::
+
+            def my_g(x):
+                return x ** 3, (3 * x ** 2).mean(axis=-1)
+
+    fun_args : dict, default=None
+        Arguments to send to the functional form.
+        If empty or None and if fun='logcosh', fun_args will take value
+        {'alpha' : 1.0}.
+
+    max_iter : int, default=200
+        Maximum number of iterations to perform.
+
+    tol : float, default=1e-4
+        A positive scalar giving the tolerance at which the
+        un-mixing matrix is considered to have converged.
+
+    w_init : ndarray of shape (n_components, n_components), default=None
+        Initial un-mixing array. If `w_init=None`, then an array of values
+        drawn from a normal distribution is used.
+
+    whiten_solver : {"eigh", "svd"}, default="svd"
+        The solver to use for whitening.
+
+        - "svd" is more stable numerically if the problem is degenerate, and
+          often faster when `n_samples <= n_features`.
+
+        - "eigh" is generally more memory efficient when
+          `n_samples >= n_features`, and can be faster when
+          `n_samples >= 50 * n_features`.
+
+        .. versionadded:: 1.2
+
+    random_state : int, RandomState instance or None, default=None
+        Used to initialize ``w_init`` when not specified, with a
+        normal distribution. Pass an int, for reproducible results
+        across multiple function calls.
+        See :term:`Glossary <random_state>`.
+
+    return_X_mean : bool, default=False
+        If True, X_mean is returned too.
+
+    compute_sources : bool, default=True
+        If False, sources are not computed, but only the rotation matrix.
+        This can save memory when working with big data. Defaults to True.
+
+    return_n_iter : bool, default=False
+        Whether or not to return the number of iterations.
+
+    Returns
+    -------
+    K : ndarray of shape (n_components, n_features) or None
+        If whiten is 'True', K is the pre-whitening matrix that projects data
+        onto the first n_components principal components. If whiten is 'False',
+        K is 'None'.
+
+    W : ndarray of shape (n_components, n_components)
+        The square matrix that unmixes the data after whitening.
+        The mixing matrix is the pseudo-inverse of matrix ``W K``
+        if K is not None, else it is the inverse of W.
+
+    S : ndarray of shape (n_samples, n_components) or None
+        Estimated source matrix.
+
+    X_mean : ndarray of shape (n_features,)
+        The mean over features. Returned only if return_X_mean is True.
+
+    n_iter : int
+        If the algorithm is "deflation", n_iter is the
+        maximum number of iterations run across all components. Else
+        they are just the number of iterations taken to converge. This is
+        returned only when return_n_iter is set to `True`.
+
+    Notes
+    -----
+    The data matrix X is considered to be a linear combination of
+    non-Gaussian (independent) components i.e. X = AS where columns of S
+    contain the independent components and A is a linear mixing
+    matrix. In short ICA attempts to `un-mix' the data by estimating an
+    un-mixing matrix W where ``S = W K X.``
+    While FastICA was proposed to estimate as many sources
+    as features, it is possible to estimate less by setting
+    n_components < n_features. It this case K is not a square matrix
+    and the estimated A is the pseudo-inverse of ``W K``.
+
+    This implementation was originally made for data of shape
+    [n_features, n_samples]. Now the input is transposed
+    before the algorithm is applied. This makes it slightly
+    faster for Fortran-ordered input.
+
+    References
+    ----------
+    .. [1] A. Hyvarinen and E. Oja, "Fast Independent Component Analysis",
+           Algorithms and Applications, Neural Networks, 13(4-5), 2000,
+           pp. 411-430.
+
+    Examples
+    --------
+    >>> from sklearn.datasets import load_digits
+    >>> from sklearn.decomposition import fastica
+    >>> X, _ = load_digits(return_X_y=True)
+    >>> K, W, S = fastica(X, n_components=7, random_state=0, whiten='unit-variance')
+    >>> K.shape
+    (7, 64)
+    >>> W.shape
+    (7, 7)
+    >>> S.shape
+    (1797, 7)
+    """
+    est = FastICA(
+        n_components=n_components,
+        algorithm=algorithm,
+        whiten=whiten,
+        fun=fun,
+        fun_args=fun_args,
+        max_iter=max_iter,
+        tol=tol,
+        w_init=w_init,
+        whiten_solver=whiten_solver,
+        random_state=random_state,
+    )
+    est._validate_params()
+    S = est._fit_transform(X, compute_sources=compute_sources)
+
+    if est.whiten in ["unit-variance", "arbitrary-variance"]:
+        K = est.whitening_
+        X_mean = est.mean_
+    else:
+        K = None
+        X_mean = None
+
+    returned_values = [K, est._unmixing, S]
+    if return_X_mean:
+        returned_values.append(X_mean)
+    if return_n_iter:
+        returned_values.append(est.n_iter_)
+
+    return returned_values
+
+
+class FastICA(ClassNamePrefixFeaturesOutMixin, TransformerMixin, BaseEstimator):
+    """FastICA: a fast algorithm for Independent Component Analysis.
+
+    The implementation is based on [1]_.
+
+    Read more in the :ref:`User Guide <ICA>`.
+
+    Parameters
+    ----------
+    n_components : int, default=None
+        Number of components to use. If None is passed, all are used.
+
+    algorithm : {'parallel', 'deflation'}, default='parallel'
+        Specify which algorithm to use for FastICA.
+
+    whiten : str or bool, default='unit-variance'
+        Specify the whitening strategy to use.
+
+        - If 'arbitrary-variance', a whitening with variance
+          arbitrary is used.
+        - If 'unit-variance', the whitening matrix is rescaled to ensure that
+          each recovered source has unit variance.
+        - If False, the data is already considered to be whitened, and no
+          whitening is performed.
+
+        .. versionchanged:: 1.3
+            The default value of `whiten` changed to 'unit-variance' in 1.3.
+
+    fun : {'logcosh', 'exp', 'cube'} or callable, default='logcosh'
+        The functional form of the G function used in the
+        approximation to neg-entropy. Could be either 'logcosh', 'exp',
+        or 'cube'.
+        You can also provide your own function. It should return a tuple
+        containing the value of the function, and of its derivative, in the
+        point. The derivative should be averaged along its last dimension.
+        Example::
+
+            def my_g(x):
+                return x ** 3, (3 * x ** 2).mean(axis=-1)
+
+    fun_args : dict, default=None
+        Arguments to send to the functional form.
+        If empty or None and if fun='logcosh', fun_args will take value
+        {'alpha' : 1.0}.
+
+    max_iter : int, default=200
+        Maximum number of iterations during fit.
+
+    tol : float, default=1e-4
+        A positive scalar giving the tolerance at which the
+        un-mixing matrix is considered to have converged.
+
+    w_init : array-like of shape (n_components, n_components), default=None
+        Initial un-mixing array. If `w_init=None`, then an array of values
+        drawn from a normal distribution is used.
+
+    whiten_solver : {"eigh", "svd"}, default="svd"
+        The solver to use for whitening.
+
+        - "svd" is more stable numerically if the problem is degenerate, and
+          often faster when `n_samples <= n_features`.
+
+        - "eigh" is generally more memory efficient when
+          `n_samples >= n_features`, and can be faster when
+          `n_samples >= 50 * n_features`.
+
+        .. versionadded:: 1.2
+
+    random_state : int, RandomState instance or None, default=None
+        Used to initialize ``w_init`` when not specified, with a
+        normal distribution. Pass an int, for reproducible results
+        across multiple function calls.
+        See :term:`Glossary <random_state>`.
+
+    Attributes
+    ----------
+    components_ : ndarray of shape (n_components, n_features)
+        The linear operator to apply to the data to get the independent
+        sources. This is equal to the unmixing matrix when ``whiten`` is
+        False, and equal to ``np.dot(unmixing_matrix, self.whitening_)`` when
+        ``whiten`` is True.
+
+    mixing_ : ndarray of shape (n_features, n_components)
+        The pseudo-inverse of ``components_``. It is the linear operator
+        that maps independent sources to the data.
+
+    mean_ : ndarray of shape(n_features,)
+        The mean over features. Only set if `self.whiten` is True.
+
+    n_features_in_ : int
+        Number of features seen during :term:`fit`.
+
+        .. versionadded:: 0.24
+
+    feature_names_in_ : ndarray of shape (`n_features_in_`,)
+        Names of features seen during :term:`fit`. Defined only when `X`
+        has feature names that are all strings.
+
+        .. versionadded:: 1.0
+
+    n_iter_ : int
+        If the algorithm is "deflation", n_iter is the
+        maximum number of iterations run across all components. Else
+        they are just the number of iterations taken to converge.
+
+    whitening_ : ndarray of shape (n_components, n_features)
+        Only set if whiten is 'True'. This is the pre-whitening matrix
+        that projects data onto the first `n_components` principal components.
+
+    See Also
+    --------
+    PCA : Principal component analysis (PCA).
+    IncrementalPCA : Incremental principal components analysis (IPCA).
+    KernelPCA : Kernel Principal component analysis (KPCA).
+    MiniBatchSparsePCA : Mini-batch Sparse Principal Components Analysis.
+    SparsePCA : Sparse Principal Components Analysis (SparsePCA).
+
+    References
+    ----------
+    .. [1] A. Hyvarinen and E. Oja, Independent Component Analysis:
+           Algorithms and Applications, Neural Networks, 13(4-5), 2000,
+           pp. 411-430.
+
+    Examples
+    --------
+    >>> from sklearn.datasets import load_digits
+    >>> from sklearn.decomposition import FastICA
+    >>> X, _ = load_digits(return_X_y=True)
+    >>> transformer = FastICA(n_components=7,
+    ...         random_state=0,
+    ...         whiten='unit-variance')
+    >>> X_transformed = transformer.fit_transform(X)
+    >>> X_transformed.shape
+    (1797, 7)
+    """
+
+    _parameter_constraints: dict = {
+        "n_components": [Interval(Integral, 1, None, closed="left"), None],
+        "algorithm": [StrOptions({"parallel", "deflation"})],
+        "whiten": [
+            StrOptions({"arbitrary-variance", "unit-variance"}),
+            Options(bool, {False}),
+        ],
+        "fun": [StrOptions({"logcosh", "exp", "cube"}), callable],
+        "fun_args": [dict, None],
+        "max_iter": [Interval(Integral, 1, None, closed="left")],
+        "tol": [Interval(Real, 0.0, None, closed="left")],
+        "w_init": ["array-like", None],
+        "whiten_solver": [StrOptions({"eigh", "svd"})],
+        "random_state": ["random_state"],
+    }
+
+    def __init__(
+        self,
+        n_components=None,
+        *,
+        algorithm="parallel",
+        whiten="unit-variance",
+        fun="logcosh",
+        fun_args=None,
+        max_iter=200,
+        tol=1e-4,
+        w_init=None,
+        whiten_solver="svd",
+        random_state=None,
+    ):
+        super().__init__()
+        self.n_components = n_components
+        self.algorithm = algorithm
+        self.whiten = whiten
+        self.fun = fun
+        self.fun_args = fun_args
+        self.max_iter = max_iter
+        self.tol = tol
+        self.w_init = w_init
+        self.whiten_solver = whiten_solver
+        self.random_state = random_state
+
+    def _fit_transform(self, X, compute_sources=False):
+        """Fit the model.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+            Training data, where `n_samples` is the number of samples
+            and `n_features` is the number of features.
+
+        compute_sources : bool, default=False
+            If False, sources are not computes but only the rotation matrix.
+            This can save memory when working with big data. Defaults to False.
+
+        Returns
+        -------
+        S : ndarray of shape (n_samples, n_components) or None
+            Sources matrix. `None` if `compute_sources` is `False`.
+        """
+        XT = validate_data(
+            self,
+            X,
+            copy=self.whiten,
+            dtype=[np.float64, np.float32],
+            ensure_min_samples=2,
+        ).T
+        fun_args = {} if self.fun_args is None else self.fun_args
+        random_state = check_random_state(self.random_state)
+
+        alpha = fun_args.get("alpha", 1.0)
+        if not 1 <= alpha <= 2:
+            raise ValueError("alpha must be in [1,2]")
+
+        if self.fun == "logcosh":
+            g = _logcosh
+        elif self.fun == "exp":
+            g = _exp
+        elif self.fun == "cube":
+            g = _cube
+        elif callable(self.fun):
+
+            def g(x, fun_args):
+                return self.fun(x, **fun_args)
+
+        n_features, n_samples = XT.shape
+        n_components = self.n_components
+        if not self.whiten and n_components is not None:
+            n_components = None
+            warnings.warn("Ignoring n_components with whiten=False.")
+
+        if n_components is None:
+            n_components = min(n_samples, n_features)
+        if n_components > min(n_samples, n_features):
+            n_components = min(n_samples, n_features)
+            warnings.warn(
+                "n_components is too large: it will be set to %s" % n_components
+            )
+
+        if self.whiten:
+            # Centering the features of X
+            X_mean = XT.mean(axis=-1)
+            XT -= X_mean[:, np.newaxis]
+
+            # Whitening and preprocessing by PCA
+            if self.whiten_solver == "eigh":
+                # Faster when num_samples >> n_features
+                d, u = linalg.eigh(XT.dot(X))
+                sort_indices = np.argsort(d)[::-1]
+                eps = np.finfo(d.dtype).eps * 10
+                degenerate_idx = d < eps
+                if np.any(degenerate_idx):
+                    warnings.warn(
+                        "There are some small singular values, using "
+                        "whiten_solver = 'svd' might lead to more "
+                        "accurate results."
+                    )
+                d[degenerate_idx] = eps  # For numerical issues
+                np.sqrt(d, out=d)
+                d, u = d[sort_indices], u[:, sort_indices]
+            elif self.whiten_solver == "svd":
+                u, d = linalg.svd(XT, full_matrices=False, check_finite=False)[:2]
+
+            # Give consistent eigenvectors for both svd solvers
+            u *= np.sign(u[0])
+
+            K = (u / d).T[:n_components]  # see (6.33) p.140
+            del u, d
+            X1 = np.dot(K, XT)
+            # see (13.6) p.267 Here X1 is white and data
+            # in X has been projected onto a subspace by PCA
+            X1 *= np.sqrt(n_samples)
+        else:
+            # X must be casted to floats to avoid typing issues with numpy
+            # 2.0 and the line below
+            X1 = as_float_array(XT, copy=False)  # copy has been taken care of
+
+        w_init = self.w_init
+        if w_init is None:
+            w_init = np.asarray(
+                random_state.normal(size=(n_components, n_components)), dtype=X1.dtype
+            )
+
+        else:
+            w_init = np.asarray(w_init)
+            if w_init.shape != (n_components, n_components):
+                raise ValueError(
+                    "w_init has invalid shape -- should be %(shape)s"
+                    % {"shape": (n_components, n_components)}
+                )
+
+        kwargs = {
+            "tol": self.tol,
+            "g": g,
+            "fun_args": fun_args,
+            "max_iter": self.max_iter,
+            "w_init": w_init,
+        }
+
+        if self.algorithm == "parallel":
+            W, n_iter = _ica_par(X1, **kwargs)
+        elif self.algorithm == "deflation":
+            W, n_iter = _ica_def(X1, **kwargs)
+        del X1
+
+        self.n_iter_ = n_iter
+
+        if compute_sources:
+            if self.whiten:
+                S = np.linalg.multi_dot([W, K, XT]).T
+            else:
+                S = np.dot(W, XT).T
+        else:
+            S = None
+
+        if self.whiten:
+            if self.whiten == "unit-variance":
+                if not compute_sources:
+                    S = np.linalg.multi_dot([W, K, XT]).T
+                S_std = np.std(S, axis=0, keepdims=True)
+                S /= S_std
+                W /= S_std.T
+
+            self.components_ = np.dot(W, K)
+            self.mean_ = X_mean
+            self.whitening_ = K
+        else:
+            self.components_ = W
+
+        self.mixing_ = linalg.pinv(self.components_, check_finite=False)
+        self._unmixing = W
+
+        return S
+
+    @_fit_context(prefer_skip_nested_validation=True)
+    def fit_transform(self, X, y=None):
+        """Fit the model and recover the sources from X.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+            Training data, where `n_samples` is the number of samples
+            and `n_features` is the number of features.
+
+        y : Ignored
+            Not used, present for API consistency by convention.
+
+        Returns
+        -------
+        X_new : ndarray of shape (n_samples, n_components)
+            Estimated sources obtained by transforming the data with the
+            estimated unmixing matrix.
+        """
+        return self._fit_transform(X, compute_sources=True)
+
+    @_fit_context(prefer_skip_nested_validation=True)
+    def fit(self, X, y=None):
+        """Fit the model to X.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+            Training data, where `n_samples` is the number of samples
+            and `n_features` is the number of features.
+
+        y : Ignored
+            Not used, present for API consistency by convention.
+
+        Returns
+        -------
+        self : object
+            Returns the instance itself.
+        """
+        self._fit_transform(X, compute_sources=False)
+        return self
+
+    def transform(self, X, copy=True):
+        """Recover the sources from X (apply the unmixing matrix).
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+            Data to transform, where `n_samples` is the number of samples
+            and `n_features` is the number of features.
+
+        copy : bool, default=True
+            If False, data passed to fit can be overwritten. Defaults to True.
+
+        Returns
+        -------
+        X_new : ndarray of shape (n_samples, n_components)
+            Estimated sources obtained by transforming the data with the
+            estimated unmixing matrix.
+        """
+        check_is_fitted(self)
+
+        X = validate_data(
+            self,
+            X,
+            copy=(copy and self.whiten),
+            dtype=[np.float64, np.float32],
+            reset=False,
+        )
+        if self.whiten:
+            X -= self.mean_
+
+        return np.dot(X, self.components_.T)
+
+    def inverse_transform(self, X, copy=True):
+        """Transform the sources back to the mixed data (apply mixing matrix).
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_components)
+            Sources, where `n_samples` is the number of samples
+            and `n_components` is the number of components.
+        copy : bool, default=True
+            If False, data passed to fit are overwritten. Defaults to True.
+
+        Returns
+        -------
+        X_original : ndarray of shape (n_samples, n_features)
+            Reconstructed data obtained with the mixing matrix.
+        """
+        check_is_fitted(self)
+
+        X = check_array(X, copy=(copy and self.whiten), dtype=[np.float64, np.float32])
+        X = np.dot(X, self.mixing_.T)
+        if self.whiten:
+            X += self.mean_
+
+        return X
+
+    @property
+    def _n_features_out(self):
+        """Number of transformed output features."""
+        return self.components_.shape[0]
+
+    def __sklearn_tags__(self):
+        tags = super().__sklearn_tags__()
+        tags.transformer_tags.preserves_dtype = ["float64", "float32"]
+        return tags

miniconda3/envs/active_proaction/lib/python3.10/site-packages/sklearn/decomposition/_incremental_pca.py

@@ -0,0 +1,426 @@
+"""Incremental Principal Components Analysis."""
+
+# Authors: The scikit-learn developers
+# SPDX-License-Identifier: BSD-3-Clause
+
+from numbers import Integral
+
+import numpy as np
+from scipy import linalg, sparse
+
+from sklearn.utils import metadata_routing
+
+from ..base import _fit_context
+from ..utils import gen_batches
+from ..utils._param_validation import Interval
+from ..utils.extmath import _incremental_mean_and_var, svd_flip
+from ..utils.validation import validate_data
+from ._base import _BasePCA
+
+
+class IncrementalPCA(_BasePCA):
+    """Incremental principal components analysis (IPCA).
+
+    Linear dimensionality reduction using Singular Value Decomposition of
+    the data, keeping only the most significant singular vectors to
+    project the data to a lower dimensional space. The input data is centered
+    but not scaled for each feature before applying the SVD.
+
+    Depending on the size of the input data, this algorithm can be much more
+    memory efficient than a PCA, and allows sparse input.
+
+    This algorithm has constant memory complexity, on the order
+    of ``batch_size * n_features``, enabling use of np.memmap files without
+    loading the entire file into memory. For sparse matrices, the input
+    is converted to dense in batches (in order to be able to subtract the
+    mean) which avoids storing the entire dense matrix at any one time.
+
+    The computational overhead of each SVD is
+    ``O(batch_size * n_features ** 2)``, but only 2 * batch_size samples
+    remain in memory at a time. There will be ``n_samples / batch_size`` SVD
+    computations to get the principal components, versus 1 large SVD of
+    complexity ``O(n_samples * n_features ** 2)`` for PCA.
+
+    For a usage example, see
+    :ref:`sphx_glr_auto_examples_decomposition_plot_incremental_pca.py`.
+
+    Read more in the :ref:`User Guide <IncrementalPCA>`.
+
+    .. versionadded:: 0.16
+
+    Parameters
+    ----------
+    n_components : int, default=None
+        Number of components to keep. If ``n_components`` is ``None``,
+        then ``n_components`` is set to ``min(n_samples, n_features)``.
+
+    whiten : bool, default=False
+        When True (False by default) the ``components_`` vectors are divided
+        by ``n_samples`` times ``components_`` to ensure uncorrelated outputs
+        with unit component-wise variances.
+
+        Whitening will remove some information from the transformed signal
+        (the relative variance scales of the components) but can sometimes
+        improve the predictive accuracy of the downstream estimators by
+        making data respect some hard-wired assumptions.
+
+    copy : bool, default=True
+        If False, X will be overwritten. ``copy=False`` can be used to
+        save memory but is unsafe for general use.
+
+    batch_size : int, default=None
+        The number of samples to use for each batch. Only used when calling
+        ``fit``. If ``batch_size`` is ``None``, then ``batch_size``
+        is inferred from the data and set to ``5 * n_features``, to provide a
+        balance between approximation accuracy and memory consumption.
+
+    Attributes
+    ----------
+    components_ : ndarray of shape (n_components, n_features)
+        Principal axes in feature space, representing the directions of
+        maximum variance in the data. Equivalently, the right singular
+        vectors of the centered input data, parallel to its eigenvectors.
+        The components are sorted by decreasing ``explained_variance_``.
+
+    explained_variance_ : ndarray of shape (n_components,)
+        Variance explained by each of the selected components.
+
+    explained_variance_ratio_ : ndarray of shape (n_components,)
+        Percentage of variance explained by each of the selected components.
+        If all components are stored, the sum of explained variances is equal
+        to 1.0.
+
+    singular_values_ : ndarray of shape (n_components,)
+        The singular values corresponding to each of the selected components.
+        The singular values are equal to the 2-norms of the ``n_components``
+        variables in the lower-dimensional space.
+
+    mean_ : ndarray of shape (n_features,)
+        Per-feature empirical mean, aggregate over calls to ``partial_fit``.
+
+    var_ : ndarray of shape (n_features,)
+        Per-feature empirical variance, aggregate over calls to
+        ``partial_fit``.
+
+    noise_variance_ : float
+        The estimated noise covariance following the Probabilistic PCA model
+        from Tipping and Bishop 1999. See "Pattern Recognition and
+        Machine Learning" by C. Bishop, 12.2.1 p. 574 or
+        http://www.miketipping.com/papers/met-mppca.pdf.
+
+    n_components_ : int
+        The estimated number of components. Relevant when
+        ``n_components=None``.
+
+    n_samples_seen_ : int
+        The number of samples processed by the estimator. Will be reset on
+        new calls to fit, but increments across ``partial_fit`` calls.
+
+    batch_size_ : int
+        Inferred batch size from ``batch_size``.
+
+    n_features_in_ : int
+        Number of features seen during :term:`fit`.
+
+        .. versionadded:: 0.24
+
+    feature_names_in_ : ndarray of shape (`n_features_in_`,)
+        Names of features seen during :term:`fit`. Defined only when `X`
+        has feature names that are all strings.
+
+        .. versionadded:: 1.0
+
+    See Also
+    --------
+    PCA : Principal component analysis (PCA).
+    KernelPCA : Kernel Principal component analysis (KPCA).
+    SparsePCA : Sparse Principal Components Analysis (SparsePCA).
+    TruncatedSVD : Dimensionality reduction using truncated SVD.
+
+    Notes
+    -----
+    Implements the incremental PCA model from:
+    *D. Ross, J. Lim, R. Lin, M. Yang, Incremental Learning for Robust Visual
+    Tracking, International Journal of Computer Vision, Volume 77, Issue 1-3,
+    pp. 125-141, May 2008.*
+    See https://www.cs.toronto.edu/~dross/ivt/RossLimLinYang_ijcv.pdf
+
+    This model is an extension of the Sequential Karhunen-Loeve Transform from:
+    :doi:`A. Levy and M. Lindenbaum, Sequential Karhunen-Loeve Basis Extraction and
+    its Application to Images, IEEE Transactions on Image Processing, Volume 9,
+    Number 8, pp. 1371-1374, August 2000. <10.1109/83.855432>`
+
+    We have specifically abstained from an optimization used by authors of both
+    papers, a QR decomposition used in specific situations to reduce the
+    algorithmic complexity of the SVD. The source for this technique is
+    *Matrix Computations, Third Edition, G. Holub and C. Van Loan, Chapter 5,
+    section 5.4.4, pp 252-253.*. This technique has been omitted because it is
+    advantageous only when decomposing a matrix with ``n_samples`` (rows)
+    >= 5/3 * ``n_features`` (columns), and hurts the readability of the
+    implemented algorithm. This would be a good opportunity for future
+    optimization, if it is deemed necessary.
+
+    References
+    ----------
+    D. Ross, J. Lim, R. Lin, M. Yang. Incremental Learning for Robust Visual
+    Tracking, International Journal of Computer Vision, Volume 77,
+    Issue 1-3, pp. 125-141, May 2008.
+
+    G. Golub and C. Van Loan. Matrix Computations, Third Edition, Chapter 5,
+    Section 5.4.4, pp. 252-253.
+
+    Examples
+    --------
+    >>> from sklearn.datasets import load_digits
+    >>> from sklearn.decomposition import IncrementalPCA
+    >>> from scipy import sparse
+    >>> X, _ = load_digits(return_X_y=True)
+    >>> transformer = IncrementalPCA(n_components=7, batch_size=200)
+    >>> # either partially fit on smaller batches of data
+    >>> transformer.partial_fit(X[:100, :])
+    IncrementalPCA(batch_size=200, n_components=7)
+    >>> # or let the fit function itself divide the data into batches
+    >>> X_sparse = sparse.csr_matrix(X)
+    >>> X_transformed = transformer.fit_transform(X_sparse)
+    >>> X_transformed.shape
+    (1797, 7)
+    """
+
+    __metadata_request__partial_fit = {"check_input": metadata_routing.UNUSED}
+
+    _parameter_constraints: dict = {
+        "n_components": [Interval(Integral, 1, None, closed="left"), None],
+        "whiten": ["boolean"],
+        "copy": ["boolean"],
+        "batch_size": [Interval(Integral, 1, None, closed="left"), None],
+    }
+
+    def __init__(self, n_components=None, *, whiten=False, copy=True, batch_size=None):
+        self.n_components = n_components
+        self.whiten = whiten
+        self.copy = copy
+        self.batch_size = batch_size
+
+    @_fit_context(prefer_skip_nested_validation=True)
+    def fit(self, X, y=None):
+        """Fit the model with X, using minibatches of size batch_size.
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} of shape (n_samples, n_features)
+            Training data, where `n_samples` is the number of samples and
+            `n_features` is the number of features.
+
+        y : Ignored
+            Not used, present for API consistency by convention.
+
+        Returns
+        -------
+        self : object
+            Returns the instance itself.
+        """
+        self.components_ = None
+        self.n_samples_seen_ = 0
+        self.mean_ = 0.0
+        self.var_ = 0.0
+        self.singular_values_ = None
+        self.explained_variance_ = None
+        self.explained_variance_ratio_ = None
+        self.noise_variance_ = None
+
+        X = validate_data(
+            self,
+            X,
+            accept_sparse=["csr", "csc", "lil"],
+            copy=self.copy,
+            dtype=[np.float64, np.float32],
+            force_writeable=True,
+        )
+        n_samples, n_features = X.shape
+
+        if self.batch_size is None:
+            self.batch_size_ = 5 * n_features
+        else:
+            self.batch_size_ = self.batch_size
+
+        for batch in gen_batches(
+            n_samples, self.batch_size_, min_batch_size=self.n_components or 0
+        ):
+            X_batch = X[batch]
+            if sparse.issparse(X_batch):
+                X_batch = X_batch.toarray()
+            self.partial_fit(X_batch, check_input=False)
+
+        return self
+
+    @_fit_context(prefer_skip_nested_validation=True)
+    def partial_fit(self, X, y=None, check_input=True):
+        """Incremental fit with X. All of X is processed as a single batch.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+            Training data, where `n_samples` is the number of samples and
+            `n_features` is the number of features.
+
+        y : Ignored
+            Not used, present for API consistency by convention.
+
+        check_input : bool, default=True
+            Run check_array on X.
+
+        Returns
+        -------
+        self : object
+            Returns the instance itself.
+        """
+        first_pass = not hasattr(self, "components_")
+
+        if check_input:
+            if sparse.issparse(X):
+                raise TypeError(
+                    "IncrementalPCA.partial_fit does not support "
+                    "sparse input. Either convert data to dense "
+                    "or use IncrementalPCA.fit to do so in batches."
+                )
+            X = validate_data(
+                self,
+                X,
+                copy=self.copy,
+                dtype=[np.float64, np.float32],
+                force_writeable=True,
+                reset=first_pass,
+            )
+        n_samples, n_features = X.shape
+        if first_pass:
+            self.components_ = None
+
+        if self.n_components is None:
+            if self.components_ is None:
+                self.n_components_ = min(n_samples, n_features)
+            else:
+                self.n_components_ = self.components_.shape[0]
+        elif not self.n_components <= n_features:
+            raise ValueError(
+                "n_components=%r invalid for n_features=%d, need "
+                "more rows than columns for IncrementalPCA "
+                "processing" % (self.n_components, n_features)
+            )
+        elif self.n_components > n_samples and first_pass:
+            raise ValueError(
+                f"n_components={self.n_components} must be less or equal to "
+                f"the batch number of samples {n_samples} for the first "
+                "partial_fit call."
+            )
+        else:
+            self.n_components_ = self.n_components
+
+        if (self.components_ is not None) and (
+            self.components_.shape[0] != self.n_components_
+        ):
+            raise ValueError(
+                "Number of input features has changed from %i "
+                "to %i between calls to partial_fit! Try "
+                "setting n_components to a fixed value."
+                % (self.components_.shape[0], self.n_components_)
+            )
+
+        # This is the first partial_fit
+        if not hasattr(self, "n_samples_seen_"):
+            self.n_samples_seen_ = 0
+            self.mean_ = 0.0
+            self.var_ = 0.0
+
+        # Update stats - they are 0 if this is the first step
+        col_mean, col_var, n_total_samples = _incremental_mean_and_var(
+            X,
+            last_mean=self.mean_,
+            last_variance=self.var_,
+            last_sample_count=np.repeat(self.n_samples_seen_, X.shape[1]),
+        )
+        n_total_samples = n_total_samples[0]
+
+        # Whitening
+        if self.n_samples_seen_ == 0:
+            # If it is the first step, simply whiten X
+            X -= col_mean
+        else:
+            col_batch_mean = np.mean(X, axis=0)
+            X -= col_batch_mean
+            # Build matrix of combined previous basis and new data
+            mean_correction = np.sqrt(
+                (self.n_samples_seen_ / n_total_samples) * n_samples
+            ) * (self.mean_ - col_batch_mean)
+            X = np.vstack(
+                (
+                    self.singular_values_.reshape((-1, 1)) * self.components_,
+                    X,
+                    mean_correction,
+                )
+            )
+
+        U, S, Vt = linalg.svd(X, full_matrices=False, check_finite=False)
+        U, Vt = svd_flip(U, Vt, u_based_decision=False)
+        explained_variance = S**2 / (n_total_samples - 1)
+        explained_variance_ratio = S**2 / np.sum(col_var * n_total_samples)
+
+        self.n_samples_seen_ = n_total_samples
+        self.components_ = Vt[: self.n_components_]
+        self.singular_values_ = S[: self.n_components_]
+        self.mean_ = col_mean
+        self.var_ = col_var
+        self.explained_variance_ = explained_variance[: self.n_components_]
+        self.explained_variance_ratio_ = explained_variance_ratio[: self.n_components_]
+        # we already checked `self.n_components <= n_samples` above
+        if self.n_components_ not in (n_samples, n_features):
+            self.noise_variance_ = explained_variance[self.n_components_ :].mean()
+        else:
+            self.noise_variance_ = 0.0
+        return self
+
+    def transform(self, X):
+        """Apply dimensionality reduction to X.
+
+        X is projected on the first principal components previously extracted
+        from a training set, using minibatches of size batch_size if X is
+        sparse.
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} of shape (n_samples, n_features)
+            New data, where `n_samples` is the number of samples
+            and `n_features` is the number of features.
+
+        Returns
+        -------
+        X_new : ndarray of shape (n_samples, n_components)
+            Projection of X in the first principal components.
+
+        Examples
+        --------
+
+        >>> import numpy as np
+        >>> from sklearn.decomposition import IncrementalPCA
+        >>> X = np.array([[-1, -1], [-2, -1], [-3, -2],
+        ...               [1, 1], [2, 1], [3, 2]])
+        >>> ipca = IncrementalPCA(n_components=2, batch_size=3)
+        >>> ipca.fit(X)
+        IncrementalPCA(batch_size=3, n_components=2)
+        >>> ipca.transform(X) # doctest: +SKIP
+        """
+        if sparse.issparse(X):
+            n_samples = X.shape[0]
+            output = []
+            for batch in gen_batches(
+                n_samples, self.batch_size_, min_batch_size=self.n_components or 0
+            ):
+                output.append(super().transform(X[batch].toarray()))
+            return np.vstack(output)
+        else:
+            return super().transform(X)
+
+    def __sklearn_tags__(self):
+        tags = super().__sklearn_tags__()
+        # Beware that fit accepts sparse data but partial_fit doesn't
+        tags.input_tags.sparse = True
+        return tags