决策树入门
决策树是分类算法中最重要的算法，重点
决策树算法在电信营业中怎么工作？
这个工人也是流失的，在外网转移比处虽然没有特征来判断，但是在此节点处流失率有三个分支概率更大
为什么叫决策树？
因为树的叶子节点是我们最终预判的结果。
决策树如何来？
根据训练样本建立。
问题1：为什么费用变换率放第一个？
根据特征建决策树，会有n棵树，找出最优树。
问题2：当我们特征是连续值的时候，到底从哪里开始切分？
连续值要改为离散的。
问题3：决策树能不能做回归
决策树例子：
不同的决策树对我们判定的效率，速度有影响。
总结：
树的深度：深度的基数是1，上图深度是4。一棵树所有层次的最大值称为深度。
决策树进阶
**决策树一共有五种算法。**前面四个都是有关联的。
Hunt算法：
其中所说的类别是输出的情况
属性即每一个样本的多种特征（如年龄、性别等）
以一个例子一一解说hunt算法过程
2、3、4行的解释，分两种情况
情况一（决策树刚从根节点出发）：假设上面图买电脑这一列全是是，则是这一个类是叶节点也是根节点
情景二（决策树正在内部节点分支过程中）：上面图买电脑这一列不全是是，是否混杂，在从根节点，子节点，子节点的子节点的分支过程中，某一分支处的特征（年龄、收入以及学生特征都以作为节点，假设学生开始分支，信用特征作为分支节点时），不论特征的情况如何（即不论信用的好坏）买电脑的情况都是是，则是这一个类作为学生的分支节点
5、6行的解释
情况一（A = 空）：在从根节点，子节点，子节点的子节点的分支过程中，某一分支处的特征（年龄、收入、学生特征以及信用特征都已经作为划分时（假如分到信用特征这一节点处继续向下划分））没有时，类的情况还是混杂的（买电脑的情况还是买与不买的都有），则此分支作为叶节点，且类别为这些混杂中类别最多的那一类。如下图sal<25的分支处（这里<25买房情况相同分支的叶节点可以是0也可以是1，最终选择为1是应为>25的另外一个分支上是0）
情景二（D中的样本在A上的取值相同）：在从根节点，子节点，子节点的子节点的分支过程中，某一分支处的特征（年龄、收入、学生特征以及信用特征都已经作为划分时（假如分到信用特征这一节点处继续向下划分）），但是信用这一节点的取值都相同（就像上图中假设30、32、33、sal的值都是3000时，右侧继续划分），则此分支作为叶节点，且类别为这些混杂中类别最多的那一类。
8-12行的解释
a*为属性，a*v为属性分支时的划分点（离散型的属性如性别可以划分男女，连续性的属性例如年龄可以以范围划分），例如下图的例子，（对应11、12行解释）年龄以80划分时大于80的分支为空，则此分支作为叶节点，且类别时这些样本集类别最多的那一类。线面18-34样本集中最多的类是0。
14行解释：
循环递归重复1-14行
总结：
决策树是一个递归的过程。
2,3解释：当所有的样本点都属于同一个类别的时候，不需要划分（递归结束的一个条件）；
5,6解释：属性不能再划分的时候，其类别标记取决于该样本中数据最多的类。如果类别数量相同，注意看一下另一个叶子节点，不能与上一个叶子节点的类别相同，否则，无需划分。
8，解释：如何构建最优决策树。
hunt算法有一个bug：不好选最优划分属性。D是样本集。
9~14解释：对于某一个特征（属性），的每一个值，设置为node并生成一个分支；形成两个样本子集。为空，分支节点为叶子节点，否则，样本子集中数量多的类为返回值。
信息增益–information gain(ID3)
（b）方法更好。
ID3算法主要针对属性选择问题
使用信息增益度选择测试属性。
决策树属于递归树。
信息熵：信息的度量，量化信息的作用。信息熵越小则已知的信息就越多
不确定性的多少就是未知的信息量多少
信息熵衡量的公式：
数据集D中m个不同的分类，表示以输出结果的分类（例如上面电信运营案例中的流失情况就是输出结果，流失与不流失是数据集分类；下面买电脑的情况就是输出结果，买与不买是数据集分类情况）；
Ci,D表示数据集D中Ci类的集合（例如下面买电脑情况，买这一类有5个，没买这一类有9个）
计算信息熵例子：
0~100%,先变大，后变小。50%的时候最大。熵为1的时候，不确性最大。熵为0，数据最纯。
条件信息熵
如何理解下面图片的第一句话
属性A表示每个样本中的特征（年龄、性别、收入等），v个不同的取值就是如何去划分属性A中的每一个特征（以上面买电脑情况来说明，年龄以<30，30-40，>40划分三类，性别以男女划分两类。。。）；
根据每一个特征求得的信息熵越小就是最优的划分属性（即hunt中没有说明如何找出最优属性的方法）。即某条件下的信息熵越小，信息量越小，以此条件对于数据集的划分越容易得到最终结果。
Info（Dj）样本子集的信息熵；假设Dj为年龄划分的样本子集，Info（Dj）表示年龄以<30 / 30-40 / >40的信息熵
信息增益=样本集的信息熵-某属性的信息熵
选择信息增益最大的属性。
（按条件进行划分的信息熵）例子
按年龄来划分：（年龄的信息增益最大）
实现ID3算法：
import numpy as np import operator def creatDataSet(): """ outlook-> 0:sunny | 1:overcast | 2:rain temperature-> 0:hot | 1:mild | 2:cool humidity-> 0:high | 1:normal windy-> 0:false | 1:true 输出表示玩不玩，N/Y """ dataSet = np.array([[0, 0, 0, 0, 'N'], [0, 0, 0, 1, 'N'], [1, 0, 0, 0, 'Y'], [2, 1, 0, 0, 'Y'], [2, 2, 1, 0, 'Y'], [2, 2, 1, 1, 'N'], [1, 2, 1, 1, 'Y']]) labels = np.array(['outlook', 'temperature', 'humidity', 'windy']) return dataSet, labels def createTestSet(): """ outlook-> 0:sunny | 1:overcast | 2:rain temperature-> 0:hot | 1:mild | 2:cool humidity-> 0:high | 1:normal windy-> 0:false | 1:true """ testSet = np.array([[0, 1, 0, 0], [0, 2, 1, 0], [2, 1, 1, 0], [0, 1, 1, 1], [1, 1, 0, 1], [1, 0, 1, 0], [2, 1, 0, 1]]) return testSet def dataset_entropy(dataset): """ 计算数据集的信息熵 """ classLabel=dataset[:,-1] labelCount={} for i in range(classLabel.size): label=classLabel[i] labelCount[label]=labelCount.get(label,0)+1 #将所有的类别都计算出来了
#熵值(第一步)
cnt=0 for k,v in labelCount.items(): cnt += -v/classLabel.size*np.log2(v/classLabel.size) return cnt #接下来切分,然后算最优属性
def splitDataSet(dataset, featureIndex): #划分后的子集
subdataset=[] featureValues = dataset[:,featureIndex] featureSet = list(set(featureValues)) for i in range(len(featureSet)): newset=[] for j in range(dataset.shape[0]): if featureSet[i] == featureValues[j]: newset.append(dataset[j,:]) newset=np.delete(newset,featureIndex,axis=1) # newset = newset[:,0:featureIndex].extend(newset[:,featureIndex+1:]) #不包括当前的列，得到新的数据集(数组的处理方式)
subdataset.append(np.array(newset)) return subdataset #划分得到三个子集
def splitDataSetByValue(dataset,featureIndex,value): subdataset=[] #迭代所有的样本
for example in dataset: if example[featureIndex]==value: subdataset.append(example) return np.delete(subdataset,featureIndex,axis=1) def chooseBestFeature(dataset,labels): """ 选择最优特征，但是特征是不包括名称的。 如何选择最优特征：每一个特征计算,信息增益最大==条件熵最小就可以。 """
#特征的个数
featureNum=labels.size #设置最小熵值
minEntropy,bestFeatureIndex=1,None #样本总数
n=dataset.shape[0] for i in range(featureNum): #指定特征的条件熵
featureEntropy=0 #返回第i个特征的所有子集
allSubDataSet=splitDataSet(dataset,i) for subDataSet in allSubDataSet: featureEntropy += subDataSet.shape[0]/n*dataset_entropy(subDataSet) #表示第i个特征的条件熵
if minEntropy > featureEntropy: #将最小的条件上赋给minEntropy，特征索引值i给bestFeatureIndex
minEntropy=featureEntropy bestFeatureIndex=i return bestFeatureIndex #最佳增益
def mayorClass(classList): labelCount={} #建立字典类型用于标签熟练存储
for i in range(classList.size): label=classList[i] labelCount[label]=labelCount.get(label,0)+1 #计算每个标签的数量
sortedLabel=sorted(labelCount.items(),key=operator.itemgetter(1),reverse=True) return sortedLabel[0][0] def createTree(dataset,labels): """ 参考hunt算法那张图片 """ classList=dataset[:,-1] if len(set(dataset[:,-1]))==1: return dataset[:,-1][0] #返回类别
if labels.size==0 or len(dataset[0])==1: #条件熵最少的一定是类别最多的
#条件熵算不下去的时候，
return mayorClass(classList) bestFeatureIndex=chooseBestFeature(dataset,labels) bestFeature=labels[bestFeatureIndex] dtree={bestFeature:{}} #用代码表示这棵树
featureList=dataset[:,bestFeatureIndex] featureValues=set(featureList) #得到最优节点的划分情况
for value in featureValues: subdataset=splitDataSetByValue(dataset,bestFeatureIndex,value) sublabels=np.delete(labels,bestFeatureIndex) #将最优节点的标签删去后的标签组
dtree[bestFeature][value]=createTree(subdataset,sublabels) #将原始的labels干掉一列后的
return dtree #数据集和标签，开始递归
if __name__ == "__main__": dataset,labels=creatDataSet() # print(dataset_entropy(dataset)
# s=splitDataSet(dataset,0)
# for item in s:
# print(item)
print(createTree(dataset,labels))
·····················································
输出：
{'outlook': {'2': {'windy': {'0': 'Y', '1': 'N'}}, '0': 'N', '1': 'Y'}}
if labels.size==0 or len(dataset[0])==1: #条件熵最少的一定是类别最多的
#条件熵算不下去的时候，
return mayorClass(classList) """ 这两种情况分别是 ['N','N','Y'] ['N'] """
labels.size == 0的情况
len(dateset[0]) == 1的情况
代码解释：
切分子集是为了，计算每一个特征的条件熵，然后选出最优特征。
总结：
决策树里面的重要的公式：
1，数据集的信息熵公式：Info(D)
2，指定条件下的信息熵：Info_A(D)
将算法优化：
将splitDataSet（）和splitDataSetByValue（）合二为一。
import numpy as np import operator def creatDataSet(): """ outlook-> 0:sunny | 1:overcast | 2:rain temperature-> 0:hot | 1:mild | 2:cool humidity-> 0:high | 1:normal windy-> 0:false | 1:true """
dataSet = np.array([[0, 0, 0, 0, 'N'], [0, 0, 0, 1, 'N'], [1, 0, 0, 0, 'Y'], [2, 1, 0, 0, 'Y'], [2, 2, 1, 0, 'Y'], [2, 2, 1, 1, 'N'], [1, 2, 1, 1, 'Y']]) labels = np.array(['outlook', 'temperature', 'humidity', 'windy']) return dataSet, labels
def createTestSet(): """ outlook-> 0:sunny | 1:overcast | 2:rain temperature-> 0:hot | 1:mild | 2:cool humidity-> 0:high | 1:normal windy-> 0:false | 1:true """ testSet = np.array([[0, 1, 0, 0], [0, 2, 1, 0], [2, 1, 1, 0], [0, 1, 1, 1], [1, 1, 0, 1], [1, 0, 1, 0], [2, 1, 0, 1]]) return testSet def dataset_entropy(dataset): """ 计算数据集的信息熵 """ classLabel=dataset[:,-1] labelCount={} for i in range(classLabel.size): label=classLabel[i] labelCount[label]=labelCount.get(label,0)+1 #将所有的类别都计算出来了
#熵值(第一步)
cnt=0 for k,v in labelCount.items(): cnt += -v/classLabel.size*np.log2(v/classLabel.size) return cnt #接下来切分,然后算最优属性
def splitDataSet(dataset,featureIndex,value): subdataset=[] #迭代所有的样本
for example in dataset: if example[featureIndex]==value: subdataset.append(example) return np.delete(subdataset,featureIndex,axis=1) def chooseBestFeature(dataset,labels): """ 选择最优特征，但是特征是不包括名称的。 如何选择最优特征：每一个特征计算,信息增益最大==条件熵最小就可以。 """
#特征的个数
featureNum=labels.size #设置最小熵值
minEntropy,bestFeatureIndex=1,None #样本总数
n=dataset.shape[0] for i in range(featureNum): #指定特征的条件熵
featureEntropy=0 #返回所有子集
featureList=dataset[:,i] featureValues=set(featureList) for value in featureValues: subDataSet=splitDataSet(dataset,i,value) featureEntropy += subDataSet.shape[0]/n*dataset_entropy(subDataSet) #一个的条件熵
if minEntropy > featureEntropy: minEntropy=featureEntropy bestFeatureIndex=i return bestFeatureIndex #最佳增益
def mayorClass(classList): labelCount={} for i in range(classList.size): label=classList[i] labelCount[label]=labelCount.get(label,0)+1 sortedLabel=sorted(labelCount.items(),key=operator.itemgetter(1),reverse=True) return sortedLabel[0][0] def createTree(dataset,labels): """ 参考hunt算法那张图片 """ classList=dataset[:,-1] if len(set(dataset[:,-1]))==1: return dataset[:,-1][0] #返回类别
if labels.size==0 or len(dataset[0])==1: #条件熵最少的一定是类别最多的
#条件熵算不下去的时候，
return mayorClass(classList) bestFeatureIndex=chooseBestFeature(dataset,labels) bestFeature=labels[bestFeatureIndex] dtree={bestFeature:{}} #用代码表示这棵树
featureList=dataset[:,bestFeatureIndex] featureValues=set(featureList) for value in featureValues: subdataset=splitDataSet(dataset,bestFeatureIndex,value) sublabels=np.delete(labels,bestFeatureIndex) dtree[bestFeature][value]=createTree(subdataset,sublabels) #将原始的labels干掉一列
return dtree if __name__ == "__main__": dataset,labels=creatDataSet() # print(dataset_entropy(dataset)
# s=splitDataSet(dataset,0)
# for item in s:
# print(item)
print(createTree(dataset,labels)) ······················································· 输出结果： {'outlook': {'1': 'Y', '0': 'N', '2': {'windy': {'1': 'N', '0': 'Y'}}}}
import numpy as np import operator def creatDataSet(): """ outlook-> 0:sunny | 1:overcast | 2:rain temperature-> 0:hot | 1:mild | 2:cool humidity-> 0:high | 1:normal windy-> 0:false | 1:true 输出表示玩不玩，N/Y """ dataSet = np.array([[0, 0, 0, 0, 'N'], [0, 0, 0, 1, 'N'], [1, 0, 0, 0, 'Y'], [2, 1, 0, 0, 'Y'], [2, 2, 1, 0, 'Y'], [2, 2, 1, 1, 'N'], [1, 2, 1, 1, 'Y']]) labels = np.array(['outlook', 'temperature', 'humidity', 'windy']) return dataSet, labels def createTestSet(): """ outlook-> 0:sunny | 1:overcast | 2:rain temperature-> 0:hot | 1:mild | 2:cool humidity-> 0:high | 1:normal windy-> 0:false | 1:true """ testSet = np.array([[0, 1, 0, 0], [0, 2, 1, 0], [2, 1, 1, 0], [0, 1, 1, 1], [1, 1, 0, 1], [1, 0, 1, 0], [2, 1, 0, 1]]) return testSet def dataset_entropy(dataset): """ 计算数据集的信息熵 """ classLabel=dataset[:,-1] labelCount={} for i in range(classLabel.size): label=classLabel[i] labelCount[label]=labelCount.get(label,0)+1 #将所有的类别都计算出来了
#熵值(第一步)
cnt=0 for k,v in labelCount.items(): cnt += -v/classLabel.size*np.log2(v/classLabel.size) return cnt #接下来切分,然后算最优属性
def splitDataSet(dataset, featureIndex): #划分后的子集
subdataset=[] featureValues = dataset[:,featureIndex] featureSet = list(set(featureValues)) for i in range(len(featureSet)): newset=[] for j in range(dataset.shape[0]): if featureSet[i] == featureValues[j]: newset.append(dataset[j,:]) newset=np.delete(newset,featureIndex,axis=1) # newset = newset[:,0:featureIndex].extend(newset[:,featureIndex+1:]) #不包括当前的列，得到新的数据集(数组的处理方式)
subdataset.append(np.array(newset)) return subdataset #划分得到三个子集
def splitDataSetByValue(dataset,featureIndex,value): subdataset=[] #迭代所有的样本
for example in dataset: if example[featureIndex]==value: subdataset.append(example) return np.delete(subdataset,featureIndex,axis=1) def chooseBestFeature(dataset,labels): """ 选择最优特征，但是特征是不包括名称的。 如何选择最优特征：每一个特征计算,信息增益最大==条件熵最小就可以。 """
#特征的个数
featureNum=labels.size #设置最小熵值
minEntropy,bestFeatureIndex=1,None #样本总数
n=dataset.shape[0] for i in range(featureNum): #指定特征的条件熵
featureEntropy=0 #返回第i个特征的所有子集
allSubDataSet=splitDataSet(dataset,i) for subDataSet in allSubDataSet: featureEntropy += subDataSet.shape[0]/n*dataset_entropy(subDataSet) #表示第i个特征的条件熵
if minEntropy > featureEntropy: #将最小的条件上赋给minEntropy，特征索引值i给bestFeatureIndex
minEntropy=featureEntropy bestFeatureIndex=i return bestFeatureIndex #最佳增益
def mayorClass(classList): labelCount={} #建立字典类型用于标签熟练存储
for i in range(classList.size): label=classList[i] labelCount[label]=labelCount.get(label,0)+1 #计算每个标签的数量
sortedLabel=sorted(labelCount.items(),key=operator.itemgetter(1),reverse=True) return sortedLabel[0][0] ##添加
def predict(tree,labels,testDate): rootName =list(tree.keys())[0] rootValue = tree[rootName] featureIndex = list(labels).index(rootName) classLabel = None for key in rootValue.keys(): #print(key)
if testDate[featureIndex] == int(key): if type(rootValue[key]).__name__ == "dict": classLabel = predict(rootValue[key], labels, testDate) else: classLabel = rootValue[key] pass
pass
pass
return classLabel ##添加
def predictAll(teree,labels,treeSet): classLabels = [] for i in testSet: classLabels.append(predict(tree,labels,i)) pass
return classLabels def createTree(dataset,labels): """ 参考hunt算法那张图片 """ classList=dataset[:,-1] if len(set(dataset[:,-1]))==1: return dataset[:,-1][0] #返回类别
if labels.size==0 or len(dataset[0])==1: #条件熵最少的一定是类别最多的
#条件熵算不下去的时候，
return mayorClass(classList) bestFeatureIndex=chooseBestFeature(dataset,labels) bestFeature=labels[bestFeatureIndex] dtree={bestFeature:{}} #用代码表示这棵树
featureList=dataset[:,bestFeatureIndex] featureValues=set(featureList) #得到最优节点的划分情况
for value in featureValues: subdataset=splitDataSetByValue(dataset,bestFeatureIndex,value) sublabels=np.delete(labels,bestFeatureIndex) #将最优节点的标签删去后的标签组
dtree[bestFeature][value]=createTree(subdataset,sublabels) #将原始的labels干掉一列后的
return dtree #数据集和标签，开始递归
if __name__ == "__main__": dataset,labels=creatDataSet() # print(dataset_entropy(dataset)
# s=splitDataSet(dataset,0)
# for item in s:
# print(item)
tree = createTree(dataset,labels) testSet = createTestSet() print(predictAll(tree, labels, testSet))#测试
""" 结果 ['N', 'N', 'Y', 'N', 'Y', 'Y', 'N'] """