精华内容
下载资源
问答
  • 区域经济研究中,经常需要测度产业空间集中的程度,常用的指标有区位基尼系数(Locational GiniCoefficient)、泰尔指数(Theil Index)和EG指数等。这一期先讲区位基尼系数的计算方法及其实现函数,后几期再陆续介绍...

    区域经济研究中,经常需要测度产业空间集中的程度,常用的指标有区位基尼系数(Locational GiniCoefficient)、泰尔指数(Theil Index)和EG指数等。这一期先讲区位基尼系数的计算方法及其实现函数,后几期再陆续介绍泰尔指数和EG指数。

    用Excel算区位基尼系数,尽管也可实现,但非常笨拙,而且可重复性差。然而,其计算方法是非常简单的,用R语言写一个函数来实现之,犹如杀鸡用牛刀。看完本文后,用本人写的geo.gini()函数来计算,也就是一行代码的事。如果有数十个行业,用sapply跑一遍循环,什么结果都有了,彻底将你从繁琐的计算中解脱出来!

    一、原理

    基尼系数本来是用来测度居民家庭收入分布差距的,其本质思想与变异系数、赫芬达尔指数等并无二致,无非是考察一组数值的差异性,并使得基于不同数值向量计算出的结果可比较。利用其原理来测度产业空间集中度,就是所谓的区位基尼系数。

    为什么区位基尼系数可以用来衡量产业空间集中度呢?这里得建立一个基本认识:测度产业空间集中,也就是测度产业空间分布的不均衡性。假设产业i中的全部企业落在n个区域,那么这些区域就形成对产业i经济活动的一个空间分割。如果产业分布在空间上是均衡的,那么每一区域的产业份额都是1/n;如果分布不均衡,就意味着有些区域的产业份额小于1/n,有些区域大于1/n,大于1/n说明产业i在这些区域有集中。由于所有区域的产业份额加总为1,一些区域份额越小,另一些区域份额就越大,也就是产业i在这些区域越为集中。这种差距进一步拉大,比如说达到极端状态,就意味着产业i全部集中在某一区域,该区域占比为1,其他区域均为0。直观来看,区位基尼系数应该位于两种状态值:完全均衡和完全集中之间,从一端单调增长到另一端。

    二、绝对值和相对值

    区位基尼系数有绝对和相对两种。如上所述,如果将产业i的经济活动在各区域间进行分割,就形成了产业i的空间分布数值向量x;如果将总体经济活动(产业大类或全体产业)在各区域间进行分割,就形成了总体经济活动的空间分布数值向量y。经济活动规模一般用劳动力人数、产值、增加值等指标来衡量。绝对区位基尼系数是不考虑y,将每个区域作为个体单位,仅利用x向量来计算。这实际上是假设每个区域的总体经济活动份额是相等的,均为1/n。相对区位基尼系数则考虑了区域异质性,即与y的分布相比较,x的分布差异状况。以一个两区域的空间分割来说,如果两个区域的产业份额分别为20%和80%,从绝对意义上来说,肯定有产业空间集中;但如果这两个区域的总体经济活动份额也是20%和80%,从相对意义上来说,x和y的分布一致,因此产业在这两个区域间的空间分布是均衡的,即不存在产业空间集中。

    三、计算公式

    绝对区位基尼系数实际上是相对基尼系数的简化版本。在相对区位基尼系数计算公式中,如果将作为参照分布的向量y简化为y = [1/n, 1/n,…, 1/n],即得到绝对区位基尼系数。

    Krugman(1991)年阐述了相对区位基尼系数的计算方法,先根据各区域的区位商值将各区域的总体经济活动份额和产业份额排好序,然后计算它们的累积和,据此得到洛伦兹曲线,就可以按基尼系数原理算出结果了。

    相对区域基尼系数的计算公式有两个版本。一个见Combes、Mayer & Thisse(2008),直接根据求S1和S2的面积推导求出;另一个见Kim、Barkley & Henry(2000),先将各区域区位商用它们的平均值标准化之,然后再两两相减取平均值求出。

    四、函数实现

    根据以上公式,编写计算区位基尼系数的函数geo.gini(),其参数设定说明如下:

    geo.gini(x, y = NULL, type ="cmt")

    其中:(1)x为各区域产业经济活动规模数值向量;(2)y为各区域总体经济活动规模数值向量;(3)type为计算公式类型,取值为“cmt”或“kbh”,默认为“cmt”;

    需要注意的是:(1)x、y向量不能含缺失值,且和大于0;(2)y默认为NULL,即不作设定,此时简化为绝对指标;(3)kbh法乘以2,将其结果调整为在0~1间取值,以与cmt法一致。

    让我们先用两组简单的数值试一下:代码 1

    # 函数测试

    > x

    > y

    > geo.gini(x, type = "cmt")

    [1] 0.2666667

    > geo.gini(x, type = "kbh")

    [1] 0.4

    > geo.gini(x, y, type =  "cmt")

    [1] 0.3

    > geo.gini(x, y, type = "kbh")

    [1] 0.5

    接下来用实际数据来试一下。数据“中国省份制造业数据_2012_2013.csv”包含了中国大陆31个省份2012-2013年29个制造业的就业数据,其前两列分别为省份和年份,第三列为各省份的就业总数,可作为参照分布,后面列均为各个制造业就业数。读入数据后,用geo.gini()函数算出每年各产业的区位基尼系数,并导出结果文件为“gini_results.csv”,代码如下:代码 2

    # 将存放数据和代码的文件设为工作文件夹,这里假定为"D:\\locational_gini"

    # 注意分隔路径要用“\\”而不是“\”

    > setwd("D:\\locational_gini")

    # 读入数据,并将数据按年份分拆

    > mydata

    > yearly.data

    # 一次性计算所有年份、所有产业的相对区位基尼系数

    > gini.results

    sapply(xx[,-(1:3)], geo.gini, y = xx[[3]])

    })

    # 看一下结果

    > gini.results

    2012        2013

    农副食品加工业                     0.4220937 0.3848262

    食品制造业                         0.3060742 0.2801282

    ……                                 ……        ……

    工艺品及其他制造业                  0.3399786 0.3717040

    废弃资源和废旧材料回收加工业          0.3669596 0.3695507

    # 写出结果文件至工作文件夹,大功告成!

    > write.csv(gini.results,  "gini_results.csv")

    参考文献:

    [1]       Combes, P.-P., Mayer, T., & Thisse, J.-F. 2008. Economicgeography: The integration of regions and nations: Princeton UniversityPress.

    [2]       Kim, Y., Barkley, D. L., & Henry, M. S. 2000.Industry characteristics linked to establishment concentrations in nonmetropolitanareas. Journal of Regional Science, 40(2): 234-259.

    [3]     Krugman, P. 1991. Geographyand Trade: MIT Press.

    数据和代码下载请关注本人微信公众号:SDAR-workshop,“思达区域经济研究方法”

    展开全文
  • ), the closer the Gini index is to one(1), and the larger the entropy value (>>1)   Information Gain: Entropy - conditional entropy The change in information before and after the split ...

    Classification: The purer the set, the smaller the degree of aliasing, the simpler the classification.

    Metrics that measure the degree of information mixture

    Entropy: 

    Entropy is a quantitative indicator of the uncertainty of random variables.

    Entropy is defined as the expected value ( x*p(x) =possible value(called ONE kind of result) * probability )of the information.

    If you’re classifying something that can take on multiple values(sub-class), the information for symbol xi is defined as, where p(xi) is the probability of choosing this class(xi, sub-class).

    To calculate entropy, we need the expected value of all the information of all possible values of our class(such as color =feature=class: red, yellow, green, black, white(sub-class)...). This is given by where n is the number of classes(sub-class).

    , X(uppercase X called Random Variable or random event), x (lowercase x called possible value of random variable or event result, here the event result = ln p(x) 。 So the smaller the probability that the result of event x occurs, the larger the amount of information

    two results(two possible values(0 or 1))

    Gini Index:

    a measure of total variance across the K classes. It is not hard to see that the Gini index takes on a small value if all of the pk’s are close to zero or one(1). For this reason the Gini index is referred to as a measure of
    node purity—a small value indicates that a node contains predominantly observations from a single class.

    Why we choose Entropy to measure the information?

    The higher the degree of hybridization(mixture), the closer the Gini index is to one(1), and the larger the entropy value (>>1)

     

    Information Gain: Entropy - conditional entropy

    The change in information before and after the split is known as the information gain. When you know how to calculate the information gain, you can split your data across every feature to see which split gives you the highest information gain. The split with the highest information gain is your best option.

    Conditional entropy:Given condition Y(feature), Event X still contain uncertainty.

    So we choose age(feature) to split our dataset. 

    # -*- coding: utf-8 -*-
    """
    Created on Tue Oct 30 18:03:32 2018

    @author: LlQ
    """
    ##############################################################################
    #to calculate the Shannon entropy of a dataset base on list[list[-1]]: classify

    #The change in information before and after the split is known as the 
    #information gain

    #Entropy is defined as the expected value of the information
    #if you're classifying something that can take one multiple values, the
    #   information for symbol xi is defined as
    #   l(xi) = log(p(xi),2) where p(xi) is the probability of choosing this class
    #H=-sum{ p(xi) * log(p(xi),2) } and i from 1 to n
    ##############################################################################
    from math import log

    def calcShannonEntropy(dataSet):
        numEntries = len(dataSet) # number of entries is the number of data point
        labelCountDict={}  #how many class
        
        #classify and count for each class(or label)
        for featureList in dataSet: #every element in dataSet is a list
            #the final column(label) of the list as the key of dictionary
            currentLabel = featureList[-1]
            #if currentLabel not in labelCounts.keys():
            #    labelCounts[currentLabel] = 0
            #same as if statement #labelCounts.setdefault(currentLabel, 0)
            #labelCounts[currentLabel] +=1
            labelCountDict[currentLabel]=labelCountDict.setdefault(currentLabel, \
                          0)+1
        
        shannonEntropy=0.0
        #Hi=-p(xi) * log(p(xi),2) and i from 1 to n
        #print(dataSet)
        for key in labelCountDict:
            prob = float(labelCountDict[key]) / numEntries
            #print("key: ", key,", prob: ",prob)
            shannonEntropy -= prob * log(prob, 2)
            
        return shannonEntropy

    def createDataSet():
        dataSet = [
                    [1,1,'yes'],
                    [1,1,'yes'],
                    [1,0,'no'],
                    [0,1,'no'],
                    [0,1,'no']
                  ]
        labels=["no surfacing", 'flippers']
        return dataSet, labels

    ##############################################################################
    # jupyter Notebook test
    # import treesMy
    # from imp import reload
    # reload(treesMy)
    # myDataSet, labels=treesMy.createDataSet()
    # myDataSet
    #     [[1, 1, 'yes'], [1, 1, 'yes'], [1, 0, 'no'], [0, 1, 'no'], [0, 1, 'no']]    
    # treesMy.calcShannonEntropy(myDataSet)
    #     0.9709505944546686
    # myDataSet[0][-1]='maybe'
    # myDataSet
    #    [[1, 1, 'maybe'], [1, 1, 'yes'], [1, 0, 'no'], [0, 1, 'no'], [0, 1, 'no']]    
    # treesMy.calcShannonEntropy(myDataSet)
    #    1.3709505944546687  
    ##############################################################################

    #Dataset splitting on a given feature
    def splitDataSet(dataSet, featIndex, feature):
        returnedDataSet=[]

        for elemList in dataSet:
            if elemList[featIndex] == feature:
                #cut out the feature split on
                reducedFeatList=elemList[ :featIndex]
                reducedFeatList.extend(elemList[featIndex+1: ])
                #print(feature,reducedFeatList, elemList)
                returnedDataSet.append(reducedFeatList)
                
        return returnedDataSet

    ##############################################################################
    # jupyter Notebook test
    # import treesMy
    # from imp import reload
    # reload(treesMy)
    # myDat, labels=treesMy.createDataSet()
    # myDat
    #      [[1, 1, 'yes'], [1, 1, 'yes'], [1, 0, 'no'], [0, 1, 'no'], [0, 1, 'no']]    
    # treesMy.splitDataSet(myDat, 0, 1)
    #      [[1, 'yes'], [1, 'yes'], [0, 'no']]
    # treesMy.splitDataSet(myDat,0,0)
    #      [[1, 'no'], [1, 'no']]    
    ############################################################################## 
        
    #choosing the best feature to split on
    #choosing the best feature to split on
    def chooseBestFeatureToSplit(dataSet):
        #calculates the entropy of the whole dataset before any splitting
        baseEntropy = calcShannonEntropy(dataSet)
        bestInfoGain = 0.0
        bestFeatIndex =-1 #feature(index) which we can get a best information gain 

        numFeatures = len(dataSet[0])-1 # the number of the features  without label 
        for i in range(numFeatures):    # i==column or feature
            #create a list based on index=ith column of dataset
            featList = [everyElemList[i] for everyElemList in dataSet]  #each row
            uniqueFeatSet = set(featList)  # all possible values or sub features
            
            newEntropy=0.0
            #new H=-sum{ p(xi) * sub_Hi } and i from 1 to n
            for value in uniqueFeatSet: # for each possible value or sub feature
                reducedDataSet = splitDataSet(dataSet, i, value)
                prob = len(reducedDataSet)/float(len(dataSet))#given value

                #print("cut out: ", value,"reducedDataSet: ", reducedDataSet)
                #print(prob)
                #print('*'*10)
                
                #based on label(yes/no) of the subset to calculate Shannon Entropy
                newEntropy += prob*calcShannonEntropy(reducedDataSet)
            
            infoGain = baseEntropy - newEntropy
            #Find the best information gain
            if infoGain > bestInfoGain:
                bestInfoGain = infoGain
                bestFeatIndex = i
        
        return bestFeatIndex
            
    ##############################################################################
    # jupyter Notebook test
    # import treesMy
    # from imp import reload
    # reload(treesMy)
    # myDat, labels=treesMy.createDataSet() 
    # featureIndex=trees.chooseBestFeatureToSplit(myDat)
    # featureIndex
    #             0
    # featList = [everyElemList[featureIndex] for everyElemList in myDat]
    # featList
    #            [1, 1, 1, 0, 0]
    #labels[featureIndex]
    #           'no surfacing'    
    ##############################################################################

    import operator
    def mainFeature(labelList):
        labelCountDict = {} #{label:frequency,...}
        for label in labelList:
           # if label not in labelCountDict.keys():
           #     labelCountDict[label]=0
           # labelCountDict[label]+=1
           labelCountDict[label]=labelCountDict.get(label,0)+1
        
        ##such as [('No', 3), ('Yes', 2)]
        sortedLabelCount = sorted(labelCountDict.items(),
                                    key=operator.itemgetter(1), reverse = True)
                                        #operator.itemgetter(0):dict.keys
                                        #operator:itemgettter(1):dict.values
        #return the Label that occurs with greatest frequency
        return sortedLabelCount[0][0]     #such as 'No'                           

    #Building Tree by using features to split
    #the list of featureList contains a label for each of the features in dataset
    def createTree(dataSet, featureList):
        #create a class list by using last elem of all elemLists
        classList = [elemList[-1] for elemList in dataSet]#elemList[-1]:class/label
        #all instances in the branch are the same class, then you get a leaf node
        if classList.count(classList[0]) == len(classList):#all fish or not
            return classList[0]

        #there are no more features to split
        if len(dataSet[0]) ==1: #dataSet[0] is theLastItem(class)&not other feature
            return mainFeature(classList)# more fish or not
        
        bestFeatIndex = chooseBestFeatureToSplit(dataSet)
        bestFeatLabel = featureList[bestFeatIndex]

        myTree={
                    bestFeatLabel:{}
                } 
        del(featureList[bestFeatIndex])
        
        featValues = [elemList[bestFeatIndex] for elemList in dataSet]
        uniqueVals=set(featValues) 
        for value in uniqueVals:#0's subTree or 1's subTree
            subFeatList = featureList[:]
            myTree[bestFeatLabel][value] = createTree(splitDataSet\
                          (dataSet, bestFeatIndex, value), subFeatList) 
        return myTree                             

    ##############################################################################
    #   import treesMy
    #   from imp import reload
    #   reload(treesMy)
        
    #   myDat, featList = treesMy.createDataSet()
    #   myTree = treesMy.createTree(myDat, featList)
    #   myTree
    #   {'no surfacing': {0: 'no', 1: {'flippers': {0: 'no', 1: 'yes'}}} 
    ##############################################################################    
        
    #Classification function for an existing decision tree
    #testSplitList is corresponding to brandFeatList
    def classify(inputTree, branchFeatList, testSplitList):
        rootKey = list(inputTree.keys())[0] #input #inputTree is a dict with one key
        secondDict = inputTree[rootKey]#rootKey:value is a dict
        #translate rootKey(label string) to index in branchFeatList
        featIndex = branchFeatList.index(rootKey)
        for key in secondDict.keys():
            if testSplitList[featIndex] == key:#0 or 1
                if type(secondDict[key]).__name__=='dict':
                    classLabel = classify(secondDict[key], branchFeatList, \
                                          testSplitList)
                else:
                    classLabel = secondDict[key]
        return classLabel
    ##############################################################################
    #import treePlotterMy
    #import treesMy
    #from imp import reload
    #reload(treePlotterMy)
    #reload(treesMy)
        
    #myDat, labels = treesMy.createDataSet()
    #myDat
    #[[1, 1, 'yes'], [1, 1, 'yes'], [1, 0, 'no'], [0, 1, 'no'], [0, 1, 'no']]    

    #copyLabel=labels.copy()
    #copyLabel
    #['no surfacing', 'flippers']

    #myTree=treesMy.createTree(myDat, labels)
    #treePlotterMy.createPlot(myTree)
    #myTree
    #    {'no surfacing': {0: 'no', 1: {'flippers': {0: 'no', 1: 'yes'}}}}

    #labels
    #    ['flippers']
    #copyLabel
    #    ['no surfacing', 'flippers']

    #trees.classify(myTree, copyLabel, [1,0])
    #    'no'
    ##############################################################################

    def storeTree(inputTree, filename):
        import pickle
        fw=open(filename, 'wb')
        pickle.dump(inputTree, fw)
        fw.close()
        
    def grabTree(filename):
        import pickle
        fr=open(filename,'rb')
        return pickle.load(fr)
    ##############################################################################    
    #treesMy.storeTree(myTree, 'classifierStorage2.txt')
    #treesMy.grabTree('classifierStorage2.txt')    
    #{'no surfacing': {0: 'no', 1: {'flippers': {0: 'no', 1: 'yes'}}}}    

    #fr = open('lenses.txt')
    #lenses = [inst.strip().split('\t') for inst in fr.readlines()]
    #lenses[:3]   
    #   [['young', 'myope', 'no', 'reduced', 'no lenses'],
    #    ['young', 'myope', 'no', 'normal', 'soft'],
    #    ['young', 'myope', 'yes', 'reduced', 'no lenses']]
        
    #lensesLabels = ['age','prescript','astigmatic','tearRate']
    #lensesLabels
    #['age', 'prescript', 'astigmatic', 'tearRate']
        
    #lensesTree = treesMy.createTree(lenses,lensesLabels)
    #lensesTree
    #   {'tearRate': {'normal': {'astigmatic': {'no': {'age': {'pre': 'soft',
    #      'presbyopic': {'prescript': {'myope': 'no lenses', 'hyper': 'soft'}},
    #      'young': 'soft'}},
    #    'yes': {'prescript': {'myope': 'hard',
    #      'hyper': {'age': {'pre': 'no lenses',
    #        'presbyopic': 'no lenses',
    #        'young': 'hard'}}}}}},
    #  'reduced': 'no lenses'}}

    #treePlotterMy.createPlot(lensesTree)    
    ############################################################################## 

    # -*- coding: utf-8 -*-
    """
    Created on Mon Nov  5 23:15:15 2018

    @author: LlQ
    """

    import matplotlib.pyplot as plt

    #boxstyle = "swatooth"意思是注解框的边缘是波浪线型的,fc控制的注解框内的颜色深度
    decisionNode = dict(boxStyle="sawtooth", fc="y") #fc = y: yellow

    leafNode = dict(boxstyle="round4", fc="0.8") #round4 round-square
    arrow_args = dict(arrowstyle="<-")

    def plotNode(nodeTxt, endPoint, startPoint, nodeType):
        #two point(xy & xytext)
        #https://www.jianshu.com/p/1411c51194de
        createPlot.ax1.annotate(nodeTxt,
                                xy=startPoint, xycoords="axes fraction", #This annotates a point at xy in the given coordinate (xycoords) 
                                xytext=endPoint, textcoords="axes fraction", #the text at xytext given in textcoords
                                va="center", ha="center",
                                bbox=nodeType,
                                arrowprops=arrow_args)

    def createPlot():        #panel color="white"
        fig = plt.figure(1, facecolor = 'white')
        fig.clf() #clear the current figure
        createPlot.ax1 = plt.subplot(111, frameon=False)##frameon是否绘制矩形坐标轴
                                    #endPoint  #startPoint
        plotNode("a decision node", (0.5,0.1), (0.1,0.5), decisionNode)
        plotNode("a leaf node", (0.8,0.1), (0.3,0.8), leafNode)
        plt.show()

    ##############################################################################
    #   import treePlotterMy
    #   from imp import reload
    #   reload(treePlotterMy)    

    #   treePlotterMy.createPlot()    
    ##############################################################################
        
    #Identifying the number of leaves in a tree and the depth
    #myTree
    #{'no surfacing': {0: 'no', 
    #                  1: {'flippers': {0: 'no', 
    #                                   1: 'yes'
    #                                  }
    #                     }
    #                 }
    #}

    def getNumLeafs(myTree):
        numLeafs = 0
        #The first key (string type) is the label of the first split
        keyRootStr = list(myTree.keys())[0]
        valueTreeDict = myTree[keyRootStr]
        
        for key in valueTreeDict.keys():
            if type(valueTreeDict[key]).__name__=='dict':     #if value is a dict
                numLeafs += getNumLeafs(valueTreeDict[key])
            else:
                numLeafs += 1
                
        return numLeafs

    def getTreeDepth(myTree):
        maxDepth=0
        keyRootStr = list(myTree.keys())[0]
        valueTreeDict = myTree[keyRootStr]
        
        for key in valueTreeDict.keys():
            if type(valueTreeDict[key]).__name__=='dict':
                thisDepth = 1+getTreeDepth(valueTreeDict[key])
            else:
                thisDepth = 1
            
            if thisDepth > maxDepth:
                maxDepth = thisDepth
                
        return maxDepth

    def retrieveTree(i):
        listOfTrees = [
                        {'no surfacing':{0:'no',
                                         1:{'flippers':{0:'no',
                                                        1:'yes'
                                                       }
                                                     
                                           }
                                        }
                        },
                        {'no surfacing':{0:'no',
                                         1:{'flippers':{0:{'head':{'0':'no',
                                                                  '1':'yes'
                                                                 }
                                                          },
                                                        1:'no'
                                                       }
                                           }
                                        }
                       }
                     ]
        return listOfTrees[i]

    ##############################################################################
    #   import treePlotterMy
    #   from imp import reload
    #   reload(treePlotterMy)
     
    #   treePlotterMy.retrieveTree(1)
    #   {'no surfacing': {0: 'no',
    #     1: {'flippers': {0: {'head': {'0': 'no', '1': 'yes'}}, 1: 'no'}}}} 
        
    #   myTree=treePlotterMy.retrieveTree(0)
    #   myTree
    #   {'no surfacing': {0: 'no', 1: {'flippers': {0: 'no', 1: 'yes'}}}}

    #   treePlotterMy.getNumLeafs(myTree)
    #   3

    #   treePlotter.getTreeDepth(myTree)
    #   2    
    ##############################################################################
    #The plotTree function
    def plotMidText(childPt, parentPt, labelMid):
        #Plots text between child and parent
        xMid = (parentPt[0]+childPt[0])/2.0
        yMid = (parentPt[1]+childPt[1])/2.0
        
        #createPlot.ax1 = plt.subplot(111, frameon=False)
        createPlot.ax1.text(xMid, yMid, labelMid)

    def plotTree(myTree, parentPt, keyLabel):
        #Get the width and height of current tree
        numLeafs = getNumLeafs(myTree)
        depth = getTreeDepth(myTree)
        keyRootStr = list(myTree.keys())[0]
        
        #Global Variable plotTree.totalW will store the final width of tree
        #plotTree.xOff and plotTree.yOff keep track of what has already been
        #plotted and the appropriate coordinate to place the next node
        childPt = (plotTree.xOff + (1+float(numLeafs))/2.0/plotTree.totalW, \
                       plotTree.yOff)
        
        #plot branch node and middle text label
        plotMidText(childPt, parentPt, keyLabel) #empty since keyLabel = ''        
        #hiding the excess (upper)part(parentPt and arrow)
                                #current childPt is the root of current tree
        plotNode(str(keyRootStr), childPt, parentPt, decisionNode) #keyRootStr:key
        
        valueTreeDict = myTree[keyRootStr] #value: dict or subTree
        #Global Variable plotTree.totalD stores the depth of tree
        plotTree.yOff = plotTree.yOff - 1.0/plotTree.totalD
        #go to branch(key)
        for key in valueTreeDict.keys():
            if type(valueTreeDict[key]).__name__=='dict':
                         #sub-subTree  #current childPt is the root of current tree
                plotTree(valueTreeDict[key], childPt, str(key))
            else:
                #x-axis(from o to 1)
                #increase the number of leaf will increase the value of xOff
                plotTree.xOff = plotTree.xOff + 1.0/plotTree.totalW
                #plot leafNode and middle Text
                         #value(such as'no')    #grandchild point-xyText
                plotNode(valueTreeDict[key], (plotTree.xOff, plotTree.yOff), \
                         childPt, leafNode)
                            #grandchild point
                plotMidText((plotTree.xOff, plotTree.yOff), childPt, str(key))
       #after you finsh plotting the child nodes, you increment the global Y offset
        #go back to parent node
        plotTree.yOff = plotTree.yOff + 1.0/plotTree.totalD    

    def createPlot(treeDict):
        fig = plt.figure(1, facecolor='white')
        fig.clf()
        axprops = dict(xticks=[], yticks=[])
        createPlot.ax1 = plt.subplot(111, frameon=True, **axprops)
        plotTree.totalW = float(getNumLeafs(treeDict)) #3
        plotTree.totalD = float(getTreeDepth(treeDict))#2
        plotTree.xOff = -0.5/plotTree.totalW #0.5 can move the tree to the center
                                        #x-axis start from negative value
                                        #max(negative) x-axis value move tree to the right
        plotTree.yOff = 1.0             #start from the top(and total height=1.0)
        plotTree(treeDict, (0.5,1.0), '') #the root coordinate: (0.5, 1) center-top
        plt.show()    
        
    ##############################################################################
    #   import treePlotterMy
    #   from imp import reload
    #   reload(treePlotterMy)

    #   myTree = treePlotterMy.retrieveTree(0)
    #   treePlotterMy.createPlot(myTree)

    #   myTree['no surfacing'][3]='maybe'
    #   myTree
    # {'no surfacing': {0: 'no', 1: {'flippers': {0: 'no', 1: 'yes'}}, 3: 'maybe'}}       
    #   treePlotterMy.createPlot(myTree)

        

    展开全文
  • 一、基尼指数的概念 基尼指数(Gini不纯度)表示在样本集合中一个随机选中的样本被分错的概率。 注意:Gini指数越小...我们可以看到,GoodBloodCircle的基尼系数是最小的,也就是最不容易犯错误,因此我们应该把这个

    一、基尼指数的概念

    基尼指数(Gini不纯度)表示在样本集合中一个随机选中的样本被分错的概率。
    注意:Gini指数越小表示集合中被选中的样本被参错的概率越小,也就是说集合的纯度越高,反之,集合越不纯。当集合中所有样本为一个类时,基尼指数为0.

    二、基尼系数的计算公式

    基尼指数的计算公式为:
    在这里插入图片描述

    三、计算示例

    我们分别来计算一下决策树中各个节点基尼系数:
    在这里插入图片描述
    以下excel表格记录了Gini系数的计算过程。
    在这里插入图片描述
    我们可以看到,GoodBloodCircle的基尼系数是最小的,也就是最不容易犯错误,因此我们应该把这个节点作为决策树的根节点。在机器学习中,CART分类树算法使用基尼系数来代替信息增益比,基尼系数代表了模型的不纯度,基尼系数越小,不纯度越低,特征越好。这和信息增益(比)相反。

    展开全文
  • 20世纪初意大利经济学家基尼,于1922年提出的定量测定收入分配差异程度的指标。...这个数值被称为基尼系数或称洛伦茨系数。如果A为零,基尼系数为零,表示收入分配完全平等;如果B为零则系数为1,收入分配绝对不平...

    20世纪初意大利经济学家基尼,于1922年提出的定量测定收入分配差异程度的指标。它是根据洛伦茨曲线找出了判断分配平等程度的指标(如下图)。

    Image:基尼系数.jpg

      设实际收入分配曲线和收入分配绝对平等曲线之间的面积为A,实际收入分配曲线右下方的面积为B。并以A除以A+B的商表示不平等程度。这个数值被称为基尼系数或称洛伦茨系数。如果A为零,基尼系数为零,表示收入分配完全平等;如果B为零则系数为1,收入分配绝对不平等。该系数可在零和1之间取任何值。收入分配越是趋向平等,洛伦茨曲线的弧度越小,基尼系数也越小,反之,收入分配越是趋向不平等,洛伦茨曲线的弧度越大,那么基尼系数也越大。如果个人所得税能使收入均等化,那么,基尼系数即会变小。

      基尼系数的计算公式为:

      G=\sum_{i=1}^n {X_i}{Y_i}+2\sum_{i=1}^n {X_i}(1V_i}) -1

      其中,X代表各组的人口比重,Y代表各组的收入比重,V代表各组累计的收入比重,i=1,2,3,…,n,n代表分组的组数。

    ___________________________________________________

    基尼系数,按照联合国有关组织规定:

    • 若低于0.2表示收入绝对平均;
    • 0.2-0.3表示比较平均;
    • 0.3-0.4表示相对合理;
    • 0.4-0.5表示收入差距较大;
    • 0.5以上表示收入差距悬殊。

      经济学家们通常用基尼指数来表现一个国家和地区的财富分配状况。这个指数在零和一之间,数值越低,表明财富在社会成员之间的分配越均匀;反之亦然。

      通常把0.4作为收入分配差距的“警戒线”。一般发达国家的基尼指数在0.24到0.36之间,美国偏高,为0.4。中国大陆和香港的基尼系数都超出0.4。

      此外洛伦茨曲线讲的是市场总发货值的百分比与市场中由小到大厂商的累积百分比之间的关系。 洛伦茨曲线的弧度越小,基尼系数也越小。

    _____________________________________________________________

    基尼系数是联合国规定的用来衡量各个国家、地区、种族和行业收入分配不均等程度的统计指标,也是许多国家乃至我国大多数学者评判收入分配的最重要的依据。它的优点是可以利用简单的分组数据简练地概括洛伦兹曲线所描述的居民收入分配状况,以一个数值反映总体收入差距状况。但也正因为这种概括又使得它丢掉了洛伦兹曲线所表示的一些信息,在衡量和说明收入分配状况时存在一些不足。

      基尼系数不能准确地反映洛伦兹曲线的形状,从而它不能精确地反映收入分配的不均等程度。由基尼系数的计算公式可知:基尼系数的值完全取决于洛伦兹曲线与绝对平均线之间的面积的大小,从数值无法知道各个收入阶层的收入结构,而对应不同的洛伦兹曲线,这块面积可能是相同的,即有相同的基尼系数。

      现举例说明,见下表。此例中,情况1、情况2的洛伦兹曲线分别见下图中曲线L1、L2。如下图所示,L1与L2所表示的收入分配结构显然不同,情况2的洛伦兹曲线比情况1的洛伦兹曲线偏向上,L1中的低收入群体相对贫困程度要远远高于L2所对应的分配结构,如果从扩大内需和保证社会稳定的角度出发,对于L1所描述的情形采取调整收入结构的政策措施,从而增加低收入阶层的收入水平更为迫切。但根据基尼系数的定义,由这两条曲线所计算出来的基尼系数是相等的,如果仅依据基尼系数,政策制定者就无法作出最为合理的决策。对此问题,Wilson(1987)曾经作过比较深入的研究。他通过对美国有关资料研究后发现,由于在黑人与白人间收入差异进一步扩大的同时,黑人家庭之间收入水平出现了趋同,实际计算的基尼系数却是缩小的,此时的基尼系数可能低估了美国居民的贫富差异程度。他进一步指出之所以出现这种结果,正是由于与基尼系数所对应的洛伦兹曲线的非唯一性,因而,用基尼系数反映贫富差距不够准确,至少是不够全面的。社会分配的不均等程度是由两种收入分配间的差距造成的,一种是由收入低于整个社会的平均收入而形成的差距;另一种是由收入高于整个社会的平均收入而形成的差距。基尼系数计算的是这两种差距的总和,但不能反映出这两种差距各自的大小程度。

    两种情况下的洛伦兹曲线
    两种不同情况中的基尼系数
    组号123基尼系数
    情况1 收入I 1/6 3/6 2/6 13/36
    人口P 3/6 2/6 1/6
    情况2 收入I 1/6 2/6 3/6 13/36
    人口P 2/6 3/6 1/6      

    __________________________________________

    劳伦茨曲线是1905年由经济学家马克斯·劳伦茨所提出的表示收入分配的曲线,意大利经济学家科拉多·基尼在此基础上定义了基尼系数。

    在经济学里,劳伦兹曲线是在过往财富分配数据上建立的累积分布函数所对应的曲线,它通过变量y%的值来反映各项分配的比例。它经常被用来描述收入的分配情况,即以x%代表一部分(收入相似)家庭占整个社会家庭的比例,以y%代表该部分家庭的收入占整个社会收入的比例。该曲线也可用来描述社会资本的分配情况。在这些应用当中,经济学家经常把它用来衡量社会(主要指社会收入)是否公平。概率密度函数f(x))或累积分布函数(F(x)):

    L ( F ) = ∫ − ∞ x ( F ) x f ( x ) d x ∫ − ∞ ∞ x f ( x ) d x = ∫ 0 F x ( F ′ ) d F ′ ∫ 0 1 x ( F ′ ) d F ′ {\displaystyle L(F)={\frac {\int _{-\infty }^{x(F)}xf(x)\,dx}{\int _{-\infty }^{\infty }xf(x)\,dx}}={\frac {\int _{0}^{F}x(F')\,dF'}{\int _{0}^{1}x(F')\,dF'}}} L(F)={\frac  {\int _{{-\infty }}^{{x(F)}}xf(x)\,dx}{\int _{{-\infty }}^{\infty }xf(x)\,dx}}={\frac  {\int _{0}^{F}x(F')\,dF'}{\int _{0}^{1}x(F')\,dF'}}

    这曲线在发展经济学上,除了用于常见的基尼系数表示收入分布,还有土地分布,教育度的程度的分布等。

    ____________________________________________________________

    画一个矩形,矩形的高衡量社会财富的百分比,将之分为五等份,每一等分为20的社会总财富。在矩形的长上,将100的家庭从最贫者到最富者自左向右排列,也分为5等分,第一个等份代表收入最低的20的家庭。在这个矩形中,将每一百分的家庭所有拥有的财富的百分比累计起来,并将相应的点画在图中,便得到了一条曲线就是洛伦兹曲线。

      洛伦兹曲线

       显而易见,洛伦兹曲线的弯曲程度具有重要意义。一般来说,它反映了收入分配的不平等程度。弯曲程度越大,收入分配程度越不平等;反之亦然。特别是,如果所有收入都集中在某一个人手中,而其余人口均一无所有,收入分配达到完全不平等,洛伦兹曲线成为折线OHL;另一方面,如果任一人口百分比等于其收入百分比,从而人口累计百分比等于收入累计百分比,则收入分配就是完全平等的,洛伦兹曲线成为通过原点的45度线OL。

     

    \

     

    展开全文
  • 基尼gini系数-决策树

    2020-10-25 12:11:01
    CART树采用基尼系数分割,而不是信息增益。
  • 引言 大家在机器学习中经常会看到基尼系数的词汇,有时候在做比赛的时候,有些赛题的Scoring Metric就是基尼系数。...首先,我们先看一张从Wiki上找来的经典图片:Gini基尼系数是一个分布不平衡程度的...
  • 基尼系数

    千次阅读 2012-12-10 10:10:07
    基尼系数Gini coefficient),或译基尼指数,是20世纪初意大利学者基尼根据劳伦茨曲线所定义的判断收入分配公平程度的指标。是比例数值,在0和1之间。基尼指数(Gini index)是指基尼系数乘100倍作百分比表示。 ...
  • 基尼系数(英文:Gini index、Gini Coefficient)是指国际上通用的、用以衡量一个国家或地区居民收入差距的常用指标。 基尼系数最大为“1”,最小等于“0”。基尼系数越接近0表明收入分配越是趋向平等。国际惯例把...
  • 区域经济研究中,经常需要测度产业空间集中的程度,常用的指标有区位基尼系数(Locational GiniCoefficient)、泰尔指数(Theil Index)和EG指数等。这一期先讲区位基尼系数的计算方法及其实现函数,后几期再陆续介绍...
  • 决策树:什么是基尼系数 在我翻译学习这篇Random Forests for Complete Beginners的时候,对基尼系数和它相关的一些中文表达充满了疑问,查了一些资料以后,完成了这篇文章。其中基尼杂质系数的计算和解释参考了A ...
  • 数据集D的基尼系数Gini(D)反映了从数据集D中随机抽取两个样本,其类别标记不一致的概率,因此Gini(D)越小,则数据集D的纯度越高。 特征属性a的基尼系数定义为 在上述案例中,数据集D的基尼系数为: 身高的基尼系数...
  • 决策树之基尼系数

    2020-07-30 15:59:34
    在决策树中,除了用似然估计推导出的信息熵损失函数之外,还有一个基尼系数 怎么理解呢?针对一个贷款人员是否违约的二分类问题,我们来描述一下 对于一个用户A,假如我们的模型预测出他违约的概率为p,则不...
  • 使用Python计算基尼系数

    千次阅读 2019-12-19 15:03:49
    import numpy as np def gini(data_list): '''获得列表中的gini系数''' data_length = len(data_list) total_sum = np.sum(data_list) total_gini = 0 for i in range(data_length): temp_deno...
  • 一、GINI系数(基尼系数) 衡量数据的不纯度或者不确定性。值越大样本集合的不确定性也越大。 G=1−∑i=1kp12 G= 1-\sum_{i=1}^kp1^2 G=1−i=1∑k​p12 GINI指标:取值范围(0-0.5) 基于GINI指标的算法:Cart 二、...
  • 决策树CART算法——基尼系数 决策树的CART算法使用基尼系数来选择划分属性。一个数据集的纯度可以用基尼系数来度量 Gini(D)=∑k=1∣y∣∑k′≠kpkpk′=1−∑k=1∣y∣pk2\begin{aligned}Gini(D) = \sum_{k=1}^{|y|}\...
  • 代码实现 套用公式: def gini(a: int, b: int) -> float: return 1-pow(a/(a+b), 2)-pow(b/(a+b), 2) ... return (a+b)/(a+b+c+d) * gini(a, b) + (c+d)/(a+b+c+d) * gini(c, d) print(gini(13, 98)) print(g
  • 直白解读在预测系统中基尼系数及其归一化 在CTR(click-through-rate 点击通过率)等预测模型中,绘制了Gini Normalization来评价不同模型的效果。 基尼系数分析 直白解读,假设有下面两组结果,分别表示预测值和...
  • 决策树,基尼系数,泰勒级数

    千次阅读 2017-12-03 20:14:09
    1 决策树 衡量分类好坏的方法是 熵 ...3. 熵,基尼系数和error 其实H(x)和Gini(X)还挺像的,展开把lnx在x=1处泰勒展开即可,泰勒公式如下: 把lnx在x=1处展开,那么就有 4. 下面玩玩泰勒级数
  • 基尼系数的计算原理

    千次阅读 2015-03-22 22:07:46
    基尼指数( Gini Index )是20世纪初经济学家基尼定义的指标,最为知名的应用是考察居民收入的差异情况。 居民收入的情况符合幂指函数( Power Law )分布,最直观(但非准确)的理解就是 80/20 原则,也...
  • def Gini_classification(data,column,label): classfication_feature = data[column].unique() classification_label = data[label].unique() sum1 = len(df) Gini_classification = {} for i in ...
  • 基尼指数 Gini Index

    2021-01-27 21:16:35
    基尼系数Gini index)反映的是从数据集D中随机选取两个样本,其类别标记不一致的概率。因此,基尼系数越小,数据纯度越高。 Gini(D)=1−∑k=1∣γ∣pk2.Gini(D)=1-\sum_{k=1}^{|\gamma|}{p_k^2}.Gini(D)=1−∑k=1...
  • 2.3决策树之基尼系数

    万次阅读 2016-02-08 11:09:36
    在CART里面划分决策树的条件是采用Gini Index,定义如下: gini(T)=1−sumnj=1p2j 其中,( p_j )是类j在T中的相对频率,当类在T中是倾斜的时,gini(T)会最小。 将T划分为T1(实例数为N1)和T2(实例数为N2)两...
  • GINI Index-基尼指数

    2021-03-07 10:44:46
    给定节点t: 这里的Pi(t) 是 类i的...计算单个节点基尼系数: 对于第一组: P(C1) = 0/6 = 0 P(C2) = 6/6 = 1 Gini = 1 – P(C1)2 – P(C2)2 = 1 – 0 – 1 = 0 对于第二组: P(C1) = 1/6 P(C2) = 5/6 Gini = 1 –
  • 基尼系数Gini index) 从我看到过得内容中,我认为较为好理解的定义应该是: 定义:基尼指数(基尼不纯度):表示在样本集合中一个随机选中的样本被分错的概率。 如上面定义所说的,基尼系数反映的就是样本被分错....

空空如也

空空如也

1 2 3 4 5 ... 8
收藏数 143
精华内容 57
关键字:

gini基尼系数