def deserialize_random_forest(model_dict):
model = RandomForestClassifier(**model_dict['params'])
estimators = [deserialize_decision_tree(decision_tree) for decision_tree in model_dict['estimators_']]
model.estimators_ = np.array(estimators)
model.classes_ = np.array(model_dict['classes_'])
model.n_features_ = model_dict['n_features_']
model.n_outputs_ = model_dict['n_outputs_']
model.max_depth = model_dict['max_depth']
model.min_samples_split = model_dict['min_samples_split']
model.min_samples_leaf = model_dict['min_samples_leaf']
model.min_weight_fraction_leaf = model_dict['min_weight_fraction_leaf']
model.max_features = model_dict['max_features']
model.max_leaf_nodes = model_dict['max_leaf_nodes']
model.min_impurity_decrease = model_dict['min_impurity_decrease']
model.min_impurity_split = model_dict['min_impurity_split']
if 'oob_score_' in model_dict:
model.oob_score_ = model_dict['oob_score_']
if 'oob_decision_function_' in model_dict:
model.oob_decision_function_ = model_dict['oob_decision_function_']
if isinstance(model_dict['n_classes_'], list):
model.n_classes_ = np.array(model_dict['n_classes_'])
else:
model.n_classes_ = model_dict['n_classes_']
return model
def RFC(x_train,y_train,x_test,udf_trees=100,udf_max_features='auto', udf_min_samples=50, do_CV=False,names=None):
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import roc_auc_score
if do_CV:
param_grid = {'max_features': [2,3,4],
'min_samples_leaf':[50,250,1000,2500]}
est=RandomForestClassifier(n_estimators=100,verbose=1)
cv_scores=list()
params_list=list()
start = time()
for mfeatures in param_grid['max_features']:
for minSamples in param_grid['min_samples_leaf']:
print 'Trying parameter combination: (MaxFeatures=%i, minSamples=%i)' % (mfeatures,minSamples)
est.min_samples_leaf=minSamples
est.max_features=mfeatures
cv_score=udf.cross_val_score_proba(x_train,y_train,5,est)
cv_scores.append(np.mean(cv_score))
### Create the labels for display purposes ###
params_list.append((mfeatures,minSamples))
print 'Took %.2f seconds for parameter tuning.' %(time()-start)
print 'writing CV results to file...'
results = np.array([params_list,cv_scores]).T ## should have 48 results...
print 'Parameter tuning results........'
print 'Parameters (max_features, min_samples_leaf), CV_Scores'
for i in range(len(results)):
print results[i]
else:
### Train the RFC Classifier with the optimal parameters found above ###
print 'Fitting Random Forest with optimal user-defined parameters....'
est=RandomForestClassifier(n_estimators=udf_trees, max_features=udf_max_features,min_samples_leaf=udf_min_samples,verbose=1)
est.fit(x_train,y_train)
y_pred=est.predict_proba(x_test)[:,1] ## Must predict probability!! ##
### Plot feature importances ###
plot_feature_importance(est, names)
print 'Writing submission file....'
with open('RFC_Submission.csv','wb') as testfile:
w=csv.writer(testfile)
w.writerow(('Id','Probability'))
for i in range(len(y_pred)):
w.writerow(((i+1),y_pred[i]))
testfile.close()
print 'File written to disk...'
dpi=300,
transparent=True)
plt.tight_layout()
plt.show()
# ### Accuracy vs. Maximum features
# In[18]:
rf = RandomForestClassifier(n_estimators=500,
max_features=min(10, n_feature),
random_state=42,
max_depth=5)
res = []
for i in range(1, X_train.shape[1] + 1):
rf.max_features = i
rf.fit(X_train, y_train)
d = dict({'max_features': i})
d.update({'train': rf.score(X_train, y_train)})
d.update({'test': rf.score(X_test, y_test)})
res.append(d)
res = pd.DataFrame(res)
res.plot('max_features')
plt.ylabel('Accuracy')
plt.xlabel('Maximum Number of Features selected')
plt.legend(loc='center left',
bbox_to_anchor=(1, 0.5),
title='Dataset',
fancybox=False)
plt.savefig('RF_accuracy_number_of_features.png', dpi=300, transparent=True)
plt.tight_layout()
