什么是剪枝函數(shù)？有何作用？為何要在分支限界法中使用

用約束函數(shù)在擴展結(jié)點處剪去不滿足約束的子樹； 和用限界函數(shù)剪去得不到最優(yōu)解的子 樹。這兩類函數(shù)統(tǒng)稱為剪枝函數(shù)。

創(chuàng)新互聯(lián)公司是專業(yè)的谷城網(wǎng)站建設(shè)公司，谷城接單;提供成都網(wǎng)站制作、成都做網(wǎng)站,網(wǎng)頁設(shè)計,網(wǎng)站設(shè)計,建網(wǎng)站,PHP網(wǎng)站建設(shè)等專業(yè)做網(wǎng)站服務(wù);采用PHP框架,可快速的進行谷城網(wǎng)站開發(fā)網(wǎng)頁制作和功能擴展;專業(yè)做搜索引擎喜愛的網(wǎng)站,專業(yè)的做網(wǎng)站團隊,希望更多企業(yè)前來合作!

采用剪枝函數(shù)，可避免無效搜索，提高回溯法的搜索效率。 在分支限界法中使用剪枝函數(shù)， 可以加速搜索。 該函數(shù)給出每一個可行結(jié)點相應(yīng)的子樹可能獲得的最大價值的上界。如果這個上界不比當前最優(yōu)值更大， 則說明相應(yīng)的子樹中不含問題的最優(yōu)解，因而可以剪去。

搜索策略

在當前節(jié)點（擴展節(jié)點）處，先生成其所有的子節(jié)點（分支），然后再從當前的活節(jié)點（當前節(jié)點的子節(jié)點）表中選擇下一個擴展節(jié)點。為了有效地選擇下一個擴展節(jié)點，加速搜索的進程，在每一個活節(jié)點處；

計算一個函數(shù)值（限界），并根據(jù)函數(shù)值，從當前活節(jié)點表中選擇一個最有利的節(jié)點作為擴展節(jié)點，使搜索朝著解空間上有最優(yōu)解的分支推進，以便盡快地找出一個最優(yōu)解。分支限界法解決了大量離散最優(yōu)化的問題。

以上內(nèi)容參考：百度百科-分支限界法

用python實現(xiàn)紅酒數(shù)據(jù)集的ID3,C4.5和CART算法？

ID3算法介紹

ID3算法全稱為迭代二叉樹3代算法（Iterative Dichotomiser 3）

該算法要先進行特征選擇，再生成決策樹，其中特征選擇是基于“信息增益”最大的原則進行的。

但由于決策樹完全基于訓練集生成的，有可能對訓練集過于“依賴”，即產(chǎn)生過擬合現(xiàn)象。因此在生成決策樹后，需要對決策樹進行剪枝。剪枝有兩種形式，分別為前剪枝（Pre-Pruning）和后剪枝（Post-Pruning），一般采用后剪枝。

信息熵、條件熵和信息增益

信息熵：來自于香農(nóng)定理，表示信息集合所含信息的平均不確定性。信息熵越大，表示不確定性越大，所含的信息量也就越大。

設(shè)x 1 , x 2 , x 3 , . . . x n {x_1, x_2, x_3, ...x_n}x

1

,x

2

,x

3

,...x

n

為信息集合X的n個取值，則x i x_ix

i

的概率：

P ( X = i ) = p i , i = 1 , 2 , 3 , . . . , n P(X=i) = p_i, i=1,2,3,...,n

P(X=i)=p

i

,i=1,2,3,...,n

信息集合X的信息熵為：

H ( X ) = ? ∑ i = 1 n p i log ? p i H(X) =- \sum_{i=1}^{n}{p_i}\log{p_i}

H(X)=?

i=1

∑

n

p

i

logp

i

條件熵：指已知某個隨機變量的情況下，信息集合的信息熵。

設(shè)信息集合X中有y 1 , y 2 , y 3 , . . . y m {y_1, y_2, y_3, ...y_m}y

1

,y

2

,y

3

,...y

m

組成的隨機變量集合Y，則隨機變量（X，Y）的聯(lián)合概率分布為

P ( x = i , y = j ) = p i j P(x=i,y=j) = p_{ij}

P(x=i,y=j)=p

ij

條件熵：

H ( X ∣ Y ) = ∑ j = 1 m p ( y j ) H ( X ∣ y j ) H(X|Y) = \sum_{j=1}^m{p(y_j)H(X|y_j)}

H(X∣Y)=

j=1

∑

m

p(y

j

)H(X∣y

j

)

由

H ( X ∣ y j ) = ? ∑ j = 1 m p ( y j ) ∑ i = 1 n p ( x i ∣ y j ) log ? p ( x i ∣ y j ) H(X|y_j) = - \sum_{j=1}^m{p(y_j)}\sum_{i=1}^n{p(x_i|y_j)}\log{p(x_i|y_j)}

H(X∣y

j

)=?

j=1

∑

m

p(y

j

)

i=1

∑

n

p(x

i

∣y

j

)logp(x

i

∣y

j

)

和貝葉斯公式：

p ( x i y j ) = p ( x i ∣ y j ) p ( y j ) p(x_iy_j) = p(x_i|y_j)p(y_j)

p(x

i

y

j

)=p(x

i

∣y

j

)p(y

j

)

可以化簡條件熵的計算公式為:

H ( X ∣ Y ) = ∑ j = 1 m ∑ i = 1 n p ( x i , y j ) log ? p ( x i ) p ( x i , y j ) H(X|Y) = \sum_{j=1}^m \sum_{i=1}^n{p(x_i, y_j)\log\frac{p(x_i)}{p(x_i, y_j)}}

H(X∣Y)=

j=1

∑

m

i=1

∑

n

p(x

i

,y

j

)log

p(x

i

,y

j

)

p(x

i

)

信息增益：信息熵-條件熵，用于衡量在知道已知隨機變量后，信息不確定性減小越大。

d ( X , Y ) = H ( X ) ? H ( X ∣ Y ) d(X,Y) = H(X) - H(X|Y)

d(X,Y)=H(X)?H(X∣Y)

python代碼實現(xiàn)

import numpy as np

import math

def calShannonEnt(dataSet):

""" 計算信息熵 """

labelCountDict = {}

for d in dataSet:

label = d[-1]

if label not in labelCountDict.keys():

labelCountDict[label] = 1

else:

labelCountDict[label] += 1

entropy = 0.0

for l, c in labelCountDict.items():

p = 1.0 * c / len(dataSet)

entropy -= p * math.log(p, 2)

return entropy

def filterSubDataSet(dataSet, colIndex, value):

"""返回colIndex特征列l(wèi)abel等于value，并且過濾掉改特征列的數(shù)據(jù)集"""

subDataSetList = []

for r in dataSet:

if r[colIndex] == value:

newR = r[:colIndex]

newR = np.append(newR, (r[colIndex + 1:]))

subDataSetList.append(newR)

return np.array(subDataSetList)

def chooseFeature(dataSet):

""" 通過計算信息增益選擇最合適的特征"""

featureNum = dataSet.shape[1] - 1

entropy = calShannonEnt(dataSet)

bestInfoGain = 0.0

bestFeatureIndex = -1

for i in range(featureNum):

uniqueValues = np.unique(dataSet[:, i])

condition_entropy = 0.0

for v in uniqueValues: #計算條件熵

subDataSet = filterSubDataSet(dataSet, i, v)

p = 1.0 * len(subDataSet) / len(dataSet)

condition_entropy += p * calShannonEnt(subDataSet)

infoGain = entropy - condition_entropy #計算信息增益

if infoGain = bestInfoGain: #選擇最大信息增益

bestInfoGain = infoGain

bestFeatureIndex = i

return bestFeatureIndex

def creatDecisionTree(dataSet, featNames):

""" 通過訓練集生成決策樹 """

featureName = featNames[:] # 拷貝featNames，此處不能直接用賦值操作，否則新變量會指向舊變量的地址

classList = list(dataSet[:, -1])

if len(set(classList)) == 1: # 只有一個類別

return classList[0]

if dataSet.shape[1] == 1: #當所有特征屬性都利用完仍然無法判斷樣本屬于哪一類，此時歸為該數(shù)據(jù)集中數(shù)量最多的那一類

return max(set(classList), key=classList.count)

bestFeatureIndex = chooseFeature(dataSet) #選擇特征

bestFeatureName = featNames[bestFeatureIndex]

del featureName[bestFeatureIndex] #移除已選特征列

decisionTree = {bestFeatureName: {}}

featureValueUnique = sorted(set(dataSet[:, bestFeatureIndex])) #已選特征列所包含的類別， 通過遞歸生成決策樹

for v in featureValueUnique:

copyFeatureName = featureName[:]

subDataSet = filterSubDataSet(dataSet, bestFeatureIndex, v)

decisionTree[bestFeatureName][v] = creatDecisionTree(subDataSet, copyFeatureName)

return decisionTree

def classify(decisionTree, featnames, featList):

""" 使用訓練所得的決策樹進行分類 """

classLabel = None

root = decisionTree.keys()[0]

firstGenDict = decisionTree[root]

featIndex = featnames.index(root)

for k in firstGenDict.keys():

if featList[featIndex] == k:

if isinstance(firstGenDict[k], dict): #若子節(jié)點仍是樹，則遞歸查找

classLabel = classify(firstGenDict[k], featnames, featList)

else:

classLabel = firstGenDict[k]

return classLabel

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

下面用鳶尾花數(shù)據(jù)集對該算法進行測試。由于ID3算法只能用于標稱型數(shù)據(jù)，因此用在對連續(xù)型的數(shù)值數(shù)據(jù)上時，還需要對數(shù)據(jù)進行離散化，離散化的方法稍后說明，此處為了簡化，先使用每一種特征所有連續(xù)性數(shù)值的中值作為分界點，小于中值的標記為1，大于中值的標記為0。訓練1000次，統(tǒng)計準確率均值。

from sklearn import datasets

from sklearn.model_selection import train_test_split

iris = datasets.load_iris()

data = np.c_[iris.data, iris.target]

scoreL = []

for i in range(1000): #對該過程進行10000次

trainData, testData = train_test_split(data) #區(qū)分測試集和訓練集

featNames = iris.feature_names[:]

for i in range(trainData.shape[1] - 1): #對訓練集每個特征，以中值為分界點進行離散化

splitPoint = np.mean(trainData[:, i])

featNames[i] = featNames[i]+'='+'{:.3f}'.format(splitPoint)

trainData[:, i] = [1 if x = splitPoint else 0 for x in trainData[:, i]]

testData[:, i] = [1 if x = splitPoint else 0 for x in testData[:, i]]

decisionTree = creatDecisionTree(trainData, featNames)

classifyLable = [classify(decisionTree, featNames, td) for td in testData]

scoreL.append(1.0 * sum(classifyLable == testData[:, -1]) / len(classifyLable))

print 'score: ', np.mean(scoreL)

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

輸出結(jié)果為：score: 0.7335，即準確率有73%。每次訓練和預測的準確率分布如下：

數(shù)據(jù)離散化

然而，在上例中對特征值離散化的劃分點實際上過于“野蠻”，此處介紹一種通過信息增益最大的標準來對數(shù)據(jù)進行離散化。原理很簡單，當信息增益最大時，說明用該點劃分能最大程度降低數(shù)據(jù)集的不確定性。

具體步驟如下：

對每個特征所包含的數(shù)值型特征值排序

對相鄰兩個特征值取均值，這些均值就是待選的劃分點

用每一個待選點把該特征的特征值劃分成兩類，小于該特征點置為1， 大于該特征點置為0，計算此時的條件熵，并計算出信息增益

選擇信息使信息增益最大的劃分點進行特征離散化

實現(xiàn)代碼如下：

def filterRawData(dataSet, colIndex, value, tag):

""" 用于把每個特征的連續(xù)值按照區(qū)分點分成兩類，加入tag參數(shù)，可用于標記篩選的是哪一部分數(shù)據(jù)"""

filterDataList = []

for r in dataSet:

if (tag and r[colIndex] = value) or ((not tag) and r[colIndex] value):

newR = r[:colIndex]

newR = np.append(newR, (r[colIndex + 1:]))

filterDataList.append(newR)

return np.array(filterDataList)

def dataDiscretization(dataSet, featName):

""" 對數(shù)據(jù)每個特征的數(shù)值型特征值進行離散化 """

featureNum = dataSet.shape[1] - 1

entropy = calShannonEnt(dataSet)

for featIndex in range(featureNum): #對于每一個特征

uniqueValues = sorted(np.unique(dataSet[:, featIndex]))

meanPoint = []

for i in range(len(uniqueValues) - 1): # 求出相鄰兩個值的平均值

meanPoint.append(float(uniqueValues[i+1] + uniqueValues[i]) / 2.0)

bestInfoGain = 0.0

bestMeanPoint = -1

for mp in meanPoint: #對于每個劃分點

subEntropy = 0.0 #計算該劃分點的信息熵

for tag in range(2): #分別劃分為兩類

subDataSet = filterRawData(dataSet, featIndex, mp, tag)

p = 1.0 * len(subDataSet) / len(dataSet)

subEntropy += p * calShannonEnt(subDataSet)

## 計算信息增益

infoGain = entropy - subEntropy

## 選擇最大信息增益

if infoGain = bestInfoGain:

bestInfoGain = infoGain

bestMeanPoint = mp

featName[featIndex] = featName[featIndex] + "=" + "{:.3f}".format(bestMeanPoint)

dataSet[:, featIndex] = [1 if x = bestMeanPoint else 0 for x in dataSet[:, featIndex]]

return dataSet, featName

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

重新對數(shù)據(jù)進行離散化，并重復該步驟1000次，同時用sklearn中的DecisionTreeClassifier對相同數(shù)據(jù)進行分類，分別統(tǒng)計平均準確率。運行代碼如下:

from sklearn.tree import DecisionTreeClassifier

import matplotlib.pyplot as plt

scoreL = []

scoreL_sk = []

for i in range(1000): #對該過程進行1000次

featNames = iris.feature_names[:]

trainData, testData = train_test_split(data) #區(qū)分測試集和訓練集

trainData_tmp = copy.copy(trainData)

testData_tmp = copy.copy(testData)

discritizationData, discritizationFeatName= dataDiscretization(trainData, featNames) #根據(jù)信息增益離散化

for i in range(testData.shape[1]-1): #根據(jù)測試集的區(qū)分點離散化訓練集

splitPoint = float(discritizationFeatName[i].split('=')[-1])

testData[:, i] = [1 if x=splitPoint else 0 for x in testData[:, i]]

decisionTree = creatDecisionTree(trainData, featNames)

classifyLable = [classify(decisionTree, featNames, td) for td in testData]

scoreL.append(1.0 * sum(classifyLable == testData[:, -1]) / len(classifyLable))

clf = DecisionTreeClassifier('entropy')

clf.fit(trainData[:, :-1], trainData[:, -1])

clf.predict(testData[:, :-1])

scoreL_sk.append(clf.score(testData[:, :-1], testData[:, -1]))

print 'score: ', np.mean(scoreL)

print 'score-sk: ', np.mean(scoreL_sk)

fig = plt.figure(figsize=(10, 4))

plt.subplot(1,2,1)

pd.Series(scoreL).hist(grid=False, bins=10)

plt.subplot(1,2,2)

pd.Series(scoreL_sk).hist(grid=False, bins=10)

plt.show()

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

兩者準確率分別為：

score: 0.7037894736842105

score-sk: 0.7044736842105263

準確率分布如下：

兩者的結(jié)果非常一樣。

（但是。。為什么根據(jù)信息熵離散化得到的準確率比直接用均值離散化的準確率還要低啊？？哇的哭出聲。。）

最后一次決策樹圖形如下：

決策樹剪枝

由于決策樹是完全依照訓練集生成的，有可能會有過擬合現(xiàn)象，因此一般會對生成的決策樹進行剪枝。常用的是通過決策樹損失函數(shù)剪枝，決策樹損失函數(shù)表示為:

C a ( T ) = ∑ t = 1 T N t H t ( T ) + α ∣ T ∣ C_a(T) = \sum_{t=1}^TN_tH_t(T) +\alpha|T|

C

a

(T)=

t=1

∑

T

N

t

H

t

(T)+α∣T∣

其中，H t ( T ) H_t(T)H

t

(T)表示葉子節(jié)點t的熵值，T表示決策樹的深度。前項∑ t = 1 T N t H t ( T ) \sum_{t=1}^TN_tH_t(T)∑

t=1

T

N

t

H

t

(T)是決策樹的經(jīng)驗損失函數(shù)當隨著T的增加，該節(jié)點被不停的劃分的時候，熵值可以達到最小，然而T的增加會使后項的值增大。決策樹損失函數(shù)要做的就是在兩者之間進行平衡，使得該值最小。

對于決策樹損失函數(shù)的理解，如何理解決策樹的損失函數(shù)? - 陶輕松的回答 - 知乎這個回答寫得挺好，可以按照答主的思路理解一下

C4.5算法

ID3算法通過信息增益來進行特征選擇會有一個比較明顯的缺點：即在選擇的過程中該算法會優(yōu)先選擇類別較多的屬性（這些屬性的不確定性小，條件熵小，因此信息增益會大），另外，ID3算法無法解決當每個特征屬性中每個分類都只有一個樣本的情況（此時每個屬性的條件熵都為0）。

C4.5算法ID3算法的改進，它不是依據(jù)信息增益進行特征選擇，而是依據(jù)信息增益率，它添加了特征分裂信息作為懲罰項。定義分裂信息：

S p l i t I n f o ( X , Y ) = ? ∑ i n ∣ X i ∣ ∣ X ∣ log ? ∣ X i ∣ ∣ X ∣ SplitInfo(X, Y) =-\sum_i^n\frac{|X_i|}{|X|}\log\frac{|X_i|}{|X|}

SplitInfo(X,Y)=?

i

∑

n

∣X∣

∣X

i

∣

log

∣X∣

∣X

i

∣

則信息增益率為：

G a i n R a t i o ( X , Y ) = d ( X , Y ) S p l i t I n f o ( X , Y ) GainRatio(X,Y)=\frac{d(X,Y)}{SplitInfo(X, Y)}

GainRatio(X,Y)=

SplitInfo(X,Y)

d(X,Y)

關(guān)于ID3和C4.5算法

在學習分類回歸決策樹算法時，看了不少的資料和博客。關(guān)于這兩個算法，ID3算法是最早的分類算法，這個算法剛出生的時候其實帶有很多缺陷：

無法處理連續(xù)性特征數(shù)據(jù)

特征選取會傾向于分類較多的特征

沒有解決過擬合的問題

沒有解決缺失值的問題

即該算法出生時是沒有帶有連續(xù)特征離散化、剪枝等步驟的。C4.5作為ID3的改進版本彌補列ID3算法不少的缺陷：

通過信息最大增益的標準離散化連續(xù)的特征數(shù)據(jù)

在選擇特征是標準從“最大信息增益”改為“最大信息增益率”

通過加入正則項系數(shù)對決策樹進行剪枝

對缺失值的處理體現(xiàn)在兩個方面：特征選擇和生成決策樹。初始條件下對每個樣本的權(quán)重置為1。

特征選擇：在選取最優(yōu)特征時，計算出每個特征的信息增益后，需要乘以一個**“非缺失值樣本權(quán)重占總樣本權(quán)重的比例”**作為系數(shù)來對比每個特征信息增益的大小

生成決策樹：在生成決策樹時，對于缺失的樣本我們按照一定比例把它歸屬到每個特征值中，比例為該特征每一個特征值占非缺失數(shù)據(jù)的比重

關(guān)于C4.5和CART回歸樹

作為ID3的改進版本，C4.5克服了許多缺陷，但是它自身還是存在不少問題：

C4.5的熵運算中涉及了對數(shù)運算，在數(shù)據(jù)量大的時候效率非常低。

C4.5的剪枝過于簡單

C4.5只能用于分類運算不能用于回歸

當特征有多個特征值是C4.5生成多叉樹會使樹的深度加深

————————————————

版權(quán)聲明：本文為CSDN博主「Sarah Huang」的原創(chuàng)文章，遵循CC 4.0 BY-SA版權(quán)協(xié)議，轉(zhuǎn)載請附上原文出處鏈接及本聲明。

原文鏈接：

python 決策樹怎樣修剪枝

include#include#defineMAX100structaddr{charname[30];charstreet[40];charcity[20];charstate[3];unsignedlongintzip;}addr_list[MAX];voidinit_list(void);intmenu_select(void);voidenter(void);intfind_free(void);voiddeleted(void);voidlist(void);intmain(void){charchoice;init_list();/*initializethestructurearray*/for(;;){choice=menu_select();switch(choice){case1:enter();break;case2:deleted();break;case3:list();break;case4:exit(0);}}return0;}/*initializethelist*/voidinit_list(void){registerintt;for(t=0;t4);returnc;}/*Inputaddressintothelist*/voidenter(void){intslot;chars[80];slot=find_free();if(slot==-1)

標題名稱：剪枝函數(shù)python,剪枝函數(shù)有哪幾種
本文地址：http://chinadenli.net/article3/dsspeos.html

成都網(wǎng)站建設(shè)公司_創(chuàng)新互聯(lián)，為您提供商城網(wǎng)站、軟件開發(fā)、品牌網(wǎng)站設(shè)計、定制開發(fā)、全網(wǎng)營銷推廣、網(wǎng)站營銷

廣告

聲明：本網(wǎng)站發(fā)布的內(nèi)容（圖片、視頻和文字）以用戶投稿、用戶轉(zhuǎn)載內(nèi)容為主，如果涉及侵權(quán)請盡快告知，我們將會在第一時間刪除。文章觀點不代表本網(wǎng)站立場，如需處理請聯(lián)系客服。電話：028-86922220；郵箱：631063699@qq.com。內(nèi)容未經(jīng)允許不得轉(zhuǎn)載，或轉(zhuǎn)載時需注明來源： 創(chuàng)新互聯(lián)