精华内容
下载资源
问答
  • RF_regressor 使用sklearn随机森林回归器的预测模型
  • 使用随机森林的汽车价格预测:该项目使用随机森林回归器作为监督的机器学习技术来预测汽车价格
  • sklearn随机森林回归器类的格式 sklearn.ensemble.RandomForestRegressor (n_estimators=’warn’, criterion=’mse’, max_depth=None, min_samples_split=2, min_samples_leaf=1, min_weight_fraction_leaf=0.0, ...

    sklearn随机森林回归器类的格式

    sklearn.ensemble.RandomForestRegressor (n_estimators=’warn’, criterion=’mse’, 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)
    所有的参数,属性与接口,全部和随机森林分类器一致。仅有的不同就是回归树与分类树的不同,不纯度的指标,参数Criterion不一致

    重要参数,属性与接口

    criterion
    回归树衡量分枝质量的指标,支持的标准有三种:
    1)输入"mse"使用均方误差mean squared error(MSE),父节点和叶子节点之间的均方误差的差额将被用来作为特征选择的标准,这种方法通过使用叶子节点的均值来最小化L2损失;
    2)输入“friedman_mse”使用费尔德曼均方误差,这种指标使用弗里德曼针对潜在分枝中的问题改进后的均方误差;
    3)输入"mae"使用绝对平均误差MAE(mean absolute error),这种指标使用叶节点的中值来最小化L1损失
    在这里插入图片描述
    其中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平方就会为负),而均方误差永远为正。
    值得一提的是,虽然均方误差永远为正,但是sklearn当中使用均方误差作为评判标准时,却是计算”负均方误差“(neg_mean_squared_error)。这是因为sklearn在计算模型评估指标的时候,会考虑指标本身的性质,均方误差本身是一种误差,所以被sklearn划分为模型的一种损失(loss),因此在
    sklearn当中,都以负数表示。真正的均方误差MSE的数值,其实就是neg_mean_squared_error去掉负号的数字。

    重要属性和接口

    最重要的属性和接口,都与随机森林的分类器相一致,还是apply, fit,predict和score最为核心。值得一提的是,随机森林回归并没有predict_proba这个接口,因为对于回归来说,并不存在一个样本要被分到某个类别的概率问题,因此没有predict_proba这个接口。

    随机森林回归用法

    和决策树完全一致,除了多了参数n_estimators

    from sklearn.datasets import load_boston
    from sklearn.model_selection import cross_val_score
    from sklearn.ensemble import RandomForestRegressor
    boston = load_boston()
    regressor = RandomForestRegressor(n_estimators=100,random_state=0)
    cross_val_score(regressor, boston.data, boston.target, cv=10
    				,scoring = "neg_mean_squared_error")
    
    array([-10.72900447,  -5.36049859,  -4.74614178, -20.84946337,
           -12.23497347, -17.99274635,  -6.8952756 , -93.78884428,
           -29.80411702, -15.25776814])
    
    #查看所有可以用的评估指标
    import sklearn#必须先导入sklearn,否则会报错
    sorted(sklearn.metrics.SCORERS.keys())
    
    ['accuracy',
     'adjusted_mutual_info_score',
     'adjusted_rand_score',
     'average_precision',
     'balanced_accuracy',
     'brier_score_loss',
     'completeness_score',
     'explained_variance',
     'f1',
     'f1_macro',
     'f1_micro',
     'f1_samples',
     'f1_weighted',
     'fowlkes_mallows_score',
     'homogeneity_score',
     'mutual_info_score',
     'neg_log_loss',
     'neg_mean_absolute_error',
     'neg_mean_squared_error',
     'neg_mean_squared_log_error',
     'neg_median_absolute_error',
     'normalized_mutual_info_score',
     'precision',
     'precision_macro',
     'precision_micro',
     'precision_samples',
     'precision_weighted',
     'r2',
     'recall',
     'recall_macro',
     'recall_micro',
     'recall_samples',
     'recall_weighted',
     'roc_auc',
     'v_measure_score']
    

    返回十次交叉验证的结果,注意在这里,如果不填写scoring = “neg_mean_squared_error”,交叉验证默认的模型衡量指标是R平方,因此交叉验证的结果可能有正也可能有负。而如果写上scoring,则衡量标准是负MSE,交叉验证的结果只可能为负。

    用随机森林回归填补缺失值

    从现实中收集的数据,几乎不可能是完美无缺的,往往都会有一些缺失值。面对缺失值,很多人选择的方式是直接将含有缺失值的样本删除,这是一种有效的方法,但是有时候填补缺失值会比直接丢弃样本效果更好,即便不知道缺失值的真实样貌。在sklearn中,可以使用sklearn.impute.SimpleImputer来轻松地将均值,中值,或者其他最常用的数值填补到数据中。
    在下面这个案例中,将使用均值,0,和随机森林回归来填补缺失值,并验证在这几种状况下的拟合状况,找出对使用的数据集来说最佳的缺失值填补方法。

    import numpy as np
    import pandas as pd
    import matplotlib.pyplot as plt
    from sklearn.datasets import load_boston
    from sklearn.impute import SimpleImputer
    from sklearn.ensemble import RandomForestRegressor
    from sklearn.model_selection import cross_val_score
    
    #以波士顿数据集为例,导入完整的数据集并探索
    dataset = load_boston()
    dataset.data.shape
    #总共506*13=6578个数据
    
    (506, 13)
    
    X_full, y_full = dataset.data, dataset.target
    n_samples = X_full.shape[0]
    n_features = X_full.shape[1]
    

    为完整数据集放入缺失值:首先确定我们希望放入的缺失数据的比例,在这里我们假设是50%,那总共就要有3289个数据缺失。

    #np.random.RandomState(0)伪随机数生成器,随机种子为0
    rng = np.random.RandomState(0)    
    missing_rate = 0.5
    n_missing_samples = int(np.floor(n_samples * n_features * missing_rate))
    #np.floor向下取整,返回.0格式的浮点数
    

    所有数据要随机遍布在数据集的各行各列当中,而一个缺失的数据会需要一个行索引和一个列索引。如果能创造一个数组,包含3289个分布在0-506中的行索引和3289个分布在0-13中的列索引,就可以利用索引来为数据中的任意3289个位置赋空值,然后用0、均值和随机森林来填写这些缺失值,然后查看回归的结果如何:

    missing_features = rng.randint(0,n_features,n_missing_samples)
    missing_samples = rng.randint(0,n_samples,n_missing_samples)    
    

    #missing_samples = rng.choice(dataset.data.shape[0],n_missing_samples,replace=False)
    现在采样了3289个数据,远远超过样本量506,所以使用随机抽取的函数randint。但如果需要的数据量小于样本量506,可以用np.random.choice,choice会随机抽取不重复的随机数,可以让数据更加分散,确保数据不会集中在一些行中。

    #创建含缺失值的数据集X_missing和y_missing
    X_missing = X_full.copy()
    y_missing = y_full.copy()
    #创建缺失值-按缺失值位置赋值np.nan
    X_missing[missing_samples,missing_features] = np.nan
    '''转换成DataFrame是为了后续方便各种操作,
    numpy对矩阵的运算速度快到拯救人生,
    但是在索引等功能上却不如pandas来得好用'''
    X_missing = pd.DataFrame(X_missing) 
    
    #使用均值进行填补
    from sklearn.impute import SimpleImputer
    #SimpleImputer()缺失值填补函数
    imp_mean = SimpleImputer(missing_values=np.nan, strategy='mean')
    X_missing_mean = imp_mean.fit_transform(X_missing)
    #使用0进行填补
    imp_0 = SimpleImputer(missing_values=np.nan, strategy="constant",fill_value=0)
    X_missing_0 = imp_0.fit_transform(X_missing)
    

    使用随机森林填补缺失值:
    任何回归都是从特征矩阵中学习,然后求解连续型标签y的过程,之所以能够实现这个过程,是因为回归算法认为,特征矩阵和标签之前存在着某种联系。实际上,标签和特征是可以相互转换的,比如说,在一个“用地
    区,环境,附近学校数量”预测“房价”的问题中,我们既可以用“地区”,“环境”,“附近学校数量”的数据来预测“房价”,也可以反过来,用“环境”,“附近学校数量”和“房价”来预测“地区”。而回归填补缺失值,正是利用了这种思想。
    对于一个有n个特征的数据来说,其中特征T有缺失值,就把特征T当作标签,其他的n-1个特征和原本的标签组成新的特征矩阵。T没有缺失的部分,就是Y_train,这部分数据既有标签也有特征,而它缺失的部分,只有特征没有标签,就是需要预测的部分。
    即:
    X_train:特征T不缺失的值对应的其他n-1个特征 + 本来的标签;
    Y_train:特征T不缺失的值;
    X_test:特征T缺失的值对应的其他n-1个特征 + 本来的标签;
    Y_test:特征T缺失的,需要预测的未知值。
    这种做法,对于某一个特征大量缺失,其他特征却很完整的情况,非常适用。
    如果数据中除了特征T之外,其他特征也有缺失值怎么办?
    答案是:遍历所有的特征,从缺失最少的开始进行填补(因为填补缺失最少的特征所需要的准确信息最少)。
    填补一个特征时,先将其他特征的缺失值用0代替
    ,每完成一次回归预测,就将预测值放到原本的特征矩阵中,再继续填补下一个特征。每一次填补完毕,有缺失值的特征会减少一个,所以每次循环后,需要用0来填补的特征就越来越少。当进行到最后一个特征时(这个特征应该是所有特征中缺失值最多的),已经没有任何的其他特征需要用0来进行填补了,而我们已经使用回归为其他特征填补了大量有效信息,可以用来填补缺失最多的特征。
    遍历所有的特征后,数据就完整,不再有缺失值了。

    #用随机森林预测填补缺失值
    X_missing_reg = X_missing.copy()
    #特征缺失值累计,按索引升序排序
    sortindex = np.argsort(X_missing_reg.isnull().sum(axis=0)).values
    #循环,按缺失值累计升序,依次填补不同特征的缺失值
    for i in sortindex:
        #构建我们的新特征矩阵和新标签
        #含缺失值的总数据集
        df = X_missing_reg 
        #要填充特征作为新标签列
        fillc = df.iloc[:,i] 
        #新的特征矩阵=其余特征列+原来的标签列Y
        df = pd.concat([df.iloc[:,df.columns != i],pd.DataFrame(y_full)],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()]
        Xtrain = df_0[Ytrain.index,:]
        Xtest = df_0[Ytest.index,:]
        #用随机森林回归预测缺失值
        rfc = RandomForestRegressor(n_estimators=100)
        rfc = rfc.fit(Xtrain, Ytrain)
        Ypredict = rfc.predict(Xtest)
        #填入预测值
        X_missing_reg.loc[X_missing_reg.iloc[:,i].isnull(),i] = Ypredict
    
    #对填补好的数据依次用随机森林回归建模,取得MSE结果
    X = [X_full,X_missing_mean,X_missing_0,X_missing_reg]
    mse = []
    std = []
    for x in X:
        estimator = RandomForestRegressor(random_state=0, n_estimators=100)
        scores = cross_val_score(estimator,x,y_full,scoring='neg_mean_squared_error',
                                    cv=5).mean()
        mse.append(scores * -1)
    
    #画条形图
    x_labels = ['Full data',
                'Mean Imputation',
                'Zero Imputation',
                'Regressor Imputation']
    colors = ['r', 'g', 'b', 'orange']
    plt.figure(figsize=(12, 6))
    ax = plt.subplot(111)
    for i in np.arange(len(mse)):
        ax.barh(i, mse[i],color=colors[i], alpha=0.6, align='center')
    ax.set_title('Imputation Techniques with Boston Data')
    ax.set_xlim(left=np.min(mse) * 0.9,
                right=np.max(mse) * 1.1)
    ax.set_yticks(np.arange(len(mse)))
    ax.set_xlabel('MSE')
    ax.set_yticklabels(x_labels)
    plt.show()
    

    在这里插入图片描述
    可见,用均值、0、随机森林回归来填补缺失值,随机森林预测的拟合效果最好。

    展开全文
  • 文章目录随机森林回归器 RandomForestRegressor① 重要参数、属性及接口② 简单使用 ---- 波士顿房价随机森林回归验证补充 --- 查看所有模型评估(打分)的列表 随机森林回归器 RandomForestRegressor class sklearn....


    随机森林回归器 RandomForestRegressor

    class sklearn.ensemble.RandomForestRegressor(n_estimators=100, *, criterion='mse', 
    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, ccp_alpha=0.0, max_samples=None)
    

    几乎所有的参数,属性及接口都和随机森林分类器一模一样。仅有的不同就是回归树与分类树的不同,以及不纯度的指标,参数criterion不一致。


    ① 重要参数、属性及接口

    criterion

    • 回归树衡量分枝质量的指标,支持的标准有三种:

      • 1)输入"mse"使用均方误差mean squared error(MSE),父节点和叶子节点之间的均方误差的差额将被用来作为特征选择的标准,这种方法通过使用叶子节点的均值来最小化L2损失
        在这里插入图片描述
        其中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平方就会为负),而均方误差永远为正。
        ★ 值得一提的是,虽然均方误差永远为正但是 sklearn当中使用均方误差作为评判标准时,却是计算负均方误差“(neg mean_squared_error)这是因为 sklearn在计算模型评估指标的时候,会考虑指标本身的性质,均方误差本身是一种误差,所以被 sklearn划分为模型的一种损失(loss)因此在sklearn当中,都以负数表示。真正的均方误差MSE的数值,其实就是 neg meansquared_error去掉负号的数字。

      • 2)输入"friedman mse"使用费尔德曼均方误差,这种指标使用弗里德曼针对潜在分枝中的问题改进后的均方误差

      • 3)输入"mae"使用绝对平均误差mae(mean absolute error),这种指标使用叶节点的中值来最小化L1损失

    • 属性中最重要的依然是 feature_importances_,接口依然是 apply、fit 、predict、 score最核心。

    返回顶部


    ② 简单使用 ---- 波士顿房价随机森林回归验证

    from matplotlib import pyplot as plt
    from sklearn.datasets import load_boston
    from sklearn.model_selection import cross_val_score
    from sklearn.ensemble import RandomForestRegressor
    
    #  获取数据集
    boston = load_boston()
    x = boston.data
    y = boston.target
    
    # 建模
    regressor = RandomForestRegressor(n_estimators=100,random_state=0)
    # 交叉验证
    cross_score = cross_val_score(regressor,x,y,cv=10,scoring="neg_mean_squared_error")
    cross_score
    
    array([-10.72900447,  -5.36049859,  -4.74614178, -20.84946337,
           -12.23497347, -17.99274635,  -6.8952756 , -93.78884428,
           -29.80411702, -15.25776814])
    

    补充 — 查看所有模型评估(打分)的列表

    import sklearn
    sorted(sklearn.metrics.SCORERS.keys())
    

    在这里插入图片描述

    返回顶部


    展开全文
  • python随机森林回归数据实战

    千次阅读 2020-11-12 11:51:53
    文章目录前言一、随机森林回归器参数介绍二、数据实战1.数据介绍2.重点代码2.1特征集和标签集获取2.2数据集划分2.3随机森林模型训练2.4预测结果可视化2.5 特征重要性选择及可视化3.完整代码总结 前言 我为什么写这...


    前言

    我为什么写这篇博客?
    答:记录一下自己对于sklearn库的学习过程以及学习方法,方便以后进行复用

    这篇文章主要讲什么?
    这篇文章是我使用sklearn的随机森林对我这个你在研究的数据进行处理分析的一个过程,其中包括对应的一些方法,具体见目录。

    随机森林简介?
    随机森林是一种统计学习理论,其随机有两个方面:首先在训练的每一轮中,都是对原始样本集有放回的抽取固定数目的样本点,形成k 个互不相同的样本集。第二个点是:对于每一个决策树的建立是从总的属性中随机抽取一定量的属性作为分裂属性集,这样对于k个树分类器均是不相同的。由随机生成的k个决策树组成了随机森林。
    对于每一个决策树来说,其分裂属性是不断地选取具有最大信息增益的属性进行排列。整个随机森林建立后,最终的分类标准采用投票机制得到可能性最高的结果。


    一、随机森林回归器参数介绍

    sklearn.ensemble.RandomForestRegressor (
    n_estimators=’warn’,	# 迭代次数,即森林中决策树的数量
    criterion=’mse’, 	# 分裂节点所用的标准,可选“gini”, “entropy”,默认“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,	# 最大叶子节点数,整数,默认为None
    min_impurity_decrease=0.0,  # 如果分裂指标的减少量大于该值,则进行分裂。
    min_impurity_split=None, 	# 决策树生长的最小纯净度。不推荐使用
    bootstrap=True, 	# 是否有放回的随机选取样本
    oob_score=False, 	# 是否采用袋外样本来评估模型的好坏。建议True
    n_jobs=None,	# 并行计算数。默认是None。一般选择-1,根据计算机核数自动选择
    random_state=None,	# 控制bootstrap的随机性以及选择样本的随机性。一般数字是一样的,便于调参
    verbose=0, 		# 在拟合和预测时控制详细程度。默认是0。
    warm_start=False	# 若设为True则可以再次使用训练好的模型并向其中添加更多的基学习器
    )
    

    所有的参数,属性与接口,全部和随机森林分类器一致。仅有的不同就是回归树与分类树的不同,不纯度的指标,参数Criterion不一致。

    RF框架特征

    1. n_estimators: 也就是弱学习器的最大迭代次数,或者说最大的弱学习器的个数。一般来说n_estimators太小,容易欠拟合,n_estimators太大,计算量会太大,并且n_estimators到一定的数量后,再增大n_estimators获得的模型提升会很小,所以一般选择一个适中的数值。默认是100。

    2. oob_score即是否采用袋外样本来评估模型的好坏。默认识False。个人推荐设置为True,因为袋外分数反应了一个模型拟合后的泛化能力。

    3. criterion: 即CART树做划分时对特征的评价标准。分类模型和回归模型的损失函数是不一样的。分类RF对应的CART分类树默认是基尼系数gini,另一个可选择的标准是信息增益。回归RF对应的CART回归树默认是均方差mse,另一个可以选择的标准是绝对值差mae。一般来说选择默认的标准就已经很好的。

    RF决策树参数

    1. RF划分时考虑的最大特征数max_features: 可以使用很多种类型的值,默认是"auto",意味着划分时最多考虑N\sqrt{N}个特征;如果是"log2"意味着划分时最多考虑log2Nlog_2N个特征;如果是"sqrt"或者"auto"意味着划分时最多考虑N\sqrt{N}个特征。如果是整数,代表考虑的特征绝对数。如果是浮点数,代表考虑特征百分比,即考虑(百分比xN)取整后的特征数。其中N为样本总特征数。一般我们用默认的"auto"就可以了,如果特征数非常多,我们可以灵活使用刚才描述的其他取值来控制划分时考虑的最大特征数,以控制决策树的生成时间。

    2. 决策树最大深度max_depth: 默认可以不输入,如果不输入的话,决策树在建立子树的时候不会限制子树的深度。一般来说,数据少或者特征少的时候可以不管这个值。如果模型样本量多,特征也多的情况下,推荐限制这个最大深度,具体的取值取决于数据的分布。常用的可以取值10-100之间。

    3. 内部节点再划分所需最小样本数min_samples_split: 这个值限制了子树继续划分的条件,如果某节点的样本数少于min_samples_split,则不会继续再尝试选择最优特征来进行划分。 默认是2.如果样本量不大,不需要管这个值。如果样本量数量级非常大,则推荐增大这个值。

    4. 叶子节点最少样本数min_samples_leaf: 这个值限制了叶子节点最少的样本数,如果某叶子节点数目小于样本数,则会和兄弟节点一起被剪枝。 默认是1,可以输入最少的样本数的整数,或者最少样本数占样本总数的百分比。如果样本量不大,不需要管这个值。如果样本量数量级非常大,则推荐增大这个值。

    5. 叶子节点最小的样本权重和min_weight_fraction_leaf:这个值限制了叶子节点所有样本权重和的最小值,如果小于这个值,则会和兄弟节点一起被剪枝。 默认是0,就是不考虑权重问题。一般来说,如果我们有较多样本有缺失值,或者分类树样本的分布类别偏差很大,就会引入样本权重,这时我们就要注意这个值了。

    6. 最大叶子节点数max_leaf_nodes: 通过限制最大叶子节点数,可以防止过拟合,默认是"None”,即不限制最大的叶子节点数。如果加了限制,算法会建立在最大叶子节点数内最优的决策树。如果特征不多,可以不考虑这个值,但是如果特征分成多的话,可以加以限制,具体的值可以通过交叉验证得到。

    7. 节点划分最小不纯度min_impurity_split: 这个值限制了决策树的增长,如果某节点的不纯度(基于基尼系数,均方差)小于这个阈值,则该节点不再生成子节点。即为叶子节点 。一般不推荐改动默认值1e-7。

    8. random——state:这里的random_state就是为了保证程序每次运行都分割一样的训练集和测试集。否则,同样的算法模型在不同的训练集和测试集上的效果不一样。

    上面决策树参数中最重要的包括最大特征数max_features, 最大深度max_depth, 内部节点再划分所需最小样本数min_samples_split和叶子节点最少样本数min_samples_leaf。

    调参链接参考

    二、数据实战

    1.数据介绍

    本数据使用的是经过处理出租车轨迹数据,共有15万条数据。

    特征:

    1. ‘最短行驶路程’
    2. ‘OD_speed’
    3. ‘OD_speedcv’
    4. ‘备选路径数’
    5. ‘OD_distancecv’
    6. ‘crossroadcv’
    7. ’mean_crossroad‘
    8. ‘speed’
    9. ‘speedcv’

    标签:
    RG:RelativeGap

    2.重点代码

    2.1特征集和标签集获取

    df = pd.read_csv(r'traval_merge_rp_od20_dis4000CV_cro_road.txt',sep='\t',encoding='gbk')
    df = df.dropna(axis=0, how='any') # 将缺失值的行丢弃
    col = ['最短行驶路程','OD_speed','OD_speedcv','备选路径数','OD_distancecv','crossroadcv','speed','speedcv','mean_crossroad']
    
    #取得特征
    X = df[col].values
    #取得标签
    Y = df.loc[:,'RG'].values
    

    2.2数据集划分

    #进行数据集划分,70%作为训练, 30作为测试
    x_train,x_test,y_train,y_test = train_test_split(X, Y, test_size=0.3)
    

    2.3随机森林模型训练

    #利用随机森林进行训练
    forest = RandomForestRegressor(
        n_estimators=1000,
        random_state=1,
        n_jobs=-1)
    forest.fit(x_train,y_train)
    

    2.4预测结果可视化

    #
    score = forest.score(x_test, y_test)
    result = forest.predict(x_test)
    plt.figure()
    #只取前一百条可视化,因为数据太多了
    plt.plot(np.arange(100), y_test[:100], "go-", label="True value")
    plt.plot(np.arange(100), result[:100], "ro-", label="Predict value")
    plt.title(f"RandomForest---score:{score}")
    plt.legend(loc="best")
    plt.show()
    

    可视化结果(score是R方)
    横坐标代表个数,纵坐标表示标签的值

    2.5 特征重要性选择及可视化

    # 下面对训练好的随机森林,完成重要性评估
    # feature_importances_  可以调取关于特征重要程度
    importances = forest.feature_importances_
    print("重要性:", importances)
    x_columns = ['OD_distance','OD_speed','OD_speedcv','route_num','OD_distancecv','crossroadcv','speed','speedcv','mean_crossroad']
    #返回数组从大到小的索引值
    indices = np.argsort(importances)[::-1]
    for f in range(x_train.shape[1]):
        # 对于最后需要逆序排序,我认为是做了类似决策树回溯的取值,从叶子收敛
        # 到根,根部重要程度高于叶子。
        print("%2d) %-*s %f" % (f + 1, 30, col[indices[f]], importances[indices[f]]))
    
    # 筛选变量(选择重要性比较高的变量)
    threshold = 0.15
    x_selected = x_train[:, importances > threshold]
    
    # 可视化
    
    plt.figure(figsize=(10, 6))
    plt.title("importance of  feature  in dateset", fontsize=18)
    plt.ylabel("import level", fontsize=15, rotation=90)
    
    x_columns1 = [x_columns[i] for i in indices]
    for i in range(len(x_columns)):
        plt.bar(i, importances[indices[i]], color='orange', align='center')
        plt.xticks(np.arange(len(x_columns)), x_columns1, fontsize=10, rotation =30)
    plt.show()
    

    结果
    在这里插入图片描述
    在这里插入图片描述

    3.完整代码

    #判断是否有空值
    def jud_array(x):
        print(np.isnan(x).any())
    
    #traval_merge_rp_od20_dis4000CV_cro_road.txt
    df = pd.read_csv(r'traval_merge_rp_od20_dis4000CV_cro_road.txt',sep='\t',encoding='gbk')
    df = df.dropna(axis=0, how='any')
    col = ['最短行驶路程','OD_speed','OD_speedcv','备选路径数','OD_distancecv','crossroadcv','speed','speedcv','mean_crossroad']
    X = df[col]
    
    
    
    #取得特征
    X = df[col].values
    #取得标签
    Y = df.loc[:,'RG'].values
    
    
    #进行数据集划分
    x_train,x_test,y_train,y_test = train_test_split(X, Y, test_size=0.3)
    
    #利用随机森林进行训练
    forest = RandomForestRegressor(
        n_estimators=100,
        random_state=1,
        n_jobs=-1)
    forest.fit(x_train,y_train)
    
    #预测结果可视化
    score = forest.score(x_test, y_test)
    result = forest.predict(x_test)
    plt.figure()
    plt.plot(np.arange(100), y_test[:100], "go-", label="True value")
    plt.plot(np.arange(100), result[:100], "ro-", label="Predict value")
    plt.title(f"RandomForest---score:{score}")
    plt.legend(loc="best")
    plt.show()
    
    # 分数
    y_pred = forest.predict(x_test)
    
    # 下面对训练好的随机森林,完成重要性评估
    # feature_importances_  可以调取关于特征重要程度
    importances = forest.feature_importances_
    print("重要性:", importances)
    x_columns = ['OD_distance','OD_speed','OD_speedcv','route_num','OD_distancecv','crossroadcv','speed','speedcv','mean_crossroad']
    # 返回数组从大到小的索引值
    indices = np.argsort(importances)[::-1]
    for f in range(x_train.shape[1]):
        # 对于最后需要逆序排序,我认为是做了类似决策树回溯的取值,从叶子收敛
        # 到根,根部重要程度高于叶子。
        print("%2d) %-*s %f" % (f + 1, 30, col[indices[f]], importances[indices[f]]))
    
    # 筛选变量(选择重要性比较高的变量)
    threshold = 0.15
    x_selected = x_train[:, importances > threshold]
    
    # 可视化
    
    plt.figure(figsize=(10, 6))
    plt.title("importance of  feature  in dateset", fontsize=18)
    plt.ylabel("import level", fontsize=15, rotation=90)
    
    x_columns1 = [x_columns[i] for i in indices]
    for i in range(len(x_columns)):
        plt.bar(i, importances[indices[i]], color='orange', align='center')
        plt.xticks(np.arange(len(x_columns)), x_columns1, fontsize=10, rotation=30)
    plt.show()
    
    

    总结

    目前这个博客还不够完善,后续我会继续添加缺失值处理以及调参过程。

    展开全文
  • from sklearn.ensemble import RandomForestRegressor # 随机森林回归器 from sklearn.impute import SimpleImputer # 用来填补缺失值的 import numpy as np import pandas as pd import matplotlib....
    from pprint import pprint
    
    from sklearn.ensemble import RandomForestRegressor  # 随机森林回归器
    from sklearn.impute import SimpleImputer  # 用来填补缺失值的
    import numpy as np
    import pandas as pd
    import matplotlib.pyplot as plt
    from sklearn.model_selection import cross_val_score
    from sklearn.datasets import load_boston
    
    pd.set_option('display.max_columns', None)
    # 以波士顿数据集为例,导入完整的数据集并探索
    dataset = load_boston()
    # print(dataset.data.shape)  # (506, 13)
    x_full, y_full = dataset.data, dataset.target
    
    # todo: 首先把完美的数据改成含缺失值的
    n_sample = x_full.shape[0]  # 获取样本数量  行  506
    n_feature = x_full.shape[1]  # 获取标签数量  列 13
    # 我们希望的缺失数据的比例,假设为50%,共有506*13*0.5个数据缺失
    rng = np.random.RandomState(0)  # 确认一个随机数种子
    missing_rate = 0.5
    # np.floor 向下取整 返回.0的浮点数
    n_missing_samples = int(np.floor(n_sample * n_feature * missing_rate))  # 数据总量/2个
    # print(n_missing_samples)
    missing_features = rng.randint(0, n_feature, n_missing_samples)  # 取出 0到nfeature范围内的n_missing_samples个随机数
    missing_samples = rng.randint(0, n_sample, n_missing_samples)
    # 也可以抽样来完成
    # missing_samples = rng.choice(dataset.data.shape[0], n_missing_samples, replace=False)
    # 复制一份完整的数据集,原数据不动
    X_missing = x_full.copy()
    Y_missing = y_full.copy()
    #  让它遍布空值
    X_missing[missing_samples, missing_features] = np.nan
    X_missing = pd.DataFrame(X_missing)
    
    # todo: 使用均值进行补缺
    imp_mean = SimpleImputer(missing_values=np.nan, strategy="mean")  # 要补啥,用啥补
    # 训练加导出 fit+predict -----》特殊的接口 fit_transform
    X_missing_mean = imp_mean.fit_transform(X_missing)
    # print(pd.DataFrame(X_missing_mean).isnull().sum())
    # todo: 使用0进行补缺
    imp_mean0 = SimpleImputer(missing_values=np.nan, strategy="constant", fill_value=0)  # 要补啥,用啥补
    # 训练加导出 fit+predict -----》特殊的接口 fit_transform
    X_missing_0 = imp_mean0.fit_transform(X_missing)
    # print(pd.DataFrame(X_missing_mean))
    
    # todo:                             以上填补实际都不是很合适
    # todo:使用随机森林回归填补缺失值
    # 把特征不缺失的特征+原本的标签作为新的标签
    # 遍历所有的特征,从缺失值最少的开始填补(因为所需要的准确信息最少)
    X_missing_reg = X_missing.copy()
    # print(X_missing_reg)
    # print(X_missing_reg.isnull())
    # print(X_missing_reg.isnull().sum(axis=0)) # 获取按行看每列 共有多少缺失值
    # 从小到大排序
    # np.sort(X_missing_reg.isnull().sum(axis=0))
    # todo 从小到大排序(获取对应特征索引)
    sortindex = np.argsort(X_missing_reg.isnull().sum(axis=0)).values
    # print(sortindex)  ###[ 6 12  8  7  9  0  2  1  5  4  3 10 11]  ## 第几行特征缺失最少,排序
    
    # todo 构建新特征矩阵和新标签---->逐个把排序好的特征作为标签来用,其他的用作构建成新的特征矩阵
    
    # 新标签
    for i in sortindex:
        # 原特征之一,目前是 新标签
        df = X_missing_reg
        fillc = df.iloc[:, i]
        # 新特征矩阵
        # print([*df.columns])                                   ###可以查看所有的列索引
        # print(df.iloc[:, df.columns != 6])
        # 连接俩个矩阵得到新特征矩阵
        df = pd.concat([df.iloc[:, df.columns != i], pd.DataFrame(y_full)], axis=1)
        # 在新特征矩阵中,对含有缺失值的列,进行0的填充
        df_0 = SimpleImputer(missing_values=np.nan, strategy='constant', fill_value=0).fit_transform(df)
        # print(pd.DataFrame(df_0))
        # 找出我们的训练集和测试集
        # 是被选中要填充的特征中(现在是我们的标签),存在的那些值,非nan值
        # print(fillc.isnull())
        Y_train = fillc[fillc.notnull()]
        # 是被选中要填充的特征中(现在是我们的标签),不存在的那些值,为nan的空值
        # 我们需要的不是Ytest,而是ytest所带的索引
        Y_test = fillc[fillc.isnull()]
        # 在新特征矩阵上,被选出来的要填充的特征的非空值所对应的记录
        X_train = df_0[Y_train.index, :]
        # 在新特征矩阵上,被选出来的要填充的特征的空值所对应的记录
        X_test = df_0[Y_test.index, :]
    
        # 用随机森林回归来填补缺失值
        rfc = RandomForestRegressor(n_estimators=100)  # 实例化
        rfc = rfc.fit(X_train, Y_train)  # 导入训练集去进行训练
        Ypredict = rfc.predict(X_test)  # 用predict接口将x_test导入 ,得到我们的预测结果(回归结果),就是我们要用来填补空缺的这些值
        # print(len(Ypredict))
    
        # 将填补好的特征返回我们的原始的特征矩阵中
        X_missing_reg.loc[X_missing_reg.iloc[:, i].isnull(), i] = Ypredict
    # print(X_missing_reg)
    
    # 目前已经有了四组数据 : 原数据,0填充的数据,均值填充的数据,回归填充的数据
    # 对填充好的数据进行建模
    X = [x_full, X_missing_mean, X_missing_0, X_missing_reg]
    mse = []
    for x in X:
        estimator = RandomForestRegressor(random_state=0, n_estimators=100)  # 实例化
        # 评估器 ,特征,标签
        scores = cross_val_score(estimator, x, y_full, scoring='neg_mean_squared_error', cv=5).mean()
        mse.append(scores * -1)
    # print(mse) # mse越小越好
    pprint([*zip(["x_full", "X_missing_mean", "X_missing_0", "X_missing_reg"], mse)])
    # [('x_full', 21.62860460743544),
    #  ('X_missing_mean', 40.84405476955929),
    #  ('X_missing_0', 49.50657028893417),
    #  ('X_missing_reg', 20.907999984896122)]    #########比原始数据打分都高
    
    展开全文
  • 随机森林回归和多输出元估计器对于多元回归...# 比较多输出回归(回归的目标大于1维度,例如同时回归出股市的收盘价和最高价),对比模型为:随机森林回归模型、多输出回归器; This example illustrates the use o...
  • n_estimators2,criterion3,max_depth4,min_samples_leaf5,min_samples_split7,max_features8,class_weight9,max_leaf_nodes10,oob_score11,verbose重要属性重要方法随机森林回归器 随机森林分类器 引入 ...
  • 随机森林是非常具有代表性的Bagging集成算法,它的所有基评估器都是决策树,分类树组成的森林就叫做随机森林分类器,回归树所集成的森林就叫做随机森林回归器。我们先来看 RandomForestClassifier,随机森林分类器。...
  • 所有的参数,属性与接口,全部和随机森林分类一致。仅有的不同就是回归树与分类树的不同,不纯度的指标, 参数Criterion不一致。RandomForestRegressor(n_esti...
  • 文章目录随机森林分类 RandomForestClassifierⅠ.基本参数Ⅱ.重要参数 n_estimatorsⅢ.随机森林探索wine数据集Ⅳ.交叉验证绘制学习曲线比较决策树与随机森林Ⅴ.绘制n_estimator学习曲线Ⅵ.重要参数、属性和接口...
  • 随机森林分类的重要参数:criterion、splitter、max_depth、min_samples_leaf &min_samples_split、max_features & min_impurity_decrease具体的使用可参考DecisionTreeClassifier重要参数、属性、接口...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 786
精华内容 314
关键字:

随机森林回归器