随机森林分类类RandomForestClassifier

川长思鸟来 2023-06-21 03:54 7阅读 0赞

随机森林分类器。  scikit-learn v0.19.1  
随机森林是一个元估计器，它适合数据集的各个子样本上的多个决策树分类器，并使用平均值来提高预测精度和控制过度拟合。 子样本大小始终与原始输入样本大小相同，但如果bootstrap = True（默认值），则会使用替换来绘制样本。  
先看这个类的参数：

class sklearn.ensemble.RandomForestClassifier(n\_estimators=10, criterion='gini', max\_depth=None, min\_samples\_split=2, min\_samples\_leaf=1, min\_weight\_fraction\_leaf=0.0, max\_features=’auto’, max\_leaf\_nodes=None, min\_impurity\_decrease=0.0, min\_impurity\_split=None, bootstrap=True, oob\_score=False, n\_jobs=1, random\_state=None, verbose=0, warm\_start=False, class\_weight=None)  
具体参数意义如下：  
参数：

n\_estimators : integer, optional (default=10)  整数，可选择(默认值为10)。

The number of trees in the forest.

森林里（决策）树的数目。

criterion : string, optional (default=”gini”) 字符串，可选择(默认值为“gini”)。

The function to measure the quality of a split. Supported criteria are “gini” for the Gini impurity and “entropy” for the information gain. Note: this parameter is tree-specific.

衡量分裂质量的性能（函数）。 受支持的标准是基尼不纯度的"gini",和信息增益的"entropy"（熵）。  
注意：这个参数是特定树的。  
首先Gini不纯度和Gini系数（coefficient）没有关系。Gini impurity衡量的是从一个集合中随机选择一个元素，基于该集合中标签的概率分布为元素分配标签的错误率。对于任何一个标签下的元素，其被分类正确的条件概率可以理解为在选择元素时选中该标签的概率与在分类时选中该标签的概率。基于上述描述，Gini impurity的计算就非常简单了，即1减去所有分类正确的概率，得到的就是分类不正确的概率。若元素数量非常多，切所有元素单独属于一个分类时，Gini不纯度达到极小值0。

设元素的标签为，为该标签在集合中的比例，那么

max\_features : int, float, string or None, optional (default=”auto”)  整数，浮点数，字符串或者无值，可选的（默认值为"auto"）

The number of features to consider when looking for the best split:

If int, then consider max\_features features at each split.  
If float, then max\_features is a percentage and int(max\_features \* n\_features) features are considered at each split.  
If “auto”, then max\_features=sqrt(n\_features).  
If “sqrt”, then max\_features=sqrt(n\_features) (same as “auto”).  
If “log2”, then max\_features=log2(n\_features).  
If None, then max\_features=n\_features.  
Note: the search for a split does not stop until at least one valid partition of the node samples is found, even if it requires to effectively inspect more than max\_featuresfeatures.

寻找最佳分割时需要考虑的特征数目：

&如果是int，就要考虑每一次分割处的max\_feature特征

&如果是float，那么max\_features就是一个百分比，那么（max\_feature\*n\_features）特征整数值是在每个分割处考虑的。

&如果是auto，那么max\_features=sqrt(n\_features)，即n\_features的平方根值。

&如果是log2，那么max\_features=log2(n\_features)

&如果是None,那么max\_features=n\_features

注意：寻找分割点不会停止，直到找到最少一个有效的节点划分区，即使它需要有效检查超过max\_features的特征。

max\_depth : integer or None, optional (default=None)  整数或者无值，可选的（默认为None）

The maximum depth of the tree. If None, then nodes are expanded until all leaves are pure or until all leaves contain less than min\_samples\_split samples.

（决策）树的最大深度。如果值为None，那么会扩展节点，直到所有的叶子是纯净的，或者直到所有叶子包含少于min\_sample\_split的样本。

以上叶子节点是纯净的，这句话其实我不太理解。  
min\_samples\_split : int, float, optional (default=2)   整数，浮点数，可选的（默认值为2）

The minimum number of samples required to split an internal node:

If int, then consider min\_samples\_split as the minimum number.  
If float, then min\_samples\_split is a percentage and ceil(min\_samples\_split \* n\_samples) are the minimum number of samples for each split.  
Changed in version 0.18: Added float values for percentages.

分割内部节点所需要的最小样本数量：

~如果为int，那么考虑min\_samples\_split作为最小的数字。

~如果为float，那么min\_samples\_split是一个百分比，并且把ceil(min\_samples\_split\*n\_samples)是每一个分割最小的样本数量。

在版本0.18中更改：为百分比添加浮点值。

min\_samples\_leaf : int, float, optional (default=1) 整数，浮点数，可选的（默认值为1）

The minimum number of samples required to be at a leaf node:

If int, then consider min\_samples\_leaf as the minimum number.  
If float, then min\_samples\_leaf is a percentage and ceil(min\_samples\_leaf \* n\_samples) are the minimum number of samples for each node.  
Changed in version 0.18: Added float values for percentages.

需要在叶子结点上的最小样本数量：

~如果为int，那么考虑min\_samples\_leaf作为最小的数字。

~如果为float，那么min\_samples\_leaf为一个百分比，并且ceil(min\_samples\_leaf\*n\_samples)是每一个节点的最小样本数量。

在版本0.18中更改：为百分比添加浮点值。

min\_weight\_fraction\_leaf : float, optional (default=0.)  浮点数，可选的（默认值是0.0）

The minimum weighted fraction of the sum total of weights (of all the input samples) required to be at a leaf node. Samples have equal weight when sample\_weight is not provided.

一个叶子节点所需要的权重总和（所有的输入样本）的最小加权分数。当sample\_weight没有提供时，样本具有相同的权重

max\_leaf\_nodes : int or None, optional (default=None)  整数或者无值,可选的（默认值为None）

Grow trees with max\_leaf\_nodes in best-first fashion. Best nodes are defined as relative reduction in impurity. If None then unlimited number of leaf nodes.

以最优的方法使用max\_leaf\_nodes来生长树。最好的节点被定义为不纯度上的相对减少。如果为None,那么不限制叶子节点的数量。

min\_impurity\_split : float,   浮点数

Threshold for early stopping in tree growth. A node will split if its impurity is above the threshold, otherwise it is a leaf.

树早期生长的阈值。如果一个节点的不纯度超过阈值那么这个节点将会分裂，否则它还是一片叶子。

Deprecated since version 0.19: min\_impurity\_split has been deprecated in favor ofmin\_impurity\_decrease in 0.19 and will be removed in 0.21. Use min\_impurity\_decreaseinstead.  
自0.19版以后不推荐使用：min\_impurity\_split已被弃用，取而代之的是0.19中的min\_impurity\_decrease。min\_impurity\_split将在0.21中被删除。 使用min\_impurity\_decrease。  
min\_impurity\_decrease : float, optional (default=0.)  浮点数，可选的（默认值为0）

A node will be split if this split induces a decrease of the impurity greater than or equal to this value.

The weighted impurity decrease equation is the following:

N\_t / N \* (impurity - N\_t\_R / N\_t \* right\_impurity  
                    - N\_t\_L / N\_t \* left\_impurity)  
where N is the total number of samples, N\_t is the number of samples at the current node, N\_t\_L is the number of samples in the left child, and N\_t\_R is the number of samples in the right child.

N, N\_t, N\_t\_R and N\_t\_L all refer to the weighted sum, if sample\_weight is passed.

New in version 0.19.

如果节点的分裂导致的不纯度的下降程度大于或者等于这个节点的值，那么这个节点将会被分裂。

不纯度加权减少方程式如下：

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是右孩子节点的样本数量。  
N，N\_t，N\_t\_R和N\_t\_L全部是指加权总和，如果sample\_weight通过的话。

0.19版本新加的参数。

bootstrap : boolean, optional (default=True)    布尔值，可选的（默认值为True）

Whether bootstrap samples are used when building trees.

建立决策树时，是否使用有放回抽样。

oob\_score : bool (default=False)  bool，（默认值为False）

Whether to use out-of-bag samples to estimate the generalization accuracy.

是否使用袋外样本来估计泛化精度。

n\_jobs : integer, optional (default=1)   整数，可选的（默认值为1）

The number of jobs to run in parallel for both fit and predict. If -1, then the number of jobs is set to the number of cores.

用于拟合和预测的并行运行的工作（作业）数量。如果值为-1，那么工作数量被设置为核的数量。

random\_state : int, RandomState instance or None, optional (default=None) 整数，RandomState实例，或者为None,可选（默认值为None）

RandomStateIf int, random\_state is the seed used by the random number generator; If RandomState instance, random\_state is the random number generator; If None, the random number generator is the RandomState instance used by np.random.

RandomStateIf int，random\_state是随机数生成器使用的种子; 如果是RandomState实例，random\_state就是随机数生成器; 如果为None，则随机数生成器是np.random使用的RandomState实例。

verbose : int, optional (default=0)   整数，可选的（默认值为0）

Controls the verbosity of the tree building process.

控制决策树建立过程的冗余度。

warm\_start : bool, optional (default=False)   布尔值，可选的（默认值为False）

When set to True, reuse the solution of the previous call to fit and add more estimators to the ensemble, otherwise, just fit a whole new forest.

当被设置为True时，重新使用之前呼叫的解决方案，用来给全体拟合和添加更多的估计器，反之，仅仅只是为了拟合一个全新的森林。

class\_weight : dict, list of dicts, “balanced”,   字典，字典序列，"balanced"

“balanced\_subsample” or None, optional (default=None) Weights associated with classes in the form \{class\_label: weight\}. If not given, all classes are supposed to have weight one. For multi-output problems, a list of dicts can be provided in the same order as the columns of y.

Note that for multioutput (including multilabel) weights should be defined for each class of every column in its own dict. For example, for four-class multilabel classification weights should be \[\{0: 1, 1: 1\}, \{0: 1, 1: 5\}, \{0: 1, 1: 1\}, \{0: 1, 1: 1\}\] instead of \[\{1:1\}, \{2:5\}, \{3:1\}, \{4:1\}\].

The “balanced” mode uses the values of y to automatically adjust weights inversely proportional to class frequencies in the input data as n\_samples / (n\_classes \* np.bincount(y))

The “balanced\_subsample” mode is the same as “balanced” except that weights are computed based on the bootstrap sample for every tree grown.

For multi-output, the weights of each column of y will be multiplied.

Note that these weights will be multiplied with sample\_weight (passed through the fit method) if sample\_weight is specified.

“balanced\_subsample” 或者None,（默认值为None）,与格式\{class\_label: weight\}相关联的类的可选的权值。如果没有给值，所有的类到都应该有一个权值。对于多输出问题，一个字典序列可以按照y的列的顺利被提供。  
请注意，对于多输出（包括多标签），其权值应该被定义为它自己字典的每一列的每一个类。例如，对于四类多标签分类，权值应该如\[\{0: 1, 1: 1\}, \{0: 1, 1: 5\}, \{0: 1, 1: 1\}, \{0: 1, 1: 1\}\] 这样，而不是\[\{1:1\}, \{2:5\}, \{3:1\}, \{4:1\}\].这样。

"balanced"模式使用y的值来自动的调整权值，与输入数据中类别频率成反比，如：

n\_samples / (n\_classes \* np.bincount(y))  
"balanced\_subsample"模式和"balanced"相同，除了权值是基于每棵成长树有放回抽样计算的。

对于多输出，y的每列权值将相乘。

请注意，如果指定了sample\_weight,这些权值将会和sample\_weight相乘（通过拟合方法传递）。

属性：  
estimators\_ : list of DecisionTreeClassifier   决策树分类器的序列

The collection of fitted sub-estimators.    拟合的子估计器的集合。

classes\_ : array of shape = \[n\_classes\] or a list of such arrays   数组维度=\[n\_classes\]的数组或者一个这样数组的序列。

The classes labels (single output problem), or a list of arrays of class labels (multi-output problem).

类别标签（单一输出问题），或者类别标签的数组序列（多输出问题）。

n\_classes\_ : int or list   整数或者序列

The number of classes (single output problem), or a list containing the number of classes for each output (multi-output problem).

类别的数量（单输出问题），或者一个序列，包含每一个输出的类别数量（多输出问题）

n\_features\_ : int    整数

The number of features when fit is performed.

执行拟合时的特征数量。

n\_outputs\_ : int   整数

The number of outputs when fit is performed.

执行拟合时的输出数量。

feature\_importances\_ : array of shape = \[n\_features\]  维度等于n\_features的数组

The feature importances (the higher, the more important the feature).

特征的重要性（值越高，特征越重要）

oob\_score\_ : float    浮点数

Score of the training dataset obtained using an out-of-bag estimate.

使用袋外估计获得的训练数据集的得分。

oob\_decision\_function\_ : array of shape = \[n\_samples, n\_classes\]   维度=\[n\_samples,n\_classes\]的数组

Decision function computed with out-of-bag estimate on the training set. If n\_estimators is small it might be possible that a data point was never left out during the bootstrap. In this case, oob\_decision\_function\_ might contain NaN.

在训练集上用袋外估计计算的决策函数。如果n\_estimators很小的话，那么在有放回抽样中，一个数据点也不会被忽略是可能的。在这种情况下，oob\_decision\_function\_ 可能包括NaN。

Notes

The default values for the parameters controlling the size of the trees (e.g. max\_depth, min\_samples\_leaf, etc.) lead to fully grown and unpruned trees which can potentially be very large on some data sets. To reduce memory consumption, the complexity and size of the trees should be controlled by setting those parameter values.

The features are always randomly permuted at each split. Therefore, the best found split may vary, even with the same training data, max\_features=n\_features and bootstrap=False, if the improvement of the criterion is identical for several splits enumerated during the search of the best split. To obtain a deterministic behaviour during fitting, random\_statehas to be fixed.

注意点：

参数的默认值控制决策树的大小（例如，max\_depth，，min\_samples\_leaf等等），导致完全的生长和在某些数据集上可能非常大的未修剪的树。为了降低内容消耗，决策树的复杂度和大小应该通过设置这些参数值来控制。

这些特征总是在每个分割中随机排列。 因此，即使使用相同的训练数据，max\_features = n\_features和bootstrap = False，如果在搜索最佳分割期间所列举的若干分割的准则的改进是相同的，那么找到的最佳分割点可能会不同。 为了在拟合过程中获得一个确定的行为，random\_state将不得不被修正。  
例子：

>>> from sklearn.ensemble import RandomForestClassifier  
>>> from sklearn.datasets import make\_classification  
>>>  
>>> X, y = make\_classification(n\_samples=1000, n\_features=4,  
...                            n\_informative=2, n\_redundant=0,  
...                            random\_state=0, shuffle=False)  
>>> clf = RandomForestClassifier(max\_depth=2, random\_state=0)  
>>> clf.fit(X, y)  
RandomForestClassifier(bootstrap=True, class\_weight=None, criterion='gini',  
            max\_depth=2, max\_features='auto', max\_leaf\_nodes=None,  
            min\_impurity\_decrease=0.0, min\_impurity\_split=None,  
            min\_samples\_leaf=1, min\_samples\_split=2,  
            min\_weight\_fraction\_leaf=0.0, n\_estimators=10, n\_jobs=1,  
            oob\_score=False, random\_state=0, verbose=0, warm\_start=False)  
>>> print(clf.feature\_importances\_)  
\[ 0.17287856  0.80608704  0.01884792  0.00218648\]  
>>> print(clf.predict(\[\[0, 0, 0, 0\]\]))  
\[1\]  
methods:

apply(X)      Apply trees in the forest to X, return leaf indices.  
decision\_path(X)      Return the decision path in the forest  
fit(X, y\[, sample\_weight\])        Build a forest of trees from the training set (X, y).  
get\_params(\[deep\])       Get parameters for this estimator.  
predict(X)        Predict class for X.  
predict\_log\_proba(X)        Predict class log-probabilities for X.  
predict\_proba(X)         Predict class probabilities for X.  
score(X, y\[, sample\_weight\])         Returns the mean accuracy on the given test data and labels.  
set\_params(\*\*params)        Set the parameters of this estimator.

以下是RandomForestClassifier的超类  
\_\_init\_\_(n\_estimators=10, criterion=’gini’, max\_depth=None, min\_samples\_split=2, min\_samples\_leaf=1, min\_weight\_fraction\_leaf=0.0, max\_features=’auto’, max\_leaf\_nodes=None, min\_impurity\_decrease=0.0, min\_impurity\_split=None, bootstrap=True, oob\_score=False, n\_jobs=1, random\_state=None, verbose=0, warm\_start=False, class\_weight=None)  
apply(X)  
Apply trees in the forest to X, return leaf indices.将森林中的树应用到X，返回树叶索引。

Parameters:      
X : array-like or sparse matrix, shape = \[n\_samples, n\_features\]  像数组或者稀疏矩阵，维度= \[n\_samples, n\_features\]

The input samples. Internally, its dtype will be converted to dtype=np.float32. If a sparse matrix is provided, it will be converted into a sparse csr\_matrix.

输入样本。 在内部，其dtype将被转换为dtype = np.float32。 如果提供了一个稀疏矩阵，它将被转换成一个稀疏的csr\_matrix。  
Returns:      
X\_leaves : array\_like, shape = \[n\_samples, n\_estimators\]

For each datapoint x in X and for each tree in the forest, return the index of the leaf x ends up in.

对于X中的每个数据点x和森林中的每个树，返回叶子x的索引。

decision\_path(X)\[source\]  
Return the decision path in the forest   返回森林中的决策路径。

New in version 0.18.

Parameters:      
X : array-like or sparse matrix, shape = \[n\_samples, n\_features\]

The input samples. Internally, its dtype will be converted to dtype=np.float32. If a sparse matrix is provided, it will be converted into a sparse csr\_matrix.

Returns:      
indicator : sparse csr array, shape = \[n\_samples, n\_nodes\]   指针。

Return a node indicator matrix where non zero elements indicates that the samples goes through the nodes.

n\_nodes\_ptr : array of size (n\_estimators + 1, )     数组大小（估计器加1）

The columns from indicator\[n\_nodes\_ptr\[i\]:n\_nodes\_ptr\[i+1\]\] gives the indicator value for the i-th estimator.

feature\_importances\_  
Return the feature importances (the higher, the more important the  
feature).  
Returns:    feature\_importances\_ : array, shape = \[n\_features\]  
fit(X, y, sample\_weight=None)        
Build a forest of trees from the training set (X, y).    从训练数据集(X,y)上建立一个决策树森林。

Parameters:      
X : array-like or sparse matrix of shape = \[n\_samples, n\_features\]

The training input samples. Internally, its dtype will be converted to dtype=np.float32. If a sparse matrix is provided, it will be converted into a sparse csc\_matrix.

y : array-like, shape = \[n\_samples\] or \[n\_samples, n\_outputs\]

The target values (class labels in classification, real numbers in regression).

目标值（分类中的类标签，回归中的实数）。  
sample\_weight : array-like, shape = \[n\_samples\] or None

Sample weights. If None, then samples are equally weighted. Splits that would create child nodes with net zero or negative weight are ignored while searching for a split in each node. In the case of classification, splits are also ignored if they would result in any single class carrying a negative weight in either child node.

样本权值。 如果没有，那么样本的权重是相等的。 当搜索每个节点中的分割时，将会忽略创建具有净零或负权重的子节点的分割。 在分类的情况下，分裂也会被忽略，如果它们会导致任何一个类别在任何一个孩子节点中都带有负权重。  
Returns:      
self : object

Returns self.

get\_params(deep=True)\[source\]  
Get parameters for this estimator.  获取此估算器的参数

Parameters:      
deep : boolean, optional

If True, will return the parameters for this estimator and contained subobjects that are estimators.

Returns:      
params : mapping of string to any

Parameter names mapped to their values.

predict(X)  
Predict class for X.  预测X的类别。

The predicted class of an input sample is a vote by the trees in the forest, weighted by their probability estimates. That is, the predicted class is the one with highest mean probability estimate across the trees.

输入样本的预测类别是森林中树的投票，由它们的概率估计进行加权。 也就是说，预测的类是跨树的平均概率估计最高的类。  
Parameters:      
X : array-like or sparse matrix of shape = \[n\_samples, n\_features\]

The input samples. Internally, its dtype will be converted to dtype=np.float32. If a sparse matrix is provided, it will be converted into a sparse csr\_matrix.

Returns:      
y : array of shape = \[n\_samples\] or \[n\_samples, n\_outputs\]

The predicted classes.

predict\_log\_proba(X)\[source\]  
Predict class log-probabilities for X. 预测X的类对数概率。

The predicted class log-probabilities of an input sample is computed as the log of the mean predicted class probabilities of the trees in the forest.

输入样本的预测类别对数概率被计算为森林中树木的平均预测类别概率的对数。  
Parameters:      
X : array-like or sparse matrix of shape = \[n\_samples, n\_features\]

The input samples. Internally, its dtype will be converted to dtype=np.float32. If a sparse matrix is provided, it will be converted into a sparse csr\_matrix.

Returns:      
p : array of shape = \[n\_samples, n\_classes\], or a list of n\_outputs

such arrays if n\_outputs > 1. The class probabilities of the input samples. The order of the classes corresponds to that in the attribute classes\_.

predict\_proba(X)\[source\]  
Predict class probabilities for X. 预测X的类概率。

The predicted class probabilities of an input sample are computed as the mean predicted class probabilities of the trees in the forest. The class probability of a single tree is the fraction of samples of the same class in a leaf.

输入样本的预测类别概率被计算为森林中树木的平均预测类别概率。 单个树的类概率是叶中同一类的样本的分数。  
Parameters:      
X : array-like or sparse matrix of shape = \[n\_samples, n\_features\]

The input samples. Internally, its dtype will be converted to dtype=np.float32. If a sparse matrix is provided, it will be converted into a sparse csr\_matrix.

Returns:      
p : array of shape = \[n\_samples, n\_classes\], or a list of n\_outputs

such arrays if n\_outputs > 1. The class probabilities of the input samples. The order of the classes corresponds to that in the attribute classes\_.

score(X, y, sample\_weight=None)\[source\]  
Returns the mean accuracy on the given test data and labels.

返回给定测试数据和标签的平均精确度。  
In multi-label classification, this is the subset accuracy which is a harsh metric since you require for each sample that each label set be correctly predicted.

在多标签分类中，这是子集精度，这是一个苛刻的度量标准，因为您需要为每个样本准确地预测每个标签集。  
Parameters:      
X : array-like, shape = (n\_samples, n\_features)

Test samples.

y : array-like, shape = (n\_samples) or (n\_samples, n\_outputs)

True labels for X.

sample\_weight : array-like, shape = \[n\_samples\], optional

Sample weights.

Returns:      
score : float

Mean accuracy of self.predict(X) wrt. y.

set\_params(\*\*params)\[source\]  
Set the parameters of this estimator.

设置此估算器的参数。  
The method works on simple estimators as well as on nested objects (such as pipelines). The latter have parameters of the form<component>\_\_<parameter> so that it’s possible to update each component of a nested object.

该方法适用于简单的估计器以及嵌套对象（如管道）。 后者具有<component> \_\_ <parameter>形式的参数，以便可以更新嵌套对象的每个组件。  
Return    self :  
以上就是sklearn随机森林分类类的所有内容  
原文：http://scikit-learn.org/stable/modules/generated/sklearn.ensemble.RandomForestClassifier.html  
转自：[https://blog.csdn.net/w952470866/article/details/78987265/][https_blog.csdn.net_w952470866_article_details_78987265]

[https_blog.csdn.net_w952470866_article_details_78987265]: https://blog.csdn.net/w952470866/article/details/78987265/