U 9%e@sdZddlZddlZddlZddlZddlZddlZddlmZddl Z ddl m Z ddl mZmZddlmZddlmZdd lmZdd lmZdd lmZdd lmZdd lmZddlmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'ddddZ(ddddZ)GdddeZ*GdddZ+GdddZ,GdddZ-GdddZ.Gdd d eZ/Gd!d"d"Z0Gd#d$d$Z1Gd%d&d&Z2Gd'd(d(Z3Gd)d*d*Z4Gd+d,d,Z5Gd-d.d.Z6d/d0Z7d1d2Z8d3d4Z9d5d6Z:dS)7z Base classes for all estimators.N) defaultdict) __version__)config_context get_config)InconsistentVersionWarning) _IS_32BITestimator_html_repr)_MetadataRequester)validate_parameter_constraints)_SetOutputMixin _DEFAULT_TAGS) _check_feature_names_in_check_y_generate_get_feature_names_out_get_feature_names _is_fitted _num_features check_arraycheck_is_fitted check_X_yTsafecCs(t|drt|s|St||dS)aConstruct 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`. __sklearn_clone__r)hasattrinspectisclassr_clone_parametrized) estimatorrr!K/var/www/html/Darija-Ai-API/env/lib/python3.8/site-packages/sklearn/base.pyclone(s"r#c sbt|}|tkr&fdd|DS|ttttfkrL|fdd|DSt|dr`t|trsnt |St|trt dnt dt |t|f|j }|jdd }|D]\}}t|dd ||<q|f|}zt |j|_Wntk rYnX|jdd }|D]0}||} ||} | | k rtd ||fqt|d r^t |j|_|S) zLDefault implementation of clone. See :func:`sklearn.base.clone` for details.csi|]\}}|t|dqSrr#).0kvrr!r" Tsz'_clone_parametrized..csg|]}t|dqSr$r%)r&err!r" Vsz'_clone_parametrized.. get_paramszaCannot clone object. You should provide an instance of scikit-learn estimator instead of a class.zCannot clone object '%s' (type %s): it does not seem to be a scikit-learn estimator as it does not implement a 'get_params' method.FdeeprzWCannot clone object %s, as the constructor either does not set or modifies parameter %s_sklearn_output_config)typedictitemslisttupleset frozensetr isinstancecopydeepcopy TypeErrorrepr __class__r,r#Z_metadata_requestAttributeError RuntimeErrorr/) r rZestimator_typeklassZnew_object_paramsnameparamZ new_objectZ params_setZparam1Zparam2r!rr"rOsR       rcseZdZdZeddZd&ddZddZd d Zd'd d Z fddZ fddZ ddZ ddZ ddZddZd(ddZddZed d!Zd"d#Zd$d%ZZS)) BaseEstimatorzBase class for all estimators in scikit-learn. 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``). cCstt|jd|j}|tjkrgSt|}dd|jD}|D] }|j|jkr@t d||fq@t dd|DS)z%Get parameter names for the estimatorZdeprecated_originalcSs&g|]}|jdkr|j|jkr|qSself)r@kind VAR_KEYWORDr&pr!r!r"r+s z2BaseEstimator._get_param_names..zscikit-learn estimators should always specify their parameters in the signature of their __init__ (no varargs). %s with constructor %s doesn't follow this convention.cSsg|] }|jqSr!)r@rGr!r!r"r+s) getattr__init__objectr signature parametersvaluesrEVAR_POSITIONALr>sorted)clsinitZinit_signaturerMrHr!r!r"_get_param_namess   zBaseEstimator._get_param_namesTcsft}|D]Rt|}|rXt|drXt|tsX|}|fdd|D||<q|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. r,c3s"|]\}}d||fVqdS)__Nr!)r&r'valkeyr!r" sz+BaseEstimator.get_params..) r1rSrIrr7r0r,r2update)rDr.outvalueZ deep_itemsr!rVr"r,s    zBaseEstimator.get_paramsc Ks|s|S|jdd}tt}|D]j\}}|d\}}}||krh|}td|d|d|d|rz||||<q$t||||||<q$|D]b\}} |dkr||d kr|j d rt j d |j j d |j j d tddd}||jf| q|S)a Set 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 ``__`` so that it's possible to update each component of a nested object. Parameters ---------- **params : dict Estimator parameters. Returns ------- self : estimator instance Estimator instance. Tr-rTzInvalid parameter z for estimator z. Valid parameters are: .Zbase_estimator deprecatedsklearn.zParameter 'base_estimator' of z, is deprecated in favor of 'estimator'. See z's docstring for more details.) stacklevelr )r,rr1r2 partitionrS ValueErrorsetattr __module__ startswithwarningswarnr<__name__ FutureWarning set_params) rDparamsZ valid_paramsZ nested_paramsrWr[delimZsub_keyZlocal_valid_paramsZ sub_paramsr!r!r"rjs<      zBaseEstimator.set_paramscCst|SN)rrCr!r!r"r szBaseEstimator.__sklearn_clone__c Csddlm}d}|ddd|d}||}td|}||kr|d}d|}t||} t||ddd } d || | kr|d 7}t||ddd } d } | t| t|| kr|d| d || d}|S) Nr)_EstimatorPrettyPrinterT)compactindentZindent_at_nameZn_max_elements_to_showr_z ^(\s*\S){%d} z[^\n]*\nz...) Z utils._pprintropformatlenjoinsplitrematchend) rDZ N_CHAR_MAXroZN_MAX_ELEMENTS_TO_SHOWpprepr_Z n_nonblankZlimregexZleft_limZ right_limellipsisr!r!r"__repr__s,   zBaseEstimator.__repr__cs|t|ddrtdz t}|dkr2|j}Wntk rR|j}YnXt|j drtt | t dS|SdS)N __slots__zSYou cannot use `__slots__` in objects inheriting from `sklearn.base.BaseEstimator`.r^)_sklearn_version) rIr:super __getstate____dict__r8r=r0rdrer1r2r)rDstater<r!r"rBs  zBaseEstimator.__getstate__csrt|jdr<|dd}|tkr|d|d7}q|S)Nrsz- ... z- ru) enumerate)namesoutputZ max_n_namesir@r!r!r" add_namessz5BaseEstimator._check_feature_names..add_namesz"Feature names unseen at fit time: z1Feature names seen at fit time, yet now missing: z=Feature names must be in the same order as they were in fit. )rrrdelattrrIrfrgr<rhrwnpanyr5rPrb) rDrrZfeature_names_inZfitted_feature_namesZX_feature_namesmessageZfitted_feature_names_setZX_feature_names_setZunexpected_namesZ missing_namesrr!r!r"_check_feature_namessT         z"BaseEstimator._check_feature_names no_validationFc Ksz|j||d|dkr6|dr6td|jjdt|toF|dk}|dkp`t|to`|dk}|rr|rrtdd|i} | |}|s|s|r|} n|r|s|} n||f} n|s|rt|fd d i|} n|r|st|f|} nt|r:|\} } d| kr| | } t|fd d i| }d| kr$| | } t|fd d i| }nt ||f|\}}||f} |sv| d d rv|j ||d| S)ao Validate input data and set or check the `n_features_in_` attribute. Parameters ---------- X : {array-like, sparse matrix, dataframe} of shape (n_samples, n_features), default='no validation' The input samples. If `'no_validation'`, no validation is performed on `X`. This is useful for meta-estimator which can delegate input validation to their underlying estimator(s). In that case `y` must be passed and the only accepted `check_params` are `multi_output` and `y_numeric`. y : array-like of shape (n_samples,), default='no_validation' The targets. - If `None`, `check_array` is called on `X`. If the estimator's requires_y tag is True, then an error will be raised. - If `'no_validation'`, `check_array` is called on `X` and the estimator's requires_y tag is ignored. This is a default placeholder and is never meant to be explicitly set. In that case `X` must be passed. - Otherwise, only `y` with `_check_y` or both `X` and `y` are checked with either `check_array` or `check_X_y` depending on `validate_separately`. reset : bool, default=True Whether to reset the `n_features_in_` attribute. If False, the input will be checked for consistency with data provided when reset was last True. .. note:: It is recommended to call reset=True in `fit` and in the first call to `partial_fit`. All other methods that validate `X` should set `reset=False`. validate_separately : False or tuple of dicts, default=False Only used if y is not None. If False, call validate_X_y(). Else, it must be a tuple of kwargs to be used for calling check_array() on X and y respectively. `estimator=self` is automatically added to these dicts to generate more informative error message in case of invalid input data. cast_to_ndarray : bool, default=True Cast `X` and `y` to ndarray with checks in `check_params`. If `False`, `X` and `y` are unchanged and only `feature_names_in_` and `n_features_in_` are checked. **check_params : kwargs Parameters passed to :func:`sklearn.utils.check_array` or :func:`sklearn.utils.check_X_y`. Ignored if validate_separately is not False. `estimator=self` is automatically added to these params to generate more informative error message in case of invalid input data. Returns ------- out : {ndarray, sparse matrix} or tuple of these The validated input. A tuple is returned if both `X` and `y` are validated. )rN requires_yzThis z= estimator requires y to be passed, but the target y is None.rz*Validation should be done on X, y or both.r Z input_nameryZ ensure_2dT) rrrbr<rhr7strrrrgetr) rDrrrZvalidate_separatelyZcast_to_ndarrayZ check_paramsZno_val_XZno_val_yZdefault_check_paramsrZZcheck_X_paramsZcheck_y_paramsr!r!r"_validate_datasDG  zBaseEstimator._validate_datacCs t|j|jdd|jjddS)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. Fr-)Z caller_nameN)r Z_parameter_constraintsr,r<rhrCr!r!r"_validate_paramsvs  zBaseEstimator._validate_paramscCstddkrtd|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_`. displaydiagramzW_repr_html_ is only defined when the 'display' configuration option is set to 'diagram')rr=_repr_html_innerrCr!r!r" _repr_html_s zBaseEstimator._repr_html_cCst|S)zThis function is returned by the @property `_repr_html_` to make `hasattr(estimator, "_repr_html_") return `True` or `False` depending on `get_config()["display"]`. r rCr!r!r"rszBaseEstimator._repr_html_innercKs*dt|i}tddkr&t||d<|S)z8Mime bundle used by jupyter kernels to display estimatorz text/plainrrz text/html)r;rr )rDkwargsrr!r!r"_repr_mimebundle_s  zBaseEstimator._repr_mimebundle_)T)rn)rrTFT)rhrd __qualname____doc__ classmethodrSr,rjrrrrrrrrrrpropertyrrr __classcell__r!r!rr"rBs0   A 4   .[ y rBc@s&eZdZdZdZdddZddZdS) ClassifierMixinz0Mixin class for all classifiers in scikit-learn. classifierNcCs ddlm}|||||dS)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)metricsrpredict)rDrrrrr!r!r"scores zClassifierMixin.scorecCsddiSNrTr!rCr!r!r"rszClassifierMixin._more_tags)Nrhrdrr_estimator_typerrr!r!r!r"rs rc@s&eZdZdZdZdddZddZdS) RegressorMixinz:Mixin class for all regression estimators in scikit-learn. regressorNcCs$ddlm}||}||||dS)aReturn 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)rrr)rDrrrrZy_predr!r!r"rs)  zRegressorMixin.scorecCsddiSrr!rCr!r!r"rszRegressorMixin._more_tags)Nrr!r!r!r"rs .rc@s&eZdZdZdZdddZddZdS) ClusterMixinz7Mixin class for all cluster estimators in scikit-learn.Z clustererNcCs|||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. Returns ------- labels : ndarray of shape (n_samples,), dtype=np.int64 Cluster labels. )fitZlabels_rDrrr!r!r" fit_predicts zClusterMixin.fit_predictcCsdgiS)NZpreserves_dtyper!rCr!r!r"rszClusterMixin._more_tags)N)rhrdrrrrrr!r!r!r"rs rc@s4eZdZdZeddZddZddZdd Zd S) BiclusterMixinz9Mixin class for all bicluster estimators in scikit-learn.cCs |j|jfS)z{Convenient way to get row and column indicators together. Returns the ``rows_`` and ``columns_`` members. )rows_columns_rCr!r!r" biclusters_!szBiclusterMixin.biclusters_cCs0|j|}|j|}t|dt|dfS)aRow 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)rrrZnonzero)rDrrowscolumnsr!r!r" get_indices)s  zBiclusterMixin.get_indicescCs||}tdd|DS)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. css|]}t|VqdSrm)rw)r&rr!r!r"rXOsz+BiclusterMixin.get_shape..)rr4)rDrindicesr!r!r" get_shape>s zBiclusterMixin.get_shapecCs@ddlm}||dd}||\}}||ddtjf|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. r)rZcsr)Z accept_sparseN)utils.validationrrrZnewaxis)rDrdatarZrow_indZcol_indr!r!r" get_submatrixQs  zBiclusterMixin.get_submatrixN) rhrdrrrrrrrr!r!r!r"rs  rc@seZdZdZdddZdS)TransformerMixinaMixin class for all transformers in scikit-learn. 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`. NcKs6|dkr|j|f||S|j||f||SdS)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. N)rZ transform)rDrrZ fit_paramsr!r!r" fit_transformxszTransformerMixin.fit_transform)N)rhrdrrrr!r!r!r"rls rc@seZdZdZdddZdS)OneToOneFeatureMixinzProvides `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`. NcCst|dt||S)aGet 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. r)rrrDinput_featuresr!r!r"get_feature_names_outs z*OneToOneFeatureMixin.get_feature_names_out)Nrhrdrrrr!r!r!r"rsrc@seZdZdZdddZdS)ClassNamePrefixFeaturesOutMixinaUMixin 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`. NcCst|dt||j|dS)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)r)rrrrr!r!r"rs  z5ClassNamePrefixFeaturesOutMixin.get_feature_names_out)Nrr!r!r!r"rs rc@seZdZdZdZdddZdS) DensityMixinz7Mixin class for all density estimators in scikit-learn.ZDensityEstimatorNcCsdS)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 Nr!rr!r!r"rszDensityMixin.score)N)rhrdrrrrr!r!r!r"rsrc@seZdZdZdZdddZdS) OutlierMixinzAMixin class for all outlier detection estimators in scikit-learn.outlier_detectorNcCs|||S)aPerform 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. Returns ------- y : ndarray of shape (n_samples,) 1 for inliers, -1 for outliers. )rrrr!r!r"rszOutlierMixin.fit_predict)N)rhrdrrrrr!r!r!r"rsrc@seZdZdgZdS)MetaEstimatorMixinr N)rhrdrZ_required_parametersr!r!r!r"rsrc@seZdZdZddZdS)MultiOutputMixinz2Mixin to mark estimators that support multioutput.cCsddiS)NZ multioutputTr!rCr!r!r"rszMultiOutputMixin._more_tagsNrhrdrrrr!r!r!r"rsrc@seZdZdZddZdS)_UnstableArchMixinz=Mark estimators that are non-determinstic on 32bit or PowerPCcCsdtptdiS)NZnon_deterministic)ppcZpowerpc)rplatformmachinererCr!r!r"rs  z_UnstableArchMixin._more_tagsNrr!r!r!r"rsrcCst|dddkS)aReturn 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. rNrrIr r!r!r" is_classifier&s rcCst|dddkS)a Return 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. rNrrrr!r!r" is_regressor6s rcCst|dddkS)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. rNrrrr!r!r"is_outlier_detectorFs rcsfdd}|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. cstfdd}|S)Nc sbtd}jdkot|}|s,|s,|tp4|d|f||W5QRSQRXdS)Nskip_parameter_validationZ partial_fit)r)rrhrrr)r argsrZglobal_skip_validationZpartial_fit_and_fitted) fit_methodprefer_skip_nested_validationr!r"wrapperos z0_fit_context..decorator..wrapper) functoolswraps)rrr)rr" decoratornsz_fit_context..decoratorr!)rrr!rr" _fit_contextVs r);rr8rrrrzrf collectionsrnumpyrrsr_configrr exceptionsrutilsrZutils._estimator_html_reprr Zutils._metadata_requestsr Zutils._param_validationr Zutils._set_outputr Z utils._tagsrrrrrrrrrrrr#rrBrrrrrrrrrrrrrrrrr!r!r!r"sR         , ':%7N.$