python信息熵函数 python 熵值法

求python 熵值法实现代码

一、基本原理

在信息论中，熵是对不确定性的一种度量。信息量越大，不确定性就越小，熵也就越小；信息量越小，不确定性越大，熵也越大。

根据熵的特性，可以通过计算熵值来判断一个事件的随机性及无序程度，也可以用熵值来判断某个指标的离散程度，指标的离散程度越大，该指标对综合评价的影响（权重）越大，其熵值越小。

二、熵值法步骤

1. 选取n个国家，m个指标，则为第i个国家的第j个指标的数值（i=1, 2…, n; j=1,2,…, m）；

2. 指标的归一化处理：异质指标同质化

由于各项指标的计量单位并不统一，因此在用它们计算综合指标前，先要对它们进行标准化处理，即把指标的绝对值转化为相对值，并令，从而解决各项不同质指标值的同质化问题。而且，由于正向指标和负向指标数值代表的含义不同（正向指标数值越高越好，负向指标数值越低越好），因此，对于高低指标我们用不同的算法进行数据标准化处理。其具体方法如下:

正向指标:

负向指标:

则为第i个国家的第j个指标的数值（i=1, 2…, n; j=1, 2,…, m）。为了方便起见，归一化后的数据仍记为;

3. 计算第j项指标下第i个国家占该指标的比重：

4. 计算第j项指标的熵值：

其中. 满足;

5. 计算信息熵冗余度：

6. 计算各项指标的权值：

7. 计算各国家的综合得分：

[code]function [s,w]=shang(x)

% 函数shang.m, 实现用熵值法求各指标(列）的权重及各数据行的得分

% x为原始数据矩阵, 一行代表一个国家, 每列对应一个指标

% s返回各行得分, w返回各列权重

[n,m]=size(x); % n=23个国家, m=5个指标

%% 数据的归一化处理

% Matlab2010b,2011a,b版本都有bug,需如下处理. 其它版本直接用[X,ps]=mapminmax(x',0,1);即可

[X,ps]=mapminmax(x');

ps.ymin=0.002; % 归一化后的最小值

ps.ymax=0.996; % 归一化后的最大值

ps.yrange=ps.ymax-ps.ymin; % 归一化后的极差,若不调整该值, 则逆运算会出错

X=mapminmax(x',ps);

% mapminmax('reverse',xx,ps); % 反归一化, 回到原数据

X=X'; % X为归一化后的数据, 23行(国家), 5列(指标)

%% 计算第j个指标下，第i个记录占该指标的比重p(i,j)

for i=1:n

for j=1:m

p(i,j)=X(i,j)/sum(X(:,j));

end

end

%% 计算第j个指标的熵值e(j)

k=1/log(n);

for j=1:m

e(j)=-k*sum(p(:,j).*log(p(:,j)));

end

d=ones(1,m)-e; % 计算信息熵冗余度

w=d./sum(d); % 求权值w

s=w*p'; % 求综合得分[\code]

测试程序：

data.txt 数据如下：

114.6 1.1 0.71 85.0 346

55.3 0.96 0.4 69.0 300

132.4 0.97 0.54 73.0 410

152.1 1.04 0.49 77.0 433

103.5 0.96 0.66 67.0 385

81.0 1.08 0.54 96.0 336

179.3 0.88 0.59 89.0 446

29.8 0.83 0.49 120.0 289

92.7 1.15 0.44 154.0 300

248.6 0.79 0.5 147.0 483

115.0 0.74 0.65 252.0 453

64.9 0.59 0.5 167.0 402

163.6 0.85 0.58 220.0 495

95.7 1.02 0.48 160.0 384

139.5 0.70 0.59 217.0 478

89.9 0.96 0.39 105.0 314

76.7 0.95 0.51 162.0 341

121.8 0.83 0.60 140.0 401

42.1 1.08 0.47 110.0 326

78.5 0.89 0.44 94.0 280

77.8 1.19 0.57 91.0 364

90.0 0.95 0.43 89.0 301

100.6 0.82 0.59 83.0 456

执行代码：

[code]x=load('data.txt'); % 读入数据

[s,w]=shang(x)[\code]

运行结果：

s =

Columns 1 through 9

0.0431 0.0103 0.0371 0.0404 0.0369 0.0322 0.0507 0.0229 0.0397

Columns 10 through 18

0.0693 0.0878 0.0466 0.0860 0.0503 0.0800 0.0234 0.0456 0.0536

Columns 19 through 23

0.0272 0.0181 0.0364 0.0202 0.0420

w =

0.1660 0.0981 0.1757 0.3348 0.2254

如何用 Python 中的 NLTK 对中文进行分析和处理

最近正在用nltk 对中文网络商品评论进行褒贬情感分类，计算评论的信息熵（entropy）、互信息（point mutual information）和困惑值（perplexity）等（不过这些概念我其实也还理解不深...只是nltk 提供了相应方法）。

我感觉用nltk 处理中文是完全可用的。其重点在于中文分词和文本表达的形式。

中文和英文主要的不同之处是中文需要分词。因为nltk 的处理粒度一般是词，所以必须要先对文本进行分词然后再用nltk 来处理（不需要用nltk 来做分词，直接用分词包就可以了。严重推荐结巴分词，非常好用）。

中

文分词之后，文本就是一个由每个词组成的长数组：[word1, word2, word3…… wordn]。之后就可以使用nltk

里面的各种方法来处理这个文本了。比如用FreqDist 统计文本词频，用bigrams 把文本变成双词组的形式：[(word1, word2),

(word2, word3), (word3, word4)……(wordn-1, wordn)]。

再之后就可以用这些来计算文本词语的信息熵、互信息等。

再之后可以用这些来选择机器学习的特征，构建分类器，对文本进行分类（商品评论是由多个独立评论组成的多维数组，网上有很多情感分类的实现例子用的就是nltk 中的商品评论语料库，不过是英文的。但整个思想是可以一致的）。

另外还有一个困扰很多人的Python 中文编码问题。多次失败后我总结出一些经验。

Python 解决中文编码问题基本可以用以下逻辑：

utf8（输入） —— unicode（处理） —— （输出）utf8

Python 里面处理的字符都是都是unicode 编码，因此解决编码问题的方法是把输入的文本（无论是什么编码）解码为（decode）unicode编码，然后输出时再编码（encode）成所需编码。

由

于处理的一般为txt 文档，所以最简单的方法，是把txt 文档另存为utf-8 编码，然后使用Python

处理的时候解码为unicode（sometexts.decode('utf8')），输出结果回txt 的时候再编码成utf8（直接用str()

函数就可以了）。

python对数据进行聚类怎么显示数据分类

将其整理成数据集为：

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

算法过程：

1、计算原始的信息熵。

2、依次计算数据集中每个样本的每个特征的信息熵。

3、比较不同特征信息熵的大小，选出信息熵最大的特征值并输出。

运行结果：

col : 0 curInfoGain : 2.37744375108 baseInfoGain : 0.0

col : 1 curInfoGain : 1.37744375108 baseInfoGain : 2.37744375108

bestInfoGain : 2.37744375108 bestFeature: 0

结果分析：

说明按照第一列，即有无喉结这个特征来进行分类的效果更好。

思考：

1、能否利用决策树算法，将样本最终的分类结果进行输出？如样本1,2,3属于男性，4属于女性。

2、示例程序生成的决策树只有一层，当特征量增多的时候，如何生成具有多层结构的决策树？

3、如何评判分类结果的好坏？

在下一篇文章中，我将主要对以上三个问题进行分析和解答。如果您也感兴趣，欢迎您订阅我的文章，也可以在下方进行评论，如果有疑问或认为不对的地方，您也可以留言，我将积极与您进行解答。

完整代码如下：

from math import log

"""

计算信息熵

"""

def calcEntropy(dataset):

diclabel = {} ## 标签字典，用于记录每个分类标签出现的次数

for record in dataset:

label = record[-1]

if label not in diclabel.keys():

diclabel[label] = 0

diclabel[label] += 1

### 计算熵

entropy = 0.0

cnt = len(dataset)

for label in diclabel.keys():

prob = float(1.0 * diclabel[label]/cnt)

entropy -= prob * log(prob,2)

return entropy

def initDataSet():

dataset = [[1,0,"yes"],[1,1,"yes"],[0,1,"yes"],[0,0,"no"],[1,0,"no"]]

label = ["male","female"]

return dataset,label

#### 拆分dataset ,根据指定的过滤选项值，去掉指定的列形成一个新的数据集

def splitDataset(dataset , col, value):

retset = [] ## 拆分后的数据集

for record in dataset:

if record[col] == value :

reducedFeatVec = record[:col]

reducedFeatVec.extend(record[col+1:]) ### 将指定的列剔除

retset.append(reducedFeatVec) ### 将新形成的特征值列表追加到返回的列表中

return retset

### 找出信息熵增益最大的特征值

### 参数：

### dataset : 原始的数据集

def findBestFeature(dataset):

numFeatures = len(dataset[0]) - 1 ### 特征值的个数

baseEntropy = calcEntropy(dataset) ### 计算原始数据集的熵

baseInfoGain = 0.0 ### 初始信息增益

bestFeature = -1 ### 初始的最优分类特征值索引

### 计算每个特征值的熵

for col in range(numFeatures):

features = [record[col] for record in dataset] ### 提取每一列的特征向量 如此处col= 0 ，则features = [1,1,0,0]

uniqueFeat = set(features)

curInfoGain = 0 ### 根据每一列进行拆分，所获得的信息增益

for featVal in uniqueFeat:

subDataset = splitDataset(dataset,col,featVal) ### 根据col列的featVal特征值来对数据集进行划分

prob = 1.0 * len(subDataset)/numFeatures ### 计算子特征数据集所占比例

curInfoGain += prob * calcEntropy(subDataset) ### 计算col列的特征值featVal所产生的信息增益

# print "col : " ,col , " featVal : " , featVal , " curInfoGain :" ,curInfoGain ," baseInfoGain : " ,baseInfoGain

print "col : " ,col , " curInfoGain :" ,curInfoGain ," baseInfoGain : " ,baseInfoGain

if curInfoGain baseInfoGain:

baseInfoGain = curInfoGain

bestFeature = col

return baseInfoGain,bestFeature ### 输出最大的信息增益，以获得该增益的列

dataset,label = initDataSet()

infogain , bestFeature = findBestFeature(dataset)

print "bestInfoGain :" , infogain, " bestFeature:",bestFeature

python中有哪些简单的算法？

首先谢谢邀请，

python中有的算法还是比较多的？

python之所以火是因为人工智能的发展，人工智能的发展离不开算法！

感觉有本书比较适合你,不过可惜的是这本书没有电子版，只有纸质的。

这本书对于算法从基本的入门到实现，循序渐进的介绍，比如里面就涵盖了数学建模的常用算法。

第 1章　从数学建模到人工智能

1.1　数学建模1.1.1　数学建模与人工智能1.1.2　数学建模中的常见问题1.2　人工智能下的数学1.2.1　统计量1.2.2　矩阵概念及运算1.2.3　概率论与数理统计1.2.4　高等数学——导数、微分、不定积分、定积分

第2章 Python快速入门

2.1　安装Python2.1.1　Python安装步骤2.1.2　IDE的选择2.2　Python基本操作2.2.1　第 一个小程序2.2.2　注释与格式化输出2.2.3　列表、元组、字典2.2.4　条件语句与循环语句2.2.5　break、continue、pass2.3　Python高级操作2.3.1　lambda2.3.2　map2.3.3　filter

第3章　Python科学计算库NumPy

3.1　NumPy简介与安装3.1.1　NumPy简介3.1.2　NumPy安装3.2　基本操作3.2.1　初识NumPy3.2.2　NumPy数组类型3.2.3　NumPy创建数组3.2.4　索引与切片3.2.5　矩阵合并与分割3.2.6　矩阵运算与线性代数3.2.7　NumPy的广播机制3.2.8　NumPy统计函数3.2.9　NumPy排序、搜索3.2.10　NumPy数据的保存

第4章　常用科学计算模块快速入门

4.1　Pandas科学计算库4.1.1　初识Pandas4.1.2　Pandas基本操作4.2　Matplotlib可视化图库4.2.1　初识Matplotlib4.2.2　Matplotlib基本操作4.2.3　Matplotlib绘图案例4.3　SciPy科学计算库4.3.1　初识SciPy4.3.2　SciPy基本操作4.3.3　SciPy图像处理案例第5章　Python网络爬虫5.1　爬虫基础5.1.1　初识爬虫5.1.2　网络爬虫的算法5.2　爬虫入门实战5.2.1　调用API5.2.2　爬虫实战5.3　爬虫进阶—高效率爬虫5.3.1　多进程5.3.2　多线程5.3.3　协程5.3.4　小结

第6章　Python数据存储

6.1　关系型数据库MySQL6.1.1　初识MySQL6.1.2　Python操作MySQL6.2　NoSQL之MongoDB6.2.1　初识NoSQL6.2.2　Python操作MongoDB6.3　本章小结6.3.1　数据库基本理论6.3.2　数据库结合6.3.3　结束语

第7章　Python数据分析

7.1　数据获取7.1.1　从键盘获取数据7.1.2　文件的读取与写入7.1.3　Pandas读写操作7.2　数据分析案例7.2.1　普查数据统计分析案例7.2.2　小结

第8章　自然语言处理

8.1　Jieba分词基础8.1.1　Jieba中文分词8.1.2　Jieba分词的3种模式8.1.3　标注词性与添加定义词8.2　关键词提取8.2.1　TF-IDF关键词提取8.2.2　TextRank关键词提取8.3　word2vec介绍8.3.1　word2vec基础原理简介8.3.2　word2vec训练模型8.3.3　基于gensim的word2vec实战

第9章　从回归分析到算法基础

9.1　回归分析简介9.1.1　“回归”一词的来源9.1.2　回归与相关9.1.3　回归模型的划分与应用9.2　线性回归分析实战9.2.1　线性回归的建立与求解9.2.2　Python求解回归模型案例9.2.3　检验、预测与控制

第10章 从K-Means聚类看算法调参

10.1　K-Means基本概述10.1.1　K-Means简介10.1.2　目标函数10.1.3　算法流程10.1.4　算法优缺点分析10.2　K-Means实战

第11章 从决策树看算法升级

11.1　决策树基本简介11.2　经典算法介绍11.2.1　信息熵11.2.2　信息增益11.2.3　信息增益率11.2.4　基尼系数11.2.5　小结11.3　决策树实战11.3.1　决策树回归11.3.2　决策树的分类

第12章 从朴素贝叶斯看算法多变　193

12.1　朴素贝叶斯简介12.1.1　认识朴素贝叶斯12.1.2　朴素贝叶斯分类的工作过程12.1.3　朴素贝叶斯算法的优缺点12.2　3种朴素贝叶斯实战

第13章 从推荐系统看算法场景

13.1　推荐系统简介13.1.1　推荐系统的发展13.1.2　协同过滤13.2　基于文本的推荐13.2.1　标签与知识图谱推荐案例13.2.2　小结

第14章 从TensorFlow开启深度学习之旅

14.1　初识TensorFlow14.1.1　什么是TensorFlow14.1.2　安装TensorFlow14.1.3　TensorFlow基本概念与原理14.2　TensorFlow数据结构14.2.1　阶14.2.2　形状14.2.3　数据类型14.3　生成数据十二法14.3.1　生成Tensor14.3.2　生成序列14.3.3　生成随机数14.4　TensorFlow实战

希望对你有帮助！！！

贵在坚持，自己掌握一些，在工作中不断打磨，高薪不是梦！！

用python实现红酒数据集的ID3,C4.5和CART算法？

ID3算法介绍

ID3算法全称为迭代二叉树3代算法（Iterative Dichotomiser 3）

该算法要先进行特征选择，再生成决策树，其中特征选择是基于“信息增益”最大的原则进行的。

但由于决策树完全基于训练集生成的，有可能对训练集过于“依赖”，即产生过拟合现象。因此在生成决策树后，需要对决策树进行剪枝。剪枝有两种形式，分别为前剪枝（Pre-Pruning）和后剪枝（Post-Pruning），一般采用后剪枝。

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

信息熵：来自于香农定理，表示信息集合所含信息的平均不确定性。信息熵越大，表示不确定性越大，所含的信息量也就越大。

设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

条件熵：指已知某个随机变量的情况下，信息集合的信息熵。

设信息集合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）的联合概率分布为

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代码实现

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特征列label等于value，并且过滤掉改特征列的数据集"""

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: #当所有特征属性都利用完仍然无法判断样本属于哪一类，此时归为该数据集中数量最多的那一类

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): #若子节点仍是树，则递归查找

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

下面用鸢尾花数据集对该算法进行测试。由于ID3算法只能用于标称型数据，因此用在对连续型的数值数据上时，还需要对数据进行离散化，离散化的方法稍后说明，此处为了简化，先使用每一种特征所有连续性数值的中值作为分界点，小于中值的标记为1，大于中值的标记为0。训练1000次，统计准确率均值。

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) #区分测试集和训练集

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

输出结果为：score: 0.7335，即准确率有73%。每次训练和预测的准确率分布如下：

数据离散化

然而，在上例中对特征值离散化的划分点实际上过于“野蛮”，此处介绍一种通过信息增益最大的标准来对数据进行离散化。原理很简单，当信息增益最大时，说明用该点划分能最大程度降低数据集的不确定性。

具体步骤如下：

对每个特征所包含的数值型特征值排序

对相邻两个特征值取均值，这些均值就是待选的划分点

用每一个待选点把该特征的特征值划分成两类，小于该特征点置为1， 大于该特征点置为0，计算此时的条件熵，并计算出信息增益

选择信息使信息增益最大的划分点进行特征离散化

实现代码如下：

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

""" 用于把每个特征的连续值按照区分点分成两类，加入tag参数，可用于标记筛选的是哪一部分数据"""

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):

""" 对数据每个特征的数值型特征值进行离散化 """

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

重新对数据进行离散化，并重复该步骤1000次，同时用sklearn中的DecisionTreeClassifier对相同数据进行分类，分别统计平均准确率。运行代码如下:

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) #区分测试集和训练集

trainData_tmp = copy.copy(trainData)

testData_tmp = copy.copy(testData)

discritizationData, discritizationFeatName= dataDiscretization(trainData, featNames) #根据信息增益离散化

for i in range(testData.shape[1]-1): #根据测试集的区分点离散化训练集

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

准确率分布如下：

两者的结果非常一样。

（但是。。为什么根据信息熵离散化得到的准确率比直接用均值离散化的准确率还要低啊？？哇的哭出声。。）

最后一次决策树图形如下：

决策树剪枝

由于决策树是完全依照训练集生成的，有可能会有过拟合现象，因此一般会对生成的决策树进行剪枝。常用的是通过决策树损失函数剪枝，决策树损失函数表示为:

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)表示叶子节点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)是决策树的经验损失函数当随着T的增加，该节点被不停的划分的时候，熵值可以达到最小，然而T的增加会使后项的值增大。决策树损失函数要做的就是在两者之间进行平衡，使得该值最小。

对于决策树损失函数的理解，如何理解决策树的损失函数? - 陶轻松的回答 - 知乎这个回答写得挺好，可以按照答主的思路理解一下

C4.5算法

ID3算法通过信息增益来进行特征选择会有一个比较明显的缺点：即在选择的过程中该算法会优先选择类别较多的属性（这些属性的不确定性小，条件熵小，因此信息增益会大），另外，ID3算法无法解决当每个特征属性中每个分类都只有一个样本的情况（此时每个属性的条件熵都为0）。

C4.5算法ID3算法的改进，它不是依据信息增益进行特征选择，而是依据信息增益率，它添加了特征分裂信息作为惩罚项。定义分裂信息：

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)

关于ID3和C4.5算法

在学习分类回归决策树算法时，看了不少的资料和博客。关于这两个算法，ID3算法是最早的分类算法，这个算法刚出生的时候其实带有很多缺陷：

无法处理连续性特征数据

特征选取会倾向于分类较多的特征

没有解决过拟合的问题

没有解决缺失值的问题

即该算法出生时是没有带有连续特征离散化、剪枝等步骤的。C4.5作为ID3的改进版本弥补列ID3算法不少的缺陷：

通过信息最大增益的标准离散化连续的特征数据

在选择特征是标准从“最大信息增益”改为“最大信息增益率”

通过加入正则项系数对决策树进行剪枝

对缺失值的处理体现在两个方面：特征选择和生成决策树。初始条件下对每个样本的权重置为1。

特征选择：在选取最优特征时，计算出每个特征的信息增益后，需要乘以一个**“非缺失值样本权重占总样本权重的比例”**作为系数来对比每个特征信息增益的大小

生成决策树：在生成决策树时，对于缺失的样本我们按照一定比例把它归属到每个特征值中，比例为该特征每一个特征值占非缺失数据的比重

关于C4.5和CART回归树

作为ID3的改进版本，C4.5克服了许多缺陷，但是它自身还是存在不少问题：

C4.5的熵运算中涉及了对数运算，在数据量大的时候效率非常低。

C4.5的剪枝过于简单

C4.5只能用于分类运算不能用于回归

当特征有多个特征值是C4.5生成多叉树会使树的深度加深

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

版权声明：本文为CSDN博主「Sarah Huang」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。

原文链接：

python信息熵函数的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于python 熵值法、python信息熵函数的信息别忘了在本站进行查找喔。