具有对数概率Java实现的数值精度

2019年7月20日 207次阅读

有时,当您使用常见数据类型(如双精度数)进行非常小概率的计算时,数值不准确会在多次计算中级联并导致不正确的结果.因此,建议使用
log probabilities,这样可以提高数值稳定性.我已经在Java中实现了日志概率,我的实现工作正常,但它的数值稳定性比使用原始双精度差.我的实施有什么问题？在Java中用小概率执行许多连续计算的准确有效方法是什么？

我无法提供这个问题的完整包含的演示,因为不准确性会在许多计算中级联.但是,这里证明存在问题：this提交到CodeForces竞赛由于数字准确性而失败.运行测试#7并添加调试打印清楚地表明,从1774年开始,数值错误开始级联,直到概率总和降至0(当它应该为1时).用双打the exact same solution passes tests上的简单包装替换我的Prob类.

我实现的乘法概率：

a * b = Math.log(a)Math.log(b)

我的实施补充：

a b = Math.log(a)Math.log(1 Math.exp(Math.log(b) – Math.log(a)))

稳定性问题很可能包含在这两行中,但这是我的整个实现：

class Prob {

        /** Math explained: https://en.wikipedia.org/wiki/Log_probability
         *  Quick start:
         *      - Instantiate probabilities, eg. Prob a = new Prob(0.75)
         *      - add(), multiply() return new objects, can perform on nulls & NaNs.
         *      - get() returns probability as a readable double */

        /** Logarithmized probability. Note: 0% represented by logP NaN. */
        private double logP;

        /** Construct instance with real probability. */
        public Prob(double real) {
            if (real > 0) this.logP = Math.log(real);
            else this.logP = Double.NaN;
        }

        /** Construct instance with already logarithmized value. */
        static boolean dontLogAgain = true;
        public Prob(double logP, boolean anyBooleanHereToChooseThisConstructor) {
            this.logP = logP;
        }

        /** Returns real probability as a double. */
        public double get() {
            return Math.exp(logP);
        }

        @Override
        public String toString() {
            return ""+get();
        }

        /***************** STATIC METHODS BELOW ********************/

        /** Note: returns NaN only when a && b are both NaN/null. */
        public static Prob add(Prob a, Prob b) {
            if (nullOrNaN(a) && nullOrNaN(b)) return new Prob(Double.NaN, dontLogAgain);
            if (nullOrNaN(a)) return copy(b);
            if (nullOrNaN(b)) return copy(a);

            double x = a.logP;
            double y = b.logP;
            double sum = x + Math.log(1 + Math.exp(y - x));
            return new Prob(sum, dontLogAgain);
        }

        /** Note: multiplying by null or NaN produces NaN (repping 0% real prob). */
        public static Prob multiply(Prob a, Prob b) {
            if (nullOrNaN(a) || nullOrNaN(b)) return new Prob(Double.NaN, dontLogAgain);
            return new Prob(a.logP + b.logP, dontLogAgain);
        }

        /** Returns true if p is null or NaN. */
        private static boolean nullOrNaN(Prob p) {
            return (p == null || Double.isNaN(p.logP));
        }

        /** Returns a new instance with the same value as original. */
        private static Prob copy(Prob original) {
            return new Prob(original.logP, dontLogAgain);
        }
    }

最佳答案 问题是由Math.exp(z)在此行中使用的方式引起的：

a b = Math.log(a)Math.log(1 Math.exp(Math.log(b) – Math.log(a)))

当z达到极值时,对于Math.exp(z)的输出,double的数值精度是不够的.这会导致我们丢失信息,产生不准确的结果,然后这些结果会在多次计算中级联.

当z> = 710时,Math.exp(z)=无穷大

当z <= -746时,则Math.exp(z)= 0 在原始代码中,我用y – x调用Math.exp并随意选择哪个是x,这就是原因.让我们选择y和x,它基于哪个更大,因此z是负的而不是正的.我们得到溢出的点是在负面(746而不是710),更重要的是,当我们溢出时,我们最终会在0而不是无穷大.这是我们想要的概率很低的.

double x = Math.max(a.logP, b.logP);
double y = Math.min(a.logP, b.logP);
double sum = x + Math.log(1 + Math.exp(y - x));
点赞