U !`U@sddlZddlZddlmZddlmZmZm Z ddlm Z ddl m Z ddl mZddl mZddl mZdd l mZmZdd lmZdd lmZdd lmZdd l mZGddde eeZGddde e eZdS)N) BaseEstimatorClassifierMixinRegressorMixin)MultiOutputMixin)check_random_state) _num_samples) check_array)check_consistent_length)check_is_fitted_check_sample_weight)_random_choice_csc_weighted_percentile)class_distribution)_deprecate_positional_argscsbeZdZdZeddddddZdddZd d Zd d Zd dZ ddZ dfdd Z Z S)DummyClassifiera DummyClassifier is a classifier that makes predictions using simple rules. This classifier is useful as a simple baseline to compare with other (real) classifiers. Do not use it for real problems. Read more in the :ref:`User Guide `. .. versionadded:: 0.13 Parameters ---------- strategy : {"stratified", "most_frequent", "prior", "uniform", "constant"}, default="prior" Strategy to use to generate predictions. * "stratified": generates predictions by respecting the training set's class distribution. * "most_frequent": always predicts the most frequent label in the training set. * "prior": always predicts the class that maximizes the class prior (like "most_frequent") and ``predict_proba`` returns the class prior. * "uniform": generates predictions uniformly at random. * "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,) 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 Class labels for each output. 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 Probability of each class for each output. 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. 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 priorNstrategy random_stateconstantcCs||_||_||_dSNr)selfrrrr,lib/python3.8/site-packages/sklearn/dummy.py__init__aszDummyClassifier.__init__csd}|j|kr td|j|f|j|_|jdkrPt|rP|}tdtt||_ |j svt |}t |}|j dkrt |d}|jd|_d|_t|||dk rt||}|jdkr|jdkrtd n4t t |jdjd |jkrtd |jt||\|_|_|_|jdkrt|jD]Ftfd d |jDs:d|jt|j}t|q:|jdkr|jd |_|jd |_|jd |_|S)aFit the random 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 ) most_frequent stratifieduniformrr.Unknown strategy type: %s, expected one of %s.rzA 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.rrNrMConstant target value has to be specified when the constant strategy is used.r0Constant target value should have shape (%d, 1).c3s|]}d|kVqdS)rNr.0crkrr sz&DummyClassifier.fit..zrThe constant target value must be present in the training data. You provided constant={}. Possible values are: {}.)r ValueError _strategyspZissparseZtoarraywarningswarn UserWarningsparse_output_npZasarrayZ atleast_1dndimreshapeshape n_outputs_n_features_in_r r rrclasses_ n_classes_ class_prior_rangeanyformatlist)rXy sample_weightallowed_strategieserr_msgrr(rfiths^                    zDummyClassifier.fitcst|t|t|j|j|j|j|j}|jdkrTggg|g}|j dkrx| ||jdkrxg|j rd}|j dkrddDn<|j dkr}n,|j dkrt dn|j d krd d|Dt ||j}n|j dkrtfd dt|jDdg}n|j dkrNtfd dt|jDj}nV|j dkrfd dt|jD}t|j}n|j d krt|jdf}|jdkrt|}|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. rrN)rrcSsg|]}t|gqSr)r2arrayargmax)r&Zcprrr sz+DummyClassifier.predict..rzCSparse target prediction is not supported with the uniform strategyrcSsg|]}t|gqSr)r2rEr%rrrrGscs g|]}||qSrrFr&r))r:r8rrrGscs$g|]}||jddqS)raxisrHrI)r8probarrrGscs&g|]}|j|dqS)size)ZrandintrI)r8r9 n_samplesrsrrrGs)r rrrr9r8r:rr6r, predict_probar1r+r r2Ztiler;ZvstackTravel)rr?rZ class_probr@Zretr)r:r8r9rOrLrPrpredictsb                  zDummyClassifier.predictc Cst|t|}t|j}|j}|j}|j}|j}|jdkrT|g}|g}|g}|g}g}t |jD]} |j dkr||  } t j ||| ft jd} d| dd| f<n|j dkrt |df|| } n|j dkr|jd|| |d} | t j} n||j d kr(t j||| ft jd} | || } nJ|j d krrt || || k} t j ||| ft jd} d| dd| f<|| qb|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. rrdtypeg?NrrrMrrr)r rrrr9r8r:rr6r;r,rFr2zerosZfloat64ZonesZ multinomialZastypewhereappend) rr?rOrPr9r8r:rPr)ZindoutrrrrQsD          zDummyClassifier.predict_probacCs0||}|jdkrt|Sdd|DSdS)a Return log probability estimates for the test vectors X. Parameters ---------- X : {array-like, object with finite length or shape} Training data, requires length = n_samples 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. rcSsg|]}t|qSr)r2log)r&prrrrG[sz5DummyClassifier.predict_log_proba..N)rQr6r2r\)rr?rLrrrpredict_log_probaGs   z!DummyClassifier.predict_log_probacCsddddddS)NTzfails for the predict method)Zcheck_methods_subset_invarianceZ%check_methods_sample_order_invariance) poor_score no_validationZ _xfail_checksrrrrr _more_tags]s zDummyClassifier._more_tagscs,|dkrtjt|dfd}t|||S)akReturns 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) wrt. y. Nrr5r2rWlensuperscorerr?r@rA __class__rrrghszDummyClassifier.score)N)N) __name__ __module__ __qualname____doc__rrrDrTrQr^rbrg __classcell__rrrirrsI UK? rcsTeZdZdZeddddddZdddZdd d Zd d Zdfdd Z Z S)DummyRegressoraQ DummyRegressor is a regressor 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_outputs_ : int Number of outputs. 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 meanNrrquantilecCs||_||_||_dSrrr)rrrrsrrrrszDummyRegressor.__init__csd}|j|kr td|j|ftddd|_tdkrFtdjdkr\td jd|_ t |dk rt ||jd krtj dd |_ n6|jd krdkrtjdd |_ nfddt|j D|_ n|jdkrd|jdkst|jstd|j|jddkrDtjdd|_ nfddt|j D|_ nx|jdkr|jdkrtdt|jdddgddd|_|j dkr|jjdjdkrtdjd|j|_ t|j d|_ |S)aFit 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 )rqmedianrsrr F) ensure_2dNrzy must not be empty.rr!rq)rKZweightsrtrJcs&g|]}tdd|fddqS)NgI@ percentilerrI)rAr@rrrGsz&DummyRegressor.fit..rsz>Quantile must be a scalar in the range [0.0, 1.0], but got %s.gY@)rKqcs&g|]}tdd|fdqS)NrvrrIrwrAr@rrrGsrr#ZcsrZcscZcoo)Z accept_sparseruZensure_min_samplesr$)rr")rr+r r7rer3r2r4r5r6r r Zaverage constant_rtr;rsZisscalarrwr TypeError)rr?r@rArBrryrrDsf                  $zDummyRegressor.fitFcCspt|t|}tj||jf|jt|jjd}t||jf}|jdkr`t |}t |}|rl||fS|S)a Perform 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. rUr) r rr2Zfullr6rzrErVrWrS)rr?Z return_stdrOr@Zy_stdrrrrTs    zDummyRegressor.predictcCs dddS)NT)r_r`rrarrrrb9szDummyRegressor._more_tagscs,|dkrtjt|dfd}t|||S)aReturns 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) wrt. y. Nrrcrdrhrirrrg<szDummyRegressor.score)N)F)N) rkrlrmrnrrrDrTrbrgrorrrirrps7 P $rp)r.Znumpyr2Z scipy.sparseZsparser-baserrrrZutilsrZutils.validationrr r r r Z utils.randomr Z utils.statsrZutils.multiclassrrrrprrrrs"          r