� B�gR��dZddlZddlZddlZddlZddlZddlZddlmZddl Z ddlmZddl mZmZddlmZddlmZmZdd lmZmZdd lmZddlmZddlmZmZmZm Z m!Z!m"Z"dd l#m$Z$ddl%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-dd�d�Z.dd�d�Z/Gd�dee��Z0Gd�d��Z1Gd�d��Z2Gd�d��Z3Gd�d��Z4Gd�de��Z5Gd�d ��Z6Gd!�d"��Z7Gd#�d$��Z8Gd%�d&��Z9Gd'�d(��Z:Gd)�d*��Z;Gd+�d,��Z<d-�Z=d.�Z>d/�Z?d0�Z@d1�ZAdS)2z>Base classes for all estimators and various utility functions.�N)�defaultdict�)�__version__)�config_context� get_config)�InconsistentVersionWarning)�_HTMLDocumentationLinkMixin�estimator_html_repr)�_MetadataRequester�_routing_enabled)�validate_parameter_constraints)�_SetOutputMixin)�ClassifierTags� RegressorTags�Tags� TargetTags�TransformerTags�get_tags)� _IS_32BIT)�_check_feature_names�_check_feature_names_in�_check_n_features�_generate_get_feature_names_out� _is_fitted�check_array�check_is_fitted� validate_dataT��safec��t|d��r(tj|��s|��St ||��S)a�Construct a new unfitted estimator with the same parameters. Clone does a deep copy of the model in an estimator without actually copying attached data. It returns a new estimator with the same parameters that has not been fitted on any data. .. versionchanged:: 1.3 Delegates to `estimator.__sklearn_clone__` if the method exists. Parameters ---------- estimator : {list, tuple, set} of estimator instance or a single estimator instance The estimator or group of estimators to be cloned. safe : bool, default=True If safe is False, clone will fall back to a deep copy on objects that are not estimators. Ignored if `estimator.__sklearn_clone__` exists. Returns ------- estimator : object The deep copy of the input, an estimator if input is an estimator. Notes ----- If the estimator's `random_state` parameter is an integer (or if the estimator doesn't have a `random_state` parameter), an *exact clone* is returned: the clone and the original estimator will give the exact same results. Otherwise, *statistical clone* is returned: the clone might return different results from the original estimator. More details can be found in :ref:`randomness`. Examples -------- >>> from sklearn.base import clone >>> from sklearn.linear_model import LogisticRegression >>> X = [[-1, 0], [0, 1], [0, -1], [1, 0]] >>> y = [0, 0, 1, 1] >>> classifier = LogisticRegression().fit(X, y) >>> cloned_classifier = clone(classifier) >>> hasattr(classifier, "classes_") True >>> hasattr(cloned_classifier, "classes_") False >>> classifier is cloned_classifier False �__sklearn_clone__r)�hasattr�inspect�isclassr!�_clone_parametrized)� estimatorrs �\/home/asafur/pinokio/api/open-webui.git/app/env/lib/python3.11/site-packages/sklearn/base.py�cloner(,sN��b�y�-�.�.�-�w��y�7Q�7Q�-��*�*�,�,�,��y�t�4�4�4�4�c��t|��}|tur �fd�|��D��S|ttt tfvr|�fd�|D��St|d��rt|t��rj�stj |��St|t��rtd��tdt|��dt|��d��|j }|�d� ��}|��D]\}}t|d� ��||<�|di|��} tj |j��|_n#t"$rYnwxYw|�d� ��}|D]+}||} ||} | | urt%d|�d|��,t|d ��rtj |j��|_|S)zLDefault implementation of clone. See :func:`sklearn.base.clone` for details.c�:��i|]\}}|t|��S�r�r()�.0�k�vrs �r'� <dictcomp>z'_clone_parametrized.<locals>.<dictcomp>gs,��E�E�E�4�1�a��5��&�&�&�E�E�Er)c�2��g|]}t|��Sr,r-)r.�ers �r'� <listcomp>z'_clone_parametrized.<locals>.<listcomp>is&��F�F�F�q�u�Q�T�2�2�2�F�F�Fr)� get_paramszaCannot clone object. You should provide an instance of scikit-learn estimator instead of a class.zCannot clone object 'z' (type zb): it does not seem to be a scikit-learn estimator as it does not implement a 'get_params' method.F��deeprzCannot clone object z?, as the constructor either does not set or modifies parameter �_sklearn_output_config�)�type�dict�items�list�tuple�set� frozensetr"� isinstance�copy�deepcopy� TypeError�repr� __class__r5r(�_metadata_request�AttributeError�RuntimeErrorr8)r&r�estimator_type�klass�new_object_params�name�param� new_object� params_set�param1�param2s ` r'r%r%bsk��)�_�_�N��E�E�E�E�9�?�?�3D�3D�E�E�E�E� �D�%��i�8� 8� 8��~�F�F�F�F�I�F�F�F�G�G�G� �Y�� -� -��I�t�1L�1L�� =��+�+�+��)�T�*�*� ��C�� i�/3�9�o�o�o�o�t�I��P�� E�!�,�,�%�,�8�8��(�.�.�0�0�;�;��e�"'��E�":�":�":��$��+�+�*�+�+�J� �'+�}�Y�5P�'Q�'Q� �$�$�� &�&�E�&�2�2�J�"��"�4�(��D�!��,�BK�)�)�T�T�S�� y�2�3�3� �,0�M��,�- �- � �)��s�E/�/ E<�;E<c��eZdZdZed��Zdd�Zd�Zd�Zdd�Z �fd �Z �fd �Zd�Zd�Z d �Zd�Zed��Zd�Zd�Zd�Zd�Zd�Z�xZS)� BaseEstimatoraqBase class for all estimators in scikit-learn. Inheriting from this class provides default implementations of: - setting and getting parameters used by `GridSearchCV` and friends; - textual and HTML representation displayed in terminals and IDEs; - estimator serialization; - parameters validation; - data validation; - feature names validation. Read more in the :ref:`User Guide <rolling_your_own_estimator>`. Notes ----- All estimators should specify all the parameters that can be set at the class level in their ``__init__`` as explicit keyword arguments (no ``*args`` or ``**kwargs``). Examples -------- >>> import numpy as np >>> from sklearn.base import BaseEstimator >>> class MyEstimator(BaseEstimator): ... def __init__(self, *, param=1): ... self.param = param ... def fit(self, X, y=None): ... self.is_fitted_ = True ... return self ... def predict(self, X): ... return np.full(shape=X.shape[0], fill_value=self.param) >>> estimator = MyEstimator(param=2) >>> estimator.get_params() {'param': 2} >>> X = np.array([[1, 2], [2, 3], [3, 4]]) >>> y = np.array([1, 0, 1]) >>> estimator.fit(X, y).predict(X) array([2, 2, 2]) >>> estimator.set_params(param=3).fit(X, y).predict(X) array([3, 3, 3]) c�N�t|jd|j��}|tjurgStj|��}d�|j��D��}|D](}|j|jkrtd|�d|�d��)td�|D��S)z%Get parameter names for the estimator�deprecated_originalc�H�g|]}|jdk� |j|jk�|�� S��self)rM�kind�VAR_KEYWORD�r.�ps r'r4z2BaseEstimator._get_param_names.<locals>.<listcomp>�s=�� v��A�F�a�m�$;�$;� �$;�$;�$;r)zpscikit-learn estimators should always specify their parameters in the signature of their __init__ (no varargs). z with constructor z! doesn't follow this convention.c��g|] }|j�� Sr9)rMr\s r'r4z2BaseEstimator._get_param_names.<locals>.<listcomp>�s��2�2�2�!�q�v�2�2�2r))�getattr�__init__�objectr#� signature� parameters�valuesrZ�VAR_POSITIONALrI�sorted)�cls�init�init_signaturercr]s r'�_get_param_nameszBaseEstimator._get_param_names�s�� s�|�%:�C�L�I�I��6�?�"�"��I�!�*�4�0�0�� #�.�5�5�7�7� � � � � � � �A��v��)�)�)�"�l� 36�#�#�~�~�~� G��*��2�2�z�2�2�2�3�3�3r)Tc�X��t��}|��D]��t|��}|rlt|d��r\t |t ��sG|��}|��fd�|D��||�<��|S)ae Get parameters for this estimator. Parameters ---------- deep : bool, default=True If True, will return the parameters for this estimator and contained subobjects that are estimators. Returns ------- params : dict Parameter names mapped to their values. r5c3�2�K�|]\}}�dz|z|fV��dS)�__Nr9)r.r/�val�keys �r'� <genexpr>z+BaseEstimator.get_params.<locals>.<genexpr>�s4��J�J�V�Q��C�$�J��N�C�0�J�J�J�J�J�Jr)) r;rjr_r"rAr:r5r<�update)rYr7�out�value� deep_itemsros @r'r5zBaseEstimator.get_params�s��f�f��(�(�*�*� � �C��D�#�&�&�E�� K��|�4�4� K�Z��t�=T�=T� K�"�-�-�/�/�5�5�7�7� �� J�J�J�J�z�J�J�J�J�J�J��C��H�H�� r)c ��|s|S|�d��}tt��}|��D]s\}}|�d��\}}}||vr-|��}t d|�d|�d|�d��|r||||<�]t|||��|||<�t|��D]\}} ||jdi| ��|S) aSet the parameters of this estimator. The method works on simple estimators as well as on nested objects (such as :class:`~sklearn.pipeline.Pipeline`). The latter have parameters of the form ``<component>__<parameter>`` so that it's possible to update each component of a nested object. Parameters ---------- **params : dict Estimator parameters. Returns ------- self : estimator instance Estimator instance. Tr6rmzInvalid parameter z for estimator z. Valid parameters are: �.r9) r5rr;r<� partitionrj� ValueError�setattr� set_params) rY�params�valid_params� nested_paramsrors�delim�sub_key�local_valid_params� sub_paramss r'rzzBaseEstimator.set_params�sJ��$� ��K��D��1�1��#�D�)�)� � �,�,�.�.� *� *�J�C��"%�-�-��"5�"5��C��,�&�&�%)�%:�%:�%<�%<�"� �E��E�E�t�E�E�-?�E�E�E�� *�.3� �c�"�7�+�+��c�5�)�)�)�$)��S�!�!�,�2�2�4�4� 7� 7�O�C��(�L��(�6�6�:�6�6�6�6��r)c� �t|��S�N)r%rXs r'r!zBaseEstimator.__sklearn_clone__+s��"�4�(�(�(r)�c��ddlm}d}|ddd|��}|�|��}td�|��}||kr�|dz}d|z}t j||��} t j||ddd ��} d || | �vr5|dz }t j||ddd ��} d}| t|��zt|��| z kr|d| �dz|| d�z}|S) Nr)�_EstimatorPrettyPrinter�T)�compact�indent�indent_at_name�n_max_elements_to_show��z^(\s*\S){%d}�� z[^\n]*\nz...) � utils._pprintr��pformat�len�join�split�re�match�end)rY� N_CHAR_MAXr��N_MAX_ELEMENTS_TO_SHOW�pp�repr_� n_nonblank�lim�regex�left_lim� right_lim�ellipsiss r'�__repr__zBaseEstimator.__repr__.ss�� ;�:�:�:�:�:�!#��%� $��#9� � � �� 4� � ��/�/�0�0� �� "�"��/�C�#�c�)�E��x��u�-�-�1�1�3�3�H��d�d��d��4�4�8�8�:�:�I��u�X�y�j�0�1�1�1��$��H�U�E�$�$�B�$�K�8�8�<�<�>�>� ��H��#�h�-�-�'�#�e�*�*�y�*@�@�@��i�x�i�(�5�0�5�)��3E�E��r)c��t|dd��rtd�� t��}|�|j��}n)#t$r|j��}YnwxYwt|��j� d��r(t|��t��S|S)N� __slots__zSYou cannot use `__slots__` in objects inheriting from `sklearn.base.BaseEstimator`.�sklearn.)�_sklearn_version) r_rD�super�__getstate__�__dict__rBrHr:� __module__� startswithr;r<r)rY�staterFs �r'r�zBaseEstimator.__getstate__bs��4��d�+�+� ��0�� )��G�G�(�(�*�*�E��}�� *�*�,�,�� )� )� )��M�&�&�(�(�E�E�E� )��:�:� �+�+�J�7�7� �� D�D�D�D��Ls�;A�#B�Bc��t|��j�d��rT|�dd��}|tkr3tjt|jj t|�� t��|��dS#t$r|j �|��YdSwxYw)Nr�r�zpre-0.18)�estimator_name�current_sklearn_version�original_sklearn_version)r:r�r��popr�warnings�warnrrF�__name__r��__setstate__rHr�rq)rYr��pickle_versionrFs �r'r�zBaseEstimator.__setstate__xs��:�:� �+�+�J�7�7� �"�Y�Y�'9�:�F�F�N��,�,�� .�'+�~�'>�0;�1?�� (��G�G� � ��'�'�'�'�'�� (� (� (��M� � ��'�'�'�'�'�'� (��s�>!B!�!$C �C c�p�ddlm}m}tjdt ��|||��S)aThis code should never be reached since our `get_tags` will fallback on `__sklearn_tags__` implemented below. We keep it for backward compatibility. It is tested in `test_base_estimator_more_tags` in `sklearn/utils/testing/test_tags.py`.r)�_to_old_tags�default_tagszxThe `_more_tags` method is deprecated in 1.6 and will be removed in 1.7. Please implement the `__sklearn_tags__` method.��category)�sklearn.utils._tagsr�r�r�r��DeprecationWarning)rYr�r�s r'� _more_tagszBaseEstimator._more_tags�s[�� C�B�B�B�B�B�B�B�� C�'� � � � � �|�L�L��.�.�/�/�/r)c�p�ddlm}m}tjdt ��|||��S)Nr)r�rzwThe `_get_tags` method is deprecated in 1.6 and will be removed in 1.7. Please implement the `__sklearn_tags__` method.r�)r�r�rr�r�r�)rYr�rs r'� _get_tagszBaseEstimator._get_tags�sV��>�>�>�>�>�>�>�>�� C�'� � � � ��|�H�H�T�N�N�+�+�+r)c�F�tdtd��ddd��S)NF)�required)rJ�target_tags�transformer_tags�regressor_tags�classifier_tags)rrrXs r'�__sklearn_tags__zBaseEstimator.__sklearn_tags__�s3��"�E�2�2�2�!�� r)c�p�t|j|�d��|jj��dS)aYValidate types and values of constructor parameters The expected type and values must be defined in the `_parameter_constraints` class attribute, which is a dictionary `param_name: list of constraints`. See the docstring of `validate_parameter_constraints` for a description of the accepted constraints. Fr6)�caller_nameN)r �_parameter_constraintsr5rFr�rXs r'�_validate_paramszBaseEstimator._validate_params�sD�� '��'��O�O��O�'�'��/� � � � � � r)c�^�t��ddkrtd��|jS)aHTML representation of estimator. This is redundant with the logic of `_repr_mimebundle_`. The latter should be favorted in the long term, `_repr_html_` is only implemented for consumers who do not interpret `_repr_mimbundle_`. �display�diagramzW_repr_html_ is only defined when the 'display' configuration option is set to 'diagram')rrH�_repr_html_innerrXs r'�_repr_html_zBaseEstimator._repr_html_�s:��<�<� �"�i�/�/� �� $�$r)c� �t|��S)z�This function is returned by the @property `_repr_html_` to make `hasattr(estimator, "_repr_html_") return `True` or `False` depending on `get_config()["display"]`. )r rXs r'r�zBaseEstimator._repr_html_inner�s�� #�4�(�(�(r)c�|�dt|��i}t��ddkrt|��|d<|S)z8Mime bundle used by jupyter kernels to display estimatorz text/plainr�r�z text/html)rErr )rY�kwargs�outputs r'�_repr_mimebundle_zBaseEstimator._repr_mimebundle_�s=��T� � �+��<�<� �"�i�/�/�"5�d�";�";�F�;�� r)c�V�tjdt��t|g|�Ri|��S)Nz�`BaseEstimator._validate_data` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation.validate_data` instead. This function becomes public and is part of the scikit-learn developer API.)r�r�� FutureWarningr�rY�argsr�s r'�_validate_datazBaseEstimator._validate_data�sA�� U� � � � ��T�3�D�3�3�3�F�3�3�3r)c�Z�tjdt��t|g|�Ri|��dS)Nz�`BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.)r�r�r�rr�s r'rzBaseEstimator._check_n_features�sE�� X�� $�0��0�0�0��0�0�0�0�0r)c�Z�tjdt��t|g|�Ri|��dS)Nz�`BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.)r�r�r�rr�s r'rz"BaseEstimator._check_feature_names�sF�� T�3�D�3�3�3�F�3�3�3�3�3r))T)r�)r�r��__qualname__�__doc__�classmethodrjr5rzr!r�r�r�r�r�r�r��propertyr�r�r�r�rr� __classcell__�rFs@r'rTrT�sa��)�)�V�4�4��[�4�<��0*�*�*�X)�)�)�2�2�2�2�h��,(�(�(�(�(�"0�0�0� ,� ,� ,� � � � � � �� %� %��X� %�)�)�)��4�4�4�1�1�1�4�4�4�4�4�4�4r)rTc�.��eZdZdZdZ�fd�Zdd�Z�xZS)�ClassifierMixina�Mixin class for all classifiers in scikit-learn. This mixin defines the following functionality: - set estimator type to `"classifier"` through the `estimator_type` tag; - `score` method that default to :func:`~sklearn.metrics.accuracy_score`. - enforce that `fit` requires `y` to be passed through the `requires_y` tag, which is done by setting the classifier type tag. Read more in the :ref:`User Guide <rolling_your_own_estimator>`. Examples -------- >>> import numpy as np >>> from sklearn.base import BaseEstimator, ClassifierMixin >>> # Mixin classes should always be on the left-hand side for a correct MRO >>> class MyEstimator(ClassifierMixin, BaseEstimator): ... def __init__(self, *, param=1): ... self.param = param ... def fit(self, X, y=None): ... self.is_fitted_ = True ... return self ... def predict(self, X): ... return np.full(shape=X.shape[0], fill_value=self.param) >>> estimator = MyEstimator(param=1) >>> X = np.array([[1, 2], [2, 3], [3, 4]]) >>> y = np.array([1, 0, 1]) >>> estimator.fit(X, y).predict(X) array([1, 1, 1]) >>> estimator.score(X, y) 0.66... � classifierc��t��}d|_t��|_d|j_|S)Nr�T)r�r�rJrr�r�r��rY�tagsrFs �r'r�z ClassifierMixin.__sklearn_tags__s>��w�w�'�'�)�)��*��-�/�/��$(��!��r)Nc�P�ddlm}|||�|��|��S)a� Return the mean accuracy on the given test data and labels. In multi-label classification, this is the subset accuracy which is a harsh metric since you require for each sample that each label set be correctly predicted. Parameters ---------- X : array-like of shape (n_samples, n_features) Test samples. y : array-like of shape (n_samples,) or (n_samples, n_outputs) True labels for `X`. sample_weight : array-like of shape (n_samples,), default=None Sample weights. Returns ------- score : float Mean accuracy of ``self.predict(X)`` w.r.t. `y`. r)�accuracy_score�� sample_weight)�metricsr��predict)rY�X�yr�r�s r'�scorezClassifierMixin.score"s7��0 ,�+�+�+�+�+��~�a��a�� N�N�N�Nr)r��r�r�r�r��_estimator_typer�r�r�r�s@r'r�r��sf��D#�O��O�O�O�O�O�O�O�Or)r�c�.��eZdZdZdZ�fd�Zdd�Z�xZS)�RegressorMixina�Mixin class for all regression estimators in scikit-learn. This mixin defines the following functionality: - set estimator type to `"regressor"` through the `estimator_type` tag; - `score` method that default to :func:`~sklearn.metrics.r2_score`. - enforce that `fit` requires `y` to be passed through the `requires_y` tag, which is done by setting the regressor type tag. Read more in the :ref:`User Guide <rolling_your_own_estimator>`. Examples -------- >>> import numpy as np >>> from sklearn.base import BaseEstimator, RegressorMixin >>> # Mixin classes should always be on the left-hand side for a correct MRO >>> class MyEstimator(RegressorMixin, BaseEstimator): ... def __init__(self, *, param=1): ... self.param = param ... def fit(self, X, y=None): ... self.is_fitted_ = True ... return self ... def predict(self, X): ... return np.full(shape=X.shape[0], fill_value=self.param) >>> estimator = MyEstimator(param=0) >>> X = np.array([[1, 2], [2, 3], [3, 4]]) >>> y = np.array([-1, 0, 1]) >>> estimator.fit(X, y).predict(X) array([0, 0, 0]) >>> estimator.score(X, y) 0.0 � regressorc��t��}d|_t��|_d|j_|S)Nr�T)r�r�rJrr�r�r�r�s �r'r�zRegressorMixin.__sklearn_tags__ds<��w�w�'�'�)�)��)��+�o�o��$(��!��r)Nc�T�ddlm}|�|��}||||��S)a�Return the coefficient of determination of the prediction. The coefficient of determination :math:`R^2` is defined as :math:`(1 - \frac{u}{v})`, where :math:`u` is the residual sum of squares ``((y_true - y_pred)** 2).sum()`` and :math:`v` is the total sum of squares ``((y_true - y_true.mean()) ** 2).sum()``. The best possible score is 1.0 and it can be negative (because the model can be arbitrarily worse). A constant model that always predicts the expected value of `y`, disregarding the input features, would get a :math:`R^2` score of 0.0. Parameters ---------- X : array-like of shape (n_samples, n_features) Test samples. For some estimators this may be a precomputed kernel matrix or a list of generic objects instead with shape ``(n_samples, n_samples_fitted)``, where ``n_samples_fitted`` is the number of samples used in the fitting for the estimator. y : array-like of shape (n_samples,) or (n_samples, n_outputs) True values for `X`. sample_weight : array-like of shape (n_samples,), default=None Sample weights. Returns ------- score : float :math:`R^2` of ``self.predict(X)`` w.r.t. `y`. Notes ----- The :math:`R^2` score used when calling ``score`` on a regressor uses ``multioutput='uniform_average'`` from version 0.23 to keep consistent with default value of :func:`~sklearn.metrics.r2_score`. This influences the ``score`` method of all the multioutput regressors (except for :class:`~sklearn.multioutput.MultiOutputRegressor`). r)�r2_scorer�)r�r�r�)rYr�r�r�r��y_preds r'r�zRegressorMixin.scoreks=��R &�%�%�%�%�%��a��x��6��?�?�?�?r)r�r�r�s@r'r�r�?sf��D"�O��,@�,@�,@�,@�,@�,@�,@�,@r)r�c�.��eZdZdZdZ�fd�Zdd�Z�xZS)�ClusterMixinapMixin class for all cluster estimators in scikit-learn. - set estimator type to `"clusterer"` through the `estimator_type` tag; - `fit_predict` method returning the cluster labels associated to each sample. Examples -------- >>> import numpy as np >>> from sklearn.base import BaseEstimator, ClusterMixin >>> class MyClusterer(ClusterMixin, BaseEstimator): ... def fit(self, X, y=None): ... self.labels_ = np.ones(shape=(len(X),), dtype=np.int64) ... return self >>> X = [[1, 2], [2, 3], [3, 4]] >>> MyClusterer().fit_predict(X) array([1, 1, 1]) � clustererc�|��t��}d|_|j�g|j_|S)Nr�)r�r�rJr��preserves_dtyper�s �r'r�zClusterMixin.__sklearn_tags__�s9��w�w�'�'�)�)��)�� ,�46�D�!�1��r)Nc�,�|j|fi|��|jS)a� Perform clustering on `X` and returns cluster labels. Parameters ---------- X : array-like of shape (n_samples, n_features) Input data. y : Ignored Not used, present for API consistency by convention. **kwargs : dict Arguments to be passed to ``fit``. .. versionadded:: 1.4 Returns ------- labels : ndarray of shape (n_samples,), dtype=np.int64 Cluster labels. )�fit�labels_)rYr�r�r�s r'�fit_predictzClusterMixin.fit_predict�s&��0 ��f��|�r)r��r�r�r�r�r�r�rr�r�s@r'r�r��s]��&"�O��r)r�c�:�eZdZdZed��Zd�Zd�Zd�ZdS)�BiclusterMixina?Mixin class for all bicluster estimators in scikit-learn. This mixin defines the following functionality: - `biclusters_` property that returns the row and column indicators; - `get_indices` method that returns the row and column indices of a bicluster; - `get_shape` method that returns the shape of a bicluster; - `get_submatrix` method that returns the submatrix corresponding to a bicluster. Examples -------- >>> import numpy as np >>> from sklearn.base import BaseEstimator, BiclusterMixin >>> class DummyBiClustering(BiclusterMixin, BaseEstimator): ... def fit(self, X, y=None): ... self.rows_ = np.ones(shape=(1, X.shape[0]), dtype=bool) ... self.columns_ = np.ones(shape=(1, X.shape[1]), dtype=bool) ... return self >>> X = np.array([[1, 1], [2, 1], [1, 0], ... [4, 7], [3, 5], [3, 6]]) >>> bicluster = DummyBiClustering().fit(X) >>> hasattr(bicluster, "biclusters_") True >>> bicluster.get_indices(0) (array([0, 1, 2, 3, 4, 5]), array([0, 1])) c��|j|jfS)z{Convenient way to get row and column indicators together. Returns the ``rows_`` and ``columns_`` members. )�rows_�columns_rXs r'�biclusters_zBiclusterMixin.biclusters_�s��z�4�=�(�(r)c��|j|}|j|}tj|��dtj|��dfS)a�Row and column indices of the `i`'th bicluster. Only works if ``rows_`` and ``columns_`` attributes exist. Parameters ---------- i : int The index of the cluster. Returns ------- row_ind : ndarray, dtype=np.intp Indices of rows in the dataset that belong to the bicluster. col_ind : ndarray, dtype=np.intp Indices of columns in the dataset that belong to the bicluster. r)rr �np�nonzero)rY�i�rows�columnss r'�get_indiceszBiclusterMixin.get_indices�sD��"�z�!�}��-��"��z�$��"�B�J�w�$7�$7��$:�:�:r)c�^�|�|��}td�|D��S)a-Shape of the `i`'th bicluster. Parameters ---------- i : int The index of the cluster. Returns ------- n_rows : int Number of rows in the bicluster. n_cols : int Number of columns in the bicluster. c3�4K�|]}t|��V��dSr�)r�)r.rs r'rpz+BiclusterMixin.get_shape.<locals>.<genexpr>s(��-�-��S��V�V�-�-�-�-�-�-r))rr>)rYr�indicess r'� get_shapezBiclusterMixin.get_shapes4�� "�"�1�%�%��-�-�W�-�-�-�-�-�-r)c��t|d��}|�|��\}}||dd�tjf|fS)aReturn the submatrix corresponding to bicluster `i`. Parameters ---------- i : int The index of the cluster. data : array-like of shape (n_samples, n_features) The data. Returns ------- submatrix : ndarray of shape (n_rows, n_cols) The submatrix corresponding to bicluster `i`. Notes ----- Works with sparse matrices. Only works if ``rows_`` and ``columns_`` attributes exist. �csr)� accept_sparseN)rrr�newaxis)rYr�data�row_ind�col_inds r'� get_submatrixzBiclusterMixin.get_submatrixsM��*�4�u�5�5�5��+�+�A�.�.��G�A�A�A�r�z�M�*�G�3�4�4r)N) r�r�r�r�r�r rrrr9r)r'rr�sf��6�)�)��X�)�;�;�;�*.�.�.�&5�5�5�5�5r)rc�*��eZdZdZ�fd�Zdd�Z�xZS)�TransformerMixina�Mixin class for all transformers in scikit-learn. This mixin defines the following functionality: - a `fit_transform` method that delegates to `fit` and `transform`; - a `set_output` method to output `X` as a specific container type. If :term:`get_feature_names_out` is defined, then :class:`BaseEstimator` will automatically wrap `transform` and `fit_transform` to follow the `set_output` API. See the :ref:`developer_api_set_output` for details. :class:`OneToOneFeatureMixin` and :class:`ClassNamePrefixFeaturesOutMixin` are helpful mixins for defining :term:`get_feature_names_out`. Examples -------- >>> import numpy as np >>> from sklearn.base import BaseEstimator, TransformerMixin >>> class MyTransformer(TransformerMixin, BaseEstimator): ... def __init__(self, *, param=1): ... self.param = param ... def fit(self, X, y=None): ... return self ... def transform(self, X): ... return np.full(shape=len(X), fill_value=self.param) >>> transformer = MyTransformer() >>> X = [[1, 2], [2, 3], [3, 4]] >>> transformer.fit_transform(X) array([1, 1, 1]) c�n��t��}t��|_|Sr�)r�r�rr�r�s �r'r�z!TransformerMixin.__sklearn_tags__Zs+��w�w�'�'�)�)�� /� 1� 1��r)Nc�r�t��re|��d|��}|r(t jd|jj�d�t��|�!|j |fi|�� |��S|j ||fi|�� |��S)a� Fit to data, then transform it. Fits transformer to `X` and `y` with optional parameters `fit_params` and returns a transformed version of `X`. Parameters ---------- X : array-like of shape (n_samples, n_features) Input samples. y : array-like of shape (n_samples,) or (n_samples, n_outputs), default=None Target values (None for unsupervised transformations). **fit_params : dict Additional fit parameters. Returns ------- X_new : ndarray array of shape (n_samples, n_features_new) Transformed array. � transform��methodr{� This object (ah) has a `transform` method which consumes metadata, but `fit_transform` does not forward metadata to `transform`. Please implement a custom `fit_transform` method to forward metadata to `transform` as well. Alternatively, you can explicitly do `set_transform_request`and set all values to `False` to disable metadata routed to `transform`, if that's an option.)r�get_metadata_routing�consumes�keysr�r�rFr��UserWarningrr")rYr�r�� fit_params�transform_paramss r'� fit_transformzTransformerMixin.fit_transform_s��F�� #�8�8�:�:�C�C�"�:�?�?�+<�+<� D� � �� X��(?�X�X�X� �� 9��4�8�A�,�,��,�,�6�6�q�9�9�9��4�8�A�q�/�/�J�/�/�9�9�!�<�<�<r)r�)r�r�r�r�r�r,r�r�s@r'rr9sW��@�� :=�:=�:=�:=�:=�:=�:=�:=r)rc��eZdZdZdd�ZdS)�OneToOneFeatureMixina�Provides `get_feature_names_out` for simple transformers. This mixin assumes there's a 1-to-1 correspondence between input features and output features, such as :class:`~sklearn.preprocessing.StandardScaler`. Examples -------- >>> import numpy as np >>> from sklearn.base import OneToOneFeatureMixin, BaseEstimator >>> class MyEstimator(OneToOneFeatureMixin, BaseEstimator): ... def fit(self, X, y=None): ... self.n_features_in_ = X.shape[1] ... return self >>> X = np.array([[1, 2], [3, 4]]) >>> MyEstimator().fit(X).get_feature_names_out() array(['x0', 'x1'], dtype=object) Nc�D�t|d��t||��S)a�Get output feature names for transformation. Parameters ---------- input_features : array-like of str or None, default=None Input features. - If `input_features` is `None`, then `feature_names_in_` is used as feature names in. If `feature_names_in_` is not defined, then the following input feature names are generated: `["x0", "x1", ..., "x(n_features_in_ - 1)"]`. - If `input_features` is an array-like, then `input_features` must match `feature_names_in_` if `feature_names_in_` is defined. Returns ------- feature_names_out : ndarray of str objects Same as input features. �n_features_in_)� attributes)rr�rY�input_featuress r'�get_feature_names_outz*OneToOneFeatureMixin.get_feature_names_out�s(��. ��)9�:�:�:�:�&�t�^�<�<�<r)r��r�r�r�r�r4r9r)r'r.r.�s2��$=�=�=�=�=�=r)r.c��eZdZdZdd�ZdS)�ClassNamePrefixFeaturesOutMixina0Mixin class for transformers that generate their own names by prefixing. This mixin is useful when the transformer needs to generate its own feature names out, such as :class:`~sklearn.decomposition.PCA`. For example, if :class:`~sklearn.decomposition.PCA` outputs 3 features, then the generated feature names out are: `["pca0", "pca1", "pca2"]`. This mixin assumes that a `_n_features_out` attribute is defined when the transformer is fitted. `_n_features_out` is the number of output features that the transformer will return in `transform` of `fit_transform`. Examples -------- >>> import numpy as np >>> from sklearn.base import ClassNamePrefixFeaturesOutMixin, BaseEstimator >>> class MyEstimator(ClassNamePrefixFeaturesOutMixin, BaseEstimator): ... def fit(self, X, y=None): ... self._n_features_out = X.shape[1] ... return self >>> X = np.array([[1, 2], [3, 4]]) >>> MyEstimator().fit(X).get_feature_names_out() array(['myestimator0', 'myestimator1'], dtype=object) Nc�P�t|d��t||j|��S)aFGet output feature names for transformation. The feature names out will prefixed by the lowercased class name. For example, if the transformer outputs 3 features, then the feature names out are: `["class_name0", "class_name1", "class_name2"]`. Parameters ---------- input_features : array-like of str or None, default=None Only used to validate feature names with the names seen in `fit`. Returns ------- feature_names_out : ndarray of str objects Transformed feature names. �_n_features_out)r3)rrr9r2s r'r4z5ClassNamePrefixFeaturesOutMixin.get_feature_names_out�s6��" ��/�0�0�0�.��$�&�~� � � � r)r�r5r9r)r'r7r7�s2��0 � � � � � r)r7c�.��eZdZdZdZ�fd�Zdd�Z�xZS)�DensityMixina"Mixin class for all density estimators in scikit-learn. This mixin defines the following functionality: - sets estimator type to `"density_estimator"` through the `estimator_type` tag; - `score` method that default that do no-op. Examples -------- >>> from sklearn.base import DensityMixin >>> class MyEstimator(DensityMixin): ... def fit(self, X, y=None): ... self.is_fitted_ = True ... return self >>> estimator = MyEstimator() >>> hasattr(estimator, "score") True �DensityEstimatorc�V��t��}d|_|S)N�density_estimator�r�r�rJr�s �r'r�zDensityMixin.__sklearn_tags__s%��w�w�'�'�)�)��1��r)Nc��dS)a=Return the score of the model on the data `X`. Parameters ---------- X : array-like of shape (n_samples, n_features) Test samples. y : Ignored Not used, present for API consistency by convention. Returns ------- score : float Nr9)rYr�r�s r'r�zDensityMixin.scores �� r)r�r�r�s@r'r;r;�s]��()�O�� r)r;c�.��eZdZdZdZ�fd�Zdd�Z�xZS)�OutlierMixina�Mixin class for all outlier detection estimators in scikit-learn. This mixin defines the following functionality: - set estimator type to `"outlier_detector"` through the `estimator_type` tag; - `fit_predict` method that default to `fit` and `predict`. Examples -------- >>> import numpy as np >>> from sklearn.base import BaseEstimator, OutlierMixin >>> class MyEstimator(OutlierMixin): ... def fit(self, X, y=None): ... self.is_fitted_ = True ... return self ... def predict(self, X): ... return np.ones(shape=len(X)) >>> estimator = MyEstimator() >>> X = np.array([[1, 2], [2, 3], [3, 4]]) >>> estimator.fit_predict(X) array([1., 1., 1.]) �outlier_detectorc�V��t��}d|_|S)NrCr?r�s �r'r�zOutlierMixin.__sklearn_tags__Cs%��w�w�'�'�)�)��0��r)Nc�*�t��re|��d|��}|r(t jd|jj�d�t��|j |fi|�� |��S)a.Perform fit on X and returns labels for X. Returns -1 for outliers and 1 for inliers. Parameters ---------- X : {array-like, sparse matrix} of shape (n_samples, n_features) The input samples. y : Ignored Not used, present for API consistency by convention. **kwargs : dict Arguments to be passed to ``fit``. .. versionadded:: 1.4 Returns ------- y : ndarray of shape (n_samples,) 1 for inliers, -1 for outliers. r�r#r%aY) has a `predict` method which consumes metadata, but `fit_predict` does not forward metadata to `predict`. Please implement a custom `fit_predict` method to forward metadata to `predict` as well.Alternatively, you can explicitly do `set_predict_request`and set all values to `False` to disable metadata routed to `predict`, if that's an option.)rr&r'r(r�r�rFr�r)rr�)rYr�r�r�r+s r'rzOutlierMixin.fit_predictHs��>�� #�8�8�:�:�C�C� �� D� � �� :��(?�:�:�:� ��t�x��$�$�V�$�$�,�,�Q�/�/�/r)r�rr�s@r'rBrB(s]��0)�O�� 20�20�20�20�20�20�20�20r)rBc��eZdZdZdS)�MetaEstimatorMixinaMixin class for all meta estimators in scikit-learn. This mixin is empty, and only exists to indicate that the estimator is a meta-estimator. .. versionchanged:: 1.6 The `_required_parameters` is now removed and is unnecessary since tests are refactored and don't use this anymore. Examples -------- >>> from sklearn.base import MetaEstimatorMixin >>> from sklearn.datasets import load_iris >>> from sklearn.linear_model import LogisticRegression >>> class MyEstimator(MetaEstimatorMixin): ... def __init__(self, *, estimator=None): ... self.estimator = estimator ... def fit(self, X, y=None): ... if self.estimator is None: ... self.estimator_ = LogisticRegression() ... else: ... self.estimator_ = self.estimator ... return self >>> X, y = load_iris(return_X_y=True) >>> estimator = MyEstimator().fit(X, y) >>> estimator.estimator_ LogisticRegression() N)r�r�r�r�r9r)r'rGrG}s��r)rGc�"��eZdZdZ�fd�Z�xZS)�MultiOutputMixinz2Mixin to mark estimators that support multioutput.c�`��t��}d|j_|S)NT)r�r�r��multi_outputr�s �r'r�z!MultiOutputMixin.__sklearn_tags__�s(��w�w�'�'�)�)��(,��%��r)�r�r�r�r�r�r�r�s@r'rIrI�s>��<�<��r)rIc�"��eZdZdZ�fd�Z�xZS)�_UnstableArchMixinz=Mark estimators that are non-determinstic on 32bit or PowerPCc��t��}tp%tj��d��|_|S)N)�ppc�powerpc)r�r�r�platform�machiner��non_deterministicr�s �r'r�z#_UnstableArchMixin.__sklearn_tags__�sJ��w�w�'�'�)�)��!*�" �h�.>�.@�.@�.K�.K��/ �/ ��r)rLr�s@r'rNrN�s>��G�G��r)rNc��t|t��r]tjdt tj��dd��d�t��t|dd��dkSt|��j dkS)amReturn True if the given estimator is (probably) a classifier. Parameters ---------- estimator : object Estimator object to test. Returns ------- out : bool True if estimator is a classifier and False otherwise. Examples -------- >>> from sklearn.base import is_classifier >>> from sklearn.cluster import KMeans >>> from sklearn.svm import SVC, SVR >>> classifier = SVC() >>> regressor = SVR() >>> kmeans = KMeans() >>> is_classifier(classifier) True >>> is_classifier(regressor) False >>> is_classifier(kmeans) False �passing a class to r��P is deprecated and will be removed in 1.8. Use an instance of the class instead.r�Nr��rAr:r�r��printr#�stackr�r_rrJ�r&s r'� is_classifierr]�s��:�)�T�"�"�K�� L�%�� (:�1�(=�">�">� L� L� L�� y�"3�T�:�:�l�J�J��I��-��=�=r)c��t|t��r]tjdt tj��dd��d�t��t|dd��dkSt|��j dkS)asReturn True if the given estimator is (probably) a regressor. Parameters ---------- estimator : estimator instance Estimator object to test. Returns ------- out : bool True if estimator is a regressor and False otherwise. Examples -------- >>> from sklearn.base import is_regressor >>> from sklearn.cluster import KMeans >>> from sklearn.svm import SVC, SVR >>> classifier = SVC() >>> regressor = SVR() >>> kmeans = KMeans() >>> is_regressor(classifier) False >>> is_regressor(regressor) True >>> is_regressor(kmeans) False rVrrWrXr�Nr�rYr\s r'�is_regressorr_�s��:�)�T�"�"�J�� L�%�� (:�1�(=�">�">� L� L� L�� y�"3�T�:�:�k�I�I��I��-��<�<r)c��t|t��r]tjdt tj��dd��d�t��t|dd��dkSt|��j dkS)a�Return True if the given estimator is (probably) a clusterer. .. versionadded:: 1.6 Parameters ---------- estimator : object Estimator object to test. Returns ------- out : bool True if estimator is a clusterer and False otherwise. Examples -------- >>> from sklearn.base import is_clusterer >>> from sklearn.cluster import KMeans >>> from sklearn.svm import SVC, SVR >>> classifier = SVC() >>> regressor = SVR() >>> kmeans = KMeans() >>> is_clusterer(classifier) False >>> is_clusterer(regressor) False >>> is_clusterer(kmeans) True rVrrWrXr�Nr�rYr\s r'�is_clustererras��>�)�T�"�"�J�� L�%�� (:�1�(=�">�">� L� L� L�� y�"3�T�:�:�k�I�I��I��-��<�<r)c��t|t��r]tjdt tj��dd��d�t��t|dd��dkSt|��j dkS)aReturn True if the given estimator is (probably) an outlier detector. Parameters ---------- estimator : estimator instance Estimator object to test. Returns ------- out : bool True if estimator is an outlier detector and False otherwise. rVrrWrXr�NrCrYr\s r'�is_outlier_detectorrc*s��)�T�"�"�Q�� L�%�� (:�1�(=�">�">� L� L� L�� y�"3�T�:�:�>P�P�P��I��-�1C�C�Cr)c��fd�}|S)aCDecorator to run the fit methods of estimators within context managers. Parameters ---------- prefer_skip_nested_validation : bool If True, the validation of parameters of inner estimators or functions called during fit will be skipped. This is useful to avoid validating many times the parameters passed by the user from the public facing API. It's also useful to avoid validating parameters that we pass internally to inner functions that are guaranteed to be valid by the test suite. It should be set to True for most estimators, except for those that receive non-validated objects as parameters, such as meta-estimators that are given estimator objects. Returns ------- decorated_fit : method The decorated fit method. c�J��tj��fd��}|S)Nc��t��d}�jdkot|��}|s|s|��t �p|��5�|g|�Ri|��cddd��S#1swxYwYdS)N�skip_parameter_validation�partial_fit)rg)rr�rr�r)r&r�r��global_skip_validation�partial_fit_and_fitted� fit_method�prefer_skip_nested_validations ��r'�wrapperz0_fit_context.<locals>.decorator.<locals>.wrapper\s��%/�\�\�2M�%N�"��#�}�4�N��I�9N�9N� #�*� -�2H� -��*�*�,�,�,��1�K�5K�� >� >� "�z�)�=�d�=�=�=�f�=�=� >� >� >� >� >� >� >� >� >� >� >� >�� >� >� >� >� >� >s�A3�3A7�:A7)� functools�wraps)rkrmrls` �r'� decoratorz_fit_context.<locals>.decorator[s>�� $� $� >� >� >� >� >� %� $� >�$�r)r9)rlrps` r'�_fit_contextrqCs$��0��,�r))Br�rBrnr#rRr�r��collectionsr�numpyrr�r�_configrr� exceptionsr�utils._estimator_html_reprr r �utils._metadata_requestsrr�utils._param_validationr �utils._set_outputr�utils._tagsrrrrrr�utils.fixesr�utils.validationrrrrrrrrr(r%rTr�r�r�rrr.r7r;rBrGrIrNr]r_rarcrqr9r)r'�<module>r}s��D�D� �� #�#�#�#�#�#��/�/�/�/�/�/�/�/�2�2�2�2�2�2�X�X�X�X�X�X�X�X�J�J�J�J�J�J�J�J�C�C�C�C�C�C�.�.�.�.�.�.��#�"�"�"�"�"� � � � � � � � � � � � � � � � � � � � �"�35�35�35�35�35�l,0�7�7�7�7�7�tW4�W4�W4�W4�W4�/�1C�W4�W4�W4�t FO�FO�FO�FO�FO�FO�FO�FO�RX@�X@�X@�X@�X@�X@�X@�X@�v6�6�6�6�6�6�6�6�rc5�c5�c5�c5�c5�c5�c5�c5�L`=�`=�`=�`=�`=��`=�`=�`=�F+=�+=�+=�+=�+=�+=�+=�+=�\- �- �- �- �- �- �- �- �`+ �+ �+ �+ �+ �+ �+ �+ �\R0�R0�R0�R0�R0�R0�R0�R0�j��>��%>�%>�%>�P%=�%=�%=�P'=�'=�'=�TD�D�D�2.�.�.�.�.r)