Add files using upload-large-folder tool

ckpts/universal/global_step40/zero/18.mlp.dense_4h_to_h.weight/exp_avg_sq.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dc6549c0a88fbfc97075ef2d2cbbe6845eb2da840f7a8893bf3cc6564668b787
+size 33555627

ckpts/universal/global_step40/zero/18.mlp.dense_4h_to_h.weight/fp32.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f130d87201997e48c47b0ea865c94a40798b6dbcbe1d99e771a2f139b2c2b6f1
+size 33555533

ckpts/universal/global_step40/zero/19.attention.dense.weight/exp_avg_sq.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:76f467b45af601530430872d2c6314dff0b05a9f74496ad4d67a7030eb74f05c
+size 16778411

venv/lib/python3.10/site-packages/sklearn/feature_extraction/__init__.py

@@ -0,0 +1,19 @@
+"""
+The :mod:`sklearn.feature_extraction` module deals with feature extraction
+from raw data. It currently includes methods to extract features from text and
+images.
+"""
+
+from . import text
+from ._dict_vectorizer import DictVectorizer
+from ._hash import FeatureHasher
+from .image import grid_to_graph, img_to_graph
+
+__all__ = [
+    "DictVectorizer",
+    "image",
+    "img_to_graph",
+    "grid_to_graph",
+    "text",
+    "FeatureHasher",
+]

venv/lib/python3.10/site-packages/sklearn/feature_extraction/_dict_vectorizer.py

@@ -0,0 +1,452 @@
+# Authors: Lars Buitinck
+#          Dan Blanchard <[email protected]>
+# License: BSD 3 clause
+
+from array import array
+from collections.abc import Iterable, Mapping
+from numbers import Number
+from operator import itemgetter
+
+import numpy as np
+import scipy.sparse as sp
+
+from ..base import BaseEstimator, TransformerMixin, _fit_context
+from ..utils import check_array
+from ..utils.validation import check_is_fitted
+
+
+class DictVectorizer(TransformerMixin, BaseEstimator):
+    """Transforms lists of feature-value mappings to vectors.
+
+    This transformer turns lists of mappings (dict-like objects) of feature
+    names to feature values into Numpy arrays or scipy.sparse matrices for use
+    with scikit-learn estimators.
+
+    When feature values are strings, this transformer will do a binary one-hot
+    (aka one-of-K) coding: one boolean-valued feature is constructed for each
+    of the possible string values that the feature can take on. For instance,
+    a feature "f" that can take on the values "ham" and "spam" will become two
+    features in the output, one signifying "f=ham", the other "f=spam".
+
+    If a feature value is a sequence or set of strings, this transformer
+    will iterate over the values and will count the occurrences of each string
+    value.
+
+    However, note that this transformer will only do a binary one-hot encoding
+    when feature values are of type string. If categorical features are
+    represented as numeric values such as int or iterables of strings, the
+    DictVectorizer can be followed by
+    :class:`~sklearn.preprocessing.OneHotEncoder` to complete
+    binary one-hot encoding.
+
+    Features that do not occur in a sample (mapping) will have a zero value
+    in the resulting array/matrix.
+
+    For an efficiency comparison of the different feature extractors, see
+    :ref:`sphx_glr_auto_examples_text_plot_hashing_vs_dict_vectorizer.py`.
+
+    Read more in the :ref:`User Guide <dict_feature_extraction>`.
+
+    Parameters
+    ----------
+    dtype : dtype, default=np.float64
+        The type of feature values. Passed to Numpy array/scipy.sparse matrix
+        constructors as the dtype argument.
+    separator : str, default="="
+        Separator string used when constructing new features for one-hot
+        coding.
+    sparse : bool, default=True
+        Whether transform should produce scipy.sparse matrices.
+    sort : bool, default=True
+        Whether ``feature_names_`` and ``vocabulary_`` should be
+        sorted when fitting.
+
+    Attributes
+    ----------
+    vocabulary_ : dict
+        A dictionary mapping feature names to feature indices.
+
+    feature_names_ : list
+        A list of length n_features containing the feature names (e.g., "f=ham"
+        and "f=spam").
+
+    See Also
+    --------
+    FeatureHasher : Performs vectorization using only a hash function.
+    sklearn.preprocessing.OrdinalEncoder : Handles nominal/categorical
+        features encoded as columns of arbitrary data types.
+
+    Examples
+    --------
+    >>> from sklearn.feature_extraction import DictVectorizer
+    >>> v = DictVectorizer(sparse=False)
+    >>> D = [{'foo': 1, 'bar': 2}, {'foo': 3, 'baz': 1}]
+    >>> X = v.fit_transform(D)
+    >>> X
+    array([[2., 0., 1.],
+           [0., 1., 3.]])
+    >>> v.inverse_transform(X) == [{'bar': 2.0, 'foo': 1.0},
+    ...                            {'baz': 1.0, 'foo': 3.0}]
+    True
+    >>> v.transform({'foo': 4, 'unseen_feature': 3})
+    array([[0., 0., 4.]])
+    """
+
+    _parameter_constraints: dict = {
+        "dtype": "no_validation",  # validation delegated to numpy,
+        "separator": [str],
+        "sparse": ["boolean"],
+        "sort": ["boolean"],
+    }
+
+    def __init__(self, *, dtype=np.float64, separator="=", sparse=True, sort=True):
+        self.dtype = dtype
+        self.separator = separator
+        self.sparse = sparse
+        self.sort = sort
+
+    def _add_iterable_element(
+        self,
+        f,
+        v,
+        feature_names,
+        vocab,
+        *,
+        fitting=True,
+        transforming=False,
+        indices=None,
+        values=None,
+    ):
+        """Add feature names for iterable of strings"""
+        for vv in v:
+            if isinstance(vv, str):
+                feature_name = "%s%s%s" % (f, self.separator, vv)
+                vv = 1
+            else:
+                raise TypeError(
+                    f"Unsupported type {type(vv)} in iterable "
+                    "value. Only iterables of string are "
+                    "supported."
+                )
+            if fitting and feature_name not in vocab:
+                vocab[feature_name] = len(feature_names)
+                feature_names.append(feature_name)
+
+            if transforming and feature_name in vocab:
+                indices.append(vocab[feature_name])
+                values.append(self.dtype(vv))
+
+    @_fit_context(prefer_skip_nested_validation=True)
+    def fit(self, X, y=None):
+        """Learn a list of feature name -> indices mappings.
+
+        Parameters
+        ----------
+        X : Mapping or iterable over Mappings
+            Dict(s) or Mapping(s) from feature names (arbitrary Python
+            objects) to feature values (strings or convertible to dtype).
+
+            .. versionchanged:: 0.24
+               Accepts multiple string values for one categorical feature.
+
+        y : (ignored)
+            Ignored parameter.
+
+        Returns
+        -------
+        self : object
+            DictVectorizer class instance.
+        """
+        feature_names = []
+        vocab = {}
+
+        for x in X:
+            for f, v in x.items():
+                if isinstance(v, str):
+                    feature_name = "%s%s%s" % (f, self.separator, v)
+                elif isinstance(v, Number) or (v is None):
+                    feature_name = f
+                elif isinstance(v, Mapping):
+                    raise TypeError(
+                        f"Unsupported value type {type(v)} "
+                        f"for {f}: {v}.\n"
+                        "Mapping objects are not supported."
+                    )
+                elif isinstance(v, Iterable):
+                    feature_name = None
+                    self._add_iterable_element(f, v, feature_names, vocab)
+
+                if feature_name is not None:
+                    if feature_name not in vocab:
+                        vocab[feature_name] = len(feature_names)
+                        feature_names.append(feature_name)
+
+        if self.sort:
+            feature_names.sort()
+            vocab = {f: i for i, f in enumerate(feature_names)}
+
+        self.feature_names_ = feature_names
+        self.vocabulary_ = vocab
+
+        return self
+
+    def _transform(self, X, fitting):
+        # Sanity check: Python's array has no way of explicitly requesting the
+        # signed 32-bit integers that scipy.sparse needs, so we use the next
+        # best thing: typecode "i" (int). However, if that gives larger or
+        # smaller integers than 32-bit ones, np.frombuffer screws up.
+        assert array("i").itemsize == 4, (
+            "sizeof(int) != 4 on your platform; please report this at"
+            " https://github.com/scikit-learn/scikit-learn/issues and"
+            " include the output from platform.platform() in your bug report"
+        )
+
+        dtype = self.dtype
+        if fitting:
+            feature_names = []
+            vocab = {}
+        else:
+            feature_names = self.feature_names_
+            vocab = self.vocabulary_
+
+        transforming = True
+
+        # Process everything as sparse regardless of setting
+        X = [X] if isinstance(X, Mapping) else X
+
+        indices = array("i")
+        indptr = [0]
+        # XXX we could change values to an array.array as well, but it
+        # would require (heuristic) conversion of dtype to typecode...
+        values = []
+
+        # collect all the possible feature names and build sparse matrix at
+        # same time
+        for x in X:
+            for f, v in x.items():
+                if isinstance(v, str):
+                    feature_name = "%s%s%s" % (f, self.separator, v)
+                    v = 1
+                elif isinstance(v, Number) or (v is None):
+                    feature_name = f
+                elif not isinstance(v, Mapping) and isinstance(v, Iterable):
+                    feature_name = None
+                    self._add_iterable_element(
+                        f,
+                        v,
+                        feature_names,
+                        vocab,
+                        fitting=fitting,
+                        transforming=transforming,
+                        indices=indices,
+                        values=values,
+                    )
+                else:
+                    raise TypeError(
+                        f"Unsupported value Type {type(v)} "
+                        f"for {f}: {v}.\n"
+                        f"{type(v)} objects are not supported."
+                    )
+
+                if feature_name is not None:
+                    if fitting and feature_name not in vocab:
+                        vocab[feature_name] = len(feature_names)
+                        feature_names.append(feature_name)
+
+                    if feature_name in vocab:
+                        indices.append(vocab[feature_name])
+                        values.append(self.dtype(v))
+
+            indptr.append(len(indices))
+
+        if len(indptr) == 1:
+            raise ValueError("Sample sequence X is empty.")
+
+        indices = np.frombuffer(indices, dtype=np.intc)
+        shape = (len(indptr) - 1, len(vocab))
+
+        result_matrix = sp.csr_matrix(
+            (values, indices, indptr), shape=shape, dtype=dtype
+        )
+
+        # Sort everything if asked
+        if fitting and self.sort:
+            feature_names.sort()
+            map_index = np.empty(len(feature_names), dtype=np.int32)
+            for new_val, f in enumerate(feature_names):
+                map_index[new_val] = vocab[f]
+                vocab[f] = new_val
+            result_matrix = result_matrix[:, map_index]
+
+        if self.sparse:
+            result_matrix.sort_indices()
+        else:
+            result_matrix = result_matrix.toarray()
+
+        if fitting:
+            self.feature_names_ = feature_names
+            self.vocabulary_ = vocab
+
+        return result_matrix
+
+    @_fit_context(prefer_skip_nested_validation=True)
+    def fit_transform(self, X, y=None):
+        """Learn a list of feature name -> indices mappings and transform X.
+
+        Like fit(X) followed by transform(X), but does not require
+        materializing X in memory.
+
+        Parameters
+        ----------
+        X : Mapping or iterable over Mappings
+            Dict(s) or Mapping(s) from feature names (arbitrary Python
+            objects) to feature values (strings or convertible to dtype).
+
+            .. versionchanged:: 0.24
+               Accepts multiple string values for one categorical feature.
+
+        y : (ignored)
+            Ignored parameter.
+
+        Returns
+        -------
+        Xa : {array, sparse matrix}
+            Feature vectors; always 2-d.
+        """
+        return self._transform(X, fitting=True)
+
+    def inverse_transform(self, X, dict_type=dict):
+        """Transform array or sparse matrix X back to feature mappings.
+
+        X must have been produced by this DictVectorizer's transform or
+        fit_transform method; it may only have passed through transformers
+        that preserve the number of features and their order.
+
+        In the case of one-hot/one-of-K coding, the constructed feature
+        names and values are returned rather than the original ones.
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} of shape (n_samples, n_features)
+            Sample matrix.
+        dict_type : type, default=dict
+            Constructor for feature mappings. Must conform to the
+            collections.Mapping API.
+
+        Returns
+        -------
+        D : list of dict_type objects of shape (n_samples,)
+            Feature mappings for the samples in X.
+        """
+        check_is_fitted(self, "feature_names_")
+
+        # COO matrix is not subscriptable
+        X = check_array(X, accept_sparse=["csr", "csc"])
+        n_samples = X.shape[0]
+
+        names = self.feature_names_
+        dicts = [dict_type() for _ in range(n_samples)]
+
+        if sp.issparse(X):
+            for i, j in zip(*X.nonzero()):
+                dicts[i][names[j]] = X[i, j]
+        else:
+            for i, d in enumerate(dicts):
+                for j, v in enumerate(X[i, :]):
+                    if v != 0:
+                        d[names[j]] = X[i, j]
+
+        return dicts
+
+    def transform(self, X):
+        """Transform feature->value dicts to array or sparse matrix.
+
+        Named features not encountered during fit or fit_transform will be
+        silently ignored.
+
+        Parameters
+        ----------
+        X : Mapping or iterable over Mappings of shape (n_samples,)
+            Dict(s) or Mapping(s) from feature names (arbitrary Python
+            objects) to feature values (strings or convertible to dtype).
+
+        Returns
+        -------
+        Xa : {array, sparse matrix}
+            Feature vectors; always 2-d.
+        """
+        check_is_fitted(self, ["feature_names_", "vocabulary_"])
+        return self._transform(X, fitting=False)
+
+    def get_feature_names_out(self, input_features=None):
+        """Get output feature names for transformation.
+
+        Parameters
+        ----------
+        input_features : array-like of str or None, default=None
+            Not used, present here for API consistency by convention.
+
+        Returns
+        -------
+        feature_names_out : ndarray of str objects
+            Transformed feature names.
+        """
+        check_is_fitted(self, "feature_names_")
+        if any(not isinstance(name, str) for name in self.feature_names_):
+            feature_names = [str(name) for name in self.feature_names_]
+        else:
+            feature_names = self.feature_names_
+        return np.asarray(feature_names, dtype=object)
+
+    def restrict(self, support, indices=False):
+        """Restrict the features to those in support using feature selection.
+
+        This function modifies the estimator in-place.
+
+        Parameters
+        ----------
+        support : array-like
+            Boolean mask or list of indices (as returned by the get_support
+            member of feature selectors).
+        indices : bool, default=False
+            Whether support is a list of indices.
+
+        Returns
+        -------
+        self : object
+            DictVectorizer class instance.
+
+        Examples
+        --------
+        >>> from sklearn.feature_extraction import DictVectorizer
+        >>> from sklearn.feature_selection import SelectKBest, chi2
+        >>> v = DictVectorizer()
+        >>> D = [{'foo': 1, 'bar': 2}, {'foo': 3, 'baz': 1}]
+        >>> X = v.fit_transform(D)
+        >>> support = SelectKBest(chi2, k=2).fit(X, [0, 1])
+        >>> v.get_feature_names_out()
+        array(['bar', 'baz', 'foo'], ...)
+        >>> v.restrict(support.get_support())
+        DictVectorizer()
+        >>> v.get_feature_names_out()
+        array(['bar', 'foo'], ...)
+        """
+        check_is_fitted(self, "feature_names_")
+
+        if not indices:
+            support = np.where(support)[0]
+
+        names = self.feature_names_
+        new_vocab = {}
+        for i in support:
+            new_vocab[names[i]] = len(new_vocab)
+
+        self.vocabulary_ = new_vocab
+        self.feature_names_ = [
+            f for f, i in sorted(new_vocab.items(), key=itemgetter(1))
+        ]
+
+        return self
+
+    def _more_tags(self):
+        return {"X_types": ["dict"]}

venv/lib/python3.10/site-packages/sklearn/feature_extraction/_hash.py

@@ -0,0 +1,197 @@
+# Author: Lars Buitinck
+# License: BSD 3 clause
+
+from itertools import chain
+from numbers import Integral
+
+import numpy as np
+import scipy.sparse as sp
+
+from ..base import BaseEstimator, TransformerMixin, _fit_context
+from ..utils._param_validation import Interval, StrOptions
+from ._hashing_fast import transform as _hashing_transform
+
+
+def _iteritems(d):
+    """Like d.iteritems, but accepts any collections.Mapping."""
+    return d.iteritems() if hasattr(d, "iteritems") else d.items()
+
+
+class FeatureHasher(TransformerMixin, BaseEstimator):
+    """Implements feature hashing, aka the hashing trick.
+
+    This class turns sequences of symbolic feature names (strings) into
+    scipy.sparse matrices, using a hash function to compute the matrix column
+    corresponding to a name. The hash function employed is the signed 32-bit
+    version of Murmurhash3.
+
+    Feature names of type byte string are used as-is. Unicode strings are
+    converted to UTF-8 first, but no Unicode normalization is done.
+    Feature values must be (finite) numbers.
+
+    This class is a low-memory alternative to DictVectorizer and
+    CountVectorizer, intended for large-scale (online) learning and situations
+    where memory is tight, e.g. when running prediction code on embedded
+    devices.
+
+    For an efficiency comparison of the different feature extractors, see
+    :ref:`sphx_glr_auto_examples_text_plot_hashing_vs_dict_vectorizer.py`.
+
+    Read more in the :ref:`User Guide <feature_hashing>`.
+
+    .. versionadded:: 0.13
+
+    Parameters
+    ----------
+    n_features : int, default=2**20
+        The number of features (columns) in the output matrices. Small numbers
+        of features are likely to cause hash collisions, but large numbers
+        will cause larger coefficient dimensions in linear learners.
+    input_type : str, default='dict'
+        Choose a string from {'dict', 'pair', 'string'}.
+        Either "dict" (the default) to accept dictionaries over
+        (feature_name, value); "pair" to accept pairs of (feature_name, value);
+        or "string" to accept single strings.
+        feature_name should be a string, while value should be a number.
+        In the case of "string", a value of 1 is implied.
+        The feature_name is hashed to find the appropriate column for the
+        feature. The value's sign might be flipped in the output (but see
+        non_negative, below).
+    dtype : numpy dtype, default=np.float64
+        The type of feature values. Passed to scipy.sparse matrix constructors
+        as the dtype argument. Do not set this to bool, np.boolean or any
+        unsigned integer type.
+    alternate_sign : bool, default=True
+        When True, an alternating sign is added to the features as to
+        approximately conserve the inner product in the hashed space even for
+        small n_features. This approach is similar to sparse random projection.
+
+        .. versionchanged:: 0.19
+            ``alternate_sign`` replaces the now deprecated ``non_negative``
+            parameter.
+
+    See Also
+    --------
+    DictVectorizer : Vectorizes string-valued features using a hash table.
+    sklearn.preprocessing.OneHotEncoder : Handles nominal/categorical features.
+
+    Notes
+    -----
+    This estimator is :term:`stateless` and does not need to be fitted.
+    However, we recommend to call :meth:`fit_transform` instead of
+    :meth:`transform`, as parameter validation is only performed in
+    :meth:`fit`.
+
+    Examples
+    --------
+    >>> from sklearn.feature_extraction import FeatureHasher
+    >>> h = FeatureHasher(n_features=10)
+    >>> D = [{'dog': 1, 'cat':2, 'elephant':4},{'dog': 2, 'run': 5}]
+    >>> f = h.transform(D)
+    >>> f.toarray()
+    array([[ 0.,  0., -4., -1.,  0.,  0.,  0.,  0.,  0.,  2.],
+           [ 0.,  0.,  0., -2., -5.,  0.,  0.,  0.,  0.,  0.]])
+
+    With `input_type="string"`, the input must be an iterable over iterables of
+    strings:
+
+    >>> h = FeatureHasher(n_features=8, input_type="string")
+    >>> raw_X = [["dog", "cat", "snake"], ["snake", "dog"], ["cat", "bird"]]
+    >>> f = h.transform(raw_X)
+    >>> f.toarray()
+    array([[ 0.,  0.,  0., -1.,  0., -1.,  0.,  1.],
+           [ 0.,  0.,  0., -1.,  0., -1.,  0.,  0.],
+           [ 0., -1.,  0.,  0.,  0.,  0.,  0.,  1.]])
+    """
+
+    _parameter_constraints: dict = {
+        "n_features": [Interval(Integral, 1, np.iinfo(np.int32).max, closed="both")],
+        "input_type": [StrOptions({"dict", "pair", "string"})],
+        "dtype": "no_validation",  # delegate to numpy
+        "alternate_sign": ["boolean"],
+    }
+
+    def __init__(
+        self,
+        n_features=(2**20),
+        *,
+        input_type="dict",
+        dtype=np.float64,
+        alternate_sign=True,
+    ):
+        self.dtype = dtype
+        self.input_type = input_type
+        self.n_features = n_features
+        self.alternate_sign = alternate_sign
+
+    @_fit_context(prefer_skip_nested_validation=True)
+    def fit(self, X=None, y=None):
+        """Only validates estimator's parameters.
+
+        This method allows to: (i) validate the estimator's parameters and
+        (ii) be consistent with the scikit-learn transformer API.
+
+        Parameters
+        ----------
+        X : Ignored
+            Not used, present here for API consistency by convention.
+
+        y : Ignored
+            Not used, present here for API consistency by convention.
+
+        Returns
+        -------
+        self : object
+            FeatureHasher class instance.
+        """
+        return self
+
+    def transform(self, raw_X):
+        """Transform a sequence of instances to a scipy.sparse matrix.
+
+        Parameters
+        ----------
+        raw_X : iterable over iterable over raw features, length = n_samples
+            Samples. Each sample must be iterable an (e.g., a list or tuple)
+            containing/generating feature names (and optionally values, see
+            the input_type constructor argument) which will be hashed.
+            raw_X need not support the len function, so it can be the result
+            of a generator; n_samples is determined on the fly.
+
+        Returns
+        -------
+        X : sparse matrix of shape (n_samples, n_features)
+            Feature matrix, for use with estimators or further transformers.
+        """
+        raw_X = iter(raw_X)
+        if self.input_type == "dict":
+            raw_X = (_iteritems(d) for d in raw_X)
+        elif self.input_type == "string":
+            first_raw_X = next(raw_X)
+            if isinstance(first_raw_X, str):
+                raise ValueError(
+                    "Samples can not be a single string. The input must be an iterable"
+                    " over iterables of strings."
+                )
+            raw_X_ = chain([first_raw_X], raw_X)
+            raw_X = (((f, 1) for f in x) for x in raw_X_)
+
+        indices, indptr, values = _hashing_transform(
+            raw_X, self.n_features, self.dtype, self.alternate_sign, seed=0
+        )
+        n_samples = indptr.shape[0] - 1
+
+        if n_samples == 0:
+            raise ValueError("Cannot vectorize empty sequence.")
+
+        X = sp.csr_matrix(
+            (values, indices, indptr),
+            dtype=self.dtype,
+            shape=(n_samples, self.n_features),
+        )
+        X.sum_duplicates()  # also sorts the indices
+
+        return X
+
+    def _more_tags(self):
+        return {"X_types": [self.input_type]}

venv/lib/python3.10/site-packages/sklearn/feature_extraction/_stop_words.py

@@ -0,0 +1,325 @@
+# This list of English stop words is taken from the "Glasgow Information
+# Retrieval Group". The original list can be found at
+# http://ir.dcs.gla.ac.uk/resources/linguistic_utils/stop_words
+ENGLISH_STOP_WORDS = frozenset(
+    [
+        "a",
+        "about",
+        "above",
+        "across",
+        "after",
+        "afterwards",
+        "again",
+        "against",
+        "all",
+        "almost",
+        "alone",
+        "along",
+        "already",
+        "also",
+        "although",
+        "always",
+        "am",
+        "among",
+        "amongst",
+        "amoungst",
+        "amount",
+        "an",
+        "and",
+        "another",
+        "any",
+        "anyhow",
+        "anyone",
+        "anything",
+        "anyway",
+        "anywhere",
+        "are",
+        "around",
+        "as",
+        "at",
+        "back",
+        "be",
+        "became",
+        "because",
+        "become",
+        "becomes",
+        "becoming",
+        "been",
+        "before",
+        "beforehand",
+        "behind",
+        "being",
+        "below",
+        "beside",
+        "besides",
+        "between",
+        "beyond",
+        "bill",
+        "both",
+        "bottom",
+        "but",
+        "by",
+        "call",
+        "can",
+        "cannot",
+        "cant",
+        "co",
+        "con",
+        "could",
+        "couldnt",
+        "cry",
+        "de",
+        "describe",
+        "detail",
+        "do",
+        "done",
+        "down",
+        "due",
+        "during",
+        "each",
+        "eg",
+        "eight",
+        "either",
+        "eleven",
+        "else",
+        "elsewhere",
+        "empty",
+        "enough",
+        "etc",
+        "even",
+        "ever",
+        "every",
+        "everyone",
+        "everything",
+        "everywhere",
+        "except",
+        "few",
+        "fifteen",
+        "fifty",
+        "fill",
+        "find",
+        "fire",
+        "first",
+        "five",
+        "for",
+        "former",
+        "formerly",
+        "forty",
+        "found",
+        "four",
+        "from",
+        "front",
+        "full",
+        "further",
+        "get",
+        "give",
+        "go",
+        "had",
+        "has",
+        "hasnt",
+        "have",
+        "he",
+        "hence",
+        "her",
+        "here",
+        "hereafter",
+        "hereby",
+        "herein",
+        "hereupon",
+        "hers",
+        "herself",
+        "him",
+        "himself",
+        "his",
+        "how",
+        "however",
+        "hundred",
+        "i",
+        "ie",
+        "if",
+        "in",
+        "inc",
+        "indeed",
+        "interest",
+        "into",
+        "is",
+        "it",
+        "its",
+        "itself",
+        "keep",
+        "last",
+        "latter",
+        "latterly",
+        "least",
+        "less",
+        "ltd",
+        "made",
+        "many",
+        "may",
+        "me",
+        "meanwhile",
+        "might",
+        "mill",
+        "mine",
+        "more",
+        "moreover",
+        "most",
+        "mostly",
+        "move",
+        "much",
+        "must",
+        "my",
+        "myself",
+        "name",
+        "namely",
+        "neither",
+        "never",
+        "nevertheless",
+        "next",
+        "nine",
+        "no",
+        "nobody",
+        "none",
+        "noone",
+        "nor",
+        "not",
+        "nothing",
+        "now",
+        "nowhere",
+        "of",
+        "off",
+        "often",
+        "on",
+        "once",
+        "one",
+        "only",
+        "onto",
+        "or",
+        "other",
+        "others",
+        "otherwise",
+        "our",
+        "ours",
+        "ourselves",
+        "out",
+        "over",
+        "own",
+        "part",
+        "per",
+        "perhaps",
+        "please",
+        "put",
+        "rather",
+        "re",
+        "same",
+        "see",
+        "seem",
+        "seemed",
+        "seeming",
+        "seems",
+        "serious",
+        "several",
+        "she",
+        "should",
+        "show",
+        "side",
+        "since",
+        "sincere",
+        "six",
+        "sixty",
+        "so",
+        "some",
+        "somehow",
+        "someone",
+        "something",
+        "sometime",
+        "sometimes",
+        "somewhere",
+        "still",
+        "such",
+        "system",
+        "take",
+        "ten",
+        "than",
+        "that",
+        "the",
+        "their",
+        "them",
+        "themselves",
+        "then",
+        "thence",
+        "there",
+        "thereafter",
+        "thereby",
+        "therefore",
+        "therein",
+        "thereupon",
+        "these",
+        "they",
+        "thick",
+        "thin",
+        "third",
+        "this",
+        "those",
+        "though",
+        "three",
+        "through",
+        "throughout",
+        "thru",
+        "thus",
+        "to",
+        "together",
+        "too",
+        "top",
+        "toward",
+        "towards",
+        "twelve",
+        "twenty",
+        "two",
+        "un",
+        "under",
+        "until",
+        "up",
+        "upon",
+        "us",
+        "very",
+        "via",
+        "was",
+        "we",
+        "well",
+        "were",
+        "what",
+        "whatever",
+        "when",
+        "whence",
+        "whenever",
+        "where",
+        "whereafter",
+        "whereas",
+        "whereby",
+        "wherein",
+        "whereupon",
+        "wherever",
+        "whether",
+        "which",
+        "while",
+        "whither",
+        "who",
+        "whoever",
+        "whole",
+        "whom",
+        "whose",
+        "why",
+        "will",
+        "with",
+        "within",
+        "without",
+        "would",
+        "yet",
+        "you",
+        "your",
+        "yours",
+        "yourself",
+        "yourselves",
+    ]
+)

venv/lib/python3.10/site-packages/sklearn/feature_extraction/image.py

@@ -0,0 +1,671 @@
+"""
+The :mod:`sklearn.feature_extraction.image` submodule gathers utilities to
+extract features from images.
+"""
+
+# Authors: Emmanuelle Gouillart <[email protected]>
+#          Gael Varoquaux <[email protected]>
+#          Olivier Grisel
+#          Vlad Niculae
+# License: BSD 3 clause
+
+from itertools import product
+from numbers import Integral, Number, Real
+
+import numpy as np
+from numpy.lib.stride_tricks import as_strided
+from scipy import sparse
+
+from ..base import BaseEstimator, TransformerMixin, _fit_context
+from ..utils import check_array, check_random_state
+from ..utils._param_validation import Hidden, Interval, RealNotInt, validate_params
+
+__all__ = [
+    "PatchExtractor",
+    "extract_patches_2d",
+    "grid_to_graph",
+    "img_to_graph",
+    "reconstruct_from_patches_2d",
+]
+
+###############################################################################
+# From an image to a graph
+
+
+def _make_edges_3d(n_x, n_y, n_z=1):
+    """Returns a list of edges for a 3D image.
+
+    Parameters
+    ----------
+    n_x : int
+        The size of the grid in the x direction.
+    n_y : int
+        The size of the grid in the y direction.
+    n_z : integer, default=1
+        The size of the grid in the z direction, defaults to 1
+    """
+    vertices = np.arange(n_x * n_y * n_z).reshape((n_x, n_y, n_z))
+    edges_deep = np.vstack((vertices[:, :, :-1].ravel(), vertices[:, :, 1:].ravel()))
+    edges_right = np.vstack((vertices[:, :-1].ravel(), vertices[:, 1:].ravel()))
+    edges_down = np.vstack((vertices[:-1].ravel(), vertices[1:].ravel()))
+    edges = np.hstack((edges_deep, edges_right, edges_down))
+    return edges
+
+
+def _compute_gradient_3d(edges, img):
+    _, n_y, n_z = img.shape
+    gradient = np.abs(
+        img[
+            edges[0] // (n_y * n_z),
+            (edges[0] % (n_y * n_z)) // n_z,
+            (edges[0] % (n_y * n_z)) % n_z,
+        ]
+        - img[
+            edges[1] // (n_y * n_z),
+            (edges[1] % (n_y * n_z)) // n_z,
+            (edges[1] % (n_y * n_z)) % n_z,
+        ]
+    )
+    return gradient
+
+
+# XXX: Why mask the image after computing the weights?
+
+
+def _mask_edges_weights(mask, edges, weights=None):
+    """Apply a mask to edges (weighted or not)"""
+    inds = np.arange(mask.size)
+    inds = inds[mask.ravel()]
+    ind_mask = np.logical_and(np.isin(edges[0], inds), np.isin(edges[1], inds))
+    edges = edges[:, ind_mask]
+    if weights is not None:
+        weights = weights[ind_mask]
+    if len(edges.ravel()):
+        maxval = edges.max()
+    else:
+        maxval = 0
+    order = np.searchsorted(np.flatnonzero(mask), np.arange(maxval + 1))
+    edges = order[edges]
+    if weights is None:
+        return edges
+    else:
+        return edges, weights
+
+
+def _to_graph(
+    n_x, n_y, n_z, mask=None, img=None, return_as=sparse.coo_matrix, dtype=None
+):
+    """Auxiliary function for img_to_graph and grid_to_graph"""
+    edges = _make_edges_3d(n_x, n_y, n_z)
+
+    if dtype is None:  # To not overwrite input dtype
+        if img is None:
+            dtype = int
+        else:
+            dtype = img.dtype
+
+    if img is not None:
+        img = np.atleast_3d(img)
+        weights = _compute_gradient_3d(edges, img)
+        if mask is not None:
+            edges, weights = _mask_edges_weights(mask, edges, weights)
+            diag = img.squeeze()[mask]
+        else:
+            diag = img.ravel()
+        n_voxels = diag.size
+    else:
+        if mask is not None:
+            mask = mask.astype(dtype=bool, copy=False)
+            edges = _mask_edges_weights(mask, edges)
+            n_voxels = np.sum(mask)
+        else:
+            n_voxels = n_x * n_y * n_z
+        weights = np.ones(edges.shape[1], dtype=dtype)
+        diag = np.ones(n_voxels, dtype=dtype)
+
+    diag_idx = np.arange(n_voxels)
+    i_idx = np.hstack((edges[0], edges[1]))
+    j_idx = np.hstack((edges[1], edges[0]))
+    graph = sparse.coo_matrix(
+        (
+            np.hstack((weights, weights, diag)),
+            (np.hstack((i_idx, diag_idx)), np.hstack((j_idx, diag_idx))),
+        ),
+        (n_voxels, n_voxels),
+        dtype=dtype,
+    )
+    if return_as is np.ndarray:
+        return graph.toarray()
+    return return_as(graph)
+
+
+@validate_params(
+    {
+        "img": ["array-like"],
+        "mask": [None, np.ndarray],
+        "return_as": [type],
+        "dtype": "no_validation",  # validation delegated to numpy
+    },
+    prefer_skip_nested_validation=True,
+)
+def img_to_graph(img, *, mask=None, return_as=sparse.coo_matrix, dtype=None):
+    """Graph of the pixel-to-pixel gradient connections.
+
+    Edges are weighted with the gradient values.
+
+    Read more in the :ref:`User Guide <image_feature_extraction>`.
+
+    Parameters
+    ----------
+    img : array-like of shape (height, width) or (height, width, channel)
+        2D or 3D image.
+    mask : ndarray of shape (height, width) or \
+            (height, width, channel), dtype=bool, default=None
+        An optional mask of the image, to consider only part of the
+        pixels.
+    return_as : np.ndarray or a sparse matrix class, \
+            default=sparse.coo_matrix
+        The class to use to build the returned adjacency matrix.
+    dtype : dtype, default=None
+        The data of the returned sparse matrix. By default it is the
+        dtype of img.
+
+    Returns
+    -------
+    graph : ndarray or a sparse matrix class
+        The computed adjacency matrix.
+
+    Notes
+    -----
+    For scikit-learn versions 0.14.1 and prior, return_as=np.ndarray was
+    handled by returning a dense np.matrix instance.  Going forward, np.ndarray
+    returns an np.ndarray, as expected.
+
+    For compatibility, user code relying on this method should wrap its
+    calls in ``np.asarray`` to avoid type issues.
+    """
+    img = np.atleast_3d(img)
+    n_x, n_y, n_z = img.shape
+    return _to_graph(n_x, n_y, n_z, mask, img, return_as, dtype)
+
+
+@validate_params(
+    {
+        "n_x": [Interval(Integral, left=1, right=None, closed="left")],
+        "n_y": [Interval(Integral, left=1, right=None, closed="left")],
+        "n_z": [Interval(Integral, left=1, right=None, closed="left")],
+        "mask": [None, np.ndarray],
+        "return_as": [type],
+        "dtype": "no_validation",  # validation delegated to numpy
+    },
+    prefer_skip_nested_validation=True,
+)
+def grid_to_graph(
+    n_x, n_y, n_z=1, *, mask=None, return_as=sparse.coo_matrix, dtype=int
+):
+    """Graph of the pixel-to-pixel connections.
+
+    Edges exist if 2 voxels are connected.
+
+    Parameters
+    ----------
+    n_x : int
+        Dimension in x axis.
+    n_y : int
+        Dimension in y axis.
+    n_z : int, default=1
+        Dimension in z axis.
+    mask : ndarray of shape (n_x, n_y, n_z), dtype=bool, default=None
+        An optional mask of the image, to consider only part of the
+        pixels.
+    return_as : np.ndarray or a sparse matrix class, \
+            default=sparse.coo_matrix
+        The class to use to build the returned adjacency matrix.
+    dtype : dtype, default=int
+        The data of the returned sparse matrix. By default it is int.
+
+    Returns
+    -------
+    graph : np.ndarray or a sparse matrix class
+        The computed adjacency matrix.
+
+    Notes
+    -----
+    For scikit-learn versions 0.14.1 and prior, return_as=np.ndarray was
+    handled by returning a dense np.matrix instance.  Going forward, np.ndarray
+    returns an np.ndarray, as expected.
+
+    For compatibility, user code relying on this method should wrap its
+    calls in ``np.asarray`` to avoid type issues.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from sklearn.feature_extraction.image import grid_to_graph
+    >>> shape_img = (4, 4, 1)
+    >>> mask = np.zeros(shape=shape_img, dtype=bool)
+    >>> mask[[1, 2], [1, 2], :] = True
+    >>> graph = grid_to_graph(*shape_img, mask=mask)
+    >>> print(graph)
+      (0, 0)    1
+      (1, 1)    1
+    """
+    return _to_graph(n_x, n_y, n_z, mask=mask, return_as=return_as, dtype=dtype)
+
+
+###############################################################################
+# From an image to a set of small image patches
+
+
+def _compute_n_patches(i_h, i_w, p_h, p_w, max_patches=None):
+    """Compute the number of patches that will be extracted in an image.
+
+    Read more in the :ref:`User Guide <image_feature_extraction>`.
+
+    Parameters
+    ----------
+    i_h : int
+        The image height
+    i_w : int
+        The image with
+    p_h : int
+        The height of a patch
+    p_w : int
+        The width of a patch
+    max_patches : int or float, default=None
+        The maximum number of patches to extract. If `max_patches` is a float
+        between 0 and 1, it is taken to be a proportion of the total number
+        of patches. If `max_patches` is None, all possible patches are extracted.
+    """
+    n_h = i_h - p_h + 1
+    n_w = i_w - p_w + 1
+    all_patches = n_h * n_w
+
+    if max_patches:
+        if isinstance(max_patches, (Integral)) and max_patches < all_patches:
+            return max_patches
+        elif isinstance(max_patches, (Integral)) and max_patches >= all_patches:
+            return all_patches
+        elif isinstance(max_patches, (Real)) and 0 < max_patches < 1:
+            return int(max_patches * all_patches)
+        else:
+            raise ValueError("Invalid value for max_patches: %r" % max_patches)
+    else:
+        return all_patches
+
+
+def _extract_patches(arr, patch_shape=8, extraction_step=1):
+    """Extracts patches of any n-dimensional array in place using strides.
+
+    Given an n-dimensional array it will return a 2n-dimensional array with
+    the first n dimensions indexing patch position and the last n indexing
+    the patch content. This operation is immediate (O(1)). A reshape
+    performed on the first n dimensions will cause numpy to copy data, leading
+    to a list of extracted patches.
+
+    Read more in the :ref:`User Guide <image_feature_extraction>`.
+
+    Parameters
+    ----------
+    arr : ndarray
+        n-dimensional array of which patches are to be extracted
+
+    patch_shape : int or tuple of length arr.ndim.default=8
+        Indicates the shape of the patches to be extracted. If an
+        integer is given, the shape will be a hypercube of
+        sidelength given by its value.
+
+    extraction_step : int or tuple of length arr.ndim, default=1
+        Indicates step size at which extraction shall be performed.
+        If integer is given, then the step is uniform in all dimensions.
+
+
+    Returns
+    -------
+    patches : strided ndarray
+        2n-dimensional array indexing patches on first n dimensions and
+        containing patches on the last n dimensions. These dimensions
+        are fake, but this way no data is copied. A simple reshape invokes
+        a copying operation to obtain a list of patches:
+        result.reshape([-1] + list(patch_shape))
+    """
+
+    arr_ndim = arr.ndim
+
+    if isinstance(patch_shape, Number):
+        patch_shape = tuple([patch_shape] * arr_ndim)
+    if isinstance(extraction_step, Number):
+        extraction_step = tuple([extraction_step] * arr_ndim)
+
+    patch_strides = arr.strides
+
+    slices = tuple(slice(None, None, st) for st in extraction_step)
+    indexing_strides = arr[slices].strides
+
+    patch_indices_shape = (
+        (np.array(arr.shape) - np.array(patch_shape)) // np.array(extraction_step)
+    ) + 1
+
+    shape = tuple(list(patch_indices_shape) + list(patch_shape))
+    strides = tuple(list(indexing_strides) + list(patch_strides))
+
+    patches = as_strided(arr, shape=shape, strides=strides)
+    return patches
+
+
+@validate_params(
+    {
+        "image": [np.ndarray],
+        "patch_size": [tuple, list],
+        "max_patches": [
+            Interval(RealNotInt, 0, 1, closed="neither"),
+            Interval(Integral, 1, None, closed="left"),
+            None,
+        ],
+        "random_state": ["random_state"],
+    },
+    prefer_skip_nested_validation=True,
+)
+def extract_patches_2d(image, patch_size, *, max_patches=None, random_state=None):
+    """Reshape a 2D image into a collection of patches.
+
+    The resulting patches are allocated in a dedicated array.
+
+    Read more in the :ref:`User Guide <image_feature_extraction>`.
+
+    Parameters
+    ----------
+    image : ndarray of shape (image_height, image_width) or \
+        (image_height, image_width, n_channels)
+        The original image data. For color images, the last dimension specifies
+        the channel: a RGB image would have `n_channels=3`.
+
+    patch_size : tuple of int (patch_height, patch_width)
+        The dimensions of one patch.
+
+    max_patches : int or float, default=None
+        The maximum number of patches to extract. If `max_patches` is a float
+        between 0 and 1, it is taken to be a proportion of the total number
+        of patches. If `max_patches` is None it corresponds to the total number
+        of patches that can be extracted.
+
+    random_state : int, RandomState instance, default=None
+        Determines the random number generator used for random sampling when
+        `max_patches` is not None. Use an int to make the randomness
+        deterministic.
+        See :term:`Glossary <random_state>`.
+
+    Returns
+    -------
+    patches : array of shape (n_patches, patch_height, patch_width) or \
+        (n_patches, patch_height, patch_width, n_channels)
+        The collection of patches extracted from the image, where `n_patches`
+        is either `max_patches` or the total number of patches that can be
+        extracted.
+
+    Examples
+    --------
+    >>> from sklearn.datasets import load_sample_image
+    >>> from sklearn.feature_extraction import image
+    >>> # Use the array data from the first image in this dataset:
+    >>> one_image = load_sample_image("china.jpg")
+    >>> print('Image shape: {}'.format(one_image.shape))
+    Image shape: (427, 640, 3)
+    >>> patches = image.extract_patches_2d(one_image, (2, 2))
+    >>> print('Patches shape: {}'.format(patches.shape))
+    Patches shape: (272214, 2, 2, 3)
+    >>> # Here are just two of these patches:
+    >>> print(patches[1])
+    [[[174 201 231]
+      [174 201 231]]
+     [[173 200 230]
+      [173 200 230]]]
+    >>> print(patches[800])
+    [[[187 214 243]
+      [188 215 244]]
+     [[187 214 243]
+      [188 215 244]]]
+    """
+    i_h, i_w = image.shape[:2]
+    p_h, p_w = patch_size
+
+    if p_h > i_h:
+        raise ValueError(
+            "Height of the patch should be less than the height of the image."
+        )
+
+    if p_w > i_w:
+        raise ValueError(
+            "Width of the patch should be less than the width of the image."
+        )
+
+    image = check_array(image, allow_nd=True)
+    image = image.reshape((i_h, i_w, -1))
+    n_colors = image.shape[-1]
+
+    extracted_patches = _extract_patches(
+        image, patch_shape=(p_h, p_w, n_colors), extraction_step=1
+    )
+
+    n_patches = _compute_n_patches(i_h, i_w, p_h, p_w, max_patches)
+    if max_patches:
+        rng = check_random_state(random_state)
+        i_s = rng.randint(i_h - p_h + 1, size=n_patches)
+        j_s = rng.randint(i_w - p_w + 1, size=n_patches)
+        patches = extracted_patches[i_s, j_s, 0]
+    else:
+        patches = extracted_patches
+
+    patches = patches.reshape(-1, p_h, p_w, n_colors)
+    # remove the color dimension if useless
+    if patches.shape[-1] == 1:
+        return patches.reshape((n_patches, p_h, p_w))
+    else:
+        return patches
+
+
+@validate_params(
+    {"patches": [np.ndarray], "image_size": [tuple, Hidden(list)]},
+    prefer_skip_nested_validation=True,
+)
+def reconstruct_from_patches_2d(patches, image_size):
+    """Reconstruct the image from all of its patches.
+
+    Patches are assumed to overlap and the image is constructed by filling in
+    the patches from left to right, top to bottom, averaging the overlapping
+    regions.
+
+    Read more in the :ref:`User Guide <image_feature_extraction>`.
+
+    Parameters
+    ----------
+    patches : ndarray of shape (n_patches, patch_height, patch_width) or \
+        (n_patches, patch_height, patch_width, n_channels)
+        The complete set of patches. If the patches contain colour information,
+        channels are indexed along the last dimension: RGB patches would
+        have `n_channels=3`.
+
+    image_size : tuple of int (image_height, image_width) or \
+        (image_height, image_width, n_channels)
+        The size of the image that will be reconstructed.
+
+    Returns
+    -------
+    image : ndarray of shape image_size
+        The reconstructed image.
+    """
+    i_h, i_w = image_size[:2]
+    p_h, p_w = patches.shape[1:3]
+    img = np.zeros(image_size)
+    # compute the dimensions of the patches array
+    n_h = i_h - p_h + 1
+    n_w = i_w - p_w + 1
+    for p, (i, j) in zip(patches, product(range(n_h), range(n_w))):
+        img[i : i + p_h, j : j + p_w] += p
+
+    for i in range(i_h):
+        for j in range(i_w):
+            # divide by the amount of overlap
+            # XXX: is this the most efficient way? memory-wise yes, cpu wise?
+            img[i, j] /= float(min(i + 1, p_h, i_h - i) * min(j + 1, p_w, i_w - j))
+    return img
+
+
+class PatchExtractor(TransformerMixin, BaseEstimator):
+    """Extracts patches from a collection of images.
+
+    Read more in the :ref:`User Guide <image_feature_extraction>`.
+
+    .. versionadded:: 0.9
+
+    Parameters
+    ----------
+    patch_size : tuple of int (patch_height, patch_width), default=None
+        The dimensions of one patch. If set to None, the patch size will be
+        automatically set to `(img_height // 10, img_width // 10)`, where
+        `img_height` and `img_width` are the dimensions of the input images.
+
+    max_patches : int or float, default=None
+        The maximum number of patches per image to extract. If `max_patches` is
+        a float in (0, 1), it is taken to mean a proportion of the total number
+        of patches. If set to None, extract all possible patches.
+
+    random_state : int, RandomState instance, default=None
+        Determines the random number generator used for random sampling when
+        `max_patches is not None`. Use an int to make the randomness
+        deterministic.
+        See :term:`Glossary <random_state>`.
+
+    See Also
+    --------
+    reconstruct_from_patches_2d : Reconstruct image from all of its patches.
+
+    Notes
+    -----
+    This estimator is stateless and does not need to be fitted. However, we
+    recommend to call :meth:`fit_transform` instead of :meth:`transform`, as
+    parameter validation is only performed in :meth:`fit`.
+
+    Examples
+    --------
+    >>> from sklearn.datasets import load_sample_images
+    >>> from sklearn.feature_extraction import image
+    >>> # Use the array data from the second image in this dataset:
+    >>> X = load_sample_images().images[1]
+    >>> X = X[None, ...]
+    >>> print(f"Image shape: {X.shape}")
+    Image shape: (1, 427, 640, 3)
+    >>> pe = image.PatchExtractor(patch_size=(10, 10))
+    >>> pe_trans = pe.transform(X)
+    >>> print(f"Patches shape: {pe_trans.shape}")
+    Patches shape: (263758, 10, 10, 3)
+    >>> X_reconstructed = image.reconstruct_from_patches_2d(pe_trans, X.shape[1:])
+    >>> print(f"Reconstructed shape: {X_reconstructed.shape}")
+    Reconstructed shape: (427, 640, 3)
+    """
+
+    _parameter_constraints: dict = {
+        "patch_size": [tuple, None],
+        "max_patches": [
+            None,
+            Interval(RealNotInt, 0, 1, closed="neither"),
+            Interval(Integral, 1, None, closed="left"),
+        ],
+        "random_state": ["random_state"],
+    }
+
+    def __init__(self, *, patch_size=None, max_patches=None, random_state=None):
+        self.patch_size = patch_size
+        self.max_patches = max_patches
+        self.random_state = random_state
+
+    @_fit_context(prefer_skip_nested_validation=True)
+    def fit(self, X, y=None):
+        """Only validate the parameters of the estimator.
+
+        This method allows to: (i) validate the parameters of the estimator  and
+        (ii) be consistent with the scikit-learn transformer API.
+
+        Parameters
+        ----------
+        X : ndarray of shape (n_samples, image_height, image_width) or \
+                (n_samples, image_height, image_width, n_channels)
+            Array of images from which to extract patches. For color images,
+            the last dimension specifies the channel: a RGB image would have
+            `n_channels=3`.
+
+        y : Ignored
+            Not used, present for API consistency by convention.
+
+        Returns
+        -------
+        self : object
+            Returns the instance itself.
+        """
+        return self
+
+    def transform(self, X):
+        """Transform the image samples in `X` into a matrix of patch data.
+
+        Parameters
+        ----------
+        X : ndarray of shape (n_samples, image_height, image_width) or \
+                (n_samples, image_height, image_width, n_channels)
+            Array of images from which to extract patches. For color images,
+            the last dimension specifies the channel: a RGB image would have
+            `n_channels=3`.
+
+        Returns
+        -------
+        patches : array of shape (n_patches, patch_height, patch_width) or \
+                (n_patches, patch_height, patch_width, n_channels)
+            The collection of patches extracted from the images, where
+            `n_patches` is either `n_samples * max_patches` or the total
+            number of patches that can be extracted.
+        """
+        X = self._validate_data(
+            X=X,
+            ensure_2d=False,
+            allow_nd=True,
+            ensure_min_samples=1,
+            ensure_min_features=1,
+            reset=False,
+        )
+        random_state = check_random_state(self.random_state)
+        n_imgs, img_height, img_width = X.shape[:3]
+        if self.patch_size is None:
+            patch_size = img_height // 10, img_width // 10
+        else:
+            if len(self.patch_size) != 2:
+                raise ValueError(
+                    "patch_size must be a tuple of two integers. Got"
+                    f" {self.patch_size} instead."
+                )
+            patch_size = self.patch_size
+
+        n_imgs, img_height, img_width = X.shape[:3]
+        X = np.reshape(X, (n_imgs, img_height, img_width, -1))
+        n_channels = X.shape[-1]
+
+        # compute the dimensions of the patches array
+        patch_height, patch_width = patch_size
+        n_patches = _compute_n_patches(
+            img_height, img_width, patch_height, patch_width, self.max_patches
+        )
+        patches_shape = (n_imgs * n_patches,) + patch_size
+        if n_channels > 1:
+            patches_shape += (n_channels,)
+
+        # extract the patches
+        patches = np.empty(patches_shape)
+        for ii, image in enumerate(X):
+            patches[ii * n_patches : (ii + 1) * n_patches] = extract_patches_2d(
+                image,
+                patch_size,
+                max_patches=self.max_patches,
+                random_state=random_state,
+            )
+        return patches
+
+    def _more_tags(self):
+        return {"X_types": ["3darray"], "stateless": True}

venv/lib/python3.10/site-packages/sklearn/feature_extraction/tests/test_dict_vectorizer.py

@@ -0,0 +1,262 @@
+# Authors: Lars Buitinck
+#          Dan Blanchard <[email protected]>
+# License: BSD 3 clause
+
+from random import Random
+
+import numpy as np
+import pytest
+import scipy.sparse as sp
+from numpy.testing import assert_allclose, assert_array_equal
+
+from sklearn.exceptions import NotFittedError
+from sklearn.feature_extraction import DictVectorizer
+from sklearn.feature_selection import SelectKBest, chi2
+
+
+@pytest.mark.parametrize("sparse", (True, False))
+@pytest.mark.parametrize("dtype", (int, np.float32, np.int16))
+@pytest.mark.parametrize("sort", (True, False))
+@pytest.mark.parametrize("iterable", (True, False))
+def test_dictvectorizer(sparse, dtype, sort, iterable):
+    D = [{"foo": 1, "bar": 3}, {"bar": 4, "baz": 2}, {"bar": 1, "quux": 1, "quuux": 2}]
+
+    v = DictVectorizer(sparse=sparse, dtype=dtype, sort=sort)
+    X = v.fit_transform(iter(D) if iterable else D)
+
+    assert sp.issparse(X) == sparse
+    assert X.shape == (3, 5)
+    assert X.sum() == 14
+    assert v.inverse_transform(X) == D
+
+    if sparse:
+        # CSR matrices can't be compared for equality
+        assert_array_equal(
+            X.toarray(), v.transform(iter(D) if iterable else D).toarray()
+        )
+    else:
+        assert_array_equal(X, v.transform(iter(D) if iterable else D))
+
+    if sort:
+        assert v.feature_names_ == sorted(v.feature_names_)
+
+
+def test_feature_selection():
+    # make two feature dicts with two useful features and a bunch of useless
+    # ones, in terms of chi2
+    d1 = dict([("useless%d" % i, 10) for i in range(20)], useful1=1, useful2=20)
+    d2 = dict([("useless%d" % i, 10) for i in range(20)], useful1=20, useful2=1)
+
+    for indices in (True, False):
+        v = DictVectorizer().fit([d1, d2])
+        X = v.transform([d1, d2])
+        sel = SelectKBest(chi2, k=2).fit(X, [0, 1])
+
+        v.restrict(sel.get_support(indices=indices), indices=indices)
+        assert_array_equal(v.get_feature_names_out(), ["useful1", "useful2"])
+
+
+def test_one_of_k():
+    D_in = [
+        {"version": "1", "ham": 2},
+        {"version": "2", "spam": 0.3},
+        {"version=3": True, "spam": -1},
+    ]
+    v = DictVectorizer()
+    X = v.fit_transform(D_in)
+    assert X.shape == (3, 5)
+
+    D_out = v.inverse_transform(X)
+    assert D_out[0] == {"version=1": 1, "ham": 2}
+
+    names = v.get_feature_names_out()
+    assert "version=2" in names
+    assert "version" not in names
+
+
+def test_iterable_value():
+    D_names = ["ham", "spam", "version=1", "version=2", "version=3"]
+    X_expected = [
+        [2.0, 0.0, 2.0, 1.0, 0.0],
+        [0.0, 0.3, 0.0, 1.0, 0.0],
+        [0.0, -1.0, 0.0, 0.0, 1.0],
+    ]
+    D_in = [
+        {"version": ["1", "2", "1"], "ham": 2},
+        {"version": "2", "spam": 0.3},
+        {"version=3": True, "spam": -1},
+    ]
+    v = DictVectorizer()
+    X = v.fit_transform(D_in)
+    X = X.toarray()
+    assert_array_equal(X, X_expected)
+
+    D_out = v.inverse_transform(X)
+    assert D_out[0] == {"version=1": 2, "version=2": 1, "ham": 2}
+
+    names = v.get_feature_names_out()
+
+    assert_array_equal(names, D_names)
+
+
+def test_iterable_not_string_error():
+    error_value = (
+        "Unsupported type <class 'int'> in iterable value. "
+        "Only iterables of string are supported."
+    )
+    D2 = [{"foo": "1", "bar": "2"}, {"foo": "3", "baz": "1"}, {"foo": [1, "three"]}]
+    v = DictVectorizer(sparse=False)
+    with pytest.raises(TypeError) as error:
+        v.fit(D2)
+    assert str(error.value) == error_value
+
+
+def test_mapping_error():
+    error_value = (
+        "Unsupported value type <class 'dict'> "
+        "for foo: {'one': 1, 'three': 3}.\n"
+        "Mapping objects are not supported."
+    )
+    D2 = [
+        {"foo": "1", "bar": "2"},
+        {"foo": "3", "baz": "1"},
+        {"foo": {"one": 1, "three": 3}},
+    ]
+    v = DictVectorizer(sparse=False)
+    with pytest.raises(TypeError) as error:
+        v.fit(D2)
+    assert str(error.value) == error_value
+
+
+def test_unseen_or_no_features():
+    D = [{"camelot": 0, "spamalot": 1}]
+    for sparse in [True, False]:
+        v = DictVectorizer(sparse=sparse).fit(D)
+
+        X = v.transform({"push the pram a lot": 2})
+        if sparse:
+            X = X.toarray()
+        assert_array_equal(X, np.zeros((1, 2)))
+
+        X = v.transform({})
+        if sparse:
+            X = X.toarray()
+        assert_array_equal(X, np.zeros((1, 2)))
+
+        with pytest.raises(ValueError, match="empty"):
+            v.transform([])
+
+
+def test_deterministic_vocabulary(global_random_seed):
+    # Generate equal dictionaries with different memory layouts
+    items = [("%03d" % i, i) for i in range(1000)]
+    rng = Random(global_random_seed)
+    d_sorted = dict(items)
+    rng.shuffle(items)
+    d_shuffled = dict(items)
+
+    # check that the memory layout does not impact the resulting vocabulary
+    v_1 = DictVectorizer().fit([d_sorted])
+    v_2 = DictVectorizer().fit([d_shuffled])
+
+    assert v_1.vocabulary_ == v_2.vocabulary_
+
+
+def test_n_features_in():
+    # For vectorizers, n_features_in_ does not make sense and does not exist.
+    dv = DictVectorizer()
+    assert not hasattr(dv, "n_features_in_")
+    d = [{"foo": 1, "bar": 2}, {"foo": 3, "baz": 1}]
+    dv.fit(d)
+    assert not hasattr(dv, "n_features_in_")
+
+
+def test_dictvectorizer_dense_sparse_equivalence():
+    """Check the equivalence between between sparse and dense DictVectorizer.
+    Non-regression test for:
+    https://github.com/scikit-learn/scikit-learn/issues/19978
+    """
+    movie_entry_fit = [
+        {"category": ["thriller", "drama"], "year": 2003},
+        {"category": ["animation", "family"], "year": 2011},
+        {"year": 1974},
+    ]
+    movie_entry_transform = [{"category": ["thriller"], "unseen_feature": "3"}]
+    dense_vectorizer = DictVectorizer(sparse=False)
+    sparse_vectorizer = DictVectorizer(sparse=True)
+
+    dense_vector_fit = dense_vectorizer.fit_transform(movie_entry_fit)
+    sparse_vector_fit = sparse_vectorizer.fit_transform(movie_entry_fit)
+
+    assert not sp.issparse(dense_vector_fit)
+    assert sp.issparse(sparse_vector_fit)
+
+    assert_allclose(dense_vector_fit, sparse_vector_fit.toarray())
+
+    dense_vector_transform = dense_vectorizer.transform(movie_entry_transform)
+    sparse_vector_transform = sparse_vectorizer.transform(movie_entry_transform)
+
+    assert not sp.issparse(dense_vector_transform)
+    assert sp.issparse(sparse_vector_transform)
+
+    assert_allclose(dense_vector_transform, sparse_vector_transform.toarray())
+
+    dense_inverse_transform = dense_vectorizer.inverse_transform(dense_vector_transform)
+    sparse_inverse_transform = sparse_vectorizer.inverse_transform(
+        sparse_vector_transform
+    )
+
+    expected_inverse = [{"category=thriller": 1.0}]
+    assert dense_inverse_transform == expected_inverse
+    assert sparse_inverse_transform == expected_inverse
+
+
+def test_dict_vectorizer_unsupported_value_type():
+    """Check that we raise an error when the value associated to a feature
+    is not supported.
+
+    Non-regression test for:
+    https://github.com/scikit-learn/scikit-learn/issues/19489
+    """
+
+    class A:
+        pass
+
+    vectorizer = DictVectorizer(sparse=True)
+    X = [{"foo": A()}]
+    err_msg = "Unsupported value Type"
+    with pytest.raises(TypeError, match=err_msg):
+        vectorizer.fit_transform(X)
+
+
+def test_dict_vectorizer_get_feature_names_out():
+    """Check that integer feature names are converted to strings in
+    feature_names_out."""
+
+    X = [{1: 2, 3: 4}, {2: 4}]
+    dv = DictVectorizer(sparse=False).fit(X)
+
+    feature_names = dv.get_feature_names_out()
+    assert isinstance(feature_names, np.ndarray)
+    assert feature_names.dtype == object
+    assert_array_equal(feature_names, ["1", "2", "3"])
+
+
+@pytest.mark.parametrize(
+    "method, input",
+    [
+        ("transform", [{1: 2, 3: 4}, {2: 4}]),
+        ("inverse_transform", [{1: 2, 3: 4}, {2: 4}]),
+        ("restrict", [True, False, True]),
+    ],
+)
+def test_dict_vectorizer_not_fitted_error(method, input):
+    """Check that unfitted DictVectorizer instance raises NotFittedError.
+
+    This should be part of the common test but currently they test estimator accepting
+    text input.
+    """
+    dv = DictVectorizer(sparse=False)
+
+    with pytest.raises(NotFittedError):
+        getattr(dv, method)(input)

venv/lib/python3.10/site-packages/sklearn/feature_extraction/tests/test_feature_hasher.py

@@ -0,0 +1,160 @@
+import numpy as np
+import pytest
+from numpy.testing import assert_array_equal
+
+from sklearn.feature_extraction import FeatureHasher
+from sklearn.feature_extraction._hashing_fast import transform as _hashing_transform
+
+
+def test_feature_hasher_dicts():
+    feature_hasher = FeatureHasher(n_features=16)
+    assert "dict" == feature_hasher.input_type
+
+    raw_X = [{"foo": "bar", "dada": 42, "tzara": 37}, {"foo": "baz", "gaga": "string1"}]
+    X1 = FeatureHasher(n_features=16).transform(raw_X)
+    gen = (iter(d.items()) for d in raw_X)
+    X2 = FeatureHasher(n_features=16, input_type="pair").transform(gen)
+    assert_array_equal(X1.toarray(), X2.toarray())
+
+
+def test_feature_hasher_strings():
+    # mix byte and Unicode strings; note that "foo" is a duplicate in row 0
+    raw_X = [
+        ["foo", "bar", "baz", "foo".encode("ascii")],
+        ["bar".encode("ascii"), "baz", "quux"],
+    ]
+
+    for lg_n_features in (7, 9, 11, 16, 22):
+        n_features = 2**lg_n_features
+
+        it = (x for x in raw_X)  # iterable
+
+        feature_hasher = FeatureHasher(
+            n_features=n_features, input_type="string", alternate_sign=False
+        )
+        X = feature_hasher.transform(it)
+
+        assert X.shape[0] == len(raw_X)
+        assert X.shape[1] == n_features
+
+        assert X[0].sum() == 4
+        assert X[1].sum() == 3
+
+        assert X.nnz == 6
+
+
+@pytest.mark.parametrize(
+    "raw_X",
+    [
+        ["my_string", "another_string"],
+        (x for x in ["my_string", "another_string"]),
+    ],
+    ids=["list", "generator"],
+)
+def test_feature_hasher_single_string(raw_X):
+    """FeatureHasher raises error when a sample is a single string.
+
+    Non-regression test for gh-13199.
+    """
+    msg = "Samples can not be a single string"
+
+    feature_hasher = FeatureHasher(n_features=10, input_type="string")
+    with pytest.raises(ValueError, match=msg):
+        feature_hasher.transform(raw_X)
+
+
+def test_hashing_transform_seed():
+    # check the influence of the seed when computing the hashes
+    raw_X = [
+        ["foo", "bar", "baz", "foo".encode("ascii")],
+        ["bar".encode("ascii"), "baz", "quux"],
+    ]
+
+    raw_X_ = (((f, 1) for f in x) for x in raw_X)
+    indices, indptr, _ = _hashing_transform(raw_X_, 2**7, str, False)
+
+    raw_X_ = (((f, 1) for f in x) for x in raw_X)
+    indices_0, indptr_0, _ = _hashing_transform(raw_X_, 2**7, str, False, seed=0)
+    assert_array_equal(indices, indices_0)
+    assert_array_equal(indptr, indptr_0)
+
+    raw_X_ = (((f, 1) for f in x) for x in raw_X)
+    indices_1, _, _ = _hashing_transform(raw_X_, 2**7, str, False, seed=1)
+    with pytest.raises(AssertionError):
+        assert_array_equal(indices, indices_1)
+
+
+def test_feature_hasher_pairs():
+    raw_X = (
+        iter(d.items())
+        for d in [{"foo": 1, "bar": 2}, {"baz": 3, "quux": 4, "foo": -1}]
+    )
+    feature_hasher = FeatureHasher(n_features=16, input_type="pair")
+    x1, x2 = feature_hasher.transform(raw_X).toarray()
+    x1_nz = sorted(np.abs(x1[x1 != 0]))
+    x2_nz = sorted(np.abs(x2[x2 != 0]))
+    assert [1, 2] == x1_nz
+    assert [1, 3, 4] == x2_nz
+
+
+def test_feature_hasher_pairs_with_string_values():
+    raw_X = (
+        iter(d.items())
+        for d in [{"foo": 1, "bar": "a"}, {"baz": "abc", "quux": 4, "foo": -1}]
+    )
+    feature_hasher = FeatureHasher(n_features=16, input_type="pair")
+    x1, x2 = feature_hasher.transform(raw_X).toarray()
+    x1_nz = sorted(np.abs(x1[x1 != 0]))
+    x2_nz = sorted(np.abs(x2[x2 != 0]))
+    assert [1, 1] == x1_nz
+    assert [1, 1, 4] == x2_nz
+
+    raw_X = (iter(d.items()) for d in [{"bax": "abc"}, {"bax": "abc"}])
+    x1, x2 = feature_hasher.transform(raw_X).toarray()
+    x1_nz = np.abs(x1[x1 != 0])
+    x2_nz = np.abs(x2[x2 != 0])
+    assert [1] == x1_nz
+    assert [1] == x2_nz
+    assert_array_equal(x1, x2)
+
+
+def test_hash_empty_input():
+    n_features = 16
+    raw_X = [[], (), iter(range(0))]
+
+    feature_hasher = FeatureHasher(n_features=n_features, input_type="string")
+    X = feature_hasher.transform(raw_X)
+
+    assert_array_equal(X.toarray(), np.zeros((len(raw_X), n_features)))
+
+
+def test_hasher_zeros():
+    # Assert that no zeros are materialized in the output.
+    X = FeatureHasher().transform([{"foo": 0}])
+    assert X.data.shape == (0,)
+
+
+def test_hasher_alternate_sign():
+    X = [list("Thequickbrownfoxjumped")]
+
+    Xt = FeatureHasher(alternate_sign=True, input_type="string").fit_transform(X)
+    assert Xt.data.min() < 0 and Xt.data.max() > 0
+
+    Xt = FeatureHasher(alternate_sign=False, input_type="string").fit_transform(X)
+    assert Xt.data.min() > 0
+
+
+def test_hash_collisions():
+    X = [list("Thequickbrownfoxjumped")]
+
+    Xt = FeatureHasher(
+        alternate_sign=True, n_features=1, input_type="string"
+    ).fit_transform(X)
+    # check that some of the hashed tokens are added
+    # with an opposite sign and cancel out
+    assert abs(Xt.data[0]) < len(X[0])
+
+    Xt = FeatureHasher(
+        alternate_sign=False, n_features=1, input_type="string"
+    ).fit_transform(X)
+    assert Xt.data[0] == len(X[0])

venv/lib/python3.10/site-packages/sklearn/feature_extraction/tests/test_image.py

@@ -0,0 +1,356 @@
+# Authors: Emmanuelle Gouillart <[email protected]>
+#          Gael Varoquaux <[email protected]>
+# License: BSD 3 clause
+
+import numpy as np
+import pytest
+from scipy import ndimage
+from scipy.sparse.csgraph import connected_components
+
+from sklearn.feature_extraction.image import (
+    PatchExtractor,
+    _extract_patches,
+    extract_patches_2d,
+    grid_to_graph,
+    img_to_graph,
+    reconstruct_from_patches_2d,
+)
+
+
+def test_img_to_graph():
+    x, y = np.mgrid[:4, :4] - 10
+    grad_x = img_to_graph(x)
+    grad_y = img_to_graph(y)
+    assert grad_x.nnz == grad_y.nnz
+    # Negative elements are the diagonal: the elements of the original
+    # image. Positive elements are the values of the gradient, they
+    # should all be equal on grad_x and grad_y
+    np.testing.assert_array_equal(
+        grad_x.data[grad_x.data > 0], grad_y.data[grad_y.data > 0]
+    )
+
+
+def test_img_to_graph_sparse():
+    # Check that the edges are in the right position
+    #  when using a sparse image with a singleton component
+    mask = np.zeros((2, 3), dtype=bool)
+    mask[0, 0] = 1
+    mask[:, 2] = 1
+    x = np.zeros((2, 3))
+    x[0, 0] = 1
+    x[0, 2] = -1
+    x[1, 2] = -2
+    grad_x = img_to_graph(x, mask=mask).todense()
+    desired = np.array([[1, 0, 0], [0, -1, 1], [0, 1, -2]])
+    np.testing.assert_array_equal(grad_x, desired)
+
+
+def test_grid_to_graph():
+    # Checking that the function works with graphs containing no edges
+    size = 2
+    roi_size = 1
+    # Generating two convex parts with one vertex
+    # Thus, edges will be empty in _to_graph
+    mask = np.zeros((size, size), dtype=bool)
+    mask[0:roi_size, 0:roi_size] = True
+    mask[-roi_size:, -roi_size:] = True
+    mask = mask.reshape(size**2)
+    A = grid_to_graph(n_x=size, n_y=size, mask=mask, return_as=np.ndarray)
+    assert connected_components(A)[0] == 2
+
+    # check ordering
+    mask = np.zeros((2, 3), dtype=bool)
+    mask[0, 0] = 1
+    mask[:, 2] = 1
+    graph = grid_to_graph(2, 3, 1, mask=mask.ravel()).todense()
+    desired = np.array([[1, 0, 0], [0, 1, 1], [0, 1, 1]])
+    np.testing.assert_array_equal(graph, desired)
+
+    # Checking that the function works whatever the type of mask is
+    mask = np.ones((size, size), dtype=np.int16)
+    A = grid_to_graph(n_x=size, n_y=size, n_z=size, mask=mask)
+    assert connected_components(A)[0] == 1
+
+    # Checking dtype of the graph
+    mask = np.ones((size, size))
+    A = grid_to_graph(n_x=size, n_y=size, n_z=size, mask=mask, dtype=bool)
+    assert A.dtype == bool
+    A = grid_to_graph(n_x=size, n_y=size, n_z=size, mask=mask, dtype=int)
+    assert A.dtype == int
+    A = grid_to_graph(n_x=size, n_y=size, n_z=size, mask=mask, dtype=np.float64)
+    assert A.dtype == np.float64
+
+
+def test_connect_regions(raccoon_face_fxt):
+    face = raccoon_face_fxt
+    # subsample by 4 to reduce run time
+    face = face[::4, ::4]
+    for thr in (50, 150):
+        mask = face > thr
+        graph = img_to_graph(face, mask=mask)
+        assert ndimage.label(mask)[1] == connected_components(graph)[0]
+
+
+def test_connect_regions_with_grid(raccoon_face_fxt):
+    face = raccoon_face_fxt
+
+    # subsample by 4 to reduce run time
+    face = face[::4, ::4]
+
+    mask = face > 50
+    graph = grid_to_graph(*face.shape, mask=mask)
+    assert ndimage.label(mask)[1] == connected_components(graph)[0]
+
+    mask = face > 150
+    graph = grid_to_graph(*face.shape, mask=mask, dtype=None)
+    assert ndimage.label(mask)[1] == connected_components(graph)[0]
+
+
+@pytest.fixture
+def downsampled_face(raccoon_face_fxt):
+    face = raccoon_face_fxt
+    face = face[::2, ::2] + face[1::2, ::2] + face[::2, 1::2] + face[1::2, 1::2]
+    face = face[::2, ::2] + face[1::2, ::2] + face[::2, 1::2] + face[1::2, 1::2]
+    face = face.astype(np.float32)
+    face /= 16.0
+    return face
+
+
+@pytest.fixture
+def orange_face(downsampled_face):
+    face = downsampled_face
+    face_color = np.zeros(face.shape + (3,))
+    face_color[:, :, 0] = 256 - face
+    face_color[:, :, 1] = 256 - face / 2
+    face_color[:, :, 2] = 256 - face / 4
+    return face_color
+
+
+def _make_images(face):
+    # make a collection of faces
+    images = np.zeros((3,) + face.shape)
+    images[0] = face
+    images[1] = face + 1
+    images[2] = face + 2
+    return images
+
+
+@pytest.fixture
+def downsampled_face_collection(downsampled_face):
+    return _make_images(downsampled_face)
+
+
+def test_extract_patches_all(downsampled_face):
+    face = downsampled_face
+    i_h, i_w = face.shape
+    p_h, p_w = 16, 16
+    expected_n_patches = (i_h - p_h + 1) * (i_w - p_w + 1)
+    patches = extract_patches_2d(face, (p_h, p_w))
+    assert patches.shape == (expected_n_patches, p_h, p_w)
+
+
+def test_extract_patches_all_color(orange_face):
+    face = orange_face
+    i_h, i_w = face.shape[:2]
+    p_h, p_w = 16, 16
+    expected_n_patches = (i_h - p_h + 1) * (i_w - p_w + 1)
+    patches = extract_patches_2d(face, (p_h, p_w))
+    assert patches.shape == (expected_n_patches, p_h, p_w, 3)
+
+
+def test_extract_patches_all_rect(downsampled_face):
+    face = downsampled_face
+    face = face[:, 32:97]
+    i_h, i_w = face.shape
+    p_h, p_w = 16, 12
+    expected_n_patches = (i_h - p_h + 1) * (i_w - p_w + 1)
+
+    patches = extract_patches_2d(face, (p_h, p_w))
+    assert patches.shape == (expected_n_patches, p_h, p_w)
+
+
+def test_extract_patches_max_patches(downsampled_face):
+    face = downsampled_face
+    i_h, i_w = face.shape
+    p_h, p_w = 16, 16
+
+    patches = extract_patches_2d(face, (p_h, p_w), max_patches=100)
+    assert patches.shape == (100, p_h, p_w)
+
+    expected_n_patches = int(0.5 * (i_h - p_h + 1) * (i_w - p_w + 1))
+    patches = extract_patches_2d(face, (p_h, p_w), max_patches=0.5)
+    assert patches.shape == (expected_n_patches, p_h, p_w)
+
+    with pytest.raises(ValueError):
+        extract_patches_2d(face, (p_h, p_w), max_patches=2.0)
+    with pytest.raises(ValueError):
+        extract_patches_2d(face, (p_h, p_w), max_patches=-1.0)
+
+
+def test_extract_patch_same_size_image(downsampled_face):
+    face = downsampled_face
+    # Request patches of the same size as image
+    # Should return just the single patch a.k.a. the image
+    patches = extract_patches_2d(face, face.shape, max_patches=2)
+    assert patches.shape[0] == 1
+
+
+def test_extract_patches_less_than_max_patches(downsampled_face):
+    face = downsampled_face
+    i_h, i_w = face.shape
+    p_h, p_w = 3 * i_h // 4, 3 * i_w // 4
+    # this is 3185
+    expected_n_patches = (i_h - p_h + 1) * (i_w - p_w + 1)
+
+    patches = extract_patches_2d(face, (p_h, p_w), max_patches=4000)
+    assert patches.shape == (expected_n_patches, p_h, p_w)
+
+
+def test_reconstruct_patches_perfect(downsampled_face):
+    face = downsampled_face
+    p_h, p_w = 16, 16
+
+    patches = extract_patches_2d(face, (p_h, p_w))
+    face_reconstructed = reconstruct_from_patches_2d(patches, face.shape)
+    np.testing.assert_array_almost_equal(face, face_reconstructed)
+
+
+def test_reconstruct_patches_perfect_color(orange_face):
+    face = orange_face
+    p_h, p_w = 16, 16
+
+    patches = extract_patches_2d(face, (p_h, p_w))
+    face_reconstructed = reconstruct_from_patches_2d(patches, face.shape)
+    np.testing.assert_array_almost_equal(face, face_reconstructed)
+
+
+def test_patch_extractor_fit(downsampled_face_collection):
+    faces = downsampled_face_collection
+    extr = PatchExtractor(patch_size=(8, 8), max_patches=100, random_state=0)
+    assert extr == extr.fit(faces)
+
+
+def test_patch_extractor_max_patches(downsampled_face_collection):
+    faces = downsampled_face_collection
+    i_h, i_w = faces.shape[1:3]
+    p_h, p_w = 8, 8
+
+    max_patches = 100
+    expected_n_patches = len(faces) * max_patches
+    extr = PatchExtractor(
+        patch_size=(p_h, p_w), max_patches=max_patches, random_state=0
+    )
+    patches = extr.transform(faces)
+    assert patches.shape == (expected_n_patches, p_h, p_w)
+
+    max_patches = 0.5
+    expected_n_patches = len(faces) * int(
+        (i_h - p_h + 1) * (i_w - p_w + 1) * max_patches
+    )
+    extr = PatchExtractor(
+        patch_size=(p_h, p_w), max_patches=max_patches, random_state=0
+    )
+    patches = extr.transform(faces)
+    assert patches.shape == (expected_n_patches, p_h, p_w)
+
+
+def test_patch_extractor_max_patches_default(downsampled_face_collection):
+    faces = downsampled_face_collection
+    extr = PatchExtractor(max_patches=100, random_state=0)
+    patches = extr.transform(faces)
+    assert patches.shape == (len(faces) * 100, 19, 25)
+
+
+def test_patch_extractor_all_patches(downsampled_face_collection):
+    faces = downsampled_face_collection
+    i_h, i_w = faces.shape[1:3]
+    p_h, p_w = 8, 8
+    expected_n_patches = len(faces) * (i_h - p_h + 1) * (i_w - p_w + 1)
+    extr = PatchExtractor(patch_size=(p_h, p_w), random_state=0)
+    patches = extr.transform(faces)
+    assert patches.shape == (expected_n_patches, p_h, p_w)
+
+
+def test_patch_extractor_color(orange_face):
+    faces = _make_images(orange_face)
+    i_h, i_w = faces.shape[1:3]
+    p_h, p_w = 8, 8
+    expected_n_patches = len(faces) * (i_h - p_h + 1) * (i_w - p_w + 1)
+    extr = PatchExtractor(patch_size=(p_h, p_w), random_state=0)
+    patches = extr.transform(faces)
+    assert patches.shape == (expected_n_patches, p_h, p_w, 3)
+
+
+def test_extract_patches_strided():
+    image_shapes_1D = [(10,), (10,), (11,), (10,)]
+    patch_sizes_1D = [(1,), (2,), (3,), (8,)]
+    patch_steps_1D = [(1,), (1,), (4,), (2,)]
+
+    expected_views_1D = [(10,), (9,), (3,), (2,)]
+    last_patch_1D = [(10,), (8,), (8,), (2,)]
+
+    image_shapes_2D = [(10, 20), (10, 20), (10, 20), (11, 20)]
+    patch_sizes_2D = [(2, 2), (10, 10), (10, 11), (6, 6)]
+    patch_steps_2D = [(5, 5), (3, 10), (3, 4), (4, 2)]
+
+    expected_views_2D = [(2, 4), (1, 2), (1, 3), (2, 8)]
+    last_patch_2D = [(5, 15), (0, 10), (0, 8), (4, 14)]
+
+    image_shapes_3D = [(5, 4, 3), (3, 3, 3), (7, 8, 9), (7, 8, 9)]
+    patch_sizes_3D = [(2, 2, 3), (2, 2, 2), (1, 7, 3), (1, 3, 3)]
+    patch_steps_3D = [(1, 2, 10), (1, 1, 1), (2, 1, 3), (3, 3, 4)]
+
+    expected_views_3D = [(4, 2, 1), (2, 2, 2), (4, 2, 3), (3, 2, 2)]
+    last_patch_3D = [(3, 2, 0), (1, 1, 1), (6, 1, 6), (6, 3, 4)]
+
+    image_shapes = image_shapes_1D + image_shapes_2D + image_shapes_3D
+    patch_sizes = patch_sizes_1D + patch_sizes_2D + patch_sizes_3D
+    patch_steps = patch_steps_1D + patch_steps_2D + patch_steps_3D
+    expected_views = expected_views_1D + expected_views_2D + expected_views_3D
+    last_patches = last_patch_1D + last_patch_2D + last_patch_3D
+
+    for image_shape, patch_size, patch_step, expected_view, last_patch in zip(
+        image_shapes, patch_sizes, patch_steps, expected_views, last_patches
+    ):
+        image = np.arange(np.prod(image_shape)).reshape(image_shape)
+        patches = _extract_patches(
+            image, patch_shape=patch_size, extraction_step=patch_step
+        )
+
+        ndim = len(image_shape)
+
+        assert patches.shape[:ndim] == expected_view
+        last_patch_slices = tuple(
+            slice(i, i + j, None) for i, j in zip(last_patch, patch_size)
+        )
+        assert (
+            patches[(-1, None, None) * ndim] == image[last_patch_slices].squeeze()
+        ).all()
+
+
+def test_extract_patches_square(downsampled_face):
+    # test same patch size for all dimensions
+    face = downsampled_face
+    i_h, i_w = face.shape
+    p = 8
+    expected_n_patches = ((i_h - p + 1), (i_w - p + 1))
+    patches = _extract_patches(face, patch_shape=p)
+    assert patches.shape == (expected_n_patches[0], expected_n_patches[1], p, p)
+
+
+def test_width_patch():
+    # width and height of the patch should be less than the image
+    x = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
+    with pytest.raises(ValueError):
+        extract_patches_2d(x, (4, 1))
+    with pytest.raises(ValueError):
+        extract_patches_2d(x, (1, 4))
+
+
+def test_patch_extractor_wrong_input(orange_face):
+    """Check that an informative error is raised if the patch_size is not valid."""
+    faces = _make_images(orange_face)
+    err_msg = "patch_size must be a tuple of two integers"
+    extractor = PatchExtractor(patch_size=(8, 8, 8))
+    with pytest.raises(ValueError, match=err_msg):
+        extractor.transform(faces)

venv/lib/python3.10/site-packages/sklearn/feature_extraction/tests/test_text.py

@@ -0,0 +1,1655 @@
+import pickle
+import re
+import warnings
+from collections import defaultdict
+from collections.abc import Mapping
+from functools import partial
+from io import StringIO
+from itertools import product
+
+import numpy as np
+import pytest
+from numpy.testing import assert_array_almost_equal, assert_array_equal
+from scipy import sparse
+
+from sklearn.base import clone
+from sklearn.feature_extraction.text import (
+    ENGLISH_STOP_WORDS,
+    CountVectorizer,
+    HashingVectorizer,
+    TfidfTransformer,
+    TfidfVectorizer,
+    strip_accents_ascii,
+    strip_accents_unicode,
+    strip_tags,
+)
+from sklearn.model_selection import GridSearchCV, cross_val_score, train_test_split
+from sklearn.pipeline import Pipeline
+from sklearn.svm import LinearSVC
+from sklearn.utils import _IS_WASM, IS_PYPY
+from sklearn.utils._testing import (
+    assert_allclose_dense_sparse,
+    assert_almost_equal,
+    fails_if_pypy,
+    skip_if_32bit,
+)
+from sklearn.utils.fixes import CSC_CONTAINERS, CSR_CONTAINERS
+
+JUNK_FOOD_DOCS = (
+    "the pizza pizza beer copyright",
+    "the pizza burger beer copyright",
+    "the the pizza beer beer copyright",
+    "the burger beer beer copyright",
+    "the coke burger coke copyright",
+    "the coke burger burger",
+)
+
+NOTJUNK_FOOD_DOCS = (
+    "the salad celeri copyright",
+    "the salad salad sparkling water copyright",
+    "the the celeri celeri copyright",
+    "the tomato tomato salad water",
+    "the tomato salad water copyright",
+)
+
+ALL_FOOD_DOCS = JUNK_FOOD_DOCS + NOTJUNK_FOOD_DOCS
+
+
+def uppercase(s):
+    return strip_accents_unicode(s).upper()
+
+
+def strip_eacute(s):
+    return s.replace("é", "e")
+
+
+def split_tokenize(s):
+    return s.split()
+
+
+def lazy_analyze(s):
+    return ["the_ultimate_feature"]
+
+
+def test_strip_accents():
+    # check some classical latin accentuated symbols
+    a = "àáâãäåçèéêë"
+    expected = "aaaaaaceeee"
+    assert strip_accents_unicode(a) == expected
+
+    a = "ìíîïñòóôõöùúûüý"
+    expected = "iiiinooooouuuuy"
+    assert strip_accents_unicode(a) == expected
+
+    # check some arabic
+    a = "\u0625"  # alef with a hamza below: إ
+    expected = "\u0627"  # simple alef: ا
+    assert strip_accents_unicode(a) == expected
+
+    # mix letters accentuated and not
+    a = "this is à test"
+    expected = "this is a test"
+    assert strip_accents_unicode(a) == expected
+
+    # strings that are already decomposed
+    a = "o\u0308"  # o with diaeresis
+    expected = "o"
+    assert strip_accents_unicode(a) == expected
+
+    # combining marks by themselves
+    a = "\u0300\u0301\u0302\u0303"
+    expected = ""
+    assert strip_accents_unicode(a) == expected
+
+    # Multiple combining marks on one character
+    a = "o\u0308\u0304"
+    expected = "o"
+    assert strip_accents_unicode(a) == expected
+
+
+def test_to_ascii():
+    # check some classical latin accentuated symbols
+    a = "àáâãäåçèéêë"
+    expected = "aaaaaaceeee"
+    assert strip_accents_ascii(a) == expected
+
+    a = "ìíîïñòóôõöùúûüý"
+    expected = "iiiinooooouuuuy"
+    assert strip_accents_ascii(a) == expected
+
+    # check some arabic
+    a = "\u0625"  # halef with a hamza below
+    expected = ""  # halef has no direct ascii match
+    assert strip_accents_ascii(a) == expected
+
+    # mix letters accentuated and not
+    a = "this is à test"
+    expected = "this is a test"
+    assert strip_accents_ascii(a) == expected
+
+
+@pytest.mark.parametrize("Vectorizer", (CountVectorizer, HashingVectorizer))
+def test_word_analyzer_unigrams(Vectorizer):
+    wa = Vectorizer(strip_accents="ascii").build_analyzer()
+    text = "J'ai mangé du kangourou  ce midi, c'était pas très bon."
+    expected = [
+        "ai",
+        "mange",
+        "du",
+        "kangourou",
+        "ce",
+        "midi",
+        "etait",
+        "pas",
+        "tres",
+        "bon",
+    ]
+    assert wa(text) == expected
+
+    text = "This is a test, really.\n\n I met Harry yesterday."
+    expected = ["this", "is", "test", "really", "met", "harry", "yesterday"]
+    assert wa(text) == expected
+
+    wa = Vectorizer(input="file").build_analyzer()
+    text = StringIO("This is a test with a file-like object!")
+    expected = ["this", "is", "test", "with", "file", "like", "object"]
+    assert wa(text) == expected
+
+    # with custom preprocessor
+    wa = Vectorizer(preprocessor=uppercase).build_analyzer()
+    text = "J'ai mangé du kangourou  ce midi,  c'était pas très bon."
+    expected = [
+        "AI",
+        "MANGE",
+        "DU",
+        "KANGOUROU",
+        "CE",
+        "MIDI",
+        "ETAIT",
+        "PAS",
+        "TRES",
+        "BON",
+    ]
+    assert wa(text) == expected
+
+    # with custom tokenizer
+    wa = Vectorizer(tokenizer=split_tokenize, strip_accents="ascii").build_analyzer()
+    text = "J'ai mangé du kangourou  ce midi, c'était pas très bon."
+    expected = [
+        "j'ai",
+        "mange",
+        "du",
+        "kangourou",
+        "ce",
+        "midi,",
+        "c'etait",
+        "pas",
+        "tres",
+        "bon.",
+    ]
+    assert wa(text) == expected
+
+
+def test_word_analyzer_unigrams_and_bigrams():
+    wa = CountVectorizer(
+        analyzer="word", strip_accents="unicode", ngram_range=(1, 2)
+    ).build_analyzer()
+
+    text = "J'ai mangé du kangourou  ce midi, c'était pas très bon."
+    expected = [
+        "ai",
+        "mange",
+        "du",
+        "kangourou",
+        "ce",
+        "midi",
+        "etait",
+        "pas",
+        "tres",
+        "bon",
+        "ai mange",
+        "mange du",
+        "du kangourou",
+        "kangourou ce",
+        "ce midi",
+        "midi etait",
+        "etait pas",
+        "pas tres",
+        "tres bon",
+    ]
+    assert wa(text) == expected
+
+
+def test_unicode_decode_error():
+    # decode_error default to strict, so this should fail
+    # First, encode (as bytes) a unicode string.
+    text = "J'ai mangé du kangourou  ce midi, c'était pas très bon."
+    text_bytes = text.encode("utf-8")
+
+    # Then let the Analyzer try to decode it as ascii. It should fail,
+    # because we have given it an incorrect encoding.
+    wa = CountVectorizer(ngram_range=(1, 2), encoding="ascii").build_analyzer()
+    with pytest.raises(UnicodeDecodeError):
+        wa(text_bytes)
+
+    ca = CountVectorizer(
+        analyzer="char", ngram_range=(3, 6), encoding="ascii"
+    ).build_analyzer()
+    with pytest.raises(UnicodeDecodeError):
+        ca(text_bytes)
+
+
+def test_char_ngram_analyzer():
+    cnga = CountVectorizer(
+        analyzer="char", strip_accents="unicode", ngram_range=(3, 6)
+    ).build_analyzer()
+
+    text = "J'ai mangé du kangourou  ce midi, c'était pas très bon"
+    expected = ["j'a", "'ai", "ai ", "i m", " ma"]
+    assert cnga(text)[:5] == expected
+    expected = ["s tres", " tres ", "tres b", "res bo", "es bon"]
+    assert cnga(text)[-5:] == expected
+
+    text = "This \n\tis a test, really.\n\n I met Harry yesterday"
+    expected = ["thi", "his", "is ", "s i", " is"]
+    assert cnga(text)[:5] == expected
+
+    expected = [" yeste", "yester", "esterd", "sterda", "terday"]
+    assert cnga(text)[-5:] == expected
+
+    cnga = CountVectorizer(
+        input="file", analyzer="char", ngram_range=(3, 6)
+    ).build_analyzer()
+    text = StringIO("This is a test with a file-like object!")
+    expected = ["thi", "his", "is ", "s i", " is"]
+    assert cnga(text)[:5] == expected
+
+
+def test_char_wb_ngram_analyzer():
+    cnga = CountVectorizer(
+        analyzer="char_wb", strip_accents="unicode", ngram_range=(3, 6)
+    ).build_analyzer()
+
+    text = "This \n\tis a test, really.\n\n I met Harry yesterday"
+    expected = [" th", "thi", "his", "is ", " thi"]
+    assert cnga(text)[:5] == expected
+
+    expected = ["yester", "esterd", "sterda", "terday", "erday "]
+    assert cnga(text)[-5:] == expected
+
+    cnga = CountVectorizer(
+        input="file", analyzer="char_wb", ngram_range=(3, 6)
+    ).build_analyzer()
+    text = StringIO("A test with a file-like object!")
+    expected = [" a ", " te", "tes", "est", "st ", " tes"]
+    assert cnga(text)[:6] == expected
+
+
+def test_word_ngram_analyzer():
+    cnga = CountVectorizer(
+        analyzer="word", strip_accents="unicode", ngram_range=(3, 6)
+    ).build_analyzer()
+
+    text = "This \n\tis a test, really.\n\n I met Harry yesterday"
+    expected = ["this is test", "is test really", "test really met"]
+    assert cnga(text)[:3] == expected
+
+    expected = [
+        "test really met harry yesterday",
+        "this is test really met harry",
+        "is test really met harry yesterday",
+    ]
+    assert cnga(text)[-3:] == expected
+
+    cnga_file = CountVectorizer(
+        input="file", analyzer="word", ngram_range=(3, 6)
+    ).build_analyzer()
+    file = StringIO(text)
+    assert cnga_file(file) == cnga(text)
+
+
+def test_countvectorizer_custom_vocabulary():
+    vocab = {"pizza": 0, "beer": 1}
+    terms = set(vocab.keys())
+
+    # Try a few of the supported types.
+    for typ in [dict, list, iter, partial(defaultdict, int)]:
+        v = typ(vocab)
+        vect = CountVectorizer(vocabulary=v)
+        vect.fit(JUNK_FOOD_DOCS)
+        if isinstance(v, Mapping):
+            assert vect.vocabulary_ == vocab
+        else:
+            assert set(vect.vocabulary_) == terms
+        X = vect.transform(JUNK_FOOD_DOCS)
+        assert X.shape[1] == len(terms)
+        v = typ(vocab)
+        vect = CountVectorizer(vocabulary=v)
+        inv = vect.inverse_transform(X)
+        assert len(inv) == X.shape[0]
+
+
+def test_countvectorizer_custom_vocabulary_pipeline():
+    what_we_like = ["pizza", "beer"]
+    pipe = Pipeline(
+        [
+            ("count", CountVectorizer(vocabulary=what_we_like)),
+            ("tfidf", TfidfTransformer()),
+        ]
+    )
+    X = pipe.fit_transform(ALL_FOOD_DOCS)
+    assert set(pipe.named_steps["count"].vocabulary_) == set(what_we_like)
+    assert X.shape[1] == len(what_we_like)
+
+
+def test_countvectorizer_custom_vocabulary_repeated_indices():
+    vocab = {"pizza": 0, "beer": 0}
+    msg = "Vocabulary contains repeated indices"
+    with pytest.raises(ValueError, match=msg):
+        vect = CountVectorizer(vocabulary=vocab)
+        vect.fit(["pasta_siziliana"])
+
+
+def test_countvectorizer_custom_vocabulary_gap_index():
+    vocab = {"pizza": 1, "beer": 2}
+    with pytest.raises(ValueError, match="doesn't contain index"):
+        vect = CountVectorizer(vocabulary=vocab)
+        vect.fit(["pasta_verdura"])
+
+
+def test_countvectorizer_stop_words():
+    cv = CountVectorizer()
+    cv.set_params(stop_words="english")
+    assert cv.get_stop_words() == ENGLISH_STOP_WORDS
+    cv.set_params(stop_words="_bad_str_stop_")
+    with pytest.raises(ValueError):
+        cv.get_stop_words()
+    cv.set_params(stop_words="_bad_unicode_stop_")
+    with pytest.raises(ValueError):
+        cv.get_stop_words()
+    stoplist = ["some", "other", "words"]
+    cv.set_params(stop_words=stoplist)
+    assert cv.get_stop_words() == set(stoplist)
+
+
+def test_countvectorizer_empty_vocabulary():
+    with pytest.raises(ValueError, match="empty vocabulary"):
+        vect = CountVectorizer(vocabulary=[])
+        vect.fit(["foo"])
+
+    with pytest.raises(ValueError, match="empty vocabulary"):
+        v = CountVectorizer(max_df=1.0, stop_words="english")
+        # fit on stopwords only
+        v.fit(["to be or not to be", "and me too", "and so do you"])
+
+
+def test_fit_countvectorizer_twice():
+    cv = CountVectorizer()
+    X1 = cv.fit_transform(ALL_FOOD_DOCS[:5])
+    X2 = cv.fit_transform(ALL_FOOD_DOCS[5:])
+    assert X1.shape[1] != X2.shape[1]
+
+
+def test_countvectorizer_custom_token_pattern():
+    """Check `get_feature_names_out()` when a custom token pattern is passed.
+    Non-regression test for:
+    https://github.com/scikit-learn/scikit-learn/issues/12971
+    """
+    corpus = [
+        "This is the 1st document in my corpus.",
+        "This document is the 2nd sample.",
+        "And this is the 3rd one.",
+        "Is this the 4th document?",
+    ]
+    token_pattern = r"[0-9]{1,3}(?:st|nd|rd|th)\s\b(\w{2,})\b"
+    vectorizer = CountVectorizer(token_pattern=token_pattern)
+    vectorizer.fit_transform(corpus)
+    expected = ["document", "one", "sample"]
+    feature_names_out = vectorizer.get_feature_names_out()
+    assert_array_equal(feature_names_out, expected)
+
+
+def test_countvectorizer_custom_token_pattern_with_several_group():
+    """Check that we raise an error if token pattern capture several groups.
+    Non-regression test for:
+    https://github.com/scikit-learn/scikit-learn/issues/12971
+    """
+    corpus = [
+        "This is the 1st document in my corpus.",
+        "This document is the 2nd sample.",
+        "And this is the 3rd one.",
+        "Is this the 4th document?",
+    ]
+
+    token_pattern = r"([0-9]{1,3}(?:st|nd|rd|th))\s\b(\w{2,})\b"
+    err_msg = "More than 1 capturing group in token pattern"
+    vectorizer = CountVectorizer(token_pattern=token_pattern)
+    with pytest.raises(ValueError, match=err_msg):
+        vectorizer.fit(corpus)
+
+
+def test_countvectorizer_uppercase_in_vocab():
+    # Check that the check for uppercase in the provided vocabulary is only done at fit
+    # time and not at transform time (#21251)
+    vocabulary = ["Sample", "Upper", "Case", "Vocabulary"]
+    message = (
+        "Upper case characters found in"
+        " vocabulary while 'lowercase'"
+        " is True. These entries will not"
+        " be matched with any documents"
+    )
+
+    vectorizer = CountVectorizer(lowercase=True, vocabulary=vocabulary)
+
+    with pytest.warns(UserWarning, match=message):
+        vectorizer.fit(vocabulary)
+
+    with warnings.catch_warnings():
+        warnings.simplefilter("error", UserWarning)
+        vectorizer.transform(vocabulary)
+
+
+def test_tf_transformer_feature_names_out():
+    """Check get_feature_names_out for TfidfTransformer"""
+    X = [[1, 1, 1], [1, 1, 0], [1, 0, 0]]
+    tr = TfidfTransformer(smooth_idf=True, norm="l2").fit(X)
+
+    feature_names_in = ["a", "c", "b"]
+    feature_names_out = tr.get_feature_names_out(feature_names_in)
+    assert_array_equal(feature_names_in, feature_names_out)
+
+
+def test_tf_idf_smoothing():
+    X = [[1, 1, 1], [1, 1, 0], [1, 0, 0]]
+    tr = TfidfTransformer(smooth_idf=True, norm="l2")
+    tfidf = tr.fit_transform(X).toarray()
+    assert (tfidf >= 0).all()
+
+    # check normalization
+    assert_array_almost_equal((tfidf**2).sum(axis=1), [1.0, 1.0, 1.0])
+
+    # this is robust to features with only zeros
+    X = [[1, 1, 0], [1, 1, 0], [1, 0, 0]]
+    tr = TfidfTransformer(smooth_idf=True, norm="l2")
+    tfidf = tr.fit_transform(X).toarray()
+    assert (tfidf >= 0).all()
+
+
+@pytest.mark.xfail(
+    _IS_WASM,
+    reason=(
+        "no floating point exceptions, see"
+        " https://github.com/numpy/numpy/pull/21895#issuecomment-1311525881"
+    ),
+)
+def test_tfidf_no_smoothing():
+    X = [[1, 1, 1], [1, 1, 0], [1, 0, 0]]
+    tr = TfidfTransformer(smooth_idf=False, norm="l2")
+    tfidf = tr.fit_transform(X).toarray()
+    assert (tfidf >= 0).all()
+
+    # check normalization
+    assert_array_almost_equal((tfidf**2).sum(axis=1), [1.0, 1.0, 1.0])
+
+    # the lack of smoothing make IDF fragile in the presence of feature with
+    # only zeros
+    X = [[1, 1, 0], [1, 1, 0], [1, 0, 0]]
+    tr = TfidfTransformer(smooth_idf=False, norm="l2")
+
+    in_warning_message = "divide by zero"
+    with pytest.warns(RuntimeWarning, match=in_warning_message):
+        tr.fit_transform(X).toarray()
+
+
+def test_sublinear_tf():
+    X = [[1], [2], [3]]
+    tr = TfidfTransformer(sublinear_tf=True, use_idf=False, norm=None)
+    tfidf = tr.fit_transform(X).toarray()
+    assert tfidf[0] == 1
+    assert tfidf[1] > tfidf[0]
+    assert tfidf[2] > tfidf[1]
+    assert tfidf[1] < 2
+    assert tfidf[2] < 3
+
+
+def test_vectorizer():
+    # raw documents as an iterator
+    train_data = iter(ALL_FOOD_DOCS[:-1])
+    test_data = [ALL_FOOD_DOCS[-1]]
+    n_train = len(ALL_FOOD_DOCS) - 1
+
+    # test without vocabulary
+    v1 = CountVectorizer(max_df=0.5)
+    counts_train = v1.fit_transform(train_data)
+    if hasattr(counts_train, "tocsr"):
+        counts_train = counts_train.tocsr()
+    assert counts_train[0, v1.vocabulary_["pizza"]] == 2
+
+    # build a vectorizer v1 with the same vocabulary as the one fitted by v1
+    v2 = CountVectorizer(vocabulary=v1.vocabulary_)
+
+    # compare that the two vectorizer give the same output on the test sample
+    for v in (v1, v2):
+        counts_test = v.transform(test_data)
+        if hasattr(counts_test, "tocsr"):
+            counts_test = counts_test.tocsr()
+
+        vocabulary = v.vocabulary_
+        assert counts_test[0, vocabulary["salad"]] == 1
+        assert counts_test[0, vocabulary["tomato"]] == 1
+        assert counts_test[0, vocabulary["water"]] == 1
+
+        # stop word from the fixed list
+        assert "the" not in vocabulary
+
+        # stop word found automatically by the vectorizer DF thresholding
+        # words that are high frequent across the complete corpus are likely
+        # to be not informative (either real stop words of extraction
+        # artifacts)
+        assert "copyright" not in vocabulary
+
+        # not present in the sample
+        assert counts_test[0, vocabulary["coke"]] == 0
+        assert counts_test[0, vocabulary["burger"]] == 0
+        assert counts_test[0, vocabulary["beer"]] == 0
+        assert counts_test[0, vocabulary["pizza"]] == 0
+
+    # test tf-idf
+    t1 = TfidfTransformer(norm="l1")
+    tfidf = t1.fit(counts_train).transform(counts_train).toarray()
+    assert len(t1.idf_) == len(v1.vocabulary_)
+    assert tfidf.shape == (n_train, len(v1.vocabulary_))
+
+    # test tf-idf with new data
+    tfidf_test = t1.transform(counts_test).toarray()
+    assert tfidf_test.shape == (len(test_data), len(v1.vocabulary_))
+
+    # test tf alone
+    t2 = TfidfTransformer(norm="l1", use_idf=False)
+    tf = t2.fit(counts_train).transform(counts_train).toarray()
+    assert not hasattr(t2, "idf_")
+
+    # test idf transform with unlearned idf vector
+    t3 = TfidfTransformer(use_idf=True)
+    with pytest.raises(ValueError):
+        t3.transform(counts_train)
+
+    # L1-normalized term frequencies sum to one
+    assert_array_almost_equal(np.sum(tf, axis=1), [1.0] * n_train)
+
+    # test the direct tfidf vectorizer
+    # (equivalent to term count vectorizer + tfidf transformer)
+    train_data = iter(ALL_FOOD_DOCS[:-1])
+    tv = TfidfVectorizer(norm="l1")
+
+    tv.max_df = v1.max_df
+    tfidf2 = tv.fit_transform(train_data).toarray()
+    assert not tv.fixed_vocabulary_
+    assert_array_almost_equal(tfidf, tfidf2)
+
+    # test the direct tfidf vectorizer with new data
+    tfidf_test2 = tv.transform(test_data).toarray()
+    assert_array_almost_equal(tfidf_test, tfidf_test2)
+
+    # test transform on unfitted vectorizer with empty vocabulary
+    v3 = CountVectorizer(vocabulary=None)
+    with pytest.raises(ValueError):
+        v3.transform(train_data)
+
+    # ascii preprocessor?
+    v3.set_params(strip_accents="ascii", lowercase=False)
+    processor = v3.build_preprocessor()
+    text = "J'ai mangé du kangourou  ce midi, c'était pas très bon."
+    expected = strip_accents_ascii(text)
+    result = processor(text)
+    assert expected == result
+
+    # error on bad strip_accents param
+    v3.set_params(strip_accents="_gabbledegook_", preprocessor=None)
+    with pytest.raises(ValueError):
+        v3.build_preprocessor()
+
+    # error with bad analyzer type
+    v3.set_params = "_invalid_analyzer_type_"
+    with pytest.raises(ValueError):
+        v3.build_analyzer()
+
+
+def test_tfidf_vectorizer_setters():
+    norm, use_idf, smooth_idf, sublinear_tf = "l2", False, False, False
+    tv = TfidfVectorizer(
+        norm=norm, use_idf=use_idf, smooth_idf=smooth_idf, sublinear_tf=sublinear_tf
+    )
+    tv.fit(JUNK_FOOD_DOCS)
+    assert tv._tfidf.norm == norm
+    assert tv._tfidf.use_idf == use_idf
+    assert tv._tfidf.smooth_idf == smooth_idf
+    assert tv._tfidf.sublinear_tf == sublinear_tf
+
+    # assigning value to `TfidfTransformer` should not have any effect until
+    # fitting
+    tv.norm = "l1"
+    tv.use_idf = True
+    tv.smooth_idf = True
+    tv.sublinear_tf = True
+    assert tv._tfidf.norm == norm
+    assert tv._tfidf.use_idf == use_idf
+    assert tv._tfidf.smooth_idf == smooth_idf
+    assert tv._tfidf.sublinear_tf == sublinear_tf
+
+    tv.fit(JUNK_FOOD_DOCS)
+    assert tv._tfidf.norm == tv.norm
+    assert tv._tfidf.use_idf == tv.use_idf
+    assert tv._tfidf.smooth_idf == tv.smooth_idf
+    assert tv._tfidf.sublinear_tf == tv.sublinear_tf
+
+
+@fails_if_pypy
+def test_hashing_vectorizer():
+    v = HashingVectorizer()
+    X = v.transform(ALL_FOOD_DOCS)
+    token_nnz = X.nnz
+    assert X.shape == (len(ALL_FOOD_DOCS), v.n_features)
+    assert X.dtype == v.dtype
+
+    # By default the hashed values receive a random sign and l2 normalization
+    # makes the feature values bounded
+    assert np.min(X.data) > -1
+    assert np.min(X.data) < 0
+    assert np.max(X.data) > 0
+    assert np.max(X.data) < 1
+
+    # Check that the rows are normalized
+    for i in range(X.shape[0]):
+        assert_almost_equal(np.linalg.norm(X[0].data, 2), 1.0)
+
+    # Check vectorization with some non-default parameters
+    v = HashingVectorizer(ngram_range=(1, 2), norm="l1")
+    X = v.transform(ALL_FOOD_DOCS)
+    assert X.shape == (len(ALL_FOOD_DOCS), v.n_features)
+    assert X.dtype == v.dtype
+
+    # ngrams generate more non zeros
+    ngrams_nnz = X.nnz
+    assert ngrams_nnz > token_nnz
+    assert ngrams_nnz < 2 * token_nnz
+
+    # makes the feature values bounded
+    assert np.min(X.data) > -1
+    assert np.max(X.data) < 1
+
+    # Check that the rows are normalized
+    for i in range(X.shape[0]):
+        assert_almost_equal(np.linalg.norm(X[0].data, 1), 1.0)
+
+
+def test_feature_names():
+    cv = CountVectorizer(max_df=0.5)
+
+    # test for Value error on unfitted/empty vocabulary
+    with pytest.raises(ValueError):
+        cv.get_feature_names_out()
+    assert not cv.fixed_vocabulary_
+
+    # test for vocabulary learned from data
+    X = cv.fit_transform(ALL_FOOD_DOCS)
+    n_samples, n_features = X.shape
+    assert len(cv.vocabulary_) == n_features
+
+    feature_names = cv.get_feature_names_out()
+    assert isinstance(feature_names, np.ndarray)
+    assert feature_names.dtype == object
+
+    assert len(feature_names) == n_features
+    assert_array_equal(
+        [
+            "beer",
+            "burger",
+            "celeri",
+            "coke",
+            "pizza",
+            "salad",
+            "sparkling",
+            "tomato",
+            "water",
+        ],
+        feature_names,
+    )
+
+    for idx, name in enumerate(feature_names):
+        assert idx == cv.vocabulary_.get(name)
+
+    # test for custom vocabulary
+    vocab = [
+        "beer",
+        "burger",
+        "celeri",
+        "coke",
+        "pizza",
+        "salad",
+        "sparkling",
+        "tomato",
+        "water",
+    ]
+
+    cv = CountVectorizer(vocabulary=vocab)
+    feature_names = cv.get_feature_names_out()
+    assert_array_equal(
+        [
+            "beer",
+            "burger",
+            "celeri",
+            "coke",
+            "pizza",
+            "salad",
+            "sparkling",
+            "tomato",
+            "water",
+        ],
+        feature_names,
+    )
+    assert cv.fixed_vocabulary_
+
+    for idx, name in enumerate(feature_names):
+        assert idx == cv.vocabulary_.get(name)
+
+
+@pytest.mark.parametrize("Vectorizer", (CountVectorizer, TfidfVectorizer))
+def test_vectorizer_max_features(Vectorizer):
+    expected_vocabulary = {"burger", "beer", "salad", "pizza"}
+    expected_stop_words = {
+        "celeri",
+        "tomato",
+        "copyright",
+        "coke",
+        "sparkling",
+        "water",
+        "the",
+    }
+
+    # test bounded number of extracted features
+    vectorizer = Vectorizer(max_df=0.6, max_features=4)
+    vectorizer.fit(ALL_FOOD_DOCS)
+    assert set(vectorizer.vocabulary_) == expected_vocabulary
+    assert vectorizer.stop_words_ == expected_stop_words
+
+
+def test_count_vectorizer_max_features():
+    # Regression test: max_features didn't work correctly in 0.14.
+
+    cv_1 = CountVectorizer(max_features=1)
+    cv_3 = CountVectorizer(max_features=3)
+    cv_None = CountVectorizer(max_features=None)
+
+    counts_1 = cv_1.fit_transform(JUNK_FOOD_DOCS).sum(axis=0)
+    counts_3 = cv_3.fit_transform(JUNK_FOOD_DOCS).sum(axis=0)
+    counts_None = cv_None.fit_transform(JUNK_FOOD_DOCS).sum(axis=0)
+
+    features_1 = cv_1.get_feature_names_out()
+    features_3 = cv_3.get_feature_names_out()
+    features_None = cv_None.get_feature_names_out()
+
+    # The most common feature is "the", with frequency 7.
+    assert 7 == counts_1.max()
+    assert 7 == counts_3.max()
+    assert 7 == counts_None.max()
+
+    # The most common feature should be the same
+    assert "the" == features_1[np.argmax(counts_1)]
+    assert "the" == features_3[np.argmax(counts_3)]
+    assert "the" == features_None[np.argmax(counts_None)]
+
+
+def test_vectorizer_max_df():
+    test_data = ["abc", "dea", "eat"]
+    vect = CountVectorizer(analyzer="char", max_df=1.0)
+    vect.fit(test_data)
+    assert "a" in vect.vocabulary_.keys()
+    assert len(vect.vocabulary_.keys()) == 6
+    assert len(vect.stop_words_) == 0
+
+    vect.max_df = 0.5  # 0.5 * 3 documents -> max_doc_count == 1.5
+    vect.fit(test_data)
+    assert "a" not in vect.vocabulary_.keys()  # {ae} ignored
+    assert len(vect.vocabulary_.keys()) == 4  # {bcdt} remain
+    assert "a" in vect.stop_words_
+    assert len(vect.stop_words_) == 2
+
+    vect.max_df = 1
+    vect.fit(test_data)
+    assert "a" not in vect.vocabulary_.keys()  # {ae} ignored
+    assert len(vect.vocabulary_.keys()) == 4  # {bcdt} remain
+    assert "a" in vect.stop_words_
+    assert len(vect.stop_words_) == 2
+
+
+def test_vectorizer_min_df():
+    test_data = ["abc", "dea", "eat"]
+    vect = CountVectorizer(analyzer="char", min_df=1)
+    vect.fit(test_data)
+    assert "a" in vect.vocabulary_.keys()
+    assert len(vect.vocabulary_.keys()) == 6
+    assert len(vect.stop_words_) == 0
+
+    vect.min_df = 2
+    vect.fit(test_data)
+    assert "c" not in vect.vocabulary_.keys()  # {bcdt} ignored
+    assert len(vect.vocabulary_.keys()) == 2  # {ae} remain
+    assert "c" in vect.stop_words_
+    assert len(vect.stop_words_) == 4
+
+    vect.min_df = 0.8  # 0.8 * 3 documents -> min_doc_count == 2.4
+    vect.fit(test_data)
+    assert "c" not in vect.vocabulary_.keys()  # {bcdet} ignored
+    assert len(vect.vocabulary_.keys()) == 1  # {a} remains
+    assert "c" in vect.stop_words_
+    assert len(vect.stop_words_) == 5
+
+
+def test_count_binary_occurrences():
+    # by default multiple occurrences are counted as longs
+    test_data = ["aaabc", "abbde"]
+    vect = CountVectorizer(analyzer="char", max_df=1.0)
+    X = vect.fit_transform(test_data).toarray()
+    assert_array_equal(["a", "b", "c", "d", "e"], vect.get_feature_names_out())
+    assert_array_equal([[3, 1, 1, 0, 0], [1, 2, 0, 1, 1]], X)
+
+    # using boolean features, we can fetch the binary occurrence info
+    # instead.
+    vect = CountVectorizer(analyzer="char", max_df=1.0, binary=True)
+    X = vect.fit_transform(test_data).toarray()
+    assert_array_equal([[1, 1, 1, 0, 0], [1, 1, 0, 1, 1]], X)
+
+    # check the ability to change the dtype
+    vect = CountVectorizer(analyzer="char", max_df=1.0, binary=True, dtype=np.float32)
+    X_sparse = vect.fit_transform(test_data)
+    assert X_sparse.dtype == np.float32
+
+
+@fails_if_pypy
+def test_hashed_binary_occurrences():
+    # by default multiple occurrences are counted as longs
+    test_data = ["aaabc", "abbde"]
+    vect = HashingVectorizer(alternate_sign=False, analyzer="char", norm=None)
+    X = vect.transform(test_data)
+    assert np.max(X[0:1].data) == 3
+    assert np.max(X[1:2].data) == 2
+    assert X.dtype == np.float64
+
+    # using boolean features, we can fetch the binary occurrence info
+    # instead.
+    vect = HashingVectorizer(
+        analyzer="char", alternate_sign=False, binary=True, norm=None
+    )
+    X = vect.transform(test_data)
+    assert np.max(X.data) == 1
+    assert X.dtype == np.float64
+
+    # check the ability to change the dtype
+    vect = HashingVectorizer(
+        analyzer="char", alternate_sign=False, binary=True, norm=None, dtype=np.float64
+    )
+    X = vect.transform(test_data)
+    assert X.dtype == np.float64
+
+
+@pytest.mark.parametrize("Vectorizer", (CountVectorizer, TfidfVectorizer))
+def test_vectorizer_inverse_transform(Vectorizer):
+    # raw documents
+    data = ALL_FOOD_DOCS
+    vectorizer = Vectorizer()
+    transformed_data = vectorizer.fit_transform(data)
+    inversed_data = vectorizer.inverse_transform(transformed_data)
+    assert isinstance(inversed_data, list)
+
+    analyze = vectorizer.build_analyzer()
+    for doc, inversed_terms in zip(data, inversed_data):
+        terms = np.sort(np.unique(analyze(doc)))
+        inversed_terms = np.sort(np.unique(inversed_terms))
+        assert_array_equal(terms, inversed_terms)
+
+    assert sparse.issparse(transformed_data)
+    assert transformed_data.format == "csr"
+
+    # Test that inverse_transform also works with numpy arrays and
+    # scipy
+    transformed_data2 = transformed_data.toarray()
+    inversed_data2 = vectorizer.inverse_transform(transformed_data2)
+    for terms, terms2 in zip(inversed_data, inversed_data2):
+        assert_array_equal(np.sort(terms), np.sort(terms2))
+
+    # Check that inverse_transform also works on non CSR sparse data:
+    transformed_data3 = transformed_data.tocsc()
+    inversed_data3 = vectorizer.inverse_transform(transformed_data3)
+    for terms, terms3 in zip(inversed_data, inversed_data3):
+        assert_array_equal(np.sort(terms), np.sort(terms3))
+
+
+def test_count_vectorizer_pipeline_grid_selection():
+    # raw documents
+    data = JUNK_FOOD_DOCS + NOTJUNK_FOOD_DOCS
+
+    # label junk food as -1, the others as +1
+    target = [-1] * len(JUNK_FOOD_DOCS) + [1] * len(NOTJUNK_FOOD_DOCS)
+
+    # split the dataset for model development and final evaluation
+    train_data, test_data, target_train, target_test = train_test_split(
+        data, target, test_size=0.2, random_state=0
+    )
+
+    pipeline = Pipeline([("vect", CountVectorizer()), ("svc", LinearSVC(dual="auto"))])
+
+    parameters = {
+        "vect__ngram_range": [(1, 1), (1, 2)],
+        "svc__loss": ("hinge", "squared_hinge"),
+    }
+
+    # find the best parameters for both the feature extraction and the
+    # classifier
+    grid_search = GridSearchCV(pipeline, parameters, n_jobs=1, cv=3)
+
+    # Check that the best model found by grid search is 100% correct on the
+    # held out evaluation set.
+    pred = grid_search.fit(train_data, target_train).predict(test_data)
+    assert_array_equal(pred, target_test)
+
+    # on this toy dataset bigram representation which is used in the last of
+    # the grid_search is considered the best estimator since they all converge
+    # to 100% accuracy models
+    assert grid_search.best_score_ == 1.0
+    best_vectorizer = grid_search.best_estimator_.named_steps["vect"]
+    assert best_vectorizer.ngram_range == (1, 1)
+
+
+def test_vectorizer_pipeline_grid_selection():
+    # raw documents
+    data = JUNK_FOOD_DOCS + NOTJUNK_FOOD_DOCS
+
+    # label junk food as -1, the others as +1
+    target = [-1] * len(JUNK_FOOD_DOCS) + [1] * len(NOTJUNK_FOOD_DOCS)
+
+    # split the dataset for model development and final evaluation
+    train_data, test_data, target_train, target_test = train_test_split(
+        data, target, test_size=0.1, random_state=0
+    )
+
+    pipeline = Pipeline([("vect", TfidfVectorizer()), ("svc", LinearSVC(dual="auto"))])
+
+    parameters = {
+        "vect__ngram_range": [(1, 1), (1, 2)],
+        "vect__norm": ("l1", "l2"),
+        "svc__loss": ("hinge", "squared_hinge"),
+    }
+
+    # find the best parameters for both the feature extraction and the
+    # classifier
+    grid_search = GridSearchCV(pipeline, parameters, n_jobs=1)
+
+    # Check that the best model found by grid search is 100% correct on the
+    # held out evaluation set.
+    pred = grid_search.fit(train_data, target_train).predict(test_data)
+    assert_array_equal(pred, target_test)
+
+    # on this toy dataset bigram representation which is used in the last of
+    # the grid_search is considered the best estimator since they all converge
+    # to 100% accuracy models
+    assert grid_search.best_score_ == 1.0
+    best_vectorizer = grid_search.best_estimator_.named_steps["vect"]
+    assert best_vectorizer.ngram_range == (1, 1)
+    assert best_vectorizer.norm == "l2"
+    assert not best_vectorizer.fixed_vocabulary_
+
+
+def test_vectorizer_pipeline_cross_validation():
+    # raw documents
+    data = JUNK_FOOD_DOCS + NOTJUNK_FOOD_DOCS
+
+    # label junk food as -1, the others as +1
+    target = [-1] * len(JUNK_FOOD_DOCS) + [1] * len(NOTJUNK_FOOD_DOCS)
+
+    pipeline = Pipeline([("vect", TfidfVectorizer()), ("svc", LinearSVC(dual="auto"))])
+
+    cv_scores = cross_val_score(pipeline, data, target, cv=3)
+    assert_array_equal(cv_scores, [1.0, 1.0, 1.0])
+
+
+@fails_if_pypy
+def test_vectorizer_unicode():
+    # tests that the count vectorizer works with cyrillic.
+    document = (
+        "Машинное обучение — обширный подраздел искусственного "
+        "интеллекта, изучающий методы построения алгоритмов, "
+        "способных обучаться."
+    )
+
+    vect = CountVectorizer()
+    X_counted = vect.fit_transform([document])
+    assert X_counted.shape == (1, 12)
+
+    vect = HashingVectorizer(norm=None, alternate_sign=False)
+    X_hashed = vect.transform([document])
+    assert X_hashed.shape == (1, 2**20)
+
+    # No collisions on such a small dataset
+    assert X_counted.nnz == X_hashed.nnz
+
+    # When norm is None and not alternate_sign, the tokens are counted up to
+    # collisions
+    assert_array_equal(np.sort(X_counted.data), np.sort(X_hashed.data))
+
+
+def test_tfidf_vectorizer_with_fixed_vocabulary():
+    # non regression smoke test for inheritance issues
+    vocabulary = ["pizza", "celeri"]
+    vect = TfidfVectorizer(vocabulary=vocabulary)
+    X_1 = vect.fit_transform(ALL_FOOD_DOCS)
+    X_2 = vect.transform(ALL_FOOD_DOCS)
+    assert_array_almost_equal(X_1.toarray(), X_2.toarray())
+    assert vect.fixed_vocabulary_
+
+
+def test_pickling_vectorizer():
+    instances = [
+        HashingVectorizer(),
+        HashingVectorizer(norm="l1"),
+        HashingVectorizer(binary=True),
+        HashingVectorizer(ngram_range=(1, 2)),
+        CountVectorizer(),
+        CountVectorizer(preprocessor=strip_tags),
+        CountVectorizer(analyzer=lazy_analyze),
+        CountVectorizer(preprocessor=strip_tags).fit(JUNK_FOOD_DOCS),
+        CountVectorizer(strip_accents=strip_eacute).fit(JUNK_FOOD_DOCS),
+        TfidfVectorizer(),
+        TfidfVectorizer(analyzer=lazy_analyze),
+        TfidfVectorizer().fit(JUNK_FOOD_DOCS),
+    ]
+
+    for orig in instances:
+        s = pickle.dumps(orig)
+        copy = pickle.loads(s)
+        assert type(copy) == orig.__class__
+        assert copy.get_params() == orig.get_params()
+        if IS_PYPY and isinstance(orig, HashingVectorizer):
+            continue
+        else:
+            assert_allclose_dense_sparse(
+                copy.fit_transform(JUNK_FOOD_DOCS),
+                orig.fit_transform(JUNK_FOOD_DOCS),
+            )
+
+
+@pytest.mark.parametrize(
+    "factory",
+    [
+        CountVectorizer.build_analyzer,
+        CountVectorizer.build_preprocessor,
+        CountVectorizer.build_tokenizer,
+    ],
+)
+def test_pickling_built_processors(factory):
+    """Tokenizers cannot be pickled
+    https://github.com/scikit-learn/scikit-learn/issues/12833
+    """
+    vec = CountVectorizer()
+    function = factory(vec)
+    text = "J'ai mangé du kangourou  ce midi, c'était pas très bon."
+    roundtripped_function = pickle.loads(pickle.dumps(function))
+    expected = function(text)
+    result = roundtripped_function(text)
+    assert result == expected
+
+
+def test_countvectorizer_vocab_sets_when_pickling():
+    # ensure that vocabulary of type set is coerced to a list to
+    # preserve iteration ordering after deserialization
+    rng = np.random.RandomState(0)
+    vocab_words = np.array(
+        [
+            "beer",
+            "burger",
+            "celeri",
+            "coke",
+            "pizza",
+            "salad",
+            "sparkling",
+            "tomato",
+            "water",
+        ]
+    )
+    for x in range(0, 100):
+        vocab_set = set(rng.choice(vocab_words, size=5, replace=False))
+        cv = CountVectorizer(vocabulary=vocab_set)
+        unpickled_cv = pickle.loads(pickle.dumps(cv))
+        cv.fit(ALL_FOOD_DOCS)
+        unpickled_cv.fit(ALL_FOOD_DOCS)
+        assert_array_equal(
+            cv.get_feature_names_out(), unpickled_cv.get_feature_names_out()
+        )
+
+
+def test_countvectorizer_vocab_dicts_when_pickling():
+    rng = np.random.RandomState(0)
+    vocab_words = np.array(
+        [
+            "beer",
+            "burger",
+            "celeri",
+            "coke",
+            "pizza",
+            "salad",
+            "sparkling",
+            "tomato",
+            "water",
+        ]
+    )
+    for x in range(0, 100):
+        vocab_dict = dict()
+        words = rng.choice(vocab_words, size=5, replace=False)
+        for y in range(0, 5):
+            vocab_dict[words[y]] = y
+        cv = CountVectorizer(vocabulary=vocab_dict)
+        unpickled_cv = pickle.loads(pickle.dumps(cv))
+        cv.fit(ALL_FOOD_DOCS)
+        unpickled_cv.fit(ALL_FOOD_DOCS)
+        assert_array_equal(
+            cv.get_feature_names_out(), unpickled_cv.get_feature_names_out()
+        )
+
+
+def test_stop_words_removal():
+    # Ensure that deleting the stop_words_ attribute doesn't affect transform
+
+    fitted_vectorizers = (
+        TfidfVectorizer().fit(JUNK_FOOD_DOCS),
+        CountVectorizer(preprocessor=strip_tags).fit(JUNK_FOOD_DOCS),
+        CountVectorizer(strip_accents=strip_eacute).fit(JUNK_FOOD_DOCS),
+    )
+
+    for vect in fitted_vectorizers:
+        vect_transform = vect.transform(JUNK_FOOD_DOCS).toarray()
+
+        vect.stop_words_ = None
+        stop_None_transform = vect.transform(JUNK_FOOD_DOCS).toarray()
+
+        delattr(vect, "stop_words_")
+        stop_del_transform = vect.transform(JUNK_FOOD_DOCS).toarray()
+
+        assert_array_equal(stop_None_transform, vect_transform)
+        assert_array_equal(stop_del_transform, vect_transform)
+
+
+def test_pickling_transformer():
+    X = CountVectorizer().fit_transform(JUNK_FOOD_DOCS)
+    orig = TfidfTransformer().fit(X)
+    s = pickle.dumps(orig)
+    copy = pickle.loads(s)
+    assert type(copy) == orig.__class__
+    assert_array_equal(copy.fit_transform(X).toarray(), orig.fit_transform(X).toarray())
+
+
+def test_transformer_idf_setter():
+    X = CountVectorizer().fit_transform(JUNK_FOOD_DOCS)
+    orig = TfidfTransformer().fit(X)
+    copy = TfidfTransformer()
+    copy.idf_ = orig.idf_
+    assert_array_equal(copy.transform(X).toarray(), orig.transform(X).toarray())
+
+
+def test_tfidf_vectorizer_setter():
+    orig = TfidfVectorizer(use_idf=True)
+    orig.fit(JUNK_FOOD_DOCS)
+    copy = TfidfVectorizer(vocabulary=orig.vocabulary_, use_idf=True)
+    copy.idf_ = orig.idf_
+    assert_array_equal(
+        copy.transform(JUNK_FOOD_DOCS).toarray(),
+        orig.transform(JUNK_FOOD_DOCS).toarray(),
+    )
+    # `idf_` cannot be set with `use_idf=False`
+    copy = TfidfVectorizer(vocabulary=orig.vocabulary_, use_idf=False)
+    err_msg = "`idf_` cannot be set when `user_idf=False`."
+    with pytest.raises(ValueError, match=err_msg):
+        copy.idf_ = orig.idf_
+
+
+def test_tfidfvectorizer_invalid_idf_attr():
+    vect = TfidfVectorizer(use_idf=True)
+    vect.fit(JUNK_FOOD_DOCS)
+    copy = TfidfVectorizer(vocabulary=vect.vocabulary_, use_idf=True)
+    expected_idf_len = len(vect.idf_)
+    invalid_idf = [1.0] * (expected_idf_len + 1)
+    with pytest.raises(ValueError):
+        setattr(copy, "idf_", invalid_idf)
+
+
+def test_non_unique_vocab():
+    vocab = ["a", "b", "c", "a", "a"]
+    vect = CountVectorizer(vocabulary=vocab)
+    with pytest.raises(ValueError):
+        vect.fit([])
+
+
+@fails_if_pypy
+def test_hashingvectorizer_nan_in_docs():
+    # np.nan can appear when using pandas to load text fields from a csv file
+    # with missing values.
+    message = "np.nan is an invalid document, expected byte or unicode string."
+    exception = ValueError
+
+    def func():
+        hv = HashingVectorizer()
+        hv.fit_transform(["hello world", np.nan, "hello hello"])
+
+    with pytest.raises(exception, match=message):
+        func()
+
+
+def test_tfidfvectorizer_binary():
+    # Non-regression test: TfidfVectorizer used to ignore its "binary" param.
+    v = TfidfVectorizer(binary=True, use_idf=False, norm=None)
+    assert v.binary
+
+    X = v.fit_transform(["hello world", "hello hello"]).toarray()
+    assert_array_equal(X.ravel(), [1, 1, 1, 0])
+    X2 = v.transform(["hello world", "hello hello"]).toarray()
+    assert_array_equal(X2.ravel(), [1, 1, 1, 0])
+
+
+def test_tfidfvectorizer_export_idf():
+    vect = TfidfVectorizer(use_idf=True)
+    vect.fit(JUNK_FOOD_DOCS)
+    assert_array_almost_equal(vect.idf_, vect._tfidf.idf_)
+
+
+def test_vectorizer_vocab_clone():
+    vect_vocab = TfidfVectorizer(vocabulary=["the"])
+    vect_vocab_clone = clone(vect_vocab)
+    vect_vocab.fit(ALL_FOOD_DOCS)
+    vect_vocab_clone.fit(ALL_FOOD_DOCS)
+    assert vect_vocab_clone.vocabulary_ == vect_vocab.vocabulary_
+
+
+@pytest.mark.parametrize(
+    "Vectorizer", (CountVectorizer, TfidfVectorizer, HashingVectorizer)
+)
+def test_vectorizer_string_object_as_input(Vectorizer):
+    message = "Iterable over raw text documents expected, string object received."
+    vec = Vectorizer()
+
+    with pytest.raises(ValueError, match=message):
+        vec.fit_transform("hello world!")
+
+    with pytest.raises(ValueError, match=message):
+        vec.fit("hello world!")
+    vec.fit(["some text", "some other text"])
+
+    with pytest.raises(ValueError, match=message):
+        vec.transform("hello world!")
+
+
+@pytest.mark.parametrize("X_dtype", [np.float32, np.float64])
+def test_tfidf_transformer_type(X_dtype):
+    X = sparse.rand(10, 20000, dtype=X_dtype, random_state=42)
+    X_trans = TfidfTransformer().fit_transform(X)
+    assert X_trans.dtype == X.dtype
+
+
+@pytest.mark.parametrize(
+    "csc_container, csr_container", product(CSC_CONTAINERS, CSR_CONTAINERS)
+)
+def test_tfidf_transformer_sparse(csc_container, csr_container):
+    X = sparse.rand(10, 20000, dtype=np.float64, random_state=42)
+    X_csc = csc_container(X)
+    X_csr = csr_container(X)
+
+    X_trans_csc = TfidfTransformer().fit_transform(X_csc)
+    X_trans_csr = TfidfTransformer().fit_transform(X_csr)
+    assert_allclose_dense_sparse(X_trans_csc, X_trans_csr)
+    assert X_trans_csc.format == X_trans_csr.format
+
+
+@pytest.mark.parametrize(
+    "vectorizer_dtype, output_dtype, warning_expected",
+    [
+        (np.int32, np.float64, True),
+        (np.int64, np.float64, True),
+        (np.float32, np.float32, False),
+        (np.float64, np.float64, False),
+    ],
+)
+def test_tfidf_vectorizer_type(vectorizer_dtype, output_dtype, warning_expected):
+    X = np.array(["numpy", "scipy", "sklearn"])
+    vectorizer = TfidfVectorizer(dtype=vectorizer_dtype)
+
+    warning_msg_match = "'dtype' should be used."
+    if warning_expected:
+        with pytest.warns(UserWarning, match=warning_msg_match):
+            X_idf = vectorizer.fit_transform(X)
+    else:
+        with warnings.catch_warnings():
+            warnings.simplefilter("error", UserWarning)
+            X_idf = vectorizer.fit_transform(X)
+    assert X_idf.dtype == output_dtype
+
+
+@pytest.mark.parametrize(
+    "vec",
+    [
+        HashingVectorizer(ngram_range=(2, 1)),
+        CountVectorizer(ngram_range=(2, 1)),
+        TfidfVectorizer(ngram_range=(2, 1)),
+    ],
+)
+def test_vectorizers_invalid_ngram_range(vec):
+    # vectorizers could be initialized with invalid ngram range
+    # test for raising error message
+    invalid_range = vec.ngram_range
+    message = re.escape(
+        f"Invalid value for ngram_range={invalid_range} "
+        "lower boundary larger than the upper boundary."
+    )
+    if isinstance(vec, HashingVectorizer) and IS_PYPY:
+        pytest.xfail(reason="HashingVectorizer is not supported on PyPy")
+
+    with pytest.raises(ValueError, match=message):
+        vec.fit(["good news everyone"])
+
+    with pytest.raises(ValueError, match=message):
+        vec.fit_transform(["good news everyone"])
+
+    if isinstance(vec, HashingVectorizer):
+        with pytest.raises(ValueError, match=message):
+            vec.transform(["good news everyone"])
+
+
+def _check_stop_words_consistency(estimator):
+    stop_words = estimator.get_stop_words()
+    tokenize = estimator.build_tokenizer()
+    preprocess = estimator.build_preprocessor()
+    return estimator._check_stop_words_consistency(stop_words, preprocess, tokenize)
+
+
+@fails_if_pypy
+def test_vectorizer_stop_words_inconsistent():
+    lstr = r"\['and', 'll', 've'\]"
+    message = (
+        "Your stop_words may be inconsistent with your "
+        "preprocessing. Tokenizing the stop words generated "
+        "tokens %s not in stop_words." % lstr
+    )
+    for vec in [CountVectorizer(), TfidfVectorizer(), HashingVectorizer()]:
+        vec.set_params(stop_words=["you've", "you", "you'll", "AND"])
+        with pytest.warns(UserWarning, match=message):
+            vec.fit_transform(["hello world"])
+        # reset stop word validation
+        del vec._stop_words_id
+        assert _check_stop_words_consistency(vec) is False
+
+    # Only one warning per stop list
+    with warnings.catch_warnings():
+        warnings.simplefilter("error", UserWarning)
+        vec.fit_transform(["hello world"])
+    assert _check_stop_words_consistency(vec) is None
+
+    # Test caching of inconsistency assessment
+    vec.set_params(stop_words=["you've", "you", "you'll", "blah", "AND"])
+    with pytest.warns(UserWarning, match=message):
+        vec.fit_transform(["hello world"])
+
+
+@skip_if_32bit
+@pytest.mark.parametrize("csr_container", CSR_CONTAINERS)
+def test_countvectorizer_sort_features_64bit_sparse_indices(csr_container):
+    """
+    Check that CountVectorizer._sort_features preserves the dtype of its sparse
+    feature matrix.
+
+    This test is skipped on 32bit platforms, see:
+        https://github.com/scikit-learn/scikit-learn/pull/11295
+    for more details.
+    """
+
+    X = csr_container((5, 5), dtype=np.int64)
+
+    # force indices and indptr to int64.
+    INDICES_DTYPE = np.int64
+    X.indices = X.indices.astype(INDICES_DTYPE)
+    X.indptr = X.indptr.astype(INDICES_DTYPE)
+
+    vocabulary = {"scikit-learn": 0, "is": 1, "great!": 2}
+
+    Xs = CountVectorizer()._sort_features(X, vocabulary)
+
+    assert INDICES_DTYPE == Xs.indices.dtype
+
+
+@fails_if_pypy
+@pytest.mark.parametrize(
+    "Estimator", [CountVectorizer, TfidfVectorizer, HashingVectorizer]
+)
+def test_stop_word_validation_custom_preprocessor(Estimator):
+    data = [{"text": "some text"}]
+
+    vec = Estimator()
+    assert _check_stop_words_consistency(vec) is True
+
+    vec = Estimator(preprocessor=lambda x: x["text"], stop_words=["and"])
+    assert _check_stop_words_consistency(vec) == "error"
+    # checks are cached
+    assert _check_stop_words_consistency(vec) is None
+    vec.fit_transform(data)
+
+    class CustomEstimator(Estimator):
+        def build_preprocessor(self):
+            return lambda x: x["text"]
+
+    vec = CustomEstimator(stop_words=["and"])
+    assert _check_stop_words_consistency(vec) == "error"
+
+    vec = Estimator(
+        tokenizer=lambda doc: re.compile(r"\w{1,}").findall(doc), stop_words=["and"]
+    )
+    assert _check_stop_words_consistency(vec) is True
+
+
+@pytest.mark.parametrize(
+    "Estimator", [CountVectorizer, TfidfVectorizer, HashingVectorizer]
+)
+@pytest.mark.parametrize(
+    "input_type, err_type, err_msg",
+    [
+        ("filename", FileNotFoundError, ""),
+        ("file", AttributeError, "'str' object has no attribute 'read'"),
+    ],
+)
+def test_callable_analyzer_error(Estimator, input_type, err_type, err_msg):
+    if issubclass(Estimator, HashingVectorizer) and IS_PYPY:
+        pytest.xfail("HashingVectorizer is not supported on PyPy")
+    data = ["this is text, not file or filename"]
+    with pytest.raises(err_type, match=err_msg):
+        Estimator(analyzer=lambda x: x.split(), input=input_type).fit_transform(data)
+
+
+@pytest.mark.parametrize(
+    "Estimator",
+    [
+        CountVectorizer,
+        TfidfVectorizer,
+        pytest.param(HashingVectorizer, marks=fails_if_pypy),
+    ],
+)
+@pytest.mark.parametrize(
+    "analyzer", [lambda doc: open(doc, "r"), lambda doc: doc.read()]
+)
+@pytest.mark.parametrize("input_type", ["file", "filename"])
+def test_callable_analyzer_change_behavior(Estimator, analyzer, input_type):
+    data = ["this is text, not file or filename"]
+    with pytest.raises((FileNotFoundError, AttributeError)):
+        Estimator(analyzer=analyzer, input=input_type).fit_transform(data)
+
+
+@pytest.mark.parametrize(
+    "Estimator", [CountVectorizer, TfidfVectorizer, HashingVectorizer]
+)
+def test_callable_analyzer_reraise_error(tmpdir, Estimator):
+    # check if a custom exception from the analyzer is shown to the user
+    def analyzer(doc):
+        raise Exception("testing")
+
+    if issubclass(Estimator, HashingVectorizer) and IS_PYPY:
+        pytest.xfail("HashingVectorizer is not supported on PyPy")
+
+    f = tmpdir.join("file.txt")
+    f.write("sample content\n")
+
+    with pytest.raises(Exception, match="testing"):
+        Estimator(analyzer=analyzer, input="file").fit_transform([f])
+
+
+@pytest.mark.parametrize(
+    "Vectorizer", [CountVectorizer, HashingVectorizer, TfidfVectorizer]
+)
+@pytest.mark.parametrize(
+    (
+        "stop_words, tokenizer, preprocessor, ngram_range, token_pattern,"
+        "analyzer, unused_name, ovrd_name, ovrd_msg"
+    ),
+    [
+        (
+            ["you've", "you'll"],
+            None,
+            None,
+            (1, 1),
+            None,
+            "char",
+            "'stop_words'",
+            "'analyzer'",
+            "!= 'word'",
+        ),
+        (
+            None,
+            lambda s: s.split(),
+            None,
+            (1, 1),
+            None,
+            "char",
+            "'tokenizer'",
+            "'analyzer'",
+            "!= 'word'",
+        ),
+        (
+            None,
+            lambda s: s.split(),
+            None,
+            (1, 1),
+            r"\w+",
+            "word",
+            "'token_pattern'",
+            "'tokenizer'",
+            "is not None",
+        ),
+        (
+            None,
+            None,
+            lambda s: s.upper(),
+            (1, 1),
+            r"\w+",
+            lambda s: s.upper(),
+            "'preprocessor'",
+            "'analyzer'",
+            "is callable",
+        ),
+        (
+            None,
+            None,
+            None,
+            (1, 2),
+            None,
+            lambda s: s.upper(),
+            "'ngram_range'",
+            "'analyzer'",
+            "is callable",
+        ),
+        (
+            None,
+            None,
+            None,
+            (1, 1),
+            r"\w+",
+            "char",
+            "'token_pattern'",
+            "'analyzer'",
+            "!= 'word'",
+        ),
+    ],
+)
+def test_unused_parameters_warn(
+    Vectorizer,
+    stop_words,
+    tokenizer,
+    preprocessor,
+    ngram_range,
+    token_pattern,
+    analyzer,
+    unused_name,
+    ovrd_name,
+    ovrd_msg,
+):
+    train_data = JUNK_FOOD_DOCS
+    # setting parameter and checking for corresponding warning messages
+    vect = Vectorizer()
+    vect.set_params(
+        stop_words=stop_words,
+        tokenizer=tokenizer,
+        preprocessor=preprocessor,
+        ngram_range=ngram_range,
+        token_pattern=token_pattern,
+        analyzer=analyzer,
+    )
+    msg = "The parameter %s will not be used since %s %s" % (
+        unused_name,
+        ovrd_name,
+        ovrd_msg,
+    )
+    with pytest.warns(UserWarning, match=msg):
+        vect.fit(train_data)
+
+
+@pytest.mark.parametrize(
+    "Vectorizer, X",
+    (
+        (HashingVectorizer, [{"foo": 1, "bar": 2}, {"foo": 3, "baz": 1}]),
+        (CountVectorizer, JUNK_FOOD_DOCS),
+    ),
+)
+def test_n_features_in(Vectorizer, X):
+    # For vectorizers, n_features_in_ does not make sense
+    vectorizer = Vectorizer()
+    assert not hasattr(vectorizer, "n_features_in_")
+    vectorizer.fit(X)
+    assert not hasattr(vectorizer, "n_features_in_")
+
+
+def test_tie_breaking_sample_order_invariance():
+    # Checks the sample order invariance when setting max_features
+    # non-regression test for #17939
+    vec = CountVectorizer(max_features=1)
+    vocab1 = vec.fit(["hello", "world"]).vocabulary_
+    vocab2 = vec.fit(["world", "hello"]).vocabulary_
+    assert vocab1 == vocab2
+
+
+@fails_if_pypy
+def test_nonnegative_hashing_vectorizer_result_indices():
+    # add test for pr 19035
+    hashing = HashingVectorizer(n_features=1000000, ngram_range=(2, 3))
+    indices = hashing.transform(["22pcs efuture"]).indices
+    assert indices[0] >= 0
+
+
+@pytest.mark.parametrize(
+    "Estimator", [CountVectorizer, TfidfVectorizer, TfidfTransformer, HashingVectorizer]
+)
+def test_vectorizers_do_not_have_set_output(Estimator):
+    """Check that vectorizers do not define set_output."""
+    est = Estimator()
+    assert not hasattr(est, "set_output")

venv/lib/python3.10/site-packages/sklearn/feature_extraction/text.py

@@ -0,0 +1,2166 @@
+# Authors: Olivier Grisel <[email protected]>
+#          Mathieu Blondel <[email protected]>
+#          Lars Buitinck
+#          Robert Layton <[email protected]>
+#          Jochen Wersdörfer <[email protected]>
+#          Roman Sinayev <[email protected]>
+#
+# License: BSD 3 clause
+"""
+The :mod:`sklearn.feature_extraction.text` submodule gathers utilities to
+build feature vectors from text documents.
+"""
+
+import array
+import re
+import unicodedata
+import warnings
+from collections import defaultdict
+from collections.abc import Mapping
+from functools import partial
+from numbers import Integral
+from operator import itemgetter
+
+import numpy as np
+import scipy.sparse as sp
+
+from ..base import BaseEstimator, OneToOneFeatureMixin, TransformerMixin, _fit_context
+from ..exceptions import NotFittedError
+from ..preprocessing import normalize
+from ..utils import _IS_32BIT
+from ..utils._param_validation import HasMethods, Interval, RealNotInt, StrOptions
+from ..utils.validation import FLOAT_DTYPES, check_array, check_is_fitted
+from ._hash import FeatureHasher
+from ._stop_words import ENGLISH_STOP_WORDS
+
+__all__ = [
+    "HashingVectorizer",
+    "CountVectorizer",
+    "ENGLISH_STOP_WORDS",
+    "TfidfTransformer",
+    "TfidfVectorizer",
+    "strip_accents_ascii",
+    "strip_accents_unicode",
+    "strip_tags",
+]
+
+
+def _preprocess(doc, accent_function=None, lower=False):
+    """Chain together an optional series of text preprocessing steps to
+    apply to a document.
+
+    Parameters
+    ----------
+    doc: str
+        The string to preprocess
+    accent_function: callable, default=None
+        Function for handling accented characters. Common strategies include
+        normalizing and removing.
+    lower: bool, default=False
+        Whether to use str.lower to lowercase all of the text
+
+    Returns
+    -------
+    doc: str
+        preprocessed string
+    """
+    if lower:
+        doc = doc.lower()
+    if accent_function is not None:
+        doc = accent_function(doc)
+    return doc
+
+
+def _analyze(
+    doc,
+    analyzer=None,
+    tokenizer=None,
+    ngrams=None,
+    preprocessor=None,
+    decoder=None,
+    stop_words=None,
+):
+    """Chain together an optional series of text processing steps to go from
+    a single document to ngrams, with or without tokenizing or preprocessing.
+
+    If analyzer is used, only the decoder argument is used, as the analyzer is
+    intended to replace the preprocessor, tokenizer, and ngrams steps.
+
+    Parameters
+    ----------
+    analyzer: callable, default=None
+    tokenizer: callable, default=None
+    ngrams: callable, default=None
+    preprocessor: callable, default=None
+    decoder: callable, default=None
+    stop_words: list, default=None
+
+    Returns
+    -------
+    ngrams: list
+        A sequence of tokens, possibly with pairs, triples, etc.
+    """
+
+    if decoder is not None:
+        doc = decoder(doc)
+    if analyzer is not None:
+        doc = analyzer(doc)
+    else:
+        if preprocessor is not None:
+            doc = preprocessor(doc)
+        if tokenizer is not None:
+            doc = tokenizer(doc)
+        if ngrams is not None:
+            if stop_words is not None:
+                doc = ngrams(doc, stop_words)
+            else:
+                doc = ngrams(doc)
+    return doc
+
+
+def strip_accents_unicode(s):
+    """Transform accentuated unicode symbols into their simple counterpart.
+
+    Warning: the python-level loop and join operations make this
+    implementation 20 times slower than the strip_accents_ascii basic
+    normalization.
+
+    Parameters
+    ----------
+    s : str
+        The string to strip.
+
+    Returns
+    -------
+    s : str
+        The stripped string.
+
+    See Also
+    --------
+    strip_accents_ascii : Remove accentuated char for any unicode symbol that
+        has a direct ASCII equivalent.
+    """
+    try:
+        # If `s` is ASCII-compatible, then it does not contain any accented
+        # characters and we can avoid an expensive list comprehension
+        s.encode("ASCII", errors="strict")
+        return s
+    except UnicodeEncodeError:
+        normalized = unicodedata.normalize("NFKD", s)
+        return "".join([c for c in normalized if not unicodedata.combining(c)])
+
+
+def strip_accents_ascii(s):
+    """Transform accentuated unicode symbols into ascii or nothing.
+
+    Warning: this solution is only suited for languages that have a direct
+    transliteration to ASCII symbols.
+
+    Parameters
+    ----------
+    s : str
+        The string to strip.
+
+    Returns
+    -------
+    s : str
+        The stripped string.
+
+    See Also
+    --------
+    strip_accents_unicode : Remove accentuated char for any unicode symbol.
+    """
+    nkfd_form = unicodedata.normalize("NFKD", s)
+    return nkfd_form.encode("ASCII", "ignore").decode("ASCII")
+
+
+def strip_tags(s):
+    """Basic regexp based HTML / XML tag stripper function.
+
+    For serious HTML/XML preprocessing you should rather use an external
+    library such as lxml or BeautifulSoup.
+
+    Parameters
+    ----------
+    s : str
+        The string to strip.
+
+    Returns
+    -------
+    s : str
+        The stripped string.
+    """
+    return re.compile(r"<([^>]+)>", flags=re.UNICODE).sub(" ", s)
+
+
+def _check_stop_list(stop):
+    if stop == "english":
+        return ENGLISH_STOP_WORDS
+    elif isinstance(stop, str):
+        raise ValueError("not a built-in stop list: %s" % stop)
+    elif stop is None:
+        return None
+    else:  # assume it's a collection
+        return frozenset(stop)
+
+
+class _VectorizerMixin:
+    """Provides common code for text vectorizers (tokenization logic)."""
+
+    _white_spaces = re.compile(r"\s\s+")
+
+    def decode(self, doc):
+        """Decode the input into a string of unicode symbols.
+
+        The decoding strategy depends on the vectorizer parameters.
+
+        Parameters
+        ----------
+        doc : bytes or str
+            The string to decode.
+
+        Returns
+        -------
+        doc: str
+            A string of unicode symbols.
+        """
+        if self.input == "filename":
+            with open(doc, "rb") as fh:
+                doc = fh.read()
+
+        elif self.input == "file":
+            doc = doc.read()
+
+        if isinstance(doc, bytes):
+            doc = doc.decode(self.encoding, self.decode_error)
+
+        if doc is np.nan:
+            raise ValueError(
+                "np.nan is an invalid document, expected byte or unicode string."
+            )
+
+        return doc
+
+    def _word_ngrams(self, tokens, stop_words=None):
+        """Turn tokens into a sequence of n-grams after stop words filtering"""
+        # handle stop words
+        if stop_words is not None:
+            tokens = [w for w in tokens if w not in stop_words]
+
+        # handle token n-grams
+        min_n, max_n = self.ngram_range
+        if max_n != 1:
+            original_tokens = tokens
+            if min_n == 1:
+                # no need to do any slicing for unigrams
+                # just iterate through the original tokens
+                tokens = list(original_tokens)
+                min_n += 1
+            else:
+                tokens = []
+
+            n_original_tokens = len(original_tokens)
+
+            # bind method outside of loop to reduce overhead
+            tokens_append = tokens.append
+            space_join = " ".join
+
+            for n in range(min_n, min(max_n + 1, n_original_tokens + 1)):
+                for i in range(n_original_tokens - n + 1):
+                    tokens_append(space_join(original_tokens[i : i + n]))
+
+        return tokens
+
+    def _char_ngrams(self, text_document):
+        """Tokenize text_document into a sequence of character n-grams"""
+        # normalize white spaces
+        text_document = self._white_spaces.sub(" ", text_document)
+
+        text_len = len(text_document)
+        min_n, max_n = self.ngram_range
+        if min_n == 1:
+            # no need to do any slicing for unigrams
+            # iterate through the string
+            ngrams = list(text_document)
+            min_n += 1
+        else:
+            ngrams = []
+
+        # bind method outside of loop to reduce overhead
+        ngrams_append = ngrams.append
+
+        for n in range(min_n, min(max_n + 1, text_len + 1)):
+            for i in range(text_len - n + 1):
+                ngrams_append(text_document[i : i + n])
+        return ngrams
+
+    def _char_wb_ngrams(self, text_document):
+        """Whitespace sensitive char-n-gram tokenization.
+
+        Tokenize text_document into a sequence of character n-grams
+        operating only inside word boundaries. n-grams at the edges
+        of words are padded with space."""
+        # normalize white spaces
+        text_document = self._white_spaces.sub(" ", text_document)
+
+        min_n, max_n = self.ngram_range
+        ngrams = []
+
+        # bind method outside of loop to reduce overhead
+        ngrams_append = ngrams.append
+
+        for w in text_document.split():
+            w = " " + w + " "
+            w_len = len(w)
+            for n in range(min_n, max_n + 1):
+                offset = 0
+                ngrams_append(w[offset : offset + n])
+                while offset + n < w_len:
+                    offset += 1
+                    ngrams_append(w[offset : offset + n])
+                if offset == 0:  # count a short word (w_len < n) only once
+                    break
+        return ngrams
+
+    def build_preprocessor(self):
+        """Return a function to preprocess the text before tokenization.
+
+        Returns
+        -------
+        preprocessor: callable
+              A function to preprocess the text before tokenization.
+        """
+        if self.preprocessor is not None:
+            return self.preprocessor
+
+        # accent stripping
+        if not self.strip_accents:
+            strip_accents = None
+        elif callable(self.strip_accents):
+            strip_accents = self.strip_accents
+        elif self.strip_accents == "ascii":
+            strip_accents = strip_accents_ascii
+        elif self.strip_accents == "unicode":
+            strip_accents = strip_accents_unicode
+        else:
+            raise ValueError(
+                'Invalid value for "strip_accents": %s' % self.strip_accents
+            )
+
+        return partial(_preprocess, accent_function=strip_accents, lower=self.lowercase)
+
+    def build_tokenizer(self):
+        """Return a function that splits a string into a sequence of tokens.
+
+        Returns
+        -------
+        tokenizer: callable
+              A function to split a string into a sequence of tokens.
+        """
+        if self.tokenizer is not None:
+            return self.tokenizer
+        token_pattern = re.compile(self.token_pattern)
+
+        if token_pattern.groups > 1:
+            raise ValueError(
+                "More than 1 capturing group in token pattern. Only a single "
+                "group should be captured."
+            )
+
+        return token_pattern.findall
+
+    def get_stop_words(self):
+        """Build or fetch the effective stop words list.
+
+        Returns
+        -------
+        stop_words: list or None
+                A list of stop words.
+        """
+        return _check_stop_list(self.stop_words)
+
+    def _check_stop_words_consistency(self, stop_words, preprocess, tokenize):
+        """Check if stop words are consistent
+
+        Returns
+        -------
+        is_consistent : True if stop words are consistent with the preprocessor
+                        and tokenizer, False if they are not, None if the check
+                        was previously performed, "error" if it could not be
+                        performed (e.g. because of the use of a custom
+                        preprocessor / tokenizer)
+        """
+        if id(self.stop_words) == getattr(self, "_stop_words_id", None):
+            # Stop words are were previously validated
+            return None
+
+        # NB: stop_words is validated, unlike self.stop_words
+        try:
+            inconsistent = set()
+            for w in stop_words or ():
+                tokens = list(tokenize(preprocess(w)))
+                for token in tokens:
+                    if token not in stop_words:
+                        inconsistent.add(token)
+            self._stop_words_id = id(self.stop_words)
+
+            if inconsistent:
+                warnings.warn(
+                    "Your stop_words may be inconsistent with "
+                    "your preprocessing. Tokenizing the stop "
+                    "words generated tokens %r not in "
+                    "stop_words."
+                    % sorted(inconsistent)
+                )
+            return not inconsistent
+        except Exception:
+            # Failed to check stop words consistency (e.g. because a custom
+            # preprocessor or tokenizer was used)
+            self._stop_words_id = id(self.stop_words)
+            return "error"
+
+    def build_analyzer(self):
+        """Return a callable to process input data.
+
+        The callable handles preprocessing, tokenization, and n-grams generation.
+
+        Returns
+        -------
+        analyzer: callable
+            A function to handle preprocessing, tokenization
+            and n-grams generation.
+        """
+
+        if callable(self.analyzer):
+            return partial(_analyze, analyzer=self.analyzer, decoder=self.decode)
+
+        preprocess = self.build_preprocessor()
+
+        if self.analyzer == "char":
+            return partial(
+                _analyze,
+                ngrams=self._char_ngrams,
+                preprocessor=preprocess,
+                decoder=self.decode,
+            )
+
+        elif self.analyzer == "char_wb":
+            return partial(
+                _analyze,
+                ngrams=self._char_wb_ngrams,
+                preprocessor=preprocess,
+                decoder=self.decode,
+            )
+
+        elif self.analyzer == "word":
+            stop_words = self.get_stop_words()
+            tokenize = self.build_tokenizer()
+            self._check_stop_words_consistency(stop_words, preprocess, tokenize)
+            return partial(
+                _analyze,
+                ngrams=self._word_ngrams,
+                tokenizer=tokenize,
+                preprocessor=preprocess,
+                decoder=self.decode,
+                stop_words=stop_words,
+            )
+
+        else:
+            raise ValueError(
+                "%s is not a valid tokenization scheme/analyzer" % self.analyzer
+            )
+
+    def _validate_vocabulary(self):
+        vocabulary = self.vocabulary
+        if vocabulary is not None:
+            if isinstance(vocabulary, set):
+                vocabulary = sorted(vocabulary)
+            if not isinstance(vocabulary, Mapping):
+                vocab = {}
+                for i, t in enumerate(vocabulary):
+                    if vocab.setdefault(t, i) != i:
+                        msg = "Duplicate term in vocabulary: %r" % t
+                        raise ValueError(msg)
+                vocabulary = vocab
+            else:
+                indices = set(vocabulary.values())
+                if len(indices) != len(vocabulary):
+                    raise ValueError("Vocabulary contains repeated indices.")
+                for i in range(len(vocabulary)):
+                    if i not in indices:
+                        msg = "Vocabulary of size %d doesn't contain index %d." % (
+                            len(vocabulary),
+                            i,
+                        )
+                        raise ValueError(msg)
+            if not vocabulary:
+                raise ValueError("empty vocabulary passed to fit")
+            self.fixed_vocabulary_ = True
+            self.vocabulary_ = dict(vocabulary)
+        else:
+            self.fixed_vocabulary_ = False
+
+    def _check_vocabulary(self):
+        """Check if vocabulary is empty or missing (not fitted)"""
+        if not hasattr(self, "vocabulary_"):
+            self._validate_vocabulary()
+            if not self.fixed_vocabulary_:
+                raise NotFittedError("Vocabulary not fitted or provided")
+
+        if len(self.vocabulary_) == 0:
+            raise ValueError("Vocabulary is empty")
+
+    def _validate_ngram_range(self):
+        """Check validity of ngram_range parameter"""
+        min_n, max_m = self.ngram_range
+        if min_n > max_m:
+            raise ValueError(
+                "Invalid value for ngram_range=%s "
+                "lower boundary larger than the upper boundary."
+                % str(self.ngram_range)
+            )
+
+    def _warn_for_unused_params(self):
+        if self.tokenizer is not None and self.token_pattern is not None:
+            warnings.warn(
+                "The parameter 'token_pattern' will not be used"
+                " since 'tokenizer' is not None'"
+            )
+
+        if self.preprocessor is not None and callable(self.analyzer):
+            warnings.warn(
+                "The parameter 'preprocessor' will not be used"
+                " since 'analyzer' is callable'"
+            )
+
+        if (
+            self.ngram_range != (1, 1)
+            and self.ngram_range is not None
+            and callable(self.analyzer)
+        ):
+            warnings.warn(
+                "The parameter 'ngram_range' will not be used"
+                " since 'analyzer' is callable'"
+            )
+        if self.analyzer != "word" or callable(self.analyzer):
+            if self.stop_words is not None:
+                warnings.warn(
+                    "The parameter 'stop_words' will not be used"
+                    " since 'analyzer' != 'word'"
+                )
+            if (
+                self.token_pattern is not None
+                and self.token_pattern != r"(?u)\b\w\w+\b"
+            ):
+                warnings.warn(
+                    "The parameter 'token_pattern' will not be used"
+                    " since 'analyzer' != 'word'"
+                )
+            if self.tokenizer is not None:
+                warnings.warn(
+                    "The parameter 'tokenizer' will not be used"
+                    " since 'analyzer' != 'word'"
+                )
+
+
+class HashingVectorizer(
+    TransformerMixin, _VectorizerMixin, BaseEstimator, auto_wrap_output_keys=None
+):
+    r"""Convert a collection of text documents to a matrix of token occurrences.
+
+    It turns a collection of text documents into a scipy.sparse matrix holding
+    token occurrence counts (or binary occurrence information), possibly
+    normalized as token frequencies if norm='l1' or projected on the euclidean
+    unit sphere if norm='l2'.
+
+    This text vectorizer implementation uses the hashing trick to find the
+    token string name to feature integer index mapping.
+
+    This strategy has several advantages:
+
+    - it is very low memory scalable to large datasets as there is no need to
+      store a vocabulary dictionary in memory.
+
+    - it is fast to pickle and un-pickle as it holds no state besides the
+      constructor parameters.
+
+    - it can be used in a streaming (partial fit) or parallel pipeline as there
+      is no state computed during fit.
+
+    There are also a couple of cons (vs using a CountVectorizer with an
+    in-memory vocabulary):
+
+    - there is no way to compute the inverse transform (from feature indices to
+      string feature names) which can be a problem when trying to introspect
+      which features are most important to a model.
+
+    - there can be collisions: distinct tokens can be mapped to the same
+      feature index. However in practice this is rarely an issue if n_features
+      is large enough (e.g. 2 ** 18 for text classification problems).
+
+    - no IDF weighting as this would render the transformer stateful.
+
+    The hash function employed is the signed 32-bit version of Murmurhash3.
+
+    For an efficiency comparison of the different feature extractors, see
+    :ref:`sphx_glr_auto_examples_text_plot_hashing_vs_dict_vectorizer.py`.
+
+    Read more in the :ref:`User Guide <text_feature_extraction>`.
+
+    Parameters
+    ----------
+    input : {'filename', 'file', 'content'}, default='content'
+        - If `'filename'`, the sequence passed as an argument to fit is
+          expected to be a list of filenames that need reading to fetch
+          the raw content to analyze.
+
+        - If `'file'`, the sequence items must have a 'read' method (file-like
+          object) that is called to fetch the bytes in memory.
+
+        - If `'content'`, the input is expected to be a sequence of items that
+          can be of type string or byte.
+
+    encoding : str, default='utf-8'
+        If bytes or files are given to analyze, this encoding is used to
+        decode.
+
+    decode_error : {'strict', 'ignore', 'replace'}, default='strict'
+        Instruction on what to do if a byte sequence is given to analyze that
+        contains characters not of the given `encoding`. By default, it is
+        'strict', meaning that a UnicodeDecodeError will be raised. Other
+        values are 'ignore' and 'replace'.
+
+    strip_accents : {'ascii', 'unicode'} or callable, default=None
+        Remove accents and perform other character normalization
+        during the preprocessing step.
+        'ascii' is a fast method that only works on characters that have
+        a direct ASCII mapping.
+        'unicode' is a slightly slower method that works on any character.
+        None (default) means no character normalization is performed.
+
+        Both 'ascii' and 'unicode' use NFKD normalization from
+        :func:`unicodedata.normalize`.
+
+    lowercase : bool, default=True
+        Convert all characters to lowercase before tokenizing.
+
+    preprocessor : callable, default=None
+        Override the preprocessing (string transformation) stage while
+        preserving the tokenizing and n-grams generation steps.
+        Only applies if ``analyzer`` is not callable.
+
+    tokenizer : callable, default=None
+        Override the string tokenization step while preserving the
+        preprocessing and n-grams generation steps.
+        Only applies if ``analyzer == 'word'``.
+
+    stop_words : {'english'}, list, default=None
+        If 'english', a built-in stop word list for English is used.
+        There are several known issues with 'english' and you should
+        consider an alternative (see :ref:`stop_words`).
+
+        If a list, that list is assumed to contain stop words, all of which
+        will be removed from the resulting tokens.
+        Only applies if ``analyzer == 'word'``.
+
+    token_pattern : str or None, default=r"(?u)\\b\\w\\w+\\b"
+        Regular expression denoting what constitutes a "token", only used
+        if ``analyzer == 'word'``. The default regexp selects tokens of 2
+        or more alphanumeric characters (punctuation is completely ignored
+        and always treated as a token separator).
+
+        If there is a capturing group in token_pattern then the
+        captured group content, not the entire match, becomes the token.
+        At most one capturing group is permitted.
+
+    ngram_range : tuple (min_n, max_n), default=(1, 1)
+        The lower and upper boundary of the range of n-values for different
+        n-grams to be extracted. All values of n such that min_n <= n <= max_n
+        will be used. For example an ``ngram_range`` of ``(1, 1)`` means only
+        unigrams, ``(1, 2)`` means unigrams and bigrams, and ``(2, 2)`` means
+        only bigrams.
+        Only applies if ``analyzer`` is not callable.
+
+    analyzer : {'word', 'char', 'char_wb'} or callable, default='word'
+        Whether the feature should be made of word or character n-grams.
+        Option 'char_wb' creates character n-grams only from text inside
+        word boundaries; n-grams at the edges of words are padded with space.
+
+        If a callable is passed it is used to extract the sequence of features
+        out of the raw, unprocessed input.
+
+        .. versionchanged:: 0.21
+            Since v0.21, if ``input`` is ``'filename'`` or ``'file'``, the data
+            is first read from the file and then passed to the given callable
+            analyzer.
+
+    n_features : int, default=(2 ** 20)
+        The number of features (columns) in the output matrices. Small numbers
+        of features are likely to cause hash collisions, but large numbers
+        will cause larger coefficient dimensions in linear learners.
+
+    binary : bool, default=False
+        If True, all non zero counts are set to 1. This is useful for discrete
+        probabilistic models that model binary events rather than integer
+        counts.
+
+    norm : {'l1', 'l2'}, default='l2'
+        Norm used to normalize term vectors. None for no normalization.
+
+    alternate_sign : bool, default=True
+        When True, an alternating sign is added to the features as to
+        approximately conserve the inner product in the hashed space even for
+        small n_features. This approach is similar to sparse random projection.
+
+        .. versionadded:: 0.19
+
+    dtype : type, default=np.float64
+        Type of the matrix returned by fit_transform() or transform().
+
+    See Also
+    --------
+    CountVectorizer : Convert a collection of text documents to a matrix of
+        token counts.
+    TfidfVectorizer : Convert a collection of raw documents to a matrix of
+        TF-IDF features.
+
+    Notes
+    -----
+    This estimator is :term:`stateless` and does not need to be fitted.
+    However, we recommend to call :meth:`fit_transform` instead of
+    :meth:`transform`, as parameter validation is only performed in
+    :meth:`fit`.
+
+    Examples
+    --------
+    >>> from sklearn.feature_extraction.text import HashingVectorizer
+    >>> corpus = [
+    ...     'This is the first document.',
+    ...     'This document is the second document.',
+    ...     'And this is the third one.',
+    ...     'Is this the first document?',
+    ... ]
+    >>> vectorizer = HashingVectorizer(n_features=2**4)
+    >>> X = vectorizer.fit_transform(corpus)
+    >>> print(X.shape)
+    (4, 16)
+    """
+
+    _parameter_constraints: dict = {
+        "input": [StrOptions({"filename", "file", "content"})],
+        "encoding": [str],
+        "decode_error": [StrOptions({"strict", "ignore", "replace"})],
+        "strip_accents": [StrOptions({"ascii", "unicode"}), None, callable],
+        "lowercase": ["boolean"],
+        "preprocessor": [callable, None],
+        "tokenizer": [callable, None],
+        "stop_words": [StrOptions({"english"}), list, None],
+        "token_pattern": [str, None],
+        "ngram_range": [tuple],
+        "analyzer": [StrOptions({"word", "char", "char_wb"}), callable],
+        "n_features": [Interval(Integral, 1, np.iinfo(np.int32).max, closed="left")],
+        "binary": ["boolean"],
+        "norm": [StrOptions({"l1", "l2"}), None],
+        "alternate_sign": ["boolean"],
+        "dtype": "no_validation",  # delegate to numpy
+    }
+
+    def __init__(
+        self,
+        *,
+        input="content",
+        encoding="utf-8",
+        decode_error="strict",
+        strip_accents=None,
+        lowercase=True,
+        preprocessor=None,
+        tokenizer=None,
+        stop_words=None,
+        token_pattern=r"(?u)\b\w\w+\b",
+        ngram_range=(1, 1),
+        analyzer="word",
+        n_features=(2**20),
+        binary=False,
+        norm="l2",
+        alternate_sign=True,
+        dtype=np.float64,
+    ):
+        self.input = input
+        self.encoding = encoding
+        self.decode_error = decode_error
+        self.strip_accents = strip_accents
+        self.preprocessor = preprocessor
+        self.tokenizer = tokenizer
+        self.analyzer = analyzer
+        self.lowercase = lowercase
+        self.token_pattern = token_pattern
+        self.stop_words = stop_words
+        self.n_features = n_features
+        self.ngram_range = ngram_range
+        self.binary = binary
+        self.norm = norm
+        self.alternate_sign = alternate_sign
+        self.dtype = dtype
+
+    @_fit_context(prefer_skip_nested_validation=True)
+    def partial_fit(self, X, y=None):
+        """Only validates estimator's parameters.
+
+        This method allows to: (i) validate the estimator's parameters and
+        (ii) be consistent with the scikit-learn transformer API.
+
+        Parameters
+        ----------
+        X : ndarray of shape [n_samples, n_features]
+            Training data.
+
+        y : Ignored
+            Not used, present for API consistency by convention.
+
+        Returns
+        -------
+        self : object
+            HashingVectorizer instance.
+        """
+        return self
+
+    @_fit_context(prefer_skip_nested_validation=True)
+    def fit(self, X, y=None):
+        """Only validates estimator's parameters.
+
+        This method allows to: (i) validate the estimator's parameters and
+        (ii) be consistent with the scikit-learn transformer API.
+
+        Parameters
+        ----------
+        X : ndarray of shape [n_samples, n_features]
+            Training data.
+
+        y : Ignored
+            Not used, present for API consistency by convention.
+
+        Returns
+        -------
+        self : object
+            HashingVectorizer instance.
+        """
+        # triggers a parameter validation
+        if isinstance(X, str):
+            raise ValueError(
+                "Iterable over raw text documents expected, string object received."
+            )
+
+        self._warn_for_unused_params()
+        self._validate_ngram_range()
+
+        self._get_hasher().fit(X, y=y)
+        return self
+
+    def transform(self, X):
+        """Transform a sequence of documents to a document-term matrix.
+
+        Parameters
+        ----------
+        X : iterable over raw text documents, length = n_samples
+            Samples. Each sample must be a text document (either bytes or
+            unicode strings, file name or file object depending on the
+            constructor argument) which will be tokenized and hashed.
+
+        Returns
+        -------
+        X : sparse matrix of shape (n_samples, n_features)
+            Document-term matrix.
+        """
+        if isinstance(X, str):
+            raise ValueError(
+                "Iterable over raw text documents expected, string object received."
+            )
+
+        self._validate_ngram_range()
+
+        analyzer = self.build_analyzer()
+        X = self._get_hasher().transform(analyzer(doc) for doc in X)
+        if self.binary:
+            X.data.fill(1)
+        if self.norm is not None:
+            X = normalize(X, norm=self.norm, copy=False)
+        return X
+
+    def fit_transform(self, X, y=None):
+        """Transform a sequence of documents to a document-term matrix.
+
+        Parameters
+        ----------
+        X : iterable over raw text documents, length = n_samples
+            Samples. Each sample must be a text document (either bytes or
+            unicode strings, file name or file object depending on the
+            constructor argument) which will be tokenized and hashed.
+        y : any
+            Ignored. This parameter exists only for compatibility with
+            sklearn.pipeline.Pipeline.
+
+        Returns
+        -------
+        X : sparse matrix of shape (n_samples, n_features)
+            Document-term matrix.
+        """
+        return self.fit(X, y).transform(X)
+
+    def _get_hasher(self):
+        return FeatureHasher(
+            n_features=self.n_features,
+            input_type="string",
+            dtype=self.dtype,
+            alternate_sign=self.alternate_sign,
+        )
+
+    def _more_tags(self):
+        return {"X_types": ["string"]}
+
+
+def _document_frequency(X):
+    """Count the number of non-zero values for each feature in sparse X."""
+    if sp.issparse(X) and X.format == "csr":
+        return np.bincount(X.indices, minlength=X.shape[1])
+    else:
+        return np.diff(X.indptr)
+
+
+class CountVectorizer(_VectorizerMixin, BaseEstimator):
+    r"""Convert a collection of text documents to a matrix of token counts.
+
+    This implementation produces a sparse representation of the counts using
+    scipy.sparse.csr_matrix.
+
+    If you do not provide an a-priori dictionary and you do not use an analyzer
+    that does some kind of feature selection then the number of features will
+    be equal to the vocabulary size found by analyzing the data.
+
+    For an efficiency comparison of the different feature extractors, see
+    :ref:`sphx_glr_auto_examples_text_plot_hashing_vs_dict_vectorizer.py`.
+
+    Read more in the :ref:`User Guide <text_feature_extraction>`.
+
+    Parameters
+    ----------
+    input : {'filename', 'file', 'content'}, default='content'
+        - If `'filename'`, the sequence passed as an argument to fit is
+          expected to be a list of filenames that need reading to fetch
+          the raw content to analyze.
+
+        - If `'file'`, the sequence items must have a 'read' method (file-like
+          object) that is called to fetch the bytes in memory.
+
+        - If `'content'`, the input is expected to be a sequence of items that
+          can be of type string or byte.
+
+    encoding : str, default='utf-8'
+        If bytes or files are given to analyze, this encoding is used to
+        decode.
+
+    decode_error : {'strict', 'ignore', 'replace'}, default='strict'
+        Instruction on what to do if a byte sequence is given to analyze that
+        contains characters not of the given `encoding`. By default, it is
+        'strict', meaning that a UnicodeDecodeError will be raised. Other
+        values are 'ignore' and 'replace'.
+
+    strip_accents : {'ascii', 'unicode'} or callable, default=None
+        Remove accents and perform other character normalization
+        during the preprocessing step.
+        'ascii' is a fast method that only works on characters that have
+        a direct ASCII mapping.
+        'unicode' is a slightly slower method that works on any characters.
+        None (default) means no character normalization is performed.
+
+        Both 'ascii' and 'unicode' use NFKD normalization from
+        :func:`unicodedata.normalize`.
+
+    lowercase : bool, default=True
+        Convert all characters to lowercase before tokenizing.
+
+    preprocessor : callable, default=None
+        Override the preprocessing (strip_accents and lowercase) stage while
+        preserving the tokenizing and n-grams generation steps.
+        Only applies if ``analyzer`` is not callable.
+
+    tokenizer : callable, default=None
+        Override the string tokenization step while preserving the
+        preprocessing and n-grams generation steps.
+        Only applies if ``analyzer == 'word'``.
+
+    stop_words : {'english'}, list, default=None
+        If 'english', a built-in stop word list for English is used.
+        There are several known issues with 'english' and you should
+        consider an alternative (see :ref:`stop_words`).
+
+        If a list, that list is assumed to contain stop words, all of which
+        will be removed from the resulting tokens.
+        Only applies if ``analyzer == 'word'``.
+
+        If None, no stop words will be used. In this case, setting `max_df`
+        to a higher value, such as in the range (0.7, 1.0), can automatically detect
+        and filter stop words based on intra corpus document frequency of terms.
+
+    token_pattern : str or None, default=r"(?u)\\b\\w\\w+\\b"
+        Regular expression denoting what constitutes a "token", only used
+        if ``analyzer == 'word'``. The default regexp select tokens of 2
+        or more alphanumeric characters (punctuation is completely ignored
+        and always treated as a token separator).
+
+        If there is a capturing group in token_pattern then the
+        captured group content, not the entire match, becomes the token.
+        At most one capturing group is permitted.
+
+    ngram_range : tuple (min_n, max_n), default=(1, 1)
+        The lower and upper boundary of the range of n-values for different
+        word n-grams or char n-grams to be extracted. All values of n such
+        such that min_n <= n <= max_n will be used. For example an
+        ``ngram_range`` of ``(1, 1)`` means only unigrams, ``(1, 2)`` means
+        unigrams and bigrams, and ``(2, 2)`` means only bigrams.
+        Only applies if ``analyzer`` is not callable.
+
+    analyzer : {'word', 'char', 'char_wb'} or callable, default='word'
+        Whether the feature should be made of word n-gram or character
+        n-grams.
+        Option 'char_wb' creates character n-grams only from text inside
+        word boundaries; n-grams at the edges of words are padded with space.
+
+        If a callable is passed it is used to extract the sequence of features
+        out of the raw, unprocessed input.
+
+        .. versionchanged:: 0.21
+
+        Since v0.21, if ``input`` is ``filename`` or ``file``, the data is
+        first read from the file and then passed to the given callable
+        analyzer.
+
+    max_df : float in range [0.0, 1.0] or int, default=1.0
+        When building the vocabulary ignore terms that have a document
+        frequency strictly higher than the given threshold (corpus-specific
+        stop words).
+        If float, the parameter represents a proportion of documents, integer
+        absolute counts.
+        This parameter is ignored if vocabulary is not None.
+
+    min_df : float in range [0.0, 1.0] or int, default=1
+        When building the vocabulary ignore terms that have a document
+        frequency strictly lower than the given threshold. This value is also
+        called cut-off in the literature.
+        If float, the parameter represents a proportion of documents, integer
+        absolute counts.
+        This parameter is ignored if vocabulary is not None.
+
+    max_features : int, default=None
+        If not None, build a vocabulary that only consider the top
+        `max_features` ordered by term frequency across the corpus.
+        Otherwise, all features are used.
+
+        This parameter is ignored if vocabulary is not None.
+
+    vocabulary : Mapping or iterable, default=None
+        Either a Mapping (e.g., a dict) where keys are terms and values are
+        indices in the feature matrix, or an iterable over terms. If not
+        given, a vocabulary is determined from the input documents. Indices
+        in the mapping should not be repeated and should not have any gap
+        between 0 and the largest index.
+
+    binary : bool, default=False
+        If True, all non zero counts are set to 1. This is useful for discrete
+        probabilistic models that model binary events rather than integer
+        counts.
+
+    dtype : dtype, default=np.int64
+        Type of the matrix returned by fit_transform() or transform().
+
+    Attributes
+    ----------
+    vocabulary_ : dict
+        A mapping of terms to feature indices.
+
+    fixed_vocabulary_ : bool
+        True if a fixed vocabulary of term to indices mapping
+        is provided by the user.
+
+    stop_words_ : set
+        Terms that were ignored because they either:
+
+          - occurred in too many documents (`max_df`)
+          - occurred in too few documents (`min_df`)
+          - were cut off by feature selection (`max_features`).
+
+        This is only available if no vocabulary was given.
+
+    See Also
+    --------
+    HashingVectorizer : Convert a collection of text documents to a
+        matrix of token counts.
+
+    TfidfVectorizer : Convert a collection of raw documents to a matrix
+        of TF-IDF features.
+
+    Notes
+    -----
+    The ``stop_words_`` attribute can get large and increase the model size
+    when pickling. This attribute is provided only for introspection and can
+    be safely removed using delattr or set to None before pickling.
+
+    Examples
+    --------
+    >>> from sklearn.feature_extraction.text import CountVectorizer
+    >>> corpus = [
+    ...     'This is the first document.',
+    ...     'This document is the second document.',
+    ...     'And this is the third one.',
+    ...     'Is this the first document?',
+    ... ]
+    >>> vectorizer = CountVectorizer()
+    >>> X = vectorizer.fit_transform(corpus)
+    >>> vectorizer.get_feature_names_out()
+    array(['and', 'document', 'first', 'is', 'one', 'second', 'the', 'third',
+           'this'], ...)
+    >>> print(X.toarray())
+    [[0 1 1 1 0 0 1 0 1]
+     [0 2 0 1 0 1 1 0 1]
+     [1 0 0 1 1 0 1 1 1]
+     [0 1 1 1 0 0 1 0 1]]
+    >>> vectorizer2 = CountVectorizer(analyzer='word', ngram_range=(2, 2))
+    >>> X2 = vectorizer2.fit_transform(corpus)
+    >>> vectorizer2.get_feature_names_out()
+    array(['and this', 'document is', 'first document', 'is the', 'is this',
+           'second document', 'the first', 'the second', 'the third', 'third one',
+           'this document', 'this is', 'this the'], ...)
+     >>> print(X2.toarray())
+     [[0 0 1 1 0 0 1 0 0 0 0 1 0]
+     [0 1 0 1 0 1 0 1 0 0 1 0 0]
+     [1 0 0 1 0 0 0 0 1 1 0 1 0]
+     [0 0 1 0 1 0 1 0 0 0 0 0 1]]
+    """
+
+    _parameter_constraints: dict = {
+        "input": [StrOptions({"filename", "file", "content"})],
+        "encoding": [str],
+        "decode_error": [StrOptions({"strict", "ignore", "replace"})],
+        "strip_accents": [StrOptions({"ascii", "unicode"}), None, callable],
+        "lowercase": ["boolean"],
+        "preprocessor": [callable, None],
+        "tokenizer": [callable, None],
+        "stop_words": [StrOptions({"english"}), list, None],
+        "token_pattern": [str, None],
+        "ngram_range": [tuple],
+        "analyzer": [StrOptions({"word", "char", "char_wb"}), callable],
+        "max_df": [
+            Interval(RealNotInt, 0, 1, closed="both"),
+            Interval(Integral, 1, None, closed="left"),
+        ],
+        "min_df": [
+            Interval(RealNotInt, 0, 1, closed="both"),
+            Interval(Integral, 1, None, closed="left"),
+        ],
+        "max_features": [Interval(Integral, 1, None, closed="left"), None],
+        "vocabulary": [Mapping, HasMethods("__iter__"), None],
+        "binary": ["boolean"],
+        "dtype": "no_validation",  # delegate to numpy
+    }
+
+    def __init__(
+        self,
+        *,
+        input="content",
+        encoding="utf-8",
+        decode_error="strict",
+        strip_accents=None,
+        lowercase=True,
+        preprocessor=None,
+        tokenizer=None,
+        stop_words=None,
+        token_pattern=r"(?u)\b\w\w+\b",
+        ngram_range=(1, 1),
+        analyzer="word",
+        max_df=1.0,
+        min_df=1,
+        max_features=None,
+        vocabulary=None,
+        binary=False,
+        dtype=np.int64,
+    ):
+        self.input = input
+        self.encoding = encoding
+        self.decode_error = decode_error
+        self.strip_accents = strip_accents
+        self.preprocessor = preprocessor
+        self.tokenizer = tokenizer
+        self.analyzer = analyzer
+        self.lowercase = lowercase
+        self.token_pattern = token_pattern
+        self.stop_words = stop_words
+        self.max_df = max_df
+        self.min_df = min_df
+        self.max_features = max_features
+        self.ngram_range = ngram_range
+        self.vocabulary = vocabulary
+        self.binary = binary
+        self.dtype = dtype
+
+    def _sort_features(self, X, vocabulary):
+        """Sort features by name
+
+        Returns a reordered matrix and modifies the vocabulary in place
+        """
+        sorted_features = sorted(vocabulary.items())
+        map_index = np.empty(len(sorted_features), dtype=X.indices.dtype)
+        for new_val, (term, old_val) in enumerate(sorted_features):
+            vocabulary[term] = new_val
+            map_index[old_val] = new_val
+
+        X.indices = map_index.take(X.indices, mode="clip")
+        return X
+
+    def _limit_features(self, X, vocabulary, high=None, low=None, limit=None):
+        """Remove too rare or too common features.
+
+        Prune features that are non zero in more samples than high or less
+        documents than low, modifying the vocabulary, and restricting it to
+        at most the limit most frequent.
+
+        This does not prune samples with zero features.
+        """
+        if high is None and low is None and limit is None:
+            return X, set()
+
+        # Calculate a mask based on document frequencies
+        dfs = _document_frequency(X)
+        mask = np.ones(len(dfs), dtype=bool)
+        if high is not None:
+            mask &= dfs <= high
+        if low is not None:
+            mask &= dfs >= low
+        if limit is not None and mask.sum() > limit:
+            tfs = np.asarray(X.sum(axis=0)).ravel()
+            mask_inds = (-tfs[mask]).argsort()[:limit]
+            new_mask = np.zeros(len(dfs), dtype=bool)
+            new_mask[np.where(mask)[0][mask_inds]] = True
+            mask = new_mask
+
+        new_indices = np.cumsum(mask) - 1  # maps old indices to new
+        removed_terms = set()
+        for term, old_index in list(vocabulary.items()):
+            if mask[old_index]:
+                vocabulary[term] = new_indices[old_index]
+            else:
+                del vocabulary[term]
+                removed_terms.add(term)
+        kept_indices = np.where(mask)[0]
+        if len(kept_indices) == 0:
+            raise ValueError(
+                "After pruning, no terms remain. Try a lower min_df or a higher max_df."
+            )
+        return X[:, kept_indices], removed_terms
+
+    def _count_vocab(self, raw_documents, fixed_vocab):
+        """Create sparse feature matrix, and vocabulary where fixed_vocab=False"""
+        if fixed_vocab:
+            vocabulary = self.vocabulary_
+        else:
+            # Add a new value when a new vocabulary item is seen
+            vocabulary = defaultdict()
+            vocabulary.default_factory = vocabulary.__len__
+
+        analyze = self.build_analyzer()
+        j_indices = []
+        indptr = []
+
+        values = _make_int_array()
+        indptr.append(0)
+        for doc in raw_documents:
+            feature_counter = {}
+            for feature in analyze(doc):
+                try:
+                    feature_idx = vocabulary[feature]
+                    if feature_idx not in feature_counter:
+                        feature_counter[feature_idx] = 1
+                    else:
+                        feature_counter[feature_idx] += 1
+                except KeyError:
+                    # Ignore out-of-vocabulary items for fixed_vocab=True
+                    continue
+
+            j_indices.extend(feature_counter.keys())
+            values.extend(feature_counter.values())
+            indptr.append(len(j_indices))
+
+        if not fixed_vocab:
+            # disable defaultdict behaviour
+            vocabulary = dict(vocabulary)
+            if not vocabulary:
+                raise ValueError(
+                    "empty vocabulary; perhaps the documents only contain stop words"
+                )
+
+        if indptr[-1] > np.iinfo(np.int32).max:  # = 2**31 - 1
+            if _IS_32BIT:
+                raise ValueError(
+                    (
+                        "sparse CSR array has {} non-zero "
+                        "elements and requires 64 bit indexing, "
+                        "which is unsupported with 32 bit Python."
+                    ).format(indptr[-1])
+                )
+            indices_dtype = np.int64
+
+        else:
+            indices_dtype = np.int32
+        j_indices = np.asarray(j_indices, dtype=indices_dtype)
+        indptr = np.asarray(indptr, dtype=indices_dtype)
+        values = np.frombuffer(values, dtype=np.intc)
+
+        X = sp.csr_matrix(
+            (values, j_indices, indptr),
+            shape=(len(indptr) - 1, len(vocabulary)),
+            dtype=self.dtype,
+        )
+        X.sort_indices()
+        return vocabulary, X
+
+    def fit(self, raw_documents, y=None):
+        """Learn a vocabulary dictionary of all tokens in the raw documents.
+
+        Parameters
+        ----------
+        raw_documents : iterable
+            An iterable which generates either str, unicode or file objects.
+
+        y : None
+            This parameter is ignored.
+
+        Returns
+        -------
+        self : object
+            Fitted vectorizer.
+        """
+        self.fit_transform(raw_documents)
+        return self
+
+    @_fit_context(prefer_skip_nested_validation=True)
+    def fit_transform(self, raw_documents, y=None):
+        """Learn the vocabulary dictionary and return document-term matrix.
+
+        This is equivalent to fit followed by transform, but more efficiently
+        implemented.
+
+        Parameters
+        ----------
+        raw_documents : iterable
+            An iterable which generates either str, unicode or file objects.
+
+        y : None
+            This parameter is ignored.
+
+        Returns
+        -------
+        X : array of shape (n_samples, n_features)
+            Document-term matrix.
+        """
+        # We intentionally don't call the transform method to make
+        # fit_transform overridable without unwanted side effects in
+        # TfidfVectorizer.
+        if isinstance(raw_documents, str):
+            raise ValueError(
+                "Iterable over raw text documents expected, string object received."
+            )
+
+        self._validate_ngram_range()
+        self._warn_for_unused_params()
+        self._validate_vocabulary()
+        max_df = self.max_df
+        min_df = self.min_df
+        max_features = self.max_features
+
+        if self.fixed_vocabulary_ and self.lowercase:
+            for term in self.vocabulary:
+                if any(map(str.isupper, term)):
+                    warnings.warn(
+                        "Upper case characters found in"
+                        " vocabulary while 'lowercase'"
+                        " is True. These entries will not"
+                        " be matched with any documents"
+                    )
+                    break
+
+        vocabulary, X = self._count_vocab(raw_documents, self.fixed_vocabulary_)
+
+        if self.binary:
+            X.data.fill(1)
+
+        if not self.fixed_vocabulary_:
+            n_doc = X.shape[0]
+            max_doc_count = max_df if isinstance(max_df, Integral) else max_df * n_doc
+            min_doc_count = min_df if isinstance(min_df, Integral) else min_df * n_doc
+            if max_doc_count < min_doc_count:
+                raise ValueError("max_df corresponds to < documents than min_df")
+            if max_features is not None:
+                X = self._sort_features(X, vocabulary)
+            X, self.stop_words_ = self._limit_features(
+                X, vocabulary, max_doc_count, min_doc_count, max_features
+            )
+            if max_features is None:
+                X = self._sort_features(X, vocabulary)
+            self.vocabulary_ = vocabulary
+
+        return X
+
+    def transform(self, raw_documents):
+        """Transform documents to document-term matrix.
+
+        Extract token counts out of raw text documents using the vocabulary
+        fitted with fit or the one provided to the constructor.
+
+        Parameters
+        ----------
+        raw_documents : iterable
+            An iterable which generates either str, unicode or file objects.
+
+        Returns
+        -------
+        X : sparse matrix of shape (n_samples, n_features)
+            Document-term matrix.
+        """
+        if isinstance(raw_documents, str):
+            raise ValueError(
+                "Iterable over raw text documents expected, string object received."
+            )
+        self._check_vocabulary()
+
+        # use the same matrix-building strategy as fit_transform
+        _, X = self._count_vocab(raw_documents, fixed_vocab=True)
+        if self.binary:
+            X.data.fill(1)
+        return X
+
+    def inverse_transform(self, X):
+        """Return terms per document with nonzero entries in X.
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} of shape (n_samples, n_features)
+            Document-term matrix.
+
+        Returns
+        -------
+        X_inv : list of arrays of shape (n_samples,)
+            List of arrays of terms.
+        """
+        self._check_vocabulary()
+        # We need CSR format for fast row manipulations.
+        X = check_array(X, accept_sparse="csr")
+        n_samples = X.shape[0]
+
+        terms = np.array(list(self.vocabulary_.keys()))
+        indices = np.array(list(self.vocabulary_.values()))
+        inverse_vocabulary = terms[np.argsort(indices)]
+
+        if sp.issparse(X):
+            return [
+                inverse_vocabulary[X[i, :].nonzero()[1]].ravel()
+                for i in range(n_samples)
+            ]
+        else:
+            return [
+                inverse_vocabulary[np.flatnonzero(X[i, :])].ravel()
+                for i in range(n_samples)
+            ]
+
+    def get_feature_names_out(self, input_features=None):
+        """Get output feature names for transformation.
+
+        Parameters
+        ----------
+        input_features : array-like of str or None, default=None
+            Not used, present here for API consistency by convention.
+
+        Returns
+        -------
+        feature_names_out : ndarray of str objects
+            Transformed feature names.
+        """
+        self._check_vocabulary()
+        return np.asarray(
+            [t for t, i in sorted(self.vocabulary_.items(), key=itemgetter(1))],
+            dtype=object,
+        )
+
+    def _more_tags(self):
+        return {"X_types": ["string"]}
+
+
+def _make_int_array():
+    """Construct an array.array of a type suitable for scipy.sparse indices."""
+    return array.array(str("i"))
+
+
+class TfidfTransformer(
+    OneToOneFeatureMixin, TransformerMixin, BaseEstimator, auto_wrap_output_keys=None
+):
+    """Transform a count matrix to a normalized tf or tf-idf representation.
+
+    Tf means term-frequency while tf-idf means term-frequency times inverse
+    document-frequency. This is a common term weighting scheme in information
+    retrieval, that has also found good use in document classification.
+
+    The goal of using tf-idf instead of the raw frequencies of occurrence of a
+    token in a given document is to scale down the impact of tokens that occur
+    very frequently in a given corpus and that are hence empirically less
+    informative than features that occur in a small fraction of the training
+    corpus.
+
+    The formula that is used to compute the tf-idf for a term t of a document d
+    in a document set is tf-idf(t, d) = tf(t, d) * idf(t), and the idf is
+    computed as idf(t) = log [ n / df(t) ] + 1 (if ``smooth_idf=False``), where
+    n is the total number of documents in the document set and df(t) is the
+    document frequency of t; the document frequency is the number of documents
+    in the document set that contain the term t. The effect of adding "1" to
+    the idf in the equation above is that terms with zero idf, i.e., terms
+    that occur in all documents in a training set, will not be entirely
+    ignored.
+    (Note that the idf formula above differs from the standard textbook
+    notation that defines the idf as
+    idf(t) = log [ n / (df(t) + 1) ]).
+
+    If ``smooth_idf=True`` (the default), the constant "1" is added to the
+    numerator and denominator of the idf as if an extra document was seen
+    containing every term in the collection exactly once, which prevents
+    zero divisions: idf(t) = log [ (1 + n) / (1 + df(t)) ] + 1.
+
+    Furthermore, the formulas used to compute tf and idf depend
+    on parameter settings that correspond to the SMART notation used in IR
+    as follows:
+
+    Tf is "n" (natural) by default, "l" (logarithmic) when
+    ``sublinear_tf=True``.
+    Idf is "t" when use_idf is given, "n" (none) otherwise.
+    Normalization is "c" (cosine) when ``norm='l2'``, "n" (none)
+    when ``norm=None``.
+
+    Read more in the :ref:`User Guide <text_feature_extraction>`.
+
+    Parameters
+    ----------
+    norm : {'l1', 'l2'} or None, default='l2'
+        Each output row will have unit norm, either:
+
+        - 'l2': Sum of squares of vector elements is 1. The cosine
+          similarity between two vectors is their dot product when l2 norm has
+          been applied.
+        - 'l1': Sum of absolute values of vector elements is 1.
+          See :func:`~sklearn.preprocessing.normalize`.
+        - None: No normalization.
+
+    use_idf : bool, default=True
+        Enable inverse-document-frequency reweighting. If False, idf(t) = 1.
+
+    smooth_idf : bool, default=True
+        Smooth idf weights by adding one to document frequencies, as if an
+        extra document was seen containing every term in the collection
+        exactly once. Prevents zero divisions.
+
+    sublinear_tf : bool, default=False
+        Apply sublinear tf scaling, i.e. replace tf with 1 + log(tf).
+
+    Attributes
+    ----------
+    idf_ : array of shape (n_features)
+        The inverse document frequency (IDF) vector; only defined
+        if  ``use_idf`` is True.
+
+        .. versionadded:: 0.20
+
+    n_features_in_ : int
+        Number of features seen during :term:`fit`.
+
+        .. versionadded:: 1.0
+
+    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
+    --------
+    CountVectorizer : Transforms text into a sparse matrix of n-gram counts.
+
+    TfidfVectorizer : Convert a collection of raw documents to a matrix of
+        TF-IDF features.
+
+    HashingVectorizer : Convert a collection of text documents to a matrix
+        of token occurrences.
+
+    References
+    ----------
+    .. [Yates2011] R. Baeza-Yates and B. Ribeiro-Neto (2011). Modern
+                   Information Retrieval. Addison Wesley, pp. 68-74.
+
+    .. [MRS2008] C.D. Manning, P. Raghavan and H. Schütze  (2008).
+                   Introduction to Information Retrieval. Cambridge University
+                   Press, pp. 118-120.
+
+    Examples
+    --------
+    >>> from sklearn.feature_extraction.text import TfidfTransformer
+    >>> from sklearn.feature_extraction.text import CountVectorizer
+    >>> from sklearn.pipeline import Pipeline
+    >>> corpus = ['this is the first document',
+    ...           'this document is the second document',
+    ...           'and this is the third one',
+    ...           'is this the first document']
+    >>> vocabulary = ['this', 'document', 'first', 'is', 'second', 'the',
+    ...               'and', 'one']
+    >>> pipe = Pipeline([('count', CountVectorizer(vocabulary=vocabulary)),
+    ...                  ('tfid', TfidfTransformer())]).fit(corpus)
+    >>> pipe['count'].transform(corpus).toarray()
+    array([[1, 1, 1, 1, 0, 1, 0, 0],
+           [1, 2, 0, 1, 1, 1, 0, 0],
+           [1, 0, 0, 1, 0, 1, 1, 1],
+           [1, 1, 1, 1, 0, 1, 0, 0]])
+    >>> pipe['tfid'].idf_
+    array([1.        , 1.22314355, 1.51082562, 1.        , 1.91629073,
+           1.        , 1.91629073, 1.91629073])
+    >>> pipe.transform(corpus).shape
+    (4, 8)
+    """
+
+    _parameter_constraints: dict = {
+        "norm": [StrOptions({"l1", "l2"}), None],
+        "use_idf": ["boolean"],
+        "smooth_idf": ["boolean"],
+        "sublinear_tf": ["boolean"],
+    }
+
+    def __init__(self, *, norm="l2", use_idf=True, smooth_idf=True, sublinear_tf=False):
+        self.norm = norm
+        self.use_idf = use_idf
+        self.smooth_idf = smooth_idf
+        self.sublinear_tf = sublinear_tf
+
+    @_fit_context(prefer_skip_nested_validation=True)
+    def fit(self, X, y=None):
+        """Learn the idf vector (global term weights).
+
+        Parameters
+        ----------
+        X : sparse matrix of shape (n_samples, n_features)
+            A matrix of term/token counts.
+
+        y : None
+            This parameter is not needed to compute tf-idf.
+
+        Returns
+        -------
+        self : object
+            Fitted transformer.
+        """
+        # large sparse data is not supported for 32bit platforms because
+        # _document_frequency uses np.bincount which works on arrays of
+        # dtype NPY_INTP which is int32 for 32bit platforms. See #20923
+        X = self._validate_data(
+            X, accept_sparse=("csr", "csc"), accept_large_sparse=not _IS_32BIT
+        )
+        if not sp.issparse(X):
+            X = sp.csr_matrix(X)
+        dtype = X.dtype if X.dtype in FLOAT_DTYPES else np.float64
+
+        if self.use_idf:
+            n_samples, n_features = X.shape
+            df = _document_frequency(X)
+            df = df.astype(dtype, copy=False)
+
+            # perform idf smoothing if required
+            df += int(self.smooth_idf)
+            n_samples += int(self.smooth_idf)
+
+            # log+1 instead of log makes sure terms with zero idf don't get
+            # suppressed entirely.
+            idf = np.log(n_samples / df) + 1
+            self._idf_diag = sp.diags(
+                idf,
+                offsets=0,
+                shape=(n_features, n_features),
+                format="csr",
+                dtype=dtype,
+            )
+
+        return self
+
+    def transform(self, X, copy=True):
+        """Transform a count matrix to a tf or tf-idf representation.
+
+        Parameters
+        ----------
+        X : sparse matrix of (n_samples, n_features)
+            A matrix of term/token counts.
+
+        copy : bool, default=True
+            Whether to copy X and operate on the copy or perform in-place
+            operations.
+
+        Returns
+        -------
+        vectors : sparse matrix of shape (n_samples, n_features)
+            Tf-idf-weighted document-term matrix.
+        """
+        X = self._validate_data(
+            X, accept_sparse="csr", dtype=FLOAT_DTYPES, copy=copy, reset=False
+        )
+        if not sp.issparse(X):
+            X = sp.csr_matrix(X, dtype=np.float64)
+
+        if self.sublinear_tf:
+            np.log(X.data, X.data)
+            X.data += 1
+
+        if self.use_idf:
+            # idf_ being a property, the automatic attributes detection
+            # does not work as usual and we need to specify the attribute
+            # name:
+            check_is_fitted(self, attributes=["idf_"], msg="idf vector is not fitted")
+
+            X = X @ self._idf_diag
+
+        if self.norm is not None:
+            X = normalize(X, norm=self.norm, copy=False)
+
+        return X
+
+    @property
+    def idf_(self):
+        """Inverse document frequency vector, only defined if `use_idf=True`.
+
+        Returns
+        -------
+        ndarray of shape (n_features,)
+        """
+        # if _idf_diag is not set, this will raise an attribute error,
+        # which means hasattr(self, "idf_") is False
+        return np.ravel(self._idf_diag.sum(axis=0))
+
+    @idf_.setter
+    def idf_(self, value):
+        value = np.asarray(value, dtype=np.float64)
+        n_features = value.shape[0]
+        self._idf_diag = sp.spdiags(
+            value, diags=0, m=n_features, n=n_features, format="csr"
+        )
+
+    def _more_tags(self):
+        return {"X_types": ["2darray", "sparse"]}
+
+
+class TfidfVectorizer(CountVectorizer):
+    r"""Convert a collection of raw documents to a matrix of TF-IDF features.
+
+    Equivalent to :class:`CountVectorizer` followed by
+    :class:`TfidfTransformer`.
+
+    For an example of usage, see
+    :ref:`sphx_glr_auto_examples_text_plot_document_classification_20newsgroups.py`.
+
+    For an efficiency comparison of the different feature extractors, see
+    :ref:`sphx_glr_auto_examples_text_plot_hashing_vs_dict_vectorizer.py`.
+
+    Read more in the :ref:`User Guide <text_feature_extraction>`.
+
+    Parameters
+    ----------
+    input : {'filename', 'file', 'content'}, default='content'
+        - If `'filename'`, the sequence passed as an argument to fit is
+          expected to be a list of filenames that need reading to fetch
+          the raw content to analyze.
+
+        - If `'file'`, the sequence items must have a 'read' method (file-like
+          object) that is called to fetch the bytes in memory.
+
+        - If `'content'`, the input is expected to be a sequence of items that
+          can be of type string or byte.
+
+    encoding : str, default='utf-8'
+        If bytes or files are given to analyze, this encoding is used to
+        decode.
+
+    decode_error : {'strict', 'ignore', 'replace'}, default='strict'
+        Instruction on what to do if a byte sequence is given to analyze that
+        contains characters not of the given `encoding`. By default, it is
+        'strict', meaning that a UnicodeDecodeError will be raised. Other
+        values are 'ignore' and 'replace'.
+
+    strip_accents : {'ascii', 'unicode'} or callable, default=None
+        Remove accents and perform other character normalization
+        during the preprocessing step.
+        'ascii' is a fast method that only works on characters that have
+        a direct ASCII mapping.
+        'unicode' is a slightly slower method that works on any characters.
+        None (default) means no character normalization is performed.
+
+        Both 'ascii' and 'unicode' use NFKD normalization from
+        :func:`unicodedata.normalize`.
+
+    lowercase : bool, default=True
+        Convert all characters to lowercase before tokenizing.
+
+    preprocessor : callable, default=None
+        Override the preprocessing (string transformation) stage while
+        preserving the tokenizing and n-grams generation steps.
+        Only applies if ``analyzer`` is not callable.
+
+    tokenizer : callable, default=None
+        Override the string tokenization step while preserving the
+        preprocessing and n-grams generation steps.
+        Only applies if ``analyzer == 'word'``.
+
+    analyzer : {'word', 'char', 'char_wb'} or callable, default='word'
+        Whether the feature should be made of word or character n-grams.
+        Option 'char_wb' creates character n-grams only from text inside
+        word boundaries; n-grams at the edges of words are padded with space.
+
+        If a callable is passed it is used to extract the sequence of features
+        out of the raw, unprocessed input.
+
+        .. versionchanged:: 0.21
+            Since v0.21, if ``input`` is ``'filename'`` or ``'file'``, the data
+            is first read from the file and then passed to the given callable
+            analyzer.
+
+    stop_words : {'english'}, list, default=None
+        If a string, it is passed to _check_stop_list and the appropriate stop
+        list is returned. 'english' is currently the only supported string
+        value.
+        There are several known issues with 'english' and you should
+        consider an alternative (see :ref:`stop_words`).
+
+        If a list, that list is assumed to contain stop words, all of which
+        will be removed from the resulting tokens.
+        Only applies if ``analyzer == 'word'``.
+
+        If None, no stop words will be used. In this case, setting `max_df`
+        to a higher value, such as in the range (0.7, 1.0), can automatically detect
+        and filter stop words based on intra corpus document frequency of terms.
+
+    token_pattern : str, default=r"(?u)\\b\\w\\w+\\b"
+        Regular expression denoting what constitutes a "token", only used
+        if ``analyzer == 'word'``. The default regexp selects tokens of 2
+        or more alphanumeric characters (punctuation is completely ignored
+        and always treated as a token separator).
+
+        If there is a capturing group in token_pattern then the
+        captured group content, not the entire match, becomes the token.
+        At most one capturing group is permitted.
+
+    ngram_range : tuple (min_n, max_n), default=(1, 1)
+        The lower and upper boundary of the range of n-values for different
+        n-grams to be extracted. All values of n such that min_n <= n <= max_n
+        will be used. For example an ``ngram_range`` of ``(1, 1)`` means only
+        unigrams, ``(1, 2)`` means unigrams and bigrams, and ``(2, 2)`` means
+        only bigrams.
+        Only applies if ``analyzer`` is not callable.
+
+    max_df : float or int, default=1.0
+        When building the vocabulary ignore terms that have a document
+        frequency strictly higher than the given threshold (corpus-specific
+        stop words).
+        If float in range [0.0, 1.0], the parameter represents a proportion of
+        documents, integer absolute counts.
+        This parameter is ignored if vocabulary is not None.
+
+    min_df : float or int, default=1
+        When building the vocabulary ignore terms that have a document
+        frequency strictly lower than the given threshold. This value is also
+        called cut-off in the literature.
+        If float in range of [0.0, 1.0], the parameter represents a proportion
+        of documents, integer absolute counts.
+        This parameter is ignored if vocabulary is not None.
+
+    max_features : int, default=None
+        If not None, build a vocabulary that only consider the top
+        `max_features` ordered by term frequency across the corpus.
+        Otherwise, all features are used.
+
+        This parameter is ignored if vocabulary is not None.
+
+    vocabulary : Mapping or iterable, default=None
+        Either a Mapping (e.g., a dict) where keys are terms and values are
+        indices in the feature matrix, or an iterable over terms. If not
+        given, a vocabulary is determined from the input documents.
+
+    binary : bool, default=False
+        If True, all non-zero term counts are set to 1. This does not mean
+        outputs will have only 0/1 values, only that the tf term in tf-idf
+        is binary. (Set `binary` to True, `use_idf` to False and
+        `norm` to None to get 0/1 outputs).
+
+    dtype : dtype, default=float64
+        Type of the matrix returned by fit_transform() or transform().
+
+    norm : {'l1', 'l2'} or None, default='l2'
+        Each output row will have unit norm, either:
+
+        - 'l2': Sum of squares of vector elements is 1. The cosine
+          similarity between two vectors is their dot product when l2 norm has
+          been applied.
+        - 'l1': Sum of absolute values of vector elements is 1.
+          See :func:`~sklearn.preprocessing.normalize`.
+        - None: No normalization.
+
+    use_idf : bool, default=True
+        Enable inverse-document-frequency reweighting. If False, idf(t) = 1.
+
+    smooth_idf : bool, default=True
+        Smooth idf weights by adding one to document frequencies, as if an
+        extra document was seen containing every term in the collection
+        exactly once. Prevents zero divisions.
+
+    sublinear_tf : bool, default=False
+        Apply sublinear tf scaling, i.e. replace tf with 1 + log(tf).
+
+    Attributes
+    ----------
+    vocabulary_ : dict
+        A mapping of terms to feature indices.
+
+    fixed_vocabulary_ : bool
+        True if a fixed vocabulary of term to indices mapping
+        is provided by the user.
+
+    idf_ : array of shape (n_features,)
+        The inverse document frequency (IDF) vector; only defined
+        if ``use_idf`` is True.
+
+    stop_words_ : set
+        Terms that were ignored because they either:
+
+          - occurred in too many documents (`max_df`)
+          - occurred in too few documents (`min_df`)
+          - were cut off by feature selection (`max_features`).
+
+        This is only available if no vocabulary was given.
+
+    See Also
+    --------
+    CountVectorizer : Transforms text into a sparse matrix of n-gram counts.
+
+    TfidfTransformer : Performs the TF-IDF transformation from a provided
+        matrix of counts.
+
+    Notes
+    -----
+    The ``stop_words_`` attribute can get large and increase the model size
+    when pickling. This attribute is provided only for introspection and can
+    be safely removed using delattr or set to None before pickling.
+
+    Examples
+    --------
+    >>> from sklearn.feature_extraction.text import TfidfVectorizer
+    >>> corpus = [
+    ...     'This is the first document.',
+    ...     'This document is the second document.',
+    ...     'And this is the third one.',
+    ...     'Is this the first document?',
+    ... ]
+    >>> vectorizer = TfidfVectorizer()
+    >>> X = vectorizer.fit_transform(corpus)
+    >>> vectorizer.get_feature_names_out()
+    array(['and', 'document', 'first', 'is', 'one', 'second', 'the', 'third',
+           'this'], ...)
+    >>> print(X.shape)
+    (4, 9)
+    """
+
+    _parameter_constraints: dict = {**CountVectorizer._parameter_constraints}
+    _parameter_constraints.update(
+        {
+            "norm": [StrOptions({"l1", "l2"}), None],
+            "use_idf": ["boolean"],
+            "smooth_idf": ["boolean"],
+            "sublinear_tf": ["boolean"],
+        }
+    )
+
+    def __init__(
+        self,
+        *,
+        input="content",
+        encoding="utf-8",
+        decode_error="strict",
+        strip_accents=None,
+        lowercase=True,
+        preprocessor=None,
+        tokenizer=None,
+        analyzer="word",
+        stop_words=None,
+        token_pattern=r"(?u)\b\w\w+\b",
+        ngram_range=(1, 1),
+        max_df=1.0,
+        min_df=1,
+        max_features=None,
+        vocabulary=None,
+        binary=False,
+        dtype=np.float64,
+        norm="l2",
+        use_idf=True,
+        smooth_idf=True,
+        sublinear_tf=False,
+    ):
+        super().__init__(
+            input=input,
+            encoding=encoding,
+            decode_error=decode_error,
+            strip_accents=strip_accents,
+            lowercase=lowercase,
+            preprocessor=preprocessor,
+            tokenizer=tokenizer,
+            analyzer=analyzer,
+            stop_words=stop_words,
+            token_pattern=token_pattern,
+            ngram_range=ngram_range,
+            max_df=max_df,
+            min_df=min_df,
+            max_features=max_features,
+            vocabulary=vocabulary,
+            binary=binary,
+            dtype=dtype,
+        )
+        self.norm = norm
+        self.use_idf = use_idf
+        self.smooth_idf = smooth_idf
+        self.sublinear_tf = sublinear_tf
+
+    # Broadcast the TF-IDF parameters to the underlying transformer instance
+    # for easy grid search and repr
+
+    @property
+    def idf_(self):
+        """Inverse document frequency vector, only defined if `use_idf=True`.
+
+        Returns
+        -------
+        ndarray of shape (n_features,)
+        """
+        if not hasattr(self, "_tfidf"):
+            raise NotFittedError(
+                f"{self.__class__.__name__} is not fitted yet. Call 'fit' with "
+                "appropriate arguments before using this attribute."
+            )
+        return self._tfidf.idf_
+
+    @idf_.setter
+    def idf_(self, value):
+        if not self.use_idf:
+            raise ValueError("`idf_` cannot be set when `user_idf=False`.")
+        if not hasattr(self, "_tfidf"):
+            # We should support transferring `idf_` from another `TfidfTransformer`
+            # and therefore, we need to create the transformer instance it does not
+            # exist yet.
+            self._tfidf = TfidfTransformer(
+                norm=self.norm,
+                use_idf=self.use_idf,
+                smooth_idf=self.smooth_idf,
+                sublinear_tf=self.sublinear_tf,
+            )
+        self._validate_vocabulary()
+        if hasattr(self, "vocabulary_"):
+            if len(self.vocabulary_) != len(value):
+                raise ValueError(
+                    "idf length = %d must be equal to vocabulary size = %d"
+                    % (len(value), len(self.vocabulary))
+                )
+        self._tfidf.idf_ = value
+
+    def _check_params(self):
+        if self.dtype not in FLOAT_DTYPES:
+            warnings.warn(
+                "Only {} 'dtype' should be used. {} 'dtype' will "
+                "be converted to np.float64.".format(FLOAT_DTYPES, self.dtype),
+                UserWarning,
+            )
+
+    @_fit_context(prefer_skip_nested_validation=True)
+    def fit(self, raw_documents, y=None):
+        """Learn vocabulary and idf from training set.
+
+        Parameters
+        ----------
+        raw_documents : iterable
+            An iterable which generates either str, unicode or file objects.
+
+        y : None
+            This parameter is not needed to compute tfidf.
+
+        Returns
+        -------
+        self : object
+            Fitted vectorizer.
+        """
+        self._check_params()
+        self._warn_for_unused_params()
+        self._tfidf = TfidfTransformer(
+            norm=self.norm,
+            use_idf=self.use_idf,
+            smooth_idf=self.smooth_idf,
+            sublinear_tf=self.sublinear_tf,
+        )
+        X = super().fit_transform(raw_documents)
+        self._tfidf.fit(X)
+        return self
+
+    def fit_transform(self, raw_documents, y=None):
+        """Learn vocabulary and idf, return document-term matrix.
+
+        This is equivalent to fit followed by transform, but more efficiently
+        implemented.
+
+        Parameters
+        ----------
+        raw_documents : iterable
+            An iterable which generates either str, unicode or file objects.
+
+        y : None
+            This parameter is ignored.
+
+        Returns
+        -------
+        X : sparse matrix of (n_samples, n_features)
+            Tf-idf-weighted document-term matrix.
+        """
+        self._check_params()
+        self._tfidf = TfidfTransformer(
+            norm=self.norm,
+            use_idf=self.use_idf,
+            smooth_idf=self.smooth_idf,
+            sublinear_tf=self.sublinear_tf,
+        )
+        X = super().fit_transform(raw_documents)
+        self._tfidf.fit(X)
+        # X is already a transformed view of raw_documents so
+        # we set copy to False
+        return self._tfidf.transform(X, copy=False)
+
+    def transform(self, raw_documents):
+        """Transform documents to document-term matrix.
+
+        Uses the vocabulary and document frequencies (df) learned by fit (or
+        fit_transform).
+
+        Parameters
+        ----------
+        raw_documents : iterable
+            An iterable which generates either str, unicode or file objects.
+
+        Returns
+        -------
+        X : sparse matrix of (n_samples, n_features)
+            Tf-idf-weighted document-term matrix.
+        """
+        check_is_fitted(self, msg="The TF-IDF vectorizer is not fitted")
+
+        X = super().transform(raw_documents)
+        return self._tfidf.transform(X, copy=False)
+
+    def _more_tags(self):
+        return {"X_types": ["string"], "_skip_test": True}

venv/lib/python3.10/site-packages/sklearn/svm/__init__.py

@@ -0,0 +1,25 @@
+"""
+The :mod:`sklearn.svm` module includes Support Vector Machine algorithms.
+"""
+
+# See http://scikit-learn.sourceforge.net/modules/svm.html for complete
+# documentation.
+
+# Author: Fabian Pedregosa <[email protected]> with help from
+#         the scikit-learn community. LibSVM and LibLinear are copyright
+#         of their respective owners.
+# License: BSD 3 clause (C) INRIA 2010
+
+from ._bounds import l1_min_c
+from ._classes import SVC, SVR, LinearSVC, LinearSVR, NuSVC, NuSVR, OneClassSVM
+
+__all__ = [
+    "LinearSVC",
+    "LinearSVR",
+    "NuSVC",
+    "NuSVR",
+    "OneClassSVM",
+    "SVC",
+    "SVR",
+    "l1_min_c",
+]

venv/lib/python3.10/site-packages/sklearn/svm/_base.py

@@ -0,0 +1,1249 @@
+import warnings
+from abc import ABCMeta, abstractmethod
+from numbers import Integral, Real
+
+import numpy as np
+import scipy.sparse as sp
+
+from ..base import BaseEstimator, ClassifierMixin, _fit_context
+from ..exceptions import ConvergenceWarning, NotFittedError
+from ..preprocessing import LabelEncoder
+from ..utils import check_array, check_random_state, column_or_1d, compute_class_weight
+from ..utils._param_validation import Interval, StrOptions
+from ..utils.extmath import safe_sparse_dot
+from ..utils.metaestimators import available_if
+from ..utils.multiclass import _ovr_decision_function, check_classification_targets
+from ..utils.validation import (
+    _check_large_sparse,
+    _check_sample_weight,
+    _num_samples,
+    check_consistent_length,
+    check_is_fitted,
+)
+from . import _liblinear as liblinear  # type: ignore
+
+# mypy error: error: Module 'sklearn.svm' has no attribute '_libsvm'
+# (and same for other imports)
+from . import _libsvm as libsvm  # type: ignore
+from . import _libsvm_sparse as libsvm_sparse  # type: ignore
+
+LIBSVM_IMPL = ["c_svc", "nu_svc", "one_class", "epsilon_svr", "nu_svr"]
+
+
+def _one_vs_one_coef(dual_coef, n_support, support_vectors):
+    """Generate primal coefficients from dual coefficients
+    for the one-vs-one multi class LibSVM in the case
+    of a linear kernel."""
+
+    # get 1vs1 weights for all n*(n-1) classifiers.
+    # this is somewhat messy.
+    # shape of dual_coef_ is nSV * (n_classes -1)
+    # see docs for details
+    n_class = dual_coef.shape[0] + 1
+
+    # XXX we could do preallocation of coef but
+    # would have to take care in the sparse case
+    coef = []
+    sv_locs = np.cumsum(np.hstack([[0], n_support]))
+    for class1 in range(n_class):
+        # SVs for class1:
+        sv1 = support_vectors[sv_locs[class1] : sv_locs[class1 + 1], :]
+        for class2 in range(class1 + 1, n_class):
+            # SVs for class1:
+            sv2 = support_vectors[sv_locs[class2] : sv_locs[class2 + 1], :]
+
+            # dual coef for class1 SVs:
+            alpha1 = dual_coef[class2 - 1, sv_locs[class1] : sv_locs[class1 + 1]]
+            # dual coef for class2 SVs:
+            alpha2 = dual_coef[class1, sv_locs[class2] : sv_locs[class2 + 1]]
+            # build weight for class1 vs class2
+
+            coef.append(safe_sparse_dot(alpha1, sv1) + safe_sparse_dot(alpha2, sv2))
+    return coef
+
+
+class BaseLibSVM(BaseEstimator, metaclass=ABCMeta):
+    """Base class for estimators that use libsvm as backing library.
+
+    This implements support vector machine classification and regression.
+
+    Parameter documentation is in the derived `SVC` class.
+    """
+
+    _parameter_constraints: dict = {
+        "kernel": [
+            StrOptions({"linear", "poly", "rbf", "sigmoid", "precomputed"}),
+            callable,
+        ],
+        "degree": [Interval(Integral, 0, None, closed="left")],
+        "gamma": [
+            StrOptions({"scale", "auto"}),
+            Interval(Real, 0.0, None, closed="left"),
+        ],
+        "coef0": [Interval(Real, None, None, closed="neither")],
+        "tol": [Interval(Real, 0.0, None, closed="neither")],
+        "C": [Interval(Real, 0.0, None, closed="neither")],
+        "nu": [Interval(Real, 0.0, 1.0, closed="right")],
+        "epsilon": [Interval(Real, 0.0, None, closed="left")],
+        "shrinking": ["boolean"],
+        "probability": ["boolean"],
+        "cache_size": [Interval(Real, 0, None, closed="neither")],
+        "class_weight": [StrOptions({"balanced"}), dict, None],
+        "verbose": ["verbose"],
+        "max_iter": [Interval(Integral, -1, None, closed="left")],
+        "random_state": ["random_state"],
+    }
+
+    # The order of these must match the integer values in LibSVM.
+    # XXX These are actually the same in the dense case. Need to factor
+    # this out.
+    _sparse_kernels = ["linear", "poly", "rbf", "sigmoid", "precomputed"]
+
+    @abstractmethod
+    def __init__(
+        self,
+        kernel,
+        degree,
+        gamma,
+        coef0,
+        tol,
+        C,
+        nu,
+        epsilon,
+        shrinking,
+        probability,
+        cache_size,
+        class_weight,
+        verbose,
+        max_iter,
+        random_state,
+    ):
+        if self._impl not in LIBSVM_IMPL:
+            raise ValueError(
+                "impl should be one of %s, %s was given" % (LIBSVM_IMPL, self._impl)
+            )
+
+        self.kernel = kernel
+        self.degree = degree
+        self.gamma = gamma
+        self.coef0 = coef0
+        self.tol = tol
+        self.C = C
+        self.nu = nu
+        self.epsilon = epsilon
+        self.shrinking = shrinking
+        self.probability = probability
+        self.cache_size = cache_size
+        self.class_weight = class_weight
+        self.verbose = verbose
+        self.max_iter = max_iter
+        self.random_state = random_state
+
+    def _more_tags(self):
+        # Used by cross_val_score.
+        return {"pairwise": self.kernel == "precomputed"}
+
+    @_fit_context(prefer_skip_nested_validation=True)
+    def fit(self, X, y, sample_weight=None):
+        """Fit the SVM model according to the given training data.
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} of shape (n_samples, n_features) \
+                or (n_samples, n_samples)
+            Training vectors, where `n_samples` is the number of samples
+            and `n_features` is the number of features.
+            For kernel="precomputed", the expected shape of X is
+            (n_samples, n_samples).
+
+        y : array-like of shape (n_samples,)
+            Target values (class labels in classification, real numbers in
+            regression).
+
+        sample_weight : array-like of shape (n_samples,), default=None
+            Per-sample weights. Rescale C per sample. Higher weights
+            force the classifier to put more emphasis on these points.
+
+        Returns
+        -------
+        self : object
+            Fitted estimator.
+
+        Notes
+        -----
+        If X and y are not C-ordered and contiguous arrays of np.float64 and
+        X is not a scipy.sparse.csr_matrix, X and/or y may be copied.
+
+        If X is a dense array, then the other methods will not support sparse
+        matrices as input.
+        """
+        rnd = check_random_state(self.random_state)
+
+        sparse = sp.issparse(X)
+        if sparse and self.kernel == "precomputed":
+            raise TypeError("Sparse precomputed kernels are not supported.")
+        self._sparse = sparse and not callable(self.kernel)
+
+        if callable(self.kernel):
+            check_consistent_length(X, y)
+        else:
+            X, y = self._validate_data(
+                X,
+                y,
+                dtype=np.float64,
+                order="C",
+                accept_sparse="csr",
+                accept_large_sparse=False,
+            )
+
+        y = self._validate_targets(y)
+
+        sample_weight = np.asarray(
+            [] if sample_weight is None else sample_weight, dtype=np.float64
+        )
+        solver_type = LIBSVM_IMPL.index(self._impl)
+
+        # input validation
+        n_samples = _num_samples(X)
+        if solver_type != 2 and n_samples != y.shape[0]:
+            raise ValueError(
+                "X and y have incompatible shapes.\n"
+                + "X has %s samples, but y has %s." % (n_samples, y.shape[0])
+            )
+
+        if self.kernel == "precomputed" and n_samples != X.shape[1]:
+            raise ValueError(
+                "Precomputed matrix must be a square matrix."
+                " Input is a {}x{} matrix.".format(X.shape[0], X.shape[1])
+            )
+
+        if sample_weight.shape[0] > 0 and sample_weight.shape[0] != n_samples:
+            raise ValueError(
+                "sample_weight and X have incompatible shapes: "
+                "%r vs %r\n"
+                "Note: Sparse matrices cannot be indexed w/"
+                "boolean masks (use `indices=True` in CV)."
+                % (sample_weight.shape, X.shape)
+            )
+
+        kernel = "precomputed" if callable(self.kernel) else self.kernel
+
+        if kernel == "precomputed":
+            # unused but needs to be a float for cython code that ignores
+            # it anyway
+            self._gamma = 0.0
+        elif isinstance(self.gamma, str):
+            if self.gamma == "scale":
+                # var = E[X^2] - E[X]^2 if sparse
+                X_var = (X.multiply(X)).mean() - (X.mean()) ** 2 if sparse else X.var()
+                self._gamma = 1.0 / (X.shape[1] * X_var) if X_var != 0 else 1.0
+            elif self.gamma == "auto":
+                self._gamma = 1.0 / X.shape[1]
+        elif isinstance(self.gamma, Real):
+            self._gamma = self.gamma
+
+        fit = self._sparse_fit if self._sparse else self._dense_fit
+        if self.verbose:
+            print("[LibSVM]", end="")
+
+        seed = rnd.randint(np.iinfo("i").max)
+        fit(X, y, sample_weight, solver_type, kernel, random_seed=seed)
+        # see comment on the other call to np.iinfo in this file
+
+        self.shape_fit_ = X.shape if hasattr(X, "shape") else (n_samples,)
+
+        # In binary case, we need to flip the sign of coef, intercept and
+        # decision function. Use self._intercept_ and self._dual_coef_
+        # internally.
+        self._intercept_ = self.intercept_.copy()
+        self._dual_coef_ = self.dual_coef_
+        if self._impl in ["c_svc", "nu_svc"] and len(self.classes_) == 2:
+            self.intercept_ *= -1
+            self.dual_coef_ = -self.dual_coef_
+
+        dual_coef = self._dual_coef_.data if self._sparse else self._dual_coef_
+        intercept_finiteness = np.isfinite(self._intercept_).all()
+        dual_coef_finiteness = np.isfinite(dual_coef).all()
+        if not (intercept_finiteness and dual_coef_finiteness):
+            raise ValueError(
+                "The dual coefficients or intercepts are not finite."
+                " The input data may contain large values and need to be"
+                " preprocessed."
+            )
+
+        # Since, in the case of SVC and NuSVC, the number of models optimized by
+        # libSVM could be greater than one (depending on the input), `n_iter_`
+        # stores an ndarray.
+        # For the other sub-classes (SVR, NuSVR, and OneClassSVM), the number of
+        # models optimized by libSVM is always one, so `n_iter_` stores an
+        # integer.
+        if self._impl in ["c_svc", "nu_svc"]:
+            self.n_iter_ = self._num_iter
+        else:
+            self.n_iter_ = self._num_iter.item()
+
+        return self
+
+    def _validate_targets(self, y):
+        """Validation of y and class_weight.
+
+        Default implementation for SVR and one-class; overridden in BaseSVC.
+        """
+        return column_or_1d(y, warn=True).astype(np.float64, copy=False)
+
+    def _warn_from_fit_status(self):
+        assert self.fit_status_ in (0, 1)
+        if self.fit_status_ == 1:
+            warnings.warn(
+                "Solver terminated early (max_iter=%i)."
+                "  Consider pre-processing your data with"
+                " StandardScaler or MinMaxScaler."
+                % self.max_iter,
+                ConvergenceWarning,
+            )
+
+    def _dense_fit(self, X, y, sample_weight, solver_type, kernel, random_seed):
+        if callable(self.kernel):
+            # you must store a reference to X to compute the kernel in predict
+            # TODO: add keyword copy to copy on demand
+            self.__Xfit = X
+            X = self._compute_kernel(X)
+
+            if X.shape[0] != X.shape[1]:
+                raise ValueError("X.shape[0] should be equal to X.shape[1]")
+
+        libsvm.set_verbosity_wrap(self.verbose)
+
+        # we don't pass **self.get_params() to allow subclasses to
+        # add other parameters to __init__
+        (
+            self.support_,
+            self.support_vectors_,
+            self._n_support,
+            self.dual_coef_,
+            self.intercept_,
+            self._probA,
+            self._probB,
+            self.fit_status_,
+            self._num_iter,
+        ) = libsvm.fit(
+            X,
+            y,
+            svm_type=solver_type,
+            sample_weight=sample_weight,
+            class_weight=getattr(self, "class_weight_", np.empty(0)),
+            kernel=kernel,
+            C=self.C,
+            nu=self.nu,
+            probability=self.probability,
+            degree=self.degree,
+            shrinking=self.shrinking,
+            tol=self.tol,
+            cache_size=self.cache_size,
+            coef0=self.coef0,
+            gamma=self._gamma,
+            epsilon=self.epsilon,
+            max_iter=self.max_iter,
+            random_seed=random_seed,
+        )
+
+        self._warn_from_fit_status()
+
+    def _sparse_fit(self, X, y, sample_weight, solver_type, kernel, random_seed):
+        X.data = np.asarray(X.data, dtype=np.float64, order="C")
+        X.sort_indices()
+
+        kernel_type = self._sparse_kernels.index(kernel)
+
+        libsvm_sparse.set_verbosity_wrap(self.verbose)
+
+        (
+            self.support_,
+            self.support_vectors_,
+            dual_coef_data,
+            self.intercept_,
+            self._n_support,
+            self._probA,
+            self._probB,
+            self.fit_status_,
+            self._num_iter,
+        ) = libsvm_sparse.libsvm_sparse_train(
+            X.shape[1],
+            X.data,
+            X.indices,
+            X.indptr,
+            y,
+            solver_type,
+            kernel_type,
+            self.degree,
+            self._gamma,
+            self.coef0,
+            self.tol,
+            self.C,
+            getattr(self, "class_weight_", np.empty(0)),
+            sample_weight,
+            self.nu,
+            self.cache_size,
+            self.epsilon,
+            int(self.shrinking),
+            int(self.probability),
+            self.max_iter,
+            random_seed,
+        )
+
+        self._warn_from_fit_status()
+
+        if hasattr(self, "classes_"):
+            n_class = len(self.classes_) - 1
+        else:  # regression
+            n_class = 1
+        n_SV = self.support_vectors_.shape[0]
+
+        dual_coef_indices = np.tile(np.arange(n_SV), n_class)
+        if not n_SV:
+            self.dual_coef_ = sp.csr_matrix([])
+        else:
+            dual_coef_indptr = np.arange(
+                0, dual_coef_indices.size + 1, dual_coef_indices.size / n_class
+            )
+            self.dual_coef_ = sp.csr_matrix(
+                (dual_coef_data, dual_coef_indices, dual_coef_indptr), (n_class, n_SV)
+            )
+
+    def predict(self, X):
+        """Perform regression on samples in X.
+
+        For an one-class model, +1 (inlier) or -1 (outlier) is returned.
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} of shape (n_samples, n_features)
+            For kernel="precomputed", the expected shape of X is
+            (n_samples_test, n_samples_train).
+
+        Returns
+        -------
+        y_pred : ndarray of shape (n_samples,)
+            The predicted values.
+        """
+        X = self._validate_for_predict(X)
+        predict = self._sparse_predict if self._sparse else self._dense_predict
+        return predict(X)
+
+    def _dense_predict(self, X):
+        X = self._compute_kernel(X)
+        if X.ndim == 1:
+            X = check_array(X, order="C", accept_large_sparse=False)
+
+        kernel = self.kernel
+        if callable(self.kernel):
+            kernel = "precomputed"
+            if X.shape[1] != self.shape_fit_[0]:
+                raise ValueError(
+                    "X.shape[1] = %d should be equal to %d, "
+                    "the number of samples at training time"
+                    % (X.shape[1], self.shape_fit_[0])
+                )
+
+        svm_type = LIBSVM_IMPL.index(self._impl)
+
+        return libsvm.predict(
+            X,
+            self.support_,
+            self.support_vectors_,
+            self._n_support,
+            self._dual_coef_,
+            self._intercept_,
+            self._probA,
+            self._probB,
+            svm_type=svm_type,
+            kernel=kernel,
+            degree=self.degree,
+            coef0=self.coef0,
+            gamma=self._gamma,
+            cache_size=self.cache_size,
+        )
+
+    def _sparse_predict(self, X):
+        # Precondition: X is a csr_matrix of dtype np.float64.
+        kernel = self.kernel
+        if callable(kernel):
+            kernel = "precomputed"
+
+        kernel_type = self._sparse_kernels.index(kernel)
+
+        C = 0.0  # C is not useful here
+
+        return libsvm_sparse.libsvm_sparse_predict(
+            X.data,
+            X.indices,
+            X.indptr,
+            self.support_vectors_.data,
+            self.support_vectors_.indices,
+            self.support_vectors_.indptr,
+            self._dual_coef_.data,
+            self._intercept_,
+            LIBSVM_IMPL.index(self._impl),
+            kernel_type,
+            self.degree,
+            self._gamma,
+            self.coef0,
+            self.tol,
+            C,
+            getattr(self, "class_weight_", np.empty(0)),
+            self.nu,
+            self.epsilon,
+            self.shrinking,
+            self.probability,
+            self._n_support,
+            self._probA,
+            self._probB,
+        )
+
+    def _compute_kernel(self, X):
+        """Return the data transformed by a callable kernel"""
+        if callable(self.kernel):
+            # in the case of precomputed kernel given as a function, we
+            # have to compute explicitly the kernel matrix
+            kernel = self.kernel(X, self.__Xfit)
+            if sp.issparse(kernel):
+                kernel = kernel.toarray()
+            X = np.asarray(kernel, dtype=np.float64, order="C")
+        return X
+
+    def _decision_function(self, X):
+        """Evaluates the decision function for the samples in X.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+
+        Returns
+        -------
+        X : array-like of shape (n_samples, n_class * (n_class-1) / 2)
+            Returns the decision function of the sample for each class
+            in the model.
+        """
+        # NOTE: _validate_for_predict contains check for is_fitted
+        # hence must be placed before any other attributes are used.
+        X = self._validate_for_predict(X)
+        X = self._compute_kernel(X)
+
+        if self._sparse:
+            dec_func = self._sparse_decision_function(X)
+        else:
+            dec_func = self._dense_decision_function(X)
+
+        # In binary case, we need to flip the sign of coef, intercept and
+        # decision function.
+        if self._impl in ["c_svc", "nu_svc"] and len(self.classes_) == 2:
+            return -dec_func.ravel()
+
+        return dec_func
+
+    def _dense_decision_function(self, X):
+        X = check_array(X, dtype=np.float64, order="C", accept_large_sparse=False)
+
+        kernel = self.kernel
+        if callable(kernel):
+            kernel = "precomputed"
+
+        return libsvm.decision_function(
+            X,
+            self.support_,
+            self.support_vectors_,
+            self._n_support,
+            self._dual_coef_,
+            self._intercept_,
+            self._probA,
+            self._probB,
+            svm_type=LIBSVM_IMPL.index(self._impl),
+            kernel=kernel,
+            degree=self.degree,
+            cache_size=self.cache_size,
+            coef0=self.coef0,
+            gamma=self._gamma,
+        )
+
+    def _sparse_decision_function(self, X):
+        X.data = np.asarray(X.data, dtype=np.float64, order="C")
+
+        kernel = self.kernel
+        if hasattr(kernel, "__call__"):
+            kernel = "precomputed"
+
+        kernel_type = self._sparse_kernels.index(kernel)
+
+        return libsvm_sparse.libsvm_sparse_decision_function(
+            X.data,
+            X.indices,
+            X.indptr,
+            self.support_vectors_.data,
+            self.support_vectors_.indices,
+            self.support_vectors_.indptr,
+            self._dual_coef_.data,
+            self._intercept_,
+            LIBSVM_IMPL.index(self._impl),
+            kernel_type,
+            self.degree,
+            self._gamma,
+            self.coef0,
+            self.tol,
+            self.C,
+            getattr(self, "class_weight_", np.empty(0)),
+            self.nu,
+            self.epsilon,
+            self.shrinking,
+            self.probability,
+            self._n_support,
+            self._probA,
+            self._probB,
+        )
+
+    def _validate_for_predict(self, X):
+        check_is_fitted(self)
+
+        if not callable(self.kernel):
+            X = self._validate_data(
+                X,
+                accept_sparse="csr",
+                dtype=np.float64,
+                order="C",
+                accept_large_sparse=False,
+                reset=False,
+            )
+
+        if self._sparse and not sp.issparse(X):
+            X = sp.csr_matrix(X)
+        if self._sparse:
+            X.sort_indices()
+
+        if sp.issparse(X) and not self._sparse and not callable(self.kernel):
+            raise ValueError(
+                "cannot use sparse input in %r trained on dense data"
+                % type(self).__name__
+            )
+
+        if self.kernel == "precomputed":
+            if X.shape[1] != self.shape_fit_[0]:
+                raise ValueError(
+                    "X.shape[1] = %d should be equal to %d, "
+                    "the number of samples at training time"
+                    % (X.shape[1], self.shape_fit_[0])
+                )
+        # Fixes https://nvd.nist.gov/vuln/detail/CVE-2020-28975
+        # Check that _n_support is consistent with support_vectors
+        sv = self.support_vectors_
+        if not self._sparse and sv.size > 0 and self.n_support_.sum() != sv.shape[0]:
+            raise ValueError(
+                f"The internal representation of {self.__class__.__name__} was altered"
+            )
+        return X
+
+    @property
+    def coef_(self):
+        """Weights assigned to the features when `kernel="linear"`.
+
+        Returns
+        -------
+        ndarray of shape (n_features, n_classes)
+        """
+        if self.kernel != "linear":
+            raise AttributeError("coef_ is only available when using a linear kernel")
+
+        coef = self._get_coef()
+
+        # coef_ being a read-only property, it's better to mark the value as
+        # immutable to avoid hiding potential bugs for the unsuspecting user.
+        if sp.issparse(coef):
+            # sparse matrix do not have global flags
+            coef.data.flags.writeable = False
+        else:
+            # regular dense array
+            coef.flags.writeable = False
+        return coef
+
+    def _get_coef(self):
+        return safe_sparse_dot(self._dual_coef_, self.support_vectors_)
+
+    @property
+    def n_support_(self):
+        """Number of support vectors for each class."""
+        try:
+            check_is_fitted(self)
+        except NotFittedError:
+            raise AttributeError
+
+        svm_type = LIBSVM_IMPL.index(self._impl)
+        if svm_type in (0, 1):
+            return self._n_support
+        else:
+            # SVR and OneClass
+            # _n_support has size 2, we make it size 1
+            return np.array([self._n_support[0]])
+
+
+class BaseSVC(ClassifierMixin, BaseLibSVM, metaclass=ABCMeta):
+    """ABC for LibSVM-based classifiers."""
+
+    _parameter_constraints: dict = {
+        **BaseLibSVM._parameter_constraints,
+        "decision_function_shape": [StrOptions({"ovr", "ovo"})],
+        "break_ties": ["boolean"],
+    }
+    for unused_param in ["epsilon", "nu"]:
+        _parameter_constraints.pop(unused_param)
+
+    @abstractmethod
+    def __init__(
+        self,
+        kernel,
+        degree,
+        gamma,
+        coef0,
+        tol,
+        C,
+        nu,
+        shrinking,
+        probability,
+        cache_size,
+        class_weight,
+        verbose,
+        max_iter,
+        decision_function_shape,
+        random_state,
+        break_ties,
+    ):
+        self.decision_function_shape = decision_function_shape
+        self.break_ties = break_ties
+        super().__init__(
+            kernel=kernel,
+            degree=degree,
+            gamma=gamma,
+            coef0=coef0,
+            tol=tol,
+            C=C,
+            nu=nu,
+            epsilon=0.0,
+            shrinking=shrinking,
+            probability=probability,
+            cache_size=cache_size,
+            class_weight=class_weight,
+            verbose=verbose,
+            max_iter=max_iter,
+            random_state=random_state,
+        )
+
+    def _validate_targets(self, y):
+        y_ = column_or_1d(y, warn=True)
+        check_classification_targets(y)
+        cls, y = np.unique(y_, return_inverse=True)
+        self.class_weight_ = compute_class_weight(self.class_weight, classes=cls, y=y_)
+        if len(cls) < 2:
+            raise ValueError(
+                "The number of classes has to be greater than one; got %d class"
+                % len(cls)
+            )
+
+        self.classes_ = cls
+
+        return np.asarray(y, dtype=np.float64, order="C")
+
+    def decision_function(self, X):
+        """Evaluate the decision function for the samples in X.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+            The input samples.
+
+        Returns
+        -------
+        X : ndarray of shape (n_samples, n_classes * (n_classes-1) / 2)
+            Returns the decision function of the sample for each class
+            in the model.
+            If decision_function_shape='ovr', the shape is (n_samples,
+            n_classes).
+
+        Notes
+        -----
+        If decision_function_shape='ovo', the function values are proportional
+        to the distance of the samples X to the separating hyperplane. If the
+        exact distances are required, divide the function values by the norm of
+        the weight vector (``coef_``). See also `this question
+        <https://stats.stackexchange.com/questions/14876/
+        interpreting-distance-from-hyperplane-in-svm>`_ for further details.
+        If decision_function_shape='ovr', the decision function is a monotonic
+        transformation of ovo decision function.
+        """
+        dec = self._decision_function(X)
+        if self.decision_function_shape == "ovr" and len(self.classes_) > 2:
+            return _ovr_decision_function(dec < 0, -dec, len(self.classes_))
+        return dec
+
+    def predict(self, X):
+        """Perform classification on samples in X.
+
+        For an one-class model, +1 or -1 is returned.
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} of shape (n_samples, n_features) or \
+                (n_samples_test, n_samples_train)
+            For kernel="precomputed", the expected shape of X is
+            (n_samples_test, n_samples_train).
+
+        Returns
+        -------
+        y_pred : ndarray of shape (n_samples,)
+            Class labels for samples in X.
+        """
+        check_is_fitted(self)
+        if self.break_ties and self.decision_function_shape == "ovo":
+            raise ValueError(
+                "break_ties must be False when decision_function_shape is 'ovo'"
+            )
+
+        if (
+            self.break_ties
+            and self.decision_function_shape == "ovr"
+            and len(self.classes_) > 2
+        ):
+            y = np.argmax(self.decision_function(X), axis=1)
+        else:
+            y = super().predict(X)
+        return self.classes_.take(np.asarray(y, dtype=np.intp))
+
+    # Hacky way of getting predict_proba to raise an AttributeError when
+    # probability=False using properties. Do not use this in new code; when
+    # probabilities are not available depending on a setting, introduce two
+    # estimators.
+    def _check_proba(self):
+        if not self.probability:
+            raise AttributeError(
+                "predict_proba is not available when probability=False"
+            )
+        if self._impl not in ("c_svc", "nu_svc"):
+            raise AttributeError("predict_proba only implemented for SVC and NuSVC")
+        return True
+
+    @available_if(_check_proba)
+    def predict_proba(self, X):
+        """Compute probabilities of possible outcomes for samples in X.
+
+        The model needs to have probability information computed at training
+        time: fit with attribute `probability` set to True.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+            For kernel="precomputed", the expected shape of X is
+            (n_samples_test, n_samples_train).
+
+        Returns
+        -------
+        T : ndarray of shape (n_samples, n_classes)
+            Returns the probability of the sample for each class in
+            the model. The columns correspond to the classes in sorted
+            order, as they appear in the attribute :term:`classes_`.
+
+        Notes
+        -----
+        The probability model is created using cross validation, so
+        the results can be slightly different than those obtained by
+        predict. Also, it will produce meaningless results on very small
+        datasets.
+        """
+        X = self._validate_for_predict(X)
+        if self.probA_.size == 0 or self.probB_.size == 0:
+            raise NotFittedError(
+                "predict_proba is not available when fitted with probability=False"
+            )
+        pred_proba = (
+            self._sparse_predict_proba if self._sparse else self._dense_predict_proba
+        )
+        return pred_proba(X)
+
+    @available_if(_check_proba)
+    def predict_log_proba(self, X):
+        """Compute log probabilities of possible outcomes for samples in X.
+
+        The model need to have probability information computed at training
+        time: fit with attribute `probability` set to True.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features) or \
+                (n_samples_test, n_samples_train)
+            For kernel="precomputed", the expected shape of X is
+            (n_samples_test, n_samples_train).
+
+        Returns
+        -------
+        T : ndarray of shape (n_samples, n_classes)
+            Returns the log-probabilities of the sample for each class in
+            the model. The columns correspond to the classes in sorted
+            order, as they appear in the attribute :term:`classes_`.
+
+        Notes
+        -----
+        The probability model is created using cross validation, so
+        the results can be slightly different than those obtained by
+        predict. Also, it will produce meaningless results on very small
+        datasets.
+        """
+        return np.log(self.predict_proba(X))
+
+    def _dense_predict_proba(self, X):
+        X = self._compute_kernel(X)
+
+        kernel = self.kernel
+        if callable(kernel):
+            kernel = "precomputed"
+
+        svm_type = LIBSVM_IMPL.index(self._impl)
+        pprob = libsvm.predict_proba(
+            X,
+            self.support_,
+            self.support_vectors_,
+            self._n_support,
+            self._dual_coef_,
+            self._intercept_,
+            self._probA,
+            self._probB,
+            svm_type=svm_type,
+            kernel=kernel,
+            degree=self.degree,
+            cache_size=self.cache_size,
+            coef0=self.coef0,
+            gamma=self._gamma,
+        )
+
+        return pprob
+
+    def _sparse_predict_proba(self, X):
+        X.data = np.asarray(X.data, dtype=np.float64, order="C")
+
+        kernel = self.kernel
+        if callable(kernel):
+            kernel = "precomputed"
+
+        kernel_type = self._sparse_kernels.index(kernel)
+
+        return libsvm_sparse.libsvm_sparse_predict_proba(
+            X.data,
+            X.indices,
+            X.indptr,
+            self.support_vectors_.data,
+            self.support_vectors_.indices,
+            self.support_vectors_.indptr,
+            self._dual_coef_.data,
+            self._intercept_,
+            LIBSVM_IMPL.index(self._impl),
+            kernel_type,
+            self.degree,
+            self._gamma,
+            self.coef0,
+            self.tol,
+            self.C,
+            getattr(self, "class_weight_", np.empty(0)),
+            self.nu,
+            self.epsilon,
+            self.shrinking,
+            self.probability,
+            self._n_support,
+            self._probA,
+            self._probB,
+        )
+
+    def _get_coef(self):
+        if self.dual_coef_.shape[0] == 1:
+            # binary classifier
+            coef = safe_sparse_dot(self.dual_coef_, self.support_vectors_)
+        else:
+            # 1vs1 classifier
+            coef = _one_vs_one_coef(
+                self.dual_coef_, self._n_support, self.support_vectors_
+            )
+            if sp.issparse(coef[0]):
+                coef = sp.vstack(coef).tocsr()
+            else:
+                coef = np.vstack(coef)
+
+        return coef
+
+    @property
+    def probA_(self):
+        """Parameter learned in Platt scaling when `probability=True`.
+
+        Returns
+        -------
+        ndarray of shape  (n_classes * (n_classes - 1) / 2)
+        """
+        return self._probA
+
+    @property
+    def probB_(self):
+        """Parameter learned in Platt scaling when `probability=True`.
+
+        Returns
+        -------
+        ndarray of shape  (n_classes * (n_classes - 1) / 2)
+        """
+        return self._probB
+
+
+def _get_liblinear_solver_type(multi_class, penalty, loss, dual):
+    """Find the liblinear magic number for the solver.
+
+    This number depends on the values of the following attributes:
+      - multi_class
+      - penalty
+      - loss
+      - dual
+
+    The same number is also internally used by LibLinear to determine
+    which solver to use.
+    """
+    # nested dicts containing level 1: available loss functions,
+    # level2: available penalties for the given loss function,
+    # level3: whether the dual solver is available for the specified
+    # combination of loss function and penalty
+    _solver_type_dict = {
+        "logistic_regression": {"l1": {False: 6}, "l2": {False: 0, True: 7}},
+        "hinge": {"l2": {True: 3}},
+        "squared_hinge": {"l1": {False: 5}, "l2": {False: 2, True: 1}},
+        "epsilon_insensitive": {"l2": {True: 13}},
+        "squared_epsilon_insensitive": {"l2": {False: 11, True: 12}},
+        "crammer_singer": 4,
+    }
+
+    if multi_class == "crammer_singer":
+        return _solver_type_dict[multi_class]
+    elif multi_class != "ovr":
+        raise ValueError(
+            "`multi_class` must be one of `ovr`, `crammer_singer`, got %r" % multi_class
+        )
+
+    _solver_pen = _solver_type_dict.get(loss, None)
+    if _solver_pen is None:
+        error_string = "loss='%s' is not supported" % loss
+    else:
+        _solver_dual = _solver_pen.get(penalty, None)
+        if _solver_dual is None:
+            error_string = (
+                "The combination of penalty='%s' and loss='%s' is not supported"
+                % (penalty, loss)
+            )
+        else:
+            solver_num = _solver_dual.get(dual, None)
+            if solver_num is None:
+                error_string = (
+                    "The combination of penalty='%s' and "
+                    "loss='%s' are not supported when dual=%s" % (penalty, loss, dual)
+                )
+            else:
+                return solver_num
+    raise ValueError(
+        "Unsupported set of arguments: %s, Parameters: penalty=%r, loss=%r, dual=%r"
+        % (error_string, penalty, loss, dual)
+    )
+
+
+def _fit_liblinear(
+    X,
+    y,
+    C,
+    fit_intercept,
+    intercept_scaling,
+    class_weight,
+    penalty,
+    dual,
+    verbose,
+    max_iter,
+    tol,
+    random_state=None,
+    multi_class="ovr",
+    loss="logistic_regression",
+    epsilon=0.1,
+    sample_weight=None,
+):
+    """Used by Logistic Regression (and CV) and LinearSVC/LinearSVR.
+
+    Preprocessing is done in this function before supplying it to liblinear.
+
+    Parameters
+    ----------
+    X : {array-like, sparse matrix} 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 : array-like of shape (n_samples,)
+        Target vector relative to X
+
+    C : float
+        Inverse of cross-validation parameter. The lower the C, the higher
+        the penalization.
+
+    fit_intercept : bool
+        Whether or not to fit an intercept. If set to True, the feature vector
+        is extended to include an intercept term: ``[x_1, ..., x_n, 1]``, where
+        1 corresponds to the intercept. If set to False, no intercept will be
+        used in calculations (i.e. data is expected to be already centered).
+
+    intercept_scaling : float
+        Liblinear internally penalizes the intercept, treating it like any
+        other term in the feature vector. To reduce the impact of the
+        regularization on the intercept, the `intercept_scaling` parameter can
+        be set to a value greater than 1; the higher the value of
+        `intercept_scaling`, the lower the impact of regularization on it.
+        Then, the weights become `[w_x_1, ..., w_x_n,
+        w_intercept*intercept_scaling]`, where `w_x_1, ..., w_x_n` represent
+        the feature weights and the intercept weight is scaled by
+        `intercept_scaling`. This scaling allows the intercept term to have a
+        different regularization behavior compared to the other features.
+
+    class_weight : dict or 'balanced', default=None
+        Weights associated with classes in the form ``{class_label: weight}``.
+        If not given, all classes are supposed to have weight one. For
+        multi-output problems, a list of dicts can be provided in the same
+        order as the columns of y.
+
+        The "balanced" mode uses the values of y to automatically adjust
+        weights inversely proportional to class frequencies in the input data
+        as ``n_samples / (n_classes * np.bincount(y))``
+
+    penalty : {'l1', 'l2'}
+        The norm of the penalty used in regularization.
+
+    dual : bool
+        Dual or primal formulation,
+
+    verbose : int
+        Set verbose to any positive number for verbosity.
+
+    max_iter : int
+        Number of iterations.
+
+    tol : float
+        Stopping condition.
+
+    random_state : int, RandomState instance or None, default=None
+        Controls the pseudo random number generation for shuffling the data.
+        Pass an int for reproducible output across multiple function calls.
+        See :term:`Glossary <random_state>`.
+
+    multi_class : {'ovr', 'crammer_singer'}, default='ovr'
+        `ovr` trains n_classes one-vs-rest classifiers, while `crammer_singer`
+        optimizes a joint objective over all classes.
+        While `crammer_singer` is interesting from an theoretical perspective
+        as it is consistent it is seldom used in practice and rarely leads to
+        better accuracy and is more expensive to compute.
+        If `crammer_singer` is chosen, the options loss, penalty and dual will
+        be ignored.
+
+    loss : {'logistic_regression', 'hinge', 'squared_hinge', \
+            'epsilon_insensitive', 'squared_epsilon_insensitive}, \
+            default='logistic_regression'
+        The loss function used to fit the model.
+
+    epsilon : float, default=0.1
+        Epsilon parameter in the epsilon-insensitive loss function. Note
+        that the value of this parameter depends on the scale of the target
+        variable y. If unsure, set epsilon=0.
+
+    sample_weight : array-like of shape (n_samples,), default=None
+        Weights assigned to each sample.
+
+    Returns
+    -------
+    coef_ : ndarray of shape (n_features, n_features + 1)
+        The coefficient vector got by minimizing the objective function.
+
+    intercept_ : float
+        The intercept term added to the vector.
+
+    n_iter_ : array of int
+        Number of iterations run across for each class.
+    """
+    if loss not in ["epsilon_insensitive", "squared_epsilon_insensitive"]:
+        enc = LabelEncoder()
+        y_ind = enc.fit_transform(y)
+        classes_ = enc.classes_
+        if len(classes_) < 2:
+            raise ValueError(
+                "This solver needs samples of at least 2 classes"
+                " in the data, but the data contains only one"
+                " class: %r"
+                % classes_[0]
+            )
+
+        class_weight_ = compute_class_weight(class_weight, classes=classes_, y=y)
+    else:
+        class_weight_ = np.empty(0, dtype=np.float64)
+        y_ind = y
+    liblinear.set_verbosity_wrap(verbose)
+    rnd = check_random_state(random_state)
+    if verbose:
+        print("[LibLinear]", end="")
+
+    # LinearSVC breaks when intercept_scaling is <= 0
+    bias = -1.0
+    if fit_intercept:
+        if intercept_scaling <= 0:
+            raise ValueError(
+                "Intercept scaling is %r but needs to be greater "
+                "than 0. To disable fitting an intercept,"
+                " set fit_intercept=False." % intercept_scaling
+            )
+        else:
+            bias = intercept_scaling
+
+    libsvm.set_verbosity_wrap(verbose)
+    libsvm_sparse.set_verbosity_wrap(verbose)
+    liblinear.set_verbosity_wrap(verbose)
+
+    # Liblinear doesn't support 64bit sparse matrix indices yet
+    if sp.issparse(X):
+        _check_large_sparse(X)
+
+    # LibLinear wants targets as doubles, even for classification
+    y_ind = np.asarray(y_ind, dtype=np.float64).ravel()
+    y_ind = np.require(y_ind, requirements="W")
+
+    sample_weight = _check_sample_weight(sample_weight, X, dtype=np.float64)
+
+    solver_type = _get_liblinear_solver_type(multi_class, penalty, loss, dual)
+    raw_coef_, n_iter_ = liblinear.train_wrap(
+        X,
+        y_ind,
+        sp.issparse(X),
+        solver_type,
+        tol,
+        bias,
+        C,
+        class_weight_,
+        max_iter,
+        rnd.randint(np.iinfo("i").max),
+        epsilon,
+        sample_weight,
+    )
+    # Regarding rnd.randint(..) in the above signature:
+    # seed for srand in range [0..INT_MAX); due to limitations in Numpy
+    # on 32-bit platforms, we can't get to the UINT_MAX limit that
+    # srand supports
+    n_iter_max = max(n_iter_)
+    if n_iter_max >= max_iter:
+        warnings.warn(
+            "Liblinear failed to converge, increase the number of iterations.",
+            ConvergenceWarning,
+        )
+
+    if fit_intercept:
+        coef_ = raw_coef_[:, :-1]
+        intercept_ = intercept_scaling * raw_coef_[:, -1]
+    else:
+        coef_ = raw_coef_
+        intercept_ = 0.0
+
+    return coef_, intercept_, n_iter_

venv/lib/python3.10/site-packages/sklearn/svm/_bounds.py

@@ -0,0 +1,94 @@
+"""Determination of parameter bounds"""
+# Author: Paolo Losi
+# License: BSD 3 clause
+
+from numbers import Real
+
+import numpy as np
+
+from ..preprocessing import LabelBinarizer
+from ..utils._param_validation import Interval, StrOptions, validate_params
+from ..utils.extmath import safe_sparse_dot
+from ..utils.validation import check_array, check_consistent_length
+
+
+@validate_params(
+    {
+        "X": ["array-like", "sparse matrix"],
+        "y": ["array-like"],
+        "loss": [StrOptions({"squared_hinge", "log"})],
+        "fit_intercept": ["boolean"],
+        "intercept_scaling": [Interval(Real, 0, None, closed="neither")],
+    },
+    prefer_skip_nested_validation=True,
+)
+def l1_min_c(X, y, *, loss="squared_hinge", fit_intercept=True, intercept_scaling=1.0):
+    """Return the lowest bound for C.
+
+    The lower bound for C is computed such that for C in (l1_min_C, infinity)
+    the model is guaranteed not to be empty. This applies to l1 penalized
+    classifiers, such as LinearSVC with penalty='l1' and
+    linear_model.LogisticRegression with penalty='l1'.
+
+    This value is valid if class_weight parameter in fit() is not set.
+
+    Parameters
+    ----------
+    X : {array-like, sparse matrix} 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 : array-like of shape (n_samples,)
+        Target vector relative to X.
+
+    loss : {'squared_hinge', 'log'}, default='squared_hinge'
+        Specifies the loss function.
+        With 'squared_hinge' it is the squared hinge loss (a.k.a. L2 loss).
+        With 'log' it is the loss of logistic regression models.
+
+    fit_intercept : bool, default=True
+        Specifies if the intercept should be fitted by the model.
+        It must match the fit() method parameter.
+
+    intercept_scaling : float, default=1.0
+        When fit_intercept is True, instance vector x becomes
+        [x, intercept_scaling],
+        i.e. a "synthetic" feature with constant value equals to
+        intercept_scaling is appended to the instance vector.
+        It must match the fit() method parameter.
+
+    Returns
+    -------
+    l1_min_c : float
+        Minimum value for C.
+
+    Examples
+    --------
+    >>> from sklearn.svm import l1_min_c
+    >>> from sklearn.datasets import make_classification
+    >>> X, y = make_classification(n_samples=100, n_features=20, random_state=42)
+    >>> print(f"{l1_min_c(X, y, loss='squared_hinge', fit_intercept=True):.4f}")
+    0.0044
+    """
+
+    X = check_array(X, accept_sparse="csc")
+    check_consistent_length(X, y)
+
+    Y = LabelBinarizer(neg_label=-1).fit_transform(y).T
+    # maximum absolute value over classes and features
+    den = np.max(np.abs(safe_sparse_dot(Y, X)))
+    if fit_intercept:
+        bias = np.full(
+            (np.size(y), 1), intercept_scaling, dtype=np.array(intercept_scaling).dtype
+        )
+        den = max(den, abs(np.dot(Y, bias)).max())
+
+    if den == 0.0:
+        raise ValueError(
+            "Ill-posed l1_min_c calculation: l1 will always "
+            "select zero coefficients for this data"
+        )
+    if loss == "squared_hinge":
+        return 0.5 / den
+    else:  # loss == 'log':
+        return 2.0 / den

venv/lib/python3.10/site-packages/sklearn/svm/_classes.py

@@ -0,0 +1,1832 @@
+import warnings
+from numbers import Integral, Real
+
+import numpy as np
+
+from ..base import BaseEstimator, OutlierMixin, RegressorMixin, _fit_context
+from ..linear_model._base import LinearClassifierMixin, LinearModel, SparseCoefMixin
+from ..utils._param_validation import Hidden, Interval, StrOptions
+from ..utils.multiclass import check_classification_targets
+from ..utils.validation import _num_samples
+from ._base import BaseLibSVM, BaseSVC, _fit_liblinear, _get_liblinear_solver_type
+
+
+def _validate_dual_parameter(dual, loss, penalty, multi_class, X):
+    """Helper function to assign the value of dual parameter."""
+    if dual == "auto":
+        if X.shape[0] < X.shape[1]:
+            try:
+                _get_liblinear_solver_type(multi_class, penalty, loss, True)
+                return True
+            except ValueError:  # dual not supported for the combination
+                return False
+        else:
+            try:
+                _get_liblinear_solver_type(multi_class, penalty, loss, False)
+                return False
+            except ValueError:  # primal not supported by the combination
+                return True
+    # TODO 1.5
+    elif dual == "warn":
+        warnings.warn(
+            (
+                "The default value of `dual` will change from `True` to `'auto'` in"
+                " 1.5. Set the value of `dual` explicitly to suppress the warning."
+            ),
+            FutureWarning,
+        )
+        return True
+    else:
+        return dual
+
+
+class LinearSVC(LinearClassifierMixin, SparseCoefMixin, BaseEstimator):
+    """Linear Support Vector Classification.
+
+    Similar to SVC with parameter kernel='linear', but implemented in terms of
+    liblinear rather than libsvm, so it has more flexibility in the choice of
+    penalties and loss functions and should scale better to large numbers of
+    samples.
+
+    The main differences between :class:`~sklearn.svm.LinearSVC` and
+    :class:`~sklearn.svm.SVC` lie in the loss function used by default, and in
+    the handling of intercept regularization between those two implementations.
+
+    This class supports both dense and sparse input and the multiclass support
+    is handled according to a one-vs-the-rest scheme.
+
+    Read more in the :ref:`User Guide <svm_classification>`.
+
+    Parameters
+    ----------
+    penalty : {'l1', 'l2'}, default='l2'
+        Specifies the norm used in the penalization. The 'l2'
+        penalty is the standard used in SVC. The 'l1' leads to ``coef_``
+        vectors that are sparse.
+
+    loss : {'hinge', 'squared_hinge'}, default='squared_hinge'
+        Specifies the loss function. 'hinge' is the standard SVM loss
+        (used e.g. by the SVC class) while 'squared_hinge' is the
+        square of the hinge loss. The combination of ``penalty='l1'``
+        and ``loss='hinge'`` is not supported.
+
+    dual : "auto" or bool, default=True
+        Select the algorithm to either solve the dual or primal
+        optimization problem. Prefer dual=False when n_samples > n_features.
+        `dual="auto"` will choose the value of the parameter automatically,
+        based on the values of `n_samples`, `n_features`, `loss`, `multi_class`
+        and `penalty`. If `n_samples` < `n_features` and optimizer supports
+        chosen `loss`, `multi_class` and `penalty`, then dual will be set to True,
+        otherwise it will be set to False.
+
+        .. versionchanged:: 1.3
+           The `"auto"` option is added in version 1.3 and will be the default
+           in version 1.5.
+
+    tol : float, default=1e-4
+        Tolerance for stopping criteria.
+
+    C : float, default=1.0
+        Regularization parameter. The strength of the regularization is
+        inversely proportional to C. Must be strictly positive.
+
+    multi_class : {'ovr', 'crammer_singer'}, default='ovr'
+        Determines the multi-class strategy if `y` contains more than
+        two classes.
+        ``"ovr"`` trains n_classes one-vs-rest classifiers, while
+        ``"crammer_singer"`` optimizes a joint objective over all classes.
+        While `crammer_singer` is interesting from a theoretical perspective
+        as it is consistent, it is seldom used in practice as it rarely leads
+        to better accuracy and is more expensive to compute.
+        If ``"crammer_singer"`` is chosen, the options loss, penalty and dual
+        will be ignored.
+
+    fit_intercept : bool, default=True
+        Whether or not to fit an intercept. If set to True, the feature vector
+        is extended to include an intercept term: `[x_1, ..., x_n, 1]`, where
+        1 corresponds to the intercept. If set to False, no intercept will be
+        used in calculations (i.e. data is expected to be already centered).
+
+    intercept_scaling : float, default=1.0
+        When `fit_intercept` is True, the instance vector x becomes ``[x_1,
+        ..., x_n, intercept_scaling]``, i.e. a "synthetic" feature with a
+        constant value equal to `intercept_scaling` is appended to the instance
+        vector. The intercept becomes intercept_scaling * synthetic feature
+        weight. Note that liblinear internally penalizes the intercept,
+        treating it like any other term in the feature vector. To reduce the
+        impact of the regularization on the intercept, the `intercept_scaling`
+        parameter can be set to a value greater than 1; the higher the value of
+        `intercept_scaling`, the lower the impact of regularization on it.
+        Then, the weights become `[w_x_1, ..., w_x_n,
+        w_intercept*intercept_scaling]`, where `w_x_1, ..., w_x_n` represent
+        the feature weights and the intercept weight is scaled by
+        `intercept_scaling`. This scaling allows the intercept term to have a
+        different regularization behavior compared to the other features.
+
+    class_weight : dict or 'balanced', default=None
+        Set the parameter C of class i to ``class_weight[i]*C`` for
+        SVC. If not given, all classes are supposed to have
+        weight one.
+        The "balanced" mode uses the values of y to automatically adjust
+        weights inversely proportional to class frequencies in the input data
+        as ``n_samples / (n_classes * np.bincount(y))``.
+
+    verbose : int, default=0
+        Enable verbose output. Note that this setting takes advantage of a
+        per-process runtime setting in liblinear that, if enabled, may not work
+        properly in a multithreaded context.
+
+    random_state : int, RandomState instance or None, default=None
+        Controls the pseudo random number generation for shuffling the data for
+        the dual coordinate descent (if ``dual=True``). When ``dual=False`` the
+        underlying implementation of :class:`LinearSVC` is not random and
+        ``random_state`` has no effect on the results.
+        Pass an int for reproducible output across multiple function calls.
+        See :term:`Glossary <random_state>`.
+
+    max_iter : int, default=1000
+        The maximum number of iterations to be run.
+
+    Attributes
+    ----------
+    coef_ : ndarray of shape (1, n_features) if n_classes == 2 \
+            else (n_classes, n_features)
+        Weights assigned to the features (coefficients in the primal
+        problem).
+
+        ``coef_`` is a readonly property derived from ``raw_coef_`` that
+        follows the internal memory layout of liblinear.
+
+    intercept_ : ndarray of shape (1,) if n_classes == 2 else (n_classes,)
+        Constants in decision function.
+
+    classes_ : ndarray of shape (n_classes,)
+        The unique classes labels.
+
+    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
+        Maximum number of iterations run across all classes.
+
+    See Also
+    --------
+    SVC : Implementation of Support Vector Machine classifier using libsvm:
+        the kernel can be non-linear but its SMO algorithm does not
+        scale to large number of samples as LinearSVC does.
+
+        Furthermore SVC multi-class mode is implemented using one
+        vs one scheme while LinearSVC uses one vs the rest. It is
+        possible to implement one vs the rest with SVC by using the
+        :class:`~sklearn.multiclass.OneVsRestClassifier` wrapper.
+
+        Finally SVC can fit dense data without memory copy if the input
+        is C-contiguous. Sparse data will still incur memory copy though.
+
+    sklearn.linear_model.SGDClassifier : SGDClassifier can optimize the same
+        cost function as LinearSVC
+        by adjusting the penalty and loss parameters. In addition it requires
+        less memory, allows incremental (online) learning, and implements
+        various loss functions and regularization regimes.
+
+    Notes
+    -----
+    The underlying C implementation uses a random number generator to
+    select features when fitting the model. It is thus not uncommon
+    to have slightly different results for the same input data. If
+    that happens, try with a smaller ``tol`` parameter.
+
+    The underlying implementation, liblinear, uses a sparse internal
+    representation for the data that will incur a memory copy.
+
+    Predict output may not match that of standalone liblinear in certain
+    cases. See :ref:`differences from liblinear <liblinear_differences>`
+    in the narrative documentation.
+
+    References
+    ----------
+    `LIBLINEAR: A Library for Large Linear Classification
+    <https://www.csie.ntu.edu.tw/~cjlin/liblinear/>`__
+
+    Examples
+    --------
+    >>> from sklearn.svm import LinearSVC
+    >>> from sklearn.pipeline import make_pipeline
+    >>> from sklearn.preprocessing import StandardScaler
+    >>> from sklearn.datasets import make_classification
+    >>> X, y = make_classification(n_features=4, random_state=0)
+    >>> clf = make_pipeline(StandardScaler(),
+    ...                     LinearSVC(dual="auto", random_state=0, tol=1e-5))
+    >>> clf.fit(X, y)
+    Pipeline(steps=[('standardscaler', StandardScaler()),
+                    ('linearsvc', LinearSVC(dual='auto', random_state=0, tol=1e-05))])
+
+    >>> print(clf.named_steps['linearsvc'].coef_)
+    [[0.141...   0.526... 0.679... 0.493...]]
+
+    >>> print(clf.named_steps['linearsvc'].intercept_)
+    [0.1693...]
+    >>> print(clf.predict([[0, 0, 0, 0]]))
+    [1]
+    """
+
+    _parameter_constraints: dict = {
+        "penalty": [StrOptions({"l1", "l2"})],
+        "loss": [StrOptions({"hinge", "squared_hinge"})],
+        "dual": ["boolean", StrOptions({"auto"}), Hidden(StrOptions({"warn"}))],
+        "tol": [Interval(Real, 0.0, None, closed="neither")],
+        "C": [Interval(Real, 0.0, None, closed="neither")],
+        "multi_class": [StrOptions({"ovr", "crammer_singer"})],
+        "fit_intercept": ["boolean"],
+        "intercept_scaling": [Interval(Real, 0, None, closed="neither")],
+        "class_weight": [None, dict, StrOptions({"balanced"})],
+        "verbose": ["verbose"],
+        "random_state": ["random_state"],
+        "max_iter": [Interval(Integral, 0, None, closed="left")],
+    }
+
+    def __init__(
+        self,
+        penalty="l2",
+        loss="squared_hinge",
+        *,
+        dual="warn",
+        tol=1e-4,
+        C=1.0,
+        multi_class="ovr",
+        fit_intercept=True,
+        intercept_scaling=1,
+        class_weight=None,
+        verbose=0,
+        random_state=None,
+        max_iter=1000,
+    ):
+        self.dual = dual
+        self.tol = tol
+        self.C = C
+        self.multi_class = multi_class
+        self.fit_intercept = fit_intercept
+        self.intercept_scaling = intercept_scaling
+        self.class_weight = class_weight
+        self.verbose = verbose
+        self.random_state = random_state
+        self.max_iter = max_iter
+        self.penalty = penalty
+        self.loss = loss
+
+    @_fit_context(prefer_skip_nested_validation=True)
+    def fit(self, X, y, sample_weight=None):
+        """Fit the model according to the given training data.
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} 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 : array-like of shape (n_samples,)
+            Target vector relative to X.
+
+        sample_weight : array-like of shape (n_samples,), default=None
+            Array of weights that are assigned to individual
+            samples. If not provided,
+            then each sample is given unit weight.
+
+            .. versionadded:: 0.18
+
+        Returns
+        -------
+        self : object
+            An instance of the estimator.
+        """
+        X, y = self._validate_data(
+            X,
+            y,
+            accept_sparse="csr",
+            dtype=np.float64,
+            order="C",
+            accept_large_sparse=False,
+        )
+        check_classification_targets(y)
+        self.classes_ = np.unique(y)
+
+        _dual = _validate_dual_parameter(
+            self.dual, self.loss, self.penalty, self.multi_class, X
+        )
+
+        self.coef_, self.intercept_, n_iter_ = _fit_liblinear(
+            X,
+            y,
+            self.C,
+            self.fit_intercept,
+            self.intercept_scaling,
+            self.class_weight,
+            self.penalty,
+            _dual,
+            self.verbose,
+            self.max_iter,
+            self.tol,
+            self.random_state,
+            self.multi_class,
+            self.loss,
+            sample_weight=sample_weight,
+        )
+        # Backward compatibility: _fit_liblinear is used both by LinearSVC/R
+        # and LogisticRegression but LogisticRegression sets a structured
+        # `n_iter_` attribute with information about the underlying OvR fits
+        # while LinearSVC/R only reports the maximum value.
+        self.n_iter_ = n_iter_.max().item()
+
+        if self.multi_class == "crammer_singer" and len(self.classes_) == 2:
+            self.coef_ = (self.coef_[1] - self.coef_[0]).reshape(1, -1)
+            if self.fit_intercept:
+                intercept = self.intercept_[1] - self.intercept_[0]
+                self.intercept_ = np.array([intercept])
+
+        return self
+
+    def _more_tags(self):
+        return {
+            "_xfail_checks": {
+                "check_sample_weights_invariance": (
+                    "zero sample_weight is not equivalent to removing samples"
+                ),
+            }
+        }
+
+
+class LinearSVR(RegressorMixin, LinearModel):
+    """Linear Support Vector Regression.
+
+    Similar to SVR with parameter kernel='linear', but implemented in terms of
+    liblinear rather than libsvm, so it has more flexibility in the choice of
+    penalties and loss functions and should scale better to large numbers of
+    samples.
+
+    The main differences between :class:`~sklearn.svm.LinearSVR` and
+    :class:`~sklearn.svm.SVR` lie in the loss function used by default, and in
+    the handling of intercept regularization between those two implementations.
+
+    This class supports both dense and sparse input.
+
+    Read more in the :ref:`User Guide <svm_regression>`.
+
+    .. versionadded:: 0.16
+
+    Parameters
+    ----------
+    epsilon : float, default=0.0
+        Epsilon parameter in the epsilon-insensitive loss function. Note
+        that the value of this parameter depends on the scale of the target
+        variable y. If unsure, set ``epsilon=0``.
+
+    tol : float, default=1e-4
+        Tolerance for stopping criteria.
+
+    C : float, default=1.0
+        Regularization parameter. The strength of the regularization is
+        inversely proportional to C. Must be strictly positive.
+
+    loss : {'epsilon_insensitive', 'squared_epsilon_insensitive'}, \
+            default='epsilon_insensitive'
+        Specifies the loss function. The epsilon-insensitive loss
+        (standard SVR) is the L1 loss, while the squared epsilon-insensitive
+        loss ('squared_epsilon_insensitive') is the L2 loss.
+
+    fit_intercept : bool, default=True
+        Whether or not to fit an intercept. If set to True, the feature vector
+        is extended to include an intercept term: `[x_1, ..., x_n, 1]`, where
+        1 corresponds to the intercept. If set to False, no intercept will be
+        used in calculations (i.e. data is expected to be already centered).
+
+    intercept_scaling : float, default=1.0
+        When `fit_intercept` is True, the instance vector x becomes `[x_1, ...,
+        x_n, intercept_scaling]`, i.e. a "synthetic" feature with a constant
+        value equal to `intercept_scaling` is appended to the instance vector.
+        The intercept becomes intercept_scaling * synthetic feature weight.
+        Note that liblinear internally penalizes the intercept, treating it
+        like any other term in the feature vector. To reduce the impact of the
+        regularization on the intercept, the `intercept_scaling` parameter can
+        be set to a value greater than 1; the higher the value of
+        `intercept_scaling`, the lower the impact of regularization on it.
+        Then, the weights become `[w_x_1, ..., w_x_n,
+        w_intercept*intercept_scaling]`, where `w_x_1, ..., w_x_n` represent
+        the feature weights and the intercept weight is scaled by
+        `intercept_scaling`. This scaling allows the intercept term to have a
+        different regularization behavior compared to the other features.
+
+    dual : "auto" or bool, default=True
+        Select the algorithm to either solve the dual or primal
+        optimization problem. Prefer dual=False when n_samples > n_features.
+        `dual="auto"` will choose the value of the parameter automatically,
+        based on the values of `n_samples`, `n_features` and `loss`. If
+        `n_samples` < `n_features` and optimizer supports chosen `loss`,
+        then dual will be set to True, otherwise it will be set to False.
+
+        .. versionchanged:: 1.3
+           The `"auto"` option is added in version 1.3 and will be the default
+           in version 1.5.
+
+    verbose : int, default=0
+        Enable verbose output. Note that this setting takes advantage of a
+        per-process runtime setting in liblinear that, if enabled, may not work
+        properly in a multithreaded context.
+
+    random_state : int, RandomState instance or None, default=None
+        Controls the pseudo random number generation for shuffling the data.
+        Pass an int for reproducible output across multiple function calls.
+        See :term:`Glossary <random_state>`.
+
+    max_iter : int, default=1000
+        The maximum number of iterations to be run.
+
+    Attributes
+    ----------
+    coef_ : ndarray of shape (n_features) if n_classes == 2 \
+            else (n_classes, n_features)
+        Weights assigned to the features (coefficients in the primal
+        problem).
+
+        `coef_` is a readonly property derived from `raw_coef_` that
+        follows the internal memory layout of liblinear.
+
+    intercept_ : ndarray of shape (1) if n_classes == 2 else (n_classes)
+        Constants in decision function.
+
+    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
+        Maximum number of iterations run across all classes.
+
+    See Also
+    --------
+    LinearSVC : Implementation of Support Vector Machine classifier using the
+        same library as this class (liblinear).
+
+    SVR : Implementation of Support Vector Machine regression using libsvm:
+        the kernel can be non-linear but its SMO algorithm does not scale to
+        large number of samples as :class:`~sklearn.svm.LinearSVR` does.
+
+    sklearn.linear_model.SGDRegressor : SGDRegressor can optimize the same cost
+        function as LinearSVR
+        by adjusting the penalty and loss parameters. In addition it requires
+        less memory, allows incremental (online) learning, and implements
+        various loss functions and regularization regimes.
+
+    Examples
+    --------
+    >>> from sklearn.svm import LinearSVR
+    >>> from sklearn.pipeline import make_pipeline
+    >>> from sklearn.preprocessing import StandardScaler
+    >>> from sklearn.datasets import make_regression
+    >>> X, y = make_regression(n_features=4, random_state=0)
+    >>> regr = make_pipeline(StandardScaler(),
+    ...                      LinearSVR(dual="auto", random_state=0, tol=1e-5))
+    >>> regr.fit(X, y)
+    Pipeline(steps=[('standardscaler', StandardScaler()),
+                    ('linearsvr', LinearSVR(dual='auto', random_state=0, tol=1e-05))])
+
+    >>> print(regr.named_steps['linearsvr'].coef_)
+    [18.582... 27.023... 44.357... 64.522...]
+    >>> print(regr.named_steps['linearsvr'].intercept_)
+    [-4...]
+    >>> print(regr.predict([[0, 0, 0, 0]]))
+    [-2.384...]
+    """
+
+    _parameter_constraints: dict = {
+        "epsilon": [Real],
+        "tol": [Interval(Real, 0.0, None, closed="neither")],
+        "C": [Interval(Real, 0.0, None, closed="neither")],
+        "loss": [StrOptions({"epsilon_insensitive", "squared_epsilon_insensitive"})],
+        "fit_intercept": ["boolean"],
+        "intercept_scaling": [Interval(Real, 0, None, closed="neither")],
+        "dual": ["boolean", StrOptions({"auto"}), Hidden(StrOptions({"warn"}))],
+        "verbose": ["verbose"],
+        "random_state": ["random_state"],
+        "max_iter": [Interval(Integral, 0, None, closed="left")],
+    }
+
+    def __init__(
+        self,
+        *,
+        epsilon=0.0,
+        tol=1e-4,
+        C=1.0,
+        loss="epsilon_insensitive",
+        fit_intercept=True,
+        intercept_scaling=1.0,
+        dual="warn",
+        verbose=0,
+        random_state=None,
+        max_iter=1000,
+    ):
+        self.tol = tol
+        self.C = C
+        self.epsilon = epsilon
+        self.fit_intercept = fit_intercept
+        self.intercept_scaling = intercept_scaling
+        self.verbose = verbose
+        self.random_state = random_state
+        self.max_iter = max_iter
+        self.dual = dual
+        self.loss = loss
+
+    @_fit_context(prefer_skip_nested_validation=True)
+    def fit(self, X, y, sample_weight=None):
+        """Fit the model according to the given training data.
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} 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 : array-like of shape (n_samples,)
+            Target vector relative to X.
+
+        sample_weight : array-like of shape (n_samples,), default=None
+            Array of weights that are assigned to individual
+            samples. If not provided,
+            then each sample is given unit weight.
+
+            .. versionadded:: 0.18
+
+        Returns
+        -------
+        self : object
+            An instance of the estimator.
+        """
+        X, y = self._validate_data(
+            X,
+            y,
+            accept_sparse="csr",
+            dtype=np.float64,
+            order="C",
+            accept_large_sparse=False,
+        )
+        penalty = "l2"  # SVR only accepts l2 penalty
+
+        _dual = _validate_dual_parameter(self.dual, self.loss, penalty, "ovr", X)
+
+        self.coef_, self.intercept_, n_iter_ = _fit_liblinear(
+            X,
+            y,
+            self.C,
+            self.fit_intercept,
+            self.intercept_scaling,
+            None,
+            penalty,
+            _dual,
+            self.verbose,
+            self.max_iter,
+            self.tol,
+            self.random_state,
+            loss=self.loss,
+            epsilon=self.epsilon,
+            sample_weight=sample_weight,
+        )
+        self.coef_ = self.coef_.ravel()
+        # Backward compatibility: _fit_liblinear is used both by LinearSVC/R
+        # and LogisticRegression but LogisticRegression sets a structured
+        # `n_iter_` attribute with information about the underlying OvR fits
+        # while LinearSVC/R only reports the maximum value.
+        self.n_iter_ = n_iter_.max().item()
+
+        return self
+
+    def _more_tags(self):
+        return {
+            "_xfail_checks": {
+                "check_sample_weights_invariance": (
+                    "zero sample_weight is not equivalent to removing samples"
+                ),
+            }
+        }
+
+
+class SVC(BaseSVC):
+    """C-Support Vector Classification.
+
+    The implementation is based on libsvm. The fit time scales at least
+    quadratically with the number of samples and may be impractical
+    beyond tens of thousands of samples. For large datasets
+    consider using :class:`~sklearn.svm.LinearSVC` or
+    :class:`~sklearn.linear_model.SGDClassifier` instead, possibly after a
+    :class:`~sklearn.kernel_approximation.Nystroem` transformer or
+    other :ref:`kernel_approximation`.
+
+    The multiclass support is handled according to a one-vs-one scheme.
+
+    For details on the precise mathematical formulation of the provided
+    kernel functions and how `gamma`, `coef0` and `degree` affect each
+    other, see the corresponding section in the narrative documentation:
+    :ref:`svm_kernels`.
+
+    To learn how to tune SVC's hyperparameters, see the following example:
+    :ref:`sphx_glr_auto_examples_model_selection_plot_nested_cross_validation_iris.py`
+
+    Read more in the :ref:`User Guide <svm_classification>`.
+
+    Parameters
+    ----------
+    C : float, default=1.0
+        Regularization parameter. The strength of the regularization is
+        inversely proportional to C. Must be strictly positive. The penalty
+        is a squared l2 penalty.
+
+    kernel : {'linear', 'poly', 'rbf', 'sigmoid', 'precomputed'} or callable,  \
+        default='rbf'
+        Specifies the kernel type to be used in the algorithm. If
+        none is given, 'rbf' will be used. If a callable is given it is used to
+        pre-compute the kernel matrix from data matrices; that matrix should be
+        an array of shape ``(n_samples, n_samples)``. For an intuitive
+        visualization of different kernel types see
+        :ref:`sphx_glr_auto_examples_svm_plot_svm_kernels.py`.
+
+    degree : int, default=3
+        Degree of the polynomial kernel function ('poly').
+        Must be non-negative. Ignored by all other kernels.
+
+    gamma : {'scale', 'auto'} or float, default='scale'
+        Kernel coefficient for 'rbf', 'poly' and 'sigmoid'.
+
+        - if ``gamma='scale'`` (default) is passed then it uses
+          1 / (n_features * X.var()) as value of gamma,
+        - if 'auto', uses 1 / n_features
+        - if float, must be non-negative.
+
+        .. versionchanged:: 0.22
+           The default value of ``gamma`` changed from 'auto' to 'scale'.
+
+    coef0 : float, default=0.0
+        Independent term in kernel function.
+        It is only significant in 'poly' and 'sigmoid'.
+
+    shrinking : bool, default=True
+        Whether to use the shrinking heuristic.
+        See the :ref:`User Guide <shrinking_svm>`.
+
+    probability : bool, default=False
+        Whether to enable probability estimates. This must be enabled prior
+        to calling `fit`, will slow down that method as it internally uses
+        5-fold cross-validation, and `predict_proba` may be inconsistent with
+        `predict`. Read more in the :ref:`User Guide <scores_probabilities>`.
+
+    tol : float, default=1e-3
+        Tolerance for stopping criterion.
+
+    cache_size : float, default=200
+        Specify the size of the kernel cache (in MB).
+
+    class_weight : dict or 'balanced', default=None
+        Set the parameter C of class i to class_weight[i]*C for
+        SVC. If not given, all classes are supposed to have
+        weight one.
+        The "balanced" mode uses the values of y to automatically adjust
+        weights inversely proportional to class frequencies in the input data
+        as ``n_samples / (n_classes * np.bincount(y))``.
+
+    verbose : bool, default=False
+        Enable verbose output. Note that this setting takes advantage of a
+        per-process runtime setting in libsvm that, if enabled, may not work
+        properly in a multithreaded context.
+
+    max_iter : int, default=-1
+        Hard limit on iterations within solver, or -1 for no limit.
+
+    decision_function_shape : {'ovo', 'ovr'}, default='ovr'
+        Whether to return a one-vs-rest ('ovr') decision function of shape
+        (n_samples, n_classes) as all other classifiers, or the original
+        one-vs-one ('ovo') decision function of libsvm which has shape
+        (n_samples, n_classes * (n_classes - 1) / 2). However, note that
+        internally, one-vs-one ('ovo') is always used as a multi-class strategy
+        to train models; an ovr matrix is only constructed from the ovo matrix.
+        The parameter is ignored for binary classification.
+
+        .. versionchanged:: 0.19
+            decision_function_shape is 'ovr' by default.
+
+        .. versionadded:: 0.17
+           *decision_function_shape='ovr'* is recommended.
+
+        .. versionchanged:: 0.17
+           Deprecated *decision_function_shape='ovo' and None*.
+
+    break_ties : bool, default=False
+        If true, ``decision_function_shape='ovr'``, and number of classes > 2,
+        :term:`predict` will break ties according to the confidence values of
+        :term:`decision_function`; otherwise the first class among the tied
+        classes is returned. Please note that breaking ties comes at a
+        relatively high computational cost compared to a simple predict.
+
+        .. versionadded:: 0.22
+
+    random_state : int, RandomState instance or None, default=None
+        Controls the pseudo random number generation for shuffling the data for
+        probability estimates. Ignored when `probability` is False.
+        Pass an int for reproducible output across multiple function calls.
+        See :term:`Glossary <random_state>`.
+
+    Attributes
+    ----------
+    class_weight_ : ndarray of shape (n_classes,)
+        Multipliers of parameter C for each class.
+        Computed based on the ``class_weight`` parameter.
+
+    classes_ : ndarray of shape (n_classes,)
+        The classes labels.
+
+    coef_ : ndarray of shape (n_classes * (n_classes - 1) / 2, n_features)
+        Weights assigned to the features (coefficients in the primal
+        problem). This is only available in the case of a linear kernel.
+
+        `coef_` is a readonly property derived from `dual_coef_` and
+        `support_vectors_`.
+
+    dual_coef_ : ndarray of shape (n_classes -1, n_SV)
+        Dual coefficients of the support vector in the decision
+        function (see :ref:`sgd_mathematical_formulation`), multiplied by
+        their targets.
+        For multiclass, coefficient for all 1-vs-1 classifiers.
+        The layout of the coefficients in the multiclass case is somewhat
+        non-trivial. See the :ref:`multi-class section of the User Guide
+        <svm_multi_class>` for details.
+
+    fit_status_ : int
+        0 if correctly fitted, 1 otherwise (will raise warning)
+
+    intercept_ : ndarray of shape (n_classes * (n_classes - 1) / 2,)
+        Constants in decision function.
+
+    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_ : ndarray of shape (n_classes * (n_classes - 1) // 2,)
+        Number of iterations run by the optimization routine to fit the model.
+        The shape of this attribute depends on the number of models optimized
+        which in turn depends on the number of classes.
+
+        .. versionadded:: 1.1
+
+    support_ : ndarray of shape (n_SV)
+        Indices of support vectors.
+
+    support_vectors_ : ndarray of shape (n_SV, n_features)
+        Support vectors. An empty array if kernel is precomputed.
+
+    n_support_ : ndarray of shape (n_classes,), dtype=int32
+        Number of support vectors for each class.
+
+    probA_ : ndarray of shape (n_classes * (n_classes - 1) / 2)
+    probB_ : ndarray of shape (n_classes * (n_classes - 1) / 2)
+        If `probability=True`, it corresponds to the parameters learned in
+        Platt scaling to produce probability estimates from decision values.
+        If `probability=False`, it's an empty array. Platt scaling uses the
+        logistic function
+        ``1 / (1 + exp(decision_value * probA_ + probB_))``
+        where ``probA_`` and ``probB_`` are learned from the dataset [2]_. For
+        more information on the multiclass case and training procedure see
+        section 8 of [1]_.
+
+    shape_fit_ : tuple of int of shape (n_dimensions_of_X,)
+        Array dimensions of training vector ``X``.
+
+    See Also
+    --------
+    SVR : Support Vector Machine for Regression implemented using libsvm.
+
+    LinearSVC : Scalable Linear Support Vector Machine for classification
+        implemented using liblinear. Check the See Also section of
+        LinearSVC for more comparison element.
+
+    References
+    ----------
+    .. [1] `LIBSVM: A Library for Support Vector Machines
+        <http://www.csie.ntu.edu.tw/~cjlin/papers/libsvm.pdf>`_
+
+    .. [2] `Platt, John (1999). "Probabilistic Outputs for Support Vector
+        Machines and Comparisons to Regularized Likelihood Methods"
+        <https://citeseerx.ist.psu.edu/doc_view/pid/42e5ed832d4310ce4378c44d05570439df28a393>`_
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from sklearn.pipeline import make_pipeline
+    >>> from sklearn.preprocessing import StandardScaler
+    >>> X = np.array([[-1, -1], [-2, -1], [1, 1], [2, 1]])
+    >>> y = np.array([1, 1, 2, 2])
+    >>> from sklearn.svm import SVC
+    >>> clf = make_pipeline(StandardScaler(), SVC(gamma='auto'))
+    >>> clf.fit(X, y)
+    Pipeline(steps=[('standardscaler', StandardScaler()),
+                    ('svc', SVC(gamma='auto'))])
+
+    >>> print(clf.predict([[-0.8, -1]]))
+    [1]
+    """
+
+    _impl = "c_svc"
+
+    def __init__(
+        self,
+        *,
+        C=1.0,
+        kernel="rbf",
+        degree=3,
+        gamma="scale",
+        coef0=0.0,
+        shrinking=True,
+        probability=False,
+        tol=1e-3,
+        cache_size=200,
+        class_weight=None,
+        verbose=False,
+        max_iter=-1,
+        decision_function_shape="ovr",
+        break_ties=False,
+        random_state=None,
+    ):
+        super().__init__(
+            kernel=kernel,
+            degree=degree,
+            gamma=gamma,
+            coef0=coef0,
+            tol=tol,
+            C=C,
+            nu=0.0,
+            shrinking=shrinking,
+            probability=probability,
+            cache_size=cache_size,
+            class_weight=class_weight,
+            verbose=verbose,
+            max_iter=max_iter,
+            decision_function_shape=decision_function_shape,
+            break_ties=break_ties,
+            random_state=random_state,
+        )
+
+    def _more_tags(self):
+        return {
+            "_xfail_checks": {
+                "check_sample_weights_invariance": (
+                    "zero sample_weight is not equivalent to removing samples"
+                ),
+            }
+        }
+
+
+class NuSVC(BaseSVC):
+    """Nu-Support Vector Classification.
+
+    Similar to SVC but uses a parameter to control the number of support
+    vectors.
+
+    The implementation is based on libsvm.
+
+    Read more in the :ref:`User Guide <svm_classification>`.
+
+    Parameters
+    ----------
+    nu : float, default=0.5
+        An upper bound on the fraction of margin errors (see :ref:`User Guide
+        <nu_svc>`) and a lower bound of the fraction of support vectors.
+        Should be in the interval (0, 1].
+
+    kernel : {'linear', 'poly', 'rbf', 'sigmoid', 'precomputed'} or callable,  \
+        default='rbf'
+        Specifies the kernel type to be used in the algorithm.
+        If none is given, 'rbf' will be used. If a callable is given it is
+        used to precompute the kernel matrix. For an intuitive
+        visualization of different kernel types see
+        :ref:`sphx_glr_auto_examples_svm_plot_svm_kernels.py`.
+
+    degree : int, default=3
+        Degree of the polynomial kernel function ('poly').
+        Must be non-negative. Ignored by all other kernels.
+
+    gamma : {'scale', 'auto'} or float, default='scale'
+        Kernel coefficient for 'rbf', 'poly' and 'sigmoid'.
+
+        - if ``gamma='scale'`` (default) is passed then it uses
+          1 / (n_features * X.var()) as value of gamma,
+        - if 'auto', uses 1 / n_features
+        - if float, must be non-negative.
+
+        .. versionchanged:: 0.22
+           The default value of ``gamma`` changed from 'auto' to 'scale'.
+
+    coef0 : float, default=0.0
+        Independent term in kernel function.
+        It is only significant in 'poly' and 'sigmoid'.
+
+    shrinking : bool, default=True
+        Whether to use the shrinking heuristic.
+        See the :ref:`User Guide <shrinking_svm>`.
+
+    probability : bool, default=False
+        Whether to enable probability estimates. This must be enabled prior
+        to calling `fit`, will slow down that method as it internally uses
+        5-fold cross-validation, and `predict_proba` may be inconsistent with
+        `predict`. Read more in the :ref:`User Guide <scores_probabilities>`.
+
+    tol : float, default=1e-3
+        Tolerance for stopping criterion.
+
+    cache_size : float, default=200
+        Specify the size of the kernel cache (in MB).
+
+    class_weight : {dict, 'balanced'}, default=None
+        Set the parameter C of class i to class_weight[i]*C for
+        SVC. If not given, all classes are supposed to have
+        weight one. The "balanced" mode uses the values of y to automatically
+        adjust weights inversely proportional to class frequencies as
+        ``n_samples / (n_classes * np.bincount(y))``.
+
+    verbose : bool, default=False
+        Enable verbose output. Note that this setting takes advantage of a
+        per-process runtime setting in libsvm that, if enabled, may not work
+        properly in a multithreaded context.
+
+    max_iter : int, default=-1
+        Hard limit on iterations within solver, or -1 for no limit.
+
+    decision_function_shape : {'ovo', 'ovr'}, default='ovr'
+        Whether to return a one-vs-rest ('ovr') decision function of shape
+        (n_samples, n_classes) as all other classifiers, or the original
+        one-vs-one ('ovo') decision function of libsvm which has shape
+        (n_samples, n_classes * (n_classes - 1) / 2). However, one-vs-one
+        ('ovo') is always used as multi-class strategy. The parameter is
+        ignored for binary classification.
+
+        .. versionchanged:: 0.19
+            decision_function_shape is 'ovr' by default.
+
+        .. versionadded:: 0.17
+           *decision_function_shape='ovr'* is recommended.
+
+        .. versionchanged:: 0.17
+           Deprecated *decision_function_shape='ovo' and None*.
+
+    break_ties : bool, default=False
+        If true, ``decision_function_shape='ovr'``, and number of classes > 2,
+        :term:`predict` will break ties according to the confidence values of
+        :term:`decision_function`; otherwise the first class among the tied
+        classes is returned. Please note that breaking ties comes at a
+        relatively high computational cost compared to a simple predict.
+
+        .. versionadded:: 0.22
+
+    random_state : int, RandomState instance or None, default=None
+        Controls the pseudo random number generation for shuffling the data for
+        probability estimates. Ignored when `probability` is False.
+        Pass an int for reproducible output across multiple function calls.
+        See :term:`Glossary <random_state>`.
+
+    Attributes
+    ----------
+    class_weight_ : ndarray of shape (n_classes,)
+        Multipliers of parameter C of each class.
+        Computed based on the ``class_weight`` parameter.
+
+    classes_ : ndarray of shape (n_classes,)
+        The unique classes labels.
+
+    coef_ : ndarray of shape (n_classes * (n_classes -1) / 2, n_features)
+        Weights assigned to the features (coefficients in the primal
+        problem). This is only available in the case of a linear kernel.
+
+        `coef_` is readonly property derived from `dual_coef_` and
+        `support_vectors_`.
+
+    dual_coef_ : ndarray of shape (n_classes - 1, n_SV)
+        Dual coefficients of the support vector in the decision
+        function (see :ref:`sgd_mathematical_formulation`), multiplied by
+        their targets.
+        For multiclass, coefficient for all 1-vs-1 classifiers.
+        The layout of the coefficients in the multiclass case is somewhat
+        non-trivial. See the :ref:`multi-class section of the User Guide
+        <svm_multi_class>` for details.
+
+    fit_status_ : int
+        0 if correctly fitted, 1 if the algorithm did not converge.
+
+    intercept_ : ndarray of shape (n_classes * (n_classes - 1) / 2,)
+        Constants in decision function.
+
+    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_ : ndarray of shape (n_classes * (n_classes - 1) // 2,)
+        Number of iterations run by the optimization routine to fit the model.
+        The shape of this attribute depends on the number of models optimized
+        which in turn depends on the number of classes.
+
+        .. versionadded:: 1.1
+
+    support_ : ndarray of shape (n_SV,)
+        Indices of support vectors.
+
+    support_vectors_ : ndarray of shape (n_SV, n_features)
+        Support vectors.
+
+    n_support_ : ndarray of shape (n_classes,), dtype=int32
+        Number of support vectors for each class.
+
+    fit_status_ : int
+        0 if correctly fitted, 1 if the algorithm did not converge.
+
+    probA_ : ndarray of shape (n_classes * (n_classes - 1) / 2,)
+
+    probB_ : ndarray of shape (n_classes * (n_classes - 1) / 2,)
+        If `probability=True`, it corresponds to the parameters learned in
+        Platt scaling to produce probability estimates from decision values.
+        If `probability=False`, it's an empty array. Platt scaling uses the
+        logistic function
+        ``1 / (1 + exp(decision_value * probA_ + probB_))``
+        where ``probA_`` and ``probB_`` are learned from the dataset [2]_. For
+        more information on the multiclass case and training procedure see
+        section 8 of [1]_.
+
+    shape_fit_ : tuple of int of shape (n_dimensions_of_X,)
+        Array dimensions of training vector ``X``.
+
+    See Also
+    --------
+    SVC : Support Vector Machine for classification using libsvm.
+
+    LinearSVC : Scalable linear Support Vector Machine for classification using
+        liblinear.
+
+    References
+    ----------
+    .. [1] `LIBSVM: A Library for Support Vector Machines
+        <http://www.csie.ntu.edu.tw/~cjlin/papers/libsvm.pdf>`_
+
+    .. [2] `Platt, John (1999). "Probabilistic Outputs for Support Vector
+        Machines and Comparisons to Regularized Likelihood Methods"
+        <https://citeseerx.ist.psu.edu/doc_view/pid/42e5ed832d4310ce4378c44d05570439df28a393>`_
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> X = np.array([[-1, -1], [-2, -1], [1, 1], [2, 1]])
+    >>> y = np.array([1, 1, 2, 2])
+    >>> from sklearn.pipeline import make_pipeline
+    >>> from sklearn.preprocessing import StandardScaler
+    >>> from sklearn.svm import NuSVC
+    >>> clf = make_pipeline(StandardScaler(), NuSVC())
+    >>> clf.fit(X, y)
+    Pipeline(steps=[('standardscaler', StandardScaler()), ('nusvc', NuSVC())])
+    >>> print(clf.predict([[-0.8, -1]]))
+    [1]
+    """
+
+    _impl = "nu_svc"
+
+    _parameter_constraints: dict = {
+        **BaseSVC._parameter_constraints,
+        "nu": [Interval(Real, 0.0, 1.0, closed="right")],
+    }
+    _parameter_constraints.pop("C")
+
+    def __init__(
+        self,
+        *,
+        nu=0.5,
+        kernel="rbf",
+        degree=3,
+        gamma="scale",
+        coef0=0.0,
+        shrinking=True,
+        probability=False,
+        tol=1e-3,
+        cache_size=200,
+        class_weight=None,
+        verbose=False,
+        max_iter=-1,
+        decision_function_shape="ovr",
+        break_ties=False,
+        random_state=None,
+    ):
+        super().__init__(
+            kernel=kernel,
+            degree=degree,
+            gamma=gamma,
+            coef0=coef0,
+            tol=tol,
+            C=0.0,
+            nu=nu,
+            shrinking=shrinking,
+            probability=probability,
+            cache_size=cache_size,
+            class_weight=class_weight,
+            verbose=verbose,
+            max_iter=max_iter,
+            decision_function_shape=decision_function_shape,
+            break_ties=break_ties,
+            random_state=random_state,
+        )
+
+    def _more_tags(self):
+        return {
+            "_xfail_checks": {
+                "check_methods_subset_invariance": (
+                    "fails for the decision_function method"
+                ),
+                "check_class_weight_classifiers": "class_weight is ignored.",
+                "check_sample_weights_invariance": (
+                    "zero sample_weight is not equivalent to removing samples"
+                ),
+                "check_classifiers_one_label_sample_weights": (
+                    "specified nu is infeasible for the fit."
+                ),
+            }
+        }
+
+
+class SVR(RegressorMixin, BaseLibSVM):
+    """Epsilon-Support Vector Regression.
+
+    The free parameters in the model are C and epsilon.
+
+    The implementation is based on libsvm. The fit time complexity
+    is more than quadratic with the number of samples which makes it hard
+    to scale to datasets with more than a couple of 10000 samples. For large
+    datasets consider using :class:`~sklearn.svm.LinearSVR` or
+    :class:`~sklearn.linear_model.SGDRegressor` instead, possibly after a
+    :class:`~sklearn.kernel_approximation.Nystroem` transformer or
+    other :ref:`kernel_approximation`.
+
+    Read more in the :ref:`User Guide <svm_regression>`.
+
+    Parameters
+    ----------
+    kernel : {'linear', 'poly', 'rbf', 'sigmoid', 'precomputed'} or callable,  \
+        default='rbf'
+         Specifies the kernel type to be used in the algorithm.
+         If none is given, 'rbf' will be used. If a callable is given it is
+         used to precompute the kernel matrix.
+
+    degree : int, default=3
+        Degree of the polynomial kernel function ('poly').
+        Must be non-negative. Ignored by all other kernels.
+
+    gamma : {'scale', 'auto'} or float, default='scale'
+        Kernel coefficient for 'rbf', 'poly' and 'sigmoid'.
+
+        - if ``gamma='scale'`` (default) is passed then it uses
+          1 / (n_features * X.var()) as value of gamma,
+        - if 'auto', uses 1 / n_features
+        - if float, must be non-negative.
+
+        .. versionchanged:: 0.22
+           The default value of ``gamma`` changed from 'auto' to 'scale'.
+
+    coef0 : float, default=0.0
+        Independent term in kernel function.
+        It is only significant in 'poly' and 'sigmoid'.
+
+    tol : float, default=1e-3
+        Tolerance for stopping criterion.
+
+    C : float, default=1.0
+        Regularization parameter. The strength of the regularization is
+        inversely proportional to C. Must be strictly positive.
+        The penalty is a squared l2 penalty.
+
+    epsilon : float, default=0.1
+         Epsilon in the epsilon-SVR model. It specifies the epsilon-tube
+         within which no penalty is associated in the training loss function
+         with points predicted within a distance epsilon from the actual
+         value. Must be non-negative.
+
+    shrinking : bool, default=True
+        Whether to use the shrinking heuristic.
+        See the :ref:`User Guide <shrinking_svm>`.
+
+    cache_size : float, default=200
+        Specify the size of the kernel cache (in MB).
+
+    verbose : bool, default=False
+        Enable verbose output. Note that this setting takes advantage of a
+        per-process runtime setting in libsvm that, if enabled, may not work
+        properly in a multithreaded context.
+
+    max_iter : int, default=-1
+        Hard limit on iterations within solver, or -1 for no limit.
+
+    Attributes
+    ----------
+    coef_ : ndarray of shape (1, n_features)
+        Weights assigned to the features (coefficients in the primal
+        problem). This is only available in the case of a linear kernel.
+
+        `coef_` is readonly property derived from `dual_coef_` and
+        `support_vectors_`.
+
+    dual_coef_ : ndarray of shape (1, n_SV)
+        Coefficients of the support vector in the decision function.
+
+    fit_status_ : int
+        0 if correctly fitted, 1 otherwise (will raise warning)
+
+    intercept_ : ndarray of shape (1,)
+        Constants in decision function.
+
+    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 by the optimization routine to fit the model.
+
+        .. versionadded:: 1.1
+
+    n_support_ : ndarray of shape (1,), dtype=int32
+        Number of support vectors.
+
+    shape_fit_ : tuple of int of shape (n_dimensions_of_X,)
+        Array dimensions of training vector ``X``.
+
+    support_ : ndarray of shape (n_SV,)
+        Indices of support vectors.
+
+    support_vectors_ : ndarray of shape (n_SV, n_features)
+        Support vectors.
+
+    See Also
+    --------
+    NuSVR : Support Vector Machine for regression implemented using libsvm
+        using a parameter to control the number of support vectors.
+
+    LinearSVR : Scalable Linear Support Vector Machine for regression
+        implemented using liblinear.
+
+    References
+    ----------
+    .. [1] `LIBSVM: A Library for Support Vector Machines
+        <http://www.csie.ntu.edu.tw/~cjlin/papers/libsvm.pdf>`_
+
+    .. [2] `Platt, John (1999). "Probabilistic Outputs for Support Vector
+        Machines and Comparisons to Regularized Likelihood Methods"
+        <https://citeseerx.ist.psu.edu/doc_view/pid/42e5ed832d4310ce4378c44d05570439df28a393>`_
+
+    Examples
+    --------
+    >>> from sklearn.svm import SVR
+    >>> from sklearn.pipeline import make_pipeline
+    >>> from sklearn.preprocessing import StandardScaler
+    >>> import numpy as np
+    >>> n_samples, n_features = 10, 5
+    >>> rng = np.random.RandomState(0)
+    >>> y = rng.randn(n_samples)
+    >>> X = rng.randn(n_samples, n_features)
+    >>> regr = make_pipeline(StandardScaler(), SVR(C=1.0, epsilon=0.2))
+    >>> regr.fit(X, y)
+    Pipeline(steps=[('standardscaler', StandardScaler()),
+                    ('svr', SVR(epsilon=0.2))])
+    """
+
+    _impl = "epsilon_svr"
+
+    _parameter_constraints: dict = {**BaseLibSVM._parameter_constraints}
+    for unused_param in ["class_weight", "nu", "probability", "random_state"]:
+        _parameter_constraints.pop(unused_param)
+
+    def __init__(
+        self,
+        *,
+        kernel="rbf",
+        degree=3,
+        gamma="scale",
+        coef0=0.0,
+        tol=1e-3,
+        C=1.0,
+        epsilon=0.1,
+        shrinking=True,
+        cache_size=200,
+        verbose=False,
+        max_iter=-1,
+    ):
+        super().__init__(
+            kernel=kernel,
+            degree=degree,
+            gamma=gamma,
+            coef0=coef0,
+            tol=tol,
+            C=C,
+            nu=0.0,
+            epsilon=epsilon,
+            verbose=verbose,
+            shrinking=shrinking,
+            probability=False,
+            cache_size=cache_size,
+            class_weight=None,
+            max_iter=max_iter,
+            random_state=None,
+        )
+
+    def _more_tags(self):
+        return {
+            "_xfail_checks": {
+                "check_sample_weights_invariance": (
+                    "zero sample_weight is not equivalent to removing samples"
+                ),
+            }
+        }
+
+
+class NuSVR(RegressorMixin, BaseLibSVM):
+    """Nu Support Vector Regression.
+
+    Similar to NuSVC, for regression, uses a parameter nu to control
+    the number of support vectors. However, unlike NuSVC, where nu
+    replaces C, here nu replaces the parameter epsilon of epsilon-SVR.
+
+    The implementation is based on libsvm.
+
+    Read more in the :ref:`User Guide <svm_regression>`.
+
+    Parameters
+    ----------
+    nu : float, default=0.5
+        An upper bound on the fraction of training errors and a lower bound of
+        the fraction of support vectors. Should be in the interval (0, 1].  By
+        default 0.5 will be taken.
+
+    C : float, default=1.0
+        Penalty parameter C of the error term.
+
+    kernel : {'linear', 'poly', 'rbf', 'sigmoid', 'precomputed'} or callable,  \
+        default='rbf'
+         Specifies the kernel type to be used in the algorithm.
+         If none is given, 'rbf' will be used. If a callable is given it is
+         used to precompute the kernel matrix.
+
+    degree : int, default=3
+        Degree of the polynomial kernel function ('poly').
+        Must be non-negative. Ignored by all other kernels.
+
+    gamma : {'scale', 'auto'} or float, default='scale'
+        Kernel coefficient for 'rbf', 'poly' and 'sigmoid'.
+
+        - if ``gamma='scale'`` (default) is passed then it uses
+          1 / (n_features * X.var()) as value of gamma,
+        - if 'auto', uses 1 / n_features
+        - if float, must be non-negative.
+
+        .. versionchanged:: 0.22
+           The default value of ``gamma`` changed from 'auto' to 'scale'.
+
+    coef0 : float, default=0.0
+        Independent term in kernel function.
+        It is only significant in 'poly' and 'sigmoid'.
+
+    shrinking : bool, default=True
+        Whether to use the shrinking heuristic.
+        See the :ref:`User Guide <shrinking_svm>`.
+
+    tol : float, default=1e-3
+        Tolerance for stopping criterion.
+
+    cache_size : float, default=200
+        Specify the size of the kernel cache (in MB).
+
+    verbose : bool, default=False
+        Enable verbose output. Note that this setting takes advantage of a
+        per-process runtime setting in libsvm that, if enabled, may not work
+        properly in a multithreaded context.
+
+    max_iter : int, default=-1
+        Hard limit on iterations within solver, or -1 for no limit.
+
+    Attributes
+    ----------
+    coef_ : ndarray of shape (1, n_features)
+        Weights assigned to the features (coefficients in the primal
+        problem). This is only available in the case of a linear kernel.
+
+        `coef_` is readonly property derived from `dual_coef_` and
+        `support_vectors_`.
+
+    dual_coef_ : ndarray of shape (1, n_SV)
+        Coefficients of the support vector in the decision function.
+
+    fit_status_ : int
+        0 if correctly fitted, 1 otherwise (will raise warning)
+
+    intercept_ : ndarray of shape (1,)
+        Constants in decision function.
+
+    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 by the optimization routine to fit the model.
+
+        .. versionadded:: 1.1
+
+    n_support_ : ndarray of shape (1,), dtype=int32
+        Number of support vectors.
+
+    shape_fit_ : tuple of int of shape (n_dimensions_of_X,)
+        Array dimensions of training vector ``X``.
+
+    support_ : ndarray of shape (n_SV,)
+        Indices of support vectors.
+
+    support_vectors_ : ndarray of shape (n_SV, n_features)
+        Support vectors.
+
+    See Also
+    --------
+    NuSVC : Support Vector Machine for classification implemented with libsvm
+        with a parameter to control the number of support vectors.
+
+    SVR : Epsilon Support Vector Machine for regression implemented with
+        libsvm.
+
+    References
+    ----------
+    .. [1] `LIBSVM: A Library for Support Vector Machines
+        <http://www.csie.ntu.edu.tw/~cjlin/papers/libsvm.pdf>`_
+
+    .. [2] `Platt, John (1999). "Probabilistic Outputs for Support Vector
+        Machines and Comparisons to Regularized Likelihood Methods"
+        <https://citeseerx.ist.psu.edu/doc_view/pid/42e5ed832d4310ce4378c44d05570439df28a393>`_
+
+    Examples
+    --------
+    >>> from sklearn.svm import NuSVR
+    >>> from sklearn.pipeline import make_pipeline
+    >>> from sklearn.preprocessing import StandardScaler
+    >>> import numpy as np
+    >>> n_samples, n_features = 10, 5
+    >>> np.random.seed(0)
+    >>> y = np.random.randn(n_samples)
+    >>> X = np.random.randn(n_samples, n_features)
+    >>> regr = make_pipeline(StandardScaler(), NuSVR(C=1.0, nu=0.1))
+    >>> regr.fit(X, y)
+    Pipeline(steps=[('standardscaler', StandardScaler()),
+                    ('nusvr', NuSVR(nu=0.1))])
+    """
+
+    _impl = "nu_svr"
+
+    _parameter_constraints: dict = {**BaseLibSVM._parameter_constraints}
+    for unused_param in ["class_weight", "epsilon", "probability", "random_state"]:
+        _parameter_constraints.pop(unused_param)
+
+    def __init__(
+        self,
+        *,
+        nu=0.5,
+        C=1.0,
+        kernel="rbf",
+        degree=3,
+        gamma="scale",
+        coef0=0.0,
+        shrinking=True,
+        tol=1e-3,
+        cache_size=200,
+        verbose=False,
+        max_iter=-1,
+    ):
+        super().__init__(
+            kernel=kernel,
+            degree=degree,
+            gamma=gamma,
+            coef0=coef0,
+            tol=tol,
+            C=C,
+            nu=nu,
+            epsilon=0.0,
+            shrinking=shrinking,
+            probability=False,
+            cache_size=cache_size,
+            class_weight=None,
+            verbose=verbose,
+            max_iter=max_iter,
+            random_state=None,
+        )
+
+    def _more_tags(self):
+        return {
+            "_xfail_checks": {
+                "check_sample_weights_invariance": (
+                    "zero sample_weight is not equivalent to removing samples"
+                ),
+            }
+        }
+
+
+class OneClassSVM(OutlierMixin, BaseLibSVM):
+    """Unsupervised Outlier Detection.
+
+    Estimate the support of a high-dimensional distribution.
+
+    The implementation is based on libsvm.
+
+    Read more in the :ref:`User Guide <outlier_detection>`.
+
+    Parameters
+    ----------
+    kernel : {'linear', 'poly', 'rbf', 'sigmoid', 'precomputed'} or callable,  \
+        default='rbf'
+         Specifies the kernel type to be used in the algorithm.
+         If none is given, 'rbf' will be used. If a callable is given it is
+         used to precompute the kernel matrix.
+
+    degree : int, default=3
+        Degree of the polynomial kernel function ('poly').
+        Must be non-negative. Ignored by all other kernels.
+
+    gamma : {'scale', 'auto'} or float, default='scale'
+        Kernel coefficient for 'rbf', 'poly' and 'sigmoid'.
+
+        - if ``gamma='scale'`` (default) is passed then it uses
+          1 / (n_features * X.var()) as value of gamma,
+        - if 'auto', uses 1 / n_features
+        - if float, must be non-negative.
+
+        .. versionchanged:: 0.22
+           The default value of ``gamma`` changed from 'auto' to 'scale'.
+
+    coef0 : float, default=0.0
+        Independent term in kernel function.
+        It is only significant in 'poly' and 'sigmoid'.
+
+    tol : float, default=1e-3
+        Tolerance for stopping criterion.
+
+    nu : float, default=0.5
+        An upper bound on the fraction of training
+        errors and a lower bound of the fraction of support
+        vectors. Should be in the interval (0, 1]. By default 0.5
+        will be taken.
+
+    shrinking : bool, default=True
+        Whether to use the shrinking heuristic.
+        See the :ref:`User Guide <shrinking_svm>`.
+
+    cache_size : float, default=200
+        Specify the size of the kernel cache (in MB).
+
+    verbose : bool, default=False
+        Enable verbose output. Note that this setting takes advantage of a
+        per-process runtime setting in libsvm that, if enabled, may not work
+        properly in a multithreaded context.
+
+    max_iter : int, default=-1
+        Hard limit on iterations within solver, or -1 for no limit.
+
+    Attributes
+    ----------
+    coef_ : ndarray of shape (1, n_features)
+        Weights assigned to the features (coefficients in the primal
+        problem). This is only available in the case of a linear kernel.
+
+        `coef_` is readonly property derived from `dual_coef_` and
+        `support_vectors_`.
+
+    dual_coef_ : ndarray of shape (1, n_SV)
+        Coefficients of the support vectors in the decision function.
+
+    fit_status_ : int
+        0 if correctly fitted, 1 otherwise (will raise warning)
+
+    intercept_ : ndarray of shape (1,)
+        Constant in the decision function.
+
+    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 by the optimization routine to fit the model.
+
+        .. versionadded:: 1.1
+
+    n_support_ : ndarray of shape (n_classes,), dtype=int32
+        Number of support vectors for each class.
+
+    offset_ : float
+        Offset used to define the decision function from the raw scores.
+        We have the relation: decision_function = score_samples - `offset_`.
+        The offset is the opposite of `intercept_` and is provided for
+        consistency with other outlier detection algorithms.
+
+        .. versionadded:: 0.20
+
+    shape_fit_ : tuple of int of shape (n_dimensions_of_X,)
+        Array dimensions of training vector ``X``.
+
+    support_ : ndarray of shape (n_SV,)
+        Indices of support vectors.
+
+    support_vectors_ : ndarray of shape (n_SV, n_features)
+        Support vectors.
+
+    See Also
+    --------
+    sklearn.linear_model.SGDOneClassSVM : Solves linear One-Class SVM using
+        Stochastic Gradient Descent.
+    sklearn.neighbors.LocalOutlierFactor : Unsupervised Outlier Detection using
+        Local Outlier Factor (LOF).
+    sklearn.ensemble.IsolationForest : Isolation Forest Algorithm.
+
+    Examples
+    --------
+    >>> from sklearn.svm import OneClassSVM
+    >>> X = [[0], [0.44], [0.45], [0.46], [1]]
+    >>> clf = OneClassSVM(gamma='auto').fit(X)
+    >>> clf.predict(X)
+    array([-1,  1,  1,  1, -1])
+    >>> clf.score_samples(X)
+    array([1.7798..., 2.0547..., 2.0556..., 2.0561..., 1.7332...])
+    """
+
+    _impl = "one_class"
+
+    _parameter_constraints: dict = {**BaseLibSVM._parameter_constraints}
+    for unused_param in ["C", "class_weight", "epsilon", "probability", "random_state"]:
+        _parameter_constraints.pop(unused_param)
+
+    def __init__(
+        self,
+        *,
+        kernel="rbf",
+        degree=3,
+        gamma="scale",
+        coef0=0.0,
+        tol=1e-3,
+        nu=0.5,
+        shrinking=True,
+        cache_size=200,
+        verbose=False,
+        max_iter=-1,
+    ):
+        super().__init__(
+            kernel,
+            degree,
+            gamma,
+            coef0,
+            tol,
+            0.0,
+            nu,
+            0.0,
+            shrinking,
+            False,
+            cache_size,
+            None,
+            verbose,
+            max_iter,
+            random_state=None,
+        )
+
+    def fit(self, X, y=None, sample_weight=None):
+        """Detect the soft boundary of the set of samples X.
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} of shape (n_samples, n_features)
+            Set of samples, 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.
+
+        sample_weight : array-like of shape (n_samples,), default=None
+            Per-sample weights. Rescale C per sample. Higher weights
+            force the classifier to put more emphasis on these points.
+
+        Returns
+        -------
+        self : object
+            Fitted estimator.
+
+        Notes
+        -----
+        If X is not a C-ordered contiguous array it is copied.
+        """
+        super().fit(X, np.ones(_num_samples(X)), sample_weight=sample_weight)
+        self.offset_ = -self._intercept_
+        return self
+
+    def decision_function(self, X):
+        """Signed distance to the separating hyperplane.
+
+        Signed distance is positive for an inlier and negative for an outlier.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+            The data matrix.
+
+        Returns
+        -------
+        dec : ndarray of shape (n_samples,)
+            Returns the decision function of the samples.
+        """
+        dec = self._decision_function(X).ravel()
+        return dec
+
+    def score_samples(self, X):
+        """Raw scoring function of the samples.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+            The data matrix.
+
+        Returns
+        -------
+        score_samples : ndarray of shape (n_samples,)
+            Returns the (unshifted) scoring function of the samples.
+        """
+        return self.decision_function(X) + self.offset_
+
+    def predict(self, X):
+        """Perform classification on samples in X.
+
+        For a one-class model, +1 or -1 is returned.
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} of shape (n_samples, n_features) or \
+                (n_samples_test, n_samples_train)
+            For kernel="precomputed", the expected shape of X is
+            (n_samples_test, n_samples_train).
+
+        Returns
+        -------
+        y_pred : ndarray of shape (n_samples,)
+            Class labels for samples in X.
+        """
+        y = super().predict(X)
+        return np.asarray(y, dtype=np.intp)
+
+    def _more_tags(self):
+        return {
+            "_xfail_checks": {
+                "check_sample_weights_invariance": (
+                    "zero sample_weight is not equivalent to removing samples"
+                ),
+            }
+        }

venv/lib/python3.10/site-packages/sklearn/svm/tests/test_bounds.py

@@ -0,0 +1,142 @@
+import numpy as np
+import pytest
+from scipy import stats
+
+from sklearn.linear_model import LogisticRegression
+from sklearn.svm import LinearSVC
+from sklearn.svm._bounds import l1_min_c
+from sklearn.svm._newrand import bounded_rand_int_wrap, set_seed_wrap
+from sklearn.utils.fixes import CSR_CONTAINERS
+
+dense_X = [[-1, 0], [0, 1], [1, 1], [1, 1]]
+
+Y1 = [0, 1, 1, 1]
+Y2 = [2, 1, 0, 0]
+
+
+@pytest.mark.parametrize("X_container", CSR_CONTAINERS + [np.array])
+@pytest.mark.parametrize("loss", ["squared_hinge", "log"])
+@pytest.mark.parametrize("Y_label", ["two-classes", "multi-class"])
+@pytest.mark.parametrize("intercept_label", ["no-intercept", "fit-intercept"])
+def test_l1_min_c(X_container, loss, Y_label, intercept_label):
+    Ys = {"two-classes": Y1, "multi-class": Y2}
+    intercepts = {
+        "no-intercept": {"fit_intercept": False},
+        "fit-intercept": {"fit_intercept": True, "intercept_scaling": 10},
+    }
+
+    X = X_container(dense_X)
+    Y = Ys[Y_label]
+    intercept_params = intercepts[intercept_label]
+    check_l1_min_c(X, Y, loss, **intercept_params)
+
+
+def check_l1_min_c(X, y, loss, fit_intercept=True, intercept_scaling=1.0):
+    min_c = l1_min_c(
+        X,
+        y,
+        loss=loss,
+        fit_intercept=fit_intercept,
+        intercept_scaling=intercept_scaling,
+    )
+
+    clf = {
+        "log": LogisticRegression(penalty="l1", solver="liblinear"),
+        "squared_hinge": LinearSVC(loss="squared_hinge", penalty="l1", dual=False),
+    }[loss]
+
+    clf.fit_intercept = fit_intercept
+    clf.intercept_scaling = intercept_scaling
+
+    clf.C = min_c
+    clf.fit(X, y)
+    assert (np.asarray(clf.coef_) == 0).all()
+    assert (np.asarray(clf.intercept_) == 0).all()
+
+    clf.C = min_c * 1.01
+    clf.fit(X, y)
+    assert (np.asarray(clf.coef_) != 0).any() or (np.asarray(clf.intercept_) != 0).any()
+
+
+def test_ill_posed_min_c():
+    X = [[0, 0], [0, 0]]
+    y = [0, 1]
+    with pytest.raises(ValueError):
+        l1_min_c(X, y)
+
+
+_MAX_UNSIGNED_INT = 4294967295
+
+
+def test_newrand_default():
+    """Test that bounded_rand_int_wrap without seeding respects the range
+
+    Note this test should pass either if executed alone, or in conjunctions
+    with other tests that call set_seed explicit in any order: it checks
+    invariants on the RNG instead of specific values.
+    """
+    generated = [bounded_rand_int_wrap(100) for _ in range(10)]
+    assert all(0 <= x < 100 for x in generated)
+    assert not all(x == generated[0] for x in generated)
+
+
+@pytest.mark.parametrize("seed, expected", [(0, 54), (_MAX_UNSIGNED_INT, 9)])
+def test_newrand_set_seed(seed, expected):
+    """Test that `set_seed` produces deterministic results"""
+    set_seed_wrap(seed)
+    generated = bounded_rand_int_wrap(100)
+    assert generated == expected
+
+
+@pytest.mark.parametrize("seed", [-1, _MAX_UNSIGNED_INT + 1])
+def test_newrand_set_seed_overflow(seed):
+    """Test that `set_seed_wrap` is defined for unsigned 32bits ints"""
+    with pytest.raises(OverflowError):
+        set_seed_wrap(seed)
+
+
+@pytest.mark.parametrize("range_, n_pts", [(_MAX_UNSIGNED_INT, 10000), (100, 25)])
+def test_newrand_bounded_rand_int(range_, n_pts):
+    """Test that `bounded_rand_int` follows a uniform distribution"""
+    # XXX: this test is very seed sensitive: either it is wrong (too strict?)
+    # or the wrapped RNG is not uniform enough, at least on some platforms.
+    set_seed_wrap(42)
+    n_iter = 100
+    ks_pvals = []
+    uniform_dist = stats.uniform(loc=0, scale=range_)
+    # perform multiple samplings to make chance of outlier sampling negligible
+    for _ in range(n_iter):
+        # Deterministic random sampling
+        sample = [bounded_rand_int_wrap(range_) for _ in range(n_pts)]
+        res = stats.kstest(sample, uniform_dist.cdf)
+        ks_pvals.append(res.pvalue)
+    # Null hypothesis = samples come from an uniform distribution.
+    # Under the null hypothesis, p-values should be uniformly distributed
+    # and not concentrated on low values
+    # (this may seem counter-intuitive but is backed by multiple refs)
+    # So we can do two checks:
+
+    # (1) check uniformity of p-values
+    uniform_p_vals_dist = stats.uniform(loc=0, scale=1)
+    res_pvals = stats.kstest(ks_pvals, uniform_p_vals_dist.cdf)
+    assert res_pvals.pvalue > 0.05, (
+        "Null hypothesis rejected: generated random numbers are not uniform."
+        " Details: the (meta) p-value of the test of uniform distribution"
+        f" of p-values is {res_pvals.pvalue} which is not > 0.05"
+    )
+
+    # (2) (safety belt) check that 90% of p-values are above 0.05
+    min_10pct_pval = np.percentile(ks_pvals, q=10)
+    # lower 10th quantile pvalue <= 0.05 means that the test rejects the
+    # null hypothesis that the sample came from the uniform distribution
+    assert min_10pct_pval > 0.05, (
+        "Null hypothesis rejected: generated random numbers are not uniform. "
+        f"Details: lower 10th quantile p-value of {min_10pct_pval} not > 0.05."
+    )
+
+
+@pytest.mark.parametrize("range_", [-1, _MAX_UNSIGNED_INT + 1])
+def test_newrand_bounded_rand_int_limits(range_):
+    """Test that `bounded_rand_int_wrap` is defined for unsigned 32bits ints"""
+    with pytest.raises(OverflowError):
+        bounded_rand_int_wrap(range_)

venv/lib/python3.10/site-packages/sklearn/svm/tests/test_sparse.py

@@ -0,0 +1,493 @@
+import numpy as np
+import pytest
+from scipy import sparse
+
+from sklearn import base, datasets, linear_model, svm
+from sklearn.datasets import load_digits, make_blobs, make_classification
+from sklearn.exceptions import ConvergenceWarning
+from sklearn.svm.tests import test_svm
+from sklearn.utils._testing import (
+    assert_allclose,
+    assert_array_almost_equal,
+    assert_array_equal,
+    ignore_warnings,
+    skip_if_32bit,
+)
+from sklearn.utils.extmath import safe_sparse_dot
+from sklearn.utils.fixes import (
+    CSR_CONTAINERS,
+    DOK_CONTAINERS,
+    LIL_CONTAINERS,
+)
+
+# test sample 1
+X = np.array([[-2, -1], [-1, -1], [-1, -2], [1, 1], [1, 2], [2, 1]])
+Y = [1, 1, 1, 2, 2, 2]
+T = np.array([[-1, -1], [2, 2], [3, 2]])
+true_result = [1, 2, 2]
+
+# test sample 2
+X2 = np.array(
+    [
+        [0, 0, 0],
+        [1, 1, 1],
+        [2, 0, 0],
+        [0, 0, 2],
+        [3, 3, 3],
+    ]
+)
+Y2 = [1, 2, 2, 2, 3]
+T2 = np.array([[-1, -1, -1], [1, 1, 1], [2, 2, 2]])
+true_result2 = [1, 2, 3]
+
+iris = datasets.load_iris()
+rng = np.random.RandomState(0)
+perm = rng.permutation(iris.target.size)
+iris.data = iris.data[perm]
+iris.target = iris.target[perm]
+
+X_blobs, y_blobs = make_blobs(n_samples=100, centers=10, random_state=0)
+
+
+def check_svm_model_equal(dense_svm, X_train, y_train, X_test):
+    # Use the original svm model for dense fit and clone an exactly same
+    # svm model for sparse fit
+    sparse_svm = base.clone(dense_svm)
+
+    dense_svm.fit(X_train.toarray(), y_train)
+    if sparse.issparse(X_test):
+        X_test_dense = X_test.toarray()
+    else:
+        X_test_dense = X_test
+    sparse_svm.fit(X_train, y_train)
+    assert sparse.issparse(sparse_svm.support_vectors_)
+    assert sparse.issparse(sparse_svm.dual_coef_)
+    assert_allclose(dense_svm.support_vectors_, sparse_svm.support_vectors_.toarray())
+    assert_allclose(dense_svm.dual_coef_, sparse_svm.dual_coef_.toarray())
+    if dense_svm.kernel == "linear":
+        assert sparse.issparse(sparse_svm.coef_)
+        assert_array_almost_equal(dense_svm.coef_, sparse_svm.coef_.toarray())
+    assert_allclose(dense_svm.support_, sparse_svm.support_)
+    assert_allclose(dense_svm.predict(X_test_dense), sparse_svm.predict(X_test))
+
+    assert_array_almost_equal(
+        dense_svm.decision_function(X_test_dense), sparse_svm.decision_function(X_test)
+    )
+    assert_array_almost_equal(
+        dense_svm.decision_function(X_test_dense),
+        sparse_svm.decision_function(X_test_dense),
+    )
+    if isinstance(dense_svm, svm.OneClassSVM):
+        msg = "cannot use sparse input in 'OneClassSVM' trained on dense data"
+    else:
+        assert_array_almost_equal(
+            dense_svm.predict_proba(X_test_dense),
+            sparse_svm.predict_proba(X_test),
+            decimal=4,
+        )
+        msg = "cannot use sparse input in 'SVC' trained on dense data"
+    if sparse.issparse(X_test):
+        with pytest.raises(ValueError, match=msg):
+            dense_svm.predict(X_test)
+
+
+@skip_if_32bit
+@pytest.mark.parametrize(
+    "X_train, y_train, X_test",
+    [
+        [X, Y, T],
+        [X2, Y2, T2],
+        [X_blobs[:80], y_blobs[:80], X_blobs[80:]],
+        [iris.data, iris.target, iris.data],
+    ],
+)
+@pytest.mark.parametrize("kernel", ["linear", "poly", "rbf", "sigmoid"])
+@pytest.mark.parametrize("sparse_container", CSR_CONTAINERS + LIL_CONTAINERS)
+def test_svc(X_train, y_train, X_test, kernel, sparse_container):
+    """Check that sparse SVC gives the same result as SVC."""
+    X_train = sparse_container(X_train)
+
+    clf = svm.SVC(
+        gamma=1,
+        kernel=kernel,
+        probability=True,
+        random_state=0,
+        decision_function_shape="ovo",
+    )
+    check_svm_model_equal(clf, X_train, y_train, X_test)
+
+
+@pytest.mark.parametrize("csr_container", CSR_CONTAINERS)
+def test_unsorted_indices(csr_container):
+    # test that the result with sorted and unsorted indices in csr is the same
+    # we use a subset of digits as iris, blobs or make_classification didn't
+    # show the problem
+    X, y = load_digits(return_X_y=True)
+    X_test = csr_container(X[50:100])
+    X, y = X[:50], y[:50]
+
+    X_sparse = csr_container(X)
+    coef_dense = (
+        svm.SVC(kernel="linear", probability=True, random_state=0).fit(X, y).coef_
+    )
+    sparse_svc = svm.SVC(kernel="linear", probability=True, random_state=0).fit(
+        X_sparse, y
+    )
+    coef_sorted = sparse_svc.coef_
+    # make sure dense and sparse SVM give the same result
+    assert_allclose(coef_dense, coef_sorted.toarray())
+
+    # reverse each row's indices
+    def scramble_indices(X):
+        new_data = []
+        new_indices = []
+        for i in range(1, len(X.indptr)):
+            row_slice = slice(*X.indptr[i - 1 : i + 1])
+            new_data.extend(X.data[row_slice][::-1])
+            new_indices.extend(X.indices[row_slice][::-1])
+        return csr_container((new_data, new_indices, X.indptr), shape=X.shape)
+
+    X_sparse_unsorted = scramble_indices(X_sparse)
+    X_test_unsorted = scramble_indices(X_test)
+
+    assert not X_sparse_unsorted.has_sorted_indices
+    assert not X_test_unsorted.has_sorted_indices
+
+    unsorted_svc = svm.SVC(kernel="linear", probability=True, random_state=0).fit(
+        X_sparse_unsorted, y
+    )
+    coef_unsorted = unsorted_svc.coef_
+    # make sure unsorted indices give same result
+    assert_allclose(coef_unsorted.toarray(), coef_sorted.toarray())
+    assert_allclose(
+        sparse_svc.predict_proba(X_test_unsorted), sparse_svc.predict_proba(X_test)
+    )
+
+
+@pytest.mark.parametrize("lil_container", LIL_CONTAINERS)
+def test_svc_with_custom_kernel(lil_container):
+    def kfunc(x, y):
+        return safe_sparse_dot(x, y.T)
+
+    X_sp = lil_container(X)
+    clf_lin = svm.SVC(kernel="linear").fit(X_sp, Y)
+    clf_mylin = svm.SVC(kernel=kfunc).fit(X_sp, Y)
+    assert_array_equal(clf_lin.predict(X_sp), clf_mylin.predict(X_sp))
+
+
+@skip_if_32bit
+@pytest.mark.parametrize("csr_container", CSR_CONTAINERS)
+@pytest.mark.parametrize("kernel", ["linear", "poly", "rbf"])
+def test_svc_iris(csr_container, kernel):
+    # Test the sparse SVC with the iris dataset
+    iris_data_sp = csr_container(iris.data)
+
+    sp_clf = svm.SVC(kernel=kernel).fit(iris_data_sp, iris.target)
+    clf = svm.SVC(kernel=kernel).fit(iris.data, iris.target)
+
+    assert_allclose(clf.support_vectors_, sp_clf.support_vectors_.toarray())
+    assert_allclose(clf.dual_coef_, sp_clf.dual_coef_.toarray())
+    assert_allclose(clf.predict(iris.data), sp_clf.predict(iris_data_sp))
+    if kernel == "linear":
+        assert_allclose(clf.coef_, sp_clf.coef_.toarray())
+
+
+@pytest.mark.parametrize("csr_container", CSR_CONTAINERS)
+def test_sparse_decision_function(csr_container):
+    # Test decision_function
+
+    # Sanity check, test that decision_function implemented in python
+    # returns the same as the one in libsvm
+
+    # multi class:
+    iris_data_sp = csr_container(iris.data)
+    svc = svm.SVC(kernel="linear", C=0.1, decision_function_shape="ovo")
+    clf = svc.fit(iris_data_sp, iris.target)
+
+    dec = safe_sparse_dot(iris_data_sp, clf.coef_.T) + clf.intercept_
+
+    assert_allclose(dec, clf.decision_function(iris_data_sp))
+
+    # binary:
+    clf.fit(X, Y)
+    dec = np.dot(X, clf.coef_.T) + clf.intercept_
+    prediction = clf.predict(X)
+    assert_allclose(dec.ravel(), clf.decision_function(X))
+    assert_allclose(
+        prediction, clf.classes_[(clf.decision_function(X) > 0).astype(int).ravel()]
+    )
+    expected = np.array([-1.0, -0.66, -1.0, 0.66, 1.0, 1.0])
+    assert_array_almost_equal(clf.decision_function(X), expected, decimal=2)
+
+
+@pytest.mark.parametrize("lil_container", LIL_CONTAINERS)
+def test_error(lil_container):
+    # Test that it gives proper exception on deficient input
+    clf = svm.SVC()
+    X_sp = lil_container(X)
+
+    Y2 = Y[:-1]  # wrong dimensions for labels
+    with pytest.raises(ValueError):
+        clf.fit(X_sp, Y2)
+
+    clf.fit(X_sp, Y)
+    assert_array_equal(clf.predict(T), true_result)
+
+
+@pytest.mark.parametrize(
+    "lil_container, dok_container", zip(LIL_CONTAINERS, DOK_CONTAINERS)
+)
+def test_linearsvc(lil_container, dok_container):
+    # Similar to test_SVC
+    X_sp = lil_container(X)
+    X2_sp = dok_container(X2)
+
+    clf = svm.LinearSVC(dual="auto", random_state=0).fit(X, Y)
+    sp_clf = svm.LinearSVC(dual="auto", random_state=0).fit(X_sp, Y)
+
+    assert sp_clf.fit_intercept
+
+    assert_array_almost_equal(clf.coef_, sp_clf.coef_, decimal=4)
+    assert_array_almost_equal(clf.intercept_, sp_clf.intercept_, decimal=4)
+
+    assert_allclose(clf.predict(X), sp_clf.predict(X_sp))
+
+    clf.fit(X2, Y2)
+    sp_clf.fit(X2_sp, Y2)
+
+    assert_array_almost_equal(clf.coef_, sp_clf.coef_, decimal=4)
+    assert_array_almost_equal(clf.intercept_, sp_clf.intercept_, decimal=4)
+
+
+@pytest.mark.parametrize("csr_container", CSR_CONTAINERS)
+def test_linearsvc_iris(csr_container):
+    # Test the sparse LinearSVC with the iris dataset
+    iris_data_sp = csr_container(iris.data)
+
+    sp_clf = svm.LinearSVC(dual="auto", random_state=0).fit(iris_data_sp, iris.target)
+    clf = svm.LinearSVC(dual="auto", random_state=0).fit(iris.data, iris.target)
+
+    assert clf.fit_intercept == sp_clf.fit_intercept
+
+    assert_array_almost_equal(clf.coef_, sp_clf.coef_, decimal=1)
+    assert_array_almost_equal(clf.intercept_, sp_clf.intercept_, decimal=1)
+    assert_allclose(clf.predict(iris.data), sp_clf.predict(iris_data_sp))
+
+    # check decision_function
+    pred = np.argmax(sp_clf.decision_function(iris_data_sp), axis=1)
+    assert_allclose(pred, clf.predict(iris.data))
+
+    # sparsify the coefficients on both models and check that they still
+    # produce the same results
+    clf.sparsify()
+    assert_array_equal(pred, clf.predict(iris_data_sp))
+    sp_clf.sparsify()
+    assert_array_equal(pred, sp_clf.predict(iris_data_sp))
+
+
+@pytest.mark.parametrize("csr_container", CSR_CONTAINERS)
+def test_weight(csr_container):
+    # Test class weights
+    X_, y_ = make_classification(
+        n_samples=200, n_features=100, weights=[0.833, 0.167], random_state=0
+    )
+
+    X_ = csr_container(X_)
+    for clf in (
+        linear_model.LogisticRegression(),
+        svm.LinearSVC(dual="auto", random_state=0),
+        svm.SVC(),
+    ):
+        clf.set_params(class_weight={0: 5})
+        clf.fit(X_[:180], y_[:180])
+        y_pred = clf.predict(X_[180:])
+        assert np.sum(y_pred == y_[180:]) >= 11
+
+
+@pytest.mark.parametrize("lil_container", LIL_CONTAINERS)
+def test_sample_weights(lil_container):
+    # Test weights on individual samples
+    X_sp = lil_container(X)
+
+    clf = svm.SVC()
+    clf.fit(X_sp, Y)
+    assert_array_equal(clf.predict([X[2]]), [1.0])
+
+    sample_weight = [0.1] * 3 + [10] * 3
+    clf.fit(X_sp, Y, sample_weight=sample_weight)
+    assert_array_equal(clf.predict([X[2]]), [2.0])
+
+
+def test_sparse_liblinear_intercept_handling():
+    # Test that sparse liblinear honours intercept_scaling param
+    test_svm.test_dense_liblinear_intercept_handling(svm.LinearSVC)
+
+
+@pytest.mark.parametrize(
+    "X_train, y_train, X_test",
+    [
+        [X, None, T],
+        [X2, None, T2],
+        [X_blobs[:80], None, X_blobs[80:]],
+        [iris.data, None, iris.data],
+    ],
+)
+@pytest.mark.parametrize("kernel", ["linear", "poly", "rbf", "sigmoid"])
+@pytest.mark.parametrize("sparse_container", CSR_CONTAINERS + LIL_CONTAINERS)
+@skip_if_32bit
+def test_sparse_oneclasssvm(X_train, y_train, X_test, kernel, sparse_container):
+    # Check that sparse OneClassSVM gives the same result as dense OneClassSVM
+    X_train = sparse_container(X_train)
+
+    clf = svm.OneClassSVM(gamma=1, kernel=kernel)
+    check_svm_model_equal(clf, X_train, y_train, X_test)
+
+
+@pytest.mark.parametrize("csr_container", CSR_CONTAINERS)
+def test_sparse_realdata(csr_container):
+    # Test on a subset from the 20newsgroups dataset.
+    # This catches some bugs if input is not correctly converted into
+    # sparse format or weights are not correctly initialized.
+    data = np.array([0.03771744, 0.1003567, 0.01174647, 0.027069])
+
+    # SVC does not support large sparse, so we specify int32 indices
+    # In this case, `csr_matrix` automatically uses int32 regardless of the dtypes of
+    # `indices` and `indptr` but `csr_array` may or may not use the same dtype as
+    # `indices` and `indptr`, which would be int64 if not specified
+    indices = np.array([6, 5, 35, 31], dtype=np.int32)
+    indptr = np.array([0] * 8 + [1] * 32 + [2] * 38 + [4] * 3, dtype=np.int32)
+
+    X = csr_container((data, indices, indptr))
+    y = np.array(
+        [
+            1.0,
+            0.0,
+            2.0,
+            2.0,
+            1.0,
+            1.0,
+            1.0,
+            2.0,
+            2.0,
+            0.0,
+            1.0,
+            2.0,
+            2.0,
+            0.0,
+            2.0,
+            0.0,
+            3.0,
+            0.0,
+            3.0,
+            0.0,
+            1.0,
+            1.0,
+            3.0,
+            2.0,
+            3.0,
+            2.0,
+            0.0,
+            3.0,
+            1.0,
+            0.0,
+            2.0,
+            1.0,
+            2.0,
+            0.0,
+            1.0,
+            0.0,
+            2.0,
+            3.0,
+            1.0,
+            3.0,
+            0.0,
+            1.0,
+            0.0,
+            0.0,
+            2.0,
+            0.0,
+            1.0,
+            2.0,
+            2.0,
+            2.0,
+            3.0,
+            2.0,
+            0.0,
+            3.0,
+            2.0,
+            1.0,
+            2.0,
+            3.0,
+            2.0,
+            2.0,
+            0.0,
+            1.0,
+            0.0,
+            1.0,
+            2.0,
+            3.0,
+            0.0,
+            0.0,
+            2.0,
+            2.0,
+            1.0,
+            3.0,
+            1.0,
+            1.0,
+            0.0,
+            1.0,
+            2.0,
+            1.0,
+            1.0,
+            3.0,
+        ]
+    )
+
+    clf = svm.SVC(kernel="linear").fit(X.toarray(), y)
+    sp_clf = svm.SVC(kernel="linear").fit(X.tocoo(), y)
+
+    assert_array_equal(clf.support_vectors_, sp_clf.support_vectors_.toarray())
+    assert_array_equal(clf.dual_coef_, sp_clf.dual_coef_.toarray())
+
+
+@pytest.mark.parametrize("lil_container", LIL_CONTAINERS)
+def test_sparse_svc_clone_with_callable_kernel(lil_container):
+    # Test that the "dense_fit" is called even though we use sparse input
+    # meaning that everything works fine.
+    a = svm.SVC(C=1, kernel=lambda x, y: x @ y.T, probability=True, random_state=0)
+    b = base.clone(a)
+
+    X_sp = lil_container(X)
+    b.fit(X_sp, Y)
+    pred = b.predict(X_sp)
+    b.predict_proba(X_sp)
+
+    dense_svm = svm.SVC(
+        C=1, kernel=lambda x, y: np.dot(x, y.T), probability=True, random_state=0
+    )
+    pred_dense = dense_svm.fit(X, Y).predict(X)
+    assert_array_equal(pred_dense, pred)
+    # b.decision_function(X_sp)  # XXX : should be supported
+
+
+@pytest.mark.parametrize("lil_container", LIL_CONTAINERS)
+def test_timeout(lil_container):
+    sp = svm.SVC(
+        C=1, kernel=lambda x, y: x @ y.T, probability=True, random_state=0, max_iter=1
+    )
+    warning_msg = (
+        r"Solver terminated early \(max_iter=1\).  Consider pre-processing "
+        r"your data with StandardScaler or MinMaxScaler."
+    )
+    with pytest.warns(ConvergenceWarning, match=warning_msg):
+        sp.fit(lil_container(X), Y)
+
+
+def test_consistent_proba():
+    a = svm.SVC(probability=True, max_iter=1, random_state=0)
+    with ignore_warnings(category=ConvergenceWarning):
+        proba_1 = a.fit(X, Y).predict_proba(X)
+    a = svm.SVC(probability=True, max_iter=1, random_state=0)
+    with ignore_warnings(category=ConvergenceWarning):
+        proba_2 = a.fit(X, Y).predict_proba(X)
+    assert_allclose(proba_1, proba_2)

venv/lib/python3.10/site-packages/sklearn/svm/tests/test_svm.py

@@ -0,0 +1,1434 @@
+"""
+Testing for Support Vector Machine module (sklearn.svm)
+
+TODO: remove hard coded numerical results when possible
+"""
+import re
+
+import numpy as np
+import pytest
+from numpy.testing import (
+    assert_allclose,
+    assert_almost_equal,
+    assert_array_almost_equal,
+    assert_array_equal,
+)
+
+from sklearn import base, datasets, linear_model, metrics, svm
+from sklearn.datasets import make_blobs, make_classification
+from sklearn.exceptions import (
+    ConvergenceWarning,
+    NotFittedError,
+    UndefinedMetricWarning,
+)
+from sklearn.metrics import f1_score
+from sklearn.metrics.pairwise import rbf_kernel
+from sklearn.model_selection import train_test_split
+from sklearn.multiclass import OneVsRestClassifier
+
+# mypy error: Module 'sklearn.svm' has no attribute '_libsvm'
+from sklearn.svm import (  # type: ignore
+    SVR,
+    LinearSVC,
+    LinearSVR,
+    NuSVR,
+    OneClassSVM,
+    _libsvm,
+)
+from sklearn.svm._classes import _validate_dual_parameter
+from sklearn.utils import check_random_state, shuffle
+from sklearn.utils._testing import ignore_warnings
+from sklearn.utils.fixes import CSR_CONTAINERS, LIL_CONTAINERS
+from sklearn.utils.validation import _num_samples
+
+# toy sample
+X = [[-2, -1], [-1, -1], [-1, -2], [1, 1], [1, 2], [2, 1]]
+Y = [1, 1, 1, 2, 2, 2]
+T = [[-1, -1], [2, 2], [3, 2]]
+true_result = [1, 2, 2]
+
+# also load the iris dataset
+iris = datasets.load_iris()
+rng = check_random_state(42)
+perm = rng.permutation(iris.target.size)
+iris.data = iris.data[perm]
+iris.target = iris.target[perm]
+
+
+def test_libsvm_parameters():
+    # Test parameters on classes that make use of libsvm.
+    clf = svm.SVC(kernel="linear").fit(X, Y)
+    assert_array_equal(clf.dual_coef_, [[-0.25, 0.25]])
+    assert_array_equal(clf.support_, [1, 3])
+    assert_array_equal(clf.support_vectors_, (X[1], X[3]))
+    assert_array_equal(clf.intercept_, [0.0])
+    assert_array_equal(clf.predict(X), Y)
+
+
+def test_libsvm_iris():
+    # Check consistency on dataset iris.
+
+    # shuffle the dataset so that labels are not ordered
+    for k in ("linear", "rbf"):
+        clf = svm.SVC(kernel=k).fit(iris.data, iris.target)
+        assert np.mean(clf.predict(iris.data) == iris.target) > 0.9
+        assert hasattr(clf, "coef_") == (k == "linear")
+
+    assert_array_equal(clf.classes_, np.sort(clf.classes_))
+
+    # check also the low-level API
+    # We unpack the values to create a dictionary with some of the return values
+    # from Libsvm's fit.
+    (
+        libsvm_support,
+        libsvm_support_vectors,
+        libsvm_n_class_SV,
+        libsvm_sv_coef,
+        libsvm_intercept,
+        libsvm_probA,
+        libsvm_probB,
+        # libsvm_fit_status and libsvm_n_iter won't be used below.
+        libsvm_fit_status,
+        libsvm_n_iter,
+    ) = _libsvm.fit(iris.data, iris.target.astype(np.float64))
+
+    model_params = {
+        "support": libsvm_support,
+        "SV": libsvm_support_vectors,
+        "nSV": libsvm_n_class_SV,
+        "sv_coef": libsvm_sv_coef,
+        "intercept": libsvm_intercept,
+        "probA": libsvm_probA,
+        "probB": libsvm_probB,
+    }
+    pred = _libsvm.predict(iris.data, **model_params)
+    assert np.mean(pred == iris.target) > 0.95
+
+    # We unpack the values to create a dictionary with some of the return values
+    # from Libsvm's fit.
+    (
+        libsvm_support,
+        libsvm_support_vectors,
+        libsvm_n_class_SV,
+        libsvm_sv_coef,
+        libsvm_intercept,
+        libsvm_probA,
+        libsvm_probB,
+        # libsvm_fit_status and libsvm_n_iter won't be used below.
+        libsvm_fit_status,
+        libsvm_n_iter,
+    ) = _libsvm.fit(iris.data, iris.target.astype(np.float64), kernel="linear")
+
+    model_params = {
+        "support": libsvm_support,
+        "SV": libsvm_support_vectors,
+        "nSV": libsvm_n_class_SV,
+        "sv_coef": libsvm_sv_coef,
+        "intercept": libsvm_intercept,
+        "probA": libsvm_probA,
+        "probB": libsvm_probB,
+    }
+    pred = _libsvm.predict(iris.data, **model_params, kernel="linear")
+    assert np.mean(pred == iris.target) > 0.95
+
+    pred = _libsvm.cross_validation(
+        iris.data, iris.target.astype(np.float64), 5, kernel="linear", random_seed=0
+    )
+    assert np.mean(pred == iris.target) > 0.95
+
+    # If random_seed >= 0, the libsvm rng is seeded (by calling `srand`), hence
+    # we should get deterministic results (assuming that there is no other
+    # thread calling this wrapper calling `srand` concurrently).
+    pred2 = _libsvm.cross_validation(
+        iris.data, iris.target.astype(np.float64), 5, kernel="linear", random_seed=0
+    )
+    assert_array_equal(pred, pred2)
+
+
+def test_precomputed():
+    # SVC with a precomputed kernel.
+    # We test it with a toy dataset and with iris.
+    clf = svm.SVC(kernel="precomputed")
+    # Gram matrix for train data (square matrix)
+    # (we use just a linear kernel)
+    K = np.dot(X, np.array(X).T)
+    clf.fit(K, Y)
+    # Gram matrix for test data (rectangular matrix)
+    KT = np.dot(T, np.array(X).T)
+    pred = clf.predict(KT)
+    with pytest.raises(ValueError):
+        clf.predict(KT.T)
+
+    assert_array_equal(clf.dual_coef_, [[-0.25, 0.25]])
+    assert_array_equal(clf.support_, [1, 3])
+    assert_array_equal(clf.intercept_, [0])
+    assert_array_almost_equal(clf.support_, [1, 3])
+    assert_array_equal(pred, true_result)
+
+    # Gram matrix for test data but compute KT[i,j]
+    # for support vectors j only.
+    KT = np.zeros_like(KT)
+    for i in range(len(T)):
+        for j in clf.support_:
+            KT[i, j] = np.dot(T[i], X[j])
+
+    pred = clf.predict(KT)
+    assert_array_equal(pred, true_result)
+
+    # same as before, but using a callable function instead of the kernel
+    # matrix. kernel is just a linear kernel
+
+    def kfunc(x, y):
+        return np.dot(x, y.T)
+
+    clf = svm.SVC(kernel=kfunc)
+    clf.fit(np.array(X), Y)
+    pred = clf.predict(T)
+
+    assert_array_equal(clf.dual_coef_, [[-0.25, 0.25]])
+    assert_array_equal(clf.intercept_, [0])
+    assert_array_almost_equal(clf.support_, [1, 3])
+    assert_array_equal(pred, true_result)
+
+    # test a precomputed kernel with the iris dataset
+    # and check parameters against a linear SVC
+    clf = svm.SVC(kernel="precomputed")
+    clf2 = svm.SVC(kernel="linear")
+    K = np.dot(iris.data, iris.data.T)
+    clf.fit(K, iris.target)
+    clf2.fit(iris.data, iris.target)
+    pred = clf.predict(K)
+    assert_array_almost_equal(clf.support_, clf2.support_)
+    assert_array_almost_equal(clf.dual_coef_, clf2.dual_coef_)
+    assert_array_almost_equal(clf.intercept_, clf2.intercept_)
+    assert_almost_equal(np.mean(pred == iris.target), 0.99, decimal=2)
+
+    # Gram matrix for test data but compute KT[i,j]
+    # for support vectors j only.
+    K = np.zeros_like(K)
+    for i in range(len(iris.data)):
+        for j in clf.support_:
+            K[i, j] = np.dot(iris.data[i], iris.data[j])
+
+    pred = clf.predict(K)
+    assert_almost_equal(np.mean(pred == iris.target), 0.99, decimal=2)
+
+    clf = svm.SVC(kernel=kfunc)
+    clf.fit(iris.data, iris.target)
+    assert_almost_equal(np.mean(pred == iris.target), 0.99, decimal=2)
+
+
+def test_svr():
+    # Test Support Vector Regression
+
+    diabetes = datasets.load_diabetes()
+    for clf in (
+        svm.NuSVR(kernel="linear", nu=0.4, C=1.0),
+        svm.NuSVR(kernel="linear", nu=0.4, C=10.0),
+        svm.SVR(kernel="linear", C=10.0),
+        svm.LinearSVR(dual="auto", C=10.0),
+        svm.LinearSVR(dual="auto", C=10.0),
+    ):
+        clf.fit(diabetes.data, diabetes.target)
+        assert clf.score(diabetes.data, diabetes.target) > 0.02
+
+    # non-regression test; previously, BaseLibSVM would check that
+    # len(np.unique(y)) < 2, which must only be done for SVC
+    svm.SVR().fit(diabetes.data, np.ones(len(diabetes.data)))
+    svm.LinearSVR(dual="auto").fit(diabetes.data, np.ones(len(diabetes.data)))
+
+
+def test_linearsvr():
+    # check that SVR(kernel='linear') and LinearSVC() give
+    # comparable results
+    diabetes = datasets.load_diabetes()
+    lsvr = svm.LinearSVR(C=1e3, dual="auto").fit(diabetes.data, diabetes.target)
+    score1 = lsvr.score(diabetes.data, diabetes.target)
+
+    svr = svm.SVR(kernel="linear", C=1e3).fit(diabetes.data, diabetes.target)
+    score2 = svr.score(diabetes.data, diabetes.target)
+
+    assert_allclose(np.linalg.norm(lsvr.coef_), np.linalg.norm(svr.coef_), 1, 0.0001)
+    assert_almost_equal(score1, score2, 2)
+
+
+def test_linearsvr_fit_sampleweight():
+    # check correct result when sample_weight is 1
+    # check that SVR(kernel='linear') and LinearSVC() give
+    # comparable results
+    diabetes = datasets.load_diabetes()
+    n_samples = len(diabetes.target)
+    unit_weight = np.ones(n_samples)
+    lsvr = svm.LinearSVR(dual="auto", C=1e3, tol=1e-12, max_iter=10000).fit(
+        diabetes.data, diabetes.target, sample_weight=unit_weight
+    )
+    score1 = lsvr.score(diabetes.data, diabetes.target)
+
+    lsvr_no_weight = svm.LinearSVR(dual="auto", C=1e3, tol=1e-12, max_iter=10000).fit(
+        diabetes.data, diabetes.target
+    )
+    score2 = lsvr_no_weight.score(diabetes.data, diabetes.target)
+
+    assert_allclose(
+        np.linalg.norm(lsvr.coef_), np.linalg.norm(lsvr_no_weight.coef_), 1, 0.0001
+    )
+    assert_almost_equal(score1, score2, 2)
+
+    # check that fit(X)  = fit([X1, X2, X3], sample_weight = [n1, n2, n3]) where
+    # X = X1 repeated n1 times, X2 repeated n2 times and so forth
+    random_state = check_random_state(0)
+    random_weight = random_state.randint(0, 10, n_samples)
+    lsvr_unflat = svm.LinearSVR(dual="auto", C=1e3, tol=1e-12, max_iter=10000).fit(
+        diabetes.data, diabetes.target, sample_weight=random_weight
+    )
+    score3 = lsvr_unflat.score(
+        diabetes.data, diabetes.target, sample_weight=random_weight
+    )
+
+    X_flat = np.repeat(diabetes.data, random_weight, axis=0)
+    y_flat = np.repeat(diabetes.target, random_weight, axis=0)
+    lsvr_flat = svm.LinearSVR(dual="auto", C=1e3, tol=1e-12, max_iter=10000).fit(
+        X_flat, y_flat
+    )
+    score4 = lsvr_flat.score(X_flat, y_flat)
+
+    assert_almost_equal(score3, score4, 2)
+
+
+def test_svr_errors():
+    X = [[0.0], [1.0]]
+    y = [0.0, 0.5]
+
+    # Bad kernel
+    clf = svm.SVR(kernel=lambda x, y: np.array([[1.0]]))
+    clf.fit(X, y)
+    with pytest.raises(ValueError):
+        clf.predict(X)
+
+
+def test_oneclass():
+    # Test OneClassSVM
+    clf = svm.OneClassSVM()
+    clf.fit(X)
+    pred = clf.predict(T)
+
+    assert_array_equal(pred, [1, -1, -1])
+    assert pred.dtype == np.dtype("intp")
+    assert_array_almost_equal(clf.intercept_, [-1.218], decimal=3)
+    assert_array_almost_equal(clf.dual_coef_, [[0.750, 0.750, 0.750, 0.750]], decimal=3)
+    with pytest.raises(AttributeError):
+        (lambda: clf.coef_)()
+
+
+def test_oneclass_decision_function():
+    # Test OneClassSVM decision function
+    clf = svm.OneClassSVM()
+    rnd = check_random_state(2)
+
+    # Generate train data
+    X = 0.3 * rnd.randn(100, 2)
+    X_train = np.r_[X + 2, X - 2]
+
+    # Generate some regular novel observations
+    X = 0.3 * rnd.randn(20, 2)
+    X_test = np.r_[X + 2, X - 2]
+    # Generate some abnormal novel observations
+    X_outliers = rnd.uniform(low=-4, high=4, size=(20, 2))
+
+    # fit the model
+    clf = svm.OneClassSVM(nu=0.1, kernel="rbf", gamma=0.1)
+    clf.fit(X_train)
+
+    # predict things
+    y_pred_test = clf.predict(X_test)
+    assert np.mean(y_pred_test == 1) > 0.9
+    y_pred_outliers = clf.predict(X_outliers)
+    assert np.mean(y_pred_outliers == -1) > 0.9
+    dec_func_test = clf.decision_function(X_test)
+    assert_array_equal((dec_func_test > 0).ravel(), y_pred_test == 1)
+    dec_func_outliers = clf.decision_function(X_outliers)
+    assert_array_equal((dec_func_outliers > 0).ravel(), y_pred_outliers == 1)
+
+
+def test_oneclass_score_samples():
+    X_train = [[1, 1], [1, 2], [2, 1]]
+    clf = svm.OneClassSVM(gamma=1).fit(X_train)
+    assert_array_equal(
+        clf.score_samples([[2.0, 2.0]]),
+        clf.decision_function([[2.0, 2.0]]) + clf.offset_,
+    )
+
+
+def test_tweak_params():
+    # Make sure some tweaking of parameters works.
+    # We change clf.dual_coef_ at run time and expect .predict() to change
+    # accordingly. Notice that this is not trivial since it involves a lot
+    # of C/Python copying in the libsvm bindings.
+    # The success of this test ensures that the mapping between libsvm and
+    # the python classifier is complete.
+    clf = svm.SVC(kernel="linear", C=1.0)
+    clf.fit(X, Y)
+    assert_array_equal(clf.dual_coef_, [[-0.25, 0.25]])
+    assert_array_equal(clf.predict([[-0.1, -0.1]]), [1])
+    clf._dual_coef_ = np.array([[0.0, 1.0]])
+    assert_array_equal(clf.predict([[-0.1, -0.1]]), [2])
+
+
+def test_probability():
+    # Predict probabilities using SVC
+    # This uses cross validation, so we use a slightly bigger testing set.
+
+    for clf in (
+        svm.SVC(probability=True, random_state=0, C=1.0),
+        svm.NuSVC(probability=True, random_state=0),
+    ):
+        clf.fit(iris.data, iris.target)
+
+        prob_predict = clf.predict_proba(iris.data)
+        assert_array_almost_equal(np.sum(prob_predict, 1), np.ones(iris.data.shape[0]))
+        assert np.mean(np.argmax(prob_predict, 1) == clf.predict(iris.data)) > 0.9
+
+        assert_almost_equal(
+            clf.predict_proba(iris.data), np.exp(clf.predict_log_proba(iris.data)), 8
+        )
+
+
+def test_decision_function():
+    # Test decision_function
+    # Sanity check, test that decision_function implemented in python
+    # returns the same as the one in libsvm
+    # multi class:
+    clf = svm.SVC(kernel="linear", C=0.1, decision_function_shape="ovo").fit(
+        iris.data, iris.target
+    )
+
+    dec = np.dot(iris.data, clf.coef_.T) + clf.intercept_
+
+    assert_array_almost_equal(dec, clf.decision_function(iris.data))
+
+    # binary:
+    clf.fit(X, Y)
+    dec = np.dot(X, clf.coef_.T) + clf.intercept_
+    prediction = clf.predict(X)
+    assert_array_almost_equal(dec.ravel(), clf.decision_function(X))
+    assert_array_almost_equal(
+        prediction, clf.classes_[(clf.decision_function(X) > 0).astype(int)]
+    )
+    expected = np.array([-1.0, -0.66, -1.0, 0.66, 1.0, 1.0])
+    assert_array_almost_equal(clf.decision_function(X), expected, 2)
+
+    # kernel binary:
+    clf = svm.SVC(kernel="rbf", gamma=1, decision_function_shape="ovo")
+    clf.fit(X, Y)
+
+    rbfs = rbf_kernel(X, clf.support_vectors_, gamma=clf.gamma)
+    dec = np.dot(rbfs, clf.dual_coef_.T) + clf.intercept_
+    assert_array_almost_equal(dec.ravel(), clf.decision_function(X))
+
+
+@pytest.mark.parametrize("SVM", (svm.SVC, svm.NuSVC))
+def test_decision_function_shape(SVM):
+    # check that decision_function_shape='ovr' or 'ovo' gives
+    # correct shape and is consistent with predict
+
+    clf = SVM(kernel="linear", decision_function_shape="ovr").fit(
+        iris.data, iris.target
+    )
+    dec = clf.decision_function(iris.data)
+    assert dec.shape == (len(iris.data), 3)
+    assert_array_equal(clf.predict(iris.data), np.argmax(dec, axis=1))
+
+    # with five classes:
+    X, y = make_blobs(n_samples=80, centers=5, random_state=0)
+    X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)
+
+    clf = SVM(kernel="linear", decision_function_shape="ovr").fit(X_train, y_train)
+    dec = clf.decision_function(X_test)
+    assert dec.shape == (len(X_test), 5)
+    assert_array_equal(clf.predict(X_test), np.argmax(dec, axis=1))
+
+    # check shape of ovo_decition_function=True
+    clf = SVM(kernel="linear", decision_function_shape="ovo").fit(X_train, y_train)
+    dec = clf.decision_function(X_train)
+    assert dec.shape == (len(X_train), 10)
+
+
+def test_svr_predict():
+    # Test SVR's decision_function
+    # Sanity check, test that predict implemented in python
+    # returns the same as the one in libsvm
+
+    X = iris.data
+    y = iris.target
+
+    # linear kernel
+    reg = svm.SVR(kernel="linear", C=0.1).fit(X, y)
+
+    dec = np.dot(X, reg.coef_.T) + reg.intercept_
+    assert_array_almost_equal(dec.ravel(), reg.predict(X).ravel())
+
+    # rbf kernel
+    reg = svm.SVR(kernel="rbf", gamma=1).fit(X, y)
+
+    rbfs = rbf_kernel(X, reg.support_vectors_, gamma=reg.gamma)
+    dec = np.dot(rbfs, reg.dual_coef_.T) + reg.intercept_
+    assert_array_almost_equal(dec.ravel(), reg.predict(X).ravel())
+
+
+def test_weight():
+    # Test class weights
+    clf = svm.SVC(class_weight={1: 0.1})
+    # we give a small weights to class 1
+    clf.fit(X, Y)
+    # so all predicted values belong to class 2
+    assert_array_almost_equal(clf.predict(X), [2] * 6)
+
+    X_, y_ = make_classification(
+        n_samples=200, n_features=10, weights=[0.833, 0.167], random_state=2
+    )
+
+    for clf in (
+        linear_model.LogisticRegression(),
+        svm.LinearSVC(dual="auto", random_state=0),
+        svm.SVC(),
+    ):
+        clf.set_params(class_weight={0: 0.1, 1: 10})
+        clf.fit(X_[:100], y_[:100])
+        y_pred = clf.predict(X_[100:])
+        assert f1_score(y_[100:], y_pred) > 0.3
+
+
+@pytest.mark.parametrize("estimator", [svm.SVC(C=1e-2), svm.NuSVC()])
+def test_svm_classifier_sided_sample_weight(estimator):
+    # fit a linear SVM and check that giving more weight to opposed samples
+    # in the space will flip the decision toward these samples.
+    X = [[-2, 0], [-1, -1], [0, -2], [0, 2], [1, 1], [2, 0]]
+    estimator.set_params(kernel="linear")
+
+    # check that with unit weights, a sample is supposed to be predicted on
+    # the boundary
+    sample_weight = [1] * 6
+    estimator.fit(X, Y, sample_weight=sample_weight)
+    y_pred = estimator.decision_function([[-1.0, 1.0]])
+    assert y_pred == pytest.approx(0)
+
+    # give more weights to opposed samples
+    sample_weight = [10.0, 0.1, 0.1, 0.1, 0.1, 10]
+    estimator.fit(X, Y, sample_weight=sample_weight)
+    y_pred = estimator.decision_function([[-1.0, 1.0]])
+    assert y_pred < 0
+
+    sample_weight = [1.0, 0.1, 10.0, 10.0, 0.1, 0.1]
+    estimator.fit(X, Y, sample_weight=sample_weight)
+    y_pred = estimator.decision_function([[-1.0, 1.0]])
+    assert y_pred > 0
+
+
+@pytest.mark.parametrize("estimator", [svm.SVR(C=1e-2), svm.NuSVR(C=1e-2)])
+def test_svm_regressor_sided_sample_weight(estimator):
+    # similar test to test_svm_classifier_sided_sample_weight but for
+    # SVM regressors
+    X = [[-2, 0], [-1, -1], [0, -2], [0, 2], [1, 1], [2, 0]]
+    estimator.set_params(kernel="linear")
+
+    # check that with unit weights, a sample is supposed to be predicted on
+    # the boundary
+    sample_weight = [1] * 6
+    estimator.fit(X, Y, sample_weight=sample_weight)
+    y_pred = estimator.predict([[-1.0, 1.0]])
+    assert y_pred == pytest.approx(1.5)
+
+    # give more weights to opposed samples
+    sample_weight = [10.0, 0.1, 0.1, 0.1, 0.1, 10]
+    estimator.fit(X, Y, sample_weight=sample_weight)
+    y_pred = estimator.predict([[-1.0, 1.0]])
+    assert y_pred < 1.5
+
+    sample_weight = [1.0, 0.1, 10.0, 10.0, 0.1, 0.1]
+    estimator.fit(X, Y, sample_weight=sample_weight)
+    y_pred = estimator.predict([[-1.0, 1.0]])
+    assert y_pred > 1.5
+
+
+def test_svm_equivalence_sample_weight_C():
+    # test that rescaling all samples is the same as changing C
+    clf = svm.SVC()
+    clf.fit(X, Y)
+    dual_coef_no_weight = clf.dual_coef_
+    clf.set_params(C=100)
+    clf.fit(X, Y, sample_weight=np.repeat(0.01, len(X)))
+    assert_allclose(dual_coef_no_weight, clf.dual_coef_)
+
+
+@pytest.mark.parametrize(
+    "Estimator, err_msg",
+    [
+        (svm.SVC, "Invalid input - all samples have zero or negative weights."),
+        (svm.NuSVC, "(negative dimensions are not allowed|nu is infeasible)"),
+        (svm.SVR, "Invalid input - all samples have zero or negative weights."),
+        (svm.NuSVR, "Invalid input - all samples have zero or negative weights."),
+        (svm.OneClassSVM, "Invalid input - all samples have zero or negative weights."),
+    ],
+    ids=["SVC", "NuSVC", "SVR", "NuSVR", "OneClassSVM"],
+)
+@pytest.mark.parametrize(
+    "sample_weight",
+    [[0] * len(Y), [-0.3] * len(Y)],
+    ids=["weights-are-zero", "weights-are-negative"],
+)
+def test_negative_sample_weights_mask_all_samples(Estimator, err_msg, sample_weight):
+    est = Estimator(kernel="linear")
+    with pytest.raises(ValueError, match=err_msg):
+        est.fit(X, Y, sample_weight=sample_weight)
+
+
+@pytest.mark.parametrize(
+    "Classifier, err_msg",
+    [
+        (
+            svm.SVC,
+            (
+                "Invalid input - all samples with positive weights belong to the same"
+                " class"
+            ),
+        ),
+        (svm.NuSVC, "specified nu is infeasible"),
+    ],
+    ids=["SVC", "NuSVC"],
+)
+@pytest.mark.parametrize(
+    "sample_weight",
+    [[0, -0.5, 0, 1, 1, 1], [1, 1, 1, 0, -0.1, -0.3]],
+    ids=["mask-label-1", "mask-label-2"],
+)
+def test_negative_weights_svc_leave_just_one_label(Classifier, err_msg, sample_weight):
+    clf = Classifier(kernel="linear")
+    with pytest.raises(ValueError, match=err_msg):
+        clf.fit(X, Y, sample_weight=sample_weight)
+
+
+@pytest.mark.parametrize(
+    "Classifier, model",
+    [
+        (svm.SVC, {"when-left": [0.3998, 0.4], "when-right": [0.4, 0.3999]}),
+        (svm.NuSVC, {"when-left": [0.3333, 0.3333], "when-right": [0.3333, 0.3333]}),
+    ],
+    ids=["SVC", "NuSVC"],
+)
+@pytest.mark.parametrize(
+    "sample_weight, mask_side",
+    [([1, -0.5, 1, 1, 1, 1], "when-left"), ([1, 1, 1, 0, 1, 1], "when-right")],
+    ids=["partial-mask-label-1", "partial-mask-label-2"],
+)
+def test_negative_weights_svc_leave_two_labels(
+    Classifier, model, sample_weight, mask_side
+):
+    clf = Classifier(kernel="linear")
+    clf.fit(X, Y, sample_weight=sample_weight)
+    assert_allclose(clf.coef_, [model[mask_side]], rtol=1e-3)
+
+
+@pytest.mark.parametrize(
+    "Estimator", [svm.SVC, svm.NuSVC, svm.NuSVR], ids=["SVC", "NuSVC", "NuSVR"]
+)
+@pytest.mark.parametrize(
+    "sample_weight",
+    [[1, -0.5, 1, 1, 1, 1], [1, 1, 1, 0, 1, 1]],
+    ids=["partial-mask-label-1", "partial-mask-label-2"],
+)
+def test_negative_weight_equal_coeffs(Estimator, sample_weight):
+    # model generates equal coefficients
+    est = Estimator(kernel="linear")
+    est.fit(X, Y, sample_weight=sample_weight)
+    coef = np.abs(est.coef_).ravel()
+    assert coef[0] == pytest.approx(coef[1], rel=1e-3)
+
+
+@ignore_warnings(category=UndefinedMetricWarning)
+def test_auto_weight():
+    # Test class weights for imbalanced data
+    from sklearn.linear_model import LogisticRegression
+
+    # We take as dataset the two-dimensional projection of iris so
+    # that it is not separable and remove half of predictors from
+    # class 1.
+    # We add one to the targets as a non-regression test:
+    # class_weight="balanced"
+    # used to work only when the labels where a range [0..K).
+    from sklearn.utils import compute_class_weight
+
+    X, y = iris.data[:, :2], iris.target + 1
+    unbalanced = np.delete(np.arange(y.size), np.where(y > 2)[0][::2])
+
+    classes = np.unique(y[unbalanced])
+    class_weights = compute_class_weight("balanced", classes=classes, y=y[unbalanced])
+    assert np.argmax(class_weights) == 2
+
+    for clf in (
+        svm.SVC(kernel="linear"),
+        svm.LinearSVC(dual="auto", random_state=0),
+        LogisticRegression(),
+    ):
+        # check that score is better when class='balanced' is set.
+        y_pred = clf.fit(X[unbalanced], y[unbalanced]).predict(X)
+        clf.set_params(class_weight="balanced")
+        y_pred_balanced = clf.fit(
+            X[unbalanced],
+            y[unbalanced],
+        ).predict(X)
+        assert metrics.f1_score(y, y_pred, average="macro") <= metrics.f1_score(
+            y, y_pred_balanced, average="macro"
+        )
+
+
+@pytest.mark.parametrize("lil_container", LIL_CONTAINERS)
+def test_bad_input(lil_container):
+    # Test dimensions for labels
+    Y2 = Y[:-1]  # wrong dimensions for labels
+    with pytest.raises(ValueError):
+        svm.SVC().fit(X, Y2)
+
+    # Test with arrays that are non-contiguous.
+    for clf in (svm.SVC(), svm.LinearSVC(dual="auto", random_state=0)):
+        Xf = np.asfortranarray(X)
+        assert not Xf.flags["C_CONTIGUOUS"]
+        yf = np.ascontiguousarray(np.tile(Y, (2, 1)).T)
+        yf = yf[:, -1]
+        assert not yf.flags["F_CONTIGUOUS"]
+        assert not yf.flags["C_CONTIGUOUS"]
+        clf.fit(Xf, yf)
+        assert_array_equal(clf.predict(T), true_result)
+
+    # error for precomputed kernelsx
+    clf = svm.SVC(kernel="precomputed")
+    with pytest.raises(ValueError):
+        clf.fit(X, Y)
+
+    # predict with sparse input when trained with dense
+    clf = svm.SVC().fit(X, Y)
+    with pytest.raises(ValueError):
+        clf.predict(lil_container(X))
+
+    Xt = np.array(X).T
+    clf.fit(np.dot(X, Xt), Y)
+    with pytest.raises(ValueError):
+        clf.predict(X)
+
+    clf = svm.SVC()
+    clf.fit(X, Y)
+    with pytest.raises(ValueError):
+        clf.predict(Xt)
+
+
+def test_svc_nonfinite_params():
+    # Check SVC throws ValueError when dealing with non-finite parameter values
+    rng = np.random.RandomState(0)
+    n_samples = 10
+    fmax = np.finfo(np.float64).max
+    X = fmax * rng.uniform(size=(n_samples, 2))
+    y = rng.randint(0, 2, size=n_samples)
+
+    clf = svm.SVC()
+    msg = "The dual coefficients or intercepts are not finite"
+    with pytest.raises(ValueError, match=msg):
+        clf.fit(X, y)
+
+
+def test_unicode_kernel():
+    # Test that a unicode kernel name does not cause a TypeError
+    clf = svm.SVC(kernel="linear", probability=True)
+    clf.fit(X, Y)
+    clf.predict_proba(T)
+    _libsvm.cross_validation(
+        iris.data, iris.target.astype(np.float64), 5, kernel="linear", random_seed=0
+    )
+
+
+@pytest.mark.parametrize("csr_container", CSR_CONTAINERS)
+def test_sparse_precomputed(csr_container):
+    clf = svm.SVC(kernel="precomputed")
+    sparse_gram = csr_container([[1, 0], [0, 1]])
+    with pytest.raises(TypeError, match="Sparse precomputed"):
+        clf.fit(sparse_gram, [0, 1])
+
+
+@pytest.mark.parametrize("csr_container", CSR_CONTAINERS)
+def test_sparse_fit_support_vectors_empty(csr_container):
+    # Regression test for #14893
+    X_train = csr_container([[0, 1, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0], [0, 0, 0, 1]])
+    y_train = np.array([0.04, 0.04, 0.10, 0.16])
+    model = svm.SVR(kernel="linear")
+    model.fit(X_train, y_train)
+    assert not model.support_vectors_.data.size
+    assert not model.dual_coef_.data.size
+
+
+@pytest.mark.parametrize("loss", ["hinge", "squared_hinge"])
+@pytest.mark.parametrize("penalty", ["l1", "l2"])
+@pytest.mark.parametrize("dual", [True, False])
+def test_linearsvc_parameters(loss, penalty, dual):
+    # Test possible parameter combinations in LinearSVC
+    # Generate list of possible parameter combinations
+    X, y = make_classification(n_samples=5, n_features=5, random_state=0)
+
+    clf = svm.LinearSVC(penalty=penalty, loss=loss, dual=dual, random_state=0)
+    if (
+        (loss, penalty) == ("hinge", "l1")
+        or (loss, penalty, dual) == ("hinge", "l2", False)
+        or (penalty, dual) == ("l1", True)
+    ):
+        with pytest.raises(
+            ValueError,
+            match="Unsupported set of arguments.*penalty='%s.*loss='%s.*dual=%s"
+            % (penalty, loss, dual),
+        ):
+            clf.fit(X, y)
+    else:
+        clf.fit(X, y)
+
+
+def test_linearsvc():
+    # Test basic routines using LinearSVC
+    clf = svm.LinearSVC(dual="auto", random_state=0).fit(X, Y)
+
+    # by default should have intercept
+    assert clf.fit_intercept
+
+    assert_array_equal(clf.predict(T), true_result)
+    assert_array_almost_equal(clf.intercept_, [0], decimal=3)
+
+    # the same with l1 penalty
+    clf = svm.LinearSVC(
+        penalty="l1", loss="squared_hinge", dual=False, random_state=0
+    ).fit(X, Y)
+    assert_array_equal(clf.predict(T), true_result)
+
+    # l2 penalty with dual formulation
+    clf = svm.LinearSVC(penalty="l2", dual=True, random_state=0).fit(X, Y)
+    assert_array_equal(clf.predict(T), true_result)
+
+    # l2 penalty, l1 loss
+    clf = svm.LinearSVC(penalty="l2", loss="hinge", dual=True, random_state=0)
+    clf.fit(X, Y)
+    assert_array_equal(clf.predict(T), true_result)
+
+    # test also decision function
+    dec = clf.decision_function(T)
+    res = (dec > 0).astype(int) + 1
+    assert_array_equal(res, true_result)
+
+
+def test_linearsvc_crammer_singer():
+    # Test LinearSVC with crammer_singer multi-class svm
+    ovr_clf = svm.LinearSVC(dual="auto", random_state=0).fit(iris.data, iris.target)
+    cs_clf = svm.LinearSVC(dual="auto", multi_class="crammer_singer", random_state=0)
+    cs_clf.fit(iris.data, iris.target)
+
+    # similar prediction for ovr and crammer-singer:
+    assert (ovr_clf.predict(iris.data) == cs_clf.predict(iris.data)).mean() > 0.9
+
+    # classifiers shouldn't be the same
+    assert (ovr_clf.coef_ != cs_clf.coef_).all()
+
+    # test decision function
+    assert_array_equal(
+        cs_clf.predict(iris.data),
+        np.argmax(cs_clf.decision_function(iris.data), axis=1),
+    )
+    dec_func = np.dot(iris.data, cs_clf.coef_.T) + cs_clf.intercept_
+    assert_array_almost_equal(dec_func, cs_clf.decision_function(iris.data))
+
+
+def test_linearsvc_fit_sampleweight():
+    # check correct result when sample_weight is 1
+    n_samples = len(X)
+    unit_weight = np.ones(n_samples)
+    clf = svm.LinearSVC(dual="auto", random_state=0).fit(X, Y)
+    clf_unitweight = svm.LinearSVC(
+        dual="auto", random_state=0, tol=1e-12, max_iter=1000
+    ).fit(X, Y, sample_weight=unit_weight)
+
+    # check if same as sample_weight=None
+    assert_array_equal(clf_unitweight.predict(T), clf.predict(T))
+    assert_allclose(clf.coef_, clf_unitweight.coef_, 1, 0.0001)
+
+    # check that fit(X)  = fit([X1, X2, X3],sample_weight = [n1, n2, n3]) where
+    # X = X1 repeated n1 times, X2 repeated n2 times and so forth
+
+    random_state = check_random_state(0)
+    random_weight = random_state.randint(0, 10, n_samples)
+    lsvc_unflat = svm.LinearSVC(
+        dual="auto", random_state=0, tol=1e-12, max_iter=1000
+    ).fit(X, Y, sample_weight=random_weight)
+
+    pred1 = lsvc_unflat.predict(T)
+
+    X_flat = np.repeat(X, random_weight, axis=0)
+    y_flat = np.repeat(Y, random_weight, axis=0)
+    lsvc_flat = svm.LinearSVC(
+        dual="auto", random_state=0, tol=1e-12, max_iter=1000
+    ).fit(X_flat, y_flat)
+    pred2 = lsvc_flat.predict(T)
+
+    assert_array_equal(pred1, pred2)
+    assert_allclose(lsvc_unflat.coef_, lsvc_flat.coef_, 1, 0.0001)
+
+
+def test_crammer_singer_binary():
+    # Test Crammer-Singer formulation in the binary case
+    X, y = make_classification(n_classes=2, random_state=0)
+
+    for fit_intercept in (True, False):
+        acc = (
+            svm.LinearSVC(
+                dual="auto",
+                fit_intercept=fit_intercept,
+                multi_class="crammer_singer",
+                random_state=0,
+            )
+            .fit(X, y)
+            .score(X, y)
+        )
+        assert acc > 0.9
+
+
+def test_linearsvc_iris():
+    # Test that LinearSVC gives plausible predictions on the iris dataset
+    # Also, test symbolic class names (classes_).
+    target = iris.target_names[iris.target]
+    clf = svm.LinearSVC(dual="auto", random_state=0).fit(iris.data, target)
+    assert set(clf.classes_) == set(iris.target_names)
+    assert np.mean(clf.predict(iris.data) == target) > 0.8
+
+    dec = clf.decision_function(iris.data)
+    pred = iris.target_names[np.argmax(dec, 1)]
+    assert_array_equal(pred, clf.predict(iris.data))
+
+
+def test_dense_liblinear_intercept_handling(classifier=svm.LinearSVC):
+    # Test that dense liblinear honours intercept_scaling param
+    X = [[2, 1], [3, 1], [1, 3], [2, 3]]
+    y = [0, 0, 1, 1]
+    clf = classifier(
+        fit_intercept=True,
+        penalty="l1",
+        loss="squared_hinge",
+        dual=False,
+        C=4,
+        tol=1e-7,
+        random_state=0,
+    )
+    assert clf.intercept_scaling == 1, clf.intercept_scaling
+    assert clf.fit_intercept
+
+    # when intercept_scaling is low the intercept value is highly "penalized"
+    # by regularization
+    clf.intercept_scaling = 1
+    clf.fit(X, y)
+    assert_almost_equal(clf.intercept_, 0, decimal=5)
+
+    # when intercept_scaling is sufficiently high, the intercept value
+    # is not affected by regularization
+    clf.intercept_scaling = 100
+    clf.fit(X, y)
+    intercept1 = clf.intercept_
+    assert intercept1 < -1
+
+    # when intercept_scaling is sufficiently high, the intercept value
+    # doesn't depend on intercept_scaling value
+    clf.intercept_scaling = 1000
+    clf.fit(X, y)
+    intercept2 = clf.intercept_
+    assert_array_almost_equal(intercept1, intercept2, decimal=2)
+
+
+def test_liblinear_set_coef():
+    # multi-class case
+    clf = svm.LinearSVC(dual="auto").fit(iris.data, iris.target)
+    values = clf.decision_function(iris.data)
+    clf.coef_ = clf.coef_.copy()
+    clf.intercept_ = clf.intercept_.copy()
+    values2 = clf.decision_function(iris.data)
+    assert_array_almost_equal(values, values2)
+
+    # binary-class case
+    X = [[2, 1], [3, 1], [1, 3], [2, 3]]
+    y = [0, 0, 1, 1]
+
+    clf = svm.LinearSVC(dual="auto").fit(X, y)
+    values = clf.decision_function(X)
+    clf.coef_ = clf.coef_.copy()
+    clf.intercept_ = clf.intercept_.copy()
+    values2 = clf.decision_function(X)
+    assert_array_equal(values, values2)
+
+
+def test_immutable_coef_property():
+    # Check that primal coef modification are not silently ignored
+    svms = [
+        svm.SVC(kernel="linear").fit(iris.data, iris.target),
+        svm.NuSVC(kernel="linear").fit(iris.data, iris.target),
+        svm.SVR(kernel="linear").fit(iris.data, iris.target),
+        svm.NuSVR(kernel="linear").fit(iris.data, iris.target),
+        svm.OneClassSVM(kernel="linear").fit(iris.data),
+    ]
+    for clf in svms:
+        with pytest.raises(AttributeError):
+            clf.__setattr__("coef_", np.arange(3))
+        with pytest.raises((RuntimeError, ValueError)):
+            clf.coef_.__setitem__((0, 0), 0)
+
+
+def test_linearsvc_verbose():
+    # stdout: redirect
+    import os
+
+    stdout = os.dup(1)  # save original stdout
+    os.dup2(os.pipe()[1], 1)  # replace it
+
+    # actual call
+    clf = svm.LinearSVC(dual="auto", verbose=1)
+    clf.fit(X, Y)
+
+    # stdout: restore
+    os.dup2(stdout, 1)  # restore original stdout
+
+
+def test_svc_clone_with_callable_kernel():
+    # create SVM with callable linear kernel, check that results are the same
+    # as with built-in linear kernel
+    svm_callable = svm.SVC(
+        kernel=lambda x, y: np.dot(x, y.T),
+        probability=True,
+        random_state=0,
+        decision_function_shape="ovr",
+    )
+    # clone for checking clonability with lambda functions..
+    svm_cloned = base.clone(svm_callable)
+    svm_cloned.fit(iris.data, iris.target)
+
+    svm_builtin = svm.SVC(
+        kernel="linear", probability=True, random_state=0, decision_function_shape="ovr"
+    )
+    svm_builtin.fit(iris.data, iris.target)
+
+    assert_array_almost_equal(svm_cloned.dual_coef_, svm_builtin.dual_coef_)
+    assert_array_almost_equal(svm_cloned.intercept_, svm_builtin.intercept_)
+    assert_array_equal(svm_cloned.predict(iris.data), svm_builtin.predict(iris.data))
+
+    assert_array_almost_equal(
+        svm_cloned.predict_proba(iris.data),
+        svm_builtin.predict_proba(iris.data),
+        decimal=4,
+    )
+    assert_array_almost_equal(
+        svm_cloned.decision_function(iris.data),
+        svm_builtin.decision_function(iris.data),
+    )
+
+
+def test_svc_bad_kernel():
+    svc = svm.SVC(kernel=lambda x, y: x)
+    with pytest.raises(ValueError):
+        svc.fit(X, Y)
+
+
+def test_libsvm_convergence_warnings():
+    a = svm.SVC(
+        kernel=lambda x, y: np.dot(x, y.T), probability=True, random_state=0, max_iter=2
+    )
+    warning_msg = (
+        r"Solver terminated early \(max_iter=2\).  Consider pre-processing "
+        r"your data with StandardScaler or MinMaxScaler."
+    )
+    with pytest.warns(ConvergenceWarning, match=warning_msg):
+        a.fit(np.array(X), Y)
+    assert np.all(a.n_iter_ == 2)
+
+
+def test_unfitted():
+    X = "foo!"  # input validation not required when SVM not fitted
+
+    clf = svm.SVC()
+    with pytest.raises(Exception, match=r".*\bSVC\b.*\bnot\b.*\bfitted\b"):
+        clf.predict(X)
+
+    clf = svm.NuSVR()
+    with pytest.raises(Exception, match=r".*\bNuSVR\b.*\bnot\b.*\bfitted\b"):
+        clf.predict(X)
+
+
+# ignore convergence warnings from max_iter=1
+@ignore_warnings
+def test_consistent_proba():
+    a = svm.SVC(probability=True, max_iter=1, random_state=0)
+    proba_1 = a.fit(X, Y).predict_proba(X)
+    a = svm.SVC(probability=True, max_iter=1, random_state=0)
+    proba_2 = a.fit(X, Y).predict_proba(X)
+    assert_array_almost_equal(proba_1, proba_2)
+
+
+def test_linear_svm_convergence_warnings():
+    # Test that warnings are raised if model does not converge
+
+    lsvc = svm.LinearSVC(dual="auto", random_state=0, max_iter=2)
+    warning_msg = "Liblinear failed to converge, increase the number of iterations."
+    with pytest.warns(ConvergenceWarning, match=warning_msg):
+        lsvc.fit(X, Y)
+    # Check that we have an n_iter_ attribute with int type as opposed to a
+    # numpy array or an np.int32 so as to match the docstring.
+    assert isinstance(lsvc.n_iter_, int)
+    assert lsvc.n_iter_ == 2
+
+    lsvr = svm.LinearSVR(dual="auto", random_state=0, max_iter=2)
+    with pytest.warns(ConvergenceWarning, match=warning_msg):
+        lsvr.fit(iris.data, iris.target)
+    assert isinstance(lsvr.n_iter_, int)
+    assert lsvr.n_iter_ == 2
+
+
+def test_svr_coef_sign():
+    # Test that SVR(kernel="linear") has coef_ with the right sign.
+    # Non-regression test for #2933.
+    X = np.random.RandomState(21).randn(10, 3)
+    y = np.random.RandomState(12).randn(10)
+
+    for svr in [
+        svm.SVR(kernel="linear"),
+        svm.NuSVR(kernel="linear"),
+        svm.LinearSVR(dual="auto"),
+    ]:
+        svr.fit(X, y)
+        assert_array_almost_equal(
+            svr.predict(X), np.dot(X, svr.coef_.ravel()) + svr.intercept_
+        )
+
+
+def test_lsvc_intercept_scaling_zero():
+    # Test that intercept_scaling is ignored when fit_intercept is False
+
+    lsvc = svm.LinearSVC(dual="auto", fit_intercept=False)
+    lsvc.fit(X, Y)
+    assert lsvc.intercept_ == 0.0
+
+
+def test_hasattr_predict_proba():
+    # Method must be (un)available before or after fit, switched by
+    # `probability` param
+
+    G = svm.SVC(probability=True)
+    assert hasattr(G, "predict_proba")
+    G.fit(iris.data, iris.target)
+    assert hasattr(G, "predict_proba")
+
+    G = svm.SVC(probability=False)
+    assert not hasattr(G, "predict_proba")
+    G.fit(iris.data, iris.target)
+    assert not hasattr(G, "predict_proba")
+
+    # Switching to `probability=True` after fitting should make
+    # predict_proba available, but calling it must not work:
+    G.probability = True
+    assert hasattr(G, "predict_proba")
+    msg = "predict_proba is not available when fitted with probability=False"
+
+    with pytest.raises(NotFittedError, match=msg):
+        G.predict_proba(iris.data)
+
+
+def test_decision_function_shape_two_class():
+    for n_classes in [2, 3]:
+        X, y = make_blobs(centers=n_classes, random_state=0)
+        for estimator in [svm.SVC, svm.NuSVC]:
+            clf = OneVsRestClassifier(estimator(decision_function_shape="ovr")).fit(
+                X, y
+            )
+            assert len(clf.predict(X)) == len(y)
+
+
+def test_ovr_decision_function():
+    # One point from each quadrant represents one class
+    X_train = np.array([[1, 1], [-1, 1], [-1, -1], [1, -1]])
+    y_train = [0, 1, 2, 3]
+
+    # First point is closer to the decision boundaries than the second point
+    base_points = np.array([[5, 5], [10, 10]])
+
+    # For all the quadrants (classes)
+    X_test = np.vstack(
+        (
+            base_points * [1, 1],  # Q1
+            base_points * [-1, 1],  # Q2
+            base_points * [-1, -1],  # Q3
+            base_points * [1, -1],  # Q4
+        )
+    )
+
+    y_test = [0] * 2 + [1] * 2 + [2] * 2 + [3] * 2
+
+    clf = svm.SVC(kernel="linear", decision_function_shape="ovr")
+    clf.fit(X_train, y_train)
+
+    y_pred = clf.predict(X_test)
+
+    # Test if the prediction is the same as y
+    assert_array_equal(y_pred, y_test)
+
+    deci_val = clf.decision_function(X_test)
+
+    # Assert that the predicted class has the maximum value
+    assert_array_equal(np.argmax(deci_val, axis=1), y_pred)
+
+    # Get decision value at test points for the predicted class
+    pred_class_deci_val = deci_val[range(8), y_pred].reshape((4, 2))
+
+    # Assert pred_class_deci_val > 0 here
+    assert np.min(pred_class_deci_val) > 0.0
+
+    # Test if the first point has lower decision value on every quadrant
+    # compared to the second point
+    assert np.all(pred_class_deci_val[:, 0] < pred_class_deci_val[:, 1])
+
+
+@pytest.mark.parametrize("SVCClass", [svm.SVC, svm.NuSVC])
+def test_svc_invalid_break_ties_param(SVCClass):
+    X, y = make_blobs(random_state=42)
+
+    svm = SVCClass(
+        kernel="linear", decision_function_shape="ovo", break_ties=True, random_state=42
+    ).fit(X, y)
+
+    with pytest.raises(ValueError, match="break_ties must be False"):
+        svm.predict(y)
+
+
+@pytest.mark.parametrize("SVCClass", [svm.SVC, svm.NuSVC])
+def test_svc_ovr_tie_breaking(SVCClass):
+    """Test if predict breaks ties in OVR mode.
+    Related issue: https://github.com/scikit-learn/scikit-learn/issues/8277
+    """
+    X, y = make_blobs(random_state=0, n_samples=20, n_features=2)
+
+    xs = np.linspace(X[:, 0].min(), X[:, 0].max(), 100)
+    ys = np.linspace(X[:, 1].min(), X[:, 1].max(), 100)
+    xx, yy = np.meshgrid(xs, ys)
+
+    common_params = dict(
+        kernel="rbf", gamma=1e6, random_state=42, decision_function_shape="ovr"
+    )
+    svm = SVCClass(
+        break_ties=False,
+        **common_params,
+    ).fit(X, y)
+    pred = svm.predict(np.c_[xx.ravel(), yy.ravel()])
+    dv = svm.decision_function(np.c_[xx.ravel(), yy.ravel()])
+    assert not np.all(pred == np.argmax(dv, axis=1))
+
+    svm = SVCClass(
+        break_ties=True,
+        **common_params,
+    ).fit(X, y)
+    pred = svm.predict(np.c_[xx.ravel(), yy.ravel()])
+    dv = svm.decision_function(np.c_[xx.ravel(), yy.ravel()])
+    assert np.all(pred == np.argmax(dv, axis=1))
+
+
+def test_gamma_scale():
+    X, y = [[0.0], [1.0]], [0, 1]
+
+    clf = svm.SVC()
+    clf.fit(X, y)
+    assert_almost_equal(clf._gamma, 4)
+
+
+@pytest.mark.parametrize(
+    "SVM, params",
+    [
+        (LinearSVC, {"penalty": "l1", "loss": "squared_hinge", "dual": False}),
+        (LinearSVC, {"penalty": "l2", "loss": "squared_hinge", "dual": True}),
+        (LinearSVC, {"penalty": "l2", "loss": "squared_hinge", "dual": False}),
+        (LinearSVC, {"penalty": "l2", "loss": "hinge", "dual": True}),
+        (LinearSVR, {"loss": "epsilon_insensitive", "dual": True}),
+        (LinearSVR, {"loss": "squared_epsilon_insensitive", "dual": True}),
+        (LinearSVR, {"loss": "squared_epsilon_insensitive", "dual": True}),
+    ],
+)
+def test_linearsvm_liblinear_sample_weight(SVM, params):
+    X = np.array(
+        [
+            [1, 3],
+            [1, 3],
+            [1, 3],
+            [1, 3],
+            [2, 1],
+            [2, 1],
+            [2, 1],
+            [2, 1],
+            [3, 3],
+            [3, 3],
+            [3, 3],
+            [3, 3],
+            [4, 1],
+            [4, 1],
+            [4, 1],
+            [4, 1],
+        ],
+        dtype=np.dtype("float"),
+    )
+    y = np.array(
+        [1, 1, 1, 1, 2, 2, 2, 2, 1, 1, 1, 1, 2, 2, 2, 2], dtype=np.dtype("int")
+    )
+
+    X2 = np.vstack([X, X])
+    y2 = np.hstack([y, 3 - y])
+    sample_weight = np.ones(shape=len(y) * 2)
+    sample_weight[len(y) :] = 0
+    X2, y2, sample_weight = shuffle(X2, y2, sample_weight, random_state=0)
+
+    base_estimator = SVM(random_state=42)
+    base_estimator.set_params(**params)
+    base_estimator.set_params(tol=1e-12, max_iter=1000)
+    est_no_weight = base.clone(base_estimator).fit(X, y)
+    est_with_weight = base.clone(base_estimator).fit(
+        X2, y2, sample_weight=sample_weight
+    )
+
+    for method in ("predict", "decision_function"):
+        if hasattr(base_estimator, method):
+            X_est_no_weight = getattr(est_no_weight, method)(X)
+            X_est_with_weight = getattr(est_with_weight, method)(X)
+            assert_allclose(X_est_no_weight, X_est_with_weight)
+
+
+@pytest.mark.parametrize("Klass", (OneClassSVM, SVR, NuSVR))
+def test_n_support(Klass):
+    # Make n_support is correct for oneclass and SVR (used to be
+    # non-initialized)
+    # this is a non regression test for issue #14774
+    X = np.array([[0], [0.44], [0.45], [0.46], [1]])
+    y = np.arange(X.shape[0])
+    est = Klass()
+    assert not hasattr(est, "n_support_")
+    est.fit(X, y)
+    assert est.n_support_[0] == est.support_vectors_.shape[0]
+    assert est.n_support_.size == 1
+
+
+@pytest.mark.parametrize("Estimator", [svm.SVC, svm.SVR])
+def test_custom_kernel_not_array_input(Estimator):
+    """Test using a custom kernel that is not fed with array-like for floats"""
+    data = ["A A", "A", "B", "B B", "A B"]
+    X = np.array([[2, 0], [1, 0], [0, 1], [0, 2], [1, 1]])  # count encoding
+    y = np.array([1, 1, 2, 2, 1])
+
+    def string_kernel(X1, X2):
+        assert isinstance(X1[0], str)
+        n_samples1 = _num_samples(X1)
+        n_samples2 = _num_samples(X2)
+        K = np.zeros((n_samples1, n_samples2))
+        for ii in range(n_samples1):
+            for jj in range(ii, n_samples2):
+                K[ii, jj] = X1[ii].count("A") * X2[jj].count("A")
+                K[ii, jj] += X1[ii].count("B") * X2[jj].count("B")
+                K[jj, ii] = K[ii, jj]
+        return K
+
+    K = string_kernel(data, data)
+    assert_array_equal(np.dot(X, X.T), K)
+
+    svc1 = Estimator(kernel=string_kernel).fit(data, y)
+    svc2 = Estimator(kernel="linear").fit(X, y)
+    svc3 = Estimator(kernel="precomputed").fit(K, y)
+
+    assert svc1.score(data, y) == svc3.score(K, y)
+    assert svc1.score(data, y) == svc2.score(X, y)
+    if hasattr(svc1, "decision_function"):  # classifier
+        assert_allclose(svc1.decision_function(data), svc2.decision_function(X))
+        assert_allclose(svc1.decision_function(data), svc3.decision_function(K))
+        assert_array_equal(svc1.predict(data), svc2.predict(X))
+        assert_array_equal(svc1.predict(data), svc3.predict(K))
+    else:  # regressor
+        assert_allclose(svc1.predict(data), svc2.predict(X))
+        assert_allclose(svc1.predict(data), svc3.predict(K))
+
+
+def test_svc_raises_error_internal_representation():
+    """Check that SVC raises error when internal representation is altered.
+
+    Non-regression test for #18891 and https://nvd.nist.gov/vuln/detail/CVE-2020-28975
+    """
+    clf = svm.SVC(kernel="linear").fit(X, Y)
+    clf._n_support[0] = 1000000
+
+    msg = "The internal representation of SVC was altered"
+    with pytest.raises(ValueError, match=msg):
+        clf.predict(X)
+
+
+@pytest.mark.parametrize(
+    "estimator, expected_n_iter_type",
+    [
+        (svm.SVC, np.ndarray),
+        (svm.NuSVC, np.ndarray),
+        (svm.SVR, int),
+        (svm.NuSVR, int),
+        (svm.OneClassSVM, int),
+    ],
+)
+@pytest.mark.parametrize(
+    "dataset",
+    [
+        make_classification(n_classes=2, n_informative=2, random_state=0),
+        make_classification(n_classes=3, n_informative=3, random_state=0),
+        make_classification(n_classes=4, n_informative=4, random_state=0),
+    ],
+)
+def test_n_iter_libsvm(estimator, expected_n_iter_type, dataset):
+    # Check that the type of n_iter_ is correct for the classes that inherit
+    # from BaseSVC.
+    # Note that for SVC, and NuSVC this is an ndarray; while for SVR, NuSVR, and
+    # OneClassSVM, it is an int.
+    # For SVC and NuSVC also check the shape of n_iter_.
+    X, y = dataset
+    n_iter = estimator(kernel="linear").fit(X, y).n_iter_
+    assert type(n_iter) == expected_n_iter_type
+    if estimator in [svm.SVC, svm.NuSVC]:
+        n_classes = len(np.unique(y))
+        assert n_iter.shape == (n_classes * (n_classes - 1) // 2,)
+
+
+# TODO(1.5): Remove
+@pytest.mark.parametrize("Estimator", [LinearSVR, LinearSVC])
+def test_dual_auto_deprecation_warning(Estimator):
+    svm = Estimator()
+    msg = (
+        "The default value of `dual` will change from `True` to `'auto'` in"
+        " 1.5. Set the value of `dual` explicitly to suppress the warning."
+    )
+    with pytest.warns(FutureWarning, match=re.escape(msg)):
+        svm.fit(X, Y)
+
+
+@pytest.mark.parametrize("loss", ["squared_hinge", "squared_epsilon_insensitive"])
+def test_dual_auto(loss):
+    # OvR, L2, N > M (6,2)
+    dual = _validate_dual_parameter("auto", loss, "l2", "ovr", np.asarray(X))
+    assert dual is False
+    # OvR, L2, N < M (2,6)
+    dual = _validate_dual_parameter("auto", loss, "l2", "ovr", np.asarray(X).T)
+    assert dual is True
+
+
+def test_dual_auto_edge_cases():
+    # Hinge, OvR, L2, N > M (6,2)
+    dual = _validate_dual_parameter("auto", "hinge", "l2", "ovr", np.asarray(X))
+    assert dual is True  # only supports True
+    dual = _validate_dual_parameter(
+        "auto", "epsilon_insensitive", "l2", "ovr", np.asarray(X)
+    )
+    assert dual is True  # only supports True
+    # SqHinge, OvR, L1, N < M (2,6)
+    dual = _validate_dual_parameter(
+        "auto", "squared_hinge", "l1", "ovr", np.asarray(X).T
+    )
+    assert dual is False  # only supports False

venv/lib/python3.10/site-packages/sklearn/utils/__init__.py

@@ -0,0 +1,1299 @@
+"""
+The :mod:`sklearn.utils` module includes various utilities.
+"""
+
+import math
+import numbers
+import platform
+import struct
+import timeit
+import warnings
+from collections.abc import Sequence
+from contextlib import contextmanager, suppress
+from itertools import compress, islice
+
+import numpy as np
+from scipy.sparse import issparse
+
+from .. import get_config
+from ..exceptions import DataConversionWarning
+from . import _joblib, metadata_routing
+from ._bunch import Bunch
+from ._estimator_html_repr import estimator_html_repr
+from ._param_validation import Integral, Interval, validate_params
+from .class_weight import compute_class_weight, compute_sample_weight
+from .deprecation import deprecated
+from .discovery import all_estimators
+from .fixes import parse_version, threadpool_info
+from .murmurhash import murmurhash3_32
+from .validation import (
+    _is_arraylike_not_scalar,
+    _is_pandas_df,
+    _is_polars_df,
+    _use_interchange_protocol,
+    as_float_array,
+    assert_all_finite,
+    check_array,
+    check_consistent_length,
+    check_random_state,
+    check_scalar,
+    check_symmetric,
+    check_X_y,
+    column_or_1d,
+    indexable,
+)
+
+# Do not deprecate parallel_backend and register_parallel_backend as they are
+# needed to tune `scikit-learn` behavior and have different effect if called
+# from the vendored version or or the site-package version. The other are
+# utilities that are independent of scikit-learn so they are not part of
+# scikit-learn public API.
+parallel_backend = _joblib.parallel_backend
+register_parallel_backend = _joblib.register_parallel_backend
+
+__all__ = [
+    "murmurhash3_32",
+    "as_float_array",
+    "assert_all_finite",
+    "check_array",
+    "check_random_state",
+    "compute_class_weight",
+    "compute_sample_weight",
+    "column_or_1d",
+    "check_consistent_length",
+    "check_X_y",
+    "check_scalar",
+    "indexable",
+    "check_symmetric",
+    "indices_to_mask",
+    "deprecated",
+    "parallel_backend",
+    "register_parallel_backend",
+    "resample",
+    "shuffle",
+    "check_matplotlib_support",
+    "all_estimators",
+    "DataConversionWarning",
+    "estimator_html_repr",
+    "Bunch",
+    "metadata_routing",
+]
+
+IS_PYPY = platform.python_implementation() == "PyPy"
+_IS_32BIT = 8 * struct.calcsize("P") == 32
+_IS_WASM = platform.machine() in ["wasm32", "wasm64"]
+
+
+def _in_unstable_openblas_configuration():
+    """Return True if in an unstable configuration for OpenBLAS"""
+
+    # Import libraries which might load OpenBLAS.
+    import numpy  # noqa
+    import scipy  # noqa
+
+    modules_info = threadpool_info()
+
+    open_blas_used = any(info["internal_api"] == "openblas" for info in modules_info)
+    if not open_blas_used:
+        return False
+
+    # OpenBLAS 0.3.16 fixed instability for arm64, see:
+    # https://github.com/xianyi/OpenBLAS/blob/1b6db3dbba672b4f8af935bd43a1ff6cff4d20b7/Changelog.txt#L56-L58 # noqa
+    openblas_arm64_stable_version = parse_version("0.3.16")
+    for info in modules_info:
+        if info["internal_api"] != "openblas":
+            continue
+        openblas_version = info.get("version")
+        openblas_architecture = info.get("architecture")
+        if openblas_version is None or openblas_architecture is None:
+            # Cannot be sure that OpenBLAS is good enough. Assume unstable:
+            return True
+        if (
+            openblas_architecture == "neoversen1"
+            and parse_version(openblas_version) < openblas_arm64_stable_version
+        ):
+            # See discussions in https://github.com/numpy/numpy/issues/19411
+            return True
+    return False
+
+
+@validate_params(
+    {
+        "X": ["array-like", "sparse matrix"],
+        "mask": ["array-like"],
+    },
+    prefer_skip_nested_validation=True,
+)
+def safe_mask(X, mask):
+    """Return a mask which is safe to use on X.
+
+    Parameters
+    ----------
+    X : {array-like, sparse matrix}
+        Data on which to apply mask.
+
+    mask : array-like
+        Mask to be used on X.
+
+    Returns
+    -------
+    mask : ndarray
+        Array that is safe to use on X.
+
+    Examples
+    --------
+    >>> from sklearn.utils import safe_mask
+    >>> from scipy.sparse import csr_matrix
+    >>> data = csr_matrix([[1], [2], [3], [4], [5]])
+    >>> condition = [False, True, True, False, True]
+    >>> mask = safe_mask(data, condition)
+    >>> data[mask].toarray()
+    array([[2],
+           [3],
+           [5]])
+    """
+    mask = np.asarray(mask)
+    if np.issubdtype(mask.dtype, np.signedinteger):
+        return mask
+
+    if hasattr(X, "toarray"):
+        ind = np.arange(mask.shape[0])
+        mask = ind[mask]
+    return mask
+
+
+def axis0_safe_slice(X, mask, len_mask):
+    """Return a mask which is safer to use on X than safe_mask.
+
+    This mask is safer than safe_mask since it returns an
+    empty array, when a sparse matrix is sliced with a boolean mask
+    with all False, instead of raising an unhelpful error in older
+    versions of SciPy.
+
+    See: https://github.com/scipy/scipy/issues/5361
+
+    Also note that we can avoid doing the dot product by checking if
+    the len_mask is not zero in _huber_loss_and_gradient but this
+    is not going to be the bottleneck, since the number of outliers
+    and non_outliers are typically non-zero and it makes the code
+    tougher to follow.
+
+    Parameters
+    ----------
+    X : {array-like, sparse matrix}
+        Data on which to apply mask.
+
+    mask : ndarray
+        Mask to be used on X.
+
+    len_mask : int
+        The length of the mask.
+
+    Returns
+    -------
+    mask : ndarray
+        Array that is safe to use on X.
+    """
+    if len_mask != 0:
+        return X[safe_mask(X, mask), :]
+    return np.zeros(shape=(0, X.shape[1]))
+
+
+def _array_indexing(array, key, key_dtype, axis):
+    """Index an array or scipy.sparse consistently across NumPy version."""
+    if issparse(array) and key_dtype == "bool":
+        key = np.asarray(key)
+    if isinstance(key, tuple):
+        key = list(key)
+    return array[key, ...] if axis == 0 else array[:, key]
+
+
+def _pandas_indexing(X, key, key_dtype, axis):
+    """Index a pandas dataframe or a series."""
+    if _is_arraylike_not_scalar(key):
+        key = np.asarray(key)
+
+    if key_dtype == "int" and not (isinstance(key, slice) or np.isscalar(key)):
+        # using take() instead of iloc[] ensures the return value is a "proper"
+        # copy that will not raise SettingWithCopyWarning
+        return X.take(key, axis=axis)
+    else:
+        # check whether we should index with loc or iloc
+        indexer = X.iloc if key_dtype == "int" else X.loc
+        return indexer[:, key] if axis else indexer[key]
+
+
+def _list_indexing(X, key, key_dtype):
+    """Index a Python list."""
+    if np.isscalar(key) or isinstance(key, slice):
+        # key is a slice or a scalar
+        return X[key]
+    if key_dtype == "bool":
+        # key is a boolean array-like
+        return list(compress(X, key))
+    # key is a integer array-like of key
+    return [X[idx] for idx in key]
+
+
+def _polars_indexing(X, key, key_dtype, axis):
+    """Indexing X with polars interchange protocol."""
+    # Polars behavior is more consistent with lists
+    if isinstance(key, np.ndarray):
+        key = key.tolist()
+
+    if axis == 1:
+        return X[:, key]
+    else:
+        return X[key]
+
+
+def _determine_key_type(key, accept_slice=True):
+    """Determine the data type of key.
+
+    Parameters
+    ----------
+    key : scalar, slice or array-like
+        The key from which we want to infer the data type.
+
+    accept_slice : bool, default=True
+        Whether or not to raise an error if the key is a slice.
+
+    Returns
+    -------
+    dtype : {'int', 'str', 'bool', None}
+        Returns the data type of key.
+    """
+    err_msg = (
+        "No valid specification of the columns. Only a scalar, list or "
+        "slice of all integers or all strings, or boolean mask is "
+        "allowed"
+    )
+
+    dtype_to_str = {int: "int", str: "str", bool: "bool", np.bool_: "bool"}
+    array_dtype_to_str = {
+        "i": "int",
+        "u": "int",
+        "b": "bool",
+        "O": "str",
+        "U": "str",
+        "S": "str",
+    }
+
+    if key is None:
+        return None
+    if isinstance(key, tuple(dtype_to_str.keys())):
+        try:
+            return dtype_to_str[type(key)]
+        except KeyError:
+            raise ValueError(err_msg)
+    if isinstance(key, slice):
+        if not accept_slice:
+            raise TypeError(
+                "Only array-like or scalar are supported. A Python slice was given."
+            )
+        if key.start is None and key.stop is None:
+            return None
+        key_start_type = _determine_key_type(key.start)
+        key_stop_type = _determine_key_type(key.stop)
+        if key_start_type is not None and key_stop_type is not None:
+            if key_start_type != key_stop_type:
+                raise ValueError(err_msg)
+        if key_start_type is not None:
+            return key_start_type
+        return key_stop_type
+    if isinstance(key, (list, tuple)):
+        unique_key = set(key)
+        key_type = {_determine_key_type(elt) for elt in unique_key}
+        if not key_type:
+            return None
+        if len(key_type) != 1:
+            raise ValueError(err_msg)
+        return key_type.pop()
+    if hasattr(key, "dtype"):
+        try:
+            return array_dtype_to_str[key.dtype.kind]
+        except KeyError:
+            raise ValueError(err_msg)
+    raise ValueError(err_msg)
+
+
+def _safe_indexing(X, indices, *, axis=0):
+    """Return rows, items or columns of X using indices.
+
+    .. warning::
+
+        This utility is documented, but **private**. This means that
+        backward compatibility might be broken without any deprecation
+        cycle.
+
+    Parameters
+    ----------
+    X : array-like, sparse-matrix, list, pandas.DataFrame, pandas.Series
+        Data from which to sample rows, items or columns. `list` are only
+        supported when `axis=0`.
+    indices : bool, int, str, slice, array-like
+        - If `axis=0`, boolean and integer array-like, integer slice,
+          and scalar integer are supported.
+        - If `axis=1`:
+            - to select a single column, `indices` can be of `int` type for
+              all `X` types and `str` only for dataframe. The selected subset
+              will be 1D, unless `X` is a sparse matrix in which case it will
+              be 2D.
+            - to select multiples columns, `indices` can be one of the
+              following: `list`, `array`, `slice`. The type used in
+              these containers can be one of the following: `int`, 'bool' and
+              `str`. However, `str` is only supported when `X` is a dataframe.
+              The selected subset will be 2D.
+    axis : int, default=0
+        The axis along which `X` will be subsampled. `axis=0` will select
+        rows while `axis=1` will select columns.
+
+    Returns
+    -------
+    subset
+        Subset of X on axis 0 or 1.
+
+    Notes
+    -----
+    CSR, CSC, and LIL sparse matrices are supported. COO sparse matrices are
+    not supported.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from sklearn.utils import _safe_indexing
+    >>> data = np.array([[1, 2], [3, 4], [5, 6]])
+    >>> _safe_indexing(data, 0, axis=0)  # select the first row
+    array([1, 2])
+    >>> _safe_indexing(data, 0, axis=1)  # select the first column
+    array([1, 3, 5])
+    """
+    if indices is None:
+        return X
+
+    if axis not in (0, 1):
+        raise ValueError(
+            "'axis' should be either 0 (to index rows) or 1 (to index "
+            " column). Got {} instead.".format(axis)
+        )
+
+    indices_dtype = _determine_key_type(indices)
+
+    if axis == 0 and indices_dtype == "str":
+        raise ValueError("String indexing is not supported with 'axis=0'")
+
+    if axis == 1 and isinstance(X, list):
+        raise ValueError("axis=1 is not supported for lists")
+
+    if axis == 1 and hasattr(X, "ndim") and X.ndim != 2:
+        raise ValueError(
+            "'X' should be a 2D NumPy array, 2D sparse matrix or pandas "
+            "dataframe when indexing the columns (i.e. 'axis=1'). "
+            "Got {} instead with {} dimension(s).".format(type(X), X.ndim)
+        )
+
+    if (
+        axis == 1
+        and indices_dtype == "str"
+        and not (_is_pandas_df(X) or _use_interchange_protocol(X))
+    ):
+        raise ValueError(
+            "Specifying the columns using strings is only supported for dataframes."
+        )
+
+    if hasattr(X, "iloc"):
+        # TODO: we should probably use _is_pandas_df(X) instead but this would
+        # require updating some tests such as test_train_test_split_mock_pandas.
+        return _pandas_indexing(X, indices, indices_dtype, axis=axis)
+    elif _is_polars_df(X):
+        return _polars_indexing(X, indices, indices_dtype, axis=axis)
+    elif hasattr(X, "shape"):
+        return _array_indexing(X, indices, indices_dtype, axis=axis)
+    else:
+        return _list_indexing(X, indices, indices_dtype)
+
+
+def _safe_assign(X, values, *, row_indexer=None, column_indexer=None):
+    """Safe assignment to a numpy array, sparse matrix, or pandas dataframe.
+
+    Parameters
+    ----------
+    X : {ndarray, sparse-matrix, dataframe}
+        Array to be modified. It is expected to be 2-dimensional.
+
+    values : ndarray
+        The values to be assigned to `X`.
+
+    row_indexer : array-like, dtype={int, bool}, default=None
+        A 1-dimensional array to select the rows of interest. If `None`, all
+        rows are selected.
+
+    column_indexer : array-like, dtype={int, bool}, default=None
+        A 1-dimensional array to select the columns of interest. If `None`, all
+        columns are selected.
+    """
+    row_indexer = slice(None, None, None) if row_indexer is None else row_indexer
+    column_indexer = (
+        slice(None, None, None) if column_indexer is None else column_indexer
+    )
+
+    if hasattr(X, "iloc"):  # pandas dataframe
+        with warnings.catch_warnings():
+            # pandas >= 1.5 raises a warning when using iloc to set values in a column
+            # that does not have the same type as the column being set. It happens
+            # for instance when setting a categorical column with a string.
+            # In the future the behavior won't change and the warning should disappear.
+            # TODO(1.3): check if the warning is still raised or remove the filter.
+            warnings.simplefilter("ignore", FutureWarning)
+            X.iloc[row_indexer, column_indexer] = values
+    else:  # numpy array or sparse matrix
+        X[row_indexer, column_indexer] = values
+
+
+def _get_column_indices_for_bool_or_int(key, n_columns):
+    # Convert key into list of positive integer indexes
+    try:
+        idx = _safe_indexing(np.arange(n_columns), key)
+    except IndexError as e:
+        raise ValueError(
+            f"all features must be in [0, {n_columns - 1}] or [-{n_columns}, 0]"
+        ) from e
+    return np.atleast_1d(idx).tolist()
+
+
+def _get_column_indices(X, key):
+    """Get feature column indices for input data X and key.
+
+    For accepted values of `key`, see the docstring of
+    :func:`_safe_indexing`.
+    """
+    key_dtype = _determine_key_type(key)
+    if _use_interchange_protocol(X):
+        return _get_column_indices_interchange(X.__dataframe__(), key, key_dtype)
+
+    n_columns = X.shape[1]
+    if isinstance(key, (list, tuple)) and not key:
+        # we get an empty list
+        return []
+    elif key_dtype in ("bool", "int"):
+        return _get_column_indices_for_bool_or_int(key, n_columns)
+    else:
+        try:
+            all_columns = X.columns
+        except AttributeError:
+            raise ValueError(
+                "Specifying the columns using strings is only supported for dataframes."
+            )
+        if isinstance(key, str):
+            columns = [key]
+        elif isinstance(key, slice):
+            start, stop = key.start, key.stop
+            if start is not None:
+                start = all_columns.get_loc(start)
+            if stop is not None:
+                # pandas indexing with strings is endpoint included
+                stop = all_columns.get_loc(stop) + 1
+            else:
+                stop = n_columns + 1
+            return list(islice(range(n_columns), start, stop))
+        else:
+            columns = list(key)
+
+        try:
+            column_indices = []
+            for col in columns:
+                col_idx = all_columns.get_loc(col)
+                if not isinstance(col_idx, numbers.Integral):
+                    raise ValueError(
+                        f"Selected columns, {columns}, are not unique in dataframe"
+                    )
+                column_indices.append(col_idx)
+
+        except KeyError as e:
+            raise ValueError("A given column is not a column of the dataframe") from e
+
+        return column_indices
+
+
+def _get_column_indices_interchange(X_interchange, key, key_dtype):
+    """Same as _get_column_indices but for X with __dataframe__ protocol."""
+
+    n_columns = X_interchange.num_columns()
+
+    if isinstance(key, (list, tuple)) and not key:
+        # we get an empty list
+        return []
+    elif key_dtype in ("bool", "int"):
+        return _get_column_indices_for_bool_or_int(key, n_columns)
+    else:
+        column_names = list(X_interchange.column_names())
+
+        if isinstance(key, slice):
+            if key.step not in [1, None]:
+                raise NotImplementedError("key.step must be 1 or None")
+            start, stop = key.start, key.stop
+            if start is not None:
+                start = column_names.index(start)
+
+            if stop is not None:
+                stop = column_names.index(stop) + 1
+            else:
+                stop = n_columns + 1
+            return list(islice(range(n_columns), start, stop))
+
+        selected_columns = [key] if np.isscalar(key) else key
+
+        try:
+            return [column_names.index(col) for col in selected_columns]
+        except ValueError as e:
+            raise ValueError("A given column is not a column of the dataframe") from e
+
+
+@validate_params(
+    {
+        "replace": ["boolean"],
+        "n_samples": [Interval(numbers.Integral, 1, None, closed="left"), None],
+        "random_state": ["random_state"],
+        "stratify": ["array-like", None],
+    },
+    prefer_skip_nested_validation=True,
+)
+def resample(*arrays, replace=True, n_samples=None, random_state=None, stratify=None):
+    """Resample arrays or sparse matrices in a consistent way.
+
+    The default strategy implements one step of the bootstrapping
+    procedure.
+
+    Parameters
+    ----------
+    *arrays : sequence of array-like of shape (n_samples,) or \
+            (n_samples, n_outputs)
+        Indexable data-structures can be arrays, lists, dataframes or scipy
+        sparse matrices with consistent first dimension.
+
+    replace : bool, default=True
+        Implements resampling with replacement. If False, this will implement
+        (sliced) random permutations.
+
+    n_samples : int, default=None
+        Number of samples to generate. If left to None this is
+        automatically set to the first dimension of the arrays.
+        If replace is False it should not be larger than the length of
+        arrays.
+
+    random_state : int, RandomState instance or None, default=None
+        Determines random number generation for shuffling
+        the data.
+        Pass an int for reproducible results across multiple function calls.
+        See :term:`Glossary <random_state>`.
+
+    stratify : array-like of shape (n_samples,) or (n_samples, n_outputs), \
+            default=None
+        If not None, data is split in a stratified fashion, using this as
+        the class labels.
+
+    Returns
+    -------
+    resampled_arrays : sequence of array-like of shape (n_samples,) or \
+            (n_samples, n_outputs)
+        Sequence of resampled copies of the collections. The original arrays
+        are not impacted.
+
+    See Also
+    --------
+    shuffle : Shuffle arrays or sparse matrices in a consistent way.
+
+    Examples
+    --------
+    It is possible to mix sparse and dense arrays in the same run::
+
+      >>> import numpy as np
+      >>> X = np.array([[1., 0.], [2., 1.], [0., 0.]])
+      >>> y = np.array([0, 1, 2])
+
+      >>> from scipy.sparse import coo_matrix
+      >>> X_sparse = coo_matrix(X)
+
+      >>> from sklearn.utils import resample
+      >>> X, X_sparse, y = resample(X, X_sparse, y, random_state=0)
+      >>> X
+      array([[1., 0.],
+             [2., 1.],
+             [1., 0.]])
+
+      >>> X_sparse
+      <3x2 sparse matrix of type '<... 'numpy.float64'>'
+          with 4 stored elements in Compressed Sparse Row format>
+
+      >>> X_sparse.toarray()
+      array([[1., 0.],
+             [2., 1.],
+             [1., 0.]])
+
+      >>> y
+      array([0, 1, 0])
+
+      >>> resample(y, n_samples=2, random_state=0)
+      array([0, 1])
+
+    Example using stratification::
+
+      >>> y = [0, 0, 1, 1, 1, 1, 1, 1, 1]
+      >>> resample(y, n_samples=5, replace=False, stratify=y,
+      ...          random_state=0)
+      [1, 1, 1, 0, 1]
+    """
+    max_n_samples = n_samples
+    random_state = check_random_state(random_state)
+
+    if len(arrays) == 0:
+        return None
+
+    first = arrays[0]
+    n_samples = first.shape[0] if hasattr(first, "shape") else len(first)
+
+    if max_n_samples is None:
+        max_n_samples = n_samples
+    elif (max_n_samples > n_samples) and (not replace):
+        raise ValueError(
+            "Cannot sample %d out of arrays with dim %d when replace is False"
+            % (max_n_samples, n_samples)
+        )
+
+    check_consistent_length(*arrays)
+
+    if stratify is None:
+        if replace:
+            indices = random_state.randint(0, n_samples, size=(max_n_samples,))
+        else:
+            indices = np.arange(n_samples)
+            random_state.shuffle(indices)
+            indices = indices[:max_n_samples]
+    else:
+        # Code adapted from StratifiedShuffleSplit()
+        y = check_array(stratify, ensure_2d=False, dtype=None)
+        if y.ndim == 2:
+            # for multi-label y, map each distinct row to a string repr
+            # using join because str(row) uses an ellipsis if len(row) > 1000
+            y = np.array([" ".join(row.astype("str")) for row in y])
+
+        classes, y_indices = np.unique(y, return_inverse=True)
+        n_classes = classes.shape[0]
+
+        class_counts = np.bincount(y_indices)
+
+        # Find the sorted list of instances for each class:
+        # (np.unique above performs a sort, so code is O(n logn) already)
+        class_indices = np.split(
+            np.argsort(y_indices, kind="mergesort"), np.cumsum(class_counts)[:-1]
+        )
+
+        n_i = _approximate_mode(class_counts, max_n_samples, random_state)
+
+        indices = []
+
+        for i in range(n_classes):
+            indices_i = random_state.choice(class_indices[i], n_i[i], replace=replace)
+            indices.extend(indices_i)
+
+        indices = random_state.permutation(indices)
+
+    # convert sparse matrices to CSR for row-based indexing
+    arrays = [a.tocsr() if issparse(a) else a for a in arrays]
+    resampled_arrays = [_safe_indexing(a, indices) for a in arrays]
+    if len(resampled_arrays) == 1:
+        # syntactic sugar for the unit argument case
+        return resampled_arrays[0]
+    else:
+        return resampled_arrays
+
+
+def shuffle(*arrays, random_state=None, n_samples=None):
+    """Shuffle arrays or sparse matrices in a consistent way.
+
+    This is a convenience alias to ``resample(*arrays, replace=False)`` to do
+    random permutations of the collections.
+
+    Parameters
+    ----------
+    *arrays : sequence of indexable data-structures
+        Indexable data-structures can be arrays, lists, dataframes or scipy
+        sparse matrices with consistent first dimension.
+
+    random_state : int, RandomState instance or None, default=None
+        Determines random number generation for shuffling
+        the data.
+        Pass an int for reproducible results across multiple function calls.
+        See :term:`Glossary <random_state>`.
+
+    n_samples : int, default=None
+        Number of samples to generate. If left to None this is
+        automatically set to the first dimension of the arrays.  It should
+        not be larger than the length of arrays.
+
+    Returns
+    -------
+    shuffled_arrays : sequence of indexable data-structures
+        Sequence of shuffled copies of the collections. The original arrays
+        are not impacted.
+
+    See Also
+    --------
+    resample : Resample arrays or sparse matrices in a consistent way.
+
+    Examples
+    --------
+    It is possible to mix sparse and dense arrays in the same run::
+
+      >>> import numpy as np
+      >>> X = np.array([[1., 0.], [2., 1.], [0., 0.]])
+      >>> y = np.array([0, 1, 2])
+
+      >>> from scipy.sparse import coo_matrix
+      >>> X_sparse = coo_matrix(X)
+
+      >>> from sklearn.utils import shuffle
+      >>> X, X_sparse, y = shuffle(X, X_sparse, y, random_state=0)
+      >>> X
+      array([[0., 0.],
+             [2., 1.],
+             [1., 0.]])
+
+      >>> X_sparse
+      <3x2 sparse matrix of type '<... 'numpy.float64'>'
+          with 3 stored elements in Compressed Sparse Row format>
+
+      >>> X_sparse.toarray()
+      array([[0., 0.],
+             [2., 1.],
+             [1., 0.]])
+
+      >>> y
+      array([2, 1, 0])
+
+      >>> shuffle(y, n_samples=2, random_state=0)
+      array([0, 1])
+    """
+    return resample(
+        *arrays, replace=False, n_samples=n_samples, random_state=random_state
+    )
+
+
+def safe_sqr(X, *, copy=True):
+    """Element wise squaring of array-likes and sparse matrices.
+
+    Parameters
+    ----------
+    X : {array-like, ndarray, sparse matrix}
+
+    copy : bool, default=True
+        Whether to create a copy of X and operate on it or to perform
+        inplace computation (default behaviour).
+
+    Returns
+    -------
+    X ** 2 : element wise square
+         Return the element-wise square of the input.
+
+    Examples
+    --------
+    >>> from sklearn.utils import safe_sqr
+    >>> safe_sqr([1, 2, 3])
+    array([1, 4, 9])
+    """
+    X = check_array(X, accept_sparse=["csr", "csc", "coo"], ensure_2d=False)
+    if issparse(X):
+        if copy:
+            X = X.copy()
+        X.data **= 2
+    else:
+        if copy:
+            X = X**2
+        else:
+            X **= 2
+    return X
+
+
+def _chunk_generator(gen, chunksize):
+    """Chunk generator, ``gen`` into lists of length ``chunksize``. The last
+    chunk may have a length less than ``chunksize``."""
+    while True:
+        chunk = list(islice(gen, chunksize))
+        if chunk:
+            yield chunk
+        else:
+            return
+
+
+@validate_params(
+    {
+        "n": [Interval(numbers.Integral, 1, None, closed="left")],
+        "batch_size": [Interval(numbers.Integral, 1, None, closed="left")],
+        "min_batch_size": [Interval(numbers.Integral, 0, None, closed="left")],
+    },
+    prefer_skip_nested_validation=True,
+)
+def gen_batches(n, batch_size, *, min_batch_size=0):
+    """Generator to create slices containing `batch_size` elements from 0 to `n`.
+
+    The last slice may contain less than `batch_size` elements, when
+    `batch_size` does not divide `n`.
+
+    Parameters
+    ----------
+    n : int
+        Size of the sequence.
+    batch_size : int
+        Number of elements in each batch.
+    min_batch_size : int, default=0
+        Minimum number of elements in each batch.
+
+    Yields
+    ------
+    slice of `batch_size` elements
+
+    See Also
+    --------
+    gen_even_slices: Generator to create n_packs slices going up to n.
+
+    Examples
+    --------
+    >>> from sklearn.utils import gen_batches
+    >>> list(gen_batches(7, 3))
+    [slice(0, 3, None), slice(3, 6, None), slice(6, 7, None)]
+    >>> list(gen_batches(6, 3))
+    [slice(0, 3, None), slice(3, 6, None)]
+    >>> list(gen_batches(2, 3))
+    [slice(0, 2, None)]
+    >>> list(gen_batches(7, 3, min_batch_size=0))
+    [slice(0, 3, None), slice(3, 6, None), slice(6, 7, None)]
+    >>> list(gen_batches(7, 3, min_batch_size=2))
+    [slice(0, 3, None), slice(3, 7, None)]
+    """
+    start = 0
+    for _ in range(int(n // batch_size)):
+        end = start + batch_size
+        if end + min_batch_size > n:
+            continue
+        yield slice(start, end)
+        start = end
+    if start < n:
+        yield slice(start, n)
+
+
+@validate_params(
+    {
+        "n": [Interval(Integral, 1, None, closed="left")],
+        "n_packs": [Interval(Integral, 1, None, closed="left")],
+        "n_samples": [Interval(Integral, 1, None, closed="left"), None],
+    },
+    prefer_skip_nested_validation=True,
+)
+def gen_even_slices(n, n_packs, *, n_samples=None):
+    """Generator to create `n_packs` evenly spaced slices going up to `n`.
+
+    If `n_packs` does not divide `n`, except for the first `n % n_packs`
+    slices, remaining slices may contain fewer elements.
+
+    Parameters
+    ----------
+    n : int
+        Size of the sequence.
+    n_packs : int
+        Number of slices to generate.
+    n_samples : int, default=None
+        Number of samples. Pass `n_samples` when the slices are to be used for
+        sparse matrix indexing; slicing off-the-end raises an exception, while
+        it works for NumPy arrays.
+
+    Yields
+    ------
+    `slice` representing a set of indices from 0 to n.
+
+    See Also
+    --------
+    gen_batches: Generator to create slices containing batch_size elements
+        from 0 to n.
+
+    Examples
+    --------
+    >>> from sklearn.utils import gen_even_slices
+    >>> list(gen_even_slices(10, 1))
+    [slice(0, 10, None)]
+    >>> list(gen_even_slices(10, 10))
+    [slice(0, 1, None), slice(1, 2, None), ..., slice(9, 10, None)]
+    >>> list(gen_even_slices(10, 5))
+    [slice(0, 2, None), slice(2, 4, None), ..., slice(8, 10, None)]
+    >>> list(gen_even_slices(10, 3))
+    [slice(0, 4, None), slice(4, 7, None), slice(7, 10, None)]
+    """
+    start = 0
+    for pack_num in range(n_packs):
+        this_n = n // n_packs
+        if pack_num < n % n_packs:
+            this_n += 1
+        if this_n > 0:
+            end = start + this_n
+            if n_samples is not None:
+                end = min(n_samples, end)
+            yield slice(start, end, None)
+            start = end
+
+
+def tosequence(x):
+    """Cast iterable x to a Sequence, avoiding a copy if possible.
+
+    Parameters
+    ----------
+    x : iterable
+        The iterable to be converted.
+
+    Returns
+    -------
+    x : Sequence
+        If `x` is a NumPy array, it returns it as a `ndarray`. If `x`
+        is a `Sequence`, `x` is returned as-is. If `x` is from any other
+        type, `x` is returned casted as a list.
+    """
+    if isinstance(x, np.ndarray):
+        return np.asarray(x)
+    elif isinstance(x, Sequence):
+        return x
+    else:
+        return list(x)
+
+
+def _to_object_array(sequence):
+    """Convert sequence to a 1-D NumPy array of object dtype.
+
+    numpy.array constructor has a similar use but it's output
+    is ambiguous. It can be 1-D NumPy array of object dtype if
+    the input is a ragged array, but if the input is a list of
+    equal length arrays, then the output is a 2D numpy.array.
+    _to_object_array solves this ambiguity by guarantying that
+    the output is a 1-D NumPy array of objects for any input.
+
+    Parameters
+    ----------
+    sequence : array-like of shape (n_elements,)
+        The sequence to be converted.
+
+    Returns
+    -------
+    out : ndarray of shape (n_elements,), dtype=object
+        The converted sequence into a 1-D NumPy array of object dtype.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from sklearn.utils import _to_object_array
+    >>> _to_object_array([np.array([0]), np.array([1])])
+    array([array([0]), array([1])], dtype=object)
+    >>> _to_object_array([np.array([0]), np.array([1, 2])])
+    array([array([0]), array([1, 2])], dtype=object)
+    >>> _to_object_array([np.array([0]), np.array([1, 2])])
+    array([array([0]), array([1, 2])], dtype=object)
+    """
+    out = np.empty(len(sequence), dtype=object)
+    out[:] = sequence
+    return out
+
+
+def indices_to_mask(indices, mask_length):
+    """Convert list of indices to boolean mask.
+
+    Parameters
+    ----------
+    indices : list-like
+        List of integers treated as indices.
+    mask_length : int
+        Length of boolean mask to be generated.
+        This parameter must be greater than max(indices).
+
+    Returns
+    -------
+    mask : 1d boolean nd-array
+        Boolean array that is True where indices are present, else False.
+
+    Examples
+    --------
+    >>> from sklearn.utils import indices_to_mask
+    >>> indices = [1, 2 , 3, 4]
+    >>> indices_to_mask(indices, 5)
+    array([False,  True,  True,  True,  True])
+    """
+    if mask_length <= np.max(indices):
+        raise ValueError("mask_length must be greater than max(indices)")
+
+    mask = np.zeros(mask_length, dtype=bool)
+    mask[indices] = True
+
+    return mask
+
+
+def _message_with_time(source, message, time):
+    """Create one line message for logging purposes.
+
+    Parameters
+    ----------
+    source : str
+        String indicating the source or the reference of the message.
+
+    message : str
+        Short message.
+
+    time : int
+        Time in seconds.
+    """
+    start_message = "[%s] " % source
+
+    # adapted from joblib.logger.short_format_time without the Windows -.1s
+    # adjustment
+    if time > 60:
+        time_str = "%4.1fmin" % (time / 60)
+    else:
+        time_str = " %5.1fs" % time
+    end_message = " %s, total=%s" % (message, time_str)
+    dots_len = 70 - len(start_message) - len(end_message)
+    return "%s%s%s" % (start_message, dots_len * ".", end_message)
+
+
+@contextmanager
+def _print_elapsed_time(source, message=None):
+    """Log elapsed time to stdout when the context is exited.
+
+    Parameters
+    ----------
+    source : str
+        String indicating the source or the reference of the message.
+
+    message : str, default=None
+        Short message. If None, nothing will be printed.
+
+    Returns
+    -------
+    context_manager
+        Prints elapsed time upon exit if verbose.
+    """
+    if message is None:
+        yield
+    else:
+        start = timeit.default_timer()
+        yield
+        print(_message_with_time(source, message, timeit.default_timer() - start))
+
+
+def get_chunk_n_rows(row_bytes, *, max_n_rows=None, working_memory=None):
+    """Calculate how many rows can be processed within `working_memory`.
+
+    Parameters
+    ----------
+    row_bytes : int
+        The expected number of bytes of memory that will be consumed
+        during the processing of each row.
+    max_n_rows : int, default=None
+        The maximum return value.
+    working_memory : int or float, default=None
+        The number of rows to fit inside this number of MiB will be
+        returned. When None (default), the value of
+        ``sklearn.get_config()['working_memory']`` is used.
+
+    Returns
+    -------
+    int
+        The number of rows which can be processed within `working_memory`.
+
+    Warns
+    -----
+    Issues a UserWarning if `row_bytes exceeds `working_memory` MiB.
+    """
+
+    if working_memory is None:
+        working_memory = get_config()["working_memory"]
+
+    chunk_n_rows = int(working_memory * (2**20) // row_bytes)
+    if max_n_rows is not None:
+        chunk_n_rows = min(chunk_n_rows, max_n_rows)
+    if chunk_n_rows < 1:
+        warnings.warn(
+            "Could not adhere to working_memory config. "
+            "Currently %.0fMiB, %.0fMiB required."
+            % (working_memory, np.ceil(row_bytes * 2**-20))
+        )
+        chunk_n_rows = 1
+    return chunk_n_rows
+
+
+def _is_pandas_na(x):
+    """Test if x is pandas.NA.
+
+    We intentionally do not use this function to return `True` for `pd.NA` in
+    `is_scalar_nan`, because estimators that support `pd.NA` are the exception
+    rather than the rule at the moment. When `pd.NA` is more universally
+    supported, we may reconsider this decision.
+
+    Parameters
+    ----------
+    x : any type
+
+    Returns
+    -------
+    boolean
+    """
+    with suppress(ImportError):
+        from pandas import NA
+
+        return x is NA
+
+    return False
+
+
+def is_scalar_nan(x):
+    """Test if x is NaN.
+
+    This function is meant to overcome the issue that np.isnan does not allow
+    non-numerical types as input, and that np.nan is not float('nan').
+
+    Parameters
+    ----------
+    x : any type
+        Any scalar value.
+
+    Returns
+    -------
+    bool
+        Returns true if x is NaN, and false otherwise.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from sklearn.utils import is_scalar_nan
+    >>> is_scalar_nan(np.nan)
+    True
+    >>> is_scalar_nan(float("nan"))
+    True
+    >>> is_scalar_nan(None)
+    False
+    >>> is_scalar_nan("")
+    False
+    >>> is_scalar_nan([np.nan])
+    False
+    """
+    return (
+        not isinstance(x, numbers.Integral)
+        and isinstance(x, numbers.Real)
+        and math.isnan(x)
+    )
+
+
+def _approximate_mode(class_counts, n_draws, rng):
+    """Computes approximate mode of multivariate hypergeometric.
+
+    This is an approximation to the mode of the multivariate
+    hypergeometric given by class_counts and n_draws.
+    It shouldn't be off by more than one.
+
+    It is the mostly likely outcome of drawing n_draws many
+    samples from the population given by class_counts.
+
+    Parameters
+    ----------
+    class_counts : ndarray of int
+        Population per class.
+    n_draws : int
+        Number of draws (samples to draw) from the overall population.
+    rng : random state
+        Used to break ties.
+
+    Returns
+    -------
+    sampled_classes : ndarray of int
+        Number of samples drawn from each class.
+        np.sum(sampled_classes) == n_draws
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from sklearn.utils import _approximate_mode
+    >>> _approximate_mode(class_counts=np.array([4, 2]), n_draws=3, rng=0)
+    array([2, 1])
+    >>> _approximate_mode(class_counts=np.array([5, 2]), n_draws=4, rng=0)
+    array([3, 1])
+    >>> _approximate_mode(class_counts=np.array([2, 2, 2, 1]),
+    ...                   n_draws=2, rng=0)
+    array([0, 1, 1, 0])
+    >>> _approximate_mode(class_counts=np.array([2, 2, 2, 1]),
+    ...                   n_draws=2, rng=42)
+    array([1, 1, 0, 0])
+    """
+    rng = check_random_state(rng)
+    # this computes a bad approximation to the mode of the
+    # multivariate hypergeometric given by class_counts and n_draws
+    continuous = class_counts / class_counts.sum() * n_draws
+    # floored means we don't overshoot n_samples, but probably undershoot
+    floored = np.floor(continuous)
+    # we add samples according to how much "left over" probability
+    # they had, until we arrive at n_samples
+    need_to_add = int(n_draws - floored.sum())
+    if need_to_add > 0:
+        remainder = continuous - floored
+        values = np.sort(np.unique(remainder))[::-1]
+        # add according to remainder, but break ties
+        # randomly to avoid biases
+        for value in values:
+            (inds,) = np.where(remainder == value)
+            # if we need_to_add less than what's in inds
+            # we draw randomly from them.
+            # if we need to add more, we add them all and
+            # go to the next value
+            add_now = min(len(inds), need_to_add)
+            inds = rng.choice(inds, size=add_now, replace=False)
+            floored[inds] += 1
+            need_to_add -= add_now
+            if need_to_add == 0:
+                break
+    return floored.astype(int)
+
+
+def check_matplotlib_support(caller_name):
+    """Raise ImportError with detailed error message if mpl is not installed.
+
+    Plot utilities like any of the Display's plotting functions should lazily import
+    matplotlib and call this helper before any computation.
+
+    Parameters
+    ----------
+    caller_name : str
+        The name of the caller that requires matplotlib.
+    """
+    try:
+        import matplotlib  # noqa
+    except ImportError as e:
+        raise ImportError(
+            "{} requires matplotlib. You can install matplotlib with "
+            "`pip install matplotlib`".format(caller_name)
+        ) from e
+
+
+def check_pandas_support(caller_name):
+    """Raise ImportError with detailed error message if pandas is not installed.
+
+    Plot utilities like :func:`fetch_openml` should lazily import
+    pandas and call this helper before any computation.
+
+    Parameters
+    ----------
+    caller_name : str
+        The name of the caller that requires pandas.
+
+    Returns
+    -------
+    pandas
+        The pandas package.
+    """
+    try:
+        import pandas  # noqa
+
+        return pandas
+    except ImportError as e:
+        raise ImportError("{} requires pandas.".format(caller_name)) from e

venv/lib/python3.10/site-packages/sklearn/utils/_arpack.py

@@ -0,0 +1,30 @@
+from .validation import check_random_state
+
+
+def _init_arpack_v0(size, random_state):
+    """Initialize the starting vector for iteration in ARPACK functions.
+
+    Initialize a ndarray with values sampled from the uniform distribution on
+    [-1, 1]. This initialization model has been chosen to be consistent with
+    the ARPACK one as another initialization can lead to convergence issues.
+
+    Parameters
+    ----------
+    size : int
+        The size of the eigenvalue vector to be initialized.
+
+    random_state : int, RandomState instance or None, default=None
+        The seed of the pseudo random number generator used to generate a
+        uniform distribution. If int, random_state is the seed used by the
+        random number generator; If RandomState instance, random_state is the
+        random number generator; If None, the random number generator is the
+        RandomState instance used by `np.random`.
+
+    Returns
+    -------
+    v0 : ndarray of shape (size,)
+        The initialized vector.
+    """
+    random_state = check_random_state(random_state)
+    v0 = random_state.uniform(-1, 1, size)
+    return v0

venv/lib/python3.10/site-packages/sklearn/utils/_array_api.py

@@ -0,0 +1,575 @@
+"""Tools to support array_api."""
+import itertools
+import math
+from functools import wraps
+
+import numpy
+import scipy.special as special
+
+from .._config import get_config
+from .fixes import parse_version
+
+
+def yield_namespace_device_dtype_combinations():
+    """Yield supported namespace, device, dtype tuples for testing.
+
+    Use this to test that an estimator works with all combinations.
+
+    Returns
+    -------
+    array_namespace : str
+        The name of the Array API namespace.
+
+    device : str
+        The name of the device on which to allocate the arrays. Can be None to
+        indicate that the default value should be used.
+
+    dtype_name : str
+        The name of the data type to use for arrays. Can be None to indicate
+        that the default value should be used.
+    """
+    for array_namespace in [
+        # The following is used to test the array_api_compat wrapper when
+        # array_api_dispatch is enabled: in particular, the arrays used in the
+        # tests are regular numpy arrays without any "device" attribute.
+        "numpy",
+        # Stricter NumPy-based Array API implementation. The
+        # numpy.array_api.Array instances always a dummy "device" attribute.
+        "numpy.array_api",
+        "cupy",
+        "cupy.array_api",
+        "torch",
+    ]:
+        if array_namespace == "torch":
+            for device, dtype in itertools.product(
+                ("cpu", "cuda"), ("float64", "float32")
+            ):
+                yield array_namespace, device, dtype
+            yield array_namespace, "mps", "float32"
+        else:
+            yield array_namespace, None, None
+
+
+def _check_array_api_dispatch(array_api_dispatch):
+    """Check that array_api_compat is installed and NumPy version is compatible.
+
+    array_api_compat follows NEP29, which has a higher minimum NumPy version than
+    scikit-learn.
+    """
+    if array_api_dispatch:
+        try:
+            import array_api_compat  # noqa
+        except ImportError:
+            raise ImportError(
+                "array_api_compat is required to dispatch arrays using the API"
+                " specification"
+            )
+
+        numpy_version = parse_version(numpy.__version__)
+        min_numpy_version = "1.21"
+        if numpy_version < parse_version(min_numpy_version):
+            raise ImportError(
+                f"NumPy must be {min_numpy_version} or newer to dispatch array using"
+                " the API specification"
+            )
+
+
+def device(x):
+    """Hardware device the array data resides on.
+
+    Parameters
+    ----------
+    x : array
+        Array instance from NumPy or an array API compatible library.
+
+    Returns
+    -------
+    out : device
+        `device` object (see the "Device Support" section of the array API spec).
+    """
+    if isinstance(x, (numpy.ndarray, numpy.generic)):
+        return "cpu"
+    return x.device
+
+
+def size(x):
+    """Return the total number of elements of x.
+
+    Parameters
+    ----------
+    x : array
+        Array instance from NumPy or an array API compatible library.
+
+    Returns
+    -------
+    out : int
+        Total number of elements.
+    """
+    return math.prod(x.shape)
+
+
+def _is_numpy_namespace(xp):
+    """Return True if xp is backed by NumPy."""
+    return xp.__name__ in {"numpy", "array_api_compat.numpy", "numpy.array_api"}
+
+
+def _union1d(a, b, xp):
+    if _is_numpy_namespace(xp):
+        return xp.asarray(numpy.union1d(a, b))
+    assert a.ndim == b.ndim == 1
+    return xp.unique_values(xp.concat([xp.unique_values(a), xp.unique_values(b)]))
+
+
+def isdtype(dtype, kind, *, xp):
+    """Returns a boolean indicating whether a provided dtype is of type "kind".
+
+    Included in the v2022.12 of the Array API spec.
+    https://data-apis.org/array-api/latest/API_specification/generated/array_api.isdtype.html
+    """
+    if isinstance(kind, tuple):
+        return any(_isdtype_single(dtype, k, xp=xp) for k in kind)
+    else:
+        return _isdtype_single(dtype, kind, xp=xp)
+
+
+def _isdtype_single(dtype, kind, *, xp):
+    if isinstance(kind, str):
+        if kind == "bool":
+            return dtype == xp.bool
+        elif kind == "signed integer":
+            return dtype in {xp.int8, xp.int16, xp.int32, xp.int64}
+        elif kind == "unsigned integer":
+            return dtype in {xp.uint8, xp.uint16, xp.uint32, xp.uint64}
+        elif kind == "integral":
+            return any(
+                _isdtype_single(dtype, k, xp=xp)
+                for k in ("signed integer", "unsigned integer")
+            )
+        elif kind == "real floating":
+            return dtype in supported_float_dtypes(xp)
+        elif kind == "complex floating":
+            # Some name spaces do not have complex, such as cupy.array_api
+            # and numpy.array_api
+            complex_dtypes = set()
+            if hasattr(xp, "complex64"):
+                complex_dtypes.add(xp.complex64)
+            if hasattr(xp, "complex128"):
+                complex_dtypes.add(xp.complex128)
+            return dtype in complex_dtypes
+        elif kind == "numeric":
+            return any(
+                _isdtype_single(dtype, k, xp=xp)
+                for k in ("integral", "real floating", "complex floating")
+            )
+        else:
+            raise ValueError(f"Unrecognized data type kind: {kind!r}")
+    else:
+        return dtype == kind
+
+
+def supported_float_dtypes(xp):
+    """Supported floating point types for the namespace
+
+    Note: float16 is not officially part of the Array API spec at the
+    time of writing but scikit-learn estimators and functions can choose
+    to accept it when xp.float16 is defined.
+
+    https://data-apis.org/array-api/latest/API_specification/data_types.html
+    """
+    if hasattr(xp, "float16"):
+        return (xp.float64, xp.float32, xp.float16)
+    else:
+        return (xp.float64, xp.float32)
+
+
+class _ArrayAPIWrapper:
+    """sklearn specific Array API compatibility wrapper
+
+    This wrapper makes it possible for scikit-learn maintainers to
+    deal with discrepancies between different implementations of the
+    Python Array API standard and its evolution over time.
+
+    The Python Array API standard specification:
+    https://data-apis.org/array-api/latest/
+
+    Documentation of the NumPy implementation:
+    https://numpy.org/neps/nep-0047-array-api-standard.html
+    """
+
+    def __init__(self, array_namespace):
+        self._namespace = array_namespace
+
+    def __getattr__(self, name):
+        return getattr(self._namespace, name)
+
+    def __eq__(self, other):
+        return self._namespace == other._namespace
+
+    def isdtype(self, dtype, kind):
+        return isdtype(dtype, kind, xp=self._namespace)
+
+
+def _check_device_cpu(device):  # noqa
+    if device not in {"cpu", None}:
+        raise ValueError(f"Unsupported device for NumPy: {device!r}")
+
+
+def _accept_device_cpu(func):
+    @wraps(func)
+    def wrapped_func(*args, **kwargs):
+        _check_device_cpu(kwargs.pop("device", None))
+        return func(*args, **kwargs)
+
+    return wrapped_func
+
+
+class _NumPyAPIWrapper:
+    """Array API compat wrapper for any numpy version
+
+    NumPy < 1.22 does not expose the numpy.array_api namespace. This
+    wrapper makes it possible to write code that uses the standard
+    Array API while working with any version of NumPy supported by
+    scikit-learn.
+
+    See the `get_namespace()` public function for more details.
+    """
+
+    # Creation functions in spec:
+    # https://data-apis.org/array-api/latest/API_specification/creation_functions.html
+    _CREATION_FUNCS = {
+        "arange",
+        "empty",
+        "empty_like",
+        "eye",
+        "full",
+        "full_like",
+        "linspace",
+        "ones",
+        "ones_like",
+        "zeros",
+        "zeros_like",
+    }
+    # Data types in spec
+    # https://data-apis.org/array-api/latest/API_specification/data_types.html
+    _DTYPES = {
+        "int8",
+        "int16",
+        "int32",
+        "int64",
+        "uint8",
+        "uint16",
+        "uint32",
+        "uint64",
+        # XXX: float16 is not part of the Array API spec but exposed by
+        # some namespaces.
+        "float16",
+        "float32",
+        "float64",
+        "complex64",
+        "complex128",
+    }
+
+    def __getattr__(self, name):
+        attr = getattr(numpy, name)
+
+        # Support device kwargs and make sure they are on the CPU
+        if name in self._CREATION_FUNCS:
+            return _accept_device_cpu(attr)
+
+        # Convert to dtype objects
+        if name in self._DTYPES:
+            return numpy.dtype(attr)
+        return attr
+
+    @property
+    def bool(self):
+        return numpy.bool_
+
+    def astype(self, x, dtype, *, copy=True, casting="unsafe"):
+        # astype is not defined in the top level NumPy namespace
+        return x.astype(dtype, copy=copy, casting=casting)
+
+    def asarray(self, x, *, dtype=None, device=None, copy=None):  # noqa
+        _check_device_cpu(device)
+        # Support copy in NumPy namespace
+        if copy is True:
+            return numpy.array(x, copy=True, dtype=dtype)
+        else:
+            return numpy.asarray(x, dtype=dtype)
+
+    def unique_inverse(self, x):
+        return numpy.unique(x, return_inverse=True)
+
+    def unique_counts(self, x):
+        return numpy.unique(x, return_counts=True)
+
+    def unique_values(self, x):
+        return numpy.unique(x)
+
+    def concat(self, arrays, *, axis=None):
+        return numpy.concatenate(arrays, axis=axis)
+
+    def reshape(self, x, shape, *, copy=None):
+        """Gives a new shape to an array without changing its data.
+
+        The Array API specification requires shape to be a tuple.
+        https://data-apis.org/array-api/latest/API_specification/generated/array_api.reshape.html
+        """
+        if not isinstance(shape, tuple):
+            raise TypeError(
+                f"shape must be a tuple, got {shape!r} of type {type(shape)}"
+            )
+
+        if copy is True:
+            x = x.copy()
+        return numpy.reshape(x, shape)
+
+    def isdtype(self, dtype, kind):
+        return isdtype(dtype, kind, xp=self)
+
+
+_NUMPY_API_WRAPPER_INSTANCE = _NumPyAPIWrapper()
+
+
+def get_namespace(*arrays):
+    """Get namespace of arrays.
+
+    Introspect `arrays` arguments and return their common Array API
+    compatible namespace object, if any. NumPy 1.22 and later can
+    construct such containers using the `numpy.array_api` namespace
+    for instance.
+
+    See: https://numpy.org/neps/nep-0047-array-api-standard.html
+
+    If `arrays` are regular numpy arrays, an instance of the
+    `_NumPyAPIWrapper` compatibility wrapper is returned instead.
+
+    Namespace support is not enabled by default. To enabled it
+    call:
+
+      sklearn.set_config(array_api_dispatch=True)
+
+    or:
+
+      with sklearn.config_context(array_api_dispatch=True):
+          # your code here
+
+    Otherwise an instance of the `_NumPyAPIWrapper`
+    compatibility wrapper is always returned irrespective of
+    the fact that arrays implement the `__array_namespace__`
+    protocol or not.
+
+    Parameters
+    ----------
+    *arrays : array objects
+        Array objects.
+
+    Returns
+    -------
+    namespace : module
+        Namespace shared by array objects. If any of the `arrays` are not arrays,
+        the namespace defaults to NumPy.
+
+    is_array_api_compliant : bool
+        True if the arrays are containers that implement the Array API spec.
+        Always False when array_api_dispatch=False.
+    """
+    array_api_dispatch = get_config()["array_api_dispatch"]
+    if not array_api_dispatch:
+        return _NUMPY_API_WRAPPER_INSTANCE, False
+
+    _check_array_api_dispatch(array_api_dispatch)
+
+    # array-api-compat is a required dependency of scikit-learn only when
+    # configuring `array_api_dispatch=True`. Its import should therefore be
+    # protected by _check_array_api_dispatch to display an informative error
+    # message in case it is missing.
+    import array_api_compat
+
+    namespace, is_array_api_compliant = array_api_compat.get_namespace(*arrays), True
+
+    # These namespaces need additional wrapping to smooth out small differences
+    # between implementations
+    if namespace.__name__ in {"numpy.array_api", "cupy.array_api"}:
+        namespace = _ArrayAPIWrapper(namespace)
+
+    return namespace, is_array_api_compliant
+
+
+def _expit(X):
+    xp, _ = get_namespace(X)
+    if _is_numpy_namespace(xp):
+        return xp.asarray(special.expit(numpy.asarray(X)))
+
+    return 1.0 / (1.0 + xp.exp(-X))
+
+
+def _add_to_diagonal(array, value, xp):
+    # Workaround for the lack of support for xp.reshape(a, shape, copy=False) in
+    # numpy.array_api: https://github.com/numpy/numpy/issues/23410
+    value = xp.asarray(value, dtype=array.dtype)
+    if _is_numpy_namespace(xp):
+        array_np = numpy.asarray(array)
+        array_np.flat[:: array.shape[0] + 1] += value
+        return xp.asarray(array_np)
+    elif value.ndim == 1:
+        for i in range(array.shape[0]):
+            array[i, i] += value[i]
+    else:
+        # scalar value
+        for i in range(array.shape[0]):
+            array[i, i] += value
+
+
+def _weighted_sum(sample_score, sample_weight, normalize=False, xp=None):
+    # XXX: this function accepts Array API input but returns a Python scalar
+    # float. The call to float() is convenient because it removes the need to
+    # move back results from device to host memory (e.g. calling `.cpu()` on a
+    # torch tensor). However, this might interact in unexpected ways (break?)
+    # with lazy Array API implementations. See:
+    # https://github.com/data-apis/array-api/issues/642
+    if xp is None:
+        xp, _ = get_namespace(sample_score)
+    if normalize and _is_numpy_namespace(xp):
+        sample_score_np = numpy.asarray(sample_score)
+        if sample_weight is not None:
+            sample_weight_np = numpy.asarray(sample_weight)
+        else:
+            sample_weight_np = None
+        return float(numpy.average(sample_score_np, weights=sample_weight_np))
+
+    if not xp.isdtype(sample_score.dtype, "real floating"):
+        # We move to cpu device ahead of time since certain devices may not support
+        # float64, but we want the same precision for all devices and namespaces.
+        sample_score = xp.astype(xp.asarray(sample_score, device="cpu"), xp.float64)
+
+    if sample_weight is not None:
+        sample_weight = xp.asarray(
+            sample_weight, dtype=sample_score.dtype, device=device(sample_score)
+        )
+        if not xp.isdtype(sample_weight.dtype, "real floating"):
+            sample_weight = xp.astype(sample_weight, xp.float64)
+
+    if normalize:
+        if sample_weight is not None:
+            scale = xp.sum(sample_weight)
+        else:
+            scale = sample_score.shape[0]
+        if scale != 0:
+            sample_score = sample_score / scale
+
+    if sample_weight is not None:
+        return float(sample_score @ sample_weight)
+    else:
+        return float(xp.sum(sample_score))
+
+
+def _nanmin(X, axis=None):
+    # TODO: refactor once nan-aware reductions are standardized:
+    # https://github.com/data-apis/array-api/issues/621
+    xp, _ = get_namespace(X)
+    if _is_numpy_namespace(xp):
+        return xp.asarray(numpy.nanmin(X, axis=axis))
+
+    else:
+        mask = xp.isnan(X)
+        X = xp.min(xp.where(mask, xp.asarray(+xp.inf, device=device(X)), X), axis=axis)
+        # Replace Infs from all NaN slices with NaN again
+        mask = xp.all(mask, axis=axis)
+        if xp.any(mask):
+            X = xp.where(mask, xp.asarray(xp.nan), X)
+        return X
+
+
+def _nanmax(X, axis=None):
+    # TODO: refactor once nan-aware reductions are standardized:
+    # https://github.com/data-apis/array-api/issues/621
+    xp, _ = get_namespace(X)
+    if _is_numpy_namespace(xp):
+        return xp.asarray(numpy.nanmax(X, axis=axis))
+
+    else:
+        mask = xp.isnan(X)
+        X = xp.max(xp.where(mask, xp.asarray(-xp.inf, device=device(X)), X), axis=axis)
+        # Replace Infs from all NaN slices with NaN again
+        mask = xp.all(mask, axis=axis)
+        if xp.any(mask):
+            X = xp.where(mask, xp.asarray(xp.nan), X)
+        return X
+
+
+def _asarray_with_order(array, dtype=None, order=None, copy=None, *, xp=None):
+    """Helper to support the order kwarg only for NumPy-backed arrays
+
+    Memory layout parameter `order` is not exposed in the Array API standard,
+    however some input validation code in scikit-learn needs to work both
+    for classes and functions that will leverage Array API only operations
+    and for code that inherently relies on NumPy backed data containers with
+    specific memory layout constraints (e.g. our own Cython code). The
+    purpose of this helper is to make it possible to share code for data
+    container validation without memory copies for both downstream use cases:
+    the `order` parameter is only enforced if the input array implementation
+    is NumPy based, otherwise `order` is just silently ignored.
+    """
+    if xp is None:
+        xp, _ = get_namespace(array)
+    if _is_numpy_namespace(xp):
+        # Use NumPy API to support order
+        if copy is True:
+            array = numpy.array(array, order=order, dtype=dtype)
+        else:
+            array = numpy.asarray(array, order=order, dtype=dtype)
+
+        # At this point array is a NumPy ndarray. We convert it to an array
+        # container that is consistent with the input's namespace.
+        return xp.asarray(array)
+    else:
+        return xp.asarray(array, dtype=dtype, copy=copy)
+
+
+def _convert_to_numpy(array, xp):
+    """Convert X into a NumPy ndarray on the CPU."""
+    xp_name = xp.__name__
+
+    if xp_name in {"array_api_compat.torch", "torch"}:
+        return array.cpu().numpy()
+    elif xp_name == "cupy.array_api":
+        return array._array.get()
+    elif xp_name in {"array_api_compat.cupy", "cupy"}:  # pragma: nocover
+        return array.get()
+
+    return numpy.asarray(array)
+
+
+def _estimator_with_converted_arrays(estimator, converter):
+    """Create new estimator which converting all attributes that are arrays.
+
+    The converter is called on all NumPy arrays and arrays that support the
+    `DLPack interface <https://dmlc.github.io/dlpack/latest/>`__.
+
+    Parameters
+    ----------
+    estimator : Estimator
+        Estimator to convert
+
+    converter : callable
+        Callable that takes an array attribute and returns the converted array.
+
+    Returns
+    -------
+    new_estimator : Estimator
+        Convert estimator
+    """
+    from sklearn.base import clone
+
+    new_estimator = clone(estimator)
+    for key, attribute in vars(estimator).items():
+        if hasattr(attribute, "__dlpack__") or isinstance(attribute, numpy.ndarray):
+            attribute = converter(attribute)
+        setattr(new_estimator, key, attribute)
+    return new_estimator
+
+
+def _atol_for_type(dtype):
+    """Return the absolute tolerance for a given dtype."""
+    return numpy.finfo(dtype).eps * 100

venv/lib/python3.10/site-packages/sklearn/utils/_available_if.py

@@ -0,0 +1,93 @@
+from functools import update_wrapper, wraps
+from types import MethodType
+
+
+class _AvailableIfDescriptor:
+    """Implements a conditional property using the descriptor protocol.
+
+    Using this class to create a decorator will raise an ``AttributeError``
+    if check(self) returns a falsey value. Note that if check raises an error
+    this will also result in hasattr returning false.
+
+    See https://docs.python.org/3/howto/descriptor.html for an explanation of
+    descriptors.
+    """
+
+    def __init__(self, fn, check, attribute_name):
+        self.fn = fn
+        self.check = check
+        self.attribute_name = attribute_name
+
+        # update the docstring of the descriptor
+        update_wrapper(self, fn)
+
+    def _check(self, obj, owner):
+        attr_err_msg = (
+            f"This {repr(owner.__name__)} has no attribute {repr(self.attribute_name)}"
+        )
+        try:
+            check_result = self.check(obj)
+        except Exception as e:
+            raise AttributeError(attr_err_msg) from e
+
+        if not check_result:
+            raise AttributeError(attr_err_msg)
+
+    def __get__(self, obj, owner=None):
+        if obj is not None:
+            # delegate only on instances, not the classes.
+            # this is to allow access to the docstrings.
+            self._check(obj, owner=owner)
+            out = MethodType(self.fn, obj)
+
+        else:
+            # This makes it possible to use the decorated method as an unbound method,
+            # for instance when monkeypatching.
+            @wraps(self.fn)
+            def out(*args, **kwargs):
+                self._check(args[0], owner=owner)
+                return self.fn(*args, **kwargs)
+
+        return out
+
+
+def available_if(check):
+    """An attribute that is available only if check returns a truthy value.
+
+    Parameters
+    ----------
+    check : callable
+        When passed the object with the decorated method, this should return
+        a truthy value if the attribute is available, and either return False
+        or raise an AttributeError if not available.
+
+    Returns
+    -------
+    callable
+        Callable makes the decorated method available if `check` returns
+        a truthy value, otherwise the decorated method is unavailable.
+
+    Examples
+    --------
+    >>> from sklearn.utils.metaestimators import available_if
+    >>> class HelloIfEven:
+    ...    def __init__(self, x):
+    ...        self.x = x
+    ...
+    ...    def _x_is_even(self):
+    ...        return self.x % 2 == 0
+    ...
+    ...    @available_if(_x_is_even)
+    ...    def say_hello(self):
+    ...        print("Hello")
+    ...
+    >>> obj = HelloIfEven(1)
+    >>> hasattr(obj, "say_hello")
+    False
+    >>> obj.x = 2
+    >>> hasattr(obj, "say_hello")
+    True
+    >>> obj.say_hello()
+    Hello
+    """
+    return lambda fn: _AvailableIfDescriptor(fn, check, attribute_name=fn.__name__)