3 [hU@sddlZddlZddljZddlmZmZm 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 priorN)strategy random_stateconstantcCs||_||_||_dS)N)rrr)selfrrrr5/tmp/pip-build-zwgx3nbq/scikit-learn/sklearn/dummy.py__init__aszDummyClassifier.__init__csd}|j|kr td|j|f|j|_|jdkrPtj|rP|j}tjdttj||_ |j svt j |}t j |}|j dkrt j|d}|jd|_d |_t|||d k rt||}|jdkr|jd krtd n4t jt j |jdjd |jkrtd |jt||\|_|_|_|jdkrxTt|jD]Ftfd d|jDssz&DummyClassifier.fit..zrThe constant target value must be present in the training data. You provided constant={}. Possible values are: {}.)rrrrr)r!rr!)r!r)r ValueError _strategyspissparseZtoarraywarningswarn UserWarningsparse_output_npZasarrayZ atleast_1dndimreshapeshape n_outputs_n_features_in_r r rrclasses_ n_classes_ class_prior_rangeanyformatlist)rXy sample_weightallowed_strategieserr_msgr)rrrfithsP                   zDummyClassifier.fitcst|t|t|j|j|j|j|j}|jdkrTggg|g}|j dkrx|j ||jdkrxg|j rd}|j dkrddDn<|j dkr}n,|j dkrt d n|j d krd d|Dt ||j}n|j dkrtjfd dt|jDdg}n|j dkrNtjfd dt|jDj}nV|j dkrfddt|jD}tj|j}n|j d krtj|jdf}|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. rrNrrcSsg|]}tj|jgqSr)r*arrayargmax)rcprrr sz+DummyClassifier.predict..rzCSparse target prediction is not supported with the uniform strategyrcSsg|]}tj|gqSr)r*r=)rrrrrr@scs g|]}||jqSr)r>)rr)r2r0rrr@scs$g|]}||jddqS)r)axis)r>)rr)r0probarrr@scs&g|]}|j|dqS))size)randint)rr)r0r1 n_samplesrsrrr@s)rr)rr)r rrrr1r0r2rr.r# predict_probar)r"r r*Ztiler3ZvstackTravel)rr7rZ class_probr8retr)r2r0r1rErBrFrpredictsV                  zDummyClassifier.predictc Cst|t|}t|j}|j}|j}|j}|j}|jdkrT|g}|g}|g}|g}g}x(t |jD]} |j dkr|| j } t j ||| ft jd} d| dd| f<n|j dkrt j|df|| } n|j dkr|jd|| |d} | jt j} n||j d kr,t j||| ft jd} | || } nJ|j d krvt j|| || k} t j ||| ft jd} d| dd| f<|j| qfW|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. rr)dtypeg?Nrr)rCrrr)r rrrr1r0r2rr.r3r#r>r*zerosZfloat64ZonesZ multinomialZastypewhereappend) rr7rErFr1r0r2rPrindoutrrrrGsD         zDummyClassifier.predict_probacCs0|j|}|jdkrtj|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|]}tj|qSr)r*log)rprrrr@[sz5DummyClassifier.predict_log_proba..N)rGr.r*rS)rr7rBrrrpredict_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_checksr)rrrr _more_tags]szDummyClassifier._more_tagscs,|dkrtjt|dfd}tj|||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. Nr)r-)r*rMlensuperscore)rr7r8r9) __class__rrr[hszDummyClassifier.score)N)N) __name__ __module__ __qualname____doc__rrr<rKrGrUrXr[ __classcell__rr)r\rrsI 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 meanN)rrquantilecCs||_||_||_dS)N)rrrd)rrrrdrrrrszDummyRegressor.__init__csd}|j|kr td|j|ftddd|_td krFtd jd kr\tjdjd |_ t |dk rt ||jdkrtj d d |_ n8|jdkrdkrtjd d |_ nfddt|j D|_ n|jdkrf|jdkstj|j rtd|j|jddkrFtjd d|_ nfddt|j D|_ nx|jdkr|jdkrtdt|jdddgdd d|_|j d kr|jjd jd krtdjd |j|_ tj|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 rcmedianrdrz.Unknown strategy type: %s, expected one of %s.F) ensure_2dNrzy must not be empty.r)rAweights)rAcs&g|]}tdd|fddqS)NgI@) percentile)r)rr)r9r8rrr@sz&DummyRegressor.fit..z>Quantile must be a scalar in the range [0.0, 1.0], but got %s.gY@)rAqcs&g|]}tdd|fdqS)N)rh)r)rr)rhr9r8rrr@szMConstant target value has to be specified when the constant strategy is used.ZcsrZcscZcoo)Z accept_sparserfZensure_min_samplesz0Constant target value should have shape (%d, 1).)rcrerdrr!)r!rr!)rr!)rr"r r/rYr+r*r,r-r.r r Zaverage constant_rer3rdZisscalarrhr TypeError)rr7r8r9r:r)rhr9r8rr<sV                  $zDummyRegressor.fitFcCspt|t|}tj||jf|jtj|jjd}tj||jf}|jdkr`tj |}tj |}|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. )rLr) r rr*fullr.rjr=rLrMrI)rr7Z return_stdrEr8Zy_stdrrrrKs   zDummyRegressor.predictcCs dddS)NT)rVrWr)rrrrrX9szDummyRegressor._more_tagscs,|dkrtjt|dfd}tj|||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. Nr)r-)r*rMrYrZr[)rr7r8r9)r\rrr[<szDummyRegressor.score)N)F)N) r]r^r_r`rrr<rKrXr[rarr)r\rrbs7 P $rb)r&Znumpyr*Z scipy.sparsesparser$baserrrrutilsrZutils.validationrr r r r Z utils.randomr Z utils.statsrZutils.multiclassrrrrbrrrrs"          r