El código fuente GitHub ( https://github.com/fansking/Machine/blob/master/Machine/trees.py) en
una variedad de atributos de las cosas, pero una gran cantidad de bienes no determina si era esta cosa. Por ejemplo, algunos gatos son peludas, algunos gatos no tienen pelo, no todo el pelo no es un gato no puede decidir. Luego de tantos atributos, ¿cómo elegir de aquí uno o más atributos como un factor decisivo en ella. Aquí hay que introducir el concepto de aumento de la entropía y la información.
Cuando añadimos un atributo a una categoría y atributo particular algo tan consistente, por ejemplo, si hay que aumentar los peces pueden vivir en el agua otra vez, la mayoría de los peces es sí, pero no la mayoría de los peces no pueden vivir en el agua. Esto no va a ser separado del pescado muy buena zona, bajo el agua la vida puede traer una buena información de ganancia. Entonces, ¿cómo nos encontramos con esta propiedad?
Eso es (todos los atributos juntos expectativas de información) - (valor esperado de una propiedad para eliminar la información), mayor es el valor, entonces existe la mayor influencia sobre la exactitud de la clasificación cuando esta cantidad.
Shannon entropía se calcula como sigue, donde p (xi) es las características de frecuencia de esto aparece de propiedad.
Y una construcción de árbol de decisión está dispuesto en un descienden hacia abajo, factores de orden construido.
A continuación se muestra una descripción de una función de una función:
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 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
La primera función aquí es construir un conjunto de datos, es nuestra siguiente de datos. datos correspondientes a la segunda fila de la primera columna de la etiqueta en los dos datos de entidad, el último uno de sus categorías. La segunda función se le da un conjunto de datos para calcular el valor de la entropía de Shannon.
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
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) #subDataSet是除去本次遍历的列的内容，我们需要得到他的长度，并根据长度求得权重系数
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
Aquí es la primera función de un conjunto de datos, eliminar la columna de índice especificado, y devuelve el sub-conjunto de datos.
La segunda función es un principio que decir, a través de todas las columnas, el mayor impacto es el más grande de datos característicos entropía change're mirando calculada después de eliminar esta columna, devuelve el índice correspondiente a las características de los datos.
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]
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: #即当没有更多特征时，一定到达了递归出口（叶子结点）,对最后一个特征使用举手表决的方式，哪个对应的标签最多就选择哪个标签
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[:] #python是使用引用的方式来传递变量，所以直接用等号会导致同步变化，我们需要拷贝一份新的值给子标签
myTree[bestFeatLabel][value] = createTree(splitDataSet(dataSet, bestFeat, value),subLabels)#递归得到下一层内容
return myTree
La primera función es a mano alzada, mucha explicación
segunda función es una estructura de árbol recursivo (diccionario), se añadió a cada dato de las características más altas de impacto.
Los resultados obtenidos fueron los siguientes:
