随机森林（random forest）

1.随机森林基本思想

Bagging+决策树作为base model + 每个决策树权重为1 + Boostrap有放回的采样

2.决策树采用投票的方式。

假如训练了5颗树，其中4颗树是True,1颗树是False

那么结果就是True

3.单颗决策树建立的过程

（1）随即在N个样本中选择一个样本，重复N次（样本有可能重复）。

（2）随机在M个特征中选出m（m<=M）个特征。

那么建立多颗决策树，样本，特征大多不一样。

随机森林要求每颗决策树的正确率一定要大于50%,如果正确率小于50%，那么随机森林整体正确率也会远远低于单颗决策树。所以使用随机森林之前一定要检查，用来组成随机森林的分类树是否都至少有50%的正确率，如果没有，那就不要使用随机森林。

sklearn中的应用

4.随机森林分类器参数介绍

（1）criterion:不纯度的衡量指标（不纯度越低代表分类效果越好）：gini,信息熵。

（2）max_depth：树的最大深度。

（3）min_samples_leaf=5:节点至少包含5个训练样本，如果少于5个，那么就不会再分支

（4）min_sample_split=5:节点必须包含5个样本，这个节点才被允许分支。

（5）max_features:限制分支时考虑的特征个数，超过限制个数都会被舍弃（有点类似于降维），默认值为总特征个数开平方取证。

（6）min_impurity_decrease:限制信息增益的大小，信息增益小于设置的数值，分支就不会发生。

注：随机森林的这些参数和决策树的参数一模一样

新的参数：

（1）n_estimators：使用决策树的个数，决策树的个数在增长到决策边界后，随机森林的准确率就不会增长。所以并不是决策树的数量越多越好。n_estimators的数量越大，消耗的时间和内存也越多。一般来说0-200之间是效果比较好的。

# 查看随机森林中每一棵树的属性参数
rfc.estimators_

（2）随机森林的random_state和决策树有区别，决策树是生成了一个随机数，随机森林是对每一棵树随机设置随机数，即每一棵树的随机数是不一样的。

（3）boostarp=True 开启有放回的随机抽样技术。

（3）oob_score:True    sklearn开启袋外数据验证,oob数据开启后，随机森林就不用切分训练集和测试集了。（当然随机森林可以用交叉验证也可以用袋外数据做验证）

# 查看袋外数据测试分数
rfc.oob_score_

# 返回每一个样本对应的每一类标签的概率
rfc.predict_proba(X_test)

[[0.925 0.07  0.005]
 [0.725 0.26  0.015]
 [0.    1.    0.   ]
 [0.27  0.59  0.14 ]
 [0.015 0.965 0.02 ]
 [0.98  0.01  0.01 ]
 [0.335 0.625 0.04 ]
 [0.005 0.055 0.94 ]
 [0.92  0.06  0.02 ]
 [0.    0.995 0.005]
 [0.02  0.085 0.895]
 [0.    0.    1.   ]
 [0.    0.995 0.005]
 [0.215 0.645 0.14 ]
 [0.01  0.13  0.86 ]
 [0.095 0.28  0.625]
 [0.    0.06  0.94 ]
 [0.06  0.25  0.69 ]
 [0.985 0.015 0.   ]
 [0.    0.995 0.005]
 [0.62  0.375 0.005]
 [0.99  0.01  0.   ]
 [1.    0.    0.   ]
 [0.91  0.08  0.01 ]
 [0.    0.01  0.99 ]
 [0.005 0.915 0.08 ]
 [0.04  0.15  0.81 ]
 [1.    0.    0.   ]
 [0.03  0.97  0.   ]
 [0.03  0.965 0.005]
 [0.    0.98  0.02 ]
 [0.01  0.98  0.01 ]
 [0.18  0.15  0.67 ]
 [0.94  0.03  0.03 ]
 [0.995 0.005 0.   ]
 [0.915 0.07  0.015]
 [0.    0.    1.   ]
 [0.995 0.005 0.   ]
 [0.    1.    0.   ]
 [0.015 0.94  0.045]
 [0.09  0.91  0.   ]
 [1.    0.    0.   ]
 [0.185 0.765 0.05 ]
 [0.085 0.235 0.68 ]
 [0.96  0.04  0.   ]]

 5.随机森林分类代码实现：

    from sklearn.ensemble import RandomForestClassifier    

    # 随机森林进行预测
    rf = RandomForestClassifier()

    # 网格搜索与交叉验证
    param = {"n_estimators": [120, 200, 300, 500, 800, 1200], "max_depth": [5, 8, 15, 25, 30]}
    gs = GridSearchCV(rf, param_grid=param, cv=5)
    gs.fit(X_train, y_train)
    gs.predict(X_test)
    print("准确率是:",gs.score(X_test, y_test))
    print("选择的参数模型：", gs.best_params_)

6.随机森林做回归

sklearn机会所有的参数都和随机森林做回归一样。

不同点:

criterion的参数，分类树用的gini系数，信息增益。回归树用mse均方误差。

随机森林做回归没有predict_proba接口。

代码：

    regress = RandomForestRegressor(n_estimators=100, random_state=0)
    print(cross_val_score(regress, X, y, cv=10, scoring="neg_mean_squared_error"))

    # 返回的这些数是mse,mse越小，代表这个模型拟合的越好。

    # [-0.0146 - 0.04884444 - 0.05197222 - 0.07756111 - 0.09371111 - 0.01176111
    #  - 0.0136 - 0.20569444 - 0.17169412 - 0.01501765]
    print(sklearn.metrics.SCORERS.keys())

7.随机森林用回归的方式填补缺失值

（1）某一列里面含有缺失值：

对于回归任务，特征和标签是可以相互转换的，例如地区，环境，附近学校来预测房价，

那么如果有一列特征有缺失值，那么我们可以将这一列特征转换成标签，而标签则转换成特征，

那么这样转换后的标签就有一部分为null，一部分是有值的。而特征都是有值的。

那么我们就可以将有值的特征和标签当作训练集，剩下有值的对应缺失值的特征作为测试集X，

而标签空值作为预测值。训练模型带入X_test,预测出来缺失值。

（2）所有列都有缺失值

对于所有的列都有缺失值，我们可以从缺失值最少的列开始，假设其他的缺失值都是0,那么我们可以回归填补这一列的值，而以同样的做法处理第二列，以此类推。

这样到处理最后一列时（也是缺失值最多的一列），那么前面的所有缺失值都已经填满。所以最后一列含缺失值最多的一列信息丢失也最少。

处理到最后数据就全部完整不在有缺失值了。

import numpy as np
import pandas as pd
from sklearn.datasets import load_boston
from sklearn.ensemble import RandomForestRegressor
from sklearn.impute import SimpleImputer
from sklearn.model_selection import train_test_split
from sklearn.model_selection import cross_val_score


def pre_data():
    boston = load_boston()
    X = boston.data
    y = boston.target

    # 确定一个随机种子
    rng = np.random.RandomState(10)

    # 给完整的数据添加一些缺失值，为了测试Imputer
    n_samples = X.shape[0]
    n_feature = X.shape[1]

    missing_rate = 0.5
    # np.floor()向下取整返回一个.0的浮点数，再用int取整数。
    n_miss_samples = int(np.floor(n_samples * n_feature * missing_rate))

    # 取所有随机的横坐标纵坐标
    missing_features = rng.randint(0, n_feature, n_miss_samples)
    missing_samples = rng.randint(0, n_samples, n_miss_samples)

    X_missing = X.copy()    # X_missing数据进行处理
    y_missing = y.copy()    # y_missing不进行处理

    X_missing[missing_samples, missing_features] = np.nan


    # 用sklearn自带的方法填充空值
    # sp = SimpleImputer(missing_values=np.nan, strategy="mean")
    # X = sp.fit_transform(X_missing)
    # print(pd.DataFrame(X).info())

    # 用随机森林做预测进行填充空值
    X_missing_reg = X_missing.copy()

    for i in range(13):
        X_missing_reg = pd.DataFrame(X_missing_reg)
        sortindex = np.argsort(X_missing_reg.isnull().sum(axis=0)).values

        # 将第四列变成目标值
        fillc = X_missing_reg.iloc[:, i]

        df = X_missing_reg
        # 将去掉第i列剩下的列和Y合并成一个df
        df = pd.concat([df.iloc[:, df.columns != i], pd.DataFrame(y_missing)], axis=1)

        # 填充0
        df_0 = SimpleImputer(missing_values=np.nan, strategy="constant", fill_value=0).fit_transform(df)

        Ytrain = fillc[fillc.notnull()]
        Ytest = fillc[fillc.isnull()]

        Xtest = df_0[Ytest.index, :]
        Xtrain = df_0[Ytrain.index, :]

        # 随机森林训练模型
        rfc = RandomForestRegressor(n_estimators=100)
        rfc.fit(Xtrain, Ytrain)
        # 随机森林预测出来剩下的标签值
        Ypredict = rfc.predict(Xtest)

        #print(X_missing_reg.iloc[:, 4].isnull())

        # 用loc传入内容返回对应的索引
        X_missing_reg.loc[X_missing_reg.iloc[:, i].isnull(), i] = Ypredict

    # # 查看有无缺失值
    # print(X_missing_reg.isnull().sum())
    return X_missing_reg, y


def Reg(data, target):
    # 建立模型
    Rfr = RandomForestRegressor(n_estimators=200,
                                criterion='mse',
                                max_depth=5)
    # 交叉验证
    print(cross_val_score(Rfr, data, target, scoring="neg_mean_squared_error", cv=10).mean())



if __name__ == "__main__":
    X, y = pre_data()
    Reg(X, y)

5.随机森林的优点：

（1）具有良好的准确率。

（2）得益于bagging,能够并行训练，能够运行在大数据集上面。

（3）能够处理高纬度特征输入样本，而且不需要降维。

（4）能够评估各个特征在分类问题上的重要性。