[TOC]
## 1. 熵权法
熵权法(the entropy weight method)
1. 基本概念
a.. 信息熵最初由香农引入信息论
1. 独立与热力学熵的概念
2. 具有热力学熵的基本性质:单值性、可加性、极值性
3. 且具有更为广泛、普遍的意义,称为广义熵
4. 根据信息论
a. 信息是一个系统有序程度的度量
b. 熵是系统无序程度的度量
c. 熵值越小-> 变异程度越大 -> 提供的信息越多
b. 熵权法是一种客观赋权方法
1. 利用信息熵计算各指标熵权
2. 再利用熵权对各指标的权重进行修正,得到较为客观的指标权重
3. 适用范围
a. 任何评价问题中确定指标权重
b. 剔除指标体系中对评价结果贡献不大的指标
2. 熵权法基本原理
a. 若系统可能处于m种状态,且各出现的概率为P[i],系统熵定义为
e = -(P * ln(P)).sum()
则各状态出现概率相同时,熵取最大值
e.max = ln(m)
b. 对m个待评测项目、n个属性,评价矩阵R.shape=(m, n),则各属性
信息熵为
E = -(P * ln(P)).sum(0),其中P = R/R.sum(0)
1. 根据信息论:属性的熵值越小 -> 提供的信息量越大 ->
综合评价中该属性作用越大 -> 权重越大
2. 据此信息熵计算各属性熵权
W = (e.max - E)/(e.max - E).sum()
利用各属性熵权对所有属性加权
3. 还可以和各属性的重要性A综合考虑得到综合权数
WA = (W * A)/(W * A).sum()
3. 熵权法步骤(R.shape = (m, n))
a. 计算各项目、属性指标值比重P(同上)
b. 计算各属性熵值
E = 1/ln(m) * E
这个公式和上面的公式不一样,保证在属性熵最大(个项目在该属性上
取值相同)时E = 1,此时熵权计算公式简单
c. 计算各指标熵权
W = (1 - E)/(1 - E).sum()
d. 确定指标的综合权数(同上)
code1:
```python
###方法二:熵权法
class cul_weight():
def get_df(self,df):
"""处理数据,列名分别为组别、指标1、指标2、指标3,每行数据为每组数据统计量"""
def str2ft(x):
x = x[:-1]
return float(x) * 0.01
df['ctr'] = df.ctr.map(str2ft) #将带%的字符串转化成浮点数
df['followed'] = df.followed.map(str2ft)
data = df.copy()
data.iloc[:, 1:] = (data.iloc[:, 1:] - data.iloc[:, 1:].min()) / (
data.iloc[:, 1:].max() - data.iloc[:, 1:].min()) # 标准化
data.iloc[:, 1:] = (data.iloc[:, 1:]) / (data.iloc[:, 1:].sum()) # 统计概率p
return data
def comentropy(self,s):
"""计算某一列的信息熵"""
n = len(s)
def get_list(x):
if x > 0:
x = x * math.log(x, math.e)
else:
x = 0
return x
s = s.map(get_list)
E = (s.sum()) * (-1) / math.log(n, math.e)
return E
def get_weight(self,df):
"""根据信息熵来计算每个变量的权重"""
self.data = self.get_df(df)
columns = df.iloc[:, 1:].columns
k = len(columns)
s = []
for x in columns:
self.value = self.comentropy(self.data[x])
s.append(self.value)
wl = []
for i in range(k):
weight = (1-s[i])/(k-sum(s))
wl.append(weight)
res = pd.Series(wl, index=columns)
return res
```
code2:
```python
def entropy(data0):
#返回每个样本的指数
#样本数,指标个数
n,m=np.shape(data0)
#一行一个样本,一列一个指标
#下面是归一化
maxium=np.max(data0,axis=0)
minium=np.min(data0,axis=0)
data= (data0-minium)*1.0/(maxium-minium)
##计算第j项指标,第i个样本占该指标的比重
sumzb=np.sum(data,axis=0)
data=data/sumzb
#对ln0处理
a=data*1.0
print("a:",a)
a.iloc[np.where(data==0)]=0.0001
#data.iloc[np.where(data.iloc[:, 0] == samples[i])]
print("a2:",a)
# #计算每个指标的熵
e=(-1.0/np.log(n))*np.sum(data*np.log(a),axis=0)
# #计算权重
w=(1-e)/np.sum(1-e)
recodes=np.sum(data*w,axis=1)
return recodes
data = x_train[cat_col+continuous_col]
mm = data.copy()
w = get_entropy_weight(data)
# print("w:",w)
# print("wi_list:",wi_list[:20])
# w = get_score(mm, w)
# print("score_list:",score_list[:10])
# w = entropy(x_train[cat_col])
print("w:", w)
weights1 = np.array(w)
weights = weights1.tolist()
w.index = data.columns
w.columns = ['weight']
# mode=‘a’:即向csv文件追加数据,按行追加
# header=True:写入dataframe的列名(表头)
# index=None:不添加索引列
w.sort_values(by=["weight"], axis=0, ascending=False, inplace=True)
w.to_csv('grades.csv', mode='w', header=True)
print(w)
```
---
## 2. 双基点法
Technique for order preformance by similarity to ideal solution
双基点法
1. 概念
a. 基本原理:通过检测评价对象与最优解、最劣解的距离进行排序,若
评价对象最靠近最优解同时又最远离最劣解则为最好,反之最差
b. 最优解(理想解):各属性值都达到最满意的解
c. 最劣解(负理想解):各属性值都达到最不满意的解
2. 优势
a. 可客观的的对多指标情况下的各方案进行综合评价
b. 可加入评价着的主观偏好来对各方案进行综合评价
c. 概念简单、计算过程清晰、具有可操作性
3. 计算步骤(代码参见topsis.py)
#todo数据是否需要归一化
a. 向量规范法求规范决策矩阵Z
b. 构成加权规范阵
c. 确定理想解和负理想解
1. 效益属性:理想解为最大值,负理想解为最小值
2. 成本属性:与效益反
d. 计算各方案到理想解与负理解解直接的距离(欧式距离)
e. 计算各方案与理想解的接近程度
f. 按接近程度排序
4. 数据处理中的一些问题
a. 成本属性和效益属性的理想解要求相反的解决方案
1. 不做变换,直接对成本属性的理想解取最小值
2. 对数据做变换
a. 线性变换
1. 效益:x' = x/max(X)
变换后最差不为0,最佳为1
2. 成本:x' = 1 - x/max(X)
变换后最佳不为1,最差为0
b. 标准0-1变换:
1. 效益:x = (x - min(X))/(max(X) - min(X))
2. 成本:y = (max(X) - x)/(max(X) - min(X))
3. 特点:最佳值均为1,最差值为0,且变换后差值线性
c. 最优值为区间时变换
设最优区间[x2, x3],x1为无法容忍下限,x4为无法容忍上限
1. 对x1 < x <x2
x' = 1 - (x2 - x)/(x2 - x1)
2. 对x2 < x < x3
x' = 1
3. 对x3 < x < x4
x' = 1 - (x - x3)/(x4 - x3)
d. 对数据做变换其实就是寻找一个合适的函数,其值域符合
要求,而其中最常用的就是线性变换,即使用线性函数对数据
进行变换,如以上三个方法。
而如果能够确信一个更加符合实际情况的变换函数,也可以不
采用线性变换。
b. 权重计算
1. 能够直接获得可用的属性权重向量,可以直接使用
2. 有时无法直接获得各属性的权重,只能获得其两两重要性比较
矩阵,此时则需要对矩阵进行运算得到权重向量
## 3. 均方差,均方根误差和方差的区别
(1)总的来说,均方差,均方根误差和方差,标准差是不能够等同的,尽管它们的公式相似。我们需要从真实值和均值之间的关系来区分它们
(2)对于方差和标准差而言,它们反映的是数据序列与均值的关系。
(3)对于均方差和均方根误差而言,它们反映的是数据序列与真实值之间的关系。
## 4. 计算信息熵和信息增益
python 计算信息熵和信息增益
1. 计算信息熵
```python
def calc_ent(x):
"""
calculate shanno ent of x
"""
x_value_list = set([x[i] for i in range(x.shape[0])])
ent = 0.0
for x_value in x_value_list:
p = float(x[x == x_value].shape[0]) / x.shape[0]
logp = np.log2(p)
ent -= p * logp
return ent
```
2. 计算条件信息熵
```python
def calc_condition_ent(x, y):
"""
calculate ent H(y|x)
"""
# calc ent(y|x)
x_value_list = set([x[i] for i in range(x.shape[0])])
ent = 0.0
for x_value in x_value_list:
sub_y = y[x == x_value]
temp_ent = calc_ent(sub_y)
ent += (float(sub_y.shape[0]) / y.shape[0]) * temp_ent
return ent
```
3. 计算信息增益
ent_prap = H(Y) - H(Y|X)
```python
def calc_ent_grap(x,y):
"""
calculate ent grap
"""
base_ent = calc_ent(y)
condition_ent = calc_condition_ent(x, y)
ent_grap = base_ent - condition_ent
return ent_grap
```
另一种方法:
```python
import pandas as pd
import numpy as np
import math
## 计算信息熵
def getEntropy(s):
# 找到各个不同取值出现的次数
if not isinstance(s, pd.core.series.Series):
s = pd.Series(s)
prt_ary = pd.groupby(s , by = s).count().values / float(len(s))
return -(np.log2(prt_ary) * prt_ary).sum()
## 计算条件熵: 条件s1下s2的条件熵
def getCondEntropy(s1 , s2):
d = dict()
for i in list(range(len(s1))):
d[s1[i]] = d.get(s1[i] , []) + [s2[i]]
return sum([getEntropy(d[k]) * len(d[k]) / float(len(s1)) for k in d])
## 计算信息增益
def getEntropyGain(s1, s2):
return getEntropy(s2) - getCondEntropy(s1, s2)
## 计算增益率
def getEntropyGainRadio(s1, s2):
return getEntropyGain(s1, s2) / getEntropy(s2)
## 衡量离散值的相关性
import math
def getDiscreteCorr(s1, s2):
return getEntropyGain(s1,s2) / math.sqrt(getEntropy(s1) * getEntropy(s2))
# ######## 计算概率平方和
def getProbSS(s):
if not isinstance(s, pd.core.series.Series):
s = pd.Series(s)
prt_ary = pd.groupby(s, by = s).count().values / float(len(s))
return sum(prt_ary ** 2)
######## 计算基尼系数
def getGini(s1, s2):
d = dict()
for i in list(range(len(s1))):
d[s1[i]] = d.get(s1[i] , []) + [s2[i]]
return 1-sum([getProbSS(d[k]) * len(d[k]) / float(len(s1)) for k in d])
## 对离散型变量计算相关系数,并画出热力图, 返回相关性矩阵
def DiscreteCorr(C_data):
## 对离散型变量(C_data)进行相关系数的计算
C_data_column_names = C_data.columns.tolist()
## 存储C_data相关系数的矩阵
import numpy as np
dp_corr_mat = np.zeros([len(C_data_column_names) , len(C_data_column_names)])
for i in range(len(C_data_column_names)):
for j in range(len(C_data_column_names)):
# 计算两个属性之间的相关系数
temp_corr = getDiscreteCorr(C_data.iloc[:,i] , C_data.iloc[:,j])
dp_corr_mat[i][j] = temp_cor
# 画出相关系数图
fig = plt.figure()
fig.add_subplot(2,2,1)
sns.heatmap(dp_corr_mat ,vmin= - 1, vmax= 1, cmap= sns.color_palette('RdBu' , n_colors= 128) , xticklabels= C_data_column_names , yticklabels= C_data_column_names)
return pd.DataFrame(dp_corr_mat)
if __name__ == "__main__":
s1 = pd.Series(['X1' , 'X1' , 'X2' , 'X2' , 'X2' , 'X2'])
s2 = pd.Series(['Y1' , 'Y1' , 'Y1' , 'Y2' , 'Y2' , 'Y2'])
print('CondEntropy:',getCondEntropy(s1, s2))
print('EntropyGain:' , getEntropyGain(s1, s2))
print('EntropyGainRadio' , getEntropyGainRadio(s1 , s2))
print('DiscreteCorr:' , getDiscreteCorr(s1, s1))
print('Gini' , getGini(s1, s2))
```
原创声明:本文系作者授权腾讯云开发者社区发表,未经许可,不得转载。
如有侵权,请联系 cloudcommunity@tencent.com 删除。
原创声明:本文系作者授权腾讯云开发者社区发表,未经许可,不得转载。
如有侵权,请联系 cloudcommunity@tencent.com 删除。