lriF_dZddlZddlmZmZddlZddlmZ ddl m Z m Z m Z mZmZddlmZddlmZmZddlmZddlmZdd lmZdd lmZmZmZmZm Z m!Z!Gd d e e e Z"Gd de ee Z#dS)z6Dummy estimators that implement simple rules of thumb.N)IntegralReal) BaseEstimatorClassifierMixinMultiOutputMixinRegressorMixin _fit_context)check_random_state)Interval StrOptions)class_distribution)_random_choice_csc)_weighted_percentile)_check_sample_weight _num_samples check_arraycheck_consistent_lengthcheck_is_fitted validate_dataceZdZUdZehdgdgeeddgdZee d<ddddd Z e d dd Z d Z dZdZfdZdfd ZxZS)DummyClassifiera]DummyClassifier makes predictions that ignore the input features. This classifier serves as a simple baseline to compare against other more complex classifiers. The specific behavior of the baseline is selected with the `strategy` parameter. All strategies make predictions that ignore the input feature values passed as the `X` argument to `fit` and `predict`. The predictions, however, typically depend on values observed in the `y` parameter passed to `fit`. Note that the "stratified" and "uniform" strategies lead to non-deterministic predictions that can be rendered deterministic by setting the `random_state` parameter if needed. The other strategies are naturally deterministic and, once fit, always return the same constant prediction for any value of `X`. Read more in the :ref:`User Guide `. .. versionadded:: 0.13 Parameters ---------- strategy : {"most_frequent", "prior", "stratified", "uniform", "constant"}, default="prior" Strategy to use to generate predictions. * "most_frequent": the `predict` method always returns the most frequent class label in the observed `y` argument passed to `fit`. The `predict_proba` method returns the matching one-hot encoded vector. * "prior": the `predict` method always returns the most frequent class label in the observed `y` argument passed to `fit` (like "most_frequent"). ``predict_proba`` always returns the empirical class distribution of `y` also known as the empirical class prior distribution. * "stratified": the `predict_proba` method randomly samples one-hot vectors from a multinomial distribution parametrized by the empirical class prior probabilities. The `predict` method returns the class label which got probability one in the one-hot vector of `predict_proba`. Each sampled row of both methods is therefore independent and identically distributed. * "uniform": generates predictions uniformly at random from the list of unique classes observed in `y`, i.e. each class has equal probability. * "constant": always predicts a constant label that is provided by the user. This is useful for metrics that evaluate a non-majority class. .. versionchanged:: 0.24 The default value of `strategy` has changed to "prior" in version 0.24. random_state : int, RandomState instance or None, default=None Controls the randomness to generate the predictions when ``strategy='stratified'`` or ``strategy='uniform'``. Pass an int for reproducible output across multiple function calls. See :term:`Glossary `. constant : int or str or array-like of shape (n_outputs,), default=None The explicit constant as predicted by the "constant" strategy. This parameter is useful only for the "constant" strategy. Attributes ---------- classes_ : ndarray of shape (n_classes,) or list of such arrays Unique class labels observed in `y`. For multi-output classification problems, this attribute is a list of arrays as each output has an independent set of possible classes. n_classes_ : int or list of int Number of label for each output. class_prior_ : ndarray of shape (n_classes,) or list of such arrays Frequency of each class observed in `y`. For multioutput classification problems, this is computed independently for each output. n_features_in_ : int Number of features seen during :term:`fit`. feature_names_in_ : ndarray of shape (`n_features_in_`,) Names of features seen during :term:`fit`. Defined only when `X` has feature names that are all strings. n_outputs_ : int Number of outputs. sparse_output_ : bool True if the array returned from predict is to be in sparse CSC format. Is automatically set to True if the input `y` is passed in sparse format. See Also -------- DummyRegressor : Regressor that makes predictions using simple rules. Examples -------- >>> import numpy as np >>> from sklearn.dummy import DummyClassifier >>> X = np.array([-1, 1, 1, 1]) >>> y = np.array([0, 1, 1, 1]) >>> dummy_clf = DummyClassifier(strategy="most_frequent") >>> dummy_clf.fit(X, y) DummyClassifier(strategy='most_frequent') >>> dummy_clf.predict(X) array([1, 1, 1, 1]) >>> dummy_clf.score(X, y) 0.75 >prioruniformconstant stratified most_frequent random_state array-likeNstrategyrr_parameter_constraintsrc0||_||_||_dSNr)selfr rrs m/var/www/html/bestrading.cuttalo.com/services/ml-inference/venv/lib/python3.11/site-packages/sklearn/dummy.py__init__zDummyClassifier.__init__s  (  Tprefer_skip_nested_validationct||d|j|_|jdkrBtj|r.|}t jdttj||_ |j s(tj |}tj |}|j dkrtj|d}|jd|_t#|||t%||}|jdkro|jt)d tjtj |jdjd |jkrt)d |jzt+||\|_|_|_|jdkrt3|jD]pt5fd |jDsGd |j|j}t)|q|jdkr6|jd |_|jd |_|jd |_|S)aFit the baseline classifier. Parameters ---------- X : array-like of shape (n_samples, n_features) Training data. y : array-like of shape (n_samples,) or (n_samples, n_outputs) Target values. sample_weight : array-like of shape (n_samples,), default=None Sample weights. Returns ------- self : object Returns the instance itself. Tskip_check_arrayrzA local copy of the target data has been converted to a numpy array. Predicting on sparse target data with the uniform strategy would not save memory and would be slower.r-NrMConstant target value has to be specified when the constant strategy is used.r0Constant target value should have shape (%d, 1).c3<K|]}d|kVdS)rN).0crks r% z&DummyClassifier.fit..s0II18A;q>Q.IIIIIIr'zrThe constant target value must be present in the training data. You provided constant={}. Possible values are: {}.)rr _strategyspissparsetoarraywarningswarn UserWarningsparse_output_npasarray atleast_1dndimreshapeshape n_outputs_rrr ValueErrorr classes_ n_classes_ class_prior_rangeanyformattolist)r$Xy sample_weighterr_msgrr6s @@r%fitzDummyClassifier.fitsr( dA5555 >Y & &2;q>> & A M+    !k!nn" ! 1 A a  A 6Q;; 1g&&A'!*1%%%  $0BBM >Z ' '}$ : :bmDM&B&BGLL>!$77$J/* ?Q }? ? ;): >Z ' '4?++ . .IIIII a8HIIIII .3396 M4=+;+B+B+D+D44%W--- . ?a  "oa0DO M!,DM $ 1! 4D  r'cJ t|t| t|j |j|j|j|j}|jdkr ggg|g}|j dkr#| | |jdkr g |j rpd}|j dvr dDn?|j dkr}n1|j dkrtd|j dkr d |Dt ||j}n|j dvr7tjfd t!|jD dg}n|j dkr9tj fd t!|jDj}no|j dkr= fd t!|jD}tj|j}n'|j dkrtj|j df}|jdkrtj|}|S) a;Perform classification on test vectors X. Parameters ---------- X : array-like of shape (n_samples, n_features) Test data. Returns ------- y : array-like of shape (n_samples,) or (n_samples, n_outputs) Predicted target values for X. r-rN)rrc\g|])}tj|g*Sr3)r@arrayargmax)r4cps r% z+DummyClassifier.predict..#s,KKKBHbiikk]33KKKr'rzCSparse target prediction is not supported with the uniform strategyrc8g|]}tj|gSr3)r@rV)r4r5s r%rYz+DummyClassifier.predict../s"<<.5sB! LO$:$:$<$<=r'c`g|]*}||d+S)r-axisr\)r4r6rHprobas r%rYz+DummyClassifier.predict..>sD! E!HOOO$;$;<r'cbg|]+}||,S)size)randint)r4r6rHrI n_samplesrss r%rYz+DummyClassifier.predict..EsFQK :a=y I IJr')rrr rrIrHrJrrFr8 predict_probar?rGrr@tilerKvstackTravel) r$rOr class_probrPretrJrHrIrer`rfs @@@@@@r%predictzDummyClassifier.predicts !OO  1 2 2_ =( = ?a  $J zH(>L zH >\ ) )&&q))E!##  / J~!;;;KKlKKK<//) 9,, : :--<<8<<<"9h DDUVVAA~!;;;G!&t!7!7N <//I!&t!7!7  9,,"4?33IcNN$:--GDMIq>::!##HQKKr'c,t|t|}t|j}|j}|j}|j}|j}|jdkr |g}|g}|g}|g}g}t|jD]} |j dkrM||  } tj ||| ftj} d| dd| f<n|j dkr tj|df|| z} n|j dkr>|d|| |} | tj} n|j d kr4tj||| ftj} | || z} n`|j d krUtj|| || k} tj ||| ftj} d| dd| f<|| |jdkr|d }|S) a Return probability estimates for the test vectors X. Parameters ---------- X : array-like of shape (n_samples, n_features) Test data. Returns ------- P : ndarray of shape (n_samples, n_classes) or list of such arrays Returns the probability of the sample for each class in the model, where classes are ordered arithmetically, for each output. r-rdtype?Nrrrbrrr)rrr rrIrHrJrrFrKr8rWr@zerosfloat64ones multinomialastypewhereappend) r$rOrerfrIrHrJrPr6indouts r%rgzDummyClassifier.predict_probaSs !OO  1 2 2_ =( = ?a  $J zH(>L zH t''  A~00"1o,,..h :a=9LLL!AAAsF 7**gy!n-- Q?<//nnQ QinHHjj,,9,,gy*Q-8 KKKz!}$:--hx{hqk9::h :a=9LLL!AAAsF HHSMMMM ?a  !Ar'c||}|jdkrtj|Sd|DS)a Return log probability estimates for the test vectors X. Parameters ---------- X : {array-like, object with finite length or shape} Training data. Returns ------- P : ndarray of shape (n_samples, n_classes) or list of such arrays Returns the log probability of the sample for each class in the model, where classes are ordered arithmetically for each output. r-c6g|]}tj|Sr3)r@log)r4ps r%rYz5DummyClassifier.predict_log_proba..s ---!BF1II---r')rgrFr@r)r$rOr`s r%predict_log_probaz!DummyClassifier.predict_log_probasF ""1%% ?a  6%== --u--- -r'ct}d|j_d|j_d|_|SNT)super__sklearn_tags__ input_tagssparseclassifier_tags poor_score no_validationr$tags __class__s r%rz DummyClassifier.__sklearn_tags__s:ww''))!%*.'! r'c|$tjt|df}t|||S)akReturn 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 : None or array-like of shape (n_samples, n_features) Test samples. Passing None as test samples gives the same result as passing real test samples, since DummyClassifier operates independently of the sampled observations. 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. Nr-rEr@rslenrscorer$rOrPrQrs r%rzDummyClassifier.scores@2 9A{+++Aww}}Q=111r'r#)__name__ __module__ __qualname____doc__r rstrr!dict__annotations__r&r rSrnrgrrr __classcell__rs@r%rr"s9oof JVVV W W ((sL$7 $$D$+!!!!! \555XXX65XtUUUn===~...,2222222222r'rceZdZUdZehdgeeddddgeedddd dgd Zee d <d ddd dZ e dddZ ddZ fdZdfd ZxZS)DummyRegressoraRegressor that makes predictions using simple rules. This regressor is useful as a simple baseline to compare with other (real) regressors. Do not use it for real problems. Read more in the :ref:`User Guide `. .. versionadded:: 0.13 Parameters ---------- strategy : {"mean", "median", "quantile", "constant"}, default="mean" Strategy to use to generate predictions. * "mean": always predicts the mean of the training set * "median": always predicts the median of the training set * "quantile": always predicts a specified quantile of the training set, provided with the quantile parameter. * "constant": always predicts a constant value that is provided by the user. constant : int or float or array-like of shape (n_outputs,), default=None The explicit constant as predicted by the "constant" strategy. This parameter is useful only for the "constant" strategy. quantile : float in [0.0, 1.0], default=None The quantile to predict using the "quantile" strategy. A quantile of 0.5 corresponds to the median, while 0.0 to the minimum and 1.0 to the maximum. Attributes ---------- constant_ : ndarray of shape (1, n_outputs) Mean or median or quantile of the training targets or constant value given by the user. n_features_in_ : int Number of features seen during :term:`fit`. feature_names_in_ : ndarray of shape (`n_features_in_`,) Names of features seen during :term:`fit`. Defined only when `X` has feature names that are all strings. n_outputs_ : int Number of outputs. See Also -------- DummyClassifier: Classifier that makes predictions using simple rules. Examples -------- >>> import numpy as np >>> from sklearn.dummy import DummyRegressor >>> X = np.array([1.0, 2.0, 3.0, 4.0]) >>> y = np.array([2.0, 3.0, 5.0, 10.0]) >>> dummy_regr = DummyRegressor(strategy="mean") >>> dummy_regr.fit(X, y) DummyRegressor() >>> dummy_regr.predict(X) array([5., 5., 5., 5.]) >>> dummy_regr.score(X, y) 0.0 >meanmedianrquantilegrrboth)closedNneitherr)r rrr!rr rrc0||_||_||_dSr#r)r$r rrs r%r&zDummyRegressor.__init__s      r'Tr(c&t||dt|dd}t|dkrtd|jdkrt j|d }|jd|_t||||t||}|j d krt j |d| |_ n-|j d kr7|t j|d|_ nt||d|_ n|j dkrW|jtd|jdz}|t j|d||_ nt||||_ n|j dkr~|jt'dt|jgddd|_ |jdkr>|j jd|jdkrtd|jdzt j|j d|_ |S)aFit the baseline regressor. Parameters ---------- X : array-like of shape (n_samples, n_features) Training data. y : array-like of shape (n_samples,) or (n_samples, n_outputs) Target values. sample_weight : array-like of shape (n_samples,), default=None Sample weights. Returns ------- self : object Fitted estimator. Tr+FrP) ensure_2d input_namerzy must not be empty.r-r.Nr)r_weightsrr^gI@)percentile_rankrz^When using `strategy='quantile', you have to specify the desired quantile in the range [0, 1].gY@)r_qrr0)csrcsccoo) accept_sparserensure_min_samplesr1)r-r/)rrrrGrCr@rDrErFrrr average constant_rrr percentiler TypeError)r$rOrPrQrs r%rSzDummyRegressor.fitsG( dA5555 Us ; ; ; q66Q;;344 4 6Q;; 1g&&A'!*1m444  $0BBM =F " "Z=IIIDNN ]h & &$!#11!5!5!5!5}d"""]j ( (}$ 4#me3O$!#qqO!L!L!L!5}o"""]j ( (}$: ) 333#$ DN!##(**0    )T_566 ?a   AHUOOE'.5zzQ.r'ct}d|j_d|j_d|_|Sr)rrrrregressor_tagsrrrs r%rzDummyRegressor.__sklearn_tags__s:ww''))!%)-&! r'c|$tjt|df}t|||S)aReturn the coefficient of determination R^2 of the prediction. The coefficient R^2 is defined as `(1 - u/v)`, where `u` is the residual sum of squares `((y_true - y_pred) ** 2).sum()` and `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 R^2 score of 0.0. Parameters ---------- X : None or array-like of shape (n_samples, n_features) Test samples. Passing None as test samples gives the same result as passing real test samples, since `DummyRegressor` operates independently of the sampled observations. 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 R^2 of `self.predict(X)` w.r.t. y. Nr-rrrs r%rzDummyRegressor.scores@: 9A{+++Aww}}Q=111r'r#)F)rrrrr r rr!rrr&r rSrnrrrrs@r%rrs@??D Z J J JKKLXdCV<<rs<< """"""""-,,,,,@@@@@@@@777777333333444444h2h2h2h2h2&h2h2h2V o2o2o2o2o2%~}o2o2o2o2o2r'