决策模型(二)：风险决策法

时间 2019-12-10

标签决策模型风险繁體版

原文原文链接

原文连接（转载请注明出处）：决策模型(二)：风险决策法

前言

风险决策法是指决策者对客观状况不了解，可是对将发生各事件的几率是已知的。决策者每每经过调查，根据过去的经验或主观估计等途径得到这些几率。在风险决策中通常采用指望值做为决策准则，经常使用的有最大指望收益决策准则（EMV）和最小机会损失决策准则（EOL）。html

风险型决策问题通常具备如下特色:java

决策具备明确目标: 得到最大收益（利润）或最小损失；
存在两个以上可供选择的行动方案
存在两个或两个以上不以决策者主观意志为转移的天然状态，但决策者根据过去的经验，主观估计或科学理论等可预先估算出这些状态出现的几率值；
各行动方案在肯定状态下的损益值能够计算出来；

下面接着上一篇博文，对文中的例子作风险决策分析，决策矩阵以下：算法

（策略\事件）	E₁ = 0	E₂ = 10	E₃ = 20	E₄ = 30	E₅ = 40
事件几率（p_j）	0.1	0.2	0.4	0.2	0.1
S₁ = 0	0	0	0	0	0
S₂ = 10	-10	50	50	50	50
S₃ = 20	-20	40	100	100	100
S₄= 30	-30	30	90	150	150
S₅ = 40	-40	20	80	140	200

(注：记各天然状态发生的几率为\(p_j\)，采用第 i 种方案在发生第 j 天然状态下的损益值为 \(a_{ij}\))函数

最大指望收益决策准则（EMV）

定义

最大指望收益决策，显而易见，就是计算出每一个方案指望收益值，而后选取最大指望值对应的方案即为最优方案。spa

计算步骤

先根据各事件发生的几率 \(p_j\)，求出各个策略的指望收益值。而后从这些指望收益值中选择最大者，它对应的策略为决策应选策略。code

计算公式

S^*_k \(\rightarrow\) max \(\sum_{j} p_ja_{ij}\)htm

计算结果

（策略\事件）	E₁ = 0	E₂ = 10	E₃ = 20	E₄ = 30	E₅ = 40	EMV
事件几率（p_j）	0.1	0.2	0.4	0.2	0.1
S₁ = 0	0	0	0	0	0	0
S₂ = 10	-10	50	50	50	50	44
S₃ = 20	-20	40	100	100	100	76
S₄= 30	-30	30	90	150	150	84 \(\longleftarrow\) max
S₅ = 40	-40	20	80	140	200	80

根据 EMV 决策准则有blog

max (0 , 44 , 76, 84, 80) = 84事件

对应的决策策略为 S₄，为决策者选择的策略。ci

EMV 决策准则适用于一次决策屡次重复进行生产的状况，因此它是平均意义下的最大收益。

计算代码

private static int row = 4; //行
private static int col = 3; //列
private static double t =2; //效用曲率系数

private static double[][] matrix = {//决策矩阵
     //事件     1   2   3
            {0.2,0.5,0.3},  //事件几率
            {140,120, 80},  //策略
            {200,150, 40},  //策略
            {340,140,-20},  //策略
    };

/**
 * 最大指望收益决策准则(EMV)
 * @param matrix
 * @param row
 * @param col
 */
private static void EMV(double[][] matrix, int row, int col){
    double[] maxMar = new double[row+1]; //记录每种行动方案的结果，第一行是天然状态几率
    double max = 0.0; //最优结果
    double temp = 0.0;
    double chance = 0.0; //几率
    int maxIndex = 0; //最优结果下标
    //由于第一行是天然状态几率，因此从第二行开始，实际的行数比 row 多一行
    for (int i = 1; i <= row; i++) {
        for (int j = 0; j < col; j++) {
            chance =  matrix[0][j]; //天然几率
            temp = (j != 0) ? (temp + matrix[i][j]*chance) : (matrix[i][j]*chance);
        }
        maxMar[i] = temp;
        if(i == 1){ // 当 i=1时，为 max 与 maxIndex 赋初值
            max = temp;
            maxIndex = 1;
        }else if(temp > max){
            max = temp;
            maxIndex = i;
        }
    }
    System.out.println(Arrays.toString(maxMar));
    System.out.println(max+"--"+maxIndex);
}

最小机会损失决策准则（EOL）

定义

最小机会损失决策与不肯定型决策法里的最小机会损失决策准则相相似，都是先将收益矩阵的中各元素变换为机会损失值。将各天然状态下的最大收益值定为理想目标，并将该状态中的其余值与最高值之差称为机会损失值。而后求这些机会损失值的指望损失值，最后从中选取最小的指望损失值，对应的策略即为决策者所选的策略。

计算步骤

首先计算出当发生 j 事件后，各策略的收益最大值

a_i_j = max ( a_i_j )

这时各策略的机会损失值为

\(a'_{ij}\) = { max ( a_i_j ) - a_i_j }

而后求这些机会损失值的指望损失值，最后从中选取最小的指望损失值

min \(\sum_{j} p_ja'_{ij}\)

计算公式

S^*_k \(\rightarrow\) min \(\sum_{j} p_ja'_{ij}\)

计算结果

（策略\事件）	E₁ = 0	E₂ = 10	E₃ = 20	E₄ = 30	E₅ = 40	EOL
事件几率（p_j）	0.1	0.2	0.4	0.2	0.1
S₁ = 0	0	50	100	150	200	100
S₂ = 10	10	0	50	100	150	56
S₃ = 20	20	10	0	50	100	24
S₄= 30	30	20	10	0	50	16 \(\longleftarrow\) max
S₅ = 40	40	30	20	10	0	20

根据 EOL 决策准则有

min (100, 56 , 24, 16, 20) = 16

对应的决策策略为 S₄，为决策者选择的策略。

从本质上讲 EMV 与 EOL 决策准则是同样的。因此决策时这两个决策结果是同样的。

计算代码

/**
 * 最小机会损失决策准则(EOL)
 * @param matrix
 * @param row
 * @param col
 */
private static void EOL(double[][] matrix, int row, int col){
    //先求损失矩阵
    double[][] loss = new double[row+1][col];
    for (int j = 0; j < col; j++) {
        loss[0][j] = matrix[0][j]; //将天然几率复制到损失矩阵的第一行中
        double max = matrix[1][j]; //先定每一列的第一个最大
        for (int i = 1; i <= row; i++) {
            if(matrix[i][j] > max){
                max = matrix[i][j];
            }
        }
        //此时已经求出该列的最大值
        //损失矩阵中对应位置的值 = 决策矩阵中列最大值 - 决策矩阵中对应位置值
        for (int i = 1; i <= row; i++) {
            loss[i][j] = max - matrix[i][j];
        }
    }

    //而后再求 EOL 决策
    double[] maxMar = new double[row+1];
    double min = 0.0;
    double temp = 0.0;
    int minIndex = 0;
    double chance = 0.0;
    for (int i = 1; i <= row; i++) {
        for (int j = 0; j < col; j++) {
            chance =  loss[0][j]; //天然几率
            temp = (j != 0) ? (temp + loss[i][j]*chance) : (loss[i][j]*chance);
        }
        maxMar[i] = temp;
        if(i == 1){
            min = temp;
            minIndex = 1;
        } else if(temp < min){
            min = temp;
            minIndex = i;
        }
    }
    
    System.out.println(Arrays.toString(maxMar));
    System.out.println(min+"--"+minIndex);
}

全情报的价值（EVPI）

定义

当决策者耗费了必定经费进行调研，得到了各事件发生几率的信息，应采用 ”随机应变“ 的战术，这时所得的指望收益称为全情报的指望收益，记作 EPPI，这个收益应当大于至少等于最大指望收益，即 EPPI >= max（EMV），则有EVPI = EPPL - max(EMV)，EVPI 称为全情报的价值，这就说明得到情报的费用不能超过 EVPI 值，不然就没有增长收入。

计算步骤

先进行 EMV 决策法计算，求得最大指望收益值

max \(\sum_{j} p_ja_{ij}\)

而后求全情报指望收益，先得求收益矩阵中每行的最大值而后求指望，最后将每行最大值的指望相加，获得全情报指望收益。

\(\sum_{j} p_jmax(a_{i})\) ; \(max(a_{i})\) 是 i 行的最大值

全情报指望收益减去最大指望收益即为全情报价值 EVPI

EVPI = \(\sum_{j} p_jmax(a_{i})\) - max \(\sum_{j} p_ja_{ij}\)

计算公式

EVPI = \(\sum_{j} p_jmax(a_{i})\) - max \(\sum_{j} p_ja_{ij}\)

计算结果

（策略\事件）	E₁ = 0	E₂ = 10	E₃ = 20	E₄ = 30	E₅ = 40	EMV	指望收益	EVPI
事件几率（p_j）	0.1	0.2	0.4	0.2	0.1
S₁ = 0	0	0	0	0	0	0
S₂ = 10	-10	50	50	50	50	44
S₃ = 20	-20	40	100	100	100	76
S₄= 30	-30	30	90	150	150	84 \(\longleftarrow\) max	100	16
S₅ = 40	-40	20	80	140	200	80

根据 EMV 决策准则有

max (0, 44, 76 , 84, 80) = 84

获得最大的指望收益值为 84 , 再求得全情报指望收益 = 100 ,最后可得全情报价值EVPI = 16, 对应的决策策略为 S₄，为决策者选择的策略。

计算代码

/**
  * 全情报价值(EVPI)
  * @param matrix
  * @param row
  * @param col
  */
private static void EVPI(double[][] matrix, int row, int col){
    double[] maxMar = new double[row+1]; //记录每种行动方案的结果，第一行是天然状态几率
    double max = 0.0; //最优结果
    double temp = 0.0;
    double chance = 0.0; //几率
    int maxIndex = 0; //最优结果下标
    //由于第一行是天然状态几率，因此从第二行开始，实际的行数比 row 多一行
    for (int i = 1; i <= row; i++) {
        for (int j = 0; j < col; j++) {
            chance =  matrix[0][j]; //天然几率
            temp = (j != 0) ? (temp + matrix[i][j]*chance) : (matrix[i][j]*chance);
        }
        maxMar[i] = temp;
        if(i == 1){ // 当 i=1时，为 max 与 maxIndex 赋初值
            max = temp;
            maxIndex = 1;
        }else if(temp > max){
            max = temp;
            maxIndex = i;
        }
    }

    double rowMax = 0.0;
    double expect = 0.0;
    double chance = 0.0;
    double value = 0.0;

    //计算全情报价值收益
    for (int i = 0; i < col; i++) {
        chance =  matrix[0][i]; //天然几率
        for (int j = 1; j <= row; j++) {
            if(j == 1){ //初始化第一行第一个为该行最大的收益值
                rowMax = matrix[j][i];
            }else if (matrix[j][i] > rowMax){
                rowMax = matrix[j][i];
            }
        }
        expect += rowMax * chance;
    }
    
    except = new BigDecimal(expect).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
    value = new BigDecimal(expect - max).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
    
    System.out.println("全情报指望收益:"+except);
    System.out.println("全情报价值EVPI:"+value);
}

效用曲线拟合（EUV）

定义

效用概念首先是由贝努里提出的,他认为人们对其钱财的真实价值的考虑与他的钱财拥有量有对数关系。经济管理学家将效用做为指标，用它来衡量人们对某些事物的主观价值，态度，偏心，倾向等。例如在风险状况下进行决策，决策者对风险的态度是不一样的，用效用指标来量化决策者对待风险的态度，能够给每个决策者测定他对待风险的态度的效用曲线函数。这里还有一个几率是效用曲线系数，效用曲线系数的取值范围为（0,∞）。

计算步骤

先创建效用曲线函数，将矩阵中的收益值装化为效用值，其中 t 为效用曲线系数，b=max{x1,x2,x3,⋯,xn} ，a=min{x1,x2,x3,⋯,xn}) ；

U(x) = \(\left\{\begin{matrix} &0, & x\leq a & \\ &(\frac{x-a}{b-a})^t, & a\leq x\leq b \\ &1, &x\geq b \end{matrix}\right.\)

而后计算指望效用值,结果为指望效用的最大值

EUV_i = \(\sum_{j} p_ju_{ij}\)

计算公式

S^*_k \(\rightarrow\) max \(\sum_{j} p_ju_{ij}\)

计算结果

（策略\事件）	E₁ = 0	E₂ = 10	E₃ = 20	E₄ = 30	E₅ = 40	EUV（t=2）
事件几率（p_j）	0.1	0.2	0.4	0.2	0.1
S₁ = 0	0.03	0.03	0.03	0.03	0.03	0.03
S₂ = 10	0.02	0.14	0.14	0.14	0.14	0.128
S₃ = 20	0.01	0.11	0.34	0.34	0.34	0.261
S₄= 30	0.0	0.09	0.29	0.63	0.63	0.323
S₅ = 40	0.0	0.06	0.25	0.56	1.0	0.324 \(\longleftarrow\) max

根据 EUV决策准则有

max (0.03, 0.128 , 0.261, 0.323, 0.324) = 0.324

对应的决策策略为 S₅，为决策者选择的策略。

计算代码

/**
 * 效用曲线拟合(EUV)
 * @param matrix
 * @param row
 * @param col
 */
private static void EUV(double[][] matrix, double a, int row, int col){
    //先求出收益矩阵中的最大值与最小值
    double min = matrix[1][0];
    double max = matrix[1][0];
    for (int i = 2; i < row; i++) {
        for (int j = 0; j < col; j++) {
            if(matrix[i][j] > max){
                max = matrix[i][j];
            }
            if(matrix[i][j] < min){
                min = matrix[i][j];
            }
        }
    }
    System.out.println("min="+min+"max="+max);
    //而后求出效用值矩阵
    /*计算方法
           小于最小值(a) => 0
           大于最大值(b) => 1
           介于之间=> (x-a/b-a)^t,其中t为效用曲线系数
         */
    double[][] avail = new double[row+1][col];
        for (int i = 1; i <= row; i++) {
            for (int j = 0; j < col; j++) {
                avail[0][j] = matrix[0][j]; //将天然状态几率复制到第一行中
                if(matrix[i][j] <= min){
                    avail[i][j] = 0.0;
                }else if(matrix[i][j] >= max){
                    avail[i][j] = 1.0;
                }else {
                    double pow = Math.pow((matrix[i][j] - min) / (max - min), t);
                    avail[i][j] = new BigDecimal(pow).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
                }
            }
        }

    for (int i = 0; i < row; i++) {
        System.out.println(Arrays.toString(avail[i]));
    }

    //再求指望效用值
     double[] maxMar = new double[row+1];
        double availMax = 0.0; //效用指望最大值
        int maxIndex = 0;
        double temp = 0.0;
        double chance = 0.0;
        for (int i = 1; i <= row; i++) {
            for (int j = 0; j < col; j++) {
                chance =  avail[0][j]; //天然几率
                temp = (j != 0) ? (temp + avail[i][j]*chance) : (avail[i][j]*chance);
            }
            double value =new BigDecimal(temp).setScale(3, BigDecimal.ROUND_HALF_UP).doubleValue();
            maxMar[i] = value;
            if(i == 1){
                availMax = value;
                maxIndex = 1;
            } else if(value > availMax){
                availMax = value;
                maxIndex = i;
            }
        }
    System.out.println(Arrays.toString(maxMar));
    System.out.println(availMax+"--"+maxIndex);

}

总结

至此，决策模型模块的全部算法模型都分析，创建并实现完成。

参考

运筹学（第4版）本科版