from math import log

import operator

"""程序清单3-1 计算给定数据集的香农熵"""

def calcShannonEnt(dataSet):

numEntries = len(dataSet)

labelCounts = {}

for featVec in dataSet:  # the the number of unique elements and their occurance

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

shannonEnt -= prob * log(prob, 2)  # log base 2

return shannonEnt

"""程序清单3-2 按照给定的特征划分数据集"""

"""dataSet待划分数据集 axis划分数据集的特征 value特征的返回值"""

def splitDataSet(dataSet, axis, value):

retDataSet = []

for featVec in dataSet:

if featVec[axis] == value:

reducedFeatVec = featVec[:axis]     #chop out axis used for splitting

reducedFeatVec.extend(featVec[axis+1:])

retDataSet.append(reducedFeatVec)

return retDataSet

"""程序清单3-3 选择最好的数据集划分方式"""

def chooseBestFeatureToSplit(dataSet):

numFeatures = len(dataSet[0]) - 1      #the last column is used for the labels

baseEntropy = calcShannonEnt(dataSet)

bestInfoGain = 0.0; bestFeature = -1

for i in range(numFeatures):        #iterate over all the features

featList = [example[i] for example in dataSet]#create a list of all the examples of this feature

uniqueVals = set(featList)       #get a set of unique values

newEntropy = 0.0

for value in uniqueVals:

subDataSet = splitDataSet(dataSet, i, value)

prob = len(subDataSet)/float(len(dataSet))

newEntropy += prob * calcShannonEnt(subDataSet)

infoGain = baseEntropy - newEntropy     #calculate the info gain; ie reduction in entropy

if (infoGain > bestInfoGain):       #compare this to the best gain so far

bestInfoGain = infoGain         #if better than current best, set to best

bestFeature = i

return bestFeature                      #returns an integer

"""程序清单3-4 创建树的代码"""

"""dataSet是数据集 labels是标签列表"""

def createTree(dataSet,labels):

classList = [example[-1] for example in dataSet]

if classList.count(classList[0]) == len(classList):

return classList[0]#stop splitting when all of the classes are equal

if len(dataSet[0]) == 1: #stop splitting when there are no more features in dataSet

return majorityCnt(classList)

bestFeat = chooseBestFeatureToSplit(dataSet)

bestFeatLabel = labels[bestFeat]

myTree = {bestFeatLabel:{}}

del(labels[bestFeat])

featValues = [example[bestFeat] for example in dataSet]

uniqueVals = set(featValues)

for value in uniqueVals:

subLabels = labels[:]       #copy all of labels, so trees don't mess up existing labels

myTree[bestFeatLabel][value] = createTree(splitDataSet(dataSet, bestFeat, value),subLabels)

return myTree

def createDataSet():

dataSet = [[1, 1, 'yes'],

[1, 1, 'yes'],

[1, 0, 'no'],

[0, 1, 'no'],

[0, 1, 'no']]

labels = ['no surfacing','flippers']

#change to discrete values

return dataSet, labels

def majorityCnt(classList):

classCount={}

for vote in classList:

if vote not in classCount.keys(): classCount[vote] = 0

classCount[vote] += 1

sortedClassCount = sorted(classCount.iteritems(), key=operator.itemgetter(1), reverse=True)

return sortedClassCount[0][0]

if __name__ == "__main__":

myDat, labels = createDataSet()

# print(myDat)

# print(labels)

"""输出熵，熵越高则混合的数据越多"""

#print(calcShannonEnt(myDat))

"""0.9709505944546686"""

# myDat[0][-1] = "maybe"

# print(myDat)

# print(calcShannonEnt(myDat))

"""1.3709505944546687"""

#print(splitDataSet(myDat, 0, 1))

"""[[1, 'yes'], [1, 'yes'], [0, 'no']]"""

#print(splitDataSet(myDat, 0, 0))

"""[[1, 'no'], [1, 'no']]"""

#print(chooseBestFeatureToSplit(myDat))

"""0"""

"""第0特征是最好的用于划分数据集的特征"""

mytree = createTree(myDat, labels)

print(mytree)