python实现随机森林random forest的原理及方法

2023-09-19 01:09:05 140

引言

想通过随机森林来获取数据的主要特征

1、理论

随机森林是一个高度灵活的机器学习方法，拥有广泛的应用前景，从市场营销到医疗保健保险。既可以用来做市场营销模拟的建模，统计客户来源，保留和流失。也可用来预测疾病的风险和病患者的易感性。

根据个体学习器的生成方式，目前的集成学习方法大致可分为两大类，即个体学习器之间存在强依赖关系，必须串行生成的序列化方法，以及个体学习器间不存在强依赖关系，可同时生成的并行化方法；

前者的代表是Boosting，后者的代表是Bagging和“随机森林”（Random
Forest）

随机森林在以决策树为基学习器构建Bagging集成的基础上，进一步在决策树的训练过程中引入了随机属性选择（即引入随机特征选择）。

简单来说，随机森林就是对决策树的集成，但有两点不同：

（2）特征选取的差异性：每个决策树的n个分类特征是在所有特征中随机选择的（n是一个需要我们自己调整的参数）
随机森林，简单理解，比如预测salary，就是构建多个决策树job，age，house，然后根据要预测的量的各个特征（teacher，39，suburb）分别在对应决策树的目标值概率（salary<5000,salary>=5000），从而，确定预测量的发生概率（如，预测出P(salary<5000)=0.3）.

随机森林是一个可做能够回归和分类。它具备处理大数据的特性，而且它有助于估计或变量是非常重要的基础数据建模。

参数说明：

最主要的两个参数是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（交叉验证），除此之外记得在randomforest中，bootstrap=True。但在extra-trees中，bootstrap=False。

2、随机森林python实现

2.1Demo1

实现随机森林基本功能

#随机森林
fromsklearn.treeimportDecisionTreeRegressor
fromsklearn.ensembleimportRandomForestRegressor
importnumpyasnp

fromsklearn.datasetsimportload_iris
iris=load_iris()
#printiris#iris的４个属性是：萼片宽度萼片长度花瓣宽度花瓣长度标签是花的种类：setosaversicolourvirginica
print(iris['target'].shape)
rf=RandomForestRegressor()#这里使用了默认的参数设置
rf.fit(iris.data[:150],iris.target[:150])#进行模型的训练

#随机挑选两个预测不相同的样本
instance=iris.data[[100,109]]
print(instance)
rf.predict(instance[[0]])
print('instance0prediction；',rf.predict(instance[[0]]))
print('instance1prediction；',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]]
instance0prediction；[2.]
instance1prediction；[2.]
22

2.2Demo2

3种方法的比较

#randomforesttest
fromsklearn.model_selectionimportcross_val_score
fromsklearn.datasetsimportmake_blobs
fromsklearn.ensembleimportRandomForestClassifier
fromsklearn.ensembleimportExtraTreesClassifier
fromsklearn.treeimportDecisionTreeClassifier
X,y=make_blobs(n_samples=10000,n_features=10,centers=100,random_state=0)

clf=DecisionTreeClassifier(max_depth=None,min_samples_split=2,random_state=0)
scores=cross_val_score(clf,X,y)
print(scores.mean())


clf=RandomForestClassifier(n_estimators=10,max_depth=None,min_samples_split=2,random_state=0)
scores=cross_val_score(clf,X,y)
print(scores.mean())

clf=ExtraTreesClassifier(n_estimators=10,max_depth=None,min_samples_split=2,random_state=0)
scores=cross_val_score(clf,X,y)
print(scores.mean())

运行结果：

0.979408793821
0.999607843137
0.999898989899

2.3Demo3-实现特征选择

#随机森林2
fromsklearn.treeimportDecisionTreeRegressor
fromsklearn.ensembleimportRandomForestRegressor
importnumpyasnp
fromsklearn.datasetsimportload_iris
iris=load_iris()

fromsklearn.model_selectionimportcross_val_score,ShuffleSplit
X=iris["data"]
Y=iris["target"]
names=iris["feature_names"]
rf=RandomForestRegressor()
scores=[]
foriinrange(X.shape[1]):
score=cross_val_score(rf,X[:,i:i+1],Y,scoring="r2",
cv=ShuffleSplit(len(X),3,.3))
scores.append((round(np.mean(score),3),names[i]))
print(sorted(scores,reverse=True))

运行结果：

[(0.89300000000000002,'petalwidth(cm)'),(0.82099999999999995,'petallength
(cm)'),(0.13,'sepallength(cm)'),(-0.79100000000000004,'sepalwidth(cm)')]

2.4demo4-随机森林

本来想利用以下代码来构建随机随机森林决策树，但是，遇到的问题是，程序一直在运行，无法响应，还需要调试。

#随机森林4
#coding:utf-8
importcsv
fromrandomimportseed
fromrandomimportrandrange
frommathimportsqrt
defloadCSV(filename):#加载数据，一行行的存入列表
dataSet=[]
withopen(filename,'r')asfile:
csvReader=csv.reader(file)
forlineincsvReader:
dataSet.append(line)
returndataSet

#除了标签列，其他列都转换为float类型
defcolumn_to_float(dataSet):
featLen=len(dataSet[0])-1
fordataindataSet:
forcolumninrange(featLen):
data[column]=float(data[column].strip())

#将数据集随机分成N块，方便交叉验证，其中一块是测试集，其他四块是训练集
defspiltDataSet(dataSet,n_folds):
fold_size=int(len(dataSet)/n_folds)
dataSet_copy=list(dataSet)
dataSet_spilt=[]
foriinrange(n_folds):
fold=[]
whilelen(fold)max_depth:
root['left']=decide_label(left)
root['right']=decide_label(right)
return
iflen(left)
2.5随机森林分类sonicdata
#CARTontheBankNotedataset
fromrandomimportseed
fromrandomimportrandrange
fromcsvimportreader

#LoadaCSVfile
defload_csv(filename):
file=open(filename,"r")
lines=reader(file)
dataset=list(lines)
returndataset

#Convertstringcolumntofloat
defstr_column_to_float(dataset,column):
forrowindataset:
row[column]=float(row[column].strip())

#Splitadatasetintokfolds
defcross_validation_split(dataset,n_folds):
dataset_split=list()
dataset_copy=list(dataset)
fold_size=int(len(dataset)/n_folds)
foriinrange(n_folds):
fold=list()
whilelen(fold)=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)
split(node['left'],max_depth,min_size,depth+1)
#processrightchild
iflen(right)<=min_size:
node['right']=to_terminal(right)
else:
node['right']=get_split(right)
split(node['right'],max_depth,min_size,depth+1)

#Buildadecisiontree
defbuild_tree(train,max_depth,min_size):
root=get_split(train)
split(root,max_depth,min_size,1)
returnroot

#Makeapredictionwithadecisiontree
defpredict(node,row):
ifrow[node['index']]
运行结果：
{'index':38,'value':0.0894}

{'index':36,'value':0.8459}

{'index':50,'value':0.0024}

{'index':15,'value':0.0906}

{'index':16,'value':0.9819}

{'index':10,'value':0.0785}

{'index':16,'value':0.0886}

{'index':38,'value':0.0621}

{'index':5,'value':0.0226}

{'index':8,'value':0.0368}

{'index':11,'value':0.0754}

{'index':0,'value':0.0239}

{'index':8,'value':0.0368}

{'index':29,'value':0.1671}

{'index':46,'value':0.0237}

{'index':38,'value':0.0621}

{'index':14,'value':0.0668}

{'index':4,'value':0.0167}

{'index':37,'value':0.0836}

{'index':12,'value':0.0616}

{'index':7,'value':0.0333}

{'index':33,'value':0.8741}

{'index':16,'value':0.0886}

{'index':8,'value':0.0368}

{'index':33,'value':0.0798}

{'index':44,'value':0.0298}

Scores:[48.78048780487805,70.73170731707317,58.536585365853654,51.2195121951

2195,39.02439024390244]

MeanAccuracy:53.659%

请按任意键继续...
知识点：


1.loadCSVfile
fromcsvimportreader
#LoadaCSVfile
defload_csv(filename):
file=open(filename,"r")
lines=reader(file)
dataset=list(lines)
returndataset
filename=r'G:\0pythonstudy\决策树\sonar.all-data.csv'
dataset=load_csv(filename)
print(dataset)


2.把数据转化成float格式
#Convertstringcolumntofloat
defstr_column_to_float(dataset,column):
forrowindataset:
row[column]=float(row[column].strip())
#print(row[column])
#convertstringattributestointegers
foriinrange(len(dataset[0])-1):
str_column_to_float(dataset,i)

3.把最后一列的分类字符串转化成0、1整数
defstr_column_to_int(dataset,column):
class_values=[row[column]forrowindataset]#生成一个classlabel的list
#print(class_values)
unique=set(class_values)#set获得list的不同元素
print(unique)
lookup=dict()#定义一个字典
#print(enumerate(unique))
fori,valueinenumerate(unique):
lookup[value]=i
#print(lookup)
forrowindataset:
row[column]=lookup[row[column]]
print(lookup['M'])

4、把数据集分割成K份
#Splitadatasetintokfolds
defcross_validation_split(dataset,n_folds):
dataset_split=list()#生成空列表
dataset_copy=list(dataset)
print(len(dataset_copy))
print(len(dataset))
#print(dataset_copy)
fold_size=int(len(dataset)/n_folds)
foriinrange(n_folds):
fold=list()
whilelen(fold)
5.计算正确率
#Calculateaccuracypercentage
defaccuracy_metric(actual,predicted):
correct=0
foriinrange(len(actual)):
ifactual[i]==predicted[i]:
correct+=1
returncorrect/float(len(actual))*100.0#这个是二值分类正确性的表达式
6.二分类每列
#Splitadatasetbasedonanattributeandanattributevalue
deftest_split(index,value,dataset):
left,right=list(),list()#初始化两个空列表
forrowindataset:
ifrow[index]
7.使用gini系数来获得最佳分割点
#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):
class_values=list(set(row[-1]forrowindataset))
b_index,b_value,b_score,b_groups=999,999,999,None
forindexinrange(len(dataset[0])-1):
forrowindataset:
groups=test_split(index,row[index],dataset)
gini=gini_index(groups,class_values)
ifgini
这段代码，在求gini指数，直接应用定义式，不难理解。获得最佳分割点可能比较难看懂，这里用了两层迭代，一层是对不同列的迭代，一层是对不同行的迭代。并且，每次迭代，都对gini系数进行更新。
8、决策树生成
#Createchildsplitsforanodeormaketerminal
defsplit(node,max_depth,min_size,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)
split(node['left'],max_depth,min_size,depth+1)
#processrightchild
iflen(right)<=min_size:
node['right']=to_terminal(right)
else:
node['right']=get_split(right)
split(node['right'],max_depth,min_size,depth+1)


这里使用了递归编程，不断生成左叉树和右叉树。
9.构建决策树
#Buildadecisiontree
defbuild_tree(train,max_depth,min_size):
root=get_split(train)
split(root,max_depth,min_size,1)
returnroot
tree=build_tree(train_set,max_depth,min_size)
print(tree)
10、预测test集
#Buildadecisiontree
defbuild_tree(train,max_depth,min_size):
root=get_split(train)#获得最好的分割点,下标值，groups
split(root,max_depth,min_size,1)
returnroot
#tree=build_tree(train_set,max_depth,min_size)
#print(tree)

#Makeapredictionwithadecisiontree
defpredict(node,row):
print(row[node['index']])
print(node['value'])
ifrow[node['index']]
11.评价决策树
#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
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持毛票票。

python实现随机森林random forest的原理及方法

热门推荐

随机推荐