Python培训技术分享_用Python实现随机森林算法

　　Python培训技术分享_用Python实现随机森林算法。光环大数据讲师均为实战专家，具备10年以上软件开发培训经验，五年以上大数据实战经验，行业口碑最好。比如，杨老师，是前全球十大咨询公司ESG亚太区分析师，对云计算、大数据有深入研究，曾为IBM、DELL、HP、EMC等厂商提供产品测评报告，并为国内企业华为、联想、浪潮、曙光等企业的业务现状和发展方向提供战略咨询服务。

光环大数据只聘请专大数据领域尖端技能的精英讲师，确保教学的整体质量与教学水准。讲师团及时掌握时代潮流技术，将前沿技能融入教学中，确保学生所学知识顺应时代所需。通过深入浅出、通俗易懂的教学方式，指导学生更快的掌握技能知识，成就上万个高薪就业学子。

拥有高方差使得决策树（secisiontress）在处理特定训练数据集时其结果显得相对脆弱。bagging（bootstrapaggregating的缩写）算法从训练数据的样本中建立复合模型，可以有效降低决策树的方差，但树与树之间有高度关联（并不是理想的树的状态）。

随机森林算法（Randomforestalgorithm）是对bagging算法的扩展。除了仍然根据从训练数据样本建立复合模型之外，随机森林对用做构建树（tree）的数据特征做了一定限制，使得生成的决策树之间没有关联，从而提升算法效果。

本教程旨在探讨如何用Python实现随机森林算法。通过本文，我们可以了解到：

baggeddecisiontrees与随机森林算法的差异；

如何构建含更多方差的装袋决策树；

如何将随机森林算法运用于预测模型相关的问题。

算法描述

这个章节将对随机森林算法本身以及本教程的算法试验所用的声纳数据集（Sonardataset）做一个简要介绍。

随机森林算法

决策树运行的每一步都涉及到对数据集中的最优分裂点（bestsplitpoint）进行贪婪选择（greedyselection）。

这个机制使得决策树在没有被剪枝的情况下易产生较高的方差。整合通过提取训练数据库中不同样本（某一问题的不同表现形式）构建的复合树及其生成的预测值能够稳定并降低这样的高方差。这种方法被称作引导聚集算法（bootstrapaggregating），其简称bagging正好是装进口袋，袋子的意思，所以被称为「装袋算法」。该算法的局限在于，由于生成每一棵树的贪婪算法是相同的，那么有可能造成每棵树选取的分裂点（splitpoint）相同或者极其相似，最终导致不同树之间的趋同（树与树相关联）。相应地，反过来说，这也使得其会产生相似的预测值，降低原本要求的方差。

我们可以采用限制特征的方法来创建不一样的决策树，使贪婪算法能够在建树的同时评估每一个分裂点。这就是随机森林算法（RandomForestalgorithm）。

与装袋算法一样，随机森林算法从训练集里撷取复合样本并训练。其不同之处在于，数据在每个分裂点处完全分裂并添加到相应的那棵决策树当中，且可以只考虑用于存储属性的某一固定子集。

对于分类问题，也就是本教程中我们将要探讨的问题，其被考虑用于分裂的属性数量被限定为小于输入特征的数量之平方根。代码如下：

num_features_for_split=sqrt(total_input_features)

这个小更改会让生成的决策树各不相同（没有关联），从而使得到的预测值更加多样化。而多样的预测值组合往往会比一棵单一的决策树或者单一的装袋算法有更优的表现。

声纳数据集（Sonardataset）

我们将在本教程里使用声纳数据集作为输入数据。这是一个描述声纳反射到不同物体表面后返回的不同数值的数据集。60个输入变量表示声纳从不同角度返回的强度。这是一个二元分类问题（binaryclassificationproblem），要求模型能够区分出岩石和金属柱体的不同材质和形状，总共有208个观测样本。

该数据集非常易于理解——每个变量都互有连续性且都在0到1的标准范围之间，便于数据处理。作为输出变量，字符串’M’表示金属矿物质，’R’表示岩石。二者需分别转换成整数1和0。

通过预测数据集（M或者金属矿物质）中拥有最多观测值的类，零规则算法（ZeroRuleAlgorithm）可实现53%的精确度。

更多有关该数据集的内容可参见UCIMachineLearningrepository：https://archive.ics.uci.edu/ml/datasets/Connectionist+Bench+(Sonar,+Mines+vs.+Rocks)

免费下载该数据集，将其命名为sonar.all-data.csv，并存储到需要被操作的工作目录当中。

教程

此次教程分为两个步骤。

分裂次数的计算。

声纳数据集案例研究

这些步骤能让你了解为你自己的预测建模问题实现和应用随机森林算法的基础

分裂次数的计算

在决策树中，我们通过找到一些特定属性和属性的值来确定分裂点，这类特定属性需表现为其所需的成本是最低的。

分类问题的成本函数（costfunction）通常是基尼指数（Giniindex），即计算由分裂点产生的数据组的纯度（purity）。对于这样二元分类的分类问题来说，指数为0表示绝对纯度，说明类值被完美地分为两组。

从一棵决策树中找到最佳分裂点需要在训练数据集中对每个输入变量的值做成本评估。

在装袋算法和随机森林中，这个过程是在训练集的样本上执行并替换（放回）的。因为随机森林对输入的数据要进行行和列的采样。对于行采样，采用有放回的方式，也就是说同一行也许会在样本中被选取和放入不止一次。

我们可以考虑创建一个可以自行输入属性的样本，而不是枚举所有输入属性的值以期找到获取成本最低的分裂点，从而对这个过程进行优化。

该输入属性样本可随机选取且没有替换过程，这就意味着在寻找最低成本分裂点的时候每个输入属性只需被选取一次。

如下的代码所示，函数get_split()实现了上述过程。它将一定数量的来自待评估数据的输入特征和一个数据集作为参数，该数据集可以是实际训练集里的样本。辅助函数test_split()用于通过候选的分裂点来分割数据集，函数gini_index()用于评估通过创建的行组（groupsofrows）来确定的某一分裂点的成本。

以上我们可以看出，特征列表是通过随机选择特征索引生成的。通过枚举该特征列表，我们可将训练集中的特定值评估为符合条件的分裂点。

#Selectthebestsplitpointforadataset

defget_split(dataset,n_features):

class_values=list(set(row[-1]forrowindataset))

b_index,b_value,b_score,b_groups=999,999,999,None

features=list()

whilelen(features)<n_features:

index=randrange(len(dataset[0])-1)

ifindexnotinfeatures:

features.append(index)

forindexinfeatures:

forrowindataset:

groups=test_split(index,row[index],dataset)

gini=gini_index(groups,class_values)

ifgini<b_score:

b_index,b_value,b_score,b_groups=index,row[index],gini,groups

return{'index':b_index,'value':b_value,'groups':b_groups}

至此，我们知道该如何改造一棵用于随机森林算法的决策树。我们可将之与装袋算法结合运用到真实的数据集当中。

关于声纳数据集的案例研究

在这个部分，我们将把随机森林算法用于声纳数据集。本示例假定声纳数据集的csv格式副本已存在于当前工作目录中，文件名为sonar.all-data.csv。

首先加载该数据集，将字符串转换成数字，并将输出列从字符串转换成数值0和1.这个过程是通过辅助函数load_csv()、str_column_to_float()和str_column_to_int()来分别实现的。

我们将通过K折交叉验证（k-foldcrossvalidatio）来预估得到的学习模型在未知数据上的表现。这就意味着我们将创建并评估K个模型并预估这K个模型的平均误差。评估每一个模型是由分类准确度来体现的。辅助函数cross_validation_split()、accuracy_metric()和evaluate_algorithm()分别实现了上述功能。

装袋算法将通过分类和回归树算法来满足。辅助函数test_split()将数据集分割成不同的组；gini_index()评估每个分裂点；前文提及的改进过的get_split()函数用来获取分裂点；函数to_terminal()、split()和build_tree()用以创建单个决策树；predict()用于预测；subsample()为训练集建立子样本集；bagging_predict()对决策树列表进行预测。

新命名的函数random_forest()首先从训练集的子样本中创建决策树列表，然后对其进行预测。

正如我们开篇所说，随机森林与决策树关键的区别在于前者在建树的方法上的小小的改变，这一点在运行函数get_split()得到了体现。

完整的代码如下：

#RandomForestAlgorithmonSonarDataset

fromrandomimportseed

fromrandomimportrandrange

fromcsvimportreader

frommathimportsqrt

#LoadaCSVfile

defload_csv(filename):

dataset=list()

withopen(filename,'r')asfile:

csv_reader=reader(file)

forrowincsv_reader:

ifnotrow:

continue

dataset.append(row)

returndataset

#Convertstringcolumntofloat

defstr_column_to_float(dataset,column):

forrowindataset:

row[column]=float(row[column].strip())

#Convertstringcolumntointeger

defstr_column_to_int(dataset,column):

class_values=[row[column]forrowindataset]

unique=set(class_values)

lookup=dict()

fori,valueinenumerate(unique):

lookup[value]=i

forrowindataset:

row[column]=lookup[row[column]]

returnlookup

#Splitadatasetintokfolds

defcross_validation_split(dataset,n_folds):

dataset_split=list()

dataset_copy=list(dataset)

fold_size=len(dataset)/n_folds

foriinrange(n_folds):

fold=list()

whilelen(fold)<fold_size:

index=randrange(len(dataset_copy))

fold.append(dataset_copy.pop(index))

dataset_split.append(fold)

returndataset_split

#Calculateaccuracypercentage

defaccuracy_metric(actual,predicted):

correct=0

foriinrange(len(actual)):

ifactual[i]==predicted[i]:

correct+=1

returncorrect/float(len(actual))*100.0

#Evaluateanalgorithmusingacrossvalidationsplit

defevaluate_algorithm(dataset,algorithm,n_folds,*args):

folds=cross_validation_split(dataset,n_folds)

scores=list()

forfoldinfolds:

train_set=list(folds)

train_set.remove(fold)

train_set=sum(train_set,[])

test_set=list()

forrowinfold:

row_copy=list(row)

test_set.append(row_copy)

row_copy[-1]=None

predicted=algorithm(train_set,test_set,*args)

actual=[row[-1]forrowinfold]

accuracy=accuracy_metric(actual,predicted)

scores.append(accuracy)

returnscores

#Splitadatasetbasedonanattributeandanattributevalue

deftest_split(index,value,dataset):

left,right=list(),list()

forrowindataset:

ifrow[index]<value:

left.append(row)

else:

right.append(row)

returnleft,right

#CalculatetheGiniindexforasplitdataset

defgini_index(groups,class_values):

gini=0.0

forclass_valueinclass_values:

forgroupingroups:

size=len(group)

ifsize==0:

continue

proportion=[row[-1]forrowingroup].count(class_value)/float(size)

gini+=(proportion*(1.0-proportion))

returngini

#Selectthebestsplitpointforadataset

defget_split(dataset,n_features):

class_values=list(set(row[-1]forrowindataset))

b_index,b_value,b_score,b_groups=999,999,999,None

features=list()

whilelen(features)<n_features:

index=randrange(len(dataset[0])-1)

ifindexnotinfeatures:

features.append(index)

forindexinfeatures:

forrowindataset:

groups=test_split(index,row[index],dataset)

gini=gini_index(groups,class_values)

ifgini<b_score:

b_index,b_value,b_score,b_groups=index,row[index],gini,groups

return{'index':b_index,'value':b_value,'groups':b_groups}

#Createaterminalnodevalue

defto_terminal(group):

outcomes=[row[-1]forrowingroup]

returnmax(set(outcomes),key=outcomes.count)

#Createchildsplitsforanodeormaketerminal

defsplit(node,max_depth,min_size,n_features,depth):

left,right=node['groups']

del(node['groups'])

#checkforanosplit

ifnotleftornotright:

node['left']=node['right']=to_terminal(left+right)

return

#checkformaxdepth

ifdepth>=max_depth:

node['left'],node['right']=to_terminal(left),to_terminal(right)

return

#processleftchild

iflen(left)<=min_size:

node['left']=to_terminal(left)

else:

node['left']=get_split(left,n_features)

split(node['left'],max_depth,min_size,n_features,depth+1)

#processrightchild

iflen(right)<=min_size:

node['right']=to_terminal(right)

else:

node['right']=get_split(right,n_features)

split(node['right'],max_depth,min_size,n_features,depth+1)

#Buildadecisiontree

defbuild_tree(train,max_depth,min_size,n_features):

root=get_split(dataset,n_features)

split(root,max_depth,min_size,n_features,1)

returnroot

#Makeapredictionwithadecisiontree

defpredict(node,row):

ifrow[node['index']]<node['value']:

ifisinstance(node['left'],dict):

returnpredict(node['left'],row)

else:

returnnode['left']

else:

ifisinstance(node['right'],dict):

returnpredict(node['right'],row)

else:

returnnode['right']

#Createarandomsubsamplefromthedatasetwithreplacement

defsubsample(dataset,ratio):

sample=list()

n_sample=round(len(dataset)*ratio)

whilelen(sample)<n_sample:

index=randrange(len(dataset))

sample.append(dataset[index])

returnsample

#Makeapredictionwithalistofbaggedtrees

defbagging_predict(trees,row):

predictions=[predict(tree,row)fortreeintrees]

returnmax(set(predictions),key=predictions.count)

#RandomForestAlgorithm

defrandom_forest(train,test,max_depth,min_size,sample_size,n_trees,n_features):

trees=list()

foriinrange(n_trees):

sample=subsample(train,sample_size)

tree=build_tree(sample,max_depth,min_size,n_features)

trees.append(tree)

predictions=[bagging_predict(trees,row)forrowintest]

return(predictions)

#Testtherandomforestalgorithm

seed(1)

#loadandpreparedata

filename='sonar.all-data.csv'

dataset=load_csv(filename)

#convertstringattributestointegers

foriinrange(0,len(dataset[0])-1):

str_column_to_float(dataset,i)

#convertclasscolumntointegers

str_column_to_int(dataset,len(dataset[0])-1)

#evaluatealgorithm

n_folds=5

max_depth=10

min_size=1

sample_size=1.0

n_features=int(sqrt(len(dataset[0])-1))

forn_treesin[1,5,10]:

scores=evaluate_algorithm(dataset,random_forest,n_folds,max_depth,min_size,sample_size,n_trees,n_features)

print('Trees:%d'%n_trees)

print('Scores:%s'%scores)

print('MeanAccuracy:%.3f%%'%(sum(scores)/float(len(scores))))

这里对第197行之后对各项参数的赋值做一个说明。

将K赋值为5用于交叉验证，得到每个子样本为208/5=41.6，即超过40条声纳返回记录会用于每次迭代时的评估。

每棵树的最大深度设置为10，每个节点的最小训练行数为1.创建训练集样本的大小与原始数据集相同，这也是随机森林算法的默认预期值。

我们把在每个分裂点需要考虑的特征数设置为总的特征数目的平方根，即sqrt(60)=7.74，取整为7。

将含有三组不同数量的树同时进行评估，以表明添加更多的树可以使该算法实现的功能更多。

最后，运行这个示例代码将会print出每组树的相应分值以及每种结构的平均分值。如下所示：

Trees:1

Scores:[68.29268292682927,75.60975609756098,70.73170731707317,63.41463414634146,65.85365853658537]

MeanAccuracy:68.780%

Trees:5

Scores:[68.29268292682927,68.29268292682927,78.04878048780488,65.85365853658537,68.29268292682927]

MeanAccuracy:69.756%

Trees:10

Scores:[68.29268292682927,78.04878048780488,75.60975609756098,70.73170731707317,70.73170731707317]

MeanAccuracy:72.683%

扩展

本节会列出一些与本次教程相关的扩展内容。大家或许有兴趣一探究竟。

算法调校（AlgorithmTuning）。本文所用的配置参数或有未被修正的错误以及有待商榷之处。用更大规模的树，不同的特征数量甚至不同的树的结构都可以改进试验结果。

更多问题。该方法同样适用于其他的分类问题，甚至是用新的成本计算函数以及新的组合树的预期值的方法使其适用于回归算法。

回顾总结

通过本次教程的探讨，你知道了随机森林算法是如何实现的，特别是：

随机森林与装袋决策树的区别。

如何用决策树生成随机森林算法。

如何将随机森林算法应用于解决实际操作中的预测模型问题。

光环大数据，拥有16年的程序员培训经验，上市公司品牌，口碑极好，一线名师授课，强大的教研团队研制开发最新的课程，与中关村软件园战略合作保障人才输出，与学员签订就业协议保障就业问题！真正的靠谱品牌！

大数据培训，就选光环大数据！

原创文章，转载请注明出处：光环大数据http://hadoop.aura.cn