前言
数据结构和算法先等刷一波题有点心得再继续，刷题和复习不矛盾，就开始搞搞机器学习基础知识！参考了《机器学习》（西瓜书）和《机器学习实战》，这两本书真的好！
基本流程
基本算法
参考《机器学习》（西瓜书）
决策树中的几种情况
- D中样本都是一个类别C，那么就没必要继续分了，所以可以标记为C类叶结点
- A = ∅ A = \emptyset A=∅代表没有没划分的属性了，D中样本在A上取值相同
划分标准
信息熵
信息增益
代码+注解
参考《机器学习实战》，对《机器学习》中的西瓜数据集2.0进行操作，这里面的createDataset函数直接写了数据集上去
画图的代码这里没有附上，因为有一点bug，等我改好了再放链接。
trees.py
from math import log
import operator
import pickle
"""
决策树的一般流程
1. 收集数据
2. 准备数据：树构造算法只适用于标称型数据，因此必须离散化数据
3. 分析数据：可以使用任何方法，构造树完成后要判断是否符合预期
4. 训练算法：构造树的数据结构
5. 测试算法：使用经验树计算错误率
6. 使用该算法：决策树能更好理解划分的内在含义
"""
def createDataset():
dataset = [
[0, 0, 0, 0, 0, 0, 'yes'],
[1, 0, 1, 0, 0, 0, 'yes'],
[1, 0, 0, 0, 0, 0, 'yes'],
[0, 0, 1, 0, 0, 0, 'yes'],
[2, 0, 0, 0, 0, 0, 'yes'],
[0, 1, 0, 0, 1, 1, 'yes'],
[1, 1, 0, 1, 1, 1, 'yes'],
[1, 1, 0, 0, 1, 0, 'yes'],
[1, 1, 1, 1, 1, 0, 'no'],
[0, 2, 2, 0, 2, 1, 'no'],
[2, 2, 2, 2, 2, 0, 'no'],
[2, 0, 0, 2, 2, 1, 'no'],
[0, 1, 0, 1, 0, 0, 'no'],
[2, 1, 1, 1, 0, 0, 'no'],
[1, 1, 0, 0, 1, 1, 'no'],
[2, 0, 0, 2, 2, 0, 'no'],
[0, 0, 1, 1, 1, 0, 'no']
]
# labels = ['no surfacing', 'flippers']
labels = ['color', 'root', 'sound', 'texture', 'bottom', 'touch']
return dataset, labels
def calShannonEnt(dataset):
'''
计算信息熵
:param dataset:
:return:
'''
numEntries = len(dataset)
labelCounts = {
}
# 以下五行为所有可能分类创造字典
for featVec in dataset:
currentLabel = featVec[-1]
if currentLabel not in labelCounts.keys():
labelCounts[currentLabel] = 0
labelCounts[currentLabel] += 1
shannonEnt = 0.0
for key in labelCounts:
prob = float(labelCounts[key]) / numEntries
# 以2为底求对数
shannonEnt -= prob * log(prob, 2)
return shannonEnt
# 根据某一个属性的某个值来分割原本dataset
def splitDataSet(dataset, axis, value):
'''
:param dataset: 就是dataset
:param axis: 某个属性
:param value: 某个属性的某个值
:return: 分割之后的新dataset
'''
# 创建新的list对象，避免更改原本的dataset
retDataSet = []
for featVec in dataset:
if featVec[axis] == value:
reducedDataSet = featVec[:axis]
reducedDataSet.extend(featVec[axis + 1:])
retDataSet.append(reducedDataSet)
return retDataSet
def chooseBestFeatureToSplit(dataset):
'''
ID3就是用能使得信息增益最高的属性作为划分属性的，这个函数就是用来做这个作用的
:param dataset:
:return: bestFeature，也就是最好的特征的下标
'''
numFeatures = len(dataset[0]) - 1 # dataset的最后一列是label，所以feature的数量就要比原本-1了
baseEntropy = calShannonEnt(dataset) # 计算没划分前的entropy
bestInfoGain = 0.0 # 初始化最好的信息增益为0
bestFeature = -1 # 初始化最好的feature的位置为-1
for i in range(numFeatures):
# 以下两行是创建唯一的分类标签列表，也就是找出这个标签有几个选项
# 比如i=0是血型这个属性，血型这个属性有ABO三个可能取值
# 然后featList就会是比如AABBOOOOABOA
featList = [example[i] for example in dataset]
# 而我们只要筛选出ABO三个取值，所以用个直接用个set强转就可以了
uniqueVals = set(featList)
newEntropy = 0.0
# 以下五行计算每种划分方式的信息熵
for value in uniqueVals:
subDataSet = splitDataSet(dataset, i, value)
# print('subDataSet: ', subDataSet) # 如果不是很清楚信息增益的定义，就打印这个细节出来看
prob = float(len(subDataSet)) / float(len(dataset))
newEntropy += prob * calShannonEnt(subDataSet)
infoGain = baseEntropy - newEntropy
if infoGain > bestInfoGain:
# 计算最好的信息增益
bestInfoGain = infoGain
bestFeature = i
return bestFeature # 我们不需要最好的信息增益的值，我们需要的是最好的那个feature的下标
def majorityCnt(classList):
'''
将classList中每个类别的出现的次数统计出来，并且进行降序，也就是出现最多次的排最前面
:param classList:
:return: 出现最多次的类别
'''
classCount = {
}
for vote in classList:
if vote not in classCount.keys():
classCount[vote] = 0
classCount[vote] += 1
sortedClassCount = sorted(classCount.items(), key=operator.itemgetter(1),
reverse=True) # items()返回的是key-value形成的tuple，itemgetter(1)代表取第一维度的
print('sortedClassCount: ',sortedClassCount)
return sortedClassCount[0][0]
def createTree(dataset, labels):
'''
递归进行造树
:param dataset: 训练集
:param labels: 标签
:return: 训练好的树
'''
labels_copy = labels.copy()
classList = [example[-1] for example in dataset]
# 以下两行代码表示类别完全相同则停止继续划分
# 如果一整个classList里面的类别都是一样的，那么代表从第0个到最后一个都是一样的，所以可以这样判断
if classList.count(classList[0]) == len(classList):
return classList[0]
# 以下两行遍历完所有特征时，仍然不能将数据集划分成仅包含唯一类别的分组
# 因此返回出现次数最多的类别
if len(dataset[0]) == 1:
return majorityCnt(classList)
bestFeat = chooseBestFeatureToSplit(dataset)
bestFeatLabel = labels_copy[bestFeat]
myTree = {
bestFeatLabel: {
}} # 使用字典作为树的结点
del (labels_copy[bestFeat])
featValues = [example[bestFeat] for example in dataset] # best feature的所有值
uniqueVals = set(featValues)
for value in uniqueVals:
subLabels = labels_copy[:] # 因为python的参数是按照引用传递的，为了防止原labels被改变，所以要一个sublabels来传递
myTree[bestFeatLabel][value] = createTree(splitDataSet(dataset, bestFeat, value), subLabels)
return myTree
def classify(inputTree, featLabels, testVec):
'''
对新的目标进行分类
:param inputTree: 训练好的决策树
:param featLabels: 标签
:param testVec: 要进行分类的数据（单条）
:return: 类别
'''
firstStr = list(inputTree.keys())[0]
secondDict = inputTree[firstStr]
featIndex = featLabels.index(firstStr)
classlabel = None
for key in secondDict.keys():
if testVec[featIndex] == key:
if type(secondDict[key]).__name__ == 'dict':
classlabel = classify(secondDict[key], featLabels, testVec)
else:
classlabel = secondDict[key]
return classlabel
def storeTree(inputTree, filename):
'''
使用pickle来储存树
:param inputTree: 树
:param filename: 文件名
:return:
'''
fw = open(filename, 'w')
pickle.dump(inputTree, fw)
fw.close()
def grabTree(filename):
'''
使用pickle来读取储存的树
:param filename: 文件名
:return:
'''
fr = open(filename)
return pickle.load(fr)
main.py
import trees
if __name__ == '__main__':
myDat, labels = trees.createDataset()
print('labels: ', labels)
print(myDat)
shannonEnt = trees.calShannonEnt(myDat)
print(shannonEnt)
print(trees.chooseBestFeatureToSplit(myDat))
myTree = trees.createTree(myDat, labels)
print(myTree)
treePlotter.createPlot(myTree)
classLabel = trees.classify(myTree, labels, [0, 0, 0, 0, 0, 0])
print('class label is ',classLabel)