�
J�g� � �P � d Z ddlZddlmZ ddlmZ ddlZddlm Z m
Z
ddl m Z m
Z
mZ dd lmZmZmZmZmZ dd
lmZ dd lmZmZ d � Zd7d�Zd� Z d� Z d
d�d�Z ddd�d�Z eej dg e eddd�� � g e eddd�� � g e eddd�� � e
dh� � g e
h d�� � gd e
dh� � gdgdg e
d d h� � gd � d � � � d!dddd dd d"�d#�� � Z!d!ddd$dd%�d&�Z"dd'�d(�Z#d8d)�Z$d9d*�Z%d9d+�Z&d:d,�Z'd-� Z( d8d.�Z)d/� Z*d;d2�Z+d8d3�Z,d d4�d5�Z-d6� Z.dS )<zEUtilities to perform optimal mathematical operations in scikit-learn.� N)�partial)�Integral)�linalg�sparse� )�Interval�
StrOptions�validate_params� )�_average�_is_numpy_namespace�_nanmean�device�
get_namespace)�
csr_row_norms)� check_array�check_random_statec �� � t j | d�� � } t j | j t j � � rt j dt � � t j | | � � S )a` Squared Euclidean or Frobenius norm of x.
Faster than norm(x) ** 2.
Parameters
----------
x : array-like
The input array which could be either be a vector or a 2 dimensional array.
Returns
-------
float
The Euclidean norm when x is a vector, the Frobenius norm when x
is a matrix (2-d array).
�K)�orderzYArray type is integer, np.dot may overflow. Data should be float type to avoid this issue) �np�ravel�
issubdtype�dtype�integer�warnings�warn� UserWarning�dot��xs �e/home/asafur/pinokio/api/open-webui.git/app/env/lib/python3.11/site-packages/sklearn/utils/extmath.py� squared_normr# sa � � ���#� � � �A� �}�Q�W�b�j�)�)�
��
�@�
�
�
�
� �6�!�Q�<�<�� Fc �� � t j | � � r:| � � � } t | � � }|st j |� � }n�t
| � � \ }}t |� � r@t j | � � } t j d| | � � }|� |� � }n+|�
|� | | � � d�� � }|s|� |� � }|S )a� Row-wise (squared) Euclidean norm of X.
Equivalent to np.sqrt((X * X).sum(axis=1)), but also supports sparse
matrices and does not create an X.shape-sized temporary.
Performs no input validation.
Parameters
----------
X : array-like
The input array.
squared : bool, default=False
If True, return squared norms.
Returns
-------
array-like
The row-wise (squared) Euclidean norm of X.
zij,ij->ir ��axis) r �issparse�tocsrr r �sqrtr r
�asarray�einsum�sum�multiply)�X�squared�norms�xp�_s r" � row_normsr4 / s� � �( ��q��� #�
�G�G�I�I�� �a� � ��� #��G�E�N�N�E�� �a� � ���A� �r� "� "� 6��
�1�
�
�A��I�j�!�Q�/�/�E��J�J�u�%�%�E�E��F�F�2�;�;�q�!�,�,�1�F�5�5�E�� #��G�G�E�N�N�E� �Lr$ c � � t | � � \ }}|j � | � � \ }}|dk s|j S |S )a� Compute logarithm of determinant of a square matrix.
The (natural) logarithm of the determinant of a square matrix
is returned if det(A) is non-negative and well defined.
If the determinant is zero or negative returns -Inf.
Equivalent to : np.log(np.det(A)) but more robust.
Parameters
----------
A : array_like of shape (n, n)
The square matrix.
Returns
-------
logdet : float
When det(A) is strictly positive, log(det(A)) is returned.
When det(A) is non-positive or not defined, then -inf is returned.
See Also
--------
numpy.linalg.slogdet : Compute the sign and (natural) logarithm of the determinant
of an array.
Examples
--------
>>> import numpy as np
>>> from sklearn.utils.extmath import fast_logdet
>>> a = np.array([[5, 1], [2, 8]])
>>> fast_logdet(a)
np.float64(3.6375861597263857)
r )r r �slogdet�inf)�Ar2 r3 �sign�lds r" � fast_logdetr; U sF � �B
�!� � �E�B���y� � ��#�#�H�D�"� �!�8�8���w��
�Ir$ c �� � t | d� � r1t | j � � | j d | j d z z }n1| �dn,t | dk � � � � � | j z }|S )a� Compute density of a sparse vector.
Parameters
----------
w : {ndarray, sparse matrix}
The input data can be numpy ndarray or a sparse matrix.
Returns
-------
float
The density of w, between 0 and 1.
Examples
--------
>>> from scipy import sparse
>>> from sklearn.utils.extmath import density
>>> X = sparse.random(10, 10, density=0.25, random_state=0)
>>> density(X)
0.25
�toarrayr r )�hasattr�float�nnz�shaper- �size)�w�ds r" �densityrE } sh � �* �q�)� � � ?� �!�%�L�L�A�G�A�J����� 3� 4�����A�A��q�A�v�l�l�n�n� 5� 5��� >�� �Hr$ )� dense_outputc � � t | |� � \ }}| j dk s |j dk �rt j | � � rct j |d� � }|� |j d df� � }| |z } |j | j d g|j dd� �R � }n�t j |� � rN| � d| j d � � }||z } |j g | j dd� �|j d �R � }n/|j dk rdnd} |� | |d| g�� � }n| |z }t j | � � r:t j |� � r&|r$t |d� � r|�
� � S |S ) a% Dot product that handle the sparse matrix case correctly.
Parameters
----------
a : {ndarray, sparse matrix}
b : {ndarray, sparse matrix}
dense_output : bool, default=False
When False, ``a`` and ``b`` both being sparse will yield sparse output.
When True, output will always be a dense array.
Returns
-------
dot_product : {ndarray, sparse matrix}
Sparse if ``a`` and ``b`` are sparse and ``dense_output=False``.
Examples
--------
>>> from scipy.sparse import csr_matrix
>>> from sklearn.utils.extmath import safe_sparse_dot
>>> X = csr_matrix([[1, 2], [3, 4], [5, 6]])
>>> dot_product = safe_sparse_dot(X, X.T)
>>> dot_product.toarray()
array([[ 5, 11, 17],
[11, 25, 39],
[17, 39, 61]])
r ����������r r N)�axesr= ) r �ndimr r( r �rollaxis�reshaperA � tensordotr> r= )
�a�brF r2 r3 �b_�b_2d�ret�a_2d�b_axiss
r" �safe_sparse_dotrV � s� � �6
�!�Q� � �E�B���v��z�z�Q�V�a�Z�Z� �?�1� � � 8� ��Q��#�#�B��:�:�q�w�r�{�B� /�0�0�D��d�(�C� �#�+�a�g�a�j�8�2�8�A�B�B�<�8�8�8�C�C�
�_�Q�
�
� 8� �9�9�R�����-�-�D���(�C� �#�+�8�q�w�s��s�|�8�Q�W�Q�Z�8�8�8�C�C� �6�Q�;�;�R�R�B�F��,�,�q�!�2�v�,�,�7�7�C�C��!�e�� ����� � �O�A� � � �
� �
�C�� #� #� � �{�{�}�}� � �Jr$ �auto)�power_iteration_normalizer� random_statec �| � t | � � \ }}t |� � }|� |� | j d |f�� � � � }t | d� � r9|� | j d�� � r |� || j d�� � }|r$|� |t | � � �� � }|d k r%|d
k rd }n3|rt j d � � d
}nd}n|dk r|rt d� � �|r t |j j d�� � }n t t j dd�� � }|d
k r|} n&|dk r t t j dd�� � } nd� } t# |� � D ])}
| | |z � � \ }}
| | j |z � � \ }}
�* || |z � � \ }}
|S )a� Compute an orthonormal matrix whose range approximates the range of A.
Parameters
----------
A : 2D array
The input data matrix.
size : int
Size of the return array.
n_iter : int
Number of power iterations used to stabilize the result.
power_iteration_normalizer : {'auto', 'QR', 'LU', 'none'}, default='auto'
Whether the power iterations are normalized with step-by-step
QR factorization (the slowest but most accurate), 'none'
(the fastest but numerically unstable when `n_iter` is large, e.g.
typically 5 or larger), or 'LU' factorization (numerically stable
but can lose slightly in accuracy). The 'auto' mode applies no
normalization if `n_iter` <= 2 and switches to LU otherwise.
.. versionadded:: 0.18
random_state : int, RandomState instance or None, default=None
The seed of the pseudo random number generator to use when shuffling
the data, i.e. getting the random vectors to initialize the algorithm.
Pass an int for reproducible results across multiple function calls.
See :term:`Glossary <random_state>`.
Returns
-------
Q : ndarray
A (size x size) projection matrix, the range of which
approximates well the range of the input matrix A.
Notes
-----
Follows Algorithm 4.3 of
:arxiv:`"Finding structure with randomness:
Stochastic algorithms for constructing approximate matrix decompositions"
<0909.4061>`
Halko, et al. (2009)
An implementation of a randomized algorithm for principal component
analysis
A. Szlam et al. 2014
Examples
--------
>>> import numpy as np
>>> from sklearn.utils.extmath import randomized_range_finder
>>> A = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
>>> randomized_range_finder(A, size=2, n_iter=2, random_state=42)
array([[-0.21..., 0.88...],
[-0.52..., 0.24...],
[-0.82..., -0.38...]])
r )rB r z
real floating)�kindF��copy�r rW r �nonez�Array API does not support LU factorization, falling back to QR instead. Set `power_iteration_normalizer='QR'` explicitly to silence this warning.�QR�LUz[Array API does not support LU factorization. Set `power_iteration_normalizer='QR'` instead.�reduced)�mode�economic)rc � check_finiteT)� permute_lre c �
� | d fS �N� r s r" �<lambda>z)randomized_range_finder.<locals>.<lambda>J s
� ��4�y� r$ )r r r+ �normalrA r> �isdtyper �astyper r r �
ValueErrorr r �qr�lu�range�T) r8 rB �n_iterrX rY r2 �is_array_api_compliant�Q�
qr_normalizer�
normalizerr3 s r" �randomized_range_finderrx � s � �z "/�q�!1�!1� �B� �%�l�3�3�L�
�
�
�<�&�&�Q�W�Q�Z��,>�&�?�?�@�@�A��q�'��� .�r�z�z�!�'��z� H� H� .� �I�I�a���u�I� -� -�� � ,� �J�J�q�����J� +� +�� "�V�+�+� �Q�;�;�)/� &� &�
#� .� �M�!�
�
�
�
*.� &� &�)-� &� &� #�t� +� +�0F� +��
9�
�
�
�
� P� �� � �9�=�=�=�
�
� �� �
��O�O�O�
�!�T�)�)�"�
�
� #�t� +� +� �V�Y�$�U�K�K�K�
�
�(�(�
� �6�]�]� #� #���z�!�a�%� � ���1��z�!�#��'�"�"���1�1� �=��Q�� � �D�A�q� �Hr$ z
sparse matrix�left)�closed> ra r` rW r_ �booleanrY �gesdd�gesvd) �M� n_components�
n_oversamplesrs rX � transpose� flip_signrY �svd_lapack_driverT)� prefer_skip_nested_validation�
)r� rs rX r� r� rY r� c �b � t j | � � rM| j dv rDt j d� t | � � j � � t j � � t |� � }||z } | j \ }
} |dk r |dt | j � � z k rdnd}|dk r|
| k }|r| j } t | | |||�� � } | j | z }
t |
� � \ }}|r!|j � |
d� � � \ }}}nt j |
d|�
� � \ }}}~
| |z }|r+|st! ||� � \ }}nt! ||d� � � \ }}|r/|d |�d d �f j |d |� |d d �d |�f j fS |d d �d |�f |d |� |d |�d d �f fS )
ak Compute a truncated randomized SVD.
This method solves the fixed-rank approximation problem described in [1]_
(problem (1.5), p5).
Refer to
:ref:`sphx_glr_auto_examples_applications_wikipedia_principal_eigenvector.py`
for a typical example where the power iteration algorithm is used to rank web pages.
This algorithm is also known to be used as a building block in Google's PageRank
algorithm.
Parameters
----------
M : {ndarray, sparse matrix}
Matrix to decompose.
n_components : int
Number of singular values and vectors to extract.
n_oversamples : int, default=10
Additional number of random vectors to sample the range of `M` so as
to ensure proper conditioning. The total number of random vectors
used to find the range of `M` is `n_components + n_oversamples`. Smaller
number can improve speed but can negatively impact the quality of
approximation of singular vectors and singular values. Users might wish
to increase this parameter up to `2*k - n_components` where k is the
effective rank, for large matrices, noisy problems, matrices with
slowly decaying spectrums, or to increase precision accuracy. See [1]_
(pages 5, 23 and 26).
n_iter : int or 'auto', default='auto'
Number of power iterations. It can be used to deal with very noisy
problems. When 'auto', it is set to 4, unless `n_components` is small
(< .1 * min(X.shape)) in which case `n_iter` is set to 7.
This improves precision with few components. Note that in general
users should rather increase `n_oversamples` before increasing `n_iter`
as the principle of the randomized method is to avoid usage of these
more costly power iterations steps. When `n_components` is equal
or greater to the effective matrix rank and the spectrum does not
present a slow decay, `n_iter=0` or `1` should even work fine in theory
(see [1]_ page 9).
.. versionchanged:: 0.18
power_iteration_normalizer : {'auto', 'QR', 'LU', 'none'}, default='auto'
Whether the power iterations are normalized with step-by-step
QR factorization (the slowest but most accurate), 'none'
(the fastest but numerically unstable when `n_iter` is large, e.g.
typically 5 or larger), or 'LU' factorization (numerically stable
but can lose slightly in accuracy). The 'auto' mode applies no
normalization if `n_iter` <= 2 and switches to LU otherwise.
.. versionadded:: 0.18
transpose : bool or 'auto', default='auto'
Whether the algorithm should be applied to M.T instead of M. The
result should approximately be the same. The 'auto' mode will
trigger the transposition if M.shape[1] > M.shape[0] since this
implementation of randomized SVD tend to be a little faster in that
case.
.. versionchanged:: 0.18
flip_sign : bool, default=True
The output of a singular value decomposition is only unique up to a
permutation of the signs of the singular vectors. If `flip_sign` is
set to `True`, the sign ambiguity is resolved by making the largest
loadings for each component in the left singular vectors positive.
random_state : int, RandomState instance or None, default='warn'
The seed of the pseudo random number generator to use when
shuffling the data, i.e. getting the random vectors to initialize
the algorithm. Pass an int for reproducible results across multiple
function calls. See :term:`Glossary <random_state>`.
.. versionchanged:: 1.2
The default value changed from 0 to None.
svd_lapack_driver : {"gesdd", "gesvd"}, default="gesdd"
Whether to use the more efficient divide-and-conquer approach
(`"gesdd"`) or more general rectangular approach (`"gesvd"`) to compute
the SVD of the matrix B, which is the projection of M into a low
dimensional subspace, as described in [1]_.
.. versionadded:: 1.2
Returns
-------
u : ndarray of shape (n_samples, n_components)
Unitary matrix having left singular vectors with signs flipped as columns.
s : ndarray of shape (n_components,)
The singular values, sorted in non-increasing order.
vh : ndarray of shape (n_components, n_features)
Unitary matrix having right singular vectors with signs flipped as rows.
Notes
-----
This algorithm finds a (usually very good) approximate truncated
singular value decomposition using randomization to speed up the
computations. It is particularly fast on large matrices on which
you wish to extract only a small number of components. In order to
obtain further speed up, `n_iter` can be set <=2 (at the cost of
loss of precision). To increase the precision it is recommended to
increase `n_oversamples`, up to `2*k-n_components` where k is the
effective rank. Usually, `n_components` is chosen to be greater than k
so increasing `n_oversamples` up to `n_components` should be enough.
References
----------
.. [1] :arxiv:`"Finding structure with randomness:
Stochastic algorithms for constructing approximate matrix decompositions"
<0909.4061>`
Halko, et al. (2009)
.. [2] A randomized algorithm for the decomposition of matrices
Per-Gunnar Martinsson, Vladimir Rokhlin and Mark Tygert
.. [3] An implementation of a randomized algorithm for principal component
analysis A. Szlam et al. 2014
Examples
--------
>>> import numpy as np
>>> from sklearn.utils.extmath import randomized_svd
>>> a = np.array([[1, 2, 3, 5],
... [3, 4, 5, 6],
... [7, 8, 9, 10]])
>>> U, s, Vh = randomized_svd(a, n_components=2, random_state=0)
>>> U.shape, s.shape, Vh.shape
((3, 2), (2,), (2, 4))
)�lil�dokzCCalculating SVD of a {} is expensive. csr_matrix is more efficient.rW g�������?� � )rB rs rX rY F)�
full_matrices)r� �
lapack_driver)�u_based_decisionN)r r( �formatr r �type�__name__�SparseEfficiencyWarningr rA �minrr rx r r �svd�svd_flip)r~ r r� rs rX r� r� rY r� �n_random� n_samples�
n_featuresru �Br2 rt �Uhat�s�Vt�Us r" �randomized_svdr� Y s. � �z ��q���
�a�h�.� 8� 8��
�
,�,2�F�4��7�7�3C�,D�,D� � *�
�
�
� &�l�3�3�L��m�+�H� �G��I�z�
���� #�S�3�q�w�<�<�%7�7�7���Q���F��� �
�*� �� �
�C�� � �
��#=�!� � � �A�
��a��A� "/�q�!1�!1� �B� � �
��i�m�m�A�U�m�;�;� ��a���
�j�
�U�2C�
�
�
� ��a��
� �D��A�� <�� <� �Q��O�O�E�A�r�r� �Q��U�;�;�;�E�A�r�� K��-�<�-����"�#�%�q� �,� �'7��1�1�1�m�|�m�;K�9L�9N�N�N�����M�\�M�!�"�A�m�|�m�$4�b� �,� ����9I�6J�J�Jr$ �module)r� rs rX � selectionrY c �V � |dk rt � � �|dk rzt | ||||d|�� � \ }}} |dd�d|�f }
|d|� } t j d| d|�dd�f |dd�d|�f � � } t j | � � }
| |
z } nt d|z � � �| |
fS )a� Computes a truncated eigendecomposition using randomized methods
This method solves the fixed-rank approximation problem described in the
Halko et al paper.
The choice of which components to select can be tuned with the `selection`
parameter.
.. versionadded:: 0.24
Parameters
----------
M : ndarray or sparse matrix
Matrix to decompose, it should be real symmetric square or complex
hermitian
n_components : int
Number of eigenvalues and vectors to extract.
n_oversamples : int, default=10
Additional number of random vectors to sample the range of M so as
to ensure proper conditioning. The total number of random vectors
used to find the range of M is n_components + n_oversamples. Smaller
number can improve speed but can negatively impact the quality of
approximation of eigenvectors and eigenvalues. Users might wish
to increase this parameter up to `2*k - n_components` where k is the
effective rank, for large matrices, noisy problems, matrices with
slowly decaying spectrums, or to increase precision accuracy. See Halko
et al (pages 5, 23 and 26).
n_iter : int or 'auto', default='auto'
Number of power iterations. It can be used to deal with very noisy
problems. When 'auto', it is set to 4, unless `n_components` is small
(< .1 * min(X.shape)) in which case `n_iter` is set to 7.
This improves precision with few components. Note that in general
users should rather increase `n_oversamples` before increasing `n_iter`
as the principle of the randomized method is to avoid usage of these
more costly power iterations steps. When `n_components` is equal
or greater to the effective matrix rank and the spectrum does not
present a slow decay, `n_iter=0` or `1` should even work fine in theory
(see Halko et al paper, page 9).
power_iteration_normalizer : {'auto', 'QR', 'LU', 'none'}, default='auto'
Whether the power iterations are normalized with step-by-step
QR factorization (the slowest but most accurate), 'none'
(the fastest but numerically unstable when `n_iter` is large, e.g.
typically 5 or larger), or 'LU' factorization (numerically stable
but can lose slightly in accuracy). The 'auto' mode applies no
normalization if `n_iter` <= 2 and switches to LU otherwise.
selection : {'value', 'module'}, default='module'
Strategy used to select the n components. When `selection` is `'value'`
(not yet implemented, will become the default when implemented), the
components corresponding to the n largest eigenvalues are returned.
When `selection` is `'module'`, the components corresponding to the n
eigenvalues with largest modules are returned.
random_state : int, RandomState instance, default=None
The seed of the pseudo random number generator to use when shuffling
the data, i.e. getting the random vectors to initialize the algorithm.
Pass an int for reproducible results across multiple function calls.
See :term:`Glossary <random_state>`.
Notes
-----
This algorithm finds a (usually very good) approximate truncated
eigendecomposition using randomized methods to speed up the computations.
This method is particularly fast on large matrices on which
you wish to extract only a small number of components. In order to
obtain further speed up, `n_iter` can be set <=2 (at the cost of
loss of precision). To increase the precision it is recommended to
increase `n_oversamples`, up to `2*k-n_components` where k is the
effective rank. Usually, `n_components` is chosen to be greater than k
so increasing `n_oversamples` up to `n_components` should be enough.
Strategy 'value': not implemented yet.
Algorithms 5.3, 5.4 and 5.5 in the Halko et al paper should provide good
candidates for a future implementation.
Strategy 'module':
The principle is that for diagonalizable matrices, the singular values and
eigenvalues are related: if t is an eigenvalue of A, then :math:`|t|` is a
singular value of A. This method relies on a randomized SVD to find the n
singular components corresponding to the n singular values with largest
modules, and then uses the signs of the singular vectors to find the true
sign of t: if the sign of left and right singular vectors are different
then the corresponding eigenvalue is negative.
Returns
-------
eigvals : 1D array of shape (n_components,) containing the `n_components`
eigenvalues selected (see ``selection`` parameter).
eigvecs : 2D array of shape (M.shape[0], n_components) containing the
`n_components` eigenvectors corresponding to the `eigvals`, in the
corresponding order. Note that this follows the `scipy.linalg.eigh`
convention.
See Also
--------
:func:`randomized_svd`
References
----------
* :arxiv:`"Finding structure with randomness:
Stochastic algorithms for constructing approximate matrix decompositions"
(Algorithm 4.3 for strategy 'module') <0909.4061>`
Halko, et al. (2009)
�valuer� F)r r� rs rX r� rY Nzji,ij->jzInvalid `selection`: %r)�NotImplementedErrorr� r r, r9 rn )r~ r r� rs rX r� rY r� �Sr� �eigvecs�eigvals�diag_VtU�signss r" �_randomized_eigshr� 4 s� � �n �G���!�#�#�#� �h� � � "�
�%�'��'A��%�
�
�
���1�b� �A�A�A�}� �}�$�%���M�\�M�"�� �9�Z��M�\�M�1�1�1�,<�)=�q����M�\�M�AQ�?R�S�S�����!�!���E�/��� �2�Y�>�?�?�?� �G� �r$ r& c �� � |�+t j | � � } t j |� � }d}n(t j | � � } t j |� � }| j |j k r!t j | j ||j �� � }t j t j | � � � � }t | j � � }d||< t j |� � }t j |� � }|D ]�}t j | j � � }| |k } || || < t j t j
||� � |� � }
t j |
|k ||� � } t j |
|� � }| }��| |fS )a� Return an array of the weighted modal (most common) value in the passed array.
If there is more than one such value, only the first is returned.
The bin-count for the modal bins is also returned.
This is an extension of the algorithm in scipy.stats.mode.
Parameters
----------
a : array-like of shape (n_samples,)
Array of which values to find mode(s).
w : array-like of shape (n_samples,)
Array of weights for each value.
axis : int, default=0
Axis along which to operate. Default is 0, i.e. the first axis.
Returns
-------
vals : ndarray
Array of modal values.
score : ndarray
Array of weighted counts for each mode.
See Also
--------
scipy.stats.mode: Calculates the Modal (most common) value of array elements
along specified axis.
Examples
--------
>>> from sklearn.utils.extmath import weighted_mode
>>> x = [4, 1, 4, 2, 4, 2]
>>> weights = [1, 1, 1, 1, 1, 1]
>>> weighted_mode(x, weights)
(array([4.]), array([3.]))
The value 4 appears three times: with uniform weights, the result is
simply the mode of the distribution.
>>> weights = [1, 3, 0.5, 1.5, 1, 2] # deweight the 4's
>>> weighted_mode(x, weights)
(array([2.]), array([3.5]))
The value 2 has the highest score: it appears twice with weights of
1.5 and 2: the sum of these is 3.5.
Nr �r r )
r r r+ rA �fullr �unique�list�zeros� expand_dimsr- �where�maximum) rO rC r' �scores� testshape� oldmostfreq� oldcounts�score�template�ind�counts� mostfrequents r" �
weighted_moder� � sG � �^ �|� �H�Q�K�K�� �H�Q�K�K����� �J�q�M�M�� �J�q�M�M���w�!�'��� �G�A�G�Q�a�g� .� .� .��
�Y�r�x��{�{�
#�
#�F��Q�W�
�
�I��I�d�O��(�9�%�%�K����#�#�I�� #� #���8�A�G�$�$���5�j���#����
�� ���x�� 6� 6��=�=���x��� 2�E�;�G�G� ��J�v�y�1�1� �"� � � �� "�"r$ c �b � d� | D � � } d� | D � � }t j |� � }|� t | � � d� � j }|�$t j | � }t j ||�� � }t | � � D ]$\ }}| | |dd�|f |dd�|f< �%|S )a� Generate a cartesian product of input arrays.
Parameters
----------
arrays : list of array-like
1-D arrays to form the cartesian product of.
out : ndarray of shape (M, len(arrays)), default=None
Array to place the cartesian product in.
Returns
-------
out : ndarray of shape (M, len(arrays))
Array containing the cartesian products formed of input arrays.
If not provided, the `dtype` of the output array is set to the most
permissive `dtype` of the input arrays, according to NumPy type
promotion.
.. versionadded:: 1.2
Add support for arrays of different types.
Notes
-----
This function may not be used on more than 32 arrays
because the underlying numpy functions do not support it.
Examples
--------
>>> from sklearn.utils.extmath import cartesian
>>> cartesian(([1, 2, 3], [4, 5], [6, 7]))
array([[1, 4, 6],
[1, 4, 7],
[1, 5, 6],
[1, 5, 7],
[2, 4, 6],
[2, 4, 7],
[2, 5, 6],
[2, 5, 7],
[3, 4, 6],
[3, 4, 7],
[3, 5, 6],
[3, 5, 7]])
c �6 � g | ]}t j |� � ��S ri )r r+ ��.0r! s r" �
<listcomp>z cartesian.<locals>.<listcomp>D s � �
,�
,�
,��b�j��m�m�
,�
,�
,r$ c 3 �4 K � | ]}t |� � V � �d S rh )�lenr� s r" � <genexpr>z cartesian.<locals>.<genexpr>E s( � � � � $� $��S��V�V� $� $� $� $� $� $r$ rI Nr� )r �indicesrM r� rr � result_type�
empty_like� enumerate)�arrays�outrA �ixr �n�arrs r" � cartesianr� s� � �V -�
,�V�
,�
,�
,�F� $� $�V� $� $� $�E� ��E� � �B� ���C��K�K�� $� $� &�B�
�{����'���m�B�e�,�,�,���F�#�#� (� (���3��1�I�b����A��h�'��A�A�A�q�D� � � �Jr$ c �� � t d� | |fD � � � \ }}|r�|� |� | j � � d�� � }|� | j j d t
| � � �� � }||| j j d z z }|� |� |� | j d� � |d�� � � � }| |t j dd�f z } |�||dd�t j f z }n�|� |� |� � d�� � } |� |j d t
|� � �� � }| ||j d z z }|� |� |� |d� � |d�� � � � }| �| |t j dd�f z } ||dd�t j f z }| |fS )a� Sign correction to ensure deterministic output from SVD.
Adjusts the columns of u and the rows of v such that the loadings in the
columns in u that are largest in absolute value are always positive.
If u_based_decision is False, then the same sign correction is applied to
so that the rows in v that are largest in absolute value are always
positive.
Parameters
----------
u : ndarray
Parameters u and v are the output of `linalg.svd` or
:func:`~sklearn.utils.extmath.randomized_svd`, with matching inner
dimensions so one can compute `np.dot(u * s, v)`.
u can be None if `u_based_decision` is False.
v : ndarray
Parameters u and v are the output of `linalg.svd` or
:func:`~sklearn.utils.extmath.randomized_svd`, with matching inner
dimensions so one can compute `np.dot(u * s, v)`. The input v should
really be called vt to be consistent with scipy's output.
v can be None if `u_based_decision` is True.
u_based_decision : bool, default=True
If True, use the columns of u as the basis for sign flipping.
Otherwise, use the rows of v. The choice of which variable to base the
decision on is generally algorithm dependent.
Returns
-------
u_adjusted : ndarray
Array u with adjusted columns and the same dimensions as u.
v_adjusted : ndarray
Array v with adjusted rows and the same dimensions as v.
c � � g | ]}|�|��S rh ri )r� rO s r" r� z svd_flip.<locals>.<listcomp>z s � �?�?�?�!�� �A� � � r$ r r& r r^ )rI N) r �argmax�absrr �arangerA r r9 �takerM r �newaxis)
�u�vr� r2 r3 �max_abs_u_cols�shiftr� r� �max_abs_v_rowss
r" r� r� T s� � �L
�?�?��1�v�?�?�?� @�E�B��� "����2�6�6�!�#�;�;�Q��7�7��� � �!�#�)�A�,�v�a�y�y� �9�9�� �5�1�3�9�Q�<�#7�7���������
�
�1�3�� 6� 6��a��H�H�I�I�� �U�2�:�q�q�q�=�
!�!�� �=�
��q�q�q�"�*�}�%� %�A�� ���2�6�6�!�9�9�1��5�5��� � �!�'�!�*�V�A�Y�Y� �7�7�� �5�1�7�1�:�#5�5���������
�
�1�e� 4� 4�g�A��F�F�G�G�� �=�
��r�z�1�1�1�}�%� %�A� �U�1�1�1�b�j�=�
!�!�� �a�4�Kr$ c � � t | � � \ }}|r|� | d�� � } |� |� | d�� � d� � }| |z } t |� � r)t j | t j | � � �� � n|� | � � } |� |� | d�� � d� � }| |z } | S )a@
Calculate the softmax function.
The softmax function is calculated by
np.exp(X) / np.sum(np.exp(X), axis=1)
This will cause overflow when large values are exponentiated.
Hence the largest value in each row is subtracted from each data
point to prevent this.
Parameters
----------
X : array-like of float of shape (M, N)
Argument to the logistic function.
copy : bool, default=True
Copy X or not.
Returns
-------
out : ndarray of shape (M, N)
Softmax function evaluated at every point in x.
Tr\ r r& )rI r )r� )r r+ rM �maxr
r �expr- )r/ r] r2 rt �max_prob�sum_probs r" �softmaxr� � s� � �0 "/�q�!1�!1� �B� � � %� �J�J�q�t�J� $� $���z�z�"�&�&���&�+�+�W�5�5�H���M�A��2� � � �
��q�b�j��m�m�$�$�$�$�$�
�F�F�1�I�I���z�z�"�&�&���&�+�+�W�5�5�H���M�A� �Hr$ c � � | � � � }||k r+t j | � � rt d� � �| ||z
z } | S )aE Ensure `X.min()` >= `min_value`.
Parameters
----------
X : array-like
The matrix to make non-negative.
min_value : float, default=0
The threshold value.
Returns
-------
array-like
The thresholded array.
Raises
------
ValueError
When X is sparse.
z{Cannot make the data matrix nonnegative because it is sparse. Adding a value to every entry would make it no longer sparse.)r� r r( rn )r/ � min_value�min_s r" �make_nonnegativer� � s[ � �(
�5�5�7�7�D� �i��� �?�1� � � � �-�� �
�
��T�!� "�� �Hr$ c � � t j |j t j � � r+|j j dk r | |g|�R i |�dt j i��}n | |g|�R i |��}|S )a�
This function provides numpy accumulator functions with a float64 dtype
when used on a floating point input. This prevents accumulator overflow on
smaller floating point dtypes.
Parameters
----------
op : function
A numpy accumulator function such as np.mean or np.sum.
x : ndarray
A numpy array to apply the accumulator function.
*args : positional arguments
Positional arguments passed to the accumulator function after the
input x.
**kwargs : keyword arguments
Keyword arguments passed to the accumulator function.
Returns
-------
result
The output of the accumulator function passed to this function.
� r )r r r �floating�itemsize�float64)�opr! �args�kwargs�results r" �_safe_accumulator_opr� � s} � �.
�}�Q�W�b�k�*�*� (�q�w�/?�!�/C�/C���A�9��9�9�9��9�9�b�j�9�9�9�����A�'��'�'�'��'�'�� �Mr$ c �� � ||z }t j | � � }t j |� � r
t j }n t j }|�Zt t j |t j |d| � � � � }t t j |dd�df | z d�� � } n8t || d�� � }| j d }
|
t j |d�� � z
} || z } ||z | z } |�d}
�n || z }| |z
}|�dt t j |t j |d|� � � � }|dz }t t j |t j |d|� � � � }n)t ||d�� � }|dz }t ||d�� � }||dz | z z }||z }t j dd�� � 5 || z }||z || z ||z |z
dz z z }ddd� � n # 1 swxY w Y |dk }|| ||< || z }
| |
| fS )a� Calculate mean update and a Youngs and Cramer variance update.
If sample_weight is given, the weighted mean and variance is computed.
Update a given mean and (possibly) variance according to new data given
in X. last_mean is always required to compute the new mean.
If last_variance is None, no variance is computed and None return for
updated_variance.
From the paper "Algorithms for computing the sample variance: analysis and
recommendations", by Chan, Golub, and LeVeque.
Parameters
----------
X : array-like of shape (n_samples, n_features)
Data to use for variance update.
last_mean : array-like of shape (n_features,)
last_variance : array-like of shape (n_features,)
last_sample_count : array-like of shape (n_features,)
The number of samples encountered until now if sample_weight is None.
If sample_weight is not None, this is the sum of sample_weight
encountered.
sample_weight : array-like of shape (n_samples,) or None
Sample weights. If None, compute the unweighted mean/variance.
Returns
-------
updated_mean : ndarray of shape (n_features,)
updated_variance : ndarray of shape (n_features,)
None if last_variance was None.
updated_sample_count : ndarray of shape (n_features,)
Notes
-----
NaNs are ignored during the algorithm.
References
----------
T. Chan, G. Golub, R. LeVeque. Algorithms for computing the sample
variance: recommendations, The American Statistician, Vol. 37, No. 3,
pp. 242-247
Also, see the sparse implementation of this in
`utils.sparsefuncs.incr_mean_variance_axis` and
`utils.sparsefuncs_fast.incr_mean_variance_axis0`
Nr r& r �ignore)�divide�invalid)
r �isnan�any�nansumr- r� �matmulr� rA �errstate)r/ � last_mean�
last_variance�last_sample_count�
sample_weight�last_sum�
X_nan_mask�sum_op�new_sum�new_sample_countr� �updated_sample_count� updated_mean�updated_variancerr �temp�
correction�new_unnormalized_variance�last_unnormalized_variance�last_over_new_count� updated_unnormalized_variancer� s r" �_incremental_mean_and_varr � s� � �t �,�,�H���!���J� �v�j��� ��������� � '� �I�}�b�h�z�1�a�&@�&@�
�
�� 0� �F�M�!�!�!�T�'�*�z�k�:��
�
�
��� '�v�q�q�9�9�9���G�A�J� �$�r�v�j�q�'A�'A�'A�A��,�/?�?�� �w�&�*>�>�L�� � ��� �&� &���1�u�� � $� .�� �=�"�(�:�q�$�*G�*G�� �J�
�Q�J�D�(<�� �=�"�(�:�q�$�*G�*G�)� )� %� %� .�f�d��C�C�C�J� �Q�J�D�(<�V�T�PQ�(R�(R�(R� %�
"�Z��]�5E�%E�E�!�%2�5F�%F�"�
�[��(�
;�
;�
;� � �"3�6F�"F� �*�+�,�%�&�'�� 1�1�G�;��A�B�B�
*� � � � � � � � � � � ���� � � � � "�Q�&��/H��/O�%�e�,�8�;O�O�� �)�+?� ?�?s �- G�G� Gc �� � t j t j | � � d�� � }t j | t | j d � � |f � � }| |dd�t j f z } | S )a� Modify the sign of vectors for reproducibility.
Flips the sign of elements of all the vectors (rows of u) such that
the absolute maximum element of each vector is positive.
Parameters
----------
u : ndarray
Array with vectors as its rows.
Returns
-------
u_flipped : ndarray with same shape as u
Array with the sign flipped vectors as its rows.
r r& r N)r r� r� r9 rq rA r� )r� � max_abs_rowsr� s r" � _deterministic_vector_sign_flipr { se � � �9�R�V�A�Y�Y�Q�/�/�/�L� �G�A�e�A�G�A�J�'�'� �5�6� 7� 7�E���q�q�q�"�*�}� � �A� �Hr$ ��h㈵��>�:�0�yE>c � � t j | |t j �� � }t j | |t j �� � }t j |� d|�� � |||d�� � st
j dt � � |S )a� Use high precision for cumsum and check that final value matches sum.
Warns if the final cumulative sum does not match the sum (up to the chosen
tolerance).
Parameters
----------
arr : array-like
To be cumulatively summed as flat.
axis : int, default=None
Axis along which the cumulative sum is computed.
The default (None) is to compute the cumsum over the flattened array.
rtol : float, default=1e-05
Relative tolerance, see ``np.allclose``.
atol : float, default=1e-08
Absolute tolerance, see ``np.allclose``.
Returns
-------
out : ndarray
Array with the cumulative sums along the chosen axis.
)r' r rI r& T)�rtol�atol� equal_nanzLcumsum was found to be unstable: its last element does not correspond to sum) r �cumsumr� r- �allcloser� r r �RuntimeWarning)r� r' r r r� �expecteds r" �
stable_cumsumr � s� � �.
�)�C�d�"�*�
5�
5�
5�C��v�c��B�J�7�7�7�H�
�;� ����$�� � ���4�4� � � �
� �
�>�
�
�
�
� �Jr$ c � � t | � � \ }}| j d dk r|j S |� | � � }|� |� � r|j S |�t | |�� � S |� |� � }| | || }} t | |�� � S # t $ r t | � � cY S w xY w)a5 Compute the weighted average, ignoring NaNs.
Parameters
----------
a : ndarray
Array containing data to be averaged.
weights : array-like, default=None
An array of weights associated with the values in a. Each value in a
contributes to the average according to its associated weight. The
weights array can either be 1-D of the same shape as a. If `weights=None`,
then all data in a are assumed to have a weight equal to one.
Returns
-------
weighted_average : float
The weighted average.
Notes
-----
This wrapper to combine :func:`numpy.average` and :func:`numpy.nanmean`, so
that :func:`np.nan` values are ignored from the average and weights can
be passed. Note that when possible, we delegate to the prime methods.
r N)r2 )�weights) r rA �nanr� �allr r+ r �ZeroDivisionError)rO r r2 r3 �masks r" � _nanaverager � s� � �0
�!� � �E�B���w�q�z�Q����v�
�
�8�8�A�;�;�D� �v�v�d�|�|� ��v�
�����b�!�!�!�!��j�j��!�!�G��D�5��7�D�5�>�w�A����7�+�+�+�+�� � � � ���{�{�������s �B( �(C�Cr\ c � � t | g d�d�� � } t j | � � r'|r| � � � } | xj dz c_ n
|r| dz } n| dz } | S )a 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])
)�csr�csc�cooF)�
accept_sparse� ensure_2dr )r r r( r] �data)r/ r] s r" �safe_sqrr& � sx � �, �A�%:�%:�%:�e�L�L�L�A�
��q��� � � ������A� ���1� ���� � ��1��A�A�
�!�G�A� �Hr$ c �N � t |� � }| | � � � z |z }t j |� � }t ||� � � z
� � }|dk r�||z
}t j t j |� � � � ddd� }|D ]n}t j ||k � � \ } t t | � � |� � }
|�
| |
d�� � } || xx dz
cc< ||
z }|dk r n�o|� t � � S )a 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.extmath 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])
r NrI F)rB �replacer ) r r- r �floor�int�sortr� r� r� r� �choicerm ) � class_counts�n_draws�rng�
continuous�floored� need_to_add� remainder�valuesr� �inds�add_nows r" �_approximate_moder7 s- � �P �S�
!�
!�C� � � 0� 0� 2� 2�2�W�<�J��h�z�"�"�G� �g�� � �
�
�-�.�.�K��Q��� ��(� �����9�-�-�.�.�t�t��t�4�� � � �E��h�y�E� 1�2�2�G�T�
�#�d�)�)�[�1�1�G��:�:�d��%�:�@�@�D� �D�M�M�M�Q� �M�M�M� �7� "�K��a� � ��� � �>�>�#� � � r$ )Frh )T)r )Nr
r )/�__doc__r � functoolsr �numbersr �numpyr �scipyr r �utils._param_validationr r r
�
_array_apir r
r r r �sparsefuncs_fastr �
validationr r r# r4 r; rE rV rx �ndarrayr� r� r� r� r� r� r� r� r r r r r& r7 ri r$ r" �<module>rB s� �� K� K�
���� � � � � � � � � � � � � � � � � � � � � � � � � K� K� K� K� K� K� K� K� K� K� V� V� V� V� V� V� V� V� V� V� V� V� V� V� +� +� +� +� +� +� 7� 7� 7� 7� 7� 7� 7� 7�� � �8#� #� #� #�L%� %� %�P
�
�
�8 +0� ;� ;� ;� ;� ;�~ 4:��
�
�
�
�
�D � ��j�/�
*�!��(�A�t�F�C�C�C�D�"�(�8�Q��V�D�D�D�E��8�H�a��f�=�=�=�z�z�6�(�?S�?S�T�'1�z�2N�2N�2N�'O�'O�&P� ���V�H�!5�!5�6� �[�'�(� (�j�'�7�);� <� <� =�
�
� #'�
�
�
�$ � � %���� �JK� JK� JK� JK�
�
� JK�b � � %���X � X � X � X � X �v !"� G#� G#� G#� G#� G#�T8� 8� 8� 8�v:� :� :� :�z'
� '
� '
� '
�T
�
�
�
�H� � �> CG�{@� {@� {@� {@�|
�
�
�,#� #� #� #�L)� )� )� )�X �
�
�
�
�
�FB � B � B � B � B r$