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;}
}