精华内容
下载资源
问答
  • Python随机森林分类器代码实现
  • 根据轴承振动数据预测轴承故障,轴承振动数据一共有792组,每组数据包括6000个时间点的...将标签1~9改为1,将多分类问题变为二分类问题 import csv import numpy as np import matplotlib.pyplot as plt from sklearn.

    根据轴承振动数据预测轴承故障,轴承振动数据一共有792组,每组数据包括6000个时间点的振幅。轴承标签数据一共有10类,0表示无故障,1~9分别表示不同的故障。
    百度网盘下载训练数据:
    链接:https://pan.baidu.com/s/1oKPwn_rAgA5pMk5geCdZKg
    提取码:bqjb

    二分类

    将标签1~9改为1,将多分类问题变为二分类问题

    import csv
    import numpy as np
    import matplotlib.pyplot as plt
    from sklearn.ensemble import RandomForestClassifier
    from sklearn.tree import DecisionTreeClassifier
    from sklearn.model_selection import train_test_split, cross_val_score, GridSearchCV
    from sklearn.metrics import roc_curve, auc, roc_auc_score
    
    x = []
    y = []
    # 将item分割成sub_item_num份
    sub_item_num = 20
    rfile = open('train_data.csv', 'r')
    items = csv.reader(rfile)
    for i, item in enumerate(items):
    	if i >= 1:
    		# 获取y,将标签1~9改为1
    		label = 1 if int(item[-1])>0 else 0
    		y.append(label)
    		# 获取x
    		item = np.array(item)
    		item = item[1:-1].astype(np.float)
    		item = item**2
    		sub_items = np.array_split(item, sub_item_num)
    		feature = []
    		for sub_item in sub_items:
    			feature.append(np.max(sub_item))
    		x.append(feature)
    rfile.close()
    
    # 获取训练数据和测试数据
    xtrain, xtest, ytrain, ytest = train_test_split(x, y, test_size = 0.3, random_state = 10)
    
    # 决策树分类
    dtc = DecisionTreeClassifier(max_depth=None, min_samples_leaf=1, min_samples_split=2, random_state=10)
    dtc = dtc.fit(xtrain, ytrain)
    accuracy = dtc.score(xtest, ytest)
    print('决策树准确率:\n', accuracy)
    
    # 随机森林分类
    rfc = RandomForestClassifier(n_estimators=10, max_depth=None, min_samples_leaf=1, min_samples_split=2, random_state=10)
    rfc = rfc.fit(xtrain, ytrain)
    accuracy = rfc.score(xtest, ytest)
    print('随机森林准确率:\n', accuracy)
    print('决策树1的信息:\n', rfc.estimators_[0])
    print('类别列表:\n', rfc.classes_)
    print('类别数:\n', rfc.n_classes_)
    print('预测的标签:\n', rfc.predict(xtest)[:10]) # 仅显示前10条数据
    print('各个标签的概率值:\n', rfc.predict_proba(xtest)[:10,:]) # 仅显示前10条数据
    print('标签1的概率值:\n', rfc.predict_proba(xtest)[:10,1]) # 仅显示前10条数据
    print('各个特征的重要性:\n', rfc.feature_importances_)
    print('各个特征的重要性排名:\n', np.argsort(rfc.feature_importances_))
    
    # n_estimators:决策树个数
    # min_samples_split:节点最少样本数量,即低于此数量就不再作为节点
    # min_samples_leaf:叶子最少样本数量,即低于此数量就不再作为叶子
    # max_depth:决策树层数
    # cv:表示几折交叉验证
    
    # 优化随机森林超参数n_estimators
    param_test1 = {'n_estimators':range(1, 20 , 1)}
    gs1 = GridSearchCV(estimator = RandomForestClassifier(max_depth=8, 
    													min_samples_leaf=10, 
    													min_samples_split=20, 
    													random_state=10),
    				param_grid = param_test1,
    				scoring = 'roc_auc',
    				cv = 5) # cv表示几折交叉验证
    gs1.fit(xtrain, ytrain)
    print(gs1.best_params_, gs1.best_score_)
    
    # 优化随机森林超参数max_depth
    param_test3 = {'max_depth': range(1, 10, 1)}
    gs3 = GridSearchCV(estimator = RandomForestClassifier(n_estimators=3, 
    													min_samples_leaf=10, 
    													min_samples_split=20, 
    													random_state=10),
    				param_grid = param_test3,
    				scoring = 'roc_auc',
    				cv = 5) # cv表示几折交叉验证
    gs3.fit(xtrain, ytrain)
    print(gs3.best_params_, gs3.best_score_)
    
    # 优化随机森林超参数min_samples_leaf和min_samples_split
    param_test2 = {'min_samples_leaf':range(1, 10, 1), 'min_samples_split':range(2, 20, 1)}
    gs2 = GridSearchCV(estimator = RandomForestClassifier(n_estimators=3, 
    													max_depth=2, 
    													random_state=10),
    				param_grid = param_test2,
    				scoring = 'roc_auc',
    				cv = 5)
    gs2.fit(xtrain, ytrain)
    print(gs2.best_params_, gs2.best_score_)
    
    # 优化随机森林超参数class_weight和criterion
    param_test4 = {'class_weight': [None, 'balanced'], 'criterion': ['gini', 'entropy']}
    gs4 = GridSearchCV(estimator = RandomForestClassifier(n_estimators=3, 
    													max_depth=2,
    													min_samples_leaf=1, 
    													min_samples_split=2, 
    													random_state=10),
    				param_grid = param_test4,
    				scoring = 'roc_auc',
    				cv = 5) # cv表示几折交叉验证
    gs4.fit(xtrain, ytrain)
    print(gs4.best_params_, gs4.best_score_)
    
    # 用roc_auc_score评估
    score = roc_auc_score(ytest, gs4.best_estimator_.predict_proba(xtest)[:,1])
    print('roc_auc_score:\n', score)
    
    # 优化后的随机森林
    rfc = RandomForestClassifier(n_estimators=3, max_depth=2, min_samples_leaf=1, min_samples_split=2, random_state=10)
    rfc = rfc.fit(xtrain, ytrain)
    accuracy = rfc.score(xtest, ytest)
    print('优化后的随机森林准确率:\n', accuracy)
    

    决策树准确率:
    0.9957983193277311
    随机森林准确率:
    0.9957983193277311
    决策树1的信息:
    DecisionTreeClassifier(class_weight=None, criterion=‘gini’, max_depth=None,
    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, presort=False,
    random_state=1165313289, splitter=‘best’)
    类别列表:
    [0 1]
    类别数:
    2
    预测的标签:
    [1 1 0 1 1 1 1 0 1 0]
    各个标签的概率值:
    [[0. 1.]
    [0. 1.]
    [1. 0.]
    [0. 1.]
    [0. 1.]
    [0. 1.]
    [0. 1.]
    [1. 0.]
    [0. 1.]
    [1. 0.]]
    标签1的概率值:
    [1. 1. 0. 1. 1. 1. 1. 0. 1. 0.]
    各个特征的重要性:
    [0. 0.28922611 0.09799994 0. 0.00417205 0.
    0.0980406 0. 0.10085798 0.00506141 0. 0.09672961
    0.002046 0.09802512 0.10439175 0.0042681 0. 0.09706366
    0.00211767 0. ]
    各个特征的重要性排名:
    [ 0 16 10 7 5 19 3 12 18 4 15 9 11 17 2 13 6 8 14 1]
    {‘n_estimators’: 3} 1.0
    {‘max_depth’: 2} 1.0
    {‘min_samples_leaf’: 1, ‘min_samples_split’: 2} 1.0
    {‘class_weight’: None, ‘criterion’: ‘gini’} 1.0
    roc_auc_score:
    0.9999509419152276
    优化后的随机森林准确率:
    0.9957983193277311

    多分类

    将二分类优化好的参数应用于多分类时,准确率由85%降到39%,说明二分类优化的参数不适合多分类

    import csv
    import numpy as np
    import matplotlib.pyplot as plt
    from sklearn.ensemble import RandomForestClassifier
    from sklearn.tree import DecisionTreeClassifier
    from sklearn.model_selection import train_test_split, cross_val_score
    
    x = []
    y = []
    # 将item分割成sub_item_num份
    sub_item_num = 20
    rfile = open('train_data.csv', 'r')
    items = csv.reader(rfile)
    for i, item in enumerate(items):
    	if i >= 1:
    		# 获取y
    		label = int(item[-1])
    		y.append(label)
    		# 获取x
    		item = np.array(item)
    		item = item[1:-1].astype(np.float)
    		item = item**2
    		sub_items = np.array_split(item, sub_item_num)
    		feature = []
    		for sub_item in sub_items:
    			feature.append(np.max(sub_item))
    		x.append(feature)
    rfile.close()
    
    # 获取训练数据和测试数据
    xtrain, xtest, ytrain, ytest = train_test_split(x, y, test_size = 0.3, random_state = 10)
    
    # 决策树分类
    dtc = DecisionTreeClassifier(max_depth=None, min_samples_leaf=1, min_samples_split=2, random_state=10)
    dtc = dtc.fit(xtrain, ytrain)
    accuracy = dtc.score(xtest, ytest)
    print('决策树准确率:\n', accuracy)
    
    # 随机森林分类
    rfc = RandomForestClassifier(n_estimators=10, max_depth=None, min_samples_leaf=1, min_samples_split=2, random_state=10)
    rfc = rfc.fit(xtrain, ytrain)
    accuracy = rfc.score(xtest, ytest)
    print('随机森林准确率:\n', accuracy)
    print('决策树1的信息:\n', rfc.estimators_[0])
    print('类别列表:\n', rfc.classes_)
    print('类别数:\n', rfc.n_classes_)
    print('预测的标签:\n', rfc.predict(xtest)[:10]) # 仅显示前10条数据
    print('各个标签的概率值:\n', rfc.predict_proba(xtest)[:10,:]) # 仅显示前10条数据
    print('标签1的概率值:\n', rfc.predict_proba(xtest)[:10,1]) # 仅显示前10条数据
    print('各个特征的重要性:\n', rfc.feature_importances_)
    print('各个特征的重要性排名:\n', np.argsort(rfc.feature_importances_))
    
    # 优化后的随机森林
    rfc = RandomForestClassifier(n_estimators=3, max_depth=2, min_samples_leaf=1, min_samples_split=2, random_state=10)
    rfc = rfc.fit(xtrain, ytrain)
    accuracy = rfc.score(xtest, ytest)
    print('优化后的随机森林准确率:\n', accuracy)
    

    决策树准确率:
    0.6680672268907563
    随机森林准确率:
    0.8529411764705882
    决策树1的信息:
    DecisionTreeClassifier(class_weight=None, criterion=‘gini’, max_depth=None,
    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, presort=False,
    random_state=1165313289, splitter=‘best’)
    类别列表:
    [0 1 2 3 4 5 6 7 8 9]
    类别数:
    10
    预测的标签:
    [4 4 0 7 7 3 4 0 6 0]
    各个标签的概率值:
    [[0. 0. 0. 0. 0.5 0. 0. 0.4 0. 0.1]
    [0. 0. 0. 0. 0.8 0. 0. 0.1 0. 0.1]
    [1. 0. 0. 0. 0. 0. 0. 0. 0. 0. ]
    [0. 0. 0. 0. 0.1 0.1 0. 0.4 0. 0.4]
    [0. 0. 0. 0. 0. 0. 0.1 0.7 0. 0.2]
    [0. 0.2 0.1 0.7 0. 0. 0. 0. 0. 0. ]
    [0. 0. 0. 0. 0.7 0. 0. 0.3 0. 0. ]
    [1. 0. 0. 0. 0. 0. 0. 0. 0. 0. ]
    [0. 0. 0. 0. 0. 0. 0.6 0.3 0. 0.1]
    [1. 0. 0. 0. 0. 0. 0. 0. 0. 0. ]]
    标签1的概率值:
    [0. 0. 0. 0. 0. 0.2 0. 0. 0. 0. ]
    各个特征的重要性:
    [0.03396424 0.09647236 0.06529748 0.01845416 0.03670531 0.04392909
    0.08551289 0.03128865 0.06090745 0.0263214 0.03080538 0.05375302
    0.0860377 0.06233137 0.07279089 0.02700919 0.03563748 0.06931447
    0.02881671 0.03465075]
    各个特征的重要性排名:
    [ 3 9 15 18 10 7 0 19 16 4 5 11 8 13 2 17 14 6 12 1]
    优化后的随机森林准确率:
    0.3949579831932773

    展开全文
  • python随机森林

    千次阅读 2017-12-22 10:15:51
    准备在天池新人赛中使用随机森林。 网上搜索了一个博客: http://blog.csdn.net/lulei1217/article/details/49583287 下面是自己实现的代码: from sklearn.tree import DecisionTreeRegressor from sklearn....

    准备在天池新人赛中使用随机森林。
    网上搜索了一个博客:
    http://blog.csdn.net/lulei1217/article/details/49583287
    下面是自己实现的代码:
    from sklearn.tree import DecisionTreeRegressor
    from sklearn.ensemble import RandomForestRegressor
    import numpy as np
    from sklearn.datasets import load_iris
    iris=load_iris()

    #print iris#iris的4个属性是:萼片宽度 萼片长度 花瓣宽度 花瓣长度 标签是花的种类:setosa versicolour virginica  
    print (iris['target'].shape)
    rf=RandomForestRegressor()#这里使用了默认的参数设置  
    rf.fit(iris.data[:150],iris.target[:150])#进行模型的训练  
    #随机挑选两个预测不相同的样本  
    instance=iris.data[[100,109]]  
    print (instance  )
    print( 'instance 0 prediction',rf.predict(instance[0]) )
    print( 'instance 1 prediction',rf.predict(instance[1]) )
    print (iris.target[100],iris.target[109]  )

    输出结果:
    (150,)
    [[ 6.3 3.3 6. 2.5]
    [ 7.2 3.6 6.1 2.5]]
    instance 0 prediction [ 2.]
    instance 1 prediction [ 2.]
    2 2

    下面是自己对问题的思考:

    from sklearn.datasets import load_iris  
    iris=load_iris()  

    这个代码明显是sklearn包封装了load_iris函数,那么这个函数代码在哪里呢?数据放哪里?怎么组织的呢?

    按照介绍,sklearn包随机森林函数接口的官方说明:
    http://scikit-learn.org/stable/modules/ensemble.html#random-forests
    最简单的随机森林的例子:
    最后预测的时候需要2个数组:X为训练集合,Y为标签

    from sklearn.ensemble import RandomForestClassifier
    X = [[0, 0], [1, 1]]
    Y = [0, 1]
    clf = RandomForestClassifier(n_estimators=10)
    clf = clf.fit(X, Y)

    所以,我们回到之前的代码,可以知道:
    训练集合:iris.data[:150]
    标签集合:iris.target[:150]
    我们输入:

    iris

    可以看到iris的具体描述,好复杂,但是还是基本上都能看明白:
    这里写图片描述
    输入:

    iris['target'].shape[0]

    可以看到有150个标签,意味着有150个数据
    输入:

    iris.target[:150]

    可以看到有0、1、2合计3类
    输入:

    iris.data[:150]

    可以看到每个有4个特征。
    也就是说,只要我们把天池新人赛中的数据转换成这种格式,就可以使用随机森林做训练预测了。
    预测直接使用:

    print(rf.predict(iris.data[2]) )

    另外有个问题看官方网站介绍:
    RandomForestRegressor是做随机森林回归
    RandomForestRegressor(n_estimators=10, 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=1, random_state=None, verbose=0, warm_start=False)
    而RandomForestClassifier是做随机森林分类
    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)
    几个重要的参数:(http://blog.csdn.net/lulei1217/article/details/49583287
    最主要的两个参数是n_estimators和max_features。
    n_estimators:表示森林里树的个数。理论上是越大越好。但是伴随着就是计算时间的增长。但是并不是取得越大就会越好,预测效果最好的将会出现在合理的树个数。
    max_features:随机选择特征集合的子集合,并用来分割节点。子集合的个数越少,方差就会减少的越快,但同时偏差就会增加的越快。根据较好的实践经验。如果是回归问题则:
    max_features=n_features,如果是分类问题则max_features=sqrt(n_features)。

    如果想获取较好的结果,必须将max_depth=None,同时min_sample_split=1。
    同时还要记得进行cross_validated(交叉验证),除此之外记得在random forest中,bootstrap=True。但在extra-trees中,bootstrap=False。

    切换到随机森林分类:

    from sklearn.tree import DecisionTreeRegressor  
    from sklearn.ensemble import RandomForestRegressor  
    from sklearn.ensemble import RandomForestClassifier
    import numpy as np  
    from sklearn.datasets import load_iris  
    iris=load_iris()  
    #print iris#iris的4个属性是:萼片宽度 萼片长度 花瓣宽度 花瓣长度 标签是花的种类:setosa versicolour virginica  
    print (iris['target'].shape)
    rf=RandomForestClassifier()#这里使用了默认的参数设置  
    rf.fit(iris.data[:150],iris.target[:150])#进行模型的训练  
    #随机挑选两个预测不相同的样本  
    instance=iris.data[[100,109]]  
    print (instance  )
    print( 'instance 0 prediction',rf.predict(instance[0]) )
    print( 'instance 1 prediction',rf.predict(instance[1]) )
    print (iris.target[100],iris.target[109]  )

    最终输出结果:
    (150,)
    [[ 6.3 3.3 6. 2.5]
    [ 7.2 3.6 6.1 2.5]]
    instance 0 prediction [2]
    instance 1 prediction [2]
    2 2
    可以发现这个结果就是整数了,而不是浮点数据了。

    测试分类效果:

    err = 0
    temp = 0
    for i in range(iris['target'].shape[0]):
        temp = rf.predict(iris.data[i])
        #print(temp[0])
        if temp[0] != iris.target[i]:
            err = err +1
    err = err/iris['target'].shape[0]
    print(1-err)

    输出结果:
    0.9866666666666667

    天池新手赛使用的都是pandas类型的数据,所以又自己写了个最简单的测试代码:

    import pandas as pd
    from pandas import Series,DataFrame 
    import random
    from numpy import nan as NA
    from sklearn.tree import DecisionTreeRegressor  
    from sklearn.ensemble import RandomForestRegressor  
    from sklearn.ensemble import RandomForestClassifier
    import numpy as np  
    from sklearn.datasets import load_iris  

    读取自己随便写的一个csv文件

    #读取测试数据
    data = pd.read_csv('test.csv')
    print(data)

    读取结果如下:
    f1 f2 f3 f4 f5 flag
    0 1.414214 2 3.414214 92 106.142136 0
    1 1.732051 3 4.732051 73 90.320508 0
    2 2.000000 4 6.000000 36 56.000000 0
    3 2.236068 5 7.236068 -25 -2.639320 0
    4 2.449490 6 8.449490 -116 -91.505103 0
    5 2.645751 7 9.645751 -243 -216.542487 0
    6 2.828427 8 10.828427 -412 -383.715729 0
    7 3.000000 9 12.000000 -629 -599.000000 0
    8 3.162278 10 13.162278 -900 -868.377223 0
    9 3.316625 11 14.316625 -1231 -1197.833752 0
    10 3.464102 12 15.464102 -1628 -1593.358984 1
    11 3.605551 13 16.605551 -2097 -2060.944487 1
    12 3.741657 14 17.741657 -2644 -2606.583426 1
    13 3.872983 15 18.872983 -3275 -3236.270167 1
    14 4.000000 16 20.000000 -3996 -3956.000000 1
    15 4.123106 17 21.123106 -4813 -4771.768944 1
    16 4.242641 18 22.242641 -5732 -5689.573593 1
    17 4.358899 19 23.358899 -6759 -6715.411011 0
    18 4.472136 20 24.472136 -7900 -7855.278640 0
    19 4.582576 21 25.582576 -9161 -9115.174243 0
    20 4.690416 22 26.690416 -10548 -10501.095840 0
    21 4.795832 23 27.795832 -12067 -12019.041680 0
    22 4.898979 24 28.898979 -13724 -13675.010210 0
    23 5.000000 25 30.000000 -15525 -15475.000000 1
    24 5.099020 26 31.099020 -17476 -17425.009800 1
    25 5.196152 27 32.196152 -19583 -19531.038480 1
    26 5.291503 28 33.291503 -21852 -21799.084970 1
    27 5.385165 29 34.385165 -24289 -24235.148350 1
    28 5.477226 30 35.477226 -26900 -26845.227740 1
    29 5.567764 31 36.567764 -29691 -29635.322360 1
    30 5.656854 32 37.656854 -32668 -32611.431460 1
    31 5.744563 33 38.744563 -35837 -35779.554370 1
    32 5.830952 34 39.830952 -39204 -39145.690480 1
    对特征和标签做提取,转成numpy的数组

    UseFlag = data['flag'].values
    print(UseFlag)
    UseFeature = data[['f1','f2','f3','f4','f5']].values
    print(UseFeature)

    使用随机森林分类模型,训练

    rf=RandomForestClassifier()#这里使用了默认的参数设置  
    rf.fit(UseFeature,UseFlag)#进行模型的训练  

    验证最终模型的预测结果:

    err = 0
    temp = 0
    for i in range(UseFeature.shape[0]):
        temp = rf.predict(UseFeature[i])
        if temp[0] != UseFlag[i]:
            err = err +1
    err = err/UseFeature.shape[0]
    print(1-err)

    最终输出结果:预测成功率100%(就这几个数据,还是训练集合,不是100%就怪了)
    1.0

    这样就只剩下在天池的数据中提取出特征就OK了。

    展开全文
  • Python 随机森林特征重要度 1 声明 本文的数据来自网络,部分代码也有所参照,这里做了注释和延伸,旨在技术交流,如有冒犯之处请联系博主及时处理。 2 随机森林特征重要度简介 决策树的优点是通过树形结构以...

                               Python 随机森林特征重要度

    1 声明

    本文的数据来自网络,部分代码也有所参照,这里做了注释和延伸,旨在技术交流,如有冒犯之处请联系博主及时处理。

    2 随机森林特征重要度简介

    决策树的优点是通过树形结构以规则的形式查看模型的内在结构,但随机森林是由几十、上百甚至上千棵决策树组成的,这样很难再可视化查看模型的结构。但是我们可以通过随机森林查看特征的重要度。

    关于特征的重要性,需要注意两点:

    第一点scikit-learn要求我们将名义分类特征分解为多个二元特征(一种名义变量转化为数值型的常见方法 One-Hot编码);第二点如果两个特征高度相关,则会考虑其中一个特征,另外个特征将被弱化,如果不这么处理模型将难以解释。

    在scikit-learn中,分类回归决策树和随机森林可以使用特征重要性方法来查看每个特征的相对重要性。

    通过特征重要性筛选的步骤

    第一步随机森林用到所有特征建立模型,此时会计算出特征的重要性并形成特征矩阵,第二步对该该矩阵通过SelectFromModel的threshold阈值参数进行过滤,用这个模型作为最终的模型。

     

    3 随机森林特征重要度代码示例

    # 导入相关库和包
    import numpy as np
    import matplotlib.pyplot as plt
    from sklearn.ensemble import RandomForestClassifier
    from sklearn import datasets
    # 装载数据
    iris = datasets.load_iris()
    features = iris.data
    target = iris.target
    # 创建随机森林模型并计算特征重要度
    randomforest = RandomForestClassifier(random_state=0, n_jobs=-1)
    model = randomforest.fit(features, target)
    importances = model.feature_importances_
    indices = np.argsort(importances)[::-1]
    names = [iris.feature_names[i] for i in indices]
    #print(names)
    #print(range(features.shape[1]), importances[indices])
    # 画图
    plt.figure()
    from matplotlib.font_manager import FontProperties
    #设置支持中文字体
    fp= FontProperties(fname="c:/windows/fonts/simsun.ttc", size=12)
    plt.suptitle('特征重要性',fontproperties=fp)
    plt.bar(range(features.shape[1]), importances[indices])
    plt.xticks(range(features.shape[1]), names, rotation=90)
    plt.show()
    # 通过重要度的阈值筛选特征
    # 定义重要度的阈值
    selector = SelectFromModel(randomforest, threshold=0.3)
    features_important = selector.fit_transform(features, target)
    # 训练新的模型
    model = randomforest.fit(features_important, target)

    4 总结

     

     

    展开全文
  • python随机森林实现代码和实例,自动获取网络数据集,含数据,直接运行
  • 优化随机森林算法,正确率提高1%~5%(已经有90%+的正确率,再调高会导致过拟合) 论文当然是参考的,毕竟出现早的算法都被人研究烂了,什么优化基本都做过。而人类最高明之处就是懂得利用前人总结的经验和制造的...
  • 竞赛时写的一个python小程序,得了0.93分,思路如下,1读取训练集、2数据预处理、3上模型、4将模型应用到预测及、5生成预测结果
  • 10、python随机森林代码案例

    千次阅读 2018-12-13 19:05:20
    随机森林随机森林是包含多个决策树的分类器,并且其输出类别是由个别树输出的类别的众数而定 决策树见案例:https://blog.csdn.net/qq_36327687/article/details/84944850 2 优点 01 适合离散型和连续型的属性...

    目录

    1 概念

    2 优点

    3 理论方法

    4、代码完整案例


    1 概念

    随机森林:随机森林是包含多个决策树的分类器,并且其输出类别是由个别树输出的类别的众数而定

    决策树见案例:https://blog.csdn.net/qq_36327687/article/details/84944850

    2 优点

    01 适合离散型和连续型的属性数据

    02 对海量数据,尽量避免了过度拟合的问题

    03 对高纬度的数据,不会出现特征选择困难的问题

    04 实现简单,训练速度快,适合进行分布式计算

    3 理论方法

    # 随机森林生成方法:

    rfcModel=RandomforestClassifier(

            n_estimators=10,
            max_leaf_nodes=None
            )
            
     n_estimators 森林中树的个数,默认值为10
     
     max_leaf_nodes 统一设置树中最大的叶子节点数
     
    # 随机森林训练以及预测方法

    rfcModel.fit(featureData,targetData)

    featureData  特征数据

    targetData  目标数据

     rfcModel.predict(featureData)
     
     featureData  特征数据


    4、代码完整案例

     

    import pandas;
    
    data = pandas.read_csv('D:\\DATA\\pycase\\number2\\5.3\\data.csv')
    
    # 虚拟变量的转换
    
    dummyColumns = ["Gender", "ParentEncouragement"]
    
    for column in dummyColumns:
        data[column]=data[column].astype('category')
    
    dummiesData = pandas.get_dummies(
        data, 
        columns=dummyColumns,
        prefix=dummyColumns,
        prefix_sep="=",
        drop_first=True
    )
    dummiesData.columns
    
    # 挑选出重要特征
    
    fData = dummiesData[[
        'ParentIncome', 'IQ', 'Gender=Male',
        'ParentEncouragement=Not Encouraged'
    ]]
    
    # 挑选结果属性
    
    tData = dummiesData["CollegePlans"]
    
    
    
    from sklearn.tree import DecisionTreeClassifier
    from sklearn.ensemble import RandomForestClassifier
    from sklearn.model_selection import cross_val_score
    
    # 决策树的评分
    
    dtModel = DecisionTreeClassifier()
    
    dtScores = cross_val_score(
        dtModel, 
        fData, tData, cv=10
    )
    
    dtScores.mean()
    
    # 随机森林哥的评分,在没有参数调优的情况下,随机森林好,参数:叶子结点
    
    rfcModel = RandomForestClassifier()
    
    rfcScores = cross_val_score(
        rfcModel, 
        fData, tData, cv=10
    )
    
    rfcScores.mean()
    
    # 决策树,加入叶子节点进行调油
    
    dtModel = DecisionTreeClassifier(max_leaf_nodes=8)
    
    dtScores = cross_val_score(
        dtModel, 
        fData, tData, cv=10
    )
    
    dtScores.mean()
    
    # 随机森林,加入叶子节点进行调油,结果和决策树差不多,所以没有最好,适合
    
    rfcModel = RandomForestClassifier(max_leaf_nodes=8)
    
    rfcScores = cross_val_score(
        rfcModel, 
        fData, tData, cv=10
    )
    
    rfcScores.mean()

     

    展开全文
  • 1.随机森林定义  随机森林是一种多功能的机器学习算法,能够...在随机森林中,会生成很多的决策树,当在基于某些属性对一个新的对象进行分类判别时,随机森林中的每一棵树都会给出自己的分类选择,并由此进行“投票...
  • python随机森林回归数据实战

    千次阅读 多人点赞 2020-11-12 11:51:53
    文章目录前言一、随机森林回归器参数介绍二、数据实战1.数据介绍2.重点代码2.1特征集和标签集获取2.2数据集划分2.3随机森林模型训练2.4预测结果可视化2.5 特征重要性选择及可视化3.完整代码总结 前言 我为什么写这...
  • 每天读一篇一线开发者原创好文 译者:XTH 英文原文:...随机森林是一种在集成学习中很受欢迎的算法,可用于分类和回归。这意味着随机森林中包括多种决策树,并将每个决策树结果的平均值作为随机森林
  • 机器学习算法(8)python实现随机森林分类) 可以把随机森林看成是决策树的集 合。随机森林背后的逻辑是对分别受较大方差影响的多个决策树取平均值, 以建立一个具有更好的泛化性能和不易过拟合的强大模型。 ...
  • 使用Python进行随机森林图像分类 使用Python随机森林图像分类 请遵循以下文件夹结构。 图像分类(文件夹) 数据集(文件夹) 火车(文件夹) 图像Cat1文件夹 train_img.jpg train_img.jpg train_img.jpg .....
  • 上图: 附上代码:一个函数,传入三个参数 ........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, ...
  • Python——随机森林

    千次阅读 2017-03-26 13:13:44
    随机森林讲解文档(scikit-learn官方文档)    scikit-learn的官方文档:http://scikit-learn.org/stable/modules/ensemble.html#forests-of-randomized-trees    主要告诉大家如何使用scikit-learn包中的类...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 22,971
精华内容 9,188
关键字:

python随机森林解决分类问题

python 订阅