精华内容
下载资源
问答
  • sklearn随机森林分类类RandomForestClassifier

    万次阅读 多人点赞 2018-01-06 17:09:36
    随机森林分类器。 scikit-learn v0.19.1 随机森林是一个元估计器,它适合数据集的各个子样本上的多个决策树分类器,并使用平均值来提高预测精度和控制过度拟合。 子样本大小始终与原始输入样本大小相同,但如果...

    随机森林分类器。  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。

    设元素的标签为1,2,,m1,2,…,mfifi为该标签在集合中的比例,那么

    IG(f)=mi=1fi(1fi)=mi=1(fifi2)=mi=1fimi=1fi2=1mi=1fi2


    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.

    NN_tN_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_depthmin_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(Xysample_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(Xysample_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

    展开全文
  • 训练随机森林分类

    2019-12-21 11:36:59
    训练随机森林分类器 随机森林,,每棵树 接收的样本是 随机的,有放回随机抽样,每个节点分裂时特征随机 # 参数方面,可以设置 每个节点的特征数, 有放回抽样还是无放回抽样 # 训练随机森林分类器 from sklearn....

    训练随机森林分类器

    随机森林,,每棵树 接收的样本是 随机的,有放回随机抽样,每个节点分裂时特征随机 # 参数方面,可以设置 每个节点的特征数,

    有放回抽样还是无放回抽样

    # 训练随机森林分类器
    from sklearn.ensemble import RandomForestClassifier
    from sklearn import datasets
    ​
    iris = datasets.load_iris()
    features = iris.data
    target = iris.target
    ​
    randomforest = RandomForestClassifier(random_state=0)
    model = randomforest.fit(features, target)
    # 随机森林,,每棵树 接收的样本是  随机的,有放回随机抽样,每个节点分裂时特征随机
    # 参数方面,可以设置  每个节点的特征数,  有放回抽样还是无放回抽样
    #randomforest_entropy = RandomForestClassifier(criterion='entropy', random_state=0)
    #model_entropy = randomforest_entropy.fit(features, target)
    # 创建新样本  
    observation = [[ 5, 4, 3, 2]]
    model.predict(observation)
    array([1])
    Discussion
    A common problem with decision trees is that they tend to fit the training data too closely (i.e. overfitting). This has motivated the widespread use of an ensemble learning method called random forest. In a random forest, many decision trees are trained, but each tree only recieves a bootstrapped sample of observations (i.e. a random sample of observations with replacement that matches the original number of observations) and each node only considers a subset of features when determining the best split. The forest of randomized decision trees votes to determin the predicted class
    
    展开全文
  • 随机森林是非常具有代表性的Bagging集成算法,它的所有基评估器都是决策树,分类树组成的森林就叫做随机森林分类器,回归树所集成的森林就叫做随机森林回归器。我们先来看 RandomForestClassifier,随机森林分类器。...

    以下以随机森林为例讨论集成算法。

    sklearn随机森林分类器

    随机森林是非常具有代表性的Bagging集成算法,它的所有基评估器都是决策树,分类树组成的森林就叫做随机森林分类器,回归树所集成的森林就叫做随机森林回归器。我们先来看
    RandomForestClassifier,随机森林分类器。
    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=None, random_state=None, verbose=0, warm_start=False, class_weight=None)

    重要参数

    控制基评估器的参数

    criterion 不纯度的衡量指标,有基尼系数和信息熵两种选择
    max_depth 树的最大深度,超过最大深度的树枝都会被剪掉
    min_samples_leaf
    一个节点在分枝后的每个子节点都必须包含至少min_samples_leaf个训练样本,否则分枝就不会发生
    min_samples_split
    一个节点必须要包含至少min_samples_split个训练样本,这个节点才允许被分枝,否则分枝就不会发生
    max_features
    限制分枝时考虑的特征个数,超过限制个数的特征都会被舍弃,默认值为总特征个数开平方取整
    min_impurity_decrease 限制信息增益的大小,信息增益小于设定值的分枝不会发生
    这些参数在随机森林中的含义,和我们在上决策树时说明的内容一模一样,单个决策树的准确率越高,随机森林的准确率也会越高,因为装袋法是依赖于平均值或者少数服从多数原则来决定集成的结果的。

    n_estimators

    森林中树木的数量,即基评估器的数量。这个参数对随机森林模型的精确性影响是单调的,
    n_estimators越大,模型的效果往往越好。但是相应的,任何模型都有决策边界,n_estimators达到一定的程度之后,随机森林的精确性往往不在上升或开始波动,并且,n_estimators越大,需要的计算
    量和内存也越大,训练的时间也会越来越长。对于这个参数,我们是追求的是在训练难度和模型效果之间取得平衡。
    n_estimators的默认值在现有版本的sklearn中是10,但是在即将更新的0.22版本中,这个默认值会被修正为100。这个修正显示出了使用者的调参倾向:要更大的n_estimators。

    sklearn建立随机森林分类器

    树模型的优点是简单易懂,可视化之后的树人人都能够看懂,可惜随机森林是无法被可视化的。为了更加直观地让大家体会随机森林的效果,来进行一个随机森林和单个决策树效益的对比。
    依然使用红酒数据集。

    import numpy as np
    import pandas as pd
    import matplotlib.pyplot as plt
    %matplotlib inline
    from sklearn.tree import DecisionTreeClassifier
    from sklearn.ensemble import RandomForestClassifier
    from sklearn.datasets import load_wine
    from sklearn.model_selection import train_test_split
    wine = load_wine()
    wine
    wine.data
    wine.target
    #切分训练集和测试集
    Xtrain, Xtest, Ytrain, Ytest = train_test_split(wine.data,wine.target,test_size=0.3)
    #建立模型
    clf = DecisionTreeClassifier(random_state=0)
    rfc = RandomForestClassifier(random_state=0)
    clf = clf.fit(Xtrain,Ytrain)
    rfc = rfc.fit(Xtrain,Ytrain)
    #查看模型效果
    score_c = clf.score(Xtest,Ytest)
    score_r = rfc.score(Xtest,Ytest)
    #打印最后结果
    print("Single Tree:",score_c)
    print("Random Forest:",score_r)
    
    Single Tree: 0.8888888888888888
    Random Forest: 0.9444444444444444
    
    #画出随机森林和决策树在一组交叉验证下的效果对比
    #交叉验证:是数据集划分为n分,依次取每一份做测试集,每n-1份做训练集,多次训练模型以观测模型稳定性的方法
    from sklearn.model_selection import cross_val_score
    rfc = RandomForestClassifier(n_estimators=25)
    rfc_s = cross_val_score(rfc,wine.data,wine.target,cv=10)
    clf = DecisionTreeClassifier()
    clf_s = cross_val_score(clf,wine.data,wine.target,cv=10)
    plt.plot(range(1,11),rfc_s,label = "RandomForest")
    plt.plot(range(1,11),clf_s,label = "DecisionTree")
    plt.legend()
    plt.show()
    

    在这里插入图片描述

    #一种更加有趣也更简单的写法
    label = "RandomForest"
    for model in [RandomForestClassifier(n_estimators=25),DecisionTreeClassifier()]:
        score = cross_val_score(model,wine.data,wine.target,cv=10)
        print("{}:".format(label)),print(score.mean())
        plt.plot(range(1,11),score,label = label)
        plt.legend()
        label = "DecisionTree"
    
    RandomForest:
    0.955813553491572
    DecisionTree:
    0.88359133126935
    

    在这里插入图片描述

    #画出随机森林和决策树在十组交叉验证下的效果对比
    rfc_l = []
    clf_l = []
    for i in range(10):
        rfc = RandomForestClassifier(n_estimators=25)
        rfc_s = cross_val_score(rfc,wine.data,wine.target,cv=10).mean()
        rfc_l.append(rfc_s)
        clf = DecisionTreeClassifier()
        clf_s = cross_val_score(clf,wine.data,wine.target,cv=10).mean()
        clf_l.append(clf_s)
    #绘制结果曲线
    plt.plot(range(1,11),rfc_l,label = "RandomForest")
    plt.plot(range(1,11),clf_l,label = "DecisionTree")
    plt.legend()
    plt.show()
    

    在这里插入图片描述

    #n_estimators的学习曲线
    #======【TIME WARNING: 2mins 30 seconds】==========#
    superpa = []
    for i in range(200):
        rfc = RandomForestClassifier(n_estimators=i+1)
        rfc_s = cross_val_score(rfc,wine.data,wine.target,cv=10).mean()
        superpa.append(rfc_s)
    print(max(superpa),superpa.index(max(superpa)))
    plt.figure(figsize=[20,5])
    plt.plot(range(1,201),superpa)
    plt.show()
    
    0.9891812865497076 33
    

    在这里插入图片描述

    random_state

    随机森林的本质是一种装袋集成算法(bagging),装袋集成算法是对基评估器的预测结果进行平均或用多数表决原则来决定集成评估器的结果。在刚才的红酒例子中,我们建立了25棵树,对任何一个样本而言,平均或多数表决原则下,当且仅当有13棵以上的树判断错误的时候,随机森林才会判断错误。
    单独一棵决策树对红酒数据集的分类准确率在0.85上下浮动,假设一棵树判断错误的可能性为0.2(ε),那13棵树以上都判断错误的可能性是:
    在这里插入图片描述
    其中,i是判断错误的次数,也是判错的树的数量,ε是一棵树判断错误的概率,(1-ε)是判断正确的概率,共判对25-i次。采用组合,是因为25棵树中,有任意i棵都判断错误。

    #bagging判断错误的可能性(概率组合预测)
    from scipy.special import comb
    np.array([comb(25,i)*(0.2**i)*((1-0.2)**(25-i)) for i in range(13,26)]).sum()
    #sum([comb(25,i)*(0.2**i)*((1-0.2)**(25-i)) for i in range(13,26)])
    
    0.00036904803455582827
    

    可见,判断错误的几率非常小,这让随机森林在红酒数据集上的表现远远好于单棵决策树。
    有一个问题:袋装法服从多数表决原则或对基分类器结果求平均,即,默认森林中的每棵树应该是不同的,并且会返回不同的结果。如果随机森林里所有的树的判断结果都一致(全判断对或全判断错),随机森林无论应用何种集成原则来求结果,都应该无法比单棵决策树取得更好的效果。使用了一样的类DecisionTreeClassifier,一样的参数,一样的训练集和测试集,为什么随机森林里的众多树会有不同的判断结果?
    sklearn中的分类树DecisionTreeClassifier自带随机性,所以随机森林中的树天生就都是不一样的。决策树是从最重要的特征中随机选择出一个特征来进行分枝,因此每次生成的决策树都不一样,这个功能由参random_state控制。
    随机森林中其实也有random_state,用法和分类树中相似,只不过在分类树中,一个random_state只控制生成一棵树,而随机森林中random_state控制的是生成森林的模式,而非让一个森林中只有一棵树。

    #随机森林中的random_state控制的是生成森林的模式
    rfc = RandomForestClassifier(n_estimators=20,random_state=2)
    rfc = rfc.fit(Xtrain, Ytrain)
    #随机森林的重要属性之一:estimators,查看森林中树的状况
    rfc.estimators_[0].random_state#第一个estimator的random_state
    
    1872583848
    
    #打印出森林中所有树的随机模式
    for i in range(len(rfc.estimators_)):
    	print(rfc.estimators_[i].random_state)
    
    1872583848
    794921487
    111352301
    1853453896
    213298710
    1922988331
    1869695442
    2081981515
    1805465960
    1376693511
    1418777250
    663257521
    878959199
    854108747
    512264917
    515183663
    1287007039
    2083814687
    1146014426
    570104212
    

    当random_state固定时,随机森林中生成是一组固定的树,但每棵树依然是不一致的,这是用”随机挑选特征进行分枝“的方法得到的随机性。并且可以证明,当这种随机性越大的时候,袋装法的效果一般会越来越好。用袋装法集成时,基分类器应当是相互独立的,是不相同的。
    但这种做法的局限性是很强的,当需要成千上万棵树的时候,数据不一定能够提供成千上万的特征来构筑尽量多尽量不同的树。因此,除了random_state,还需要其他的随机性。

    bootstrap & oob_score

    要让基分类器尽量都不一样,一种很容易理解的方法是使用不同的训练集来进行训练,而袋装法正是通过有放回的随机抽样技术来形成不同的训练数据,bootstrap就是用来控制抽样技术的参数
    在一个含有n个样本的原始训练集中,随机采样,每次采样一个样本,并在抽取下一个样本之前将该样本放回原始训练集,也就是说下次采样时这个样本依然可能被采集到,这样采集n次,最终得到一个和原始训练集一样大的,n个样本组成的自助集。由于是随机采样,这样每次的自助集和原始
    数据集不同,和其他的采样集也是不同的。这样就可以自由创造取之不尽用之不竭,并且互不相同的自助集,用这些自助集来训练基分类器,我们的基分类器自然也就各不相同了。
    bootstrap参数默认True,代表采用这种有放回的随机抽样技术。通常,这个参数不会被我们设置为False。
    在这里插入图片描述
    然而有放回抽样也会有自己的问题。由于是有放回,一些样本可能在同一个自助集中出现多次,而其他一些却可能被忽略,一般来说,自助集大约平均会包含63%的原始数据。因为每一个样本被抽到某个自助集中的概率为:
    1(11n)n1-(1-\frac1n)^n
    这里的数学公式如何理解呢?要从一个n个样本的数据集中有放回抽样出另一个n个样本的数据集,也就是总共需要进行n次抽样。一个样本在一次抽样中被抽到的概率为1/n,则在一次抽样中没有被抽到的概率是1-1/n,n次都没有抽中的概率就是(1-1/n)n,所以被抽中的概率就是1减去n次都没有抽中的概率。
    在这里插入图片描述
    当n足够大时,这个概率收敛于1-(1/e),约等于0.632。因此,会有约37%的训练数据被浪费掉,没有参与建模, 这些数据被称为袋外数据(out of bag data,简写为oob)。除了最开始就划分好的测试集之外,这些数据也可以被用来作为集成算法的测试集。也就是说,在使用随机森林时,我们可以不划分测试集和训练集,只需要用袋外数据来测试我们的模型即可。当然,这也不是绝对的,当n和n_estimators都不够大的时候,很可能就没有数据掉落在袋外,自然也就无法使用oob数据来测试模型了。
    如果希望用袋外数据来测试,则需要在实例化时就将oob_score这个参数调整为True,训练完毕之后,我们可以用随机森林的另一个重要属性:oob_score_来查看我们的在袋外数据上测试的结果:

    #无需划分训练集和测试集
    rfc = RandomForestClassifier(n_estimators=25,oob_score=True)
    rfc = rfc.fit(wine.data,wine.target)
    #重要属性oob_score_
    rfc.oob_score_#使用oob评估获得的训练集得分
    
    0.9719101123595506
    

    重要属性和接口

    作为树模型的集成算法,随机森林自然也有**.feature_importances_**这个属性。
    随机森林的接口与决策树完全一致,因此依然有四个常用接口:apply, fit, predict和score。除此之外,还需要注意随机森林的predict_proba接口,这个接口返回每个测试样本对应的被分到每一类标签的概率,标签有几个分类就返回几个概率。如果是二分类问题,则predict_proba返回的数值大于0.5
    的,被分为1,小于0.5的,被分为0。传统的随机森林是利用袋装法中的规则,平均或少数服从多数来决定集成的结果,而sklearn中的随机森林是平均每个样本对应的predict_proba返回的概率,得到一个平均概率,从而决定测试样本的分类。

    #分别尝试以下属性和接口
    rfc = RandomForestClassifier(n_estimators=25)
    rfc = rfc.fit(Xtrain, Ytrain)
    rfc.score(Xtest,Ytest)
    
    0.9629629629629629
    
    rfc.feature_importances_
    
    array([0.17294472, 0.03080132, 0.0169717 , 0.00817673, 0.03415142,
           0.04871774, 0.14288035, 0.03357762, 0.02965377, 0.20877748,
           0.06008938, 0.08454388, 0.1287139 ])
    
    rfc.apply(Xtest)#返回叶节点索引值
    
    array([[19, 20, 15, ..., 15, 15,  8],
           [ 4,  3,  4, ...,  4,  2,  3],
           [10,  6,  7, ...,  9,  2,  1],
           ...,
           [19, 20, 17, ..., 16, 15,  8],
           [19, 20, 15, ..., 16, 15,  8],
           [ 8,  3,  4, ...,  5,  4,  3]], dtype=int64)
    
    rfc.predict(Xtest)
    
    array([0, 2, 1, 1, 2, 1, 1, 2, 1, 2, 2, 2, 2, 1, 2, 0, 1, 0, 0, 2, 0, 2,
           1, 0, 0, 1, 0, 0, 0, 0, 0, 2, 0, 1, 1, 0, 2, 0, 1, 0, 1, 0, 2, 1,
           1, 1, 0, 2, 2, 2, 1, 0, 0, 2])
    
    rfc.predict_proba(Xtest)
    
    array([[0.96, 0.04, 0.  ],
           [0.  , 0.28, 0.72],
           [0.  , 0.96, 0.04],
           [0.  , 1.  , 0.  ],
           ...
           [0.32, 0.64, 0.04],
           [0.88, 0.04, 0.08],
           [0.84, 0.12, 0.04],
           [0.  , 0.  , 1.  ]])
    

    Bagging的另一个必要条件

    使用袋装法时要求基评估器要尽量独立。其实,袋装法还有另一个必要条件:基分类器的判断准确率至少要超过随机分类器,就是说,基分类器的判断准确率至少要超过50%。基于随机森林的准确率公式画出基分类器的误差率ε和随机森林的误差率之间的图像如下:

    #基分类器的误差率ε和随机森林的误差率对比
    x = np.linspace(0,1,20)
    y = []
    for epsilon in np.linspace(0,1,20):
        E = np.array([comb(25,i)*(epsilon**i)*((1-epsilon)**(25-i))
            for i in range(13,26)]).sum()
        y.append(E)
    #绘制图形
    plt.plot(x,y,"o-",label="when estimators are different")
    plt.plot(x,x,"--",color="red",label="if all estimators are same")
    plt.xlabel("individual estimator's error")
    plt.ylabel("RandomForest's error")
    plt.legend()
    plt.show()
    

    在这里插入图片描述

    展开全文
  • 随机森林分类器(Random Forest)

    万次阅读 2019-06-19 12:59:06
    随机森林分类器(Random Forest) 阅读目录 1 什么是随机森林? 2 随机森林的特点 3 随机森林的相关基础知识 4 随机森林的生成 5 袋外错误率(oob error) 6 随机森林工作原理解释的一个简单例子 7 随机...

    随机森林分类器(Random Forest)

    阅读目录

    回到顶部

    1 什么是随机森林?

      作为新兴起的、高度灵活的一种机器学习算法,随机森林(Random Forest,简称RF)拥有广泛的应用前景,从市场营销到医疗保健保险,既可以用来做市场营销模拟的建模,统计客户来源,保留和流失,也可用来预测疾病的风险和病患者的易感性。最初,我是在参加校外竞赛时接触到随机森林算法的。最近几年的国内外大赛,包括2013年百度校园电影推荐系统大赛、2014年阿里巴巴天池大数据竞赛以及Kaggle数据科学竞赛,参赛者对随机森林的使用占有相当高的比例。此外,据我的个人了解来看,一大部分成功进入答辩的队伍也都选择了Random Forest 或者 GBDT 算法。所以可以看出,Random Forest在准确率方面还是相当有优势的。

      那说了这么多,那随机森林到底是怎样的一种算法呢?

      如果读者接触过决策树(Decision Tree)的话,那么会很容易理解什么是随机森林。随机森林就是通过集成学习的思想将多棵树集成的一种算法,它的基本单元是决策树,而它的本质属于机器学习的一大分支——集成学习(Ensemble Learning)方法。随机森林的名称中有两个关键词,一个是“随机”,一个就是“森林”。“森林”我们很好理解,一棵叫做树,那么成百上千棵就可以叫做森林了,这样的比喻还是很贴切的,其实这也是随机森林的主要思想--集成思想的体现。“随机”的含义我们会在下边部分讲到。

      其实从直观角度来解释,每棵决策树都是一个分类器(假设现在针对的是分类问题),那么对于一个输入样本,N棵树会有N个分类结果。而随机森林集成了所有的分类投票结果,将投票次数最多的类别指定为最终的输出,这就是一种最简单的 Bagging 思想。

    回到顶部

    2 随机森林的特点

      我们前边提到,随机森林是一种很灵活实用的方法,它有如下几个特点:

    • 在当前所有算法中,具有极好的准确率/It is unexcelled in accuracy among current algorithms;
    • 能够有效地运行在大数据集上/It runs efficiently on large data bases;
    • 能够处理具有高维特征的输入样本,而且不需要降维/It can handle thousands of input variables without variable deletion;
    • 能够评估各个特征在分类问题上的重要性/It gives estimates of what variables are important in the classification;
    • 在生成过程中,能够获取到内部生成误差的一种无偏估计/It generates an internal unbiased estimate of the generalization error as the forest building progresses;
    • 对于缺省值问题也能够获得很好得结果/It has an effective method for estimating missing data and maintains accuracy when a large proportion of the data are missing
    • ... ...

      实际上,随机森林的特点不只有这六点,它就相当于机器学习领域的Leatherman(多面手),你几乎可以把任何东西扔进去,它基本上都是可供使用的。在估计推断映射方面特别好用,以致都不需要像SVM那样做很多参数的调试。具体的随机森林介绍可以参见随机森林主页:Random Forest

    回到顶部

    3 随机森林的相关基础知识

      随机森林看起来是很好理解,但是要完全搞明白它的工作原理,需要很多机器学习方面相关的基础知识。在本文中,我们简单谈一下,而不逐一进行赘述,如果有同学不太了解相关的知识,可以参阅其他博友的一些相关博文或者文献。

      1)信息、熵以及信息增益的概念

      这三个基本概念是决策树的根本,是决策树利用特征来分类时,确定特征选取顺序的依据。理解了它们,决策树你也就了解了大概。

      引用香农的话来说,信息是用来消除随机不确定性的东西。当然这句话虽然经典,但是还是很难去搞明白这种东西到底是个什么样,可能在不同的地方来说,指的东西又不一样。对于机器学习中的决策树而言,如果带分类的事物集合可以划分为多个类别当中,则某个类(xi)的信息可以定义如下:

      I(x)用来表示随机变量的信息,p(xi)指是当xi发生时的概率。

      熵是用来度量不确定性的,当熵越大,X=xi的不确定性越大,反之越小。对于机器学习中的分类问题而言,熵越大即这个类别的不确定性更大,反之越小。

      信息增益在决策树算法中是用来选择特征的指标,信息增益越大,则这个特征的选择性越好。

      这方面的内容不再细述,感兴趣的同学可以看 信息&熵&信息增益 这篇博文。

      2)决策树

      决策树是一种树形结构,其中每个内部节点表示一个属性上的测试,每个分支代表一个测试输出,每个叶节点代表一种类别。常见的决策树算法有C4.5、ID3和CART。

      3)集成学习 

      集成学习通过建立几个模型组合的来解决单一预测问题。它的工作原理是生成多个分类器/模型,各自独立地学习和作出预测。这些预测最后结合成单预测,因此优于任何一个单分类的做出预测。

      随机森林是集成学习的一个子类,它依靠于决策树的投票选择来决定最后的分类结果。你可以在这找到用python实现集成学习的文档:Scikit 学习文档

    回到顶部

    4 随机森林的生成

      前面提到,随机森林中有许多的分类树。我们要将一个输入样本进行分类,我们需要将输入样本输入到每棵树中进行分类。打个形象的比喻:森林中召开会议,讨论某个动物到底是老鼠还是松鼠,每棵树都要独立地发表自己对这个问题的看法,也就是每棵树都要投票。该动物到底是老鼠还是松鼠,要依据投票情况来确定,获得票数最多的类别就是森林的分类结果。森林中的每棵树都是独立的,99.9%不相关的树做出的预测结果涵盖所有的情况,这些预测结果将会彼此抵消。少数优秀的树的预测结果将会超脱于芸芸“噪音”,做出一个好的预测。将若干个弱分类器的分类结果进行投票选择,从而组成一个强分类器,这就是随机森林bagging的思想(关于bagging的一个有必要提及的问题:bagging的代价是不用单棵决策树来做预测,具体哪个变量起到重要作用变得未知,所以bagging改进了预测准确率但损失了解释性。)。下图可以形象地描述这个情况:

     

      有了树我们就可以分类了,但是森林中的每棵树是怎么生成的呢?

      每棵树的按照如下规则生成:

      1)如果训练集大小为N,对于每棵树而言,随机且有放回地从训练集中的抽取N个训练样本(这种采样方式称为bootstrap sample方法),作为该树的训练集;

      从这里我们可以知道:每棵树的训练集都是不同的,而且里面包含重复的训练样本(理解这点很重要)。

      为什么要随机抽样训练集?(add @2016.05.28)

      如果不进行随机抽样,每棵树的训练集都一样,那么最终训练出的树分类结果也是完全一样的,这样的话完全没有bagging的必要;

      为什么要有放回地抽样?(add @2016.05.28)

      我理解的是这样的:如果不是有放回的抽样,那么每棵树的训练样本都是不同的,都是没有交集的,这样每棵树都是"有偏的",都是绝对"片面的"(当然这样说可能不对),也就是说每棵树训练出来都是有很大的差异的;而随机森林最后分类取决于多棵树(弱分类器)的投票表决,这种表决应该是"求同",因此使用完全不同的训练集来训练每棵树这样对最终分类结果是没有帮助的,这样无异于是"盲人摸象"。

      2)如果每个样本的特征维度为M,指定一个常数m<<M,随机地从M个特征中选取m个特征子集,每次树进行分裂时,从这m个特征中选择最优的;

      3)每棵树都尽最大程度的生长,并且没有剪枝过程。

      一开始我们提到的随机森林中的“随机”就是指的这里的两个随机性。两个随机性的引入对随机森林的分类性能至关重要。由于它们的引入,使得随机森林不容易陷入过拟合,并且具有很好得抗噪能力(比如:对缺省值不敏感)。

      随机森林分类效果(错误率)与两个因素有关:

    • 森林中任意两棵树的相关性:相关性越大,错误率越大;
    • 森林中每棵树的分类能力:每棵树的分类能力越强,整个森林的错误率越低。

      减小特征选择个数m,树的相关性和分类能力也会相应的降低;增大m,两者也会随之增大。所以关键问题是如何选择最优的m(或者是范围),这也是随机森林唯一的一个参数。

    回到顶部

    5 袋外错误率(oob error)

      上面我们提到,构建随机森林的关键问题就是如何选择最优的m,要解决这个问题主要依据计算袋外错误率oob error(out-of-bag error)。

      随机森林有一个重要的优点就是,没有必要对它进行交叉验证或者用一个独立的测试集来获得误差的一个无偏估计。它可以在内部进行评估,也就是说在生成的过程中就可以对误差建立一个无偏估计。

      我们知道,在构建每棵树时,我们对训练集使用了不同的bootstrap sample(随机且有放回地抽取)。所以对于每棵树而言(假设对于第k棵树),大约有1/3的训练实例没有参与第k棵树的生成,它们称为第k棵树的oob样本。

      而这样的采样特点就允许我们进行oob估计,它的计算方式如下:

      (note:以样本为单位)

      1)对每个样本,计算它作为oob样本的树对它的分类情况(约1/3的树);

      2)然后以简单多数投票作为该样本的分类结果;

      3)最后用误分个数占样本总数的比率作为随机森林的oob误分率。

      (文献原文:Put each case left out in the construction of the kth tree down the kth tree to get a classification. In this way, a test set classification is obtained for each case in about one-third of the trees. At the end of the run, take j to be the class that got most of the votes every time case n was oob. The proportion of times that j is not equal to the true class of n averaged over all cases is the oob error estimate. This has proven to be unbiased in many tests.)

      oob误分率是随机森林泛化误差的一个无偏估计,它的结果近似于需要大量计算的k折交叉验证。

    回到顶部

    6 随机森林工作原理解释的一个简单例子

      描述:根据已有的训练集已经生成了对应的随机森林,随机森林如何利用某一个人的年龄(Age)、性别(Gender)、教育情况(Highest Educational Qualification)、工作领域(Industry)以及住宅地(Residence)共5个字段来预测他的收入层次。

      收入层次 :

        Band 1 : Below $40,000

        Band 2: $40,000 – 150,000

        Band 3: More than $150,000

      随机森林中每一棵树都可以看做是一棵CART(分类回归树),这里假设森林中有5棵CART树,总特征个数N=5,我们取m=1(这里假设每个CART树对应一个不同的特征)。

      CART 1 : Variable Age

      rf1

      CART 2 : Variable Gender

      rf2

      CART 3 : Variable Education

      rf3

      CART 4 : Variable Residence

      rf4

      CART 5 : Variable Industry

      rf5

      我们要预测的某个人的信息如下:

      1. Age : 35 years ; 2. Gender : Male ; 3. Highest Educational Qualification : Diploma holder; 4. Industry : Manufacturing; 5. Residence : Metro.

      根据这五棵CART树的分类结果,我们可以针对这个人的信息建立收入层次的分布情况:

      DF

      最后,我们得出结论,这个人的收入层次70%是一等,大约24%为二等,6%为三等,所以最终认定该人属于一等收入层次(小于$40,000)。

    回到顶部

    7 随机森林的Python实现

      利用Python的两个模块,分别为pandas和scikit-learn来实现随机森林。

     

    复制代码

    复制代码

    from sklearn.datasets import load_iris
    from sklearn.ensemble import RandomForestClassifier
    import pandas as pd
    import numpy as np
    
    iris = load_iris()
    df = pd.DataFrame(iris.data, columns=iris.feature_names)
    df['is_train'] = np.random.uniform(0, 1, len(df)) <= .75
    df['species'] = pd.Factor(iris.target, iris.target_names)
    df.head()
    
    train, test = df[df['is_train']==True], df[df['is_train']==False]
    
    features = df.columns[:4]
    clf = RandomForestClassifier(n_jobs=2)
    y, _ = pd.factorize(train['species'])
    clf.fit(train[features], y)
    
    preds = iris.target_names[clf.predict(test[features])]
    pd.crosstab(test['species'], preds, rownames=['actual'], colnames=['preds'])

    复制代码

    复制代码

     

      分类结果:

      

      与其他机器学习分类算法进行对比:

    复制代码

    复制代码

    import numpy as np
    import matplotlib.pyplot as plt
    from matplotlib.colors import ListedColormap
    from sklearn.cross_validation import train_test_split
    from sklearn.preprocessing import StandardScaler
    from sklearn.datasets import make_moons, make_circles, make_classification
    from sklearn.neighbors import KNeighborsClassifier
    from sklearn.svm import SVC
    from sklearn.tree import DecisionTreeClassifier
    from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier
    from sklearn.naive_bayes import GaussianNB
    from sklearn.lda import LDA
    from sklearn.qda import QDA
    
    h = .02  # step size in the mesh
    
    names = ["Nearest Neighbors", "Linear SVM", "RBF SVM", "Decision Tree",
             "Random Forest", "AdaBoost", "Naive Bayes", "LDA", "QDA"]
    classifiers = [
        KNeighborsClassifier(3),
        SVC(kernel="linear", C=0.025),
        SVC(gamma=2, C=1),
        DecisionTreeClassifier(max_depth=5),
        RandomForestClassifier(max_depth=5, n_estimators=10, max_features=1),
        AdaBoostClassifier(),
        GaussianNB(),
        LDA(),
        QDA()]
    
    X, y = make_classification(n_features=2, n_redundant=0, n_informative=2,
                               random_state=1, n_clusters_per_class=1)
    rng = np.random.RandomState(2)
    X += 2 * rng.uniform(size=X.shape)
    linearly_separable = (X, y)
    
    datasets = [make_moons(noise=0.3, random_state=0),
                make_circles(noise=0.2, factor=0.5, random_state=1),
                linearly_separable
                ]
    
    figure = plt.figure(figsize=(27, 9))
    i = 1
    # iterate over datasets
    for ds in datasets:
        # preprocess dataset, split into training and test part
        X, y = ds
        X = StandardScaler().fit_transform(X)
        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=.4)
    
        x_min, x_max = X[:, 0].min() - .5, X[:, 0].max() + .5
        y_min, y_max = X[:, 1].min() - .5, X[:, 1].max() + .5
        xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
                             np.arange(y_min, y_max, h))
    
        # just plot the dataset first
        cm = plt.cm.RdBu
        cm_bright = ListedColormap(['#FF0000', '#0000FF'])
        ax = plt.subplot(len(datasets), len(classifiers) + 1, i)
        # Plot the training points
        ax.scatter(X_train[:, 0], X_train[:, 1], c=y_train, cmap=cm_bright)
        # and testing points
        ax.scatter(X_test[:, 0], X_test[:, 1], c=y_test, cmap=cm_bright, alpha=0.6)
        ax.set_xlim(xx.min(), xx.max())
        ax.set_ylim(yy.min(), yy.max())
        ax.set_xticks(())
        ax.set_yticks(())
        i += 1
    
        # iterate over classifiers
        for name, clf in zip(names, classifiers):
            ax = plt.subplot(len(datasets), len(classifiers) + 1, i)
            clf.fit(X_train, y_train)
            score = clf.score(X_test, y_test)
    
            # Plot the decision boundary. For that, we will assign a color to each
            # point in the mesh [x_min, m_max]x[y_min, y_max].
            if hasattr(clf, "decision_function"):
                Z = clf.decision_function(np.c_[xx.ravel(), yy.ravel()])
            else:
                Z = clf.predict_proba(np.c_[xx.ravel(), yy.ravel()])[:, 1]
    
            # Put the result into a color plot
            Z = Z.reshape(xx.shape)
            ax.contourf(xx, yy, Z, cmap=cm, alpha=.8)
    
            # Plot also the training points
            ax.scatter(X_train[:, 0], X_train[:, 1], c=y_train, cmap=cm_bright)
            # and testing points
            ax.scatter(X_test[:, 0], X_test[:, 1], c=y_test, cmap=cm_bright,
                       alpha=0.6)
    
            ax.set_xlim(xx.min(), xx.max())
            ax.set_ylim(yy.min(), yy.max())
            ax.set_xticks(())
            ax.set_yticks(())
            ax.set_title(name)
            ax.text(xx.max() - .3, yy.min() + .3, ('%.2f' % score).lstrip('0'),
                    size=15, horizontalalignment='right')
            i += 1
    
    figure.subplots_adjust(left=.02, right=.98)
    plt.show()

    复制代码

    复制代码

      这里随机生成了三个样本集,分割面近似为月形、圆形和线形的。我们可以重点对比一下决策树和随机森林对样本空间的分割:

      1)从准确率上可以看出,随机森林在这三个测试集上都要优于单棵决策树,90%>85%,82%>80%,95%=95%;

      2)从特征空间上直观地可以看出,随机森林比决策树拥有更强的分割能力(非线性拟合能力)。

      更多有关随机森林的代码:

      1)Fortran版本

      2)OpenCV版本

      3)Matlab版本

      4)R版本

    回到顶部

    8 参考内容

      [1] Random Forest's homepage (by Leo Breiman and Adele Cutler)

      [2] Introduction to Random forest - Simplified

      [3] Comparing a Random Forest to a CART model (Part 2)

      [4] Introduction to Random forest (博主:爱67)

      [5] Python实现随机森林

      [6] 随机森林之oob error估计

      [7] 随机森林

      [8] Wikipedia-Random Forest

      [9] Ensemble methods

            [10]http://www.cnblogs.com/maybe2030/p/4585705.html

    展开全文
  • 目前精度较高的方法主要是支持向量机分类和随机森林分类。所以废话不多说,直接上干货 1.打开envi,加载影像,主要以land sat8为例,直接打开以MTL为后缀的文件 如果打不开的话,就是头文件有问题,可以把各个波段的...
  • Python Sklearn库中的随机森林分类 RandomForestClassifier

    万次阅读 多人点赞 2018-08-08 21:38:51
    随机森林分类器。 scikit-learn v0.19.1 随机森林是一个元估计器,它适合数据集的各个子样本上的多个决策树分类器,并使用平均值来提高预测精度和控制过度拟合。 子样本大小始终与原始输入样本大小相同,但如果...
  • 分类算法-随机森林 (Classification Algorithms - Random Forest) Advertisements 广告 Previous Page 上一页 Next Page 下一页 介绍 (Introduction) Random forest is a supervised learning ...
  • 利用Python的Scikit-Learn库对遥感影像进行随机森林(RandomForest)分类 ...因此,本篇文章将为读者介绍利用Python及其扩展包Scikit-Learn对遥感影像进行随机森林分类的完整过程,包括:ShapeFile格式样本数据的读取、
  • 采用随机森林分类模型(RandomForestClassifier)再次训练上述鸢尾花数据集,具体要求如下: 1、使用pandas库再次读取数据集,得到相应矩阵,并进项相应的数据预处理:包括数据标准化与鸢尾花类别编码等。 2、采用...
  • 基于Spark的随机森林分类算法分析 一.随机森林算法原理 随机森林是由多个决策树构成的森林,算法分类结果由决策树的投票结果得到,其属于集成学习中的bagging方法。算法的主要原理如下: 1)假设为一棵决策树,...
  • 使用随机森林分类器预测空气污染级别根据每天的pm2.5数值分为优,良,轻度污染,中度污染等对这些级别进行预测实现过程: 数据清洗 – 按照pm范围划分污染等级 PipeLine组件 – labelIndexer – StringIndexer:...
  • 一文看懂随机森林
  • python3 学习使用随机森林分类器 梯度提升决策树分类 的api,并将他们和单一决策树预测结果做出对比 附上我的git,欢迎大家来参考我其他分类器的代码:https://github.com/linyi0604/MachineLearning 首先,了解...
  • https://code.earthengine.google.com/c099c198ff6120f34fcb2d34388f2cad?noload=true 随机森林分类的样本的多少和正确度对结果影响很大,应该尽量多选样本点。
  • pyhton_随机森林分析 from sklearn.ensemble import RandomForestClassifier from sklearn.datasets import make_moons ​ X, y = make_moons(n_samples=100, noise=0.25, random_state=3) X_train, X_test, y_...
  • sklearn 随机森林分类iris花

    千次阅读 2019-06-12 15:19:54
    #!/usr/bin/env python # coding: utf-8 # ### 导入随面森林的...from sklearn.ensemble import RandomForestClassifier # 导入随机森林的包 # from sklearn.model_selection import train_test_split # 这个用于...
  • 一种是利用相同的训练数据同时搭建多个独立的分裂模型,然后通过投票的方式,以少数服从多数的原则作出最终分类的决策,典型的有随机森林分类器(Random Forest Classifier),即在相同的训练数据上同时搭建多棵决策...
  • 随机森林分类器的实现

    千次阅读 2015-10-02 22:28:30
    参见博客Random Forest随机森林算法 决策树ID3Tree.h //#pragma once #ifndef ID3 #define ID3 #include #include using namespace std; #define Epsilon 0.000000001 class Record{ public: std::vector attri...
  • R语言随机森林分类

    千次阅读 2018-07-26 18:07:52
    https://blog.csdn.net/HHTNAN/article/details/54580747
  • 总样本是1440,按照70%和30%划分训练和测试集,训练集和测试集的样本数应该是1008和432。但是在随机森林分类的混淆矩阵中,它们的样本数为1007和433。请问为什么会有误差?这属于正常情况吗?
  • 本文紧接上文的决策树分类器模型,实践的同样是分类算法模型,随机森林模型可以简单理解为集成的决策树模型,实质上随机森林模型的设计思想也的确如此,它采用了一种投票的思想来完成了模型最终的决策,将多个弱分类...
  • 要用随机森林对其进行分类,其中最后一列视为标签,其余列视为特征 # coding = utf-8 import pandas as pd from sklearn.ensemble import RandomForestClassifier from IPython.display import Image from ...
  • 随机森林分类和回归python代码 详解

    万次阅读 热门讨论 2019-06-18 11:36:07
    文字部分: ... 数学的东西直接看代码。 ########################################################################## ...下面是给了数据集之后,训练随机森林的过程: 首先,咱们先来看一棵树的成长!确定好这棵...
  • 随机森林分类

    2014-02-23 10:55:11
    在github上搜索: random forest 随机森林工具箱: Random-Forest-Matlab Random Forest 实用经验
  • Scikit-Learn 随机森林分类器的使用

    万次阅读 2016-11-23 15:43:31
    随机森林(RandomForest), 指的是利用多棵树对样本进行训练并预测的一种分类器。该分类器最早由Leo Breiman和Adele Cutler提出,并被注册成了商标。简单来说,随机森林就是由多棵CART(Classification And ...
  • 上图: 附上代码:一个函数,传入三个参数 ........fit = model.fit(x_train, y_...y_score = model.fit(x_train, y_training).predict_proba(x_test) # 随机森林 fpr, tpr, thresholds = roc_curve(y_test, ...
  • 练习——随机森林分类毒、可食用蘑菇数据集

    千次阅读 多人点赞 2019-04-12 22:23:20
    对此,我们希望能找到那种能很好区分的特征,或者说区分度很大的特征,来避免危险,保证安全,所以我采用随机森林算法来实现目的。 毒蘑菇数据集是一个包含8123个样本的数据集,有22个特征,为菌盖颜色、菌盖形状、...
  • # warm_start = False, 当被设置为True时,重新使用之前呼叫的解决方案,用来给全体拟合和添加更多的估计器, # 反之,仅仅只是为了拟合一个全新的森林。 # class_weight = None clf = RandomForestClassifier(max_...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 37,824
精华内容 15,129
关键字:

随机森林分类