面向对象从视频上扒拉的决策树应付作业

决策树实现的小例子

# pylint: disable=no-member
import torch
from sklearn import tree
from sklearn.datasets import load_wine
from sklearn.model_selection import train_test_split
import pandas as pd
import graphviz
import matplotlib.pyplot as plt

wine1=load_wine()
print(wine1.data.shape)

print(pd.concat([pd.DataFrame(wine1.data),pd.DataFrame(wine1.target)],axis=1))
print(wine1.feature_names)
print(wine1.target_names)

x_train,x_test,y_train,y_test =train_test_split(wine1.data,
                                                wine1.target,test_size=0.2)

print(x_train.shape,x_test.shape,y_train.shape,y_test.shape)

# 模型主干部分
clf=tree.DecisionTreeClassifier(criterion='gini'
                               ,splitter='random'
                               ,max_depth=4
                               ,min_samples_split=15)#gini   entropy
# (random_state)降低随机性，最后得分不变
# (splitter) best and random
# max_depth
# min_samples_leaf =10 这个节点不能小于10
# min_samples_split  至少有25，才能分裂出子节点
clf=clf.fit(x_train,y_train)
score = clf.score(x_test,y_test)
print("*"*100)
print("score：{}".format(score))
print("*"*100)

dot_data = tree.export_graphviz(clf
                                ,class_names=['0:琴酒','1:苦艾酒','2:雪莉']
                                ,filled=True
                                ,rounded=True
                               )
graph = graphviz.Source(dot_data)
graph.render('test-output/round-table.gv', view=True)
# plt.imshow(graph)
# print(dot_data)
print(graph)


print([*zip(wine1.feature_names,clf.feature_importances_)])
''' 
# 可视化调参，遍历法调参可以试一下
test = []
for i in range(10):
    clf=tree.DecisionTreeClassifier(criterion='entropy'#gini   entropy
                               ,splitter='random'
                               ,max_depth=i+1
                               ,min_samples_split=15)
# (random_state)降低随机性，最后得分不变
# (splitter) best and random
# max_depth
# min_samples_leaf =10 这个节点不能小于10
# min_samples_split  至少有25，才能分裂出子节点
    clf=clf.fit(x_train,y_train)
    score = clf.score(x_test,y_test)
    test.append(score)
plt.plot(range(1,11),test,color="r",label="max_depth")
plt.legend()
plt.show() '''

# apply返回每个测试样本所在的叶子节点的索引
# preidict返回每个测试样本的分类结果
print("*"*100)
print(clf.apply(x_test))
# print(clf.preidict(x_test))

调参,应该来说可视化会舒服一些，不过也建议能画三维图，同时两个参数变量，应该会更好些。当然后续我会再写一个回归的例子，尽量用到网格搜索和交叉验证，感兴趣的话可以一起学习一下。
网格搜索的例子：

 from sklearn.model_selection import RandomizedSearchCV   #随机搜索交叉验证
 
# Number of trees in random forest
n_estimators = [int(x) for x in np.linspace(start = 100, stop = 2000, num = 10)]
# Number of features to consider at every split  
max_features = ['auto', 'sqrt']
# Maximum number of levels in tree   最大树深
max_depth = [int(x) for x in np.linspace(4, 164, num = 4)]
# max_depth.append(None)

# Minimum number of samples required to split a node 最小不分裂样本数
min_samples_split = [2, 4, 6 ,8,10]
# Minimum number of samples required at each leaf node
min_samples_leaf = [ 2, 4, 6 ,8,10]
# Method of selecting samples for training each tree
bootstrap = [True, False]

 
# Create the random grid
random_grid = {'n_estimators': n_estimators,
               'max_features': max_features,
               'max_depth': max_depth,
               'min_samples_split': min_samples_split,
               'min_samples_leaf': min_samples_leaf,
               'bootstrap': bootstrap}
 
# Use the random grid to search for best hyperparameters
# First create the base model to tune
rf = RandomForestRegressor()
# Random search of parameters, using 3 fold cross validation, 
# search across 100 different combinations, and use all available cores
# 随机选择参数100次
rf_random = RandomizedSearchCV(estimator=rf, param_distributions=random_grid,
                              n_iter = 1000, scoring='neg_mean_absolute_error', 
                              cv = 5, verbose=2, random_state=30, n_jobs=-1)
 
# Fit the random search model
rf_random.fit(x_train, y_train);
print(rf_random.best_params_)

def evaluate(model, test_features , test_labels):
    predictions = model.predict(test_features)
    errors = abs(predictions - test_labels)
    mape = 100 * np.mean(errors / test_labels)
    accuracy = 100 - mape
    print('Model Performance')
    print('Average Error: {:0.4f} degrees.'.format(np.mean(errors)))
    print('Accuracy = {:0.2f}%.'.format(accuracy))

best_random = rf_random.best_estimator_
evaluate(best_random, x_test, y_test)

决策树样子：

等大佬提建议，解决中文乱码，睡觉，顶不住了。

-------------本文结束感谢您的阅读-------------

赏

谢谢你请我喝咖啡

支付宝

微信