决策树分类ID3算法的Python实现

生成决策树是从数据中生成分类器的一个特别有效的方法。决策树从一组无次序、无规则的事例中推理出分类规则。

ID3算法

ID3算法采用自顶向下的递归方法构造决策树，从单表训练样本的单个节点开始，使用信息熵来选择合适的分类属性，将样本划分成若干子集，直到样本都在同一个分类中。

ID3算法的核心是信息熵和信息增益，计算信息熵和信息增益有以下关键公式：

信息熵：





信息增益：



信息增益大的属性将被作为下一分类依据。

简单地说：ID3算法就是按照一定规则，选择出一堆样本属性中最为合适的一个属性，作为分类的依据，最终形成一个树状的分类规则。而这里的一定规则就是计算各个属性的信息增益，其中信息增益最大的属性就是被选出的属性。

举例

据说课本上的例子是相当经典的，就是根据很多天的天气情况决定是否打网球。

很多天的天气数据如下图（其实没很多，就14项，够敲的了）：



最后生成的决策树是这样的：



其中，数据经历了这样的变化：



听说Python语言更适合于数据挖掘，于是我在这次实验之前学习了Python语言，并在这次试验中运用了起来，用Python语言实现了ID3算法。由于本人初学Python，如有可以改进优化的地方敬请大家指教。

代码

#
# 用户输入
#
titles = ['Outlook', 'Temperature', 'Humidity', 'Wind', 'PlayTennis']
dataset = [
['Sunny', 'Hot', 'High', 'Weak', 'no'],
['Sunny', 'Hot', 'High', 'Strong', 'no'],
['Overcast', 'Hot', 'High', 'Weak', 'yes'],
['Rainy', 'Mild', 'High', 'Weak', 'yes'],
['Rainy', 'Cool', 'Normal', 'Weak', 'yes'],
['Rainy', 'Cool', 'Normal', 'Strong', 'no'],
['Overcast', 'Cool', 'Normal', 'Strong', 'yes'],
['Sunny', 'Mild', 'High', 'Weak', 'no'],
['Sunny', 'Cool', 'Normal', 'Weak', 'yes'],
['Rainy', 'Mild', 'Normal', 'Weak', 'yes'],
['Sunny', 'Mild', 'Normal', 'Strong', 'yes'],
['Overcast', 'Mild', 'High', 'Strong', 'yes'],
['Overcast', 'Hot', 'Normal', 'Weak', 'yes'],
['Rainy', 'Mild', 'High', 'Strong', 'no']
]

#
# ID3算法
#
import math

def log2(n):
return math.log(n)/math.log(2)

#
# 根据下标划分子集
#
def classify(data, index):
a = {}
for ls in data:
try:
a[ls[index]].append(ls)
except:
a[ls[index]] = [ls]
return a

#
# 计算信息熵
#
def entropy(data, index):
a = {}
for item in data:
try:
a[item[index]] += 1
except:
a[item[index]] = 1
entropy = 0.0
for key in a.keys():
p = 1.0 * a[key] / len(data)
entropy += p*log2(p)
return -entropy

#
# 计算子集的熵
#
def entropy2(data, attrIndex, tarIndex):
classes = classify(data, attrIndex)
e = 0.0
for key in classes.keys():
ent = entropy(classes[key], tarIndex)
e += ent * len(classes[key]) / len(data)
return e

#
# 计算信息增益
#
def gain(entropy, entropy2):
return entropy - entropy2

#
# 决策树节点
#
class TreeNode(object):
def __init__(self, data, index, attrIndexes):
self.decision = titles[index]
classes = classify(data, index) #根据属性分类
self.children = {}
children = classes.keys()
for child in children: #生成子树
data = classes[child]
self.children[child] = generateTree(data, list(attrIndexes))

def __str__(self):
return self.decision

#
# 生成节点
#
def generateTree(dataset, attrIndexes):
classes = classify(dataset, tarIndex)
if len(classes) == 1: #假如同一类
tree = dataset[0][tarIndex]
else:
e = entropy(dataset, tarIndex) #计算信息熵
gains = {}
maxIndex = attrIndexes[0]
for i in attrIndexes: #计算信息增益并找出信息增益最大的属性
gains[titles[i]] = gain(e, entropy2(dataset, i, tarIndex))
if gains[titles[i]] > gains[titles[maxIndex]]:
maxIndex = i
attrIndexSet = set(attrIndexes[:])
attrIndexSet.remove(maxIndex)
tree = TreeNode(dataset, maxIndex, attrIndexSet)
return tree

#
# 显示决策树
#
def displayTree(tree):
if isinstance(tree, TreeNode):
print (tree)
for key in tree.children:
print (key + ':' + tree.children[key].__str__())
displayTree(tree.children[key])

tarIndex = len(dataset[0]) - 1 #样本分类下标
attrIndexes = range(0,tarIndex) #样本属性下标
tree = generateTree(dataset, attrIndexes)
displayTree(tree)