利用熵权法确定指标权重

利用熵权法确定指标权重

1. 熵权法的基本原理

熵权法的基本思路是根据指标变异性的大小来确定客观权重。
一般来说，若某个指标的信息熵越小，表明指标值得变异程度越大，提供的信息量越多，在综合评价中所能起到的作用也越大，其权重也就越大。相反，某个指标的信息熵越大，表明指标值得变异程度越小，提供的信息量也越少，在综合评价中所起到的作用也越小，其权重也就越小。

2. 熵权法求权重的具体步骤

1. 综合评价中，有些指标是高优指标，有些指标是低 优指标。用熵权法确定指标权重时，要求所有指标方 向一致。通常采用将低优指标高优化，对绝对数低优 指标采用倒数法( 1 /X) ，对相对数低优指标采用差 值法(1-X)。

2. 进行指标无量纲化。

3. 确定权重之后进行权重归一化。

   – 公式我不会写，自己网上找去。

3. 代码实现

public class CalculateWeight extends Calculate {
    public static void main(String[] args) {
        String matrixStr = "{\n" +
                "    \"coefficient\":  0.5,\n" +
                "    \"array\":[\n" +
                "        {\n" +
                "        \"name\": \"专家1\",\n" +
                "        \"index\": [1.0,0.8,0.7]\n" +
                "        },\n" +
                "        {\n" +
                "        \"name\": \"专家2\",\n" +
                "        \"index\": [0.8,0.7,0.8]\n" +
                "        },\n" +
                "        {\n" +
                "        \"name\": \"专家3\",\n" +
                "        \"index\": [0.9,0.8,0.8]\n" +
                "        },\n" +
                "        {\n" +
                "        \"name\": \"专家4\",\n" +
                "        \"index\": [0.8,0.6,0.9]\n" +
                "        }\n" +
                "    ]\n" +
                "}";
        CalculateWeight calculateWeight = new CalculateWeight();
        double[] weightArray = calculateWeight.getWeight(matrixStr);
        Arrays.stream(weightArray).forEach(System.out::println);
    }

    /**
     * 计算中间节点的权重
     *
     * @param matrixStr 重要性矩阵字符串
     * @return 权重值数组
     */
    @Override
    public double[] getWeight(String matrixStr) {
        if (StringUtils.isEmpty(matrixStr)) {
            double[] weight = new double[0];
            return weight;
        }
        // 用于存放每种指标下所有记录归一化后的和
        List<Double> listSum = new ArrayList<>();
        // 用于存放每种指标的差异系数
        List<Double> gList = new ArrayList<>();
        List<List<Double>> list = this.getList(matrixStr);
        double sumLast = 0;
        // 计算k值 k= 1/ln(n)
        double k = 1 / Math.log(list.get(0).size());

        // 数据归一化处理	(i-min)/(max-min)
        for (int i = 0; i < list.size(); i++) {
            double sum = 0;
            List<Double> list1 = list.get(i);
            double max = Collections.max(list.get(i));
            double min = Collections.min(list.get(i));
            for (int j = 0; j < list.get(i).size(); j++) {
                double temp = (list.get(i).get(j) - min) / (max - min);
                sum += temp;
                list.get(i).set(j, temp);
            }
            listSum.add(sum);
        }
        
        // 计算每项指标下每个记录所占比重
        for (int i = 0; i < list.size(); i++) {
            //每种指标下所有记录权重和
            double sum = 0;
            for (int j = 0; j < list.get(i).size(); j++) {
                if (list.get(i).get(j) / listSum.get(i) == 0) {
                    sum += 0;
                } else {
                    sum += (list.get(i).get(j) / listSum.get(i)) * Math.log(list.get(i).get(j) / listSum.get(i));
                }
            }
            // 计算第i项指标的熵值
            double e = -k * sum;
            // 计算第j项指标的差异系数
            double g = 1 - e;
            sumLast += g;
            gList.add(g);
        }

        // 用于存放每种指标的最终权重系数
        double[] weightArray = new double[gList.size()];
        // 计算每项指标的权重
        for (int i = 0; i < gList.size(); i++) {
            double val = gList.get(i) / sumLast;
            val = new BigDecimal(val).setScale(4, BigDecimal.ROUND_HALF_UP).doubleValue();
            weightArray[i] = val;
        }
        return weightArray;
    }

    /**
     * 转换数据结构
     *
     * @param str 获取每个专家评估指标的值
     * @return List-List-Double
     */
    public List<List<Double>> getList(String str) {
        List<List<Double>> list = new ArrayList<>();
        JSONObject jsonObject = JSON.parseObject(str);
        JSONArray array = jsonObject.getJSONArray("array");
        ArrayList<Double> doubles = null;
        for (int i = 0; i < array.size(); i++) {
            JSONObject jsonObject1 = array.getJSONObject(i);
            doubles = new ArrayList<>();
            JSONArray index = jsonObject1.getJSONArray("index");
            for (int j = 0; j < index.size(); j++) {
                doubles.add(index.getDouble(j));
            }
            list.add(doubles);
        }
        return list;
    }
}

4. 总结

熵权法能深刻反映出指标的区分能力，进而确定权重。熵权法也是一种客观赋权法，有理论依据，相对主观赋权具有较高的可信度和精确度。算法简单，实践起来比较方便，不需要借助其他分析软件。近 几 年已被广泛应用于医院质量评价、医疗服务能力评价、 绩效评价和卫生决策等综合评价。