做购物网站哪种服务器好,好一点的网站是怎么做的,深圳做物流网站,wordpress自媒体博客模板文章目录 决策树1 创建数据2 定义香农信息熵3 条件熵4 信息增益5 计算所有特征的信息增益#xff0c;选择最优最大信息增益的特征返回6 利用ID3算法生成决策树7 利用数据构造一颗决策树Scikit-learn实例决策树分类决策树回归Scikit-learn 的决策树参数决策树调参 实验1 通过sk… 文章目录 决策树1 创建数据2 定义香农信息熵3 条件熵4 信息增益5 计算所有特征的信息增益选择最优最大信息增益的特征返回6 利用ID3算法生成决策树7 利用数据构造一颗决策树Scikit-learn实例决策树分类决策树回归Scikit-learn 的决策树参数决策树调参 实验1 通过sklearn来做breast_cancer数据集的决策树分类器训练准备数据训练模型测试模型 实验2 构造下面的数据并调用前面手写代码实现决策树分类器采用下面的样本进行测试 决策树
1分类决策树模型是表示基于特征对实例进行分类的树形结构。决策树可以转换成一个if-then规则的集合也可以看作是定义在特征空间划分上的类的条件概率分布。
2决策树学习旨在构建一个与训练数据拟合很好并且复杂度小的决策树。因为从可能的决策树中直接选取最优决策树是NP完全问题。现实中采用启发式方法学习次优的决策树。
决策树学习算法包括3部分特征选择、树的生成和树的剪枝。常用的算法有ID3、C4.5和CART。
3特征选择的目的在于选取对训练数据能够分类的特征。特征选择的关键是其准则。常用的准则如下
1样本集合 D D D对特征 A A A的信息增益ID3 g ( D , A ) H ( D ) − H ( D ∣ A ) g(D, A)H(D)-H(D|A) g(D,A)H(D)−H(D∣A) H ( D ) − ∑ k 1 K ∣ C k ∣ ∣ D ∣ log 2 ∣ C k ∣ ∣ D ∣ H(D)-\sum_{k1}^{K} \frac{\left|C_{k}\right|}{|D|} \log _{2} \frac{\left|C_{k}\right|}{|D|} H(D)−k1∑K∣D∣∣Ck∣log2∣D∣∣Ck∣ H ( D ∣ A ) ∑ i 1 n ∣ D i ∣ ∣ D ∣ H ( D i ) H(D | A)\sum_{i1}^{n} \frac{\left|D_{i}\right|}{|D|} H\left(D_{i}\right) H(D∣A)i1∑n∣D∣∣Di∣H(Di)
其中 H ( D ) H(D) H(D)是数据集 D D D的熵 H ( D i ) H(D_i) H(Di)是数据集 D i D_i Di的熵 H ( D ∣ A ) H(D|A) H(D∣A)是数据集 D D D对特征 A A A的条件熵。 D i D_i Di是 D D D中特征 A A A取第 i i i个值的样本子集 C k C_k Ck是 D D D中属于第 k k k类的样本子集。 n n n是特征 A A A取 值的个数 K K K是类的个数。
2样本集合 D D D对特征 A A A的信息增益比C4.5 g R ( D , A ) g ( D , A ) H ( D ) g_{R}(D, A)\frac{g(D, A)}{H(D)} gR(D,A)H(D)g(D,A)
其中 g ( D , A ) g(D,A) g(D,A)是信息增益 H ( D ) H(D) H(D)是数据集 D D D的熵。
3样本集合 D D D的基尼指数CART Gini ( D ) 1 − ∑ k 1 K ( ∣ C k ∣ ∣ D ∣ ) 2 \operatorname{Gini}(D)1-\sum_{k1}^{K}\left(\frac{\left|C_{k}\right|}{|D|}\right)^{2} Gini(D)1−k1∑K(∣D∣∣Ck∣)2
特征 A A A条件下集合 D D D的基尼指数 Gini ( D , A ) ∣ D 1 ∣ ∣ D ∣ Gini ( D 1 ) ∣ D 2 ∣ ∣ D ∣ Gini ( D 2 ) \operatorname{Gini}(D, A)\frac{\left|D_{1}\right|}{|D|} \operatorname{Gini}\left(D_{1}\right)\frac{\left|D_{2}\right|}{|D|} \operatorname{Gini}\left(D_{2}\right) Gini(D,A)∣D∣∣D1∣Gini(D1)∣D∣∣D2∣Gini(D2)
4决策树的生成。通常使用信息增益最大、信息增益比最大或基尼指数最小作为特征选择的准则。决策树的生成往往通过计算信息增益或其他指标从根结点开始递归地产生决策树。这相当于用信息增益或其他准则不断地选取局部最优的特征或将训练集分割为能够基本正确分类的子集。
5决策树的剪枝。由于生成的决策树存在过拟合问题需要对它进行剪枝以简化学到的决策树。决策树的剪枝往往从已生成的树上剪掉一些叶结点或叶结点以上的子树并将其父结点或根结点作为新的叶结点从而简化生成的决策树。
import numpy as np
import pandas as pd
import math
from math import log1 创建数据
def create_data():datasets [[青年, 否, 否, 一般, 否],[青年, 否, 否, 好, 否],[青年, 是, 否, 好, 是],[青年, 是, 是, 一般, 是],[青年, 否, 否, 一般, 否],[中年, 否, 否, 一般, 否],[中年, 否, 否, 好, 否],[中年, 是, 是, 好, 是],[中年, 否, 是, 非常好, 是],[中年, 否, 是, 非常好, 是],[老年, 否, 是, 非常好, 是],[老年, 否, 是, 好, 是],[老年, 是, 否, 好, 是],[老年, 是, 否, 非常好, 是],[老年, 否, 否, 一般, 否],]labels [u年龄, u有工作, u有自己的房子, u信贷情况, u类别]# 返回数据集和每个维度的名称return datasets, labelsdatasets, labels create_data()train_data pd.DataFrame(datasets, columnslabels)train_data年龄有工作有自己的房子信贷情况类别0青年否否一般否1青年否否好否2青年是否好是3青年是是一般是4青年否否一般否5中年否否一般否6中年否否好否7中年是是好是8中年否是非常好是9中年否是非常好是10老年否是非常好是11老年否是好是12老年是否好是13老年是否非常好是14老年否否一般否
2 定义香农信息熵
def calc_ent(datasets):data_length len(datasets)label_count {}for i in range(data_length):label datasets[i][-1]if label not in label_count:label_count[label] 0label_count[label] 1ent -sum([(p / data_length) * log(p / data_length, 2)for p in label_count.values()])return ent3 条件熵
def cond_ent(datasets, axis0):data_length len(datasets)feature_sets {}for i in range(data_length):feature datasets[i][axis]if feature not in feature_sets:feature_sets[feature] []feature_sets[feature].append(datasets[i])cond_ent sum([(len(p) / data_length) * calc_ent(p)for p in feature_sets.values()])return cond_entcalc_ent(datasets)0.97095059445466864 信息增益
def info_gain(ent, cond_ent):return ent - cond_ent5 计算所有特征的信息增益选择最优最大信息增益的特征返回
def info_gain_train(datasets):count len(datasets[0]) - 1ent calc_ent(datasets)best_feature []for c in range(count):c_info_gain info_gain(ent, cond_ent(datasets, axisc))best_feature.append((c, c_info_gain))print(特征({}) 的信息增益为 {:.3f}.format(labels[c], c_info_gain))# 比较大小best_ max(best_feature, keylambda x: x[-1])return 特征({})的信息增益最大选择为根节点特征.format(labels[best_[0]])info_gain_train(np.array(datasets))特征(年龄) 的信息增益为 0.083
特征(有工作) 的信息增益为 0.324
特征(有自己的房子) 的信息增益为 0.420
特征(信贷情况) 的信息增益为 0.363特征(有自己的房子)的信息增益最大选择为根节点特征6 利用ID3算法生成决策树
# 定义节点类 二叉树
class Node:def __init__(self, rootTrue, labelNone, feature_nameNone, featureNone):self.root rootself.label labelself.feature_name feature_nameself.feature featureself.tree {}self.result {label:: self.label,feature: self.feature,tree: self.tree}def __repr__(self):return {}.format(self.result)def add_node(self, val, node):self.tree[val] nodedef predict(self, features):if self.root is True:return self.labelcurrent_treeself.tree[features[self.feature]]features.pop(self.feature)return current_tree.predict(features)class DTree:def __init__(self, epsilon0.1):self.epsilon epsilonself._tree {}# 熵staticmethoddef calc_ent(datasets):data_length len(datasets)label_count {}for i in range(data_length):label datasets[i][-1]if label not in label_count:label_count[label] 0label_count[label] 1ent -sum([(p / data_length) * log(p / data_length, 2) for p in label_count.values()])return ent# 经验条件熵def cond_ent(self, datasets, axis0):data_length len(datasets)feature_sets {}for i in range(data_length):feature datasets[i][axis]if feature not in feature_sets:feature_sets[feature] []feature_sets[feature].append(datasets[i])cond_ent sum([(len(p) / data_length) * self.calc_ent(p) for p in feature_sets.values()])return cond_ent# 信息增益staticmethoddef info_gain(ent, cond_ent):return ent - cond_entdef info_gain_train(self, datasets):count len(datasets[0]) - 1ent self.calc_ent(datasets)best_feature []for c in range(count):c_info_gain self.info_gain(ent, self.cond_ent(datasets, axisc))best_feature.append((c, c_info_gain))# 比较大小best_ max(best_feature, keylambda x: x[-1])return best_def train(self, train_data):input:数据集D(DataFrame格式)特征集A阈值etaoutput:决策树T_, y_train, features train_data.iloc[:,:-1], train_data.iloc[:,-1], train_data.columns[:-1]# 1,若D中实例属于同一类Ck则T为单节点树并将类Ck作为结点的类标记返回Tif len(y_train.value_counts()) 1:return Node(rootTrue, labely_train.iloc[0])# 2, 若A为空则T为单节点树将D中实例树最大的类Ck作为该节点的类标记返回Tif len(features) 0:return Node(rootTrue,labely_train.value_counts().sort_values(ascendingFalse).index[0])# 3,计算最大信息增益 同5.1,Ag为信息增益最大的特征max_feature, max_info_gain self.info_gain_train(np.array(train_data))max_feature_name features[max_feature]# 4,Ag的信息增益小于阈值eta,则置T为单节点树并将D中是实例数最大的类Ck作为该节点的类标记返回Tif max_info_gain self.epsilon:return Node(rootTrue,labely_train.value_counts().sort_values(ascendingFalse).index[0])# 5,构建Ag子集node_tree Node(rootFalse, feature_namemax_feature_name, featuremax_feature)feature_list train_data[max_feature_name].value_counts().indexfor f in feature_list:sub_train_df train_data.loc[train_data[max_feature_name] f].drop([max_feature_name], axis1)# 6, 递归生成树sub_tree self.train(sub_train_df)node_tree.add_node(f, sub_tree)return node_treedef fit(self, train_data):self._tree self.train(train_data)return self._treedef predict(self, X_test):return self._tree.predict(X_test)7 利用数据构造一颗决策树
datasets, labels create_data()
data_df pd.DataFrame(datasets, columnslabels)
dt DTree()
tree dt.fit(data_df)data_df年龄有工作有自己的房子信贷情况类别0青年否否一般否1青年否否好否2青年是否好是3青年是是一般是4青年否否一般否5中年否否一般否6中年否否好否7中年是是好是8中年否是非常好是9中年否是非常好是10老年否是非常好是11老年否是好是12老年是否好是13老年是否非常好是14老年否否一般否
tree{label:: None, feature: 2, tree: {否: {label:: None, feature: 1, tree: {否: {label:: 否, feature: None, tree: {}}, 是: {label:: 是, feature: None, tree: {}}}}, 是: {label:: 是, feature: None, tree: {}}}}有无房子否 是 ↓ ↓有无工作 是否 是↓ ↓否 是tree.predict([老年, 否, 否, 一般])否datasets[[青年, 否, 否, 一般, 否],[青年, 否, 否, 好, 否],[青年, 是, 否, 好, 是],[青年, 是, 是, 一般, 是],[青年, 否, 否, 一般, 否],[中年, 否, 否, 一般, 否],[中年, 否, 否, 好, 否],[中年, 是, 是, 好, 是],[中年, 否, 是, 非常好, 是],[中年, 否, 是, 非常好, 是],[老年, 否, 是, 非常好, 是],[老年, 否, 是, 好, 是],[老年, 是, 否, 好, 是],[老年, 是, 否, 非常好, 是],[老年, 否, 否, 一般, 否]]labels[年龄, 有工作, 有自己的房子, 信贷情况, 类别]dt.predict([老年, 否, 否, 一般])否Scikit-learn实例
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from collections import Counter使用Iris数据集我们可以构建如下树
# data
def create_data():iris load_iris()df pd.DataFrame(iris.data, columnsiris.feature_names)df[label] iris.targetdf.columns [sepal length, sepal width, petal length, petal width, label]data np.array(df.iloc[:100, [0, 1, -1]])# print(data)return data[:, :2], data[:, -1],iris.feature_names[0:2]X, y,feature_name create_data()
X, y,feature_name(array([[5.1, 3.5],[4.9, 3. ],[4.7, 3.2],[4.6, 3.1],[5. , 3.6],[5.4, 3.9],[4.6, 3.4],[5. , 3.4],[4.4, 2.9],[4.9, 3.1],[5.4, 3.7],[4.8, 3.4],[4.8, 3. ],[4.3, 3. ],[5.8, 4. ],[5.7, 4.4],[5.4, 3.9],[5.1, 3.5],[5.7, 3.8],[5.1, 3.8],[5.4, 3.4],[5.1, 3.7],[4.6, 3.6],[5.1, 3.3],[4.8, 3.4],[5. , 3. ],[5. , 3.4],[5.2, 3.5],[5.2, 3.4],[4.7, 3.2],[4.8, 3.1],[5.4, 3.4],[5.2, 4.1],[5.5, 4.2],[4.9, 3.1],[5. , 3.2],[5.5, 3.5],[4.9, 3.6],[4.4, 3. ],[5.1, 3.4],[5. , 3.5],[4.5, 2.3],[4.4, 3.2],[5. , 3.5],[5.1, 3.8],[4.8, 3. ],[5.1, 3.8],[4.6, 3.2],[5.3, 3.7],[5. , 3.3],[7. , 3.2],[6.4, 3.2],[6.9, 3.1],[5.5, 2.3],[6.5, 2.8],[5.7, 2.8],[6.3, 3.3],[4.9, 2.4],[6.6, 2.9],[5.2, 2.7],[5. , 2. ],[5.9, 3. ],[6. , 2.2],[6.1, 2.9],[5.6, 2.9],[6.7, 3.1],[5.6, 3. ],[5.8, 2.7],[6.2, 2.2],[5.6, 2.5],[5.9, 3.2],[6.1, 2.8],[6.3, 2.5],[6.1, 2.8],[6.4, 2.9],[6.6, 3. ],[6.8, 2.8],[6.7, 3. ],[6. , 2.9],[5.7, 2.6],[5.5, 2.4],[5.5, 2.4],[5.8, 2.7],[6. , 2.7],[5.4, 3. ],[6. , 3.4],[6.7, 3.1],[6.3, 2.3],[5.6, 3. ],[5.5, 2.5],[5.5, 2.6],[6.1, 3. ],[5.8, 2.6],[5. , 2.3],[5.6, 2.7],[5.7, 3. ],[5.7, 2.9],[6.2, 2.9],[5.1, 2.5],[5.7, 2.8]]),array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1.,1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.]),[sepal length (cm), sepal width (cm)])X_train, X_test, y_train, y_test train_test_split(X, y, test_size0.3)X_train.shape, X_test.shape, y_train.shape, y_test.shape((70, 2), (30, 2), (70,), (30,))决策树分类
from sklearn.tree import DecisionTreeClassifier
from sklearn.tree import export_graphviz
import graphviz
#1 导入相关包
from sklearn import tree
#2 构建一个决策树分类器模型
clf DecisionTreeClassifier(criterionentropy)
#3 采用数据来构建决策树
clf.fit(X_train, y_train)
#4 对决策树模型进行测试
clf.score(X_test, y_test)0.9一旦经过训练就可以用 plot_tree函数绘制树
tree.plot_tree(clf) [Text(0.6, 0.9, X[1] 3.15\nentropy 0.998\nsamples 70\nvalue [37, 33]),Text(0.4, 0.7, X[0] 4.95\nentropy 0.639\nsamples 37\nvalue [6, 31]),Text(0.3, 0.5, X[1] 2.7\nentropy 0.592\nsamples 7\nvalue [6, 1]),Text(0.2, 0.3, X[0] 4.7\nentropy 1.0\nsamples 2\nvalue [1, 1]),Text(0.1, 0.1, entropy 0.0\nsamples 1\nvalue [1, 0]),Text(0.3, 0.1, entropy 0.0\nsamples 1\nvalue [0, 1]),Text(0.4, 0.3, entropy 0.0\nsamples 5\nvalue [5, 0]),Text(0.5, 0.5, entropy 0.0\nsamples 30\nvalue [0, 30]),Text(0.8, 0.7, X[0] 6.05\nentropy 0.33\nsamples 33\nvalue [31, 2]),Text(0.7, 0.5, entropy 0.0\nsamples 31\nvalue [31, 0]),Text(0.9, 0.5, entropy 0.0\nsamples 2\nvalue [0, 2])]也可以导出树
tree_pic export_graphviz(clf, out_filemytree.pdf)
with open(mytree.pdf) as f:dot_graph f.read()或者还可以使用函数 export_text以文本格式导出树。此方法不需要安装外部库而且更紧凑
from sklearn.tree import export_textr export_text(clf)print(r)|--- feature_1 3.15
| |--- feature_0 4.95
| | |--- feature_1 2.70
| | | |--- feature_0 4.70
| | | | |--- class: 0.0
| | | |--- feature_0 4.70
| | | | |--- class: 1.0
| | |--- feature_1 2.70
| | | |--- class: 0.0
| |--- feature_0 4.95
| | |--- class: 1.0
|--- feature_1 3.15
| |--- feature_0 6.05
| | |--- class: 0.0
| |--- feature_0 6.05
| | |--- class: 1.0决策树回归
import numpy as np
from sklearn.tree import DecisionTreeRegressor
import matplotlib.pyplot as pltrng np.random.RandomState(1)
rngRandomState(MT19937) at 0x1AD2E576840X np.sort(5 * rng.rand(80, 1), axis0)# Create a random dataset
rng np.random.RandomState(1)
X np.sort(5 * rng.rand(80, 1), axis0)
y np.sin(X).ravel()
y[::5] 3 * (0.5 - rng.rand(16))X.shape,y.shape((80, 1), (80,))X_test np.arange(0.0, 5.0, 0.01)[:, np.newaxis]X_test.shape(500, 1)# Fit regression model
regr_1 DecisionTreeRegressor(max_depth2)
regr_2 DecisionTreeRegressor(max_depth5)
regr_1.fit(X, y)
regr_2.fit(X, y)# Predict
X_test np.arange(0.0, 5.0, 0.01)[:, np.newaxis]
y_1 regr_1.predict(X_test)
y_2 regr_2.predict(X_test)# Plot the results
plt.figure()
plt.scatter(X, y, s20, edgecolorblack, cdarkorange, labeldata)
plt.plot(X_test, y_1, colorcornflowerblue, labelmax_depth2, linewidth2)
plt.plot(X_test, y_2, coloryellowgreen, labelmax_depth5, linewidth2)
plt.xlabel(data)
plt.ylabel(target)
plt.title(Decision Tree Regression)
plt.legend()
plt.show()Scikit-learn 的决策树参数
DecisionTreeClassifier(criterion“gini”, splitter“best”, max_depthNone, min_samples_split2, min_samples_leaf1, min_weight_fraction_leaf0., max_featuresNone, random_stateNone, max_leaf_nodesNone, min_impurity_decrease0., min_impurity_splitNone, class_weightNone, presortFalse)
参数含义
criterion:string, optional (default“gini”) (1).criterion‘gini’,分裂节点时评价准则是Gini指数。 (2).criterion‘entropy’,分裂节点时的评价指标是信息增益。max_depth:int or None, optional (defaultNone)。指定树的最大深度。 如果为None表示树的深度不限。直到所有的叶子节点都是纯净的即叶子节点 中所有的样本点都属于同一个类别。或者每个叶子节点包含的样本数小于min_samples_split。splitter:string, optional (default“best”)。指定分裂节点时的策略。 (1).splitter‘best’,表示选择最优的分裂策略。 (2).splitter‘random’,表示选择最好的随机切分策略。min_samples_split:int, float, optional (default2)。表示分裂一个内部节点需要的做少样本数。 (1).如果为整数则min_samples_split就是最少样本数。 (2).如果为浮点数(0到1之间)则每次分裂最少样本数为ceil(min_samples_split * n_samples)min_samples_leaf: int, float, optional (default1)。指定每个叶子节点需要的最少样本数。 (1).如果为整数则min_samples_split就是最少样本数。 (2).如果为浮点数(0到1之间)则每个叶子节点最少样本数为ceil(min_samples_leaf * n_samples)min_weight_fraction_leaf:float, optional (default0.) 指定叶子节点中样本的最小权重。max_features:int, float, string or None, optional (defaultNone). 搜寻最佳划分的时候考虑的特征数量。 (1).如果为整数每次分裂只考虑max_features个特征。 (2).如果为浮点数(0到1之间)每次切分只考虑int(max_features * n_features)个特征。 (3).如果为’auto’或者’sqrt’,则每次切分只考虑sqrt(n_features)个特征 (4).如果为’log2’,则每次切分只考虑log2(n_features)个特征。 (5).如果为None,则每次切分考虑n_features个特征。 (6).如果已经考虑了max_features个特征但还是没有找到一个有效的切分那么还会继续寻找 下一个特征直到找到一个有效的切分为止。random_state:int, RandomState instance or None, optional (defaultNone) (1).如果为整数则它指定了随机数生成器的种子。 (2).如果为RandomState实例则指定了随机数生成器。 (3).如果为None则使用默认的随机数生成器。max_leaf_nodes: int or None, optional (defaultNone)。指定了叶子节点的最大数量。 (1).如果为None,叶子节点数量不限。 (2).如果为整数则max_depth被忽略。min_impurity_decrease:float, optional (default0.) 如果节点的分裂导致不纯度的减少(分裂后样本比分裂前更加纯净)大于或等于min_impurity_decrease则分裂该节点。 加权不纯度的减少量计算公式为 min_impurity_decreaseN_t / N * (impurity - N_t_R / N_t * right_impurity - N_t_L / N_t * left_impurity) 其中N是样本的总数N_t是当前节点的样本数N_t_L是分裂后左子节点的样本数 N_t_R是分裂后右子节点的样本数。impurity指当前节点的基尼指数right_impurity指 分裂后右子节点的基尼指数。left_impurity指分裂后左子节点的基尼指数。min_impurity_split:float 树生长过程中早停止的阈值。如果当前节点的不纯度高于阈值节点将分裂否则它是叶子节点。 这个参数已经被弃用。用min_impurity_decrease代替了min_impurity_split。class_weight:dict, list of dicts, “balanced” or None, defaultNone 类别权重的形式为{class_label: weight} (1).如果没有给出每个类别的权重则每个类别的权重都为1。 (2).如果class_weight‘balanced’则分类的权重与样本中每个类别出现的频率成反比。 计算公式为n_samples / (n_classes * np.bincount(y)) (3).如果sample_weight提供了样本权重(由fit方法提供)则这些权重都会乘以sample_weight。presort:bool, optional (defaultFalse) 指定是否需要提前排序数据从而加速训练中寻找最优切分的过程。设置为True时对于大数据集 会减慢总体的训练过程但是对于一个小数据集或者设定了最大深度的情况下会加速训练过程。
决策树调参
# 导入库
from sklearn.tree import DecisionTreeClassifier
from sklearn import datasets
from sklearn.model_selection import train_test_split
import matplotlib.pyplot as plt
from sklearn.model_selection import GridSearchCV
from sklearn.tree import DecisionTreeRegressor
from sklearn import metrics# 导入数据集
X datasets.load_iris() # 以全部字典形式返回,有data,target,target_names三个键
data X.data
target X.target
name X.target_names
x, y datasets.load_iris(return_X_yTrue) # 能一次性取前2个
print(x.shape, y.shape)(150, 4) (150,)# 数据分为训练集和测试集
x_train, x_test, y_train, y_test train_test_split(x,y,test_size0.2,random_state100)# 用GridSearchCV寻找最优参数字典
param {criterion: [gini],max_depth: [30, 50, 60, 100],min_samples_leaf: [2, 3, 5, 10],min_impurity_decrease: [0.1, 0.2, 0.5]
}
grid GridSearchCV(DecisionTreeClassifier(), param_gridparam, cv6)
grid.fit(x_train, y_train)
print(最优分类器:, grid.best_params_, 最优分数:, grid.best_score_) # 得到最优的参数和分值最优分类器: {criterion: gini, max_depth: 50, min_impurity_decrease: 0.2, min_samples_leaf: 10} 最优分数: 0.9416666666666665param {criterion: [gini,entropy],max_depth: [30, 50, 60, 100,80],min_samples_leaf: [2, 3, 5, 10],min_impurity_decrease: [0.1, 0.2, 0.5,0.8],splitter:[random,best]
}
gridGridSearchCV(DecisionTreeClassifier(),param_gridparam,cv5)
grid.fit(x_train,y_train)
print(grid.best_params_,grid.best_score_,grid.n_splits_){criterion: entropy, max_depth: 50, min_impurity_decrease: 0.1, min_samples_leaf: 10, splitter: random} 0.95 5实验1 通过sklearn来做breast_cancer数据集的决策树分类器训练
准备数据
from sklearn.datasets import load_breast_cancer
bst load_breast_cancer()
databst.databst.feature_namesarray([mean radius, mean texture, mean perimeter, mean area,mean smoothness, mean compactness, mean concavity,mean concave points, mean symmetry, mean fractal dimension,radius error, texture error, perimeter error, area error,smoothness error, compactness error, concavity error,concave points error, symmetry error,fractal dimension error, worst radius, worst texture,worst perimeter, worst area, worst smoothness,worst compactness, worst concavity, worst concave points,worst symmetry, worst fractal dimension], dtypeU23)data.shape(569, 30)xdata[:,:2]labelsbst.feature_names[:2]
labels array([mean radius, mean texture], dtypeU23)ybst.targetdatasetsnp.insert(x,x.shape[1],y,axis1)
datasets.shape(569, 3)data_df pd.DataFrame(datasets,columns[mean radius, mean texture,结果])
data_dfmean radiusmean texture结果017.9910.380.0120.5717.770.0219.6921.250.0311.4220.380.0420.2914.340.0............56421.5622.390.056520.1328.250.056616.6028.080.056720.6029.330.05687.7624.541.0
569 rows × 3 columns
# 数据分为训练集和测试集
X_train, X_test, y_train, y_test train_test_split(x, y, test_size0.3)X_train.shape,X_test.shape,y_train.shape,y_test.shape((398, 2), (171, 2), (398,), (171,))训练模型
from sklearn.tree import DecisionTreeClassifier
from sklearn.tree import export_graphviz
import graphviz
clf DecisionTreeClassifier(criterionentropy)
clf.fit(X_train, y_train)DecisionTreeClassifier(criterionentropy)测试模型
#4 对决策树模型进行测试
clf.score(X_test, y_test)0.8713450292397661实验2 构造下面的数据并调用前面手写代码实现决策树分类器 def create_demo():datasets[[sunny,hot,high,False,No],[sunny,hot,high,True,No],[overcast,hot,high,False,Yes],[rain,mild,high,False,Yes],[rain,cool,normal,False,Yes],[rain,cool,normal,True,No],[overcast,cool,normal,True,Yes],[sunny,mild,high,False,No],[sunny,cool,normal,False,Yes],[rain,mild,normal,True,Yes],[sunny,mild,normal,False,Yes],[overcast,mild,high,True,Yes],[overcast,hot,normal,False,Yes],[rain,mild,high,True,No]]labels[Outlook,Temperature,Humidity,Windy,Play]return datasets,labelsdatasets,labelscreate_demo()
data_df pd.DataFrame(datasets,columnslabels)
data_dfOutlookTemperatureHumidityWindyPlay0sunnyhothighFalseNo1sunnyhothighTrueNo2overcasthothighFalseYes3rainmildhighFalseYes4raincoolnormalFalseYes5raincoolnormalTrueNo6overcastcoolnormalTrueYes7sunnymildhighFalseNo8sunnycoolnormalFalseYes9rainmildnormalTrueYes10sunnymildnormalFalseYes11overcastmildhighTrueYes12overcasthotnormalFalseYes13rainmildhighTrueNo
train_datapd.DataFrame(datasets,columnslabels)dt DTree()
tree dt.fit(data_df)tree{label:: None, feature: 0, tree: {sunny: {label:: None, feature: 1, tree: {high: {label:: No, feature: None, tree: {}}, normal: {label:: Yes, feature: None, tree: {}}}}, rain: {label:: None, feature: 2, tree: {True: {label:: None, feature: 0, tree: {mild: {label:: None, feature: 0, tree: {normal: {label:: Yes, feature: None, tree: {}}, high: {label:: No, feature: None, tree: {}}}}, cool: {label:: No, feature: None, tree: {}}}}, False: {label:: Yes, feature: None, tree: {}}}}, overcast: {label:: Yes, feature: None, tree: {}}}}Outlooksunny rain overcast↓ ↓ ↓Humidity Windy Yeshigh normal True False↓ ↓ ↓ ↓No Yes Temperature Yesmild cool↓ ↓Humidity Nonormal high ↓ ↓Yes No采用下面的样本进行测试
test[sunny,hot,normal,True]tree.predict(test)Yes
