im2.0钱包下载后登录|sklearn决策树

作者： im2.0钱包下载后登录

2024-03-09 20:31:34

1.10. Decision Trees — scikit-learn 1.4.1 documentation

Install

User Guide

API

Examples

Community

Getting Started

Tutorial

What's new

Glossary

Development

FAQ

Support

Related packages

Roadmap

Governance

About us

GitHub

Other Versions and Download

Getting Started

Tutorial

What's new

Glossary

Development

FAQ

Support

Related packages

Roadmap

Governance

About us

GitHub

Other Versions and Download

Toggle Menu

PrevUp

scikit-learn 1.4.1

Other versions

Please cite us if you use the software.

1.10. Decision Trees

1.10.1. Classification

1.10.2. Regression

1.10.3. Multi-output problems

1.10.4. Complexity

1.10.5. Tips on practical use

1.10.6. Tree algorithms: ID3, C4.5, C5.0 and CART

1.10.7. Mathematical formulation

1.10.7.1. Classification criteria

1.10.7.2. Regression criteria

1.10.8. Missing Values Support

1.10.9. Minimal Cost-Complexity Pruning

1.10. Decision Trees¶

Decision Trees (DTs) are a non-parametric supervised learning method used

for classification and regression. The goal is to create a model that predicts the value of a

target variable by learning simple decision rules inferred from the data

features. A tree can be seen as a piecewise constant approximation.

For instance, in the example below, decision trees learn from data to

approximate a sine curve with a set of if-then-else decision rules. The deeper

the tree, the more complex the decision rules and the fitter the model.

Some advantages of decision trees are:

Simple to understand and to interpret. Trees can be visualized.

Requires little data preparation. Other techniques often require data

normalization, dummy variables need to be created and blank values to

be removed. Some tree and algorithm combinations support

missing values.

The cost of using the tree (i.e., predicting data) is logarithmic in the

number of data points used to train the tree.

Able to handle both numerical and categorical data. However, the scikit-learn

implementation does not support categorical variables for now. Other

techniques are usually specialized in analyzing datasets that have only one type

of variable. See algorithms for more

information.

Able to handle multi-output problems.

Uses a white box model. If a given situation is observable in a model,

the explanation for the condition is easily explained by boolean logic.

By contrast, in a black box model (e.g., in an artificial neural

network), results may be more difficult to interpret.

Possible to validate a model using statistical tests. That makes it

possible to account for the reliability of the model.

Performs well even if its assumptions are somewhat violated by

the true model from which the data were generated.

The disadvantages of decision trees include:

Decision-tree learners can create over-complex trees that do not

generalize the data well. This is called overfitting. Mechanisms

such as pruning, setting the minimum number of samples required

at a leaf node or setting the maximum depth of the tree are

necessary to avoid this problem.

Decision trees can be unstable because small variations in the

data might result in a completely different tree being generated.

This problem is mitigated by using decision trees within an

ensemble.

Predictions of decision trees are neither smooth nor continuous, but

piecewise constant approximations as seen in the above figure. Therefore,

they are not good at extrapolation.

The problem of learning an optimal decision tree is known to be

NP-complete under several aspects of optimality and even for simple

concepts. Consequently, practical decision-tree learning algorithms

are based on heuristic algorithms such as the greedy algorithm where

locally optimal decisions are made at each node. Such algorithms

cannot guarantee to return the globally optimal decision tree. This

can be mitigated by training multiple trees in an ensemble learner,

where the features and samples are randomly sampled with replacement.

There are concepts that are hard to learn because decision trees

do not express them easily, such as XOR, parity or multiplexer problems.

Decision tree learners create biased trees if some classes dominate.

It is therefore recommended to balance the dataset prior to fitting

with the decision tree.

1.10.1. Classification¶

DecisionTreeClassifier is a class capable of performing multi-class

classification on a dataset.

As with other classifiers, DecisionTreeClassifier takes as input two arrays:

an array X, sparse or dense, of shape (n_samples, n_features) holding the

training samples, and an array Y of integer values, shape (n_samples,),

holding the class labels for the training samples:

>>> from sklearn import tree

>>> X = [[0, 0], [1, 1]]

>>> Y = [0, 1]

>>> clf = tree.DecisionTreeClassifier()

>>> clf = clf.fit(X, Y)

After being fitted, the model can then be used to predict the class of samples:

>>> clf.predict([[2., 2.]])

array([1])

In case that there are multiple classes with the same and highest

probability, the classifier will predict the class with the lowest index

amongst those classes.

As an alternative to outputting a specific class, the probability of each class

can be predicted, which is the fraction of training samples of the class in a

leaf:

>>> clf.predict_proba([[2., 2.]])

array([[0., 1.]])

DecisionTreeClassifier is capable of both binary (where the

labels are [-1, 1]) classification and multiclass (where the labels are

[0, …, K-1]) classification.

Using the Iris dataset, we can construct a tree as follows:

>>> from sklearn.datasets import load_iris

>>> from sklearn import tree

>>> iris = load_iris()

>>> X, y = iris.data, iris.target

>>> clf = tree.DecisionTreeClassifier()

>>> clf = clf.fit(X, y)

Once trained, you can plot the tree with the plot_tree function:

>>> tree.plot_tree(clf)

[...]

Alternative ways to export trees

Click for more details

We can also export the tree in Graphviz format using the export_graphviz

exporter. If you use the conda package manager, the graphviz binaries

and the python package can be installed with conda install python-graphviz.

Alternatively binaries for graphviz can be downloaded from the graphviz project homepage,

and the Python wrapper installed from pypi with pip install graphviz.

Below is an example graphviz export of the above tree trained on the entire

iris dataset; the results are saved in an output file iris.pdf:

>>> import graphviz

>>> dot_data = tree.export_graphviz(clf, out_file=None)

>>> graph = graphviz.Source(dot_data)

>>> graph.render("iris")

The export_graphviz exporter also supports a variety of aesthetic

options, including coloring nodes by their class (or value for regression) and

using explicit variable and class names if desired. Jupyter notebooks also

render these plots inline automatically:

>>> dot_data = tree.export_graphviz(clf, out_file=None,

... feature_names=iris.feature_names,

... class_names=iris.target_names,

... filled=True, rounded=True,

... special_characters=True)

>>> graph = graphviz.Source(dot_data)

>>> graph

Alternatively, the tree can also be exported in textual format with the

function export_text. This method doesn’t require the installation

of external libraries and is more compact:

>>> from sklearn.datasets import load_iris

>>> from sklearn.tree import DecisionTreeClassifier

>>> from sklearn.tree import export_text

>>> iris = load_iris()

>>> decision_tree = DecisionTreeClassifier(random_state=0, max_depth=2)

>>> decision_tree = decision_tree.fit(iris.data, iris.target)

>>> r = export_text(decision_tree, feature_names=iris['feature_names'])

>>> print(r)

|--- petal width (cm) <= 0.80

| |--- class: 0

|--- petal width (cm) > 0.80

| |--- petal width (cm) <= 1.75

| | |--- class: 1

| |--- petal width (cm) > 1.75

| | |--- class: 2

Examples:

Plot the decision surface of decision trees trained on the iris dataset

Understanding the decision tree structure

1.10.2. Regression¶

Decision trees can also be applied to regression problems, using the

DecisionTreeRegressor class.

As in the classification setting, the fit method will take as argument arrays X

and y, only that in this case y is expected to have floating point values

instead of integer values:

>>> from sklearn import tree

>>> X = [[0, 0], [2, 2]]

>>> y = [0.5, 2.5]

>>> clf = tree.DecisionTreeRegressor()

>>> clf = clf.fit(X, y)

>>> clf.predict([[1, 1]])

array([0.5])

Examples:

Decision Tree Regression

1.10.3. Multi-output problems¶

A multi-output problem is a supervised learning problem with several outputs

to predict, that is when Y is a 2d array of shape (n_samples, n_outputs).

When there is no correlation between the outputs, a very simple way to solve

this kind of problem is to build n independent models, i.e. one for each

output, and then to use those models to independently predict each one of the n

outputs. However, because it is likely that the output values related to the

same input are themselves correlated, an often better way is to build a single

model capable of predicting simultaneously all n outputs. First, it requires

lower training time since only a single estimator is built. Second, the

generalization accuracy of the resulting estimator may often be increased.

With regard to decision trees, this strategy can readily be used to support

multi-output problems. This requires the following changes:

Store n output values in leaves, instead of 1;

Use splitting criteria that compute the average reduction across all

n outputs.

This module offers support for multi-output problems by implementing this

strategy in both DecisionTreeClassifier and

DecisionTreeRegressor. If a decision tree is fit on an output array Y

of shape (n_samples, n_outputs) then the resulting estimator will:

Output n_output values upon predict;

Output a list of n_output arrays of class probabilities upon

predict_proba.

The use of multi-output trees for regression is demonstrated in

Multi-output Decision Tree Regression. In this example, the input

X is a single real value and the outputs Y are the sine and cosine of X.

The use of multi-output trees for classification is demonstrated in

Face completion with a multi-output estimators. In this example, the inputs

X are the pixels of the upper half of faces and the outputs Y are the pixels of

the lower half of those faces.

Examples:

Multi-output Decision Tree Regression

Face completion with a multi-output estimators

References

Click for more details

M. Dumont et al, Fast multi-class image annotation with random subwindows

and multiple output randomized trees, International Conference on

Computer Vision Theory and Applications 2009

1.10.4. Complexity¶

In general, the run time cost to construct a balanced binary tree is

\(O(n_{samples}n_{features}\log(n_{samples}))\) and query time

\(O(\log(n_{samples}))\). Although the tree construction algorithm attempts

to generate balanced trees, they will not always be balanced. Assuming that the

subtrees remain approximately balanced, the cost at each node consists of

searching through \(O(n_{features})\) to find the feature that offers the

largest reduction in the impurity criterion, e.g. log loss (which is equivalent to an

information gain). This has a cost of

\(O(n_{features}n_{samples}\log(n_{samples}))\) at each node, leading to a

total cost over the entire trees (by summing the cost at each node) of

\(O(n_{features}n_{samples}^{2}\log(n_{samples}))\).

1.10.5. Tips on practical use¶

Decision trees tend to overfit on data with a large number of features.

Getting the right ratio of samples to number of features is important, since

a tree with few samples in high dimensional space is very likely to overfit.

Consider performing dimensionality reduction (PCA,

ICA, or Feature selection) beforehand to

give your tree a better chance of finding features that are discriminative.

Understanding the decision tree structure will help

in gaining more insights about how the decision tree makes predictions, which is

important for understanding the important features in the data.

Visualize your tree as you are training by using the export

function. Use max_depth=3 as an initial tree depth to get a feel for

how the tree is fitting to your data, and then increase the depth.

Remember that the number of samples required to populate the tree doubles

for each additional level the tree grows to. Use max_depth to control

the size of the tree to prevent overfitting.

Use min_samples_split or min_samples_leaf to ensure that multiple

samples inform every decision in the tree, by controlling which splits will

be considered. A very small number will usually mean the tree will overfit,

whereas a large number will prevent the tree from learning the data. Try

min_samples_leaf=5 as an initial value. If the sample size varies

greatly, a float number can be used as percentage in these two parameters.

While min_samples_split can create arbitrarily small leaves,

min_samples_leaf guarantees that each leaf has a minimum size, avoiding

low-variance, over-fit leaf nodes in regression problems. For

classification with few classes, min_samples_leaf=1 is often the best

choice.

Note that min_samples_split considers samples directly and independent of

sample_weight, if provided (e.g. a node with m weighted samples is still

treated as having exactly m samples). Consider min_weight_fraction_leaf or

min_impurity_decrease if accounting for sample weights is required at splits.

Balance your dataset before training to prevent the tree from being biased

toward the classes that are dominant. Class balancing can be done by

sampling an equal number of samples from each class, or preferably by

normalizing the sum of the sample weights (sample_weight) for each

class to the same value. Also note that weight-based pre-pruning criteria,

such as min_weight_fraction_leaf, will then be less biased toward

dominant classes than criteria that are not aware of the sample weights,

like min_samples_leaf.

If the samples are weighted, it will be easier to optimize the tree

structure using weight-based pre-pruning criterion such as

min_weight_fraction_leaf, which ensure that leaf nodes contain at least

a fraction of the overall sum of the sample weights.

All decision trees use np.float32 arrays internally.

If training data is not in this format, a copy of the dataset will be made.

If the input matrix X is very sparse, it is recommended to convert to sparse

csc_matrix before calling fit and sparse csr_matrix before calling

predict. Training time can be orders of magnitude faster for a sparse

matrix input compared to a dense matrix when features have zero values in

most of the samples.

1.10.6. Tree algorithms: ID3, C4.5, C5.0 and CART¶

What are all the various decision tree algorithms and how do they differ

from each other? Which one is implemented in scikit-learn?

Various decision tree algorithms

Click for more details

ID3 (Iterative Dichotomiser 3) was developed in 1986 by Ross Quinlan.

The algorithm creates a multiway tree, finding for each node (i.e. in

a greedy manner) the categorical feature that will yield the largest

information gain for categorical targets. Trees are grown to their

maximum size and then a pruning step is usually applied to improve the

ability of the tree to generalize to unseen data.

C4.5 is the successor to ID3 and removed the restriction that features

must be categorical by dynamically defining a discrete attribute (based

on numerical variables) that partitions the continuous attribute value

into a discrete set of intervals. C4.5 converts the trained trees

(i.e. the output of the ID3 algorithm) into sets of if-then rules.

The accuracy of each rule is then evaluated to determine the order

in which they should be applied. Pruning is done by removing a rule’s

precondition if the accuracy of the rule improves without it.

C5.0 is Quinlan’s latest version release under a proprietary license.

It uses less memory and builds smaller rulesets than C4.5 while being

more accurate.

CART (Classification and Regression Trees) is very similar to C4.5, but

it differs in that it supports numerical target variables (regression) and

does not compute rule sets. CART constructs binary trees using the feature

and threshold that yield the largest information gain at each node.

scikit-learn uses an optimized version of the CART algorithm; however, the

scikit-learn implementation does not support categorical variables for now.

1.10.7. Mathematical formulation¶

Given training vectors \(x_i \in R^n\), i=1,…, l and a label vector

\(y \in R^l\), a decision tree recursively partitions the feature space

such that the samples with the same labels or similar target values are grouped

together.

Let the data at node \(m\) be represented by \(Q_m\) with \(n_m\)

samples. For each candidate split \(\theta = (j, t_m)\) consisting of a

feature \(j\) and threshold \(t_m\), partition the data into

\(Q_m^{left}(\theta)\) and \(Q_m^{right}(\theta)\) subsets

\[ \begin{align}\begin{aligned}Q_m^{left}(\theta) = \{(x, y) | x_j \leq t_m\}\\Q_m^{right}(\theta) = Q_m \setminus Q_m^{left}(\theta)\end{aligned}\end{align} \]

The quality of a candidate split of node \(m\) is then computed using an

impurity function or loss function \(H()\), the choice of which depends on

the task being solved (classification or regression)

\[G(Q_m, \theta) = \frac{n_m^{left}}{n_m} H(Q_m^{left}(\theta))

+ \frac{n_m^{right}}{n_m} H(Q_m^{right}(\theta))\]

Select the parameters that minimises the impurity

\[\theta^* = \operatorname{argmin}_\theta G(Q_m, \theta)\]

Recurse for subsets \(Q_m^{left}(\theta^*)\) and

\(Q_m^{right}(\theta^*)\) until the maximum allowable depth is reached,

\(n_m < \min_{samples}\) or \(n_m = 1\).

1.10.7.1. Classification criteria¶

If a target is a classification outcome taking on values 0,1,…,K-1,

for node \(m\), let

\[p_{mk} = \frac{1}{n_m} \sum_{y \in Q_m} I(y = k)\]

be the proportion of class k observations in node \(m\). If \(m\) is a

terminal node, predict_proba for this region is set to \(p_{mk}\).

Common measures of impurity are the following.

Gini:

\[H(Q_m) = \sum_k p_{mk} (1 - p_{mk})\]

Log Loss or Entropy:

\[H(Q_m) = - \sum_k p_{mk} \log(p_{mk})\]

Shannon entropy

Click for more details

The entropy criterion computes the Shannon entropy of the possible classes. It

takes the class frequencies of the training data points that reached a given

leaf \(m\) as their probability. Using the Shannon entropy as tree node

splitting criterion is equivalent to minimizing the log loss (also known as

cross-entropy and multinomial deviance) between the true labels \(y_i\)

and the probabilistic predictions \(T_k(x_i)\) of the tree model \(T\) for class \(k\).

To see this, first recall that the log loss of a tree model \(T\)

computed on a dataset \(D\) is defined as follows:

\[\mathrm{LL}(D, T) = -\frac{1}{n} \sum_{(x_i, y_i) \in D} \sum_k I(y_i = k) \log(T_k(x_i))\]

where \(D\) is a training dataset of \(n\) pairs \((x_i, y_i)\).

In a classification tree, the predicted class probabilities within leaf nodes

are constant, that is: for all \((x_i, y_i) \in Q_m\), one has:

\(T_k(x_i) = p_{mk}\) for each class \(k\).

This property makes it possible to rewrite \(\mathrm{LL}(D, T)\) as the

sum of the Shannon entropies computed for each leaf of \(T\) weighted by

the number of training data points that reached each leaf:

\[\mathrm{LL}(D, T) = \sum_{m \in T} \frac{n_m}{n} H(Q_m)\]

1.10.7.2. Regression criteria¶

If the target is a continuous value, then for node \(m\), common

criteria to minimize as for determining locations for future splits are Mean

Squared Error (MSE or L2 error), Poisson deviance as well as Mean Absolute

Error (MAE or L1 error). MSE and Poisson deviance both set the predicted value

of terminal nodes to the learned mean value \(\bar{y}_m\) of the node

whereas the MAE sets the predicted value of terminal nodes to the median

\(median(y)_m\).

Mean Squared Error:

\[ \begin{align}\begin{aligned}\bar{y}_m = \frac{1}{n_m} \sum_{y \in Q_m} y\\H(Q_m) = \frac{1}{n_m} \sum_{y \in Q_m} (y - \bar{y}_m)^2\end{aligned}\end{align} \]

Half Poisson deviance:

\[H(Q_m) = \frac{1}{n_m} \sum_{y \in Q_m} (y \log\frac{y}{\bar{y}_m}

- y + \bar{y}_m)\]

Setting criterion="poisson" might be a good choice if your target is a count

or a frequency (count per some unit). In any case, \(y >= 0\) is a

necessary condition to use this criterion. Note that it fits much slower than

the MSE criterion.

Mean Absolute Error:

\[ \begin{align}\begin{aligned}median(y)_m = \underset{y \in Q_m}{\mathrm{median}}(y)\\H(Q_m) = \frac{1}{n_m} \sum_{y \in Q_m} |y - median(y)_m|\end{aligned}\end{align} \]

Note that it fits much slower than the MSE criterion.

1.10.8. Missing Values Support¶

DecisionTreeClassifier and DecisionTreeRegressor

have built-in support for missing values when splitter='best' and criterion is

'gini', 'entropy’, or 'log_loss', for classification or

'squared_error', 'friedman_mse', or 'poisson' for regression.

For each potential threshold on the non-missing data, the splitter will evaluate

the split with all the missing values going to the left node or the right node.

Decisions are made as follows:

By default when predicting, the samples with missing values are classified

with the class used in the split found during training:

>>> from sklearn.tree import DecisionTreeClassifier

>>> import numpy as np

>>> X = np.array([0, 1, 6, np.nan]).reshape(-1, 1)

>>> y = [0, 0, 1, 1]

>>> tree = DecisionTreeClassifier(random_state=0).fit(X, y)

>>> tree.predict(X)

array([0, 0, 1, 1])

If the criterion evaluation is the same for both nodes,

then the tie for missing value at predict time is broken by going to the

right node. The splitter also checks the split where all the missing

values go to one child and non-missing values go to the other:

>>> from sklearn.tree import DecisionTreeClassifier

>>> import numpy as np

>>> X = np.array([np.nan, -1, np.nan, 1]).reshape(-1, 1)

>>> y = [0, 0, 1, 1]

>>> tree = DecisionTreeClassifier(random_state=0).fit(X, y)

>>> X_test = np.array([np.nan]).reshape(-1, 1)

>>> tree.predict(X_test)

array([1])

If no missing values are seen during training for a given feature, then during

prediction missing values are mapped to the child with the most samples:

>>> from sklearn.tree import DecisionTreeClassifier

>>> import numpy as np

>>> X = np.array([0, 1, 2, 3]).reshape(-1, 1)

>>> y = [0, 1, 1, 1]

>>> tree = DecisionTreeClassifier(random_state=0).fit(X, y)

>>> X_test = np.array([np.nan]).reshape(-1, 1)

>>> tree.predict(X_test)

array([1])

1.10.9. Minimal Cost-Complexity Pruning¶

Minimal cost-complexity pruning is an algorithm used to prune a tree to avoid

over-fitting, described in Chapter 3 of [BRE]. This algorithm is parameterized

by \(\alpha\ge0\) known as the complexity parameter. The complexity

parameter is used to define the cost-complexity measure, \(R_\alpha(T)\) of

a given tree \(T\):

\[R_\alpha(T) = R(T) + \alpha|\widetilde{T}|\]

where \(|\widetilde{T}|\) is the number of terminal nodes in \(T\) and \(R(T)\)

is traditionally defined as the total misclassification rate of the terminal

nodes. Alternatively, scikit-learn uses the total sample weighted impurity of

the terminal nodes for \(R(T)\). As shown above, the impurity of a node

depends on the criterion. Minimal cost-complexity pruning finds the subtree of

\(T\) that minimizes \(R_\alpha(T)\).

The cost complexity measure of a single node is

\(R_\alpha(t)=R(t)+\alpha\). The branch, \(T_t\), is defined to be a

tree where node \(t\) is its root. In general, the impurity of a node

is greater than the sum of impurities of its terminal nodes,

\(R(T_t)

\(t\), and its branch, \(T_t\), can be equal depending on

\(\alpha\). We define the effective \(\alpha\) of a node to be the

value where they are equal, \(R_\alpha(T_t)=R_\alpha(t)\) or

\(\alpha_{eff}(t)=\frac{R(t)-R(T_t)}{|T|-1}\). A non-terminal node

with the smallest value of \(\alpha_{eff}\) is the weakest link and will

be pruned. This process stops when the pruned tree’s minimal

\(\alpha_{eff}\) is greater than the ccp_alpha parameter.

Examples:

Post pruning decision trees with cost complexity pruning

References

Click for more details

[BRE]

L. Breiman, J. Friedman, R. Olshen, and C. Stone. Classification

and Regression Trees. Wadsworth, Belmont, CA, 1984.

https://en.wikipedia.org/wiki/Decision_tree_learning

https://en.wikipedia.org/wiki/Predictive_analytics

J.R. Quinlan. C4. 5: programs for machine learning. Morgan

Kaufmann, 1993.

T. Hastie, R. Tibshirani and J. Friedman. Elements of Statistical

Learning, Springer, 2009.

Show this page source

一文了解sklearn决策树 - 知乎

一文了解sklearn决策树 - 知乎首发于用Numpy学机器学习切换模式写文章登录/注册一文了解sklearn决策树长水滔滔前面几篇文章，我们详细介绍了决策树的几种算法，包括ID3、C4.5和CART，并使用numpy较完整的复现了决策树算法。彼时，我们的关注点主要在算法实现细节方面，这一篇文章，我们从宏观的角度再学习一下决策树，我们主要了解决策树的优缺点，并简单介绍一下sklearn中如何实现一棵决策树。以下内容主要参考sklearn官方文档。一文搞懂sklearn决策树前面几篇文章，我们详细介绍了决策树的几种算法，包括ID3、C4.5和CART，并使用numpy较完整的复现了决策树算法。彼时，我们的关注点主要在算法实现细节方面，这一篇文章，我们从宏观的角度再学习一下决策树，我们主要了解决策树的优缺点，并简单介绍一下sklearn中如何实现一棵决策树。以下内容主要参考sklearn官方文档。决策树是一个非参数的监督学习方法，可以用于分类和回归。通过对推断自数据特征中的简单决策规则的学习，决策树能够创建一个用来预测目标变量的模型。例如，在下图中，决策树用一系列if-then-else决策规则从数据中学习到一条近似的正弦曲线。树越深，决策规则和拟合的模型越复杂。决策树的优缺点决策树有以下一些优点:简单理解和解释，树可以可视化。要求很少的数据准备工作，其他技术通常要求数据标准化，哑变量化以及删除空值等。但是要注意的是sklearn不支持缺失值。使用树（如用来预测）的成本是用于训练树所用数据量的对数。决策树既能够处理数值变量，也能够处理分类变量。其他技术通常专门用于分析只有一种变量类型的数据集。能够处理多个标签变量的问题。决策树是一个白盒模型，如果模型中某种情形是可以观测到的，这种情形很容易通过布尔逻辑进行解释。相反，在黑盒模型中（例如人工神经网络），结果解释起来很困难。能够使用统计检验验证模型，这使得解释模型的可靠性成为可能。尽管它的假定可能有些违背生成数据的真实模型，决策树仍然表现良好。决策树有以下一些缺点：决策树可能创建过于复杂的树以至于不能很好的概括数据。这被称作是过拟合。为了避免这个问题，对决策树进行剪枝，设定一个叶子节点要求的最小样本量，或者设置树的最大深度是必要的。数据的微小变异可能导致决策树不稳定，进而生成一棵完全不同的决策树。结合集成算法使用决策树可以缓解这个问题。学习一颗最优决策树是一个NP问题，因此实际的决策树学习算法基于启发式算法例如贪心算法，其在每个节点做出局部最优决策。这样的算法不能保证返回全局最优的决策树。通过有放回的随机抽取特征和样本来建立多棵树的集成算法可以使这个问题得到缓解。有些概念很难学习，因为决策树不容易表达它们，例如异或、奇偶校验或多路复用等问题。如果数据中某些类占主导，决策树学习器会学到一棵有偏差的树，因此我们推荐在拟合决策树之前应该平衡数据集。sklearn决策树使用案例分类DecisionTreeClassifier是sklearn中用来训练分类树的一个类对象，能够处理数据的多类别分类问题。DecisionTreeClassifier接收两个数组作为输入，一个是数组X，大小为(n_samples,n_features)，表示训练样本，另一个是整数数组Y，大小为(n_samples,)，作为训练数据的类标签。>>> from sklearn import tree

>>> X = [[0, 0], [1, 1]]

>>> Y = [0, 1]

>>> clf = tree.DecisionTreeClassifier()

>>> clf = clf.fit(X, Y)

拟合之后，模型就可以用来预测样本的类别：>>> clf.predict([[2., 2.]])

array([1])

也可以预测每个类别的概率，这个概率是同一个叶子节点中同类训练样本的比例。>>> clf.predict_proba([[2., 2.]])

array([[0., 1.]])

DecisionTreeClassifier能够处理二分类和多分类问题。使用Iris数据集，我们可以以如下的方式构建一棵树：>>> from sklearn.datasets import load_iris

>>> from sklearn import tree

>>> X, y = load_iris(return_X_y=True)

>>> clf = tree.DecisionTreeClassifier()

>>> clf = clf.fit(X, y)

一旦训练完毕，你可以使用plot_tree函数来画出树形图：>>> tree.plot_tree(clf)我们也可以使用export_graphviz工具以Graphviz格式导出一棵树。如果你使用了conda包管理工具，可以使用conda install python-graphviz命令安装graphviz二进制文件和python包。或者graphviz二进制文件可以从graphviz项目主页下载，然后从pypi使用pip install graphviz命令来安装。下面的例子导出了上面训练的树，结果保存在Iris.pdf文件中。>>> import graphviz

>>> dot_data = tree.export_graphviz(clf, out_file=None)

>>> graph = graphviz.Source(dot_data)

>>> graph.render("iris")

export_graphviz导出器也支持许多美化功能的参数，包括根据类别或者回归之给节点绘制颜色：>>> dot_data = tree.export_graphviz(clf, out_file=None,

feature_names=iris.feature_names,

class_names=iris.target_names,

filled=True,

rounded=True,

special_characters=True)

>>> graph = graphviz.Source(dot_data)

>>> graph

也可以使用export_text函数以文本的形式导出树，这种方法不需要安装外部库：>>> from sklearn.datasets import load_iris

>>> from sklearn.tree import DecisionTreeClassifier

>>> from sklearn.tree import export_text

>>> iris = load_iris()

>>> decision_tree = DecisionTreeClassifier(random_state=0, max_depth=2)

>>> decision_tree = decision_tree.fit(iris.data, iris.target)

>>> r = export_text(decision_tree, feature_names=iris['feature_names'])

>>> print(r)

|--- petal width (cm) <= 0.80

| |--- class: 0

|--- petal width (cm) > 0.80

| |--- petal width (cm) <= 1.75

| | |--- class: 1

| |--- petal width (cm) > 1.75

| | |--- class: 2

回归决策树还可以用到回归问题中，这需要使用DecisionTreeRegressor类。如同分类问题中的设置，fit方法接收数组X和y作为参数，在这种情况下，y应该是浮点数而非整数。>>> from sklearn import tree

>>> X = [[0, 0], [2, 2]]

>>> y = [0.5, 2.5]

>>> clf = tree.DecisionTreeRegressor()

>>> clf = clf.fit(X, y)

>>> clf.predict([[1, 1]])

array([0.5])

sklearn决策树的实际使用建议数据有大量特征时，决策树倾向于过拟合。使用合适的样本量和特征数量比很重要，因为在高维空间中如果只有少量样本很可能会过拟合。提前使用降维技术可以为你的决策树提供更多的找到具有判别能力特征的机会。理解决策树的结构会有助于理解决策树是如何做预测的，这对理解数据中的重要特征很重要。当训练模型时，使用export函数来可视化你的树。使用max_depth=3作为树的初始深度来初步感受一下树拟合数据的效果，然后增加树的深度。需要注意的是，树每增加一层，构成树所需要的样本量就要增加一倍，可以使用max_depth来控制树的大小，防止过拟合。控制哪些节点会分裂可以使用min_samples_split或min_samples_leaf两个参数。这两个参数设置的很小通常意味着会发生过拟合，而设置的很大会阻碍树的学习。可以设置min_samples_leaf=5作为初始值来进行尝试。如果不同节点的样本量变化很大，可以给这两个参数传递浮点数以节点样本量百分比的方式来使用。尽管min_samples_split可以创建任意小的叶子节点，但是min_samples_leaf保证了每一个叶子节点有一个最小样本量，从而避免了回归问题中的低方差和过拟合叶子节点。对于分类问题，min_samples_leaf=1通常是最佳选择。训练数据之前，平衡你的数据集来防止树偏向数据中的主导类。平衡数据可以通过从每个类中抽取相等数量的样本或者将每个类样本权重（sample_weight）的和标准化为一个相同的值来实现。应注意的是，以权重为基础的预剪枝标准，例如min_weight_fraction_leaf，将比不关注样本权重的标准min_samples_leaf更不易偏向主导类。如果样本是加权的，使用以权重为基础的预剪枝标准如min_weight_fraction_leaf更容易优化树的结构，这个标准定义的是叶子节点权重占样本总权重的最小值。在内部，所有的决策树使用np.float32数据类型，如果训练数据不是这种类型，会自动创建数据的一个副本。如果输入矩阵X非常稀疏，在调用fit和predict之前推荐转换为csc_matrix。当特征大部分取值为0时，相比于致密矩阵，稀疏矩阵的训练时间可以快一个数量级。编辑于 2022-11-07 12:11・IP 属地北京决策树算法sklearn赞同 4添加评论分享喜欢收藏申请转载文章被以下专栏收录用Numpy学机器学习使用Numpy实现主流机器学

sklearn.tree.DecisionTreeClassifier — scikit-learn 1.4.1 documentation

Install

User Guide

API

Examples

Community

Getting Started

Tutorial

What's new

Glossary

Development

FAQ

Support

Related packages

Roadmap

Governance

About us

GitHub

Other Versions and Download

Getting Started

Tutorial

What's new

Glossary

Development

FAQ

Support

Related packages

Roadmap

Governance

About us

GitHub

Other Versions and Download

Toggle Menu

PrevUp

scikit-learn 1.4.1

Other versions

Please cite us if you use the software.

sklearn.tree.DecisionTreeClassifier

DecisionTreeClassifier

DecisionTreeClassifier.apply

DecisionTreeClassifier.cost_complexity_pruning_path

DecisionTreeClassifier.decision_path

DecisionTreeClassifier.feature_importances_

DecisionTreeClassifier.fit

DecisionTreeClassifier.get_depth

DecisionTreeClassifier.get_metadata_routing

DecisionTreeClassifier.get_n_leaves

DecisionTreeClassifier.get_params

DecisionTreeClassifier.predict

DecisionTreeClassifier.predict_log_proba

DecisionTreeClassifier.predict_proba

DecisionTreeClassifier.score

DecisionTreeClassifier.set_fit_request

DecisionTreeClassifier.set_params

DecisionTreeClassifier.set_predict_proba_request

DecisionTreeClassifier.set_predict_request

DecisionTreeClassifier.set_score_request

Examples using sklearn.tree.DecisionTreeClassifier

sklearn.tree.DecisionTreeClassifier¶

class sklearn.tree.DecisionTreeClassifier(*, criterion='gini', splitter='best', max_depth=None, min_samples_split=2, min_samples_leaf=1, min_weight_fraction_leaf=0.0, max_features=None, random_state=None, max_leaf_nodes=None, min_impurity_decrease=0.0, class_weight=None, ccp_alpha=0.0, monotonic_cst=None)[source]¶

A decision tree classifier.

1.10. 决策树 - sklearn

sklearn

sklearn 中文文档

安装 scikit-learn

1. 监督学习

1.0 监督学习

1.1. 广义线性模型

1.2. 线性和二次判别分析

1.3. 内核岭回归

1.4. 支持向量机

1.5. 随机梯度下降

1.6. 最近邻

1.7. 高斯过程

1.8. 交叉分解

1.9. 朴素贝叶斯

1.10. 决策树

1.10.1. 分类

1.10.2. 回归

1.10.3. 多值输出问题

1.10.4. 复杂度分析

1.10.5. 实际使用技巧

1.10.6. 决策树算法: ID3, C4.5, C5.0 和 CART

1.10.7. 数学表达

1.10.7.1. 分类标准

1.10.7.2. 回归标准

1.11. 集成方法

1.12. 多类和多标签算法

1.13. 特征选择

1.14. 半监督学习

1.15. 等式回归

1.16. 概率校准

1.17. 神经网络模型（有监督）

2. 无监督学习

2.0 无监督学习

2.1. 高斯混合模型

2.2. 流形学习

2.3. 聚类

2.4. 双聚类

2.5. 分解成分中的信号（矩阵分解问题）

2.6. 协方差估计

2.7. 新奇和异常值检测

2.8. 密度估计

2.9. 神经网络模型（无监督）

3. 模型选择和评估

3.0 模型选择和评估

3.1. 交叉验证：评估估算器的表现

3.2. 调整估计器的超参数

3.3. 模型评估: 量化预测的质量

3.4. 模型持久化

3.5. 验证曲线: 绘制分数以评估模型

4. 检验

4.0 检验

4.1. 部分依赖图

5. 数据集转换

5.0 数据集转换

5.1. Pipeline（管道）和 FeatureUnion（特征联合）: 合并的评估器

5.2. 特征提取

5.3 预处理数据

5.4 缺失值插补

5.5. 无监督降维

5.6. 随机投影

5.7. 内核近似

5.8. 成对的矩阵, 类别和核函数

5.9. 预测目标

6. 数据集加载工具

6.0 数据集加载工具

6.1. 通用数据集 API

6.2. 玩具数据集

6.3 真实世界中的数据集

6.4. 样本生成器

6.5. 加载其他数据集

7. 使用scikit-learn计算

7.0 使用scikit-learn计算

7.1. 大规模计算的策略: 更大量的数据

7.2. 计算性能

7.3. 并行性、资源管理和配置

教程

使用 scikit-learn 介绍机器学习

关于科学数据处理的统计学习教程

机器学习: scikit-learn 中的设置以及预估对象

监督学习：从高维观察预测输出变量

模型选择：选择估计量及其参数

无监督学习: 寻求数据表示

把它们放在一起

寻求帮助

处理文本数据

选择正确的评估器(estimator.md

外部资源，视频和谈话

API 参考

常见问题

时光轴

sklearn

Docs »

1. 监督学习 »

1.10. 决策树

校验者:

@文谊

@皮卡乒的皮卡乓

@Loopy

翻译者:

@I Remember

Decision Trees (DTs) 是一种用来 classification 和 regression 的无参监督学习方法。其目的是创建一种模型从数据特征中学习简单的决策规则来预测一个目标变量的值。

例如，在下面的图片中，决策树通过if-then-else的决策规则来学习数据从而估测数一个正弦图像。决策树越深入，决策规则就越复杂并且对数据的拟合越好。

决策树的优势:

便于理解和解释。树的结构可以可视化出来。

训练需要的数据少。其他机器学习模型通常需要数据规范化，比如构建虚拟变量和移除缺失值,不过请注意，这种模型不支持缺失值。

由于训练决策树的数据点的数量导致了决策树的使用开销呈指数分布(训练树模型的时间复杂度是参与训练数据点的对数值)。

能够处理数值型数据和分类数据。其他的技术通常只能用来专门分析某一种变量类型的数据集。详情请参阅算法。

能够处理多路输出的问题。

使用白盒模型。如果某种给定的情况在该模型中是可以观察的，那么就可以轻易的通过布尔逻辑来解释这种情况。相比之下，在黑盒模型中的结果就是很难说明清楚地。

可以通过数值统计测试来验证该模型。这对事解释验证该模型的可靠性成为可能。

即使该模型假设的结果与真实模型所提供的数据有些违反，其表现依旧良好。

决策树的缺点包括:

决策树模型容易产生一个过于复杂的模型,这样的模型对数据的泛化性能会很差。这就是所谓的过拟合.一些策略像剪枝、设置叶节点所需的最小样本数或设置数的最大深度是避免出现该问题最为有效地方法。

决策树可能是不稳定的，因为数据中的微小变化可能会导致完全不同的树生成。这个问题可以通过决策树的集成来得到缓解

在多方面性能最优和简单化概念的要求下，学习一棵最优决策树通常是一个NP难问题。因此，实际的决策树学习算法是基于启发式算法，例如在每个节点进行局部最优决策的贪心算法。这样的算法不能保证返回全局最优决策树。这个问题可以通过集成学习来训练多棵决策树来缓解,这多棵决策树一般通过对特征和样本有放回的随机采样来生成。

有些概念很难被决策树学习到,因为决策树很难清楚的表述这些概念。例如XOR，奇偶或者复用器的问题。

如果某些类在问题中占主导地位会使得创建的决策树有偏差。因此，我们建议在拟合前先对数据集进行平衡。

1.10.1. 分类

DecisionTreeClassifier 是能够在数据集上执行多分类的类,与其他分类器一样，DecisionTreeClassifier 采用输入两个数组：数组X，用 [n_samples, n_features] 的方式来存放训练样本。整数值数组Y，用 [n_samples] 来保存训练样本的类标签:

>>> from sklearn import tree

>>> X = [[0, 0], [1, 1]]

>>> Y = [0, 1]

>>> clf = tree.DecisionTreeClassifier()

>>> clf = clf.fit(X, Y)

执行通过之后，可以使用该模型来预测样本类别:

>>> clf.predict([[2., 2.]])

array([1])

另外，也可以预测每个类的概率，这个概率是叶中相同类的训练样本的分数:

>>> clf.predict_proba([[2., 2.]])

array([[ 0., 1.]])

DecisionTreeClassifier 既能用于二分类（其中标签为[-1,1]）也能用于多分类（其中标签为[0,…,k-1]）。使用Lris数据集，我们可以构造一个决策树，如下所示:

>>> from sklearn.datasets import load_iris

>>> from sklearn import tree

>>> iris = load_iris()

>>> clf = tree.DecisionTreeClassifier()

>>> clf = clf.fit(iris.data, iris.target)

经过训练，我们可以使用 export_graphviz 导出器以 Graphviz 格式导出决策树. 如果你是用 conda 来管理包，那么安装 graphviz 二进制文件和 python 包可以用以下指令安装

conda install python-graphviz

或者，可以从 graphviz 项目主页下载 graphviz 的二进制文件，并从 pypi 安装: Python 包装器，并安装 pip install graphviz .以下是在整个 iris 数据集上训练的上述树的 graphviz 导出示例; 其结果被保存在 iris.pdf 中:

>>> import graphviz

>>> dot_data = tree.export_graphviz(clf, out_file=None)

>>> graph = graphviz.Source(dot_data)

>>> graph.render("iris")

export_graphviz 还支持各种美化，包括通过他们的类着色节点（或回归值），如果需要，还能使用显式变量和类名。Jupyter notebook也可以自动内联式渲染这些绘制节点:

>>> dot_data = tree.export_graphviz(clf, out_file=None,

... feature_names=iris.feature_names,

... class_names=iris.target_names,

... filled=True, rounded=True,

... special_characters=True)

>>> graph = graphviz.Source(dot_data)

>>> graph

示例:

* Plot the decision surface of a decision tree on the iris dataset

1.10.2. 回归

决策树通过使用 DecisionTreeRegressor 类也可以用来解决回归问题。如在分类设置中，拟合方法将数组X和数组y作为参数，只有在这种情况下，y数组预期才是浮点值:

>>> from sklearn import tree

>>> X = [[0, 0], [2, 2]]

>>> y = [0.5, 2.5]

>>> clf = tree.DecisionTreeRegressor()

>>> clf = clf.fit(X, y)

>>> clf.predict([[1, 1]])

array([ 0.5])

示例:

* Decision Tree Regression

1.10.3. 多值输出问题

一个多值输出问题是一个类似当 Y 是大小为 [n_samples, n_outputs] 的2d数组时，有多个输出值需要预测的监督学习问题。

当输出值之间没有关联时，一个很简单的处理该类型的方法是建立一个n独立模型，即每个模型对应一个输出，然后使用这些模型来独立地预测n个输出中的每一个。然而，由于可能与相同输入相关的输出值本身是相关的，所以通常更好的方法是构建能够同时预测所有n个输出的单个模型。首先，因为仅仅是建立了一个模型所以训练时间会更短。第二，最终模型的泛化性能也会有所提升。对于决策树，这一策略可以很容易地用于多输出问题。这需要以下更改：

在叶中存储n个输出值，而不是一个;

通过计算所有n个输出的平均减少量来作为分裂标准.

该模块通过在 DecisionTreeClassifier和 DecisionTreeRegressor 中实现该策略来支持多输出问题。如果决策树与大小为 [n_samples, n_outputs] 的输出数组Y向匹配，则得到的估计器:

* predict 是输出n_output的值

* 在 predict_proba 上输出 n_output 数组列表

用多输出决策树进行回归分析 Multi-output Decision Tree Regression 。在该示例中，输入X是单个实数值，并且输出Y是X的正弦和余弦。

使用多输出树进行分类，在 Face completion with a multi-output estimators 中进行了演示。在该示例中，输入X是面的上半部分的像素，并且输出Y是这些面的下半部分的像素。

示例:

* Multi-output Decision Tree Regression

* Face completion with a multi-output estimators

参考资料:

* M. Dumont et al, Fast multi-class image annotation with random subwindows and multiple output randomized trees, International Conference on Computer Vision Theory and Applications 2009

1.10.4. 复杂度分析

总体来说，用来构建平衡二叉树的运行时间为查询时间为。尽管树的构造算法尝试生成平衡树，但它们并不总能保持平衡。假设子树能大概保持平衡，每个节点的成本包括通过时间复杂度来搜索找到提供熵减小最大的特征。每个节点的花费为，从而使得整个决策树的构造成本为。

Scikit-learn提供了更多有效的方法来创建决策树。初始实现（如上所述）将重新计算沿着给定特征的每个新分割点的类标签直方图（用于分类）或平均值（用于回归）。与分类所有的样本特征，然后再次训练时运行标签计数，可将每个节点的复杂度降低为，则总的成本花费为。这是一种对所有基于树的算法的改进选项。默认情况下，对于梯度提升模型该算法是打开的，一般来说它会让训练速度更快。但对于所有其他算法默认是关闭的，当训练深度很深的树时往往会减慢训练速度。

1.10.5. 实际使用技巧

对于拥有大量特征的数据决策树会出现过拟合的现象。获得一个合适的样本比例和特征数量十分重要，因为在高维空间中只有少量的样本的树是十分容易过拟合的。

考虑事先进行降维( PCA , ICA ，使您的树更好地找到具有分辨性的特征。

通过 export 功能可以可视化您的决策树。使用 max_depth=3 作为初始树深度，让决策树知道如何适应您的数据，然后再增加树的深度。

请记住，填充树的样本数量会增加树的每个附加级别。使用 max_depth 来控制输的大小防止过拟合。

通过使用 min_samples_split 和 min_samples_leaf 来控制叶节点上的样本数量。当这个值很小时意味着生成的决策树将会过拟合，然而当这个值很大时将会不利于决策树的对样本的学习。所以尝试 min_samples_leaf=5 作为初始值。如果样本的变化量很大，可以使用浮点数作为这两个参数中的百分比。两者之间的主要区别在于 min_samples_leaf 保证叶结点中最少的采样数，而 min_samples_split 可以创建任意小的叶子，尽管在文献中 min_samples_split 更常见。

在训练之前平衡您的数据集，以防止决策树偏向于主导类.可以通过从每个类中抽取相等数量的样本来进行类平衡，或者优选地通过将每个类的样本权重 (sample_weight) 的和归一化为相同的值。还要注意的是，基于权重的预修剪标准 (min_weight_fraction_leaf) 对于显性类别的偏倚偏小，而不是不了解样本权重的标准，如 min_samples_leaf 。

如果样本被加权，则使用基于权重的预修剪标准 min_weight_fraction_leaf 来优化树结构将更容易，这确保叶节点包含样本权重的总和的至少一部分。

所有的决策树内部使用 np.float32 数组，如果训练数据不是这种格式，将会复制数据集。

如果输入的矩阵X为稀疏矩阵，建议您在调用fit之前将矩阵X转换为稀疏的csc_matrix ,在调用predict之前将 csr_matrix 稀疏。当特征在大多数样本中具有零值时，与密集矩阵相比，稀疏矩阵输入的训练时间可以快几个数量级。

1.10.6. 决策树算法: ID3, C4.5, C5.0 和 CART

所有种类的决策树算法有哪些以及它们之间的区别？scikit-learn 中实现何种算法呢？

ID3（Iterative Dichotomiser 3）由 Ross Quinlan 在1986年提出。该算法创建一个多路树，找到每个节点（即以贪心的方式）分类特征，这将产生分类目标的最大信息增益。决策树发展到其最大尺寸，然后通常利用剪枝来提高树对未知数据的泛华能力。

C4.5 是 ID3 的后继者，并且通过动态定义将连续属性值分割成一组离散间隔的离散属性（基于数字变量），消除了特征必须被明确分类的限制。C4.5 将训练的树（即，ID3算法的输出）转换成 if-then 规则的集合。然后评估每个规则的这些准确性，以确定应用它们的顺序。如果规则的准确性没有改变，则需要决策树的树枝来解决。

C5.0 是 Quinlan 根据专有许可证发布的最新版本。它使用更少的内存，并建立比 C4.5 更小的规则集，同时更准确。

CART（Classification and Regression Trees （分类和回归树））与 C4.5 非常相似，但它不同之处在于它支持数值目标变量（回归），并且不计算规则集。CART 使用在每个节点产生最大信息增益的特征和阈值来构造二叉树。

scikit-learn 使用 CART 算法的优化版本。

1.10.7. 数学表达

给定训练向量 , i=1,…, l 和标签向量。决策树递归地分割空间，例如将有相同标签的样本归为一组。

将节点上的数据用来表示。每一个候选组包含一个特征和阈值将,数据分成和子集。

使用不纯度函数计算处的不纯度,其选择取决于正在解决的任务（分类或回归）

选择使不纯度最小化的参数

在和上递归运算，直到达到最大允许深度，或。

1.10.7.1. 分类标准

对于节点，表示具有个观测值的区域，如果分类结果采用值是 0,1,…,K-1 的值，让

是节点中k类观测的比例通常用来处理杂质的方法是Gini

Cross-Entropy （交叉熵）

和 Misclassification （错误分类）

在训练节点上的数据时。

1.10.7.2. 回归标准

如果目标是连续性的值，那么对于节点 ,表示具有个观测值的区域，对于以后的分裂节点的位置的决定常用的最小化标准是均方差和平均绝对误差，前者使用终端节点处的平均值来最小化L2误差，后者使用终端节点处的中值来最小化 L1 误差。

Mean Squared Error （均方误差）:

Mean Absolute Error（平均绝对误差）:

在训练节点上的数据时。

示例:

* https://en.wikipedia.org/wiki/Decision_tree_learning

* https://en.wikipedia.org/wiki/Predictive_analytics

* L. Breiman, J. Friedman, R. Olshen, and C. Stone. Classification and Regression Trees. Wadsworth, Belmont, CA, 1984.

* J.R. Quinlan. C4. 5: programs for machine learning. Morgan Kaufmann, 1993.

* T. Hastie, R. Tibshirani and J. Friedman. Elements of Statistical Learning, Springer, 2009.

sklearn PythonOK 协议：CC BY-NC-SA 4.0

Built with MkDocs using a theme provided by Read the Docs.

« Previous

通俗地说决策树算法（三）sklearn决策树实战 - 知乎

通俗地说决策树算法（三）sklearn决策树实战 - 知乎首发于技术，数据，以及思维切换模式写文章登录/注册通俗地说决策树算法（三）sklearn决策树实战终日而思一心有猛虎，细嗅蔷薇。前情提要通俗地说决策树算法（一）基础概念介绍通俗地说决策树算法（二）实例解析上面两篇介绍了那么多决策树的知识，现在也是时候来实践一下了。Python有一个著名的机器学习框架，叫sklearn。我们可以用sklearn来运行前面说到的赖床的例子。不过在这之前，我们需要介绍一下sklearn中训练一颗决策树的具体参数。另外sklearn中训练决策树的默认算法是CART，使用CART决策树的好处是可以用它来进行回归和分类处理，不过这里我们只进行分类处理。一. sklearn决策树参数详解我们都知道，一个模型中很重要的一步是调参。在sklearn中，模型的参数是通过方法参数来决定的，以下给出sklearn中，决策树的参数：DecisionTreeClassifier(criterion="gini",

splitter="best",

max_depth=None,

min_samples_split=2,

min_samples_leaf=1,

min_weight_fraction_leaf=0.,

max_features=None,

random_state=None,

max_leaf_nodes=None,

min_impurity_decrease=0.,

min_impurity_split=None,

class_weight=None,

presort=False)

参数含义：

1.criterion:string, optional (default="gini")

(1).criterion='gini',分裂节点时评价准则是Gini指数。

(2).criterion='entropy',分裂节点时的评价指标是信息增益。

2.max_depth:int or None, optional (default=None)。指定树的最大深度。

如果为None，表示树的深度不限。直到所有的叶子节点都是纯净的，即叶子节点

中所有的样本点都属于同一个类别。或者每个叶子节点包含的样本数小于min_samples_split。

3.splitter:string, optional (default="best")。指定分裂节点时的策略。

(1).splitter='best',表示选择最优的分裂策略。

(2).splitter='random',表示选择最好的随机切分策略。

4.min_samples_split:int, float, optional (default=2)。表示分裂一个内部节点需要的做少样本数。

(1).如果为整数，则min_samples_split就是最少样本数。

(2).如果为浮点数(0到1之间)，则每次分裂最少样本数为ceil(min_samples_split * n_samples)

5.min_samples_leaf: int, float, optional (default=1)。指定每个叶子节点需要的最少样本数。

(1).如果为整数，则min_samples_split就是最少样本数。

(2).如果为浮点数(0到1之间)，则每个叶子节点最少样本数为ceil(min_samples_leaf * n_samples)

6.min_weight_fraction_leaf:float, optional (default=0.)

指定叶子节点中样本的最小权重。

7.max_features:int, float, string or None, optional (default=None).

搜寻最佳划分的时候考虑的特征数量。

(1).如果为整数，每次分裂只考虑max_features个特征。

(2).如果为浮点数(0到1之间)，每次切分只考虑int(max_features * n_features)个特征。

(3).如果为'auto'或者'sqrt',则每次切分只考虑sqrt(n_features)个特征

(4).如果为'log2',则每次切分只考虑log2(n_features)个特征。

(5).如果为None,则每次切分考虑n_features个特征。

(6).如果已经考虑了max_features个特征，但还是没有找到一个有效的切分，那么还会继续寻找

下一个特征，直到找到一个有效的切分为止。

8.random_state:int, RandomState instance or None, optional (default=None)

(1).如果为整数，则它指定了随机数生成器的种子。

(2).如果为RandomState实例，则指定了随机数生成器。

(3).如果为None，则使用默认的随机数生成器。

9.max_leaf_nodes: int or None, optional (default=None)。指定了叶子节点的最大数量。

(1).如果为None,叶子节点数量不限。

(2).如果为整数，则max_depth被忽略。

10.min_impurity_decrease:float, optional (default=0.)

如果节点的分裂导致不纯度的减少(分裂后样本比分裂前更加纯净)大于或等于min_impurity_decrease，则分裂该节点。

加权不纯度的减少量计算公式为：

min_impurity_decrease=N_t / N * (impurity - N_t_R / N_t * right_impurity

- N_t_L / N_t * left_impurity)

其中N是样本的总数，N_t是当前节点的样本数，N_t_L是分裂后左子节点的样本数，

N_t_R是分裂后右子节点的样本数。impurity指当前节点的基尼指数，right_impurity指

分裂后右子节点的基尼指数。left_impurity指分裂后左子节点的基尼指数。

11.min_impurity_split:float

树生长过程中早停止的阈值。如果当前节点的不纯度高于阈值，节点将分裂，否则它是叶子节点。

这个参数已经被弃用。用min_impurity_decrease代替了min_impurity_split。

12.class_weight:dict, list of dicts, "balanced" or None, default=None

类别权重的形式为{class_label: weight}

(1).如果没有给出每个类别的权重，则每个类别的权重都为1。

(2).如果class_weight='balanced'，则分类的权重与样本中每个类别出现的频率成反比。

计算公式为：n_samples / (n_classes * np.bincount(y))

(3).如果sample_weight提供了样本权重(由fit方法提供)，则这些权重都会乘以sample_weight。

13.presort:bool, optional (default=False)

指定是否需要提前排序数据从而加速训练中寻找最优切分的过程。设置为True时，对于大数据集

会减慢总体的训练过程；但是对于一个小数据集或者设定了最大深度的情况下，会加速训练过程。虽然看起来参数众多，但通常参数都会有默认值，我们只需要调整其中较为重要的几个参数就行。通常来说，较为重要的参数有：criterion：用以设置用信息熵还是基尼系数计算。splitter：指定分支模式max_depth：最大深度，防止过拟合min_samples_leaf：限定每个节点分枝后子节点至少有多少个数据，否则就不分枝二. sklearn决策树实战2.1 准备数据及读取数据就是上次说到的赖床特征，季节时间已过 8 点风力情况要不要赖床将它存储成 csv 文件spring,no,breeze,yes

winter,no,no wind,yes

autumn,yes,breeze,yes

winter,no,no wind,yes

summer,no,breeze,yes

winter,yes,breeze,yes

winter,no,gale,yes

winter,no,no wind,yes

spring,yes,no wind,no

summer,yes,gale,no

summer,no,gale,no

autumn,yes,breeze,no2.2 决策树的特征向量化DictVectorizersklearn的DictVectorizer能对字典进行向量化。什么叫向量化呢？比如说你有季节这个属性有[春,夏,秋,冬]四个可选值，那么如果是春季，就可以用[1,0,0,0]表示，夏季就可以用[0,1,0,0]表示。不过在调用DictVectorizer它会将这些属性打乱，不会按照我们的思路来运行，但我们也可以一个方法查看，我们看看代码就明白了。import pandas as pd

from sklearn.feature_extraction import DictVectorizer

from sklearn import tree

from sklearn.model_selection import train_test_split

#pandas 读取 csv 文件，header = None 表示不将首行作为列

data = pd.read_csv('data/laic.csv',header =None)

#指定列

data.columns = ['season','after 8','wind','lay bed']

#sparse=False意思是不产生稀疏矩阵

vec=DictVectorizer(sparse=False)

#先用 pandas 对每行生成字典，然后进行向量化

feature = data[['season','after 8','wind']]

X_train = vec.fit_transform(feature.to_dict(orient='record'))

#打印各个变量

print('show feature\n',feature)

print('show vector\n',X_train)

print('show vector name\n',vec.get_feature_names())我们来看看打印的结果：show feature

season after 8 wind

0 spring no breeze

1 winter no no wind

2 autumn yes breeze

3 winter no no wind

4 summer no breeze

5 winter yes breeze

6 winter no gale

7 winter no no wind

8 spring yes no wind

9 summer yes gale

10 summer no gale

11 autumn yes breeze

show vector

[[1. 0. 0. 1. 0. 0. 1. 0. 0.]

[1. 0. 0. 0. 0. 1. 0. 0. 1.]

[0. 1. 1. 0. 0. 0. 1. 0. 0.]

[1. 0. 0. 0. 0. 1. 0. 0. 1.]

[1. 0. 0. 0. 1. 0. 1. 0. 0.]

[0. 1. 0. 0. 0. 1. 1. 0. 0.]

[1. 0. 0. 0. 0. 1. 0. 1. 0.]

[1. 0. 0. 0. 0. 1. 0. 0. 1.]

[0. 1. 0. 1. 0. 0. 0. 0. 1.]

[0. 1. 0. 0. 1. 0. 0. 1. 0.]

[1. 0. 0. 0. 1. 0. 0. 1. 0.]

[0. 1. 1. 0. 0. 0. 1. 0. 0.]]

show vector name

['after 8=no', 'after 8=yes', 'season=autumn', 'season=spring', 'season=summer',

'season=winter', 'wind=breeze', 'wind=gale', 'wind=no wind']通过DictVectorizer，我们就能够把字符型的数据，转化成0 1的矩阵，方便后面进行运算。额外说一句，这种转换方式其实就是one-hot编码。2.4 决策树训练可以发现在向量化的时候，属性都被打乱了，但我们也可以通过get_feature_names()这个方法查看对应的属性值。有了数据后，就可以来训练一颗决策树了，用sklearn很方便，只需要很少的代码#划分成训练集，交叉集，验证集，不过这里我们数据量不够大，没必要

#train_x, test_x, train_y, test_y = train_test_split(X_train, Y_train, test_size = 0.3)

#训练决策树

clf = tree.DecisionTreeClassifier(criterion='gini')

clf.fit(X_train,Y_train)

#保存成 dot 文件，后面可以用 dot out.dot -T pdf -o out.pdf 转换成图片

with open("out.dot", 'w') as f :

f = tree.export_graphviz(clf, out_file = f,

feature_names = vec.get_feature_names())2.5 决策树可视化当完成一棵树的训练的时候，我们也可以让它可视化展示出来，不过sklearn没有提供这种功能，它仅仅能够让训练的模型保存到dot文件中。但我们可以借助其他工具让模型可视化，先看保存到dot的代码：from sklearn import tree

with open("out.dot", 'w') as f :

f = tree.export_graphviz(clf, out_file = f,

feature_names = vec.get_feature_names())

决策树可视化我们用Graphviz这个东西。当然需要先用pip安装对应的库类。然后再去官网下载它的一个发行版本，用以将dot文件转化成pdf图片。官网下载方式如下：然后进入到上面保存好的dot所在目录，打开cmd运行dot out.dot -T pdf -o out.pdf 命令，pdf 图片就会出现了。小结：今天我们介绍了sklearn，决策树模型的各个参数，并且使用sklearn模型对上一节中的例子训练出一个决策树模型，然后用Graphviz让决策树模型可视化。到此，决策树算法算是讲完啦。以上发布于 2019-08-06 18:34PythonJava机器学习赞同 484 条评论分享喜欢收藏申请转载文章被以下专栏收录技术，数据，以

1.10 决策树-scikit-learn中文社区

安装

用户指南

API

案例

入门

教程

更新日志

词汇表

常见问题

交流群

Toggle Menu

CDA数据科学研究院提供翻译支持

1.10 决策树

1.10.1 分类

1.10.2 回归

1.10.3 多输出问题

1.10.4 复杂度

1.10.5 实用技巧

1.10.6 树算法：ID3、C4.5、C5.0和CART

1.10.7 数学公式

1.10.8 最小成本复杂度剪枝

1.10 决策树¶

决策树(DTs)是一种用于分类和回归的非参数有监督学习方法。其目标是创建一个模型，通过学习从数据特性中推断出的简单决策规则来预测目标变量的值。

例如，在下面的示例中，决策树从数据中学习，用一组if-then-else的决策规则来逼近正弦曲线。树越深，决策规则越复杂，模型越适合。

决策树的一些优点：

易于理解和解释。树可以被可视化。几乎不需要数据准备。其他算法通常需要数据标准化，需要创建虚拟变量并删除缺失值。但是，请注意，此模块不支持缺失值。使用树的成本(即预测数据)是用于训练树的数据点数的对数。能够处理数值型和分类型数据。其他技术通常专门分析只有一种类型变量的数据集。有关更多信息，请参见algorithms 。能够处理多输出问题。使用白盒模型。如果给定的情况在模型中是可以观察到的，那么对条件的解释就很容易用布尔逻辑来解释。相反，在黑箱模型中(例如，在人工神经网络中)，结果可能很难解释。可以使用统计测试验证模型。这样就有可能对模型的可靠性作出解释。即使它的假设在某种程度上被生成数据的真实模型所违背，它也表现得很好。

决策树的缺点包括：

决策树学习器可以创建过于复杂的树，不能很好地概括数据。这就是所谓的过拟合。为了避免这个问题，必须设置剪枝、设置叶节点所需的最小样本数或设置树的最大深度等机制。

决策树可能是不稳定的，因为数据中的小变化可能导致生成完全不同的树。通过集成决策树来缓解这个问题。

学习最优决策树的问题在最优性的几个方面都是NP-complete的，甚至对于简单的概念也是如此。因此，实际的决策树学习算法是基于启发式算法，如贪婪算法，在每个节点上进行局部最优决策。这种算法不能保证返回全局最优决策树。这可以通过训练多棵树再集成一个学习器来缓解，其中特征和样本被随机抽取并替换。

有些概念很难学习，因为决策树不能很容易地表达它们，例如异或、奇偶校验或多路复用器问题。

如果某些类占主导地位，则决策树学习者会创建有偏见的树。因此，建议在拟合决策树之前平衡数据集。

1.10.1 分类

DecisionTreeClassifier 是一个能够在数据集上执行多类分类的类。

与其他分类器一样，DecisionTreeClassifier使用两个数组作为输入：形状为[n_samples, n_features]的数组(稀疏或稠密)，以及整数值数组，形状[n_samples]，保存训练样本的类标签：

>>> from sklearn import tree>>> X = [[0, 0], [1, 1]]>>> Y = [0, 1]>>> clf = tree.DecisionTreeClassifier()>>> clf = clf.fit(X, Y)

经拟合后，该模型可用于预测其他样本的类别：

>>> clf.predict([[2., 2.]])array([1])

或者，可以预测属于每一类别的概率，即同一类的训练样本在一片叶子中的分数：

>>> clf.predict_proba([[2., 2.]])array([[0., 1.]])

DecisionTreeClassifier 既能够进行二分类(其中标签为[-1，1])，也能够进行多类分类(其中标签为[0，…K-1])分类。

使用Iris数据集，我们可以构建如下树：

>>> from sklearn.datasets import load_iris>>> from sklearn import tree>>> X, y = load_iris(return_X_y=True)>>> clf = tree.DecisionTreeClassifier()>>> clf = clf.fit(X, y)

一旦经过训练，就可以用 plot_tree函数绘制树：

>>> tree.plot_tree(clf)

我们还可以使用 export_graphviz导出器以 Graphviz 格式导出树。如果使用 conda包管理器，则可以使用 conda install python-graphviz安装Graphviz二进制文件和python包。

另外，还可以从Graphviz项目主页下载用于Graphviz的二进制文件，并从pypi使用 pip install graphviz安装Python包装器并安装Graphviz。

下面是对整个 iris 数据集进行训练的树的图形输出示例；结果保存在一个输出文件iris.pdf中：

>>> import graphviz >>> dot_data = tree.export_graphviz(clf, out_file=None) >>> graph = graphviz.Source(dot_data) >>> graph.render("iris")

>>> dot_data = tree.export_graphviz(clf, out_file=None, ... feature_names=iris.feature_names, ... class_names=iris.target_names, ... filled=True, rounded=True, ... special_characters=True) >>> graph = graphviz.Source(dot_data) >>> graph

或者，还可以使用函数 export_text以文本格式导出树。此方法不需要安装外部库，而且更紧凑：

>>> from sklearn.datasets import load_iris>>> from sklearn.tree import DecisionTreeClassifier>>> from sklearn.tree import export_text>>> iris = load_iris()>>> decision_tree = DecisionTreeClassifier(random_state=0, max_depth=2)>>> decision_tree = decision_tree.fit(iris.data, iris.target)>>> r = export_text(decision_tree, feature_names=iris['feature_names'])>>> print(r)|--- petal width (cm) <= 0.80| |--- class: 0|--- petal width (cm) > 0.80| |--- petal width (cm) <= 1.75| | |--- class: 1| |--- petal width (cm) > 1.75| | |--- class: 2

示例

在iris数据集中绘制决策树的决策面理解决策树结构

1.10.2 回归

决策树也可以应用于回归问题，使用DecisionTreeRegressor 类。

与分类的设置一样，fit方法需要参数数组X和y，只是在这种情况下，y可以有浮点数值，而不是整数值：

>>> from sklearn import tree>>> X = [[0, 0], [2, 2]]>>> y = [0.5, 2.5]>>> clf = tree.DecisionTreeRegressor()>>> clf = clf.fit(X, y)>>> clf.predict([[1, 1]])array([0.5])

示例

决策树回归

1.10.3 多输出问题

多输出问题是一个具有多个输出预测的有监督学习问题，即 Y 是一个大小为二维的数组[n_samples, n_outputs]。

当输出之间没有相关性时，解决这类问题的一个非常简单的方法是建立n个独立的模型，即对于每个输出，利用这些模型独立地预测n个输出的每一个。但是，由于可能由于输出的值与同样的输入本身是相关的，所以通常更好的方法是建立一个能够同时预测所有n个输出的单一模型。首先，它需要较低的训练时间，因为只需要建立一个简单的估计器。其次，估计结果的泛化精度往往会提高。

对于决策树，这种策略可以很容易地用于支持多输出问题。这需要进行以下更改：

将n个输出值存储在叶子中，而不是1；通过计算所有n个输出的平均减少量来作为分裂标准。

该模块通过在 DecisionTreeClassifier 和DecisionTreeRegressor 中实现该策略来支持多输出问题。如果一个决策树在形状为 [n_samples, n_outputs] 的输出数组Y上进行拟合，则得到的估计器:

predict输出的是 n_output 的值;在predict_proba上输出类概率数组n_output的列表。

多输出决策树回归中说明了多输出树在回归上的应用。在该示例中，输入X是单个实数值，并且输出Y是X的正弦和余弦。

在使用多输出估算器完成人脸绘制中演示了多输出树的分类的使用。在这个例子中，输入X是人脸的上半部分的像素，输出Y是这些人脸的下半部的像素。

示例

多输出决策树回归使用多输出估算器完成人脸绘制

参考

M. Dumont et al, Fast multi-class image annotation with random subwindows and multiple output randomized trees, International Conference on Computer Vision Theory and Applications 2009

1.10.4 复杂度

通常，构建平衡二叉树的运行时间代价是和查询时间是。虽然树构造算法试图生成平衡树，但它们并不总是平衡的。假设子树保持近似平衡，每个节点的代价成本是通过搜索找到熵减少最大的特征。这在每个节点上的成本为，导致整个树的总成本(通过将每个节点的成本求和)是。

1.10.5 实用技巧

对于拥有大量特征的数据决策树会趋向于过拟合。获得一个合适的样本与特征的比例十分重要，因为具有高维空间中只有少量的样本的，那树是十分容易过拟合的。

考虑在此之前进行降维((PCA, ICA, 或者 Feature selection) )，以便给您的树更好的机会找到更有区分度的特征。

通过 export 功能可以可视化您的决策树。使用 max_depth=3 作为初始树深度，让决策树知道如何适应您的数据，然后再增加树的深度。

了解决策树结构理解决策树的结构将有助于更深入地了解决策树是如何进行预测的，这对于理解数据中的重要特性非常重要。

通过 export 功能可以可视化您的决策树。使用 max_depth=3 作为初始树深度，让决策树知道如何适应您的数据，然后再增加树的深度。

通过使用 min_samples_split 和 min_samples_leaf 确保多个样本通知树中的每个决策，方法是控制将考虑哪些分割。当这个值很小时意味着生成的决策树将会过拟合，然而当这个值很大时将会不利于决策树的对样本进行学习。尝试 min_samples_leaf=5 作为初始值。如果样本的变化量很大，可以使用浮点数作为这两个参数中的百分比。当min_samples_split 可以产生任意小的叶子时，, min_samples_leaf保证每个叶子都有最小的大小，避免了回归问题中的低方差、过拟合的叶节点。对于少数类的分类，min_samples_leaf=1通常是最好的选择。

在训练前平衡数据集，以防止树偏向于占主导地位的类。类平衡可以通过从每个类中抽取相同数量的样本来实现，或者最好通过将每个类的样本权重(sample_weight)之和归一化为相同的值来实现。还要注意的是，基于权重的预剪枝准则(如 min_weight_fraction_leaf)将比不知道样本权重的标准(如min_samples_leaf)更倾向于优势类。

如果样本是加权的，则使用基于权重的预剪枝准则(如min_weight_fraction_leaf)来优化树结构，这样可以确保叶节点至少包含样本权重的总和的一部分。

所有决策树都在内部使用np.float32数组。如果训练数据不是这种格式，则将复制数据集。

如果输入矩阵X非常稀疏，则建议在调用fit方法之前将其转换为稀疏 csc_matrix，在调用predict之前将其转换为稀疏csr_matrix。当大多数样本的特征值为零时，输入的稀疏矩阵训练时间比密集矩阵的训练时间快几个数量级。

1.10.6 树算法：ID3、C4.5、C5.0和CART

各种决策树算法是什么？它们之间有何不同？哪一种是在scikit-learn中实现的？

ID3(迭代分离 3)是由Ross Quinlan于1986年开发的。该算法建立了一个多路树，为每个节点(即贪婪地)寻找分类特征，从而为分类目标提供最大的信息增益。树生长到它们的最大尺寸，然后，通常采取一个剪枝步骤，以提高树的对位置数据的泛化能力。

c4.5是ID3的继承者，并且通过动态定义将连续属性值分割成一组离散间隔的离散属性（基于数字变量），从而消除了特征必须是分类的限制。c4.5将经过训练的树(即ID3算法的输出)转换成一组if-then规则的集合。然后对每条规则的这些准确性进行评估，以确定应用它们的顺序。如果规则的准确性没有提高的话，则需要决策树的树枝来解决。

c5.0是Quinlan在专有许可下发布的最新版本。与C4.5相比，它使用更少的内存和构建更小的规则集，同时更精确。

CART (分类和回归树)与C4.5非常相似，但它的不同之处在于它支持数值目标变量(回归)，不计算规则集。CART使用特征和阈值构造二叉树，在每个节点上获得最大的信息增益。

scikit-learn使用 CART算法的优化版本；但是目前，scikit-learn实现不支持分类变量。

1.10.7 数学公式

给定训练向量 I和标签向量，决策树递归地划分空间，使得具有相同标签的样本被分到一样的组。

让节点处的数据集用表示，对于一个由特征和阈值组成的候选划分数据集，将数据划分为和两个子集。

节点处的不存度用不存度函数计算，其选择取决于正在解决的任务(分类或回归)。

选择使不存度最小化的参数

对子集进行递归，直到达到最大允许的深度，。

1.10.7.1 分类标准

如果目标是变量的值0，1，…K-1的分类结果，对于节点，表示具有个观测值的区域，令：

表示的是节点中k类观测的比例。

常见的不存度度量的方法是 Gini

熵(Entropy)

和错误分类（Misclassification）

其中是节点中的训练数据。

1.10.7.2 回归标准

如果目标是连续性的值，那么对于节点 ,表示具有个观测值的区域，对于以后的分裂节点的位置的决定常用的最小化标准是均方误差和平均绝对误差，前者使用终端节点处的平均值来最小化L2误差，后者使用终端节点处的中值来最小化 L1 误差。

均方误差：

平均绝对误差：

其中是节点中的训练数据。

1.10.8 最小成本复杂度剪枝

最小代价复杂度剪枝是一种用于修剪树以避免过拟合的算法，在[BRE]第3章中描述了这种算法。该算法由α作为复杂度参数进行参数化。复杂度参数用于定义给定树的成本复杂度度量：

其中，是中的终端节点数，传统上定义为终端节点的总误分类率。或者，scikit-learn使用终端节点的总样本加权不存度作为。如上所述，节点的不存度取决于标准(criterion)。最小成本-复杂度剪枝找到的子树，使最小化。

单节点的代价复杂度度量为。被定义为一棵树，其中分支节点是它的根。一般而言，节点的不存度大于其叶子节点的不存度之和，。然而，节点及其分支的成本复杂度度量取决于α。我们定义了一个节点的有效为与它们相等的值，或者。一个非叶子节点，其最小的是最弱的连接(weakest link)，并将被修剪。当被剪枝的树的最小的比ccp_alpha参数大时，此过程将停止。

示例

具有成本复杂度的后剪枝决策树

参考

[BRE] L. Breiman, J. Friedman, R. Olshen, and C. Stone. Classification and Regression Trees. Wadsworth, Belmont, CA, 1984.

https://en.wikipedia.org/wiki/Decision_tree_learninghttps://en.wikipedia.org/wiki/Predictive_analyticsJ.R. Quinlan. C4. 5: programs for machine learning. Morgan Kaufmann, 1993.T. Hastie, R. Tibshirani and J. Friedman. Elements of Statistical Learning, Springer, 2009.

【机器学习sklearn】决策树（Decision Tree）算法_sklearn中决策树是什么算法-CSDN博客

【机器学习sklearn】决策树（Decision Tree）算法

最新推荐文章于 2024-03-04 18:43:35 发布

Moonuiu

最新推荐文章于 2024-03-04 18:43:35 发布

阅读量6.3k

点赞数

分类专栏：

sklearn

文章标签：

机器学习

决策树

算法

本文链接：https://blog.csdn.net/weixin_43182102/article/details/122106265

版权

sklearn

专栏收录该内容

8 篇文章

0 订阅

订阅专栏

提示：这里是一只努力肯的小白有错就改非礼勿喷:)

决策树算法

前言一、决策树学习基本算法1.信息熵（Information Entropy）2.信息增益（Information gain）- ID3决策树3.增益率（Gain Ratio）- C4.5决策树4.基尼指数（Gini Index）- CART决策树5.剪枝处理（Pruning）（1）预剪枝（prepruning）（2）后剪枝（postpruning）

二、利用决策树进行鸢尾花数据集分类预测

前言

天可补，海可填，南山可移，日月既往，不可复追。

决策树（Decision Tree）是基于树结构来进行决策的。（分类、回归）一棵决策树包含一个根结点、若干个内部节点和若干个叶结点。最终目的是将样本越分越纯。 “伯乐相马” 好典故！！！（摘自决策树分类算法（if-else原理））

tips: 路漫漫其修远兮吾将上下而求索

一、决策树学习基本算法

决策树学习的目的是为了产生一棵泛化能力强，即处理未见示例能力强的决策树，遵循“分而治之”（divide-and-conquer）策略。其生成是一个递归的过程。下图为机器学习中的决策树学习基本算法流程（请认真体会~）。

1.信息熵（Information Entropy）

决策树学习的关键是如何选择最优划分属性。划分过程中，决策树的分支结点所包含的样本尽可能属于同一类别，结点的“纯度”（purity）越来越高。

信息熵是度量样本集合纯度最常用的一种指标。假定当前样本集合

D中第

k类样本所占的比例来为

(

∣

)

p_k \ (k=1,2,...,|y|)

pk (k=1,2,...,∣y∣)，则

D的信息熵定义为

(

)

−

∑

∣

Ent(D)=-\sum_{k=1}^{|y|}p_k \ log_2\ p_k

Ent(D)=−k=1∑∣y∣pk log2 pk

(

)

Ent(D)

Ent(D)的值越小，则

D的纯度越高。

2.信息增益（Information gain）- ID3决策树

假定离散属性

a有

V个可能的取值

{

}

\lbrace a^1,a^2,...,a^V \rbrace

{a1,a2,...,aV}，若使用

a来对样本集

D进行划分，则会产生

V个分支结点，其中第

v个分支结点包含了

D中所有在属性

a上取值为

a^v

av的样本，即为

D^v

Dv。

给分支结点赋予权重

∣

\frac{|D^v|} {|D|}

∣D∣∣Dv∣，样本数越多的分支结点的影响越大，信息增益越大，使用属性a对样本集

D进行划分所获得的纯度提升越大。

(

)

(

)

−

∑

∣

(

)

Gain(D,a)=Ent(D)-\sum_{v=1}^{V} \frac {|D^v|} {|D|}Ent(D^v)

Gain(D,a)=Ent(D)−v=1∑V∣D∣∣Dv∣Ent(Dv)

ID3（Iterative Dichotomiser，迭代二分器）决策树学习算法，以信息增益准则来选择划分属性。信息增益准则对可取值数目较多的属性有所偏好。从属性集A中选择最优划分属性

∗

∈

(

)

a_*=\underset{a \in A}{arg\ max\ } Gain(D,a)

a∗=a∈Aarg max Gain(D,a)。

3.增益率（Gain Ratio）- C4.5决策树

C4.5决策树算法不直接使用信息增益，而是使用增益率来选择最优划分属性。增益率准则对可取值数目较少的属性有所偏好。

(

)

(

)

(

)

Gain\_ratio(D,a)= \frac {Gain(D,a)} {IV(a)}

Gain_ratio(D,a)=IV(a)Gain(D,a) 其中，

(

)

−

∑

∣

IV(a)=-\sum_{v=1}^{V} \frac {|D^v|} {|D|}log_2 \frac {|D^v|} {|D|}

IV(a)=−v=1∑V∣D∣∣Dv∣log2∣D∣∣Dv∣ 称为属性a的固有值（Intrinsic Value）。属性a的可能取值数目越多，则

(

)

IV(a)

IV(a)的值通常会越大。

C4.5决策树并未完全使用“增益率”代替“信息增益”，而是采用一种启发式的方法：先选出信息增益高于平均水平的属性，然后再从中选择增益率最高的。

4.基尼指数（Gini Index）- CART决策树

CART（Classification and Regression Tree）决策树使用基尼指数来选择划分属性。数据集

D的纯度，用基尼值度量为：

(

)

∑

∣

∑

′

≠

′

−

∑

∣

Gini(D)=\sum_{k=1}^{|y|} \sum_{k'\not= k} p_kp_k'=1-\sum_{k=1}^{|y|}p_k^2

Gini(D)=k=1∑∣y∣k′=k∑pkpk′=1−k=1∑∣y∣pk2

(

)

Gini(D)

Gini(D)的值越小，则

D的纯度越高。

属性a的基尼指数定义为：

(

)

∑

∣

(

)

Gini\_index(D,a)= \sum_{v=1}^{V} \frac {|D^v|} {|D|} Gini(D)

Gini_index(D,a)=v=1∑V∣D∣∣Dv∣Gini(D) 从属性集A中选择基尼指数最小的属性作为最优划分属性

∗

∈

(

)

a_*=\underset{a \in A}{arg\ min\ } Gini\_index(D,a)

a∗=a∈Aarg min Gini_index(D,a)。

5.剪枝处理（Pruning）

剪枝处理是决策树算法处理“过拟合”的主要方式，即主动去掉一些分支来降低过拟合的风险。

朋友们可以自己补一下<奥卡姆剃刀准则>。从机器学习这本书中拿几张图，理解一下：

【西瓜数据集】未剪枝决策树流程图，选择属性“脐部”来对训练集进行划分判别西瓜的好坏。

决策树剪枝有两种基本策略：

（1）预剪枝（prepruning）

预剪枝是指在决策树生成过程中，对每个结点在划分前先进行估计，若当前结点的划分不能带来决策树泛化性能提升，则停止划分并将当前结点标记为叶结点。

（2）后剪枝（postpruning）

后剪枝是指先从训练集生成一棵完整的决策树，然后自底向上地对非叶结点进行考察，若将该结点对应的子树替换为叶结点能带来决策树泛化性能提升，则将该子树替换为叶结点。

后剪枝决策树往往比预剪枝决策树保留更多的分支，一般情况下，后剪枝决策树的欠拟合风险较小，泛化能力往往优于预剪枝决策树。但后剪枝的训练时间比未剪枝和预剪枝都要长。

二、利用决策树进行鸢尾花数据集分类预测

sklearn中的决策树分类器

criterion ： gini或者entropy，前者是基尼指数，后者是信息熵；max_depth ： int or None, optional (default=None) 设置决策随机森林中的决策树的最大深度，深度越大，越容易过拟合，推荐树的深度为：5-20之间；max_features： None（所有），log2，sqrt，N 特征小于50的时候一般使用所有的；max_leaf_nodes ：通过限制最大叶子节点数，可以防止过拟合，默认是"None”，即不限制最大的叶子节点数。

数据集划分api

sklearn.model_selection.train_test_split(arrays, *options)

参数： x 数据集的特征值 y 数据集的标签值 test_size 测试集的大小，一般为float random_state 随机数种子,不同的种子会造成不同的随机采样结果。相同的种子采样结果相同。return x_train, x_test, y_train, y_test

代码如下（示例）：

# pandas用于处理和分析数据

import pandas as pd

import numpy as np

# 导入鸢尾花数据集

from sklearn.datasets import load_iris

# 导入决策树分类器

from sklearn.tree import DecisionTreeClassifier

# # 导入分割数据集的方法

from sklearn.model_selection import train_test_split

# import relevant packages

from sklearn import tree

from sklearn.tree import export_text

# import matplotlib; matplotlib.use('TkAgg')

import matplotlib.pyplot as plt

# 利用决策树进行鸢尾花数据集分类预测

# 数据集字段说明：

# 特征值（4个）：sepal length（花萼长度），sepal width（花萼宽度）， petal length（花瓣长度），petal width（花瓣宽度）

# 目标值（3个）：target（类别，0为'setosa'山鸢尾花，1为'versicolor'变色鸢尾花，2为'virginica'维吉尼亚鸢尾花）

# load in the data加载数据

data = load_iris()

# convert to a dataframe 转换数据格式

df = pd.DataFrame(data.data, columns = data.feature_names)

# create the species column

df['Species'] = data.target

# replace this with the actual names

target = np.unique(data.target) # 对于一维数组或者列表，unique函数去除其中重复的元素，并按元素由大到小返回一个新的无元素重复的元组或者列表

target_names = np.unique(data.target_names)

targets = dict(zip(target, target_names))

df['Species'] = df['Species'].replace(targets)

# extract features and target variables 提取特征和目标变量

x = df.drop(columns="Species")

y = df["Species"]

# save the feature name and target variables 保存特征名称和目标变量

feature_names = x.columns

labels = y.unique() # 去除重复元素

# 分割训练集、测试集

# x 数据集的特征值

# y 数据集的标签值

# 训练集的特征值x_train 测试集的特征值x_test(test_x) 训练集的目标值y_train 测试集的目标值y_test(test_lab)

# random_state 随机数种子,不同的种子会造成不同的随机采样结果。相同的种子采样结果相同。

X_train, test_x, y_train, test_lab = train_test_split(x,y,

test_size = 0.4,

random_state = 42)

# 创建决策树分类器（树的最大深度为3）

model = DecisionTreeClassifier(max_depth =3, random_state = 42) # 初始化模型

model.fit(X_train, y_train) # 训练模型

print(model.score(test_x,test_lab)) # 评估模型分数

# 计算每个特征的重要程度

print(model.feature_importances_)

# 可视化特征属性结果

r = export_text(model, feature_names=data['feature_names'])

print(r)

# plt the figure, setting a black background

plt.figure(figsize=(30,10), facecolor ='g') # facecolor设置背景色

# create the tree plot 决策树绘图模块，实现决策树可视化

a = tree.plot_tree(model,

# use the feature names stored

feature_names = feature_names,

# use the class names stored

class_names = labels,

# label='all',

rounded = True,

filled = True,

fontsize=14,

)

# show the plot

# plt.legend(loc='lower right', borderpad=0, handletextpad=0)

plt.savefig("save.png", dpi=300, bbox_inches="tight")

# plt.tight_layout()

plt.show()

输出结果：

0.9833333333333333

[0. 0. 0.58908421 0.41091579]

|--- petal length (cm) <= 2.45

| |--- class: setosa

|--- petal length (cm) > 2.45

| |--- petal width (cm) <= 1.75

| | |--- petal length (cm) <= 5.35

| | | |--- class: versicolor

| | |--- petal length (cm) > 5.35

| | | |--- class: virginica

| |--- petal width (cm) > 1.75

| | |--- petal length (cm) <= 4.85

| | | |--- class: virginica

| | |--- petal length (cm) > 4.85

| | | |--- class: virginica

优惠劵

Moonuiu

关注

踩

觉得还不错?

一键收藏

知道了

【机器学习sklearn】决策树（Decision Tree）算法

提示：这里是一只努力肯????的小白有错就改非礼勿喷:)决策树算法前言一、决策树学习基本算法1.信息熵（Information Entropy）2.信息增益（Information gain）- ID3决策树3.增益率（Gain Ratio）- C4.5决策树4.基尼指数（Gini Index）- CART决策树5.剪枝处理（Pruning）（1）预剪枝（prepruning）（2）后剪枝（postpruning）二、利用决策树进行鸢尾花数据集分类预测总结前言天可补，海可填，南山可移，日月既往

复制链接

扫一扫

专栏目录

Decision Tree_decisiontree_决策树_

10-01

决策树是一种机器学习的方法。决策树的生成算法有ID3

数据挖掘十大算法（一）：决策树算法 python和sklearn实现

【菜菜的sklearn】01 决策树 - 知乎

【菜菜的sklearn】01 决策树 - 知乎首发于菜菜的Sklearn切换模式写文章登录/注册【菜菜的sklearn】01 决策树赋范空间用最简单的语言，把算法讲的有深度~小伙伴们大家好~o(￣▽￣)ブ我是菜菜，这里是我的sklearn课堂第1期：决策树在sklearn中的实现和调参~我的开发环境是Jupyter lab，所用的库和版本大家参考：Python 3.7.1（你的版本至少要3.4以上Scikit-learn 0.20.0 （你的版本至少要0.19Graphviz 0.8.4 (没有画不出决策树哦，安装代码conda install python-graphvizNumpy 1.15.3, Pandas 0.23.4, Matplotlib 3.0.1, SciPy 1.1.0本文主要内容：

1 决策树概述

1.1 决策树是如何工作的

1.2 sklearn中的决策树

2 DecisionTreeClassifier

2.1 重要参数

2.1.1 criterion

2.1.2 random_state & splitter

2.1.3 剪枝参数

2.1.4 目标权重参数

2.2 重要属性和接口

2.3 实例：分类树在合成数集上的表现sklearn入门scikit-learn，又写作sklearn，是一个开源的基于python语言的机器学习工具包。它通过NumPy, SciPy和Matplotlib等python数值计算的库实现高效的算法应用，并且涵盖了几乎所有主流机器学习算法。http://scikit-learn.org/stable/index.html在工程应用中，用python手写代码来从头实现一个算法的可能性非常低，这样不仅耗时耗力，还不一定能够写出构架清晰，稳定性强的模型。更多情况下，是分析采集到的数据，根据数据特征选择适合的算法，在工具包中调用算法，调整算法的参数，获取需要的信息，从而实现算法效率和效果之间的平衡。而sklearn，正是这样一个可以帮助我们高效实现算法应用的工具包。sklearn有一个完整而丰富的官网，里面讲解了基于sklearn对所有算法的实现和简单应用。然而，这个官网是全英文的，并且现在没有特别理想的中文接口，市面上也没有针对sklearn非常好的书。因此，这门课的目的就是由简向繁地向大家解析sklearn的全面应用，帮助大家了解不同的机器学习算法有哪些可调参数，有哪些可用接口，这些接口和参数对算法来说有什么含义，又会对算法的性能及准确性有什么影响。我们会讲解sklearn中对算法的说明，调参，属性，接口，以及实例应用。注意，本门课程的讲解不会涉及详细的算法原理，只会专注于算法在sklearn中的实现，如果希望详细了解算法的原理，建议阅读下面这本两本书：决策树1 概述1.1 决策树是如何工作的决策树（Decision Tree）是一种非参数的有监督学习方法，它能够从一系列有特征和标签的数据中总结出决策规则，并用树状图的结构来呈现这些规则，以解决分类和回归问题。决策树算法容易理解，适用各种数据，在解决各种问题时都有良好表现，尤其是以树模型为核心的各种集成算法，在各个行业和领域都有广泛的应用。我们来简单了解一下决策树是如何工作的。决策树算法的本质是一种图结构，我们只需要问一系列问题就可以对数据进行分类了。比如说，来看看下面这组数据集，这是一系列已知物种以及所属类别的数据：我们现在的目标是，将动物们分为哺乳类和非哺乳类。那根据已经收集到的数据，决策树算法为我们算出了下面的这棵决策树：假如我们现在发现了一种新物种Python，它是冷血动物，体表带鳞片，并且不是胎生，我们就可以通过这棵决策树来判断它的所属类别。可以看出，在这个决策过程中，我们一直在对记录的特征进行提问。最初的问题所在的地方叫做根节点，在得到结论前的每一个问题都是中间节点，而得到的每一个结论（动物的类别）都叫做叶子节点。关键概念：节点根节点：没有进边，有出边。包含最初的，针对特征的提问。中间节点：既有进边也有出边，进边只有一条，出边可以有很多条。都是针对特征的提问。叶子节点：有进边，没有出边，每个叶子节点都是一个类别标签。 *子节点和父节点：在两个相连的节点中，更接近根节点的是父节点，另一个是子节点。决策树算法的核心是要解决两个问题：1）如何从数据表中找出最佳节点和最佳分枝？2）如何让决策树停止生长，防止过拟合？几乎所有决策树有关的模型调整方法，都围绕这两个问题展开。这两个问题背后的原理十分复杂，我们会在讲解模型参数和属性的时候为大家简单解释涉及到的部分。在这门课中，我会尽量避免让大家太过深入到决策树复杂的原理和数学公式中（尽管决策树的原理相比其他高级的算法来说是非常简单了），这门课会专注于实践和应用。如果大家希望理解更深入的细节，建议大家在听这门课之前还是先去阅读和学习一下决策树的原理。1.2 sklearn中的决策树模块sklearn.treesklearn中决策树的类都在”tree“这个模块之下。这个模块总共包含五个类：tree.DecisionTreeClassifier：分类树tree.DecisionTreeRegressor：回归树tree.export_graphviz：将生成的决策树导出为DOT格式，画图专tree.ExtraTreeClassifier：高随机版本的分类树tree.ExtraTreeRegressor：高随机版本的回归树我们会主要讲解分类树和回归树，并用图像呈现给大家。sklearn的基本建模流程在那之前，我们先来了解一下sklearn建模的基本流程。在这个流程下，分类树对应的代码是：from sklearn import tree #导入需要的模块

clf = tree.DecisionTreeClassifier() #实例化

clf = clf.fit(X_train,y_train) #用训练集数据训练模型

result = clf.score(X_test,y_test) #导入测试集，从接口中调用需要的信息2 DecisionTreeClassifierclasssklearn.tree.DecisionTreeClassifier(criterion=’gini’, splitter=’best’, max_depth=None, min_samples_split=2, min_samples_leaf=1, min_weight_fraction_leaf=0.0, max_features=None, random_state=None, max_leaf_nodes=None, min_impurity_decrease=0.0, min_impurity_split=None, class_weight=None, presort=False)2.1 重要参数2.1.1 criterion为了要将表格转化为一棵树，决策树需要找出最佳节点和最佳的分枝方法，对分类树来说，衡量这个“最佳”的指标叫做“不纯度”。通常来说，不纯度越低，决策树对训练集的拟合越好。现在使用的决策树算法在分枝方法上的核心大多是围绕在对某个不纯度相关指标的最优化上。不纯度基于节点来计算，树中的每个节点都会有一个不纯度，并且子节点的不纯度一定是低于父节点的，也就是说，在同一棵决策树上，叶子节点的不纯度一定是最低的。Criterion这个参数正是用来决定不纯度的计算方法的。sklearn提供了两种选择：1）输入”entropy“，使用信息熵（Entropy）2）输入”gini“，使用基尼系数（Gini Impurity）Entropy(t) = -\sum_{i=0}^{c-1}p(i|t)log_2p(i|t)\\ Gini(t) = 1-\sum_{i=0}^{c-1}{p(i|t)}^2\\ 其中t代表给定的节点，i代表标签的任意分类， p(i|t) 代表标签分类i在节点t上所占的比例。注意，当使用信息熵时，sklearn实际计算的是基于信息熵的*信息增益*(Information Gain)，即父节点的信息熵和子节点的信息熵之差。比起基尼系数，信息熵对不纯度更加敏感，对不纯度的惩罚最强。但是在实际使用中，信息熵和基尼系数的效果基本相同。信息熵的计算比基尼系数缓慢一些，因为基尼系数的计算不涉及对数。另外，因为信息熵对不纯度更加敏感，所以信息熵作为指标时，决策树的生长会更加“精细”，因此对于高维数据或者噪音很多的数据，信息熵很容易过拟合，基尼系数在这种情况下效果往往比较好。当然，这不是绝对的。到这里，决策树的基本流程其实可以简单概括如下：直到没有更多的特征可用，或整体的不纯度指标已经最优，决策树就会停止生长。建立一棵树导入需要的算法库和模块from sklearn import tree

from sklearn.datasets import load_wine

from sklearn.model_selection import train_test_split探索数据wine = load_wine()

wine.data.shape

wine.target

#如果wine是一张表，应该长这样：

import pandas as pd

pd.concat([pd.DataFrame(wine.data),pd.DataFrame(wine.target)],axis=1)

wine.feature_names

wine.target_names分训练集和测试集Xtrain, Xtest, Ytrain, Ytest = train_test_split(wine.data,wine.target,test_size=0.3)

Xtrain.shape

Xtest.shape建立模型clf = tree.DecisionTreeClassifier(criterion="entropy")

clf = clf.fit(Xtrain, Ytrain)

score = clf.score(Xtest, Ytest) #返回预测的准确度

score画出一棵树吧feature_name = ['酒精','苹果酸','灰','灰的碱性','镁','总酚','类黄酮','非黄烷类酚类','花青素','颜色强度','色调','od280/od315稀释葡萄酒','脯氨酸']

import graphviz

dot_data = tree.export_graphviz(clf

,feature_names= feature_name

,class_names=["琴酒","雪莉","贝尔摩德"]

,filled=True

,rounded=True

,out_file=None

)

graph = graphviz.Source(dot_data)

graph探索决策树#特征重要性

clf.feature_importances_

[*zip(feature_name,clf.feature_importances_)]我们已经在只了解一个参数的情况下，建立了一棵完整的决策树。但是回到步骤4建立模型，score会在某个值附近波动，引起步骤5中画出来的每一棵树都不一样。它为什么会不稳定呢？如果使用其他数据集，它还会不稳定吗？我们之前提到过，无论决策树模型如何进化，在分枝上的本质都还是追求某个不纯度相关的指标的优化，而正如我们提到的，不纯度是基于节点来计算的，也就是说，决策树在建树时，是靠优化节点来追求一棵优化的树，但最优的节点能够保证最优的树吗？集成算法被用来解决这个问题：sklearn表示，既然一棵树不能保证最优，那就建更多的不同的树，然后从中取最好的。怎样从一组数据集中建不同的树？在每次分枝时，不从使用全部特征，而是随机选取一部分特征，从中选取不纯度相关指标最优的作为分枝用的节点。这样，每次生成的树也就不同了。clf = tree.DecisionTreeClassifier(criterion="entropy",random_state=30)

clf = clf.fit(Xtrain, Ytrain)

score = clf.score(Xtest, Ytest) #返回预测的准确度

score2.1.2 random_state & splitterrandom_state用来设置分枝中的随机模式的参数，默认None，在高维度时随机性会表现更明显，低维度的数据（比如鸢尾花数据集），随机性几乎不会显现。输入任意整数，会一直长出同一棵树，让模型稳定下来。splitter也是用来控制决策树中的随机选项的，有两种输入值，输入”best"，决策树在分枝时虽然随机，但是还是会优先选择更重要的特征进行分枝（重要性可以通过属性feature_importances_查看），输入“random"，决策树在分枝时会更加随机，树会因为含有更多的不必要信息而更深更大，并因这些不必要信息而降低对训练集的拟合。这也是防止过拟合的一种方式。当你预测到你的模型会过拟合，用这两个参数来帮助你降低树建成之后过拟合的可能性。当然，树一旦建成，我们依然是使用剪枝参数来防止过拟合。clf = tree.DecisionTreeClassifier(criterion="entropy"

,random_state=30

,splitter="random"

)

clf = clf.fit(Xtrain, Ytrain)

score = clf.score(Xtest, Ytest)

score

import graphviz

dot_data = tree.export_graphviz(clf

,feature_names= feature_name

,class_names=["琴酒","雪莉","贝尔摩德"]

,filled=True

,rounded=True

,out_file=None

)

graph = graphviz.Source(dot_data)

graph2.1.3 剪枝参数在不加限制的情况下，一棵决策树会生长到衡量不纯度的指标最优，或者没有更多的特征可用为止。这样的决策树往往会过拟合，这就是说，它会在训练集上表现很好，在测试集上却表现糟糕。我们收集的样本数据不可能和整体的状况完全一致，因此当一棵决策树对训练数据有了过于优秀的解释性，它找出的规则必然包含了训练样本中的噪声，并使它对未知数据的拟合程度不足。#我们的树对训练集的拟合程度如何？

score_train = clf.score(Xtrain, Ytrain)

score_train为了让决策树有更好的泛化性，我们要对决策树进行剪枝。剪枝策略对决策树的影响巨大，正确的剪枝策略是优化决策树算法的核心。sklearn为我们提供了不同的剪枝策略：max_depth限制树的最大深度，超过设定深度的树枝全部剪掉这是用得最广泛的剪枝参数，在高维度低样本量时非常有效。决策树多生长一层，对样本量的需求会增加一倍，所以限制树深度能够有效地限制过拟合。在集成算法中也非常实用。实际使用时，建议从=3开始尝试，看看拟合的效果再决定是否增加设定深度。min_samples_leaf & min_samples_split min_samples_leaf限定，一个节点在分枝后的每个子节点都必须包含至少min_samples_leaf个训练样本，否则分枝就不会发生，或者，分枝会朝着满足每个子节点都包含min_samples_leaf个样本的方向去发生一般搭配max_depth使用，在回归树中有神奇的效果，可以让模型变得更加平滑。这个参数的数量设置得太小会引起过拟合，设置得太大就会阻止模型学习数据。一般来说，建议从=5开始使用。如果叶节点中含有的样本量变化很大，建议输入浮点数作为样本量的百分比来使用。同时，这个参数可以保证每个叶子的最小尺寸，可以在回归问题中避免低方差，过拟合的叶子节点出现。对于类别不多的分类问题，=1通常就是最佳选择。min_samples_split限定，一个节点必须要包含至少min_samples_split个训练样本，这个节点才允许被分枝，否则分枝就不会发生。clf = tree.DecisionTreeClassifier(criterion="entropy"

,random_state=30

,splitter="random"

,max_depth=3

,min_samples_leaf=10

,min_samples_split=10

)

clf = clf.fit(Xtrain, Ytrain)

dot_data = tree.export_graphviz(clf

,feature_names= feature_name

,class_names=["琴酒","雪莉","贝尔摩德"]

,filled=True

,rounded=True

)

graph = graphviz.Source(dot_data)

graph

clf.score(Xtrain,Ytrain)

clf.score(Xtest,Ytest)max_features & min_impurity_decrease一般max_depth使用，用作树的”精修“max_features限制分枝时考虑的特征个数，超过限制个数的特征都会被舍弃。和max_depth异曲同工，max_features是用来限制高维度数据的过拟合的剪枝参数，但其方法比较暴力，是直接限制可以使用的特征数量而强行使决策树停下的参数，在不知道决策树中的各个特征的重要性的情况下，强行设定这个参数可能会导致模型学习不足。如果希望通过降维的方式防止过拟合，建议使用PCA，ICA或者特征选择模块中的降维算法。min_impurity_decrease限制信息增益的大小，信息增益小于设定数值的分枝不会发生。这是在0.19版本种更新的功能，在0.19版本之前时使用min_impurity_split。确认最优的剪枝参数那具体怎么来确定每个参数填写什么值呢？这时候，我们就要使用确定超参数的曲线来进行判断了，继续使用我们已经训练好的决策树模型clf。超参数的学习曲线，是一条以超参数的取值为横坐标，模型的度量指标为纵坐标的曲线，它是用来衡量不同超参数取值下模型的表现的线。在我们建好的决策树里，我们的模型度量指标就是score。import matplotlib.pyplot as plt

test = []

for i in range(10):

clf = tree.DecisionTreeClassifier(max_depth=i+1

,criterion="entropy"

,random_state=30

,splitter="random"

)

clf = clf.fit(Xtrain, Ytrain)

score = clf.score(Xtest, Ytest)

test.append(score)

plt.plot(range(1,11),test,color="red",label="max_depth")

plt.legend()

plt.show()思考：剪枝参数一定能够提升模型在测试集上的表现吗？ - 调参没有绝对的答案，一切都是看数据本身。这么多参数，一个个画学习曲线？无论如何，剪枝参数的默认值会让树无尽地生长，这些树在某些数据集上可能非常巨大，对内存的消耗。所以如果你手中的数据集非常大，你已经预测到无论如何你都是要剪枝的，那提前设定这些参数来控制树的复杂性和大小会比较好。2.1.4 目标权重参数class_weight & min_weight_fraction_leaf完成样本标签平衡的参数。样本不平衡是指在一组数据集中，标签的一类天生占有很大的比例。比如说，在银行要判断“一个办了信用卡的人是否会违约”，就是是vs否（1%：99%）的比例。这种分类状况下，即便模型什么也不做，全把结果预测成“否”，正确率也能有99%。因此我们要使用class_weight参数对样本标签进行一定的均衡，给少量的标签更多的权重，让模型更偏向少数类，向捕获少数类的方向建模。该参数默认None，此模式表示自动给与数据集中的所有标签相同的权重。有了权重之后，样本量就不再是单纯地记录数目，而是受输入的权重影响了，因此这时候剪枝，就需要搭配min_ weight_fraction_leaf这个基于权重的剪枝参数来使用。另请注意，基于权重的剪枝参数（例如min_weight_ fraction_leaf）将比不知道样本权重的标准（比如min_samples_leaf）更少偏向主导类。如果样本是加权的，则使用基于权重的预修剪标准来更容易优化树结构，这确保叶节点至少包含样本权重的总和的一小部分。2.2 重要属性和接口属性是在模型训练之后，能够调用查看的模型的各种性质。对决策树来说，最重要的是feature_importances_，能够查看各个特征对模型的重要性。sklearn中许多算法的接口都是相似的，比如说我们之前已经用到的fit和score，几乎对每个算法都可以使用。除了这两个接口之外，决策树最常用的接口还有apply和predict。apply中输入测试集返回每个测试样本所在的叶子节点的索引，predict输入测试集返回每个测试样本的标签。返回的内容一目了然并且非常容易，大家感兴趣可以自己下去试试看。#apply返回每个测试样本所在的叶子节点的索引

clf.apply(Xtest)

#predict返回每个测试样本的分类/回归结果

clf.predict(Xtest)至此，我们已经学完了分类树DecisionTreeClassifier和用决策树绘图（export_graphviz）的所有基础。我们讲解了决策树的基本流程，分类树的七个参数，一个属性，四个接口，以及绘图所用的代码。七个参数：Criterion，两个随机性相关的参数（random_state，splitter），四个剪枝参数（max_depth, ，min_sample_leaf，max_feature，min_impurity_decrease）一个属性：feature_importances_四个接口：fit，score，apply，predict有了这些知识，基本上分类树的使用大家都能够掌握了，接下来再到实例中去磨练就好。2.3 实例：分类树在合成数集上的表现我们在红酒数据集上画出了一棵树，并且展示了多个参数会对树形成这样的影响，接下来，我们将在不同结构的数据集上测试一下决策树的效果，让大家更好地理解决策树。导入需要的库import numpy as np

import matplotlib.pyplot as plt

from matplotlib.colors import ListedColormap

from sklearn.model_selection import train_test_split

from sklearn.preprocessing import StandardScaler

from sklearn.datasets import make_moons, make_circles, make_classification

from sklearn.tree import DecisionTreeClassifier2. 生成三种数据集我们先从sklearn自带的数据库中生成三种类型的数据集：1）月亮型数据，2）环形数据，3）二分型数据#make_classification库生成随机的二分型数据

X, y = make_classification(n_samples=100, #生成100个样本

n_features=2, #包含2个特征，即生成二维数据

n_redundant=0, #添加冗余特征0个

n_informative=2, #包含信息的特征是2个

random_state=1, #随机模式1

n_clusters_per_class=1 #每个簇内包含的标签类别有1个

)

#在这里可以查看一下X和y，其中X是100行带有两个2特征的数据，y是二分类标签

#也可以画出散点图来观察一下X中特征的分布

#plt.scatter(X[:,0],X[:,1])

#从图上可以看出，生成的二分型数据的两个簇离彼此很远，这样不利于我们测试分类器的效果，因此我们使用np生成随机数组，通过让已经生成的二分型数据点加减0~1之间的随机数，使数据分布变得更散更稀疏

#注意，这个过程只能够运行一次，因为多次运行之后X会变得非常稀疏，两个簇的数据会混合在一起，分类器的效应会继续下降

rng = np.random.RandomState(2) #生成一种随机模式

X += 2 * rng.uniform(size=X.shape) #加减0~1之间的随机数

linearly_separable = (X, y) #生成了新的X，依然可以画散点图来观察一下特征的分布

#plt.scatter(X[:,0],X[:,1])

#用make_moons创建月亮型数据，make_circles创建环形数据，并将三组数据打包起来放在列表datasets中

datasets = [make_moons(noise=0.3, random_state=0),

make_circles(noise=0.2, factor=0.5, random_state=1),

linearly_separable]3. 画出三种数据集和三棵决策树的分类效应图像#创建画布，宽高比为6*9

figure = plt.figure(figsize=(6, 9))

#设置用来安排图像显示位置的全局变量i

i = 1

#开始迭代数据，对datasets中的数据进行for循环

for ds_index, ds in enumerate(datasets):

#对X中的数据进行标准化处理，然后分训练集和测试集

X, y = ds

X = StandardScaler().fit_transform(X)

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=.4, random_state=42)

#找出数据集中两个特征的最大值和最小值，让最大值+0.5，最小值-0.5，创造一个比两个特征的区间本身更大一点的区间

x1_min, x1_max = X[:, 0].min() - .5, X[:, 0].max() + .5

x2_min, x2_max = X[:, 1].min() - .5, X[:, 1].max() + .5

#用特征向量生成网格数据，网格数据，其实就相当于坐标轴上无数个点

#函数np.arange在给定的两个数之间返回均匀间隔的值，0.2为步长

#函数meshgrid用以生成网格数据，能够将两个一维数组生成两个二维矩阵。

#如果第一个数组是narray，维度是n，第二个参数是marray，维度是m。那么生成的第一个二维数组是以narray为行，m行的矩阵，而第二个二维数组是以marray的转置为列，n列的矩阵

#生成的网格数据，是用来绘制决策边界的，因为绘制决策边界的函数contourf要求输入的两个特征都必须是二维的

array1,array2 = np.meshgrid(np.arange(x1_min, x1_max, 0.2),

np.arange(x2_min, x2_max, 0.2))

#接下来生成彩色画布

#用ListedColormap为画布创建颜色，#FF0000正红，#0000FF正蓝

cm = plt.cm.RdBu

cm_bright = ListedColormap(['#FF0000', '#0000FF'])

#在画布上加上一个子图，数据为len(datasets)行，2列，放在位置i上

ax = plt.subplot(len(datasets), 2, i)

#到这里为止，已经生成了0~1之间的坐标系3个了，接下来为我们的坐标系放上标题

#我们有三个坐标系，但我们只需要在第一个坐标系上有标题，因此设定if ds_index==0这个条件

if ds_index == 0:

ax.set_title("Input data")

#将数据集的分布放到我们的坐标系上

#先放训练集

ax.scatter(X_train[:, 0], X_train[:, 1], c=y_train,

cmap=cm_bright,edgecolors='k')

#放测试集

ax.scatter(X_test[:, 0], X_test[:, 1], c=y_test,

cmap=cm_bright, alpha=0.6,edgecolors='k')

#为图设置坐标轴的最大值和最小值，并设定没有坐标轴

ax.set_xlim(array1.min(), array1.max())

ax.set_ylim(array2.min(), array2.max())

ax.set_xticks(())

ax.set_yticks(())

#每次循环之后，改变i的取值让图每次位列不同的位置

i += 1

#至此为止，数据集本身的图像已经布置完毕，运行以上的代码，可以看见三个已经处理好的数据集

#############################从这里开始是决策树模型##########################

#迭代决策树，首先用subplot增加子图，subplot(行，列，索引)这样的结构，并使用索引i定义图的位置

#在这里，len(datasets)其实就是3，2是两列

#在函数最开始，我们定义了i=1，并且在上边建立数据集的图像的时候，已经让i+1,所以i在每次循环中的取值是2，4，6

ax = plt.subplot(len(datasets),2,i)

#决策树的建模过程：实例化 → fit训练 → score接口得到预测的准确率

clf = DecisionTreeClassifier(max_depth=5)

clf.fit(X_train, y_train)

score = clf.score(X_test, y_test)

#绘制决策边界，为此，我们将为网格中的每个点指定一种颜色[x1_min，x1_max] x [x2_min，x2_max]

#分类树的接口，predict_proba，返回每一个输入的数据点所对应的标签类概率

#类概率是数据点所在的叶节点中相同类的样本数量/叶节点中的样本总数量

#由于决策树在训练的时候导入的训练集X_train里面包含两个特征，所以我们在计算类概率的时候，也必须导入结构相同的数组，即是说，必须有两个特征

#ravel()能够将一个多维数组转换成一维数组

#np.c_是能够将两个数组组合起来的函数

#在这里，我们先将两个网格数据降维降维成一维数组，再将两个数组链接变成含有两个特征的数据，再带入决策树模型，生成的Z包含数据的索引和每个样本点对应的类概率，再切片，且出类概率

Z = clf.predict_proba(np.c_[array1.ravel(),array2.ravel()])[:, 1]

#np.c_[np.array([1,2,3]), np.array([4,5,6])]

#将返回的类概率作为数据，放到contourf里面绘制去绘制轮廓

Z = Z.reshape(array1.shape)

ax.contourf(array1, array2, Z, cmap=cm, alpha=.8)

#将数据集的分布放到我们的坐标系上

# 将训练集放到图中去

ax.scatter(X_train[:, 0], X_train[:, 1], c=y_train, cmap=cm_bright,

edgecolors='k')

# 将测试集放到图中去

ax.scatter(X_test[:, 0], X_test[:, 1], c=y_test, cmap=cm_bright,

edgecolors='k', alpha=0.6)

#为图设置坐标轴的最大值和最小值

ax.set_xlim(array1.min(), array1.max())

ax.set_ylim(array2.min(), array2.max())

#设定坐标轴不显示标尺也不显示数字

ax.set_xticks(())

ax.set_yticks(())

#我们有三个坐标系，但我们只需要在第一个坐标系上有标题，因此设定if ds_index==0这个条件

if ds_index == 0:

ax.set_title("Decision Tree")

#写在右下角的数字

ax.text(array1.max() - .3, array2.min() + .3, ('{:.1f}%'.format(score*100)),

size=15, horizontalalignment='right')

#让i继续加一

i += 1

plt.tight_layout()

plt.show()从图上来看，每一条线都是决策树在二维平面上画出的一条决策边界，每当决策树分枝一次，就有一条线出现。当数据的维度更高的时候，这条决策边界就会由线变成面，甚至变成我们想象不出的多维图形。同时，很容易看得出，分类树天生不擅长环形数据。每个模型都有自己的决策上限，所以一个怎样调整都无法提升表现的可能性也是有的。当一个模型怎么调整都不行的时候，我们可以选择换其他的模型使用，不要在一棵树上吊死。顺便一说，最擅长月亮型数据的是最近邻算法，RBF支持向量机和高斯过程；最擅长环形数据的是最近邻算法和高斯过程；最擅长对半分的数据的是朴素贝叶斯，神经网络和随机森林。完整版课程目录：编辑于 2020-05-13 14:18决策树sklearn机器学习赞同 1007 条评论分享喜欢收藏申请转载文章被以下专栏收录菜菜的Sklearn菜菜出品，必

使用Sklearn学习决策树_clf怎么导入-CSDN博客

使用Sklearn学习决策树

最新推荐文章于 2023-10-23 19:48:18 发布

理科男同学

最新推荐文章于 2023-10-23 19:48:18 发布

阅读量1.7w

213

点赞数

分类专栏：

机器学习

人工智能

文章标签：

sklearn

决策树

python

机器学习

数据挖掘

本文链接：https://blog.csdn.net/qq_38163244/article/details/120454021

版权

机器学习

同时被 2 个专栏收录

9 篇文章

12 订阅

订阅专栏

人工智能

1 篇文章

0 订阅

订阅专栏

决策树

文章目录

决策树概述sklearn中的决策树sklearn的基本建模流程分类树DecisionTreeClassifier重要参数说明criterionrandom_state & splitter剪枝参数目标权重参数

重要属性和接口

回归树DecisionTreeRegressor重要属性，参数及接口一维回归的图像绘制多输出

决策树的优缺点使用技巧决策树算法: ID3, C4.5, C5.0 和 CART

sklearn官网地址：http://scikit-learn.org/stable/index.html

概述

我们来简单了解一下决策树是如何工作的。决策树算法的本质是一种图结构，我们只需要问一系列问题就可以对数据进行分类了。比如说，来看看下面这组数据集，这是一系列已知物种以及所属类别的数据：

我们现在的目标是，将动物们分为哺乳类和非哺乳类。那根据已经收集到的数据，决策树算法为我们算出了下面的这棵决策树：

假如我们现在发现了一种新物种Python，它是冷血动物，体表带鳞片，并且不是胎生，我们就可以通过这棵决策树来判断它的所属类别。

可以看出，在这个决策过程中，我们一直在对记录的特征进行提问。最初的问题所在的地方叫做根节点，在得到结论前的每一个问题都是中间节点，而得到的每一个结论（动物的类别）都叫做叶子节点。

关键概念：节点

根节点：没有进边，有出边。包含最初的，针对特征的提问。中间节点：既有进边也有出边，进边只有一条，出边可以有很多条。都是针对特征的提问。叶子节点：有进边，没有出边，每个叶子节点都是一个类别标签。子节点和父节点：在两个相连的节点中，更接近根节点的是父节点，另一个是子节点。

决策树算法的核心是要解决两个问题：

如何从数据表中找出最佳节点和最佳分枝？如何让决策树停止生长，防止过拟合？

sklearn中的决策树

sklearn中决策树的类都在”tree“这个模块之下，这个模块总共包含五个类：

tree.DecisionTreeClassifier分类树tree.DecisionTreeRegressor回归树tree.export_graphviz将生成的决策树导出为DOT格式，画图专用tree.ExtraTreeClassifier高随机版本的分类树tree.ExtraTreeRegressor高随机版本的回归树

详细可以参考：决策树

sklearn的基本建模流程

案例

from sklearn import tree #导入需要的模块

clf = tree.DecisionTreeClassifier() #实例化模型对象

clf = clf.fit(X_train,y_train) #用训练集数据训练模型

result = clf.score(X_test,y_test) #对我们训练的模型精度进行打分

分类树

DecisionTreeClassifier

class sklearn.tree.DecisionTreeClassifier (

criterion=’gini’, splitter=’best’, max_depth=None,min_samples_split=2, min_samples_leaf=1, min_weight_fraction_leaf=0.0, max_features=None,random_state=None, max_leaf_nodes=None, min_impurity_decrease=0.0, min_impurity_split=None,class_weight=None, presort=False

)

重要参数说明

criterion

这个参数正是用来决定不纯度的计算方法的。sklearn提供了两种选择

1）输入”entropy“，使用信息熵（Entropy）

2）输入”gini“，使用基尼系数（Gini Impurity）

为了要将表格转化为一棵树，决策树需要找出最佳节点和最佳的分枝方法，对分类树来说，衡量这个“最佳”的指标叫做“不纯度”。通常来说，不纯度越低，决策树对训练集的拟合越好。现在使用的决策树算法在分枝方法上的核心大多是围绕在对某个不纯度相关指标的最优化上。不纯度基于节点来计算，树中的每个节点都会有一个不纯度，并且子节点的不纯度一定是低于父节点的，也就是说，在同一棵决策树上，叶子节点的不纯度一定是最低的。

Criterion这个参数正是用来决定不纯度的计算方法的。sklearn提供了两种选择：

其中t代表给定的节点，i代表标签的任意分类，P(i/t)代表标签分类i在节点t上所占的比例,注意，当使用信息熵时，sklearn实际计算的是基于信息熵的信息增益(Information Gain)，即父节点的信息熵和子节点的信息熵之差。比起基尼系数，信息熵对不纯度更加敏感，对不纯度的惩罚最强。但是在实际使用中，信息熵和基尼系数的效果基本相同。信息熵的计算比基尼系数缓慢一些，因为基尼系数的计算不涉及对数。另外，因为信息熵对不纯度更加敏感，所以信息熵作为指标时，决策树的生长会更加“精细”，因此对于高维数据或者噪音很多的数据，信息熵很容易过拟合，基尼系数在这种情况下效果往往比较好。当模型拟合程度不足的时候，即当模型在训练集和测试集上都表现不太好的时候，使用信息熵。当然，这些不是绝对的。

参数criterion如何影响模型?确定不纯度的计算方法，帮忙找出最佳节点和最佳分枝，不纯度越低，决策树对训练集的拟合越好,可以把不纯度理解为不确定性，不确定性越小，效果越好。可能的输入有哪些？不填默认基尼系数，填写gini使用基尼系数，填写entropy使用信息增益怎样选取参数？通常就使用基尼系数数据维度很大，噪音很大时使用基尼系数维度低，数据比较清晰的时候，信息熵和基尼系数没区别，当决策树的拟合程度不够的时候，使用信息熵，两个都试试，不好就换另外一个

决策树的基本流程其实可以简单概括如下：

直到没有更多的特征可用，或整体的不纯度指标已经最优，决策树就会停止生长。下面进行案例演示：

代码说明

# 导入所需要的模块

from sklearn import tree #树的模块

from sklearn.datasets import load_wine #导入红酒数据集

from sklearn.model_selection import train_test_split # 划分数据集的模块

# 探索数据

wine = load_wine()

# 数据有178个样本，13个特征

wine.data.shape

# 标签

wine.target

#如果wine是一张表，应该长这样：

import pandas as pd

pd.concat([pd.DataFrame(wine.data),pd.DataFrame(wine.target)],axis=1)

wine.feature_names

wine.target_names

# 划分数据为训练集和测试集，test_size标示测试集数据占的百分比

Xtrain, Xtest, Ytrain, Ytest = train_test_split(wine.data,wine.target,test_size=0.3)

Xtrain.shape

Xtest.shape

# 建立模型

clf = tree.DecisionTreeClassifier(criterion="entropy")# 实例化模型，添加criterion参数

clf = clf.fit(Xtrain, Ytrain)# 使用实例化好的模型进行拟合操作

score = clf.score(Xtest, Ytest) #返回预测的准确度

score

# 在这里，我们发现每一次运行程序时，返回的准确率都不相同，这是因为sklearn每次都在全部的特征中选取若干个特征建立一棵树

# 最后选择准确率最高的决策树返回，如果我们添加上random_state参数，那么sklearn每一次建立决策树使用的特征都相同，返回的预测分数也会一样

# random_state是决定随机数的参数，随机数不变，那么每一次创建的决策树也一样

# 对数据进行可视化

feature_name = ['酒精','苹果酸','灰','灰的碱性','镁','总酚','类黄酮','非黄烷类酚类','花青素','颜色强度','色调','稀释葡萄酒','脯氨酸']

import graphviz

dot_data = tree.export_graphviz(clf #训练好的模型

,out_file = None

,feature_names= feature_name

,class_names=["琴酒","雪莉","贝尔摩德"]

,filled=True #进行颜色填充

,rounded=True #树节点的形状控制

)

graph = graphviz.Source(dot_data)

graph

#特征重要性

clf.feature_importances_# 查看每一个特征对分类的贡献率

[*zip(feature_name,clf.feature_importances_)]

# 在这里，我们发现每一次运行程序时，返回的准确率都不相同，这是因为sklearn每次都在全部的特征中选取若干个特征建立一棵树

# 最后选择准确率最高的决策树返回，如果我们添加上random_state参数，那么sklearn每一次建立决策树使用的特征都相同，返回的

# 预测分数也会一样clf = tree.DecisionTreeClassifier(criterion="entropy",random_state=30)

clf = clf.fit(Xtrain, Ytrain)

score = clf.score(Xtest, Ytest) #返回预测的准确度

score

我们已经在只了解一个参数的情况下，建立了一棵完整的决策树。但是回到步骤4建立模型，score会在某个值附近波动，引起步骤5中画出来的每一棵树都不一样。它为什么会不稳定呢？如果使用其他数据集，它还会不稳定吗？我们之前提到过，无论决策树模型如何进化，在分枝上的本质都还是追求某个不纯度相关的指标的优化，而正如我们提到的，不纯度是基于节点来计算的，也就是说，决策树在建树时，是靠优化节点来追求一棵优化的树，但最优的节点能够保证最优的树吗？集成算法被用来解决这个问题：sklearn表示，既然一棵树不能保证最优，那就建更多的不同的树，然后从中取最好的。怎样从一组数据集中建不同的树？在每次分枝时，不使用全部特征，而是随机选取一部分特征，从中选取不纯度相关指标最优的作为分枝用的节点。这样，每次生成的树也就不同了。

最后，我们画出的决策树如下：

从返回的结果我们可以发现，类黄酮的信息增益最大，所以选取类黄酮作为树的根节点来画树，接下来，算法依次算出每一个特征的信息增益，选取信息增益大的特征作为子树的根节点，递归建立决策树，注意，从根节点到叶子结点，信息增益的值一直在减小。

random_state & splitter

random_state用来设置分枝中的随机模式的参数，默认None，在高维度时随机性会表现更明显，低维度的数据（比如鸢尾花数据集），随机性几乎不会显现。输入任意整数，会一直长出同一棵树，让模型稳定下来。也就是每次选取的特征都是一样的。

splitter也是用来控制决策树中的随机选项的，有两种输入值，输入”best"，决策树在分枝时虽然随机，但是还是会优先选择更重要的特征进行分枝（重要性可以通过属性feature_importances_查看），输入“random"，决策树在分枝时会更加随机，树会因为含有更多的不必要信息而更深更大，并因这些不必要信息而降低对训练集的拟合。这也是防止过拟合的一种方式。当你预测到你的模型会过拟合，用这两个参数来帮助你降低树建成之后过拟合的可能性。当然，树一旦建成，我们依然是使用剪枝参数来防止过拟合。

案例

clf = tree.DecisionTreeClassifier(criterion="entropy"

,random_state=30 # 保证模型稳定，每一次运行，所选取的特征不变

,splitter="random"

)

clf = clf.fit(Xtrain, Ytrain)

score = clf.score(Xtest, Ytest)

import graphviz

# filled参数标示填充颜色

# rounded参数标示显示圆角矩形

dot_data=tree.export_graphviz(clf,feature._names=feature_name,class_names=["琴酒","雪莉","贝尔摩德"],filled=True,rounded=True)

graph=graphviz.Source(dot_data)

graph

[*zip(feature_name,clf.feature_importances_)]

剪枝参数

在不加限制的情况下，一棵决策树会生长到衡量不纯度的指标最优，或者没有更多的特征可用为止。这样的决策树往往会过拟合，这就是说，它会在训练集上表现很好，在测试集上却表现糟糕。我们收集的样本数据不可能和整体的状况完全一致，因此当一棵决策树对训练数据有了过于优秀的解释性，它找出的规则必然包含了训练样本中的噪声，并使它对未知数据的拟合程度足。

score_train = clf.score(Xtrain, Ytrain)

# 对于训练数据集的预测分数为100%，也就是过拟合了，需要我们做剪枝处理

score_train # 1

为了让决策树有更好的泛化性，我们要对决策树进行剪枝。剪枝策略对决策树的影响巨大，正确的剪枝策略是优化决策树算法的核心。sklearn为我们提供了不同的剪枝策略：

max_depth

树的最大深度

限制树的最大深度，超过设定深度的树枝全部剪掉，这是用得最广泛的剪枝参数，在高维度低样本量时非常有效。决策树多生长一层，对样本量的需求会增加一倍，所以限制树深度能够有效地限制过拟合。在集成算法中也非常实用。实际使用时，建议从=3开始尝试，看看拟合的效果再决定是否增加设定深度。

min_samples_leaf & min_samples_split

min_samples_leaf限定，一个节点在分枝后的每个子节点都必须包含至少min_samples_leaf个训练样本，否则分枝就不会发生，或者，分枝会朝着满足每个子节点都包含min_samples_leaf个样本的方向去发生。一般搭配max_depth使用，在回归树中有神奇的效果，可以让模型变得更加平滑。这个参数的数量设置得太小会引起过拟合，设置得太大就会阻止模型学习数据。一般来说，建议从=5开始使用。如果叶节点中含有的样本量变化很大，建议输入浮点数作为样本量的百分比来使用。同时，这个参数可以保证每个叶子的最小尺寸，可以在回归问题中避免低方差，过拟合的叶子节点出现。对于类别不多的分类问题，=1通常就是最佳选择。

min_samples_split限定，一个节点必须要包含至少min_samples_split个训练样本，这个节点才允许被分枝，否则分枝就不会发生。

clf1 = tree.DecisionTreeClassifier(criterion="entropy"

,random_state=30

,splitter="random"

,max_depth=3

,min_samples_leaf=10 #一个节点分支后，每一个子节点至少包含10个样本

,min_samples_split=10 #一个节点至少包含10个样本才会分支

)

clf1=clf1.fit(Xtrain,Ytrain)#拟合模型

dot_data=tree.export_graphviz(clf,feature_names=feature_name,class_names=["琴酒","雪莉","贝尔摩德"],filled=True,rounded=True)

graph=graphviz.Source(dot_data)

graph

max_features & min_impurity_decrease

一般max_depth使用，用作树的”精修“。max_features限制分枝时考虑的特征个数，超过限制个数的特征都会被舍弃。和max_depth异曲同工，max_features是用来限制高维度数据的过拟合的剪枝参数，但其方法比较暴力，是直接限制可以使用的特征数量而强行使决策树停下的参数，在不知道决策树中的各个特征的重要性的情况下，强行设定这个参数可能会导致模型学习不足。如果希望通过降维的方式防止过拟合，建议使用PCA，ICA或者特征选择模块中的降维算法。

min_impurity_decrease限制信息增益的大小，信息增益小于设定数值的分枝不会发生。这是在0.19版本中更新的功能，在0.19版本之前时使用min_impurity_split。

确定最优的剪枝参数

那具体怎么来确定每个参数填写什么值呢？这时候，我们就要使用确定超参数的曲线来进行判断了，继续使用我们已经训练好的决策树模型clf。超参数的学习曲线，是一条以超参数的取值为横坐标，模型的度量指标为纵坐标的曲线，它是用来衡量不同超参数取值下模型的表现的线。在我们建好的决策树里，我们的模型度量指标就是score。也就是所谓的学习曲线。

import matplotlib.pyplot as plt

test = []

for i in range(10):

clf = tree.DecisionTreeClassifier(max_depth=i+1

,criterion="entropy"

,random_state=30

,splitter="random"

)

clf = clf.fit(Xtrain, Ytrain)

score = clf.score(Xtest, Ytest)

test.append(score)

plt.plot(range(1,11),test,color="red",label="max_depth")

plt.legend()

plt.show()

思考：

剪枝参数一定能够提升模型在测试集上的表现吗？ - 调参没有绝对的答案，一切都是看数据本身。这么多参数，一个个画学习曲线？无论如何，剪枝参数的默认值会让树无尽地生长，这些树在某些数据集上可能非常巨大，对内存的消耗。所以如果你手中的数据集非常大，你已经预测到无论如何你都是要剪枝的，那提前设定这些参数来控制树的复杂性和大小会比较好。

目标权重参数

class_weight & min_weight_fraction_leaf

有了权重之后，样本量就不再是单纯地记录数目，而是受输入的权重影响了，因此这时候剪枝，就需要搭配min_weight_fraction_leaf这个基于权重的剪枝参数来使用。另请注意，基于权重的剪枝参数（例如min_weight_fraction_leaf）将比不知道样本权重的标准（比如min_samples_leaf）更少偏向主导类。如果样本是加权的，则使用基于权重的预修剪标准来更容易优化树结构，这确保叶节点至少包含样本权重的总和的一小部分。

重要属性和接口

属性是在模型训练之后，能够调用查看的模型的各种性质。对决策树来说，最重要的是feature_importances_，能够查看各个特征对模型的重要性。

sklearn中许多算法的接口都是相似的，比如说我们之前已经用到的fit和score，几乎对每个算法都可以使用。除了这两个接口之外，决策树最常用的接口还有apply和predict。

apply中输入测试集返回每个测试样本所在的叶子节点的索引，predict输入测试集返回每个测试样本的标签。

所有接口中要求输入X_train和X_test的部分，输入的特征矩阵必须至少是一个二维矩阵。sklearn不接受任何一维矩阵作为特征矩阵被输入。如果你的数据的确只有一个特征，那必须用reshape(-1,1)来给矩阵增维；如果你的数据只有一个特征和一个样本，使用reshape(1,-1)来给你的数据增维。

#apply返回每个测试样本所在的叶子节点的索引

clf.apply(Xtest)

#predict返回每个测试样本的分类/回归结果

clf.predict(Xtest)

至此，我们已经学完了分类树DecisionTreeClassifier和用决策树绘图（export_graphviz）的所有基础。

分类树的八个参数，一个属性，四个接口，以及绘图所用的代码。

八个参数：

Criterion，两个随机性相关的参数（random_state，splitter），五个剪枝参数（max_depth,min_samples_split，min_samples_leaf，max_feature，min_impurity_decrease）一个属性：feature_importances_四个接口：fit，score，apply，predict

回归树

DecisionTreeRegressor

class sklearn.tree.DecisionTreeRegressor (

criterion=’mse’, splitter=’best’, max_depth=None,min_samples_split=2, min_samples_leaf=1, min_weight_fraction_leaf=0.0, max_features=None,random_state=None, max_leaf_nodes=None, min_impurity_decrease=0.0, min_impurity_split=None, presort=False

)

几乎所有参数，属性及接口都和分类树一模一样。需要注意的是，在回归树种，没有标签分布是否均衡的问题，因此没有class_weight这样的参数。因为回顾对应的是连续性的数据。

重要属性，参数及接口

criterion

回归树衡量分枝质量的指标，支持的标准有三种：

输入"mse"使用均方误差mean squared error(MSE)，父节点和叶子节点之间的均方误差的差额将被用来作为特征选择的标准，这种方法通过使用叶子节点的均值来最小化L2损失输入“friedman_mse”使用费尔德曼均方误差，这种指标使用弗里德曼针对潜在分枝中的问题改进后的均方误差输入"mae"使用绝对平均误差MAE（mean absolute error），这种指标使用叶节点的中值来最小化L1损失

属性中最重要的依然是feature_importances_，接口依然是apply, fit, predict, score最核心。

均方误差：

其中N是样本数量，i是每一个数据样本，fi是模型回归出的数值，yi是样本点i实际的数值标签。所以MSE的本质，其实是样本真实数据与回归结果的差异。在回归树中，MSE不只是我们的分枝质量衡量指标，也是我们最常用的衡量回归树回归质量的指标，当我们在使用交叉验证，或者其他方式获取回归树的结果时，我们往往选择均方误差作为我们的评估（在分类树中这个指标是score代表的预测准确率）。在回归中，我们追求的是，MSE越小越好。

然而，回归树的接口score返回的是R平方，并不是MSE。R平方被定义如下：

其中u是残差平方和（MSE * N），v是总平方和，N是样本数量，i是每一个数据样本，fi是模型回归出的数值，yi是样本点i实际的数值标签。y帽是真实数值标签的平均数。R平方可以为正为负（如果模型的残差平方和远远大于模型的总平方和，模型非常糟糕，R平方就会为负，R的平方越接近1越好），而均方误差永远为正。

值得一提的是，虽然均方误差永远为正，但是sklearn当中使用均方误差作为评判标准时，却是计算”负均方误差“（neg_mean_squared_error）。这是因为sklearn在计算模型评估指标的时候，会考虑指标本身的性质，均方误差本身是一种误差，所以被sklearn划分为模型的一种损失(loss)，因此在sklearn当中，都以负数表示。真正的均方误差MSE的数值，其实就是neg_mean_squared_error去掉负号的数字。

交叉验证的使用方法:

from sklearn.datasets import load_boston

from sklearn.model_selection import cross_val_score

from sklearn.tree import DecisionTreeRegressor

boston = load_boston()

# scoring 表示使用军方误差衡量模型

# 如果不写参数，对于回归模型，默认返回R平方，越接近1越好

# 均方误差越小越好

regressor = DecisionTreeRegressor(random_state=0)

cross_val_score(regressor, boston.data, boston.target, cv=10,scoring = "neg_mean_squared_error")

#交叉验证cross_val_score的用法

交叉验证是用来观察模型的稳定性的一种方法，我们将数据划分为n份，依次使用其中一份作为测试集，其他n-1份作为训练集，多次计算模型的精确性来评估模型的平均准确程度。训练集和测试集的划分会干扰模型的结果，因此用交叉验证n次的结果求出的平均值，是对模型效果的一个更好的度量。

一维回归的图像绘制

接下来我们到二维平面上来观察决策树是怎样拟合一条曲线的。我们用回归树来拟合正弦曲线，并添加一些噪声来观察回归树的表现。

import numpy as np

from sklearn.tree import DecisionTreeRegressor

import matplotlib.pyplot as plt

#设置随机数种子，然后产生一个80*1的二维随机数数组，添加噪音

rng=np.random.RandomState(1)# 设置随机数的种子

X=np.sort(5*rng.rand(80,1),axis=0)

y = np.sin(X).ravel()# ravel()函数是降维函数

# 建立模型，并且进行拟合，建立回归树的深度不同

regr_1 = DecisionTreeRegressor(max_depth=2)

regr_2 = DecisionTreeRegressor(max_depth=5)

regr_1.fit(X, y)

regr_2.fit(X, y)

# np.arrange(开始，结束点，步长)，生成有序数组的函数

# 产生一个序列，并且进行升维工作，np.newaxis是升维函数，然后进行预测

X_test = np.arange(0.0, 5.0, 0.01)[:, np.newaxis]

y_1 = regr_1.predict(X_test)

y_2 = regr_2.predict(X_test)

plt.figure()

plt.scatter(X, y, s=20, edgecolor="black",c="darkorange", label="data")

plt.plot(X_test, y_1, color="cornflowerblue",label="max_depth=2", linewidth=2)

plt.plot(X_test, y_2, color="yellowgreen", label="max_depth=5", linewidth=2)

plt.xlabel("data")

plt.ylabel("target")

plt.title("Decision Tree Regression")

plt.legend()

plt.show()

可见，回归树学习了近似正弦曲线的局部线性回归。我们可以看到，如果树的最大深度（由max_depth参数控制）设置得太高，则决策树学习得太精细，它从训练数据中学了很多细节，包括噪声得呈现，从而使模型偏离真实的正弦曲线，形成过拟合。

多输出

一个多值输出问题是一个类似当 Y 是大小为 [n_samples, n_outputs] 的2d数组时，有多个输出值需要预测的监督学习问题。

在叶中存储n个输出值，而不是一个;通过计算所有n个输出的平均减少量来作为分裂标准.

predict 是输出n_output的值在 predict_proba 上输出 n_output 数组列表

案例

# 多输出案例

import numpy as np

import matplotlib.pyplot as plt

from sklearn.tree import DecisionTreeRegressor

# 生成测试数据集

# Z制作数据集

rng=np.random.RandomState(1)# 设置随机数种子

X=np.sort(200*rng.rand(100,1)-100,axis=0)

X.shape # 100*1

# y有两个标签

y = np.array([np.pi * np.sin(X).ravel(), np.pi * np.cos(X).ravel()]).T

# 给标签产生噪音

y[::5, :] += (0.5 - rng.rand(20, 2))

# 训练模型

regr_1 = DecisionTreeRegressor(max_depth=2)

regr_2 = DecisionTreeRegressor(max_depth=5)

regr_3 = DecisionTreeRegressor(max_depth=8)

regr_1.fit(X, y)

regr_2.fit(X, y)

regr_3.fit(X, y)

X_test = np.arange(-100.0, 100.0, 0.01)[:, np.newaxis]

y_1 = regr_1.predict(X_test)

y_2 = regr_2.predict(X_test)

y_3 = regr_3.predict(X_test)

y_1.shape #(2000,2)

预测结果

max_depth=2

plt.figure()

s = 25

# 原始图像

plt.scatter(y[:, 0], y[:, 1], c="navy", s=s,

edgecolor="black", label="data")

plt.scatter(y_1[:, 0], y_1[:, 1], c="cornflowerblue", s=s,

edgecolor="red", label="max_depth=2")

plt.xlim([-6, 6])

plt.ylim([-6, 6])

plt.xlabel("target 1")

plt.ylabel("target 2")

plt.title("Multi-output Decision Tree Regression")

plt.legend(loc="best")

plt.show()

可以看到，在决策树的高度是2的时候，几乎预测不到什么有用的信息。

max_depth=5

plt.figure()

s = 25

plt.scatter(y[:, 0], y[:, 1], c="navy", s=s,

edgecolor="black", label="data")

plt.scatter(y_2[:, 0], y_2[:, 1], c="red", s=s,

edgecolor="black", label="max_depth=5")

plt.xlim([-6, 6])

plt.ylim([-6, 6])

plt.xlabel("target 1")

plt.ylabel("target 2")

plt.title("Multi-output Decision Tree Regression")

plt.legend(loc="best")

plt.show()

max_depth=8

plt.figure()

s = 25

plt.scatter(y[:, 0], y[:, 1], c="navy", s=s,

edgecolor="black", label="data")

plt.scatter(y_3[:, 0], y_3[:, 1], c="red", s=s,

edgecolor="black", label="max_depth=8")

plt.xlim([-6, 6])

plt.ylim([-6, 6])

plt.xlabel("target 1")

plt.ylabel("target 2")

plt.title("Multi-output Decision Tree Regression")

plt.legend(loc="best")

plt.show()

最大高度是5的时候，几乎全部预测到。

决策树的优缺点

决策树的优点：

易于理解和解释，因为树木可以画出来被看见需要很少的数据准备。其他很多算法通常都需要数据规范化，需要创建虚拟变量并删除空值等。但请注意，sklearn中的决策树模块不支持对缺失值的处理。使用树的成本（比如说，在预测数据的时候）是用于训练树的数据点的数量的对数，相比于其他算法，这是一个很低的成本。能够同时处理数字和分类数据，既可以做回归又可以做分类。其他技术通常专门用于分析仅具有一种变量类型的数据集。能够处理多输出问题，即含有多个标签的问题，注意与一个标签中含有多种标签分类的问题区别开是一个白盒模型，结果很容易能够被解释。如果在模型中可以观察到给定的情况，则可以通过布尔逻辑轻松解释条件。相反，在黑盒模型中（例如，在人工神经网络中），结果可能更难以解释。可以使用统计测试验证模型，这让我们可以考虑模型的可靠性。即使其假设在某种程度上违反了生成数据的真实模型，也能够表现良好。

决策树的缺点：

决策树学习者可能创建过于复杂的树，这些树不能很好地推广数据。这称为过度拟合。修剪，设置叶节点所需的最小样本数或设置树的最大深度等机制是避免此问题所必需的，而这些参数的整合和调整对初学者来说会比较晦涩决策树可能不稳定，数据中微小的变化可能导致生成完全不同的树，这个问题需要通过集成算法来解决。决策树的学习是基于贪婪算法，它靠优化局部最优（每个节点的最优）来试图达到整体的最优，但这种做法不能保证返回全局最优决策树。这个问题也可以由集成算法来解决，在随机森林中，特征和样本会在分枝过程中被随机采样。有些概念很难学习，因为决策树不容易表达它们，例如XOR，奇偶校验或多路复用器问题。如果标签中的某些类占主导地位，决策树学习者会创建偏向主导类的树。因此，建议在拟合决策树之前平衡数据集。

使用技巧

对于拥有大量特征的数据决策树会出现过拟合的现象。获得一个合适的样本比例和特征数量十分重要，因为在高维空间中只有少量的样本的树是十分容易过拟合的。考虑事先进行降维( PCA , ICA ，使您的树更好地找到具有分辨性的特征。通过 export 功能可以可视化您的决策树。使用 max_depth=3 作为初始树深度，让决策树知道如何适应您的数据，然后再增加树的深度。请记住，填充树的样本数量会增加树的每个附加级别。使用 max_depth 来控制输的大小防止过拟合。通过使用 min_samples_split 和 min_samples_leaf 来控制叶节点上的样本数量。当这个值很小时意味着生成的决策树将会过拟合，然而当这个值很大时将会不利于决策树的对样本的学习。所以尝试 min_samples_leaf=5 作为初始值。如果样本的变化量很大，可以使用浮点数作为这两个参数中的百分比。两者之间的主要区别在于 min_samples_leaf 保证叶结点中最少的采样数，而 min_samples_split 可以创建任意小的叶子，尽管在文献中 min_samples_split 更常见。在训练之前平衡您的数据集，以防止决策树偏向于主导类.可以通过从每个类中抽取相等数量的样本来进行类平衡，或者优选地通过将每个类的样本权重 (sample_weight) 的和归一化为相同的值。还要注意的是，基于权重的预修剪标准 (min_weight_fraction_leaf) 对于显性类别的偏倚偏小，而不是不了解样本权重的标准，如 min_samples_leaf 。如果样本被加权，则使用基于权重的预修剪标准 min_weight_fraction_leaf 来优化树结构将更容易，这确保叶节点包含样本权重的总和的至少一部分。所有的决策树内部使用 np.float32 数组，如果训练数据不是这种格式，将会复制数据集。如果输入的矩阵X为稀疏矩阵，建议您在调用fit之前将矩阵X转换为稀疏的csc_matrix ,在调用predict之前将 csr_matrix 稀疏。当特征在大多数样本中具有零值时，与密集矩阵相比，稀疏矩阵输入的训练时间可以快几个数量级。

决策树算法: ID3, C4.5, C5.0 和 CART

所有种类的决策树算法有哪些以及它们之间的区别？scikit-learn 中实现何种算法呢？

C5.0 是 Quinlan 根据专有许可证发布的最新版本。它使用更少的内存，并建立比 C4.5 更小的规则集，同时更准确。

scikit-learn 使用 CART 算法的优化版本

最后感谢哔哩哔哩up主菜菜老师的课程，非常不错。

参考资料：

[1] https://www.bilibili.com/video/BV1WJ411k7L3?p=228

[2] https://scikit-learn.org/stable/

优惠劵

理科男同学

关注

踩

213

觉得还不错?

一键收藏

知道了

使用Sklearn学习决策树

决策树文章目录决策树概述sklearn中的决策树sklearn的基本建模流程分类树DecisionTreeClassifier重要参数说明criterionrandom_state & splitter[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vAmwT22O-1632464362155)(data:image/gif;base64,R0lGODlhAQABAPABAP///wAAACH5BAEKAAAALAAAAAABAAEAAAICRAEAOw==)]剪枝参

复制链接

扫一扫

专栏目录

sklearn之决策树

12-21

sklearn之决策树简介

第一次写博客，这里就写一下最近在学习的，易快速上手的sklearn吧。

sklearn入门

scikit-learn，又写作sklearn，是一个开源的基于python语言的机器学习工具包。它通过NumPy, SciPy和Matplotlib等python库实现高效的算法应用，并且涵盖了几乎所有主流机器学习算法。本篇主要介绍决策树。

决策树

决策树是一种有监督学习，从一系列有数据特征和标签的数据中每次选择某一特征来作为划分依据，也就是树的节点，来划分数据。依次进行直到将数据分类完成，最后呈现出树状结构。决策树算法易理解，在行业中广泛应用。

常用决策树算法：

ID3算

sklearn机器学习库(一)sklearn中的决策树

qq_44665283的博客

08-12

2155

sklearn机器学习库(一)sklearn中的决策树

2 条评论

您还未登录，请先

后发表或查看评论

python使用sklearn实现决策树的方法示例

09-18

主要介绍了python使用sklearn实现决策树的方法示例，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧

source insight python Python.CLF 语言包

08-22

刚从官网下载的

source insight python Python.CLF 语言包

SourceInsight作如下配置：

（1）选择Options > Preferences，单击Languages选项；

（2）单击import按钮，装载并导入Python.CLF；

（3）这时可以看到，左栏语言列表多了一项Python Language；

（4）单击Document Types按钮，打开文档选项对话框；

（5）添加Document Type为Python，File filter为“*.py”，Passer组中Language选项设置为Python Language；

（6）单击文档选项对话框的close按钮；

（7）单击Preferences窗口OK按钮，退出Preferences窗口，完成设置。

基于sklearn的决策树学习篇

04-13

基于sklearn的决策树学习篇

sklearn基础篇（六）-- 决策树（decision tree）

CarpeDiem

11-15

3209

sklearn中的决策树（分类）

【sklearn入门】决策树在sklearn中的实现--实战红酒分类案例_请利用sklearn库实现具体数据的决策树分类-CSDN博客

【sklearn入门】决策树在sklearn中的实现--实战红酒分类案例

最新推荐文章于 2024-01-27 15:56:32 发布

闫究生

最新推荐文章于 2024-01-27 15:56:32 发布

阅读量1.9w

214

点赞数

分类专栏：

sklearn

文章标签：

sklarn

机器学习

决策树

本文链接：https://blog.csdn.net/yxc9681/article/details/88285061

版权

sklearn

专栏收录该内容

1 篇文章

2 订阅

订阅专栏

scikit-learn简介

scikit-learn，又写作sklearn，是一个开源的基于python语言的机器学习工具包。它通过NumPy, SciPy和 Matplotlib等python数值计算的库实现高效的算法应用，并且涵盖了几乎所有主流机器学习算法。 http://scikit-learn.org/stable/index.html 在工程应用中，用python手写代码来从头实现一个算法的可能性非常低，这样不仅耗时耗力，还不一定能够写出构架清晰，稳定性强的模型。更多情况下，是分析采集到的数据，根据数据特征选择适合的算法，在工具包中调用算法，调整算法的参数，获取需要的信息，从而实现算法效率和效果之间的平衡。而sklearn，正是这样一个可以帮助我们高效实现算法应用的工具包。 sklearn有一个完整而丰富的官网，里面讲解了基于sklearn对所有算法的实现和简单应用。然而，这个官网是全英文的，并且现在没有特别理想的中文接口，市面上也没有针对sklearn非常好的书。因此，这门课的目的就是由简向繁地向大家解析sklearn的全面应用，帮助大家了解不同的机器学习算法有哪些可调参数，有哪些可用接口，这些接口和参数对算法来说有什么含义，又会对算法的性能及准确性有什么影响。我们会讲解sklearn中对算法的说明，调参，属性，接口，以及实例应用。注意，本门课程的讲解不会涉及详细的算法原理，只会专注于算法在 sklearn中的实现，如果希望详细了解算法的原理，建议阅读下面这本两本书：

决策树原理

1.1 决策树是如何工作决策树（Decision Tree）是一种非参数的有监督学习方法，它能够从一系列有特征和标签的数据中总结出决策规则，并用树状图的结构来呈现这些规则，以解决分类和回归问题。决策树算法容易理解，适用各种数据，在解决各种问题时都有良好表现，尤其是以树模型为核心的各种集成算法，在各个行业和领域都有广泛的应用。我们来简单了解一下决策树是如何工作的。决策树算法的本质是一种图结构，我们只需要问一系列问题就可以对数据进行分类了。比如说，根据西瓜的各个特征，通过决策树来判断他们是好瓜坏瓜：

决策树算法的核心是要解决两个问题： 1）如何从数据表中找出最佳节点和最佳分枝？ 2）如何让决策树停止生长，防止过拟合？

sklearn中的决策树

模块sklearn.tree

下面开始实战吧

一、建立一棵树

1、导入需要的算法库和模块

#预定义

from sklearn import tree #导入模型

from .datasets import load_wine #加载红酒数据共178个样本代表了红酒的三个档次（分别有59,71,48个样本）以及与之对应的13维的属性数据

from sklearn.model_selection import train_test_split#制作数据集和测试集

PS 本实验需要预先安装我的开发环境为jupyter notebook （环境搭建不懂得留言）

Python 3.7.1（你的版本至少要3.4以上 Scikit-learn 0.20.0 （你的版本至少要0.19 Graphviz 0.8.4 (没有画不出决策树哦，安装代码conda install python-graphviz Numpy 1.15.3, Pandas 0.23.4, Matplotlib 3.0.1, SciPy 1.1.0

2. 探索数据

wine = load_wine()

wine.data.shape#形状（178,13）

wine.target#（178，）

#如果wine是一张表，应该长这样：

import pandas as pd

pd.concat([pd.DataFrame(wine.data),pd.DataFrame(wine.target)],axis=1)

wine.feature_names

wine.target_names

3. 分训练集和测试集

Xtrain, Xtest, Ytrain, Ytest = train_test_split(wine.data,wine.target,test_size=0.3)#分训练集、测试集测试集占0.3

Xtrain.shape#训练集形状

Xtest.shape#测试集形状

4. 建立模型

clf = tree.DecisionTreeClassifier(criterion="entropy")# 载入决策树分类模型

clf = clf.fit(Xtrain, Ytrain)# 决策树拟合，得到模型

score = clf.score(Xtest, Ytest) #返回预测的准确度

score

5. 画出一棵树吧

feature_name = ['酒精','苹果酸','灰','灰的碱性','镁','总酚','类黄酮','非黄烷类酚类','花青素','颜色强度','色调','od280/od315稀释葡萄酒','脯氨酸']

import graphviz

dot_data = tree.export_graphviz(clf,feature_names= feature_name,class_names=["琴酒","雪莉","贝尔摩德"],filled=True,rounded=True)

graph = graphviz.Source(dot_data)#画树

graph

运行以上代码就得到了这样一棵树要学会利用快捷键我另外一篇博客有写

6. 探索决策树

#特征重要性

clf.feature_importances_

[*zip(feature_name,clf.feature_importances_)]

输出重要性指数

我们已经在只了解一个参数的情况下，建立了一棵完整的决策树。但是回到步骤4建立模型，score会在某个值附近波动，引起步骤5中画出来的每一棵树都不一样。它为什么会不稳定呢？如果使用其他数据集，它还会不稳定吗？我们之前提到过，无论决策树模型如何进化，在分枝上的本质都还是追求某个不纯度相关的指标的优化，而正如我们提到的，不纯度是基于节点来计算的，也就是说，决策树在建树时，是靠优化节点来追求一棵优化的树，但最优的节点能够保证最优的树吗？集成算法被用来解决这个问题：sklearn表示，既然一棵树不能保证最优，那就建更多的不同的树，然后从中取最好的。怎样从一组数据集中建不同的树？在每次分枝时，不从使用全部特征，而是随机选取一部分特征，从中选取不纯度相关指标最优的作为分枝用的节点。这样，每次生成的树也就不同了。

clf = tree.DecisionTreeClassifier(criterion="entropy",random_state=30)

#可以使用"best"或者"random"。前者在特征的所有划分点中找出最优的划分点。后者是随机的在部分划分点中找局部最优的划分点。

clf = clf.fit(Xtrain, Ytrain)

score = clf.score(Xtest, Ytest) #返回预测的准确度

score

二、调参数 random_state & splitter

random_state用来设置分枝中的随机模式的参数，默认None，在高维度时随机性会表现更明显，低维度的数据（比如鸢尾花数据集），随机性几乎不会显现。输入任意整数，会一直长出同一棵树，让模型稳定下来。 splitter也是用来控制决策树中的随机选项的，有两种输入值，输入”best"，决策树在分枝时虽然随机，但是还是会优先选择更重要的特征进行分枝（重要性可以通过属性feature_importances_查看），输入“random"，决策树在分枝时会更加随机，树会因为含有更多的不必要信息而更深更大，并因这些不必要信息而降低对训练集的拟合。这也是防止过拟合的一种方式。当你预测到你的模型会过拟合，用这两个参数来帮助你降低树建成之后过拟合的可能性。当然，树一旦建成，我们依然是使用剪枝参数来防止过拟合。

clf = tree.DecisionTreeClassifier(criterion="entropy",random_state=30,splitter="random")

clf = clf.fit(Xtrain, Ytrain)

score = clf.score(Xtest, Ytest)

score

import graphviz

dot_data = tree.export_graphviz(clf,feature_names= feature_name,class_names=["琴酒","雪莉","贝尔摩德"],filled=True,rounded=True)

graph = graphviz.Source(dot_data)

graph

剪枝参数

#我们的树对训练集的拟合程度如何？

score_train = clf.score(Xtrain, Ytrain)

score_train

为了让决策树有更好的泛化性，我们要对决策树进行剪枝。剪枝策略对决策树的影响巨大，正确的剪枝策略是优化决策树算法的核心。sklearn为我们提供了不同的剪枝策略

#带有剪枝参数

clf = tree.DecisionTreeClassifier(criterion="entropy"

,random_state=30

,splitter="random"

,max_depth=3

,min_samples_leaf=10

,min_samples_split=10

)

clf = clf.fit(Xtrain, Ytrain)

dot_data = tree.export_graphviz(clf

,feature_names= feature_name

,class_names=["琴酒","雪莉","贝尔摩德"]

,filled=True

,rounded=True

)

graph = graphviz.Source(dot_data)

graph

clf.score(Xtrain,Ytrain)

clf.score(Xtest,Ytest)

确认最优的剪枝参数那具体怎么来确定每个参数填写什么值呢？这时候，我们就要使用确定超参数的曲线来进行判断了，继续使用我们已经训练好的决策树模型clf。超参数的学习曲线，是一条以超参数的取值为横坐标，模型的度量指标为纵坐标的曲线，它是用来衡量不同超参数取值下模型的表现的线。在我们建好的决策树里，我们的模型度量指标就是score。

import matplotlib.pyplot as plt

test =[]

for i in range(10):

clf = tree.DecisionTreeClassifier(max_depth=i+1,criterion="entropy",random_state=30,splitter="random")

clf = clf.fit(Xtrain, Ytrain)

score = clf.score(Xtest, Ytest)

test.append(score)

plt.plot(range(1,11),test,color="red",label="max_depth")

plt.legend()

plt.show()

输出

目标权重参数

class_weight & min_weight_fraction_leaf

完成样本标签平衡的参数。样本不平衡是指在一组数据集中，标签的一类天生占有很大的比例。比如说，在银行要判断“一个办了信用卡的人是否会违约”，就是是vs否（1%：99%）的比例。这种分类状况下，即便模型什么也不做，全把结果预测成“否”，正确率也能有99%。因此我们要使用class_weight参数对样本标签进行一定的均衡，给少量的标签更多的权重，让模型更偏向少数类，向捕获少数类的方向建模。该参数默认None，此模式表示自动给与数据集中的所有标签相同的权重。有了权重之后，样本量就不再是单纯地记录数目，而是受输入的权重影响了，因此这时候剪枝，就需要搭配min_ weight_fraction_leaf这个基于权重的剪枝参数来使用。另请注意，基于权重的剪枝参数（例如min_weight_ fraction_leaf）将比不知道样本权重的标准（比如min_samples_leaf）更少偏向主导类。如果样本是加权的，则使用基于权重的预修剪标准来更容易优化树结构，这确保叶节点至少包含样本权重的总和的一小部分。

重要属性和接口

属性是在模型训练之后，能够调用查看的模型的各种性质。对决策树来说，最重要的是feature_importances_，能够查看各个特征对模型的重要性。 sklearn中许多算法的接口都是相似的，比如说我们之前已经用到的fit和score，几乎对每个算法都可以使用。除了这两个接口之外，决策树最常用的接口还有apply和predict。apply中输入测试集返回每个测试样本所在的叶子节点的索引，predict输入测试集返回每个测试样本的标签。返回的内容一目了然并且非常容易，大家感兴趣可以自己下去试试看。

#apply返回每个测试样本所在的叶子节点的索引

clf.apply(Xtest)

#predict返回每个测试样本的分类/回归结果

clf.predict(Xtest)

至此，我们已经学完了分类树DecisionTreeClassifier和用决策树绘图（export_graphviz）的所有基础。我们讲解了决策树的基本流程，分类树的七个参数，一个属性，四个接口，以及绘图所用的代码。七个参数：Criterion，两个随机性相关的参数（random_state，splitter），四个剪枝参数（max_depth, ， min_sample_leaf，max_feature，min_impurity_decrease）一个属性：feature_importances_ 四个接口：fit，score，apply，predict 有了这些知识，基本上分类树的使用大家都能够掌握了，接下来再到实例中去磨练就好。

实例：分类树在合成数集上的表现

我们在红酒数据集上画出了一棵树，并且展示了多个参数会对树形成这样的影响，接下来，我们将在不同结构的数据集上测试一下决策树的效果，让大家更好地理解决策树。

1、导入需要的库

import numpy as np

import matplotlib.pyplot as plt

from matplotlib.colors import ListedColormap

from sklearn.model_selection import train_test_split

from sklearn.preprocessing import StandardScaler

from sklearn.datasets import make_moons, make_circles, make_classification

from sklearn.tree import DecisionTreeClassifier

2. 生成三种数据集

我们先从sklearn自带的数据库中生成三种类型的数据集：1）月亮型数据，2）环形数据，3）二分型数据

#make_classification库生成随机的二分型数据

X, y = make_classification(n_samples=100, #生成100个样本

n_features=2, #包含2个特征，即生成二维数据

n_redundant=0, #添加冗余特征0个

n_informative=2, #包含信息的特征是2个

random_state=1, #随机模式1

n_clusters_per_class=1 #每个簇内包含的标签类别有1个

)

#在这里可以查看一下X和y，其中X是100行带有两个2特征的数据，y是二分类标签

#也可以画出散点图来观察一下X中特征的分布

#plt.scatter(X[:,0],X[:,1])

#从图上可以看出，生成的二分型数据的两个簇离彼此很远，这样不利于我们测试分类器的效果，因此我们使用np生成

随机数组，通过让已经生成的二分型数据点加减0~1之间的随机数，使数据分布变得更散更稀疏

#注意，这个过程只能够运行一次，因为多次运行之后X会变得非常稀疏，两个簇的数据会混合在一起，分类器的效应会

继续下降

rng = np.random.RandomState(2) #生成一种随机模式

X += 2 * rng.uniform(size=X.shape) #加减0~1之间的随机数

linearly_separable = (X, y) #生成了新的X，依然可以画散点图来观察一下特征的分布

#plt.scatter(X[:,0],X[:,1])

#用make_moons创建月亮型数据，make_circles创建环形数据，并将三组数据打包起来放在列表datasets中

datasets = [make_moons(noise=0.3, random_state=0),

make_circles(noise=0.2, factor=0.5, random_state=1),

linearly_separable]

画出三种数据集和三棵决策树的分类效应图像

#创建画布，宽高比为6*9

figure = plt.figure(figsize=(6, 9))

#设置用来安排图像显示位置的全局变量i

i = 1

#开始迭代数据，对datasets中的数据进行for循环

for ds_index, ds in enumerate(datasets):

#对X中的数据进行标准化处理，然后分训练集和测试集

X, y = ds

X = StandardScaler().fit_transform(X)

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=.4,

random_state=42)

#找出数据集中两个特征的最大值和最小值，让最大值+0.5，最小值-0.5，创造一个比两个特征的区间本身更大

一点的区间

x1_min, x1_max = X[:, 0].min() - .5, X[:, 0].max() + .5

x2_min, x2_max = X[:, 1].min() - .5, X[:, 1].max() + .5

#用特征向量生成网格数据，网格数据，其实就相当于坐标轴上无数个点

#函数np.arange在给定的两个数之间返回均匀间隔的值，0.2为步长

#函数meshgrid用以生成网格数据，能够将两个一维数组生成两个二维矩阵。

#如果第一个数组是narray，维度是n，第二个参数是marray，维度是m。那么生成的第一个二维数组是以

narray为行，m行的矩阵，而第二个二维数组是以marray的转置为列，n列的矩阵

#生成的网格数据，是用来绘制决策边界的，因为绘制决策边界的函数contourf要求输入的两个特征都必须是二

维的

array1,array2 = np.meshgrid(np.arange(x1_min, x1_max, 0.2),

np.arange(x2_min, x2_max, 0.2))

#接下来生成彩色画布

#用ListedColormap为画布创建颜色，#FF0000正红，#0000FF正蓝

cm = plt.cm.RdBu

cm_bright = ListedColormap(['#FF0000', '#0000FF'])

#在画布上加上一个子图，数据为len(datasets)行，2列，放在位置i上

ax = plt.subplot(len(datasets), 2, i)

#到这里为止，已经生成了0~1之间的坐标系3个了，接下来为我们的坐标系放上标题

#我们有三个坐标系，但我们只需要在第一个坐标系上有标题，因此设定if ds_index==0这个条件

if ds_index == 0:

ax.set_title("Input data")

#将数据集的分布放到我们的坐标系上

#先放训练集

ax.scatter(X_train[:, 0], X_train[:, 1], c=y_train,

cmap=cm_bright,edgecolors='k')

#放测试集

ax.scatter(X_test[:, 0], X_test[:, 1], c=y_test,

cmap=cm_bright, alpha=0.6,edgecolors='k')

#为图设置坐标轴的最大值和最小值，并设定没有坐标轴

ax.set_xlim(array1.min(), array1.max())

ax.set_ylim(array2.min(), array2.max())

ax.set_xticks(())

ax.set_yticks(())

#每次循环之后，改变i的取值让图每次位列不同的位置

i += 1

#至此为止，数据集本身的图像已经布置完毕，运行以上的代码，可以看见三个已经处理好的数据集

#############################从这里开始是决策树模型##########################

#迭代决策树，首先用subplot增加子图，subplot(行，列，索引)这样的结构，并使用索引i定义图的位置

#在这里，len(datasets)其实就是3，2是两列

#在函数最开始，我们定义了i=1，并且在上边建立数据集的图像的时候，已经让i+1,所以i在每次循环中的取值

是2，4，6

ax = plt.subplot(len(datasets),2,i)

#决策树的建模过程：实例化 → fit训练 → score接口得到预测的准确率

clf = DecisionTreeClassifier(max_depth=5)

clf.fit(X_train, y_train)

score = clf.score(X_test, y_test)

#绘制决策边界，为此，我们将为网格中的每个点指定一种颜色[x1_min，x1_max] x [x2_min，x2_max]

#分类树的接口，predict_proba，返回每一个输入的数据点所对应的标签类概率

#类概率是数据点所在的叶节点中相同类的样本数量/叶节点中的样本总数量

#由于决策树在训练的时候导入的训练集X_train里面包含两个特征，所以我们在计算类概率的时候，也必须导入

结构相同的数组，即是说，必须有两个特征

#ravel()能够将一个多维数组转换成一维数组

#np.c_是能够将两个数组组合起来的函数

#在这里，我们先将两个网格数据降维降维成一维数组，再将两个数组链接变成含有两个特征的数据，再带入决策

树模型，生成的Z包含数据的索引和每个样本点对应的类概率，再切片，且出类概率

Z = clf.predict_proba(np.c_[array1.ravel(),array2.ravel()])[:, 1]

#np.c_[np.array([1,2,3]), np.array([4,5,6])]

#将返回的类概率作为数据，放到contourf里面绘制去绘制轮廓

Z = Z.reshape(array1.shape)

ax.contourf(array1, array2, Z, cmap=cm, alpha=.8)

#将数据集的分布放到我们的坐标系上

# 将训练集放到图中去

ax.scatter(X_train[:, 0], X_train[:, 1], c=y_train, cmap=cm_bright,

edgecolors='k')

# 将测试集放到图中去

ax.scatter(X_test[:, 0], X_test[:, 1], c=y_test, cmap=cm_bright,

edgecolors='k', alpha=0.6)

#为图设置坐标轴的最大值和最小值

ax.set_xlim(array1.min(), array1.max())

ax.set_ylim(array2.min(), array2.max())

#设定坐标轴不显示标尺也不显示数字

ax.set_xticks(())

ax.set_yticks(())

#我们有三个坐标系，但我们只需要在第一个坐标系上有标题，因此设定if ds_index==0这个条件

if ds_index == 0:

ax.set_title("Decision Tree")

#写在右下角的数字

ax.text(array1.max() - .3, array2.min() + .3, ('{:.1f}%'.format(score*100)),

size=15, horizontalalignment='right')

#让i继续加一

i += 1

plt.tight_layout()

plt.show()

从图上来看，每一条线都是决策树在二维平面上画出的一条决策边界，每当决策树分枝一次，就有一条线出现。当数据的维度更高的时候，这条决策边界就会由线变成面，甚至变成我们想象不出的多维图形。同时，很容易看得出，分类树天生不擅长环形数据。每个模型都有自己的决策上限，所以一个怎样调整都无法提升表现的可能性也是有的。当一个模型怎么调整都不行的时候，我们可以选择换其他的模型使用，不要在一棵树上吊死。顺便一说，最擅长月亮型数据的是最近邻算法，RBF支持向量机和高斯过程；最擅长环形数据的是最近邻算法和高斯过程；最擅长对半分的数据的是朴素贝叶斯，神经网络和随机森林。

优惠劵

闫究生

关注

踩

214

觉得还不错?

一键收藏

知道了

【sklearn入门】决策树在sklearn中的实现--实战红酒分类案例

scikit-learn简介scikit-learn，又写作sklearn，是一个开源的基于python语言的机器学习工具包。它通过NumPy, SciPy和Matplotlib等python数值计算的库实现高效的算法应用，并且涵盖了几乎所有主流机器学习算法。 http://scikit-learn.org/stable/index.html 在工...

复制链接

扫一扫

专栏目录

决策树-分类树-红酒数据集-sklearn

07-18

决策树-分类树-红酒数据集-sklearn

机器学习（2）--sklearn库写决策树（分类树）

人工智能小白

08-16

1729

红酒数据集建立决策树

5 条评论

您还未登录，请先

后发表或查看评论

[Python] scikit-learn - 葡萄酒(wine)数据集和决策树分类器的使用

Follow

im2.0钱包下载后登录|sklearn决策树

im2.0钱包下载后登录|sklearn决策树

1.10. Decision Trees — scikit-learn 1.4.1 documentation

一文了解sklearn决策树 - 知乎

sklearn.tree.DecisionTreeClassifier — scikit-learn 1.4.1 documentation

1.10. 决策树 - sklearn

通俗地说决策树算法（三）sklearn决策树实战 - 知乎

1.10 决策树-scikit-learn中文社区

【机器学习sklearn】决策树（Decision Tree）算法_sklearn中决策树是什么算法-CSDN博客

【菜菜的sklearn】01 决策树 - 知乎

使用Sklearn学习决策树_clf怎么导入-CSDN博客

【sklearn入门】决策树在sklearn中的实现--实战红酒分类案例_请利用sklearn库实现具体数据的决策树分类-CSDN博客

最近的新闻

您可能喜欢的文章

比特派下载地址|cybertruck中国售价

imtoken钱包下载最新版|港币怎么换人民币

比特派要怎么提现到微信

比特派钱包权限怎么改回来

比特派怎么设置英文名字

比特派钱包怎么把币转到zb里

比特派转不出去怎么办