:i_SrSSKrSSKJrJr SSKrSSKJr SSK J r J r J r JrJr SSKJr SSKJrJr SSKJr SS KJr SS KJr SS KJrJrJrJrJ r "S S \ \ \ 5r!"SS\ \\ 5r"g)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_fittedc^\rSrSr%Sr\"1Sk5/S/\\SS/S.r\ \ S'S SSS.S jr \ "S S 9SS j5r SrSrSrSrSU4SjjrSrU=r$)DummyClassifier#aDummyClassifier 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_constraintsrc(XlX lX0lgNr )selfr!rrs P/srv/projetos/modelo_ml_acdoc/venv/lib/python3.13/site-packages/sklearn/dummy.py__init__DummyClassifier.__init__s ( Tprefer_skip_nested_validationct^^URUSS9 URUlURS:XaF[R"U5(a+UR 5n[ R"S[5 [R"U5Ul UR(d,[R"U5n[R"U5nURS:Xa[R"US5nURSUl[#X5 Ub [%X15nURS:XaUR&c [)S5e[R"[R"UR&5S5mTRS UR :wa[)S UR -5e[+X#5uUlUlUlURS:Xa[3UR 5Hmm[5UU4S jUR,T55(aM-S R7UR&UR,TR955n[)U5e UR S:Xa<UR.S UlUR,S UlUR0S UlU$) a^Fit 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. Fcast_to_ndarrayrzA 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.rrrMConstant target value has to be specified when the constant strategy is used.r0Constant target value should have shape (%d, 1).c3:># UHnTTSU:Hv M g7f)rN).0crks r& &DummyClassifier.fit..s I8H18A;q>Q.8HszrThe constant target value must be present in the training data. You provided constant={}. Possible values are: {}.)_validate_datar! _strategyspissparsetoarraywarningswarn UserWarningsparse_output_npasarray atleast_1dndimreshapeshape n_outputs_rrr ValueErrorrclasses_ n_classes_ class_prior_rangeanyformattolist)r%Xy sample_weighterr_msgrr7s @@r&fitDummyClassifier.fits'( Au5 >>Y &2;;q>> A MM+  !kk!n"" 1 A a A 66Q; 1g&A''!*%  $0BM >>Z '}}$ : ::bmmDMM&BGL>>!$7$J//* ?Q ? ;): >>Z '4??+I a8HIII3396 MM4==+;+B+B+D4%W--, ??a "ooa0DO MM!,DM $ 1 1! 4D  r)c ^[U5 [U5n[UR5nURnUR nUR nURnURS:Xa U/nU/nU/nU/nURS:Xa$URU5nURS:XaU/nUR(aSn URS;a6UV s/sH(n [R"U R5/5PM* nn OeURS:XaUn ORURS:Xa [S5eURS:Xa'UV s/sHn [R"U /5PM nn [!X%XR5n U $URS;aT[R""[%UR5V s/sHn X]XmR5PM sn US/5n GOURS:XaZ[R&"[%UR5V s/sHn X]WU RSS9PM sn 5R(n OURS:Xa[[%UR5V s/sHn X]UR+XMUS 9PM nn [R&"U5R(n O3URS:Xa#[R""URUS45n URS:Xa[R,"W 5n W $s sn fs sn fs sn fs sn fs sn f) zPerform 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. rrN)rrrzCSparse target prediction is not supported with the uniform strategyraxissize)rrr rrLrKrMrrIr; predict_probarBrCarrayargmaxrJrtilerNvstackTrandintravel)r%rR n_samplesrsrLrKrMrproba class_probcpr6rSr7rets r&predictDummyClassifier.predicts !O  1 1 2__ ==(( == ??a $J zH(>L zH >>\ )&&q)E!#   J~~!;;>JKlBHHbiik]3lK</) 9, : :-3;<8aBHHaSM8<"9 DUDUVA@=~~!;;GG"'t!7!7A! LO$:$:$<=!7N </II"'t!7!7A! E!HOOO$;:!#HHQK]L= s/L!L9!L !L%7!L*cB[U5 [U5n[UR5nURnUR nUR nURnURS:Xa U/nU/nU/nU/n/n[UR5GHvn URS:XaDXiR5n [R"X$U 4[RS9n SU SS2U 4'GO URS:Xa[R"US45Xi-n OURS:Xa3UR!SXiUS9n U R#[R5n OURS :Xa/[R"X$U 4[RS9n XU -n O]URS :XaM[R$"XYXy:H5n [R"X$U 4[RS9n SU SS2U 4'UR'W 5 GMy URS:XaUS nU$) aj 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. rrdtype?Nrrr[rrr)rrr rrLrKrMrrIrNr;r_rCzerosfloat64ones multinomialastypewhereappend) r%rRrerfrLrKrMrPr7indouts r&r]DummyClassifier.predict_probaTs !O  1 1 2__ ==(( == ??a $J zH(>L zH t'A~~0"o,,.hh a=9L!AsF 7*ggy!n- ?</nnQ inHjj,9,ggyQ-8 K!}$:-hhx{hk9:hh a=9L!AsF HHSM+(. ??a !Ar)cURU5nURS:Xa[R"U5$UVs/sHn[R"U5PM sn$s snf)az 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)r]rIrClog)r%rRrgps r&predict_log_proba!DummyClassifier.predict_log_probasN ""1% ??a 66%= ',-u!BFF1Iu- --s AcSSSSS.S.$)NTzfails for the predict method)check_methods_subset_invariance%check_methods_sample_order_invariance) poor_score no_validation _xfail_checksr4r%s r& _more_tagsDummyClassifier._more_tagss!3Q9W  r)ch>Uc[R"[U5S4S9n[TU]XU5$)aReturn 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. rrHrCrqlensuperscorer%rRrSrT __class__s r&rDummyClassifier.scores12 9A{+Aw}Q=11r)) r;rMrKrrLrIrrBr!r$)__name__ __module__ __qualname____firstlineno____doc__r rstrr"dict__annotations__r'r rVrkr]rrr__static_attributes__ __classcell__rs@r&rr#sof V W ((sL$7 $D$+! 5X6XtUn=~., 22r)rc ^\rSrSr%Sr\"1Sk5/\"\SSSS9S/\"\SSS S9S S/S .r\ \ S 'S SSS.Sjr \ "SS9SSj5r SSjrSrSU4SjjrSrU=r$)DummyRegressoriaRegressor 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 >meanmedianrquantilegrpboth)closedNneitherr)r!rrr"rr!rrc(XlX lX0lgr$r)r%r!rrs r&r'DummyRegressor.__init__s   r)Tr*c URUSS9 [USSS9n[U5S:Xa [S5eURS:Xa[ R "US5nURSUl[XU5 Ub [X15nURS :Xa[ R"USUS 9Ul GOURS :Xa\Uc[ R"USS 9Ul GOh[UR5Vs/sHn[!US S 2U4USS9PM snUl GO+URS:XaUR"c [S5eUR"S-nUc[ R$"USUS9Ul O[UR5Vs/sHn[!US S 2U4X5S9PM snUl OURS:XaUR&c [)S5e[UR&/SQSSS9Ul URS:waEURRSURS:wa[SURS-5e[ R "URS5Ul U$s snfs snf)aPFit the random 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. Fr-rS) ensure_2d input_namerzy must not be empty.rr/Nr)rZweightsrrYgI@) percentilerz^When using `strategy='quantile', you have to specify the desired quantile in the range [0, 1].gY@)rZqrr1)csrcsccoo) accept_sparserensure_min_samplesr2)rr0)r:rrrJrFrCrGrHrIrrr!average constant_rrNrrrr TypeError)r%rRrSrTr7rs r&rVDummyRegressor.fit"sF( Au5 Us ; q6Q;34 4 66Q; 1g&A''!*m4  $0BM ==F "ZZ=IDN ]]h &$!#11!5#4??3"3)1a4-DQ3" ]]j (}}$ 4.J$!#qqJ!G#4??3"3)1a4-W3" ]]j (}}$: ) 3#$ DN!#(<(I7I<c[U5 [U5n[R"X0R4UR [R "UR 5RS9n[R"X0R45nURS:Xa,[R"U5n[R"U5nU(aXE4$U$)aPerform classification on test vectors X. Parameters ---------- X : array-like of shape (n_samples, n_features) Test data. return_std : bool, default=False Whether to return the standard deviation of posterior prediction. All zeros in this case. .. versionadded:: 0.20 Returns ------- y : array-like of shape (n_samples,) or (n_samples, n_outputs) Predicted target values for X. y_std : array-like of shape (n_samples,) or (n_samples, n_outputs) Standard deviation of predictive distribution of query points. rnr) rrrCfullrIrr^rorqrd)r%rR return_stdrerSy_stds r&rkDummyRegressor.predictvs,  O GG  ( NN((4>>*00  )__56 ??a  AHHUOE'z.Q.r)c SSS.$)NT)rrr4rs r&rDummyRegressor._more_tagss "T::r)ch>Uc[R"[U5S4S9n[TU]XU5$)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. rrrrs r&rDummyRegressor.scores1: 9A{+Aw}Q=11r))rrrIrr!r$)F)rrrrrr r rr"rrr'r rVrkrrrrrs@r&rrs?D JKLdCVrsb<"&90,-k2&k2\ m2%~}m2r)