0.5decision-tree

import matplotlib.pyplot as plt
import numpy as np 
import pandas as pd
import scipy as sc
import seaborn as sns
import queue
from sklearn import datasets
from sklearn.metrics import accuracy_score,f1_score
from sklearn.tree import DecisionTreeClassifier

Decision Tree

• 把产生的连续变量转化成类别标签,用这个数据做决策树，就方便很多了。

x,y=datasets.make_classification()
#三个分位数：
x=np.apply_along_axis(lambda a:np.searchsorted(np.quantile(a,np.sort(np.random.rand(5))),a),0,x)
for i in list(set(y)):
    plt.plot(x[y==i][:,0],x[y==i][:,1],'*',label=i)
plt.legend()
plt.show()

1.1信息熵

def Entropy(series):
    '''
    计算类别变量的熵
    '''
    pi=pd.Series(series).value_counts()/len(series)
    return -1*np.sum(pi*np.log2(pi))
en=np.apply_along_axis(Entropy,0,x)
plt.plot(en,'*')

[<matplotlib.lines.Line2D at 0x2dec9264b00>]

1.2条件熵

• D 为样本
• k为类别个数 ，Ck为类别为k的样本数
• 特征A有不同的特征1,2,3…n,根据特征A可以将特征分为D1,D2,D3…Dn ,|D1|为样本个数
• 即Di中属于Ck的样本集合为Dik

def EntropyCondition(series,y):
    '''
    计算series的条件熵
    
    series:数据集
    y:类别
    先数据集按照特征A分开，然后计算没一份数据的经验熵
    '''    
    return -1*np.sum([Entropy(y[series==i]) for i in set(series)])
        

EntropyCondition(x[:,1],y)

-5.8599831625893435

1.4 信息增益

def GainInf(array,y):
    '''
    计算信息增益
    
    array: data
    y:label
    
    return 返回每个特征的增益
    '''
    gain=np.zeros(array.shape[1])
    for i,series in enumerate(array.T):
        gain[i]=Entropy(y)-EntropyCondition(series,y)
    return gain   
        
'''
测试全都一样的数据
'''
a=np.ones_like(x)
b=np.ones_like(y)

GainInf(a,b)#.argmax()    

array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
       0., 0., 0.])

def GainInfRatio(array,y):
    '''
    计算信息增益比
    ??? 如果信息增益比的分为0怎么办??
    返回信息增益比
    '''
    #对于信息熵等于0的特征，直接把所有特征的信息熵平均值*10
    gain=np.apply_along_axis(Entropy,0,array)   
    #尽量不要找都一样的数据，因为这样会导致分不下去
    gain[gain==0]+=np.mean(gain)*10
    
    return GainInf(array,y)/gain
    
GainInfRatio(x,y).argmax()

3

ID3

• 每棵树不一定有几个子树，所以用列表表示他的所有子树
• 如果信息增益最大的那个特征有多个取值，我应该怎么选取呢？难道是随便选，直接分开n个？

class Node():
    '''
    决策树单棵树的实现（只要提供树的数据集，就可以继续下一步了。）
    
    决策树的子树不一定只有两颗树，所以用列表表示所有的子树
    每课树保留自己的数据集、维度、值
    '''
    def __init__(self,data,value=None,nodes=None,iIndex=None):
        self.nodes=nodes #保存左树
        self.data=data  #保存数据集
        self.iIndex=iIndex #记录切割的维度
        self.value=value # 当前维度的值
    def set_node(self,value=None,nodes=None,iIndex=None):
        self.nodes=nodes
        self.value=value
        self.iIndex=iIndex 
        

def DecisionTree(node):
    '''
    通过计算信息增益比来切割数据集
    
    对数据的第iIndex个维度分割
    包含左侧数据集的树节点，右侧数据集节点，切分点
    '''
    array,y=node.data# 
    Childes=[]
    iIndex=GainInfRatio(array,y).argmax()
    node.iIndex=iIndex
    currentFeature=array[:,iIndex]
    for i in set(currentFeature):
        nodei=Node((array[currentFeature==i],y[currentFeature==i]))
        nodei.value=i
        Childes.append(nodei)
        #print(iIndex,i,np.sum(currentFeature==i))
    node.nodes=Childes 
    
    return Childes

构建决策树

• 第一步构建跟目录
• 第二步根据某个特征（iIndex）切分，切分后的数据保存到子节点nodes，设置子节点value(如果该特征的值等于values)则搜索时进入该子节点
• 第三步，选择一个nodes 继续构建，或者增益比较少，或者节点数少于2
• 考虑？等于零之类的呢？

MinSample=3 #最小样本点
myqueue=queue.Queue()
root=Node((x,y),value=0,iIndex=0) #生成根节点
currentDecision=root
myqueue.put(currentDecision)

while not myqueue.empty():
    #随便取出来一个继续决策
    currentDecision=myqueue.get()
    childe_nodes=DecisionTree(currentDecision)
    #print(myqueue.qsize(),childe_nodes[0].data[1].shape,len(childe_nodes))
    for i in childe_nodes:
        # 只有子节点大于5个样本点才回继续
        if len(i.data[1])>MinSample:            
            myqueue.put(i)
            

搜索决策树

y_pred=[]
for i in range(y.shape[0]):
    search=x[i]#设置搜索目标
    searchDecision=root
    #当前擦找的决策树，的索引
    while searchDecision.iIndex!=None:
        # 
        searchDecision=[i  for i in searchDecision.nodes if i.value==search[searchDecision.iIndex]][0]
    y_pred.append(np.mean(searchDecision.data[1])>0.5)

#我自己写的，还有一个主要的问题。
accuracy_score(y>0.5,y_pred),f1_score(y>0.5,y_pred)

(0.63, 0.5066666666666666)

tree=DecisionTreeClassifier()
tree.fit(x,y)
y_pred=tree.predict(x)
accuracy_score(y>0.5,y_pred),f1_score(y>0.5,y_pred)

(1.0, 1.0)

总结

• 主要的问题，当变量变少后，容易选择完全一致的变量。