1、前情回顾
之前的文章,我们详细介绍了熵权法的具体计算过程(不清楚的读者可点击此处的传送门《利用熵权法进行数值评分计算——算法过程》)。本篇文章我们展示熵权法的主要实现代码(Java版本,实际上Python、GoLang等逻辑是相同的,之后会提供GoLang版本的代码)。
2、具体计算过程
本文的介绍将通过以下示例场景进行:
// 指标数量
int pointNumber = 6;
// 行表示每个参与者的数据,列表示每一个评分指标
double points[][] = new double[][] {{0.0 , 0.0 , 1.0 , 0.0 , 0.0 , 4.0},{1.0 , 2.0 , 0.0 , 0.0 , 0.0 , 3.0},{2.0 , 0.0 , 0.0 , 0.0 , 0.0 , 3.0},{1.0 , 0.0 , 1.0 , 0.0 , 2.0 , 4.0},{3.0 , 0.0 , 0.0 , 0.0 , 1.0 , 4.0},{1.0 , 1.0 , 0.0 , 1.0 , 0.0 , 4.0},{0.0 , 1.0 , 1.0 , 1.0 , 1.0 , 5.0}};
// 如果为true,表示是正向指标;反之则是负向指标
boolean forwards[] = new boolean [] {false , false , false , false , false , true};
从以上代码中我们知道了,评分参与者有7人(或者理解成7个品牌的车、7款电视信号,等等)。评分指标一共有6个,其中除了最后第6个指标外,其余指标都是负向指标。
2.1、首先进行数据标准化
/*** 数据标准化,主要是区分正向因子和负向因子,进行数据标准化,以便进行下一步计算* (这里修正了一下,保证结果不可能出现分母为0的情况)* @param points 原始数据数组* @param index 需要进行标准化的原始数据的索引位置* @param forward 是否是正向因子* @return 返回的标准化之后的数值*/
private static double standard(double points[] , int index , boolean forward) {if(index < 0 || index > points.length - 1) {throw new IllegalArgumentException("错误的参数");}double max = new Max().evaluate(points);double min = new Min().evaluate(points);// 正向指标double result = 0.0;if(forward) {result = (points[index] - min + 1) / (max - min + 1);} else {result = (max - points[index] + 1) / (max - min + 1);}return result;
}// 下面开始进行矩阵的标准化
// 数据标准化后的对应矩阵,存储在这里
double standards[][] = new double[points.length][pointNumber];
// 数据标准化,正向因子和负向因子的标准化要求不一样
for(int index = 0 ; index < pointNumber ; index++) {double matrixs[] = matrixFlipping(points, index);for(int matrixIndex = 0 ; matrixIndex < matrixs.length ; matrixIndex++) {double matrixStandard = standard(matrixs, matrixIndex, forwards[index]);standards[matrixIndex][index] = matrixStandard;}
}
请注意以上代码标段中得到的标准化之后的矩阵standards,后续的计算步骤主要就是使用这个standards矩阵进行。另外注意,为了程序员编码过程的方便,我们在进行每个指标数据标准化前,可以对矩阵的一部分进行翻转,代码片段如下:
/*** 矩阵翻转,矩阵翻转的目的,是确保计算方便* @param matrixs 原始数据矩阵(二维矩阵)* @param index 需要翻转的原始矩阵的索引号* @return*/
private static double[] matrixFlipping(double matrixs[][] , int index) {int matrixLen = matrixs.length;double flips[] = new double[matrixLen];for(int lenIndex = 0 ; lenIndex < matrixLen ; lenIndex++) {flips[lenIndex] = matrixs[lenIndex][index];}return flips;
}
数值矩阵的翻转只是为了保证程序员编写代码的便利性,和计算过程没有任何关系。
2.2、求各评分要素的数值比例
接下来,我们用经过数值标准化的矩阵,带入以下代码片段,进行数值比例的计算:
/*** 求数值比例* @param points* @param index 需要求值的原始数据的索引位置* @return */
private static double relatMatrix(double standards[] , int index) {double sum = new Sum().evaluate(standards);double result = standards[index] / sum;return result;
}// 对数值比例的调用执行,如以下代码片段所示
// 比例化后的数据存储在这里
double proportions[][] = new double[standards.length][pointNumber];
for(int index = 0 ; index < pointNumber ; index++) {double matrixs[] = matrixFlipping(standards, index);for(int matrixIndex = 0 ; matrixIndex < matrixs.length ; matrixIndex++) {double matrixStandard = relatMatrix(matrixs, matrixIndex);proportions[matrixIndex][index] = matrixStandard;}
}
请注意以上代码片段中的proportions矩阵,求得的数值比例值就存储在这里,并且后续继续基于此矩阵进行计算。
2.3、求对数
求对数的方法如下代码片段所示:
// 求对数
double lnMatrixs[][] = new double[standards.length][pointNumber];
for(int index = 0 ; index < proportions.length ; index++) {double matrixItems[] = proportions[index];for(int matrixIndex = 0 ; matrixIndex < matrixItems.length ; matrixIndex++) {double lnResult = matrixItems[matrixIndex] * Math.log(matrixItems[matrixIndex]);lnMatrixs[index][matrixIndex] = lnResult;}
}
注意,以上求对数的过程引入了Java原生的求对数计算工具。另外,求得的对数值,被放置在lnMatrixs这个数值矩阵中。
2.4、求每一个评分要素的熵值
/*** 计算某一个数组的熵值* @param matrixs* @return*/
private static double entropyMatrix(double matrixs[]) {double result = (-1 * 1 / Math.log(matrixs.length)) * (new Sum().evaluate(matrixs));return result;
}// 计算熵值的代码如下所示
// 其中n表示参与评分的数据条数
double entropys[] = new double[pointNumber];
for(int index = 0 ; index < pointNumber ; index++) {double matrixs[] = matrixFlipping(lnMatrixs, index);double entropy = entropyMatrix(matrixs);entropys[index] = entropy;
}
// 根据熵求权值
double entropyWeights[] = new double[pointNumber];
for(int index = 0 ; index < pointNumber ; index++) {double weight = relatMatrix(entropys, index);entropyWeights[index] = weight;
}
注意以上代码片段中,除了调用了求每个要素熵值的matrixFlipping方法外,还调用了求数值比例的relatMatrix方法。这是因为熵值也要进行占比计算。
2.5、计算基准得分和使用者能看懂的百分制得分
现在开始计算基准得分,并基于基准得分计算得到百分制得分。
// 基于熵权进行每一个评分参与者的基准得分
double benchScores[] = new double[standards.length];
for(int index = 0 ; index < standards.length ; index++) {double standardItems[] = standards[index];double result = 0d;for(int weightIndex = 0 ; weightIndex < entropyWeights.length ; weightIndex++) {result += standardItems[weightIndex] * entropyWeights[weightIndex];}benchScores[index] = result;
}// 转换成百分数
Double percentageScores[] = new Double[standards.length];
for(int index = 0 ; index < standards.length ; index++) {percentageScores[index] = percentageScores(benchScores, index);
}
System.out.println("percentageScores = " + StringUtils.join(percentageScores, " | "));/*** 转换为100分制* @param benchScores* @param index 要将哪一个基准数转换为100分制* @return*/
private static double percentageScores(double benchScores[] , int index) {int len = benchScores.length;Double maxScore = new Max().evaluate(benchScores);Double maxScaleScore = new BigDecimal(maxScore.toString()).setScale(2, RoundingMode.UP).doubleValue();Double total = (100 * len) / (maxScaleScore * len) * benchScores[index];return new BigDecimal(total.toString()).setScale(2, RoundingMode.HALF_UP).doubleValue();
}
以下是针对最原始评分项,经过熵权法评分后的计算结果:
percentageScores = 98.99 | 84.68 | 92.72 | 81.45 | 87.93 | 87.78 | 82.91
以上计算结果中,第一个参与者的百分制得分是98.99;第二个参与者的百分制得分是84.68;以此类推。
3、总结说明
这里我们给出完整的代码片段,有需要的读者可直接复制粘贴
// 熵权法相关代码——可直接执行
public class EwmTest {public static void main(String[] args) {// 指标数量int pointNumber = 6;// 行表示每个参与者的数据,列表示每一个评分指标double points[][] = new double[][] {{0.0 , 0.0 , 1.0 , 0.0 , 0.0 , 4.0},{1.0 , 2.0 , 0.0 , 0.0 , 0.0 , 3.0},{2.0 , 0.0 , 0.0 , 0.0 , 0.0 , 3.0},{1.0 , 0.0 , 1.0 , 0.0 , 2.0 , 4.0},{3.0 , 0.0 , 0.0 , 0.0 , 1.0 , 4.0},{1.0 , 1.0 , 0.0 , 1.0 , 0.0 , 4.0},{0.0 , 1.0 , 1.0 , 1.0 , 1.0 , 5.0}};// 如果为true,表示是正向指标;反之则是负向指标boolean forwards[] = new boolean [] {false , false , false , false , false , true};// 数据标准化后的对应矩阵,存储在这里double standards[][] = new double[points.length][pointNumber];// 数据标准化,正向因子和负向因子的标准化要求不一样for(int index = 0 ; index < pointNumber ; index++) {double matrixs[] = matrixFlipping(points, index);for(int matrixIndex = 0 ; matrixIndex < matrixs.length ; matrixIndex++) {double matrixStandard = standard(matrixs, matrixIndex, forwards[index]);standards[matrixIndex][index] = matrixStandard;}}// 接着求各列的数值比例,比例化后的数据存储在这里double proportions[][] = new double[standards.length][pointNumber];for(int index = 0 ; index < pointNumber ; index++) {double matrixs[] = matrixFlipping(standards, index);for(int matrixIndex = 0 ; matrixIndex < matrixs.length ; matrixIndex++) {double matrixStandard = relatMatrix(matrixs, matrixIndex);proportions[matrixIndex][index] = matrixStandard;}}// 求对数double lnMatrixs[][] = new double[standards.length][pointNumber];for(int index = 0 ; index < proportions.length ; index++) {double matrixItems[] = proportions[index];for(int matrixIndex = 0 ; matrixIndex < matrixItems.length ; matrixIndex++) {double lnResult = matrixItems[matrixIndex] * Math.log(matrixItems[matrixIndex]);lnMatrixs[index][matrixIndex] = lnResult;}}// 计算熵值,其中n表示参与评分的数据条数double entropys[] = new double[pointNumber];for(int index = 0 ; index < pointNumber ; index++) {double matrixs[] = matrixFlipping(lnMatrixs, index);double entropy = entropyMatrix(matrixs);entropys[index] = entropy;}// 根据熵求权值double entropyWeights[] = new double[pointNumber];for(int index = 0 ; index < pointNumber ; index++) {double weight = relatMatrix(entropys, index);entropyWeights[index] = weight;}// 基于熵权进行每一个评分参与者的基准得分double benchScores[] = new double[standards.length];for(int index = 0 ; index < standards.length ; index++) {double standardItems[] = standards[index];double result = 0d;for(int weightIndex = 0 ; weightIndex < entropyWeights.length ; weightIndex++) {result += standardItems[weightIndex] * entropyWeights[weightIndex];}benchScores[index] = result;}// 转换成百分数Double percentageScores[] = new Double[standards.length];for(int index = 0 ; index < standards.length ; index++) {percentageScores[index] = percentageScores(benchScores, index);}System.out.println("percentageScores = " + StringUtils.join(percentageScores, " | "));}/*** 转换为100分制* @param benchScores* @param index 要将哪一个基准数转换为100分制* @return*/private static double percentageScores(double benchScores[] , int index) {int len = benchScores.length;Double maxScore = new Max().evaluate(benchScores);Double maxScaleScore = new BigDecimal(maxScore.toString()).setScale(2, RoundingMode.UP).doubleValue();Double total = (100 * len) / (maxScaleScore * len) * benchScores[index];return new BigDecimal(total.toString()).setScale(2, RoundingMode.HALF_UP).doubleValue();}/*** 计算某一个数组的熵值* @param matrixs* @return*/private static double entropyMatrix(double matrixs[]) {double result = (-1 * 1 / Math.log(matrixs.length)) * (new Sum().evaluate(matrixs));return result;}/*** 求数值比例比例* @param points* @param index 需要求值的原始数据的索引位置* @return */private static double relatMatrix(double standards[] , int index) {double sum = new Sum().evaluate(standards);double result = standards[index] / sum;return result;}/*** 矩阵翻转,矩阵翻转的目的,是确保计算方便* @param matrixs 原始数据矩阵(二维矩阵)* @param index 需要翻转的原始矩阵的索引号* @return*/private static double[] matrixFlipping(double matrixs[][] , int index) {int matrixLen = matrixs.length;double flips[] = new double[matrixLen];for(int lenIndex = 0 ; lenIndex < matrixLen ; lenIndex++) {flips[lenIndex] = matrixs[lenIndex][index];}return flips;}/*** 数据标准化,主要是区分正向因子和负向因子,进行数据标准化,以便进行下一步计算(这里修正了一下,导致结果不可能为0)* @param points 原始数据数组* @param index 需要进行标准化的原始数据的索引位置* @param forward 是否是正向因子* @return 返回的标准化之后的数值*/private static double standard(double points[] , int index , boolean forward) {if(index < 0 || index > points.length - 1) {throw new IllegalArgumentException("错误的参数");}double max = new Max().evaluate(points);double min = new Min().evaluate(points);// 正向指标double result = 0.0;if(forward) {result = (points[index] - min + 1) / (max - min + 1);} else {result = (max - points[index] + 1) / (max - min + 1);}return result;}
}