03機器學習實戰之決策樹

時間  2019-11-16
標籤 機器 學習 實戰 決策樹 简体版
原文   原文鏈接

決策樹 概述

決策樹（Decision Tree）算法是一種基本的分類與迴歸方法，是最常用的數據挖掘算法之一。咱們這章節只討論用於分類的決策樹。javascript

決策樹模型呈樹形結構，在分類問題中，表示基於特徵對實例進行分類的過程。它能夠認爲是 if-then 規則的集合，也能夠認爲是定義在特徵空間與類空間上的條件機率分佈。css

決策樹學習一般包括 3 個步驟：特徵選擇、決策樹的生成和決策樹的修剪。html

決策樹 場景

 

決策樹的定義：html5

分類決策樹模型是一種描述對實例進行分類的樹形結構。決策樹由結點（node）和有向邊（directed edge）組成。結點有兩種類型：內部結點（internal node）和葉結點（leaf node）。內部結點表示一個特徵或屬性(features)，葉結點表示一個類(labels)。java

用決策樹對須要測試的實例進行分類：從根節點開始，對實例的某一特徵進行測試，根據測試結果，將實例分配到其子結點；這時，每個子結點對應着該特徵的一個取值。如此遞歸地對實例進行測試並分配，直至達到葉結點。最後將實例分配到葉結點的類中。node

決策樹 原理

決策樹 須知概念

信息熵 & 信息增益

熵（entropy）： 熵指的是體系的混亂的程度，在不一樣的學科中也有引伸出的更爲具體的定義，是各領域十分重要的參量。python

信息論（information theory）中的熵（香農熵）： 是一種信息的度量方式，表示信息的混亂程度，也就是說：信息越有序，信息熵越低。例如：火柴有序放在火柴盒裏，熵值很低，相反，熵值很高。jquery

信息增益（information gain）： 在劃分數據集先後信息發生的變化稱爲信息增益。linux

決策樹 工做原理

如何構造一個決策樹?
咱們使用 createBranch() 方法，以下所示：android

def createBranch():
'''
此處運用了迭代的思想。 感興趣能夠搜索 迭代 recursion， 甚至是 dynamic programing。
'''
    檢測數據集中的全部數據的分類標籤是否相同:
        If so return 類標籤
        Else:
            尋找劃分數據集的最好特徵（劃分以後信息熵最小，也就是信息增益最大的特徵）
            劃分數據集
            建立分支節點
                for 每一個劃分的子集
                    調用函數 createBranch （建立分支的函數）並增長返回結果到分支節點中
            return 分支節點

決策樹 開發流程

收集數據：可使用任何方法。
準備數據：樹構造算法 (這裏使用的是ID3算法，只適用於標稱型數據，這就是爲何數值型數據必須離散化。 還有其餘的樹構造算法，好比CART)
分析數據：可使用任何方法，構造樹完成以後，咱們應該檢查圖形是否符合預期。
訓練算法：構造樹的數據結構。
測試算法：使用訓練好的樹計算錯誤率。
使用算法：此步驟能夠適用於任何監督學習任務，而使用決策樹能夠更好地理解數據的內在含義。

決策樹 算法特色

優勢：計算複雜度不高，輸出結果易於理解，數據有缺失也能跑，能夠處理不相關特徵。
缺點：容易過擬合。
適用數據類型：數值型和標稱型。


項目案例1: 斷定魚類和非魚類

項目概述

根據如下 2 個特徵，將動物分紅兩類：魚類和非魚類。

特徵：

  1. 在水中是否能夠生存
  2. 是否有腳蹼

開發流程

收集數據：可使用任何方法
準備數據：樹構造算法（這裏使用的是ID3算法，所以數值型數據必須離散化。）
分析數據：可使用任何方法，構造樹完成以後，咱們能夠將樹畫出來。
訓練算法：構造樹結構
測試算法：使用習得的決策樹執行分類
使用算法：此步驟能夠適用於任何監督學習任務，而使用決策樹能夠更好地理解數據的內在含義

收集數據：可使用任何方法

海洋生物數據

dataSet = [[1, 1, 'yes'],
           [1, 1, 'yes'],
           [1, 0, 'no'],
           [0, 1, 'no'],
           [0, 1, 'no']]
# labels  露出水面   腳蹼，注意：這裏的labels是寫的 dataSet 中特徵的含義，並非對應的分類標籤或者說目標變量
labels = ['no surfacing', 'flippers']

準備數據：樹構造算法

此處，因爲咱們輸入的數據自己就是離散化數據，因此這一步就省略了。

分析數據：可使用任何方法，構造樹完成以後，咱們能夠將樹畫出來。

熵的計算公式

計算給定數據集的香農熵的函數

from math import log


def calcShannonEnt(dataSet):
    """
    Desc：
        calculate Shannon entropy -- 計算給定數據集的香農熵
    Args:
        dataSet -- 數據集
    Returns:
        shannonEnt -- 返回 每一組 feature 下的某個分類下，香農熵的信息指望
    """
    # -----------計算香農熵的第一種實現方式start--------------------------------------------------------------------------------
    # 求list的長度，表示計算參與訓練的數據量
    numEntries = len(dataSet)
    # 下面輸出咱們測試的數據集的一些信息

    # 計算分類標籤label出現的次數
    labelCounts = {}
    # the the number of unique elements and their occurance
    for featVec in dataSet:
        # 將當前實例的標籤存儲，即每一行數據的最後一個數據表明的是標籤
        currentLabel = featVec[-1]
        # 爲全部可能的分類建立字典，若是當前的鍵值不存在，則擴展字典並將當前鍵值加入字典。每一個鍵值都記錄了當前類別出現的次數。
        if currentLabel not in labelCounts.keys():
            labelCounts[currentLabel] = 0
        labelCounts[currentLabel] += 1

    # 對於label標籤的佔比，求出label標籤的香農熵
    shannonEnt = 0.0
    for key in labelCounts:
        # 使用全部類標籤的發生頻率計算類別出現的機率。
        prob = float(labelCounts[key]) / numEntries
        # 計算香農熵，以 2 爲底求對數
        shannonEnt -= prob * log(prob, 2)
    # -----------計算香農熵的第一種實現方式end--------------------------------------------------------------------------------

    # # -----------計算香農熵的第二種實現方式start--------------------------------------------------------------------------------
    # # 統計標籤出現的次數
    # label_count = Counter(data[-1] for data in dataSet)
    # # 計算機率
    # probs = [p[1] / len(dataSet) for p in label_count.items()]
    # # 計算香農熵
    # shannonEnt = sum([-p * log(p, 2) for p in probs])
    # # -----------計算香農熵的第二種實現方式end--------------------------------------------------------------------------------
    return shannonEnt

 

按照給定特徵劃分數據集

將指定特徵的特徵值等於 value 的行剩下列做爲子數據集。

def splitDataSet(dataSet, index, value):
    """
    Desc：
        劃分數據集
        splitDataSet(經過遍歷dataSet數據集，求出index對應的colnum列的值爲value的行)
        就是依據index列進行分類，若是index列的數據等於 value的時候，就要將 index 劃分到咱們建立的新的數據集中
    Args:
        dataSet  -- 數據集                 待劃分的數據集
        index -- 表示每一行的index列        劃分數據集的特徵
        value -- 表示index列對應的value值   須要返回的特徵的值。
    Returns:
        index 列爲 value 的數據集【該數據集須要排除index列】
    """
    # -----------切分數據集的第一種方式 start------------------------------------
    retDataSet = []
    for featVec in dataSet: 
        # index列爲value的數據集【該數據集須要排除index列】
        # 判斷index列的值是否爲value
        if featVec[index] == value:
            # chop out index used for splitting
            # [:index]表示前index行，即若 index 爲2，就是取 featVec 的前 index 行
            reducedFeatVec = featVec[:index]
            '''
            請百度查詢一下： extend和append的區別
            list.append(object) 向列表中添加一個對象object
            list.extend(sequence) 把一個序列seq的內容添加到列表中
            一、使用append的時候，是將new_media看做一個對象，總體打包添加到music_media對象中。
            二、使用extend的時候，是將new_media看做一個序列，將這個序列和music_media序列合併，並放在其後面。
            result = []
            result.extend([1,2,3])
            print(result)
            result.append([4,5,6])
            print(result)
            result.extend([7,8,9])
            print(result)
            結果：
            [1, 2, 3]
            [1, 2, 3, [4, 5, 6]]
            [1, 2, 3, [4, 5, 6], 7, 8, 9]
            '''
            reducedFeatVec.extend(featVec[index+1:])
            # [index+1:]表示從跳過 index 的 index+1行，取接下來的數據
            # 收集結果值 index列爲value的行【該行須要排除index列】
            retDataSet.append(reducedFeatVec)
    # -----------切分數據集的第一種方式 end------------------------------------

    # # -----------切分數據集的第二種方式 start------------------------------------
    # retDataSet = [data[:index] + data[index + 1:] for data in dataSet 
    # for i, v in enumerate(data) if i == index and v == value]
    # # -----------切分數據集的第二種方式 end------------------------------------
    return retDataSet

選擇最好的數據集劃分方式

def chooseBestFeatureToSplit(dataSet):
    """
    Desc:
        選擇切分數據集的最佳特徵
    Args:
        dataSet -- 須要切分的數據集
    Returns:
        bestFeature -- 切分數據集的最優的特徵列
    """

    # -----------選擇最優特徵的第一種方式 start------------------------------------
    # 求第一行有多少列的 Feature, 最後一列是label列嘛
    numFeatures = len(dataSet[0]) - 1
    # label的信息熵
    baseEntropy = calcShannonEnt(dataSet)
    # 最優的信息增益值, 和最優的Featurn編號
    bestInfoGain = 0.0
    bestFeature = -1
    # iterate over all the features
    for i in range(numFeatures):
        # create a list of all the examples of this feature
        # 獲取每個實例的第i+1個feature，組成list集合
        featList = [example[i] for example in dataSet]
        # get a set of unique values
        # 獲取剔重後的集合，使用set對list數據進行去重
        uniqueVals = set(featList)
        # 建立一個臨時的信息熵
        newEntropy = 0.0
        # 遍歷某一列的value集合，計算該列的信息熵 
        # 遍歷當前特徵中的全部惟一屬性值，對每一個惟一屬性值劃分一次數據集，計算數據集的新熵值，並對全部惟一特徵值獲得的熵求和。
        for value in uniqueVals:
            subDataSet = splitDataSet(dataSet, i, value)
            prob = len(subDataSet) / float(len(dataSet))
            newEntropy += prob * calcShannonEnt(subDataSet)
        # gain[信息增益]: 劃分數據集先後的信息變化， 獲取信息熵最大的值
        # 信息增益是熵的減小或者是數據無序度的減小。最後，比較全部特徵中的信息增益，返回最好特徵劃分的索引值。
        infoGain = baseEntropy - newEntropy
        print('infoGain=', infoGain, 'bestFeature=', i, baseEntropy, newEntropy)
        if infoGain > bestInfoGain:
            bestInfoGain = infoGain
            bestFeature = i
    return bestFeature
    # -----------選擇最優特徵的第一種方式 end------------------------------------

    # # -----------選擇最優特徵的第二種方式 start------------------------------------
    # # 計算初始香農熵
    # base_entropy = calcShannonEnt(dataSet)
    # best_info_gain = 0
    # best_feature = -1
    # # 遍歷每個特徵
    # for i in range(len(dataSet[0]) - 1):
    #     # 對當前特徵進行統計
    #     feature_count = Counter([data[i] for data in dataSet])
    #     # 計算分割後的香農熵
    #     new_entropy = sum(feature[1] / float(len(dataSet)) * calcShannonEnt(splitDataSet(dataSet, i, feature[0])) \
    #                    for feature in feature_count.items())
    #     # 更新值
    #     info_gain = base_entropy - new_entropy
    #     print('No. {0} feature info gain is {1:.3f}'.format(i, info_gain))
    #     if info_gain > best_info_gain:
    #         best_info_gain = info_gain
    #         best_feature = i
    # return best_feature
    # # -----------選擇最優特徵的第二種方式 end---------

建立樹的函數代碼以下：

def createTree(dataSet, labels):
    """
    Desc:
        建立決策樹
    Args:
        dataSet -- 要建立決策樹的訓練數據集
        labels -- 訓練數據集中特徵對應的含義的labels，不是目標變量
    Returns:
        myTree -- 建立完成的決策樹
    """
    classList = [example[-1] for example in dataSet]
    # 若是數據集的最後一列的第一個值出現的次數=整個集合的數量，也就說只有一個類別，就只直接返回結果就行
    # 第一個中止條件：全部的類標籤徹底相同，則直接返回該類標籤。
    # count() 函數是統計括號中的值在list中出現的次數
    if classList.count(classList[0]) == len(classList):
        return classList[0]
    # 若是數據集只有1列，那麼最初出現label次數最多的一類，做爲結果
    # 第二個中止條件：使用完了全部特徵，仍然不能將數據集劃分紅僅包含惟一類別的分組。
    if len(dataSet[0]) == 1:  # 此處是有遞歸
        return majorityCnt(classList)

    # 選擇最優的列，獲得最優列對應的label含義
    bestFeat = chooseBestFeatureToSplit(dataSet)
    # 獲取label的名稱
    bestFeatLabel = labels[bestFeat]
    # 初始化myTree
    myTree = {bestFeatLabel: {}}
    # 注：labels列表是可變對象，在PYTHON函數中做爲參數時傳址引用，可以被全局修改
    # 因此這行代碼致使函數外的同名變量被刪除了元素，形成例句沒法執行，提示'no surfacing' is not in list
    del(labels[bestFeat])
    # 取出最優列，而後它的branch作分類
    featValues = [example[bestFeat] for example in dataSet]
    uniqueVals = set(featValues)
    for value in uniqueVals:
        # 求出剩餘的標籤label
        subLabels = labels[:]
        # 遍歷當前選擇特徵包含的全部屬性值，在每一個數據集劃分上遞歸調用函數createTree()
        myTree[bestFeatLabel][value] = createTree(splitDataSet(dataSet, bestFeat, value), subLabels)
        # print('myTree', value, myTree)
    return myTree

測試算法：使用決策樹執行分類

def classify(inputTree, featLabels, testVec):
    """
    Desc:
        對新數據進行分類
    Args:
        inputTree  -- 已經訓練好的決策樹模型
        featLabels -- Feature標籤對應的名稱，不是目標變量
        testVec    -- 測試輸入的數據
    Returns:
        classLabel -- 分類的結果值，須要映射label才能知道名稱
    """
    # 獲取tree的根節點對於的key值
    firstStr = list(inputTree.keys())[0]
    # 經過key獲得根節點對應的value
    secondDict = inputTree[firstStr]
    # 判斷根節點名稱獲取根節點在label中的前後順序，這樣就知道輸入的testVec怎麼開始對照樹來作分類
    featIndex = featLabels.index(firstStr)
    # 測試數據，找到根節點對應的label位置，也就知道從輸入的數據的第幾位來開始分類
    key = testVec[featIndex]
    valueOfFeat = secondDict[key]
    print('+++', firstStr, 'xxx', secondDict, '---', key, '>>>', valueOfFeat)
    # 判斷分枝是否結束: 判斷valueOfFeat是不是dict類型
    if isinstance(valueOfFeat, dict):
        classLabel = classify(valueOfFeat, featLabels, testVec)
    else:
        classLabel = valueOfFeat
    return classLabel
In [100]: 
dataSet = [[1, 1, 'yes'],
           [1, 1, 'yes'],
           [1, 0, 'no'],
           [0, 1, 'no'],
           [0, 1, 'no']]
# labels  露出水面   腳蹼，注意：這裏的labels是寫的 dataSet 中特徵的含義，並非對應的分類標籤或者說目標變量
labels = ['no surfacing', 'flippers']
In [101]: 
from math import log


def calcShannonEnt(dataSet):
    """
    Desc：
        calculate Shannon entropy -- 計算給定數據集的香農熵
    Args:
        dataSet -- 數據集
    Returns:
        shannonEnt -- 返回 每一組 feature 下的某個分類下，香農熵的信息指望
    """
    # -----------計算香農熵的第一種實現方式start--------------------------------------------------------------------------------
    # 求list的長度，表示計算參與訓練的數據量
    numEntries = len(dataSet)
    # 下面輸出咱們測試的數據集的一些信息

    # 計算分類標籤label出現的次數
    labelCounts = {}
    # the the number of unique elements and their occurance
    for featVec in dataSet:
        # 將當前實例的標籤存儲，即每一行數據的最後一個數據表明的是標籤
        currentLabel = featVec[-1]
        # 爲全部可能的分類建立字典，若是當前的鍵值不存在，則擴展字典並將當前鍵值加入字典。每一個鍵值都記錄了當前類別出現的次數。
        if currentLabel not in labelCounts.keys():
            labelCounts[currentLabel] = 0
        labelCounts[currentLabel] += 1

    # 對於label標籤的佔比，求出label標籤的香農熵
    shannonEnt = 0.0
    for key in labelCounts:
        # 使用全部類標籤的發生頻率計算類別出現的機率。
        prob = float(labelCounts[key]) / numEntries
        # 計算香農熵，以 2 爲底求對數
        shannonEnt -= prob * log(prob, 2)
    # -----------計算香農熵的第一種實現方式end--------------------------------------------------------------------------------

    # # -----------計算香農熵的第二種實現方式start--------------------------------------------------------------------------------
    # # 統計標籤出現的次數
    # label_count = Counter(data[-1] for data in dataSet)
    # # 計算機率
    # probs = [p[1] / len(dataSet) for p in label_count.items()]
    # # 計算香農熵
    # shannonEnt = sum([-p * log(p, 2) for p in probs])
    # # -----------計算香農熵的第二種實現方式end--------------------------------------------------------------------------------
    return shannonEnt
In [102]: 
def splitDataSet(dataSet, index, value):
    """
    Desc：
        劃分數據集
        splitDataSet(經過遍歷dataSet數據集，求出index對應的colnum列的值爲value的行)
        就是依據index列進行分類，若是index列的數據等於 value的時候，就要將 index 劃分到咱們建立的新的數據集中
    Args:
        dataSet  -- 數據集                 待劃分的數據集
        index -- 表示每一行的index列        劃分數據集的特徵
        value -- 表示index列對應的value值   須要返回的特徵的值。
    Returns:
        index 列爲 value 的數據集【該數據集須要排除index列】
    """
    # -----------切分數據集的第一種方式 start------------------------------------
    retDataSet = []
    for featVec in dataSet: 
        # index列爲value的數據集【該數據集須要排除index列】
        # 判斷index列的值是否爲value
        if featVec[index] == value:
            # chop out index used for splitting
            # [:index]表示前index行，即若 index 爲2，就是取 featVec 的前 index 行
            reducedFeatVec = featVec[:index]
            '''
            請百度查詢一下： extend和append的區別
            list.append(object) 向列表中添加一個對象object
            list.extend(sequence) 把一個序列seq的內容添加到列表中
            一、使用append的時候，是將new_media看做一個對象，總體打包添加到music_media對象中。
            二、使用extend的時候，是將new_media看做一個序列，將這個序列和music_media序列合併，並放在其後面。
            result = []
            result.extend([1,2,3])
            print(result)
            result.append([4,5,6])
            print(result)
            result.extend([7,8,9])
            print(result)
            結果：
            [1, 2, 3]
            [1, 2, 3, [4, 5, 6]]
            [1, 2, 3, [4, 5, 6], 7, 8, 9]
            '''
            reducedFeatVec.extend(featVec[index+1:])
            # [index+1:]表示從跳過 index 的 index+1行，取接下來的數據
            # 收集結果值 index列爲value的行【該行須要排除index列】
            retDataSet.append(reducedFeatVec)
    # -----------切分數據集的第一種方式 end------------------------------------

    # # -----------切分數據集的第二種方式 start------------------------------------
    # retDataSet = [data[:index] + data[index + 1:] for data in dataSet 
    # for i, v in enumerate(data) if i == index and v == value]
    # # -----------切分數據集的第二種方式 end------------------------------------
    return retDataSet
In [103]: 
splitDataSet(dataSet, 0, 1)
Out[103]: 
[[1, 'yes'], [1, 'yes'], [0, 'no']]
In [104]: 
splitDataSet(dataSet, 0, 0)
Out[104]: 
[[1, 'no'], [1, 'no']]
In [105]: 
def chooseBestFeatureToSplit(dataSet):
    """
    Desc:
        選擇切分數據集的最佳特徵
    Args:
        dataSet -- 須要切分的數據集
    Returns:
        bestFeature -- 切分數據集的最優的特徵列
    """

    # -----------選擇最優特徵的第一種方式 start------------------------------------
    # 求第一行有多少列的 Feature, 最後一列是label列嘛
    numFeatures = len(dataSet[0]) - 1
    # label的信息熵
    baseEntropy = calcShannonEnt(dataSet)
    # 最優的信息增益值, 和最優的Featurn編號
    bestInfoGain = 0.0
    bestFeature = -1
    # iterate over all the features
    for i in range(numFeatures):
        # create a list of all the examples of this feature
        # 獲取每個實例的第i+1個feature，組成list集合
        featList = [example[i] for example in dataSet]
        # get a set of unique values
        # 獲取剔重後的集合，使用set對list數據進行去重
        uniqueVals = set(featList)
        # 建立一個臨時的信息熵
        newEntropy = 0.0
        # 遍歷某一列的value集合，計算該列的信息熵 
        # 遍歷當前特徵中的全部惟一屬性值，對每一個惟一屬性值劃分一次數據集，計算數據集的新熵值，並對全部惟一特徵值獲得的熵求和。
        for value in uniqueVals:
            subDataSet = splitDataSet(dataSet, i, value)
            prob = len(subDataSet) / float(len(dataSet))
            newEntropy += prob * calcShannonEnt(subDataSet)
        # gain[信息增益]: 劃分數據集先後的信息變化， 獲取信息熵最大的值
        # 信息增益是熵的減小或者是數據無序度的減小。最後，比較全部特徵中的信息增益，返回最好特徵劃分的索引值。
        infoGain = baseEntropy - newEntropy
        print('infoGain=', infoGain, 'bestFeature=', i, baseEntropy, newEntropy)
        if infoGain > bestInfoGain:
            bestInfoGain = infoGain
            bestFeature = i
    return bestFeature
    # -----------選擇最優特徵的第一種方式 end------------------------------------

    # # -----------選擇最優特徵的第二種方式 start------------------------------------
    # # 計算初始香農熵
    # base_entropy = calcShannonEnt(dataSet)
    # best_info_gain = 0
    # best_feature = -1
    # # 遍歷每個特徵
    # for i in range(len(dataSet[0]) - 1):
    #     # 對當前特徵進行統計
    #     feature_count = Counter([data[i] for data in dataSet])
    #     # 計算分割後的香農熵
    #     new_entropy = sum(feature[1] / float(len(dataSet)) * calcShannonEnt(splitDataSet(dataSet, i, feature[0])) \
    #                    for feature in feature_count.items())
    #     # 更新值
    #     info_gain = base_entropy - new_entropy
    #     print('No. {0} feature info gain is {1:.3f}'.format(i, info_gain))
    #     if info_gain > best_info_gain:
    #         best_info_gain = info_gain
    #         best_feature = i
    # return best_feature
    # # -----------選擇最優特徵的第二種方式 end---------
In [106]: 
chooseBestFeatureToSplit(dataSet)
  
infoGain= 0.4199730940219749 bestFeature= 0 0.9709505944546686 0.5509775004326937
infoGain= 0.17095059445466854 bestFeature= 1 0.9709505944546686 0.8
Out[106]: 
0
In [107]: 
import operator


def majorityCnt(classList):
    """
    Desc:
        選擇出現次數最多的一個結果
    Args:
        classList label列的集合
    Returns:
        bestFeature 最優的特徵列
    """
    # -----------majorityCnt的第一種方式 start------------------------------------
    classCount = {}
    for vote in classList:
        if vote not in classCount.keys():
            classCount[vote] = 0
        classCount[vote] += 1
    # 倒敘排列classCount獲得一個字典集合，而後取出第一個就是結果（yes/no），即出現次數最多的結果
    sortedClassCount = sorted(classCount.items(), key=operator.itemgetter(1), reverse=True)
    # print('sortedClassCount:', sortedClassCount)
    return sortedClassCount[0][0]
    # -----------majorityCnt的第一種方式 end------------------------------------

    # # -----------majorityCnt的第二種方式 start------------------------------------
    # major_label = Counter(classList).most_common(1)[0]
    # return major_label
    # # -----------majorityCnt的第二種方式 end------------------------------------
In [108]: 
def createTree(dataSet, labels):
    """
    Desc:
        建立決策樹
    Args:
        dataSet -- 要建立決策樹的訓練數據集
        labels -- 訓練數據集中特徵對應的含義的labels，不是目標變量
    Returns:
        myTree -- 建立完成的決策樹
    """
    classList = [example[-1] for example in dataSet]
    # 若是數據集的最後一列的第一個值出現的次數=整個集合的數量，也就說只有一個類別，就只直接返回結果就行
    # 第一個中止條件：全部的類標籤徹底相同，則直接返回該類標籤。
    # count() 函數是統計括號中的值在list中出現的次數
    if classList.count(classList[0]) == len(classList):
        return classList[0]
    # 若是數據集只有1列，那麼最初出現label次數最多的一類，做爲結果
    # 第二個中止條件：使用完了全部特徵，仍然不能將數據集劃分紅僅包含惟一類別的分組。
    if len(dataSet[0]) == 1:  # 此處是有遞歸
        return majorityCnt(classList)

    # 選擇最優的列，獲得最優列對應的label含義
    bestFeat = chooseBestFeatureToSplit(dataSet)
    # 獲取label的名稱
    bestFeatLabel = labels[bestFeat]
    # 初始化myTree
    myTree = {bestFeatLabel: {}}
    # 注：labels列表是可變對象，在PYTHON函數中做爲參數時傳址引用，可以被全局修改
    # 因此這行代碼致使函數外的同名變量被刪除了元素，形成例句沒法執行，提示'no surfacing' is not in list
    del(labels[bestFeat])
    # 取出最優列，而後它的branch作分類
    featValues = [example[bestFeat] for example in dataSet]
    uniqueVals = set(featValues)
    for value in uniqueVals:
        # 求出剩餘的標籤label
        subLabels = labels[:]
        # 遍歷當前選擇特徵包含的全部屬性值，在每一個數據集劃分上遞歸調用函數createTree()
        myTree[bestFeatLabel][value] = createTree(splitDataSet(dataSet, bestFeat, value), subLabels)
        # print('myTree', value, myTree)
    return myTree
In [109]: 
t = createTree(dataSet, labels)
print(t)
  
infoGain= 0.4199730940219749 bestFeature= 0 0.9709505944546686 0.5509775004326937
infoGain= 0.17095059445466854 bestFeature= 1 0.9709505944546686 0.8
infoGain= 0.9182958340544896 bestFeature= 0 0.9182958340544896 0.0
{'no surfacing': {0: 'no', 1: {'flippers': {0: 'no', 1: 'yes'}}}}
In [113]: 
def classify(inputTree, featLabels, testVec):
    """
    Desc:
        對新數據進行分類
    Args:
        inputTree  -- 已經訓練好的決策樹模型
        featLabels -- Feature標籤對應的名稱，不是目標變量
        testVec    -- 測試輸入的數據
    Returns:
        classLabel -- 分類的結果值，須要映射label才能知道名稱
    """
    # 獲取tree的根節點對於的key值
    firstStr = list(inputTree.keys())[0]
    # 經過key獲得根節點對應的value
    secondDict = inputTree[firstStr]
    # 判斷根節點名稱獲取根節點在label中的前後順序，這樣就知道輸入的testVec怎麼開始對照樹來作分類
    featIndex = featLabels.index(firstStr)
    # 測試數據，找到根節點對應的label位置，也就知道從輸入的數據的第幾位來開始分類
    key = testVec[featIndex]
    valueOfFeat = secondDict[key]
    print('+++', firstStr, 'xxx', secondDict, '---', key, '>>>', valueOfFeat)
    # 判斷分枝是否結束: 判斷valueOfFeat是不是dict類型
    if isinstance(valueOfFeat, dict):
        classLabel = classify(valueOfFeat, featLabels, testVec)
    else:
        classLabel = valueOfFeat
    return classLabel
In [114]: 
classify(t, ['no surfacing', 'flippers'], [1, 1])
  
+++ no surfacing xxx {0: 'no', 1: {'flippers': {0: 'no', 1: 'yes'}}} --- 1 >>> {'flippers': {0: 'no', 1: 'yes'}}
+++ flippers xxx {0: 'no', 1: 'yes'} --- 1 >>> yes
Out[114]: 
'yes'
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程