ó ‡ˆ\c@ s dZddlmZddlZddlZddlmZddlmZddlm Z ddl Z ddl m Z dd lmZdd lmZdd lmZdd lmZdd lmZddlmZddlmZddlmZddlmZddlmZddlmZddlm Z ddl!m"Z"ddl!m#Z#ddl!m$Z$ddl%m!Z!mZmZddddgZ&e!j'Z'e!j(Z(iej)d6ej*d6Z+iej,d 6ej-d!6ej.d"6Z/iej0d#6ej1d$6Z2iej3d#6ej4d$6Z5d%ej6eeƒfd&„ƒYZ7de7efd'„ƒYZ8de7efd(„ƒYZ9de8fd)„ƒYZ:de9fd*„ƒYZ;dS(+s‘ This module gathers tree-based methods, including decision, regression and randomized trees. Single and multi-output problems are both handled. iÿÿÿÿ(tdivisionN(tABCMeta(tabstractmethod(tceil(tissparsei(t BaseEstimator(tClassifierMixin(tRegressorMixin(t is_classifier(tsix(t check_array(tcheck_random_state(tcompute_sample_weight(tcheck_classification_targets(tcheck_is_fittedi(t Criterion(tSplitter(tDepthFirstTreeBuilder(tBestFirstTreeBuilder(tTree(t_treet _splittert _criteriontDecisionTreeClassifiertDecisionTreeRegressortExtraTreeClassifiertExtraTreeRegressortginitentropytmset friedman_msetmaetbesttrandomtBaseDecisionTreecB sqeZdZeeed„ƒZeeed„Zd„Z ed„Z ed„Z ed„Z e d„ƒZRS(szBase class for decision trees. Warning: This class should not be used directly. Use derived classes instead. cC sy||_||_||_||_||_||_||_| |_||_| |_ | |_ | |_ | |_ dS(N( t criteriontsplittert max_depthtmin_samples_splittmin_samples_leaftmin_weight_fraction_leaft max_featurest random_statetmax_leaf_nodestmin_impurity_decreasetmin_impurity_splitt class_weighttpresort(tselfR#R$R%R&R'R(R)R+R*R,R-R.R/((s0lib/python2.7/site-packages/sklearn/tree/tree.pyt__init__Rs            c C s„ t|jƒ}|ršt|dtddƒ}t|dtddƒ}t|ƒrš|jƒ|jj t j ks…|j j t j kr—t dƒ‚q—qšn|j\}|_t|ƒ}t j|ƒ}d} |jdkrñt j|d&ƒ}n|jd|_|rt|ƒt j|ƒ}g|_g|_|jdk rSt j|ƒ} nt j|jdt jƒ} xyt|jƒD]h} t j|dd…| fdtƒ\} | dd…| f<|jj| ƒ|jj| jd ƒq~W| }|jdk r=t |j| ƒ} q=n&dg|j|_dg|j|_t j!|jdt j"ƒ|_t#|ddƒt$ks€|j%j& r˜t j'|dt$ƒ}n|j(dkr­d(n|j(}|j)dkrËdn|j)}t*|j+t,j-t j.fƒr#d|j+kst d |j+ƒ‚n|j+}nNd |j+ko=dknsXt d |j+ƒ‚ntt/|j+|ƒƒ}t*|j0t,j-t j.fƒrÀd |j0ks´t d|j0ƒ‚n|j0}n]d |j0koÚdknsõt d|j0ƒ‚ntt/|j0|ƒƒ}t1d |ƒ}t1|d |ƒ}t*|j2t3j4ƒrÿ|j2dkrŠ|r~t1dtt j5|jƒƒƒ}qü|j}q{|j2dkr½t1dtt j5|jƒƒƒ}q{|j2dkrðt1dtt j6|jƒƒƒ}q{t dƒ‚n||j2dkr|j}nat*|j2t,j-t j.fƒrD|j2}n7|j2d krut1dt|j2|jƒƒ}nd }||_7t8|ƒ|krµt dt8|ƒ|fƒ‚nd |j9koÏdknsãt dƒ‚n|d krþt dƒ‚nd |ko|jkns,t dƒ‚nt*|t,j-t j.fƒsZt d|ƒ‚nd|koqd knrŽt dj:|ƒƒ‚n|dk r<t#|ddƒt$ks¿|j%j& r×t j'|dt$ƒ}nt8|jƒdkrt dt8|jƒƒ‚nt8|ƒ|kr<t dt8|ƒ|fƒ‚q<n| dk rj|dk ra|| }qj| }n|dkr†|j9|}n|j9t j;|ƒ}|j<dk rÇt=j>dt?ƒ|j<}nd}|d krèt d ƒ‚n|j@d krt d!ƒ‚ndttf}|jA|krBt d"j:||jAƒƒ‚n|jAtkrlt|ƒrlt d#ƒ‚n|jA}|jAdkr”t|ƒ }n|dkrÐ|rÐt jBt jC|d$d ƒdt jDƒ}n|r |j|jkr t d%j:|j|jƒƒ‚n|jE}t*|tFƒsb |rF tG|jE|j|jƒ}qb tH|jE|j|ƒ}nt|ƒrt tIntJ}|jK}t*|jKtLƒsÀ ||jK||j7||||jAƒ}ntM|j|j|jƒ|_N|d kr tO||||||j@|ƒ}n$tP|||||||j@|ƒ}|jQ|jN||||ƒ|jdkr€ |jd |_|jd |_n|S()Ntdtypet accept_sparsetcsct ensure_2ds3No support for np.int64 index based sparse matricesiiÿÿÿÿtreturn_inverseiiis:min_samples_leaf must be at least 1 or in (0, 0.5], got %sggà?s`min_samples_split must be an integer greater than 1 or a float in (0.0, 1.0]; got the integer %sgð?s^min_samples_split must be an integer greater than 1 or a float in (0.0, 1.0]; got the float %stautotsqrttlog2sSInvalid value for max_features. Allowed string values are "auto", "sqrt" or "log2".s7Number of labels=%d does not match number of samples=%ds)min_weight_fraction_leaf must in [0, 0.5]s%max_depth must be greater than zero. s'max_features must be in (0, n_features]s1max_leaf_nodes must be integral number but was %rs7max_leaf_nodes {0} must be either None or larger than 1s4Sample weights array has more than one dimension: %ds8Number of weights=%d does not match number of samples=%ds¾The min_impurity_split parameter is deprecated. Its default value will change from 1e-7 to 0 in version 0.23, and it will be removed in 0.25. Use the min_impurity_decrease parameter instead.gH¯¼šò×z>s5min_impurity_split must be greater than or equal to 0s8min_impurity_decrease must be greater than or equal to 0s,'presort' should be in {}. Got {!r} instead.s0Presorting is not supported for sparse matrices.taxiss_The shape of X (X.shape = {}) doesn't match the shape of X_idx_sorted (X_idx_sorted.shape = {})(iÿÿÿÿiI€iÿÿÿ(RR R*R tDTYPEtFalsetNoneRt sort_indicestindicesR2tnptintctindptrt ValueErrortshapet n_features_Rt atleast_1dtndimtreshapet n_outputs_R tcopytclasses_t n_classes_R.tzerostinttrangetuniquetTruetappendR tarraytintptgetattrtDOUBLEtflagst contiguoustascontiguousarrayR%R+t isinstanceR'tnumberstIntegraltintegerRR&tmaxR)R t string_typesR8R9t max_features_tlenR(tformattsumR-twarningstwarntDeprecationWarningR,R/tasfortranarraytargsorttint32R#Rt CRITERIA_CLFt CRITERIA_REGtSPARSE_SPLITTERStDENSE_SPLITTERSR$RRttree_RRtbuild(R0tXtyt sample_weightt check_inputt X_idx_sortedR*t n_samplestis_classificationtexpanded_class_weightt y_originalt y_encodedtkt classes_kR%R+R'R&R)tmin_weight_leafR-tallowed_presortR/R#t SPLITTERSR$tbuilder((s0lib/python2.7/site-packages/sklearn/tree/tree.pytfitosb  *    %    $ $$                              cC s¢|rft|dtddƒ}t|ƒrf|jjtjksT|jjtjkrftdƒ‚qfn|j d}|j |kržtd|j |fƒ‚n|S(s>Validate X whenever one tries to predict, apply, predict_probaR2R3tcsrs3No support for np.int64 index based sparse matricesishNumber of features of the model must match the input. Model n_features is %s and input n_features is %s ( R R;RR?R2R@RARBRCRDRE(R0RpRst n_features((s0lib/python2.7/site-packages/sklearn/tree/tree.pyt_validate_X_predictvs! cC sFt|dƒ|j||ƒ}|jj|ƒ}|jd}t|ƒr|jdkr~|jjt j |ddƒddƒSt j ||jfƒ}xbt |jƒD]Q}|j|jt j |dd…|fddƒddƒ|dd…|f`. Parameters ---------- criterion : string, optional (default="gini") The function to measure the quality of a split. Supported criteria are "gini" for the Gini impurity and "entropy" for the information gain. splitter : string, optional (default="best") The strategy used to choose the split at each node. Supported strategies are "best" to choose the best split and "random" to choose the best random split. max_depth : int or None, optional (default=None) The maximum depth of the tree. If None, then nodes are expanded until all leaves are pure or until all leaves contain less than min_samples_split samples. min_samples_split : int, float, optional (default=2) The minimum number of samples required to split an internal node: - If int, then consider `min_samples_split` as the minimum number. - If float, then `min_samples_split` is a fraction and `ceil(min_samples_split * n_samples)` are the minimum number of samples for each split. .. versionchanged:: 0.18 Added float values for fractions. min_samples_leaf : int, float, optional (default=1) The minimum number of samples required to be at a leaf node. A split point at any depth will only be considered if it leaves at least ``min_samples_leaf`` training samples in each of the left and right branches. This may have the effect of smoothing the model, especially in regression. - If int, then consider `min_samples_leaf` as the minimum number. - If float, then `min_samples_leaf` is a fraction and `ceil(min_samples_leaf * n_samples)` are the minimum number of samples for each node. .. versionchanged:: 0.18 Added float values for fractions. min_weight_fraction_leaf : float, optional (default=0.) The minimum weighted fraction of the sum total of weights (of all the input samples) required to be at a leaf node. Samples have equal weight when sample_weight is not provided. max_features : int, float, string or None, optional (default=None) The number of features to consider when looking for the best split: - If int, then consider `max_features` features at each split. - If float, then `max_features` is a fraction and `int(max_features * n_features)` features are considered at each split. - If "auto", then `max_features=sqrt(n_features)`. - If "sqrt", then `max_features=sqrt(n_features)`. - If "log2", then `max_features=log2(n_features)`. - If None, then `max_features=n_features`. Note: the search for a split does not stop until at least one valid partition of the node samples is found, even if it requires to effectively inspect more than ``max_features`` features. random_state : int, RandomState instance or None, optional (default=None) If int, random_state is the seed used by the random number generator; If RandomState instance, random_state is the random number generator; If None, the random number generator is the RandomState instance used by `np.random`. max_leaf_nodes : int or None, optional (default=None) Grow a tree with ``max_leaf_nodes`` in best-first fashion. Best nodes are defined as relative reduction in impurity. If None then unlimited number of leaf nodes. min_impurity_decrease : float, optional (default=0.) A node will be split if this split induces a decrease of the impurity greater than or equal to this value. The weighted impurity decrease equation is the following:: N_t / N * (impurity - N_t_R / N_t * right_impurity - N_t_L / N_t * left_impurity) where ``N`` is the total number of samples, ``N_t`` is the number of samples at the current node, ``N_t_L`` is the number of samples in the left child, and ``N_t_R`` is the number of samples in the right child. ``N``, ``N_t``, ``N_t_R`` and ``N_t_L`` all refer to the weighted sum, if ``sample_weight`` is passed. .. versionadded:: 0.19 min_impurity_split : float, (default=1e-7) Threshold for early stopping in tree growth. A node will split if its impurity is above the threshold, otherwise it is a leaf. .. deprecated:: 0.19 ``min_impurity_split`` has been deprecated in favor of ``min_impurity_decrease`` in 0.19. The default value of ``min_impurity_split`` will change from 1e-7 to 0 in 0.23 and it will be removed in 0.25. Use ``min_impurity_decrease`` instead. class_weight : dict, list of dicts, "balanced" or None, default=None Weights associated with classes in the form ``{class_label: weight}``. If not given, all classes are supposed to have weight one. For multi-output problems, a list of dicts can be provided in the same order as the columns of y. Note that for multioutput (including multilabel) weights should be defined for each class of every column in its own dict. For example, for four-class multilabel classification weights should be [{0: 1, 1: 1}, {0: 1, 1: 5}, {0: 1, 1: 1}, {0: 1, 1: 1}] instead of [{1:1}, {2:5}, {3:1}, {4:1}]. The "balanced" mode uses the values of y to automatically adjust weights inversely proportional to class frequencies in the input data as ``n_samples / (n_classes * np.bincount(y))`` For multi-output, the weights of each column of y will be multiplied. Note that these weights will be multiplied with sample_weight (passed through the fit method) if sample_weight is specified. presort : bool, optional (default=False) Whether to presort the data to speed up the finding of best splits in fitting. For the default settings of a decision tree on large datasets, setting this to true may slow down the training process. When using either a smaller dataset or a restricted depth, this may speed up the training. Attributes ---------- classes_ : array of shape = [n_classes] or a list of such arrays The classes labels (single output problem), or a list of arrays of class labels (multi-output problem). feature_importances_ : array of shape = [n_features] The feature importances. The higher, the more important the feature. The importance of a feature is computed as the (normalized) total reduction of the criterion brought by that feature. It is also known as the Gini importance [4]_. max_features_ : int, The inferred value of max_features. n_classes_ : int or list The number of classes (for single output problems), or a list containing the number of classes for each output (for multi-output problems). n_features_ : int The number of features when ``fit`` is performed. n_outputs_ : int The number of outputs when ``fit`` is performed. tree_ : Tree object The underlying Tree object. Please refer to ``help(sklearn.tree._tree.Tree)`` for attributes of Tree object and :ref:`sphx_glr_auto_examples_tree_plot_unveil_tree_structure.py` for basic usage of these attributes. Notes ----- The default values for the parameters controlling the size of the trees (e.g. ``max_depth``, ``min_samples_leaf``, etc.) lead to fully grown and unpruned trees which can potentially be very large on some data sets. To reduce memory consumption, the complexity and size of the trees should be controlled by setting those parameter values. The features are always randomly permuted at each split. Therefore, the best found split may vary, even with the same training data and ``max_features=n_features``, if the improvement of the criterion is identical for several splits enumerated during the search of the best split. To obtain a deterministic behaviour during fitting, ``random_state`` has to be fixed. See also -------- DecisionTreeRegressor References ---------- .. [1] https://en.wikipedia.org/wiki/Decision_tree_learning .. [2] L. Breiman, J. Friedman, R. Olshen, and C. Stone, "Classification and Regression Trees", Wadsworth, Belmont, CA, 1984. .. [3] T. Hastie, R. Tibshirani and J. Friedman. "Elements of Statistical Learning", Springer, 2009. .. [4] L. Breiman, and A. Cutler, "Random Forests", https://www.stat.berkeley.edu/~breiman/RandomForests/cc_home.htm Examples -------- >>> from sklearn.datasets import load_iris >>> from sklearn.model_selection import cross_val_score >>> from sklearn.tree import DecisionTreeClassifier >>> clf = DecisionTreeClassifier(random_state=0) >>> iris = load_iris() >>> cross_val_score(clf, iris.data, iris.target, cv=10) ... # doctest: +SKIP ... array([ 1. , 0.93..., 0.86..., 0.93..., 0.93..., 0.93..., 0.93..., 1. , 0.93..., 1. ]) RR iigcC sett|ƒjd|d|d|d|d|d|d|d| d | d |d | d | d | ƒ dS(NR#R$R%R&R'R(R)R+R.R*R,R-R/(tsuperRR1(R0R#R$R%R&R'R(R)R*R+R,R-R.R/((s0lib/python2.7/site-packages/sklearn/tree/tree.pyR1Üsc C s/tt|ƒj||d|d|d|ƒ|S(sëBuild a decision tree classifier from the training set (X, y). Parameters ---------- X : array-like or sparse matrix, shape = [n_samples, n_features] The training input samples. Internally, it will be converted to ``dtype=np.float32`` and if a sparse matrix is provided to a sparse ``csc_matrix``. y : array-like, shape = [n_samples] or [n_samples, n_outputs] The target values (class labels) as integers or strings. sample_weight : array-like, shape = [n_samples] or None Sample weights. If None, then samples are equally weighted. Splits that would create child nodes with net zero or negative weight are ignored while searching for a split in each node. Splits are also ignored if they would result in any single class carrying a negative weight in either child node. check_input : boolean, (default=True) Allow to bypass several input checking. Don't use this parameter unless you know what you do. X_idx_sorted : array-like, shape = [n_samples, n_features], optional The indexes of the sorted training input samples. If many tree are grown on the same dataset, this allows the ordering to be cached between trees. If None, the data will be sorted here. Don't use this parameter unless you know what to do. Returns ------- self : object RrRsRt(R‘RR€(R0RpRqRrRsRt((s0lib/python2.7/site-packages/sklearn/tree/tree.pyR€ùs $ cC s<t|dƒ|j||ƒ}|jj|ƒ}|jdkr¢|dd…d|j…f}|jddƒdd…tjf}d||dk<||}|Sg}x‰t |jƒD]x}|dd…|d|j|…f}|jddƒdd…tjf}d||dk<||}|j |ƒq¸W|SdS(sÐPredict class probabilities of the input samples X. The predicted class probability is the fraction of samples of the same class in a leaf. check_input : boolean, (default=True) Allow to bypass several input checking. Don't use this parameter unless you know what you do. Parameters ---------- X : array-like or sparse matrix of shape = [n_samples, n_features] The input samples. Internally, it will be converted to ``dtype=np.float32`` and if a sparse matrix is provided to a sparse ``csr_matrix``. check_input : bool Run check_array on X. Returns ------- p : array of shape = [n_samples, n_classes], or a list of n_outputs such arrays if n_outputs > 1. The class probabilities of the input samples. The order of the classes corresponds to that in the attribute `classes_`. RniNR:gð?g( RRƒRnR„RIRLRcR@tnewaxisRORR(R0RpRsR‡t normalizert all_probaRztproba_k((s0lib/python2.7/site-packages/sklearn/tree/tree.pyt predict_proba$s" % &% cC sd|j|ƒ}|jdkr+tj|ƒSx.t|jƒD]}tj||ƒ|| 1. The class log-probabilities of the input samples. The order of the classes corresponds to that in the attribute `classes_`. iN(R–RIR@tlogRO(R0RpR‡Rz((s0lib/python2.7/site-packages/sklearn/tree/tree.pytpredict_log_probaWs  N( RRŽRR=R<R1RQR€R–R˜(((s0lib/python2.7/site-packages/sklearn/tree/tree.pyRs$Ô  * 3c B sMeZdZddddddddddded„ Zdedd„ZRS( s¦ A decision tree regressor. Read more in the :ref:`User Guide `. Parameters ---------- criterion : string, optional (default="mse") The function to measure the quality of a split. Supported criteria are "mse" for the mean squared error, which is equal to variance reduction as feature selection criterion and minimizes the L2 loss using the mean of each terminal node, "friedman_mse", which uses mean squared error with Friedman's improvement score for potential splits, and "mae" for the mean absolute error, which minimizes the L1 loss using the median of each terminal node. .. versionadded:: 0.18 Mean Absolute Error (MAE) criterion. splitter : string, optional (default="best") The strategy used to choose the split at each node. Supported strategies are "best" to choose the best split and "random" to choose the best random split. max_depth : int or None, optional (default=None) The maximum depth of the tree. If None, then nodes are expanded until all leaves are pure or until all leaves contain less than min_samples_split samples. min_samples_split : int, float, optional (default=2) The minimum number of samples required to split an internal node: - If int, then consider `min_samples_split` as the minimum number. - If float, then `min_samples_split` is a fraction and `ceil(min_samples_split * n_samples)` are the minimum number of samples for each split. .. versionchanged:: 0.18 Added float values for fractions. min_samples_leaf : int, float, optional (default=1) The minimum number of samples required to be at a leaf node. A split point at any depth will only be considered if it leaves at least ``min_samples_leaf`` training samples in each of the left and right branches. This may have the effect of smoothing the model, especially in regression. - If int, then consider `min_samples_leaf` as the minimum number. - If float, then `min_samples_leaf` is a fraction and `ceil(min_samples_leaf * n_samples)` are the minimum number of samples for each node. .. versionchanged:: 0.18 Added float values for fractions. min_weight_fraction_leaf : float, optional (default=0.) The minimum weighted fraction of the sum total of weights (of all the input samples) required to be at a leaf node. Samples have equal weight when sample_weight is not provided. max_features : int, float, string or None, optional (default=None) The number of features to consider when looking for the best split: - If int, then consider `max_features` features at each split. - If float, then `max_features` is a fraction and `int(max_features * n_features)` features are considered at each split. - If "auto", then `max_features=n_features`. - If "sqrt", then `max_features=sqrt(n_features)`. - If "log2", then `max_features=log2(n_features)`. - If None, then `max_features=n_features`. Note: the search for a split does not stop until at least one valid partition of the node samples is found, even if it requires to effectively inspect more than ``max_features`` features. random_state : int, RandomState instance or None, optional (default=None) If int, random_state is the seed used by the random number generator; If RandomState instance, random_state is the random number generator; If None, the random number generator is the RandomState instance used by `np.random`. max_leaf_nodes : int or None, optional (default=None) Grow a tree with ``max_leaf_nodes`` in best-first fashion. Best nodes are defined as relative reduction in impurity. If None then unlimited number of leaf nodes. min_impurity_decrease : float, optional (default=0.) A node will be split if this split induces a decrease of the impurity greater than or equal to this value. The weighted impurity decrease equation is the following:: N_t / N * (impurity - N_t_R / N_t * right_impurity - N_t_L / N_t * left_impurity) where ``N`` is the total number of samples, ``N_t`` is the number of samples at the current node, ``N_t_L`` is the number of samples in the left child, and ``N_t_R`` is the number of samples in the right child. ``N``, ``N_t``, ``N_t_R`` and ``N_t_L`` all refer to the weighted sum, if ``sample_weight`` is passed. .. versionadded:: 0.19 min_impurity_split : float, (default=1e-7) Threshold for early stopping in tree growth. A node will split if its impurity is above the threshold, otherwise it is a leaf. .. deprecated:: 0.19 ``min_impurity_split`` has been deprecated in favor of ``min_impurity_decrease`` in 0.19. The default value of ``min_impurity_split`` will change from 1e-7 to 0 in 0.23 and it will be removed in 0.25. Use ``min_impurity_decrease`` instead. presort : bool, optional (default=False) Whether to presort the data to speed up the finding of best splits in fitting. For the default settings of a decision tree on large datasets, setting this to true may slow down the training process. When using either a smaller dataset or a restricted depth, this may speed up the training. Attributes ---------- feature_importances_ : array of shape = [n_features] The feature importances. The higher, the more important the feature. The importance of a feature is computed as the (normalized) total reduction of the criterion brought by that feature. It is also known as the Gini importance [4]_. max_features_ : int, The inferred value of max_features. n_features_ : int The number of features when ``fit`` is performed. n_outputs_ : int The number of outputs when ``fit`` is performed. tree_ : Tree object The underlying Tree object. Please refer to ``help(sklearn.tree._tree.Tree)`` for attributes of Tree object and :ref:`sphx_glr_auto_examples_tree_plot_unveil_tree_structure.py` for basic usage of these attributes. Notes ----- The default values for the parameters controlling the size of the trees (e.g. ``max_depth``, ``min_samples_leaf``, etc.) lead to fully grown and unpruned trees which can potentially be very large on some data sets. To reduce memory consumption, the complexity and size of the trees should be controlled by setting those parameter values. The features are always randomly permuted at each split. Therefore, the best found split may vary, even with the same training data and ``max_features=n_features``, if the improvement of the criterion is identical for several splits enumerated during the search of the best split. To obtain a deterministic behaviour during fitting, ``random_state`` has to be fixed. See also -------- DecisionTreeClassifier References ---------- .. [1] https://en.wikipedia.org/wiki/Decision_tree_learning .. [2] L. Breiman, J. Friedman, R. Olshen, and C. Stone, "Classification and Regression Trees", Wadsworth, Belmont, CA, 1984. .. [3] T. Hastie, R. Tibshirani and J. Friedman. "Elements of Statistical Learning", Springer, 2009. .. [4] L. Breiman, and A. Cutler, "Random Forests", https://www.stat.berkeley.edu/~breiman/RandomForests/cc_home.htm Examples -------- >>> from sklearn.datasets import load_boston >>> from sklearn.model_selection import cross_val_score >>> from sklearn.tree import DecisionTreeRegressor >>> boston = load_boston() >>> regressor = DecisionTreeRegressor(random_state=0) >>> cross_val_score(regressor, boston.data, boston.target, cv=10) ... # doctest: +SKIP ... array([ 0.61..., 0.57..., -0.34..., 0.41..., 0.75..., 0.07..., 0.29..., 0.33..., -1.42..., -1.77...]) RR iigc C s_tt|ƒjd|d|d|d|d|d|d|d| d |d | d | d | ƒ dS( NR#R$R%R&R'R(R)R+R*R,R-R/(R‘RR1( R0R#R$R%R&R'R(R)R*R+R,R-R/((s0lib/python2.7/site-packages/sklearn/tree/tree.pyR14s c C s/tt|ƒj||d|d|d|ƒ|S(s˜Build a decision tree regressor from the training set (X, y). Parameters ---------- X : array-like or sparse matrix, shape = [n_samples, n_features] The training input samples. Internally, it will be converted to ``dtype=np.float32`` and if a sparse matrix is provided to a sparse ``csc_matrix``. y : array-like, shape = [n_samples] or [n_samples, n_outputs] The target values (real numbers). Use ``dtype=np.float64`` and ``order='C'`` for maximum efficiency. sample_weight : array-like, shape = [n_samples] or None Sample weights. If None, then samples are equally weighted. Splits that would create child nodes with net zero or negative weight are ignored while searching for a split in each node. check_input : boolean, (default=True) Allow to bypass several input checking. Don't use this parameter unless you know what you do. X_idx_sorted : array-like, shape = [n_samples, n_features], optional The indexes of the sorted training input samples. If many tree are grown on the same dataset, this allows the ordering to be cached between trees. If None, the data will be sorted here. Don't use this parameter unless you know what to do. Returns ------- self : object RrRsRt(R‘RR€(R0RpRqRrRsRt((s0lib/python2.7/site-packages/sklearn/tree/tree.pyR€Os # N(RRŽRR=R<R1RQR€(((s0lib/python2.7/site-packages/sklearn/tree/tree.pyRts¿ c B s;eZdZddddddddddddd„ ZRS( síAn extremely randomized tree classifier. Extra-trees differ from classic decision trees in the way they are built. When looking for the best split to separate the samples of a node into two groups, random splits are drawn for each of the `max_features` randomly selected features and the best split among those is chosen. When `max_features` is set 1, this amounts to building a totally random decision tree. Warning: Extra-trees should only be used within ensemble methods. Read more in the :ref:`User Guide `. Parameters ---------- criterion : string, optional (default="gini") The function to measure the quality of a split. Supported criteria are "gini" for the Gini impurity and "entropy" for the information gain. splitter : string, optional (default="random") The strategy used to choose the split at each node. Supported strategies are "best" to choose the best split and "random" to choose the best random split. max_depth : int or None, optional (default=None) The maximum depth of the tree. If None, then nodes are expanded until all leaves are pure or until all leaves contain less than min_samples_split samples. min_samples_split : int, float, optional (default=2) The minimum number of samples required to split an internal node: - If int, then consider `min_samples_split` as the minimum number. - If float, then `min_samples_split` is a fraction and `ceil(min_samples_split * n_samples)` are the minimum number of samples for each split. .. versionchanged:: 0.18 Added float values for fractions. min_samples_leaf : int, float, optional (default=1) The minimum number of samples required to be at a leaf node. A split point at any depth will only be considered if it leaves at least ``min_samples_leaf`` training samples in each of the left and right branches. This may have the effect of smoothing the model, especially in regression. - If int, then consider `min_samples_leaf` as the minimum number. - If float, then `min_samples_leaf` is a fraction and `ceil(min_samples_leaf * n_samples)` are the minimum number of samples for each node. .. versionchanged:: 0.18 Added float values for fractions. min_weight_fraction_leaf : float, optional (default=0.) The minimum weighted fraction of the sum total of weights (of all the input samples) required to be at a leaf node. Samples have equal weight when sample_weight is not provided. max_features : int, float, string or None, optional (default="auto") The number of features to consider when looking for the best split: - If int, then consider `max_features` features at each split. - If float, then `max_features` is a fraction and `int(max_features * n_features)` features are considered at each split. - If "auto", then `max_features=sqrt(n_features)`. - If "sqrt", then `max_features=sqrt(n_features)`. - If "log2", then `max_features=log2(n_features)`. - If None, then `max_features=n_features`. Note: the search for a split does not stop until at least one valid partition of the node samples is found, even if it requires to effectively inspect more than ``max_features`` features. random_state : int, RandomState instance or None, optional (default=None) If int, random_state is the seed used by the random number generator; If RandomState instance, random_state is the random number generator; If None, the random number generator is the RandomState instance used by `np.random`. max_leaf_nodes : int or None, optional (default=None) Grow a tree with ``max_leaf_nodes`` in best-first fashion. Best nodes are defined as relative reduction in impurity. If None then unlimited number of leaf nodes. min_impurity_decrease : float, optional (default=0.) A node will be split if this split induces a decrease of the impurity greater than or equal to this value. The weighted impurity decrease equation is the following:: N_t / N * (impurity - N_t_R / N_t * right_impurity - N_t_L / N_t * left_impurity) where ``N`` is the total number of samples, ``N_t`` is the number of samples at the current node, ``N_t_L`` is the number of samples in the left child, and ``N_t_R`` is the number of samples in the right child. ``N``, ``N_t``, ``N_t_R`` and ``N_t_L`` all refer to the weighted sum, if ``sample_weight`` is passed. .. versionadded:: 0.19 min_impurity_split : float, (default=1e-7) Threshold for early stopping in tree growth. A node will split if its impurity is above the threshold, otherwise it is a leaf. .. deprecated:: 0.19 ``min_impurity_split`` has been deprecated in favor of ``min_impurity_decrease`` in 0.19. The default value of ``min_impurity_split`` will change from 1e-7 to 0 in 0.23 and it will be removed in 0.25. Use ``min_impurity_decrease`` instead. class_weight : dict, list of dicts, "balanced" or None, default=None Weights associated with classes in the form ``{class_label: weight}``. If not given, all classes are supposed to have weight one. For multi-output problems, a list of dicts can be provided in the same order as the columns of y. Note that for multioutput (including multilabel) weights should be defined for each class of every column in its own dict. For example, for four-class multilabel classification weights should be [{0: 1, 1: 1}, {0: 1, 1: 5}, {0: 1, 1: 1}, {0: 1, 1: 1}] instead of [{1:1}, {2:5}, {3:1}, {4:1}]. The "balanced" mode uses the values of y to automatically adjust weights inversely proportional to class frequencies in the input data as ``n_samples / (n_classes * np.bincount(y))`` For multi-output, the weights of each column of y will be multiplied. Note that these weights will be multiplied with sample_weight (passed through the fit method) if sample_weight is specified. See also -------- ExtraTreeRegressor, sklearn.ensemble.ExtraTreesClassifier, sklearn.ensemble.ExtraTreesRegressor Notes ----- The default values for the parameters controlling the size of the trees (e.g. ``max_depth``, ``min_samples_leaf``, etc.) lead to fully grown and unpruned trees which can potentially be very large on some data sets. To reduce memory consumption, the complexity and size of the trees should be controlled by setting those parameter values. References ---------- .. [1] P. Geurts, D. Ernst., and L. Wehenkel, "Extremely randomized trees", Machine Learning, 63(1), 3-42, 2006. RR!iigR7c C s_tt|ƒjd|d|d|d|d|d|d|d| d | d | d | d |ƒ dS( NR#R$R%R&R'R(R)R+R.R,R-R*(R‘RR1( R0R#R$R%R&R'R(R)R*R+R,R-R.((s0lib/python2.7/site-packages/sklearn/tree/tree.pyR1s N(RRŽRR=R1(((s0lib/python2.7/site-packages/sklearn/tree/tree.pyRzs›c B s8eZdZdddddddddddd„ ZRS( s'An extremely randomized tree regressor. Extra-trees differ from classic decision trees in the way they are built. When looking for the best split to separate the samples of a node into two groups, random splits are drawn for each of the `max_features` randomly selected features and the best split among those is chosen. When `max_features` is set 1, this amounts to building a totally random decision tree. Warning: Extra-trees should only be used within ensemble methods. Read more in the :ref:`User Guide `. Parameters ---------- criterion : string, optional (default="mse") The function to measure the quality of a split. Supported criteria are "mse" for the mean squared error, which is equal to variance reduction as feature selection criterion, and "mae" for the mean absolute error. .. versionadded:: 0.18 Mean Absolute Error (MAE) criterion. splitter : string, optional (default="random") The strategy used to choose the split at each node. Supported strategies are "best" to choose the best split and "random" to choose the best random split. max_depth : int or None, optional (default=None) The maximum depth of the tree. If None, then nodes are expanded until all leaves are pure or until all leaves contain less than min_samples_split samples. min_samples_split : int, float, optional (default=2) The minimum number of samples required to split an internal node: - If int, then consider `min_samples_split` as the minimum number. - If float, then `min_samples_split` is a fraction and `ceil(min_samples_split * n_samples)` are the minimum number of samples for each split. .. versionchanged:: 0.18 Added float values for fractions. min_samples_leaf : int, float, optional (default=1) The minimum number of samples required to be at a leaf node. A split point at any depth will only be considered if it leaves at least ``min_samples_leaf`` training samples in each of the left and right branches. This may have the effect of smoothing the model, especially in regression. - If int, then consider `min_samples_leaf` as the minimum number. - If float, then `min_samples_leaf` is a fraction and `ceil(min_samples_leaf * n_samples)` are the minimum number of samples for each node. .. versionchanged:: 0.18 Added float values for fractions. min_weight_fraction_leaf : float, optional (default=0.) The minimum weighted fraction of the sum total of weights (of all the input samples) required to be at a leaf node. Samples have equal weight when sample_weight is not provided. max_features : int, float, string or None, optional (default="auto") The number of features to consider when looking for the best split: - If int, then consider `max_features` features at each split. - If float, then `max_features` is a fraction and `int(max_features * n_features)` features are considered at each split. - If "auto", then `max_features=n_features`. - If "sqrt", then `max_features=sqrt(n_features)`. - If "log2", then `max_features=log2(n_features)`. - If None, then `max_features=n_features`. Note: the search for a split does not stop until at least one valid partition of the node samples is found, even if it requires to effectively inspect more than ``max_features`` features. random_state : int, RandomState instance or None, optional (default=None) If int, random_state is the seed used by the random number generator; If RandomState instance, random_state is the random number generator; If None, the random number generator is the RandomState instance used by `np.random`. min_impurity_decrease : float, optional (default=0.) A node will be split if this split induces a decrease of the impurity greater than or equal to this value. The weighted impurity decrease equation is the following:: N_t / N * (impurity - N_t_R / N_t * right_impurity - N_t_L / N_t * left_impurity) where ``N`` is the total number of samples, ``N_t`` is the number of samples at the current node, ``N_t_L`` is the number of samples in the left child, and ``N_t_R`` is the number of samples in the right child. ``N``, ``N_t``, ``N_t_R`` and ``N_t_L`` all refer to the weighted sum, if ``sample_weight`` is passed. .. versionadded:: 0.19 min_impurity_split : float, (default=1e-7) Threshold for early stopping in tree growth. A node will split if its impurity is above the threshold, otherwise it is a leaf. .. deprecated:: 0.19 ``min_impurity_split`` has been deprecated in favor of ``min_impurity_decrease`` in 0.19. The default value of ``min_impurity_split`` will change from 1e-7 to 0 in 0.23 and it will be removed in 0.25. Use ``min_impurity_decrease`` instead. max_leaf_nodes : int or None, optional (default=None) Grow a tree with ``max_leaf_nodes`` in best-first fashion. Best nodes are defined as relative reduction in impurity. If None then unlimited number of leaf nodes. See also -------- ExtraTreeClassifier, sklearn.ensemble.ExtraTreesClassifier, sklearn.ensemble.ExtraTreesRegressor Notes ----- The default values for the parameters controlling the size of the trees (e.g. ``max_depth``, ``min_samples_leaf``, etc.) lead to fully grown and unpruned trees which can potentially be very large on some data sets. To reduce memory consumption, the complexity and size of the trees should be controlled by setting those parameter values. References ---------- .. [1] P. Geurts, D. Ernst., and L. Wehenkel, "Extremely randomized trees", Machine Learning, 63(1), 3-42, 2006. RR!iigR7c C sYtt|ƒjd|d|d|d|d|d|d|d| d | d | d |ƒ dS( NR#R$R%R&R'R(R)R+R,R-R*(R‘RR1( R0R#R$R%R&R'R(R)R*R,R-R+((s0lib/python2.7/site-packages/sklearn/tree/tree.pyR1¿s N(RRŽRR=R1(((s0lib/python2.7/site-packages/sklearn/tree/tree.pyR2sŒ(<Rt __future__RR[RdtabcRRtmathRtnumpyR@t scipy.sparseRtbaseRRRRt externalsR tutilsR R R tutils.multiclassR tutils.validationRRRRRRRRRtt__all__R;RVtGinitEntropyRjtMSEt FriedmanMSEtMAERkt BestSplittertRandomSplitterRmtBestSparseSplittertRandomSparseSplitterRltwith_metaclassR"RRRR(((s0lib/python2.7/site-packages/sklearn/tree/tree.pytsZ            "ÿ½ÿnÿ¸