统计学方法

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

```