Wie fügt man zuverlässig große Exponentialterme ohne Überlauffehler hinzu?

24

Ein sehr verbreitetes Problem in der Markov-Kette von Monte Carlo ist die Berechnung von Wahrscheinlichkeiten, die sich aus großen Exponentialausdrücken zusammensetzen.

$e^{a_1} + e^{a_2} + ...$

wobei die Komponenten $a$ Dose von sehr klein bis sehr groß reichen. Mein Ansatz war es, den größten exponentiellen Term so dass: $K := \max_{i}(a_{i})$

a^{'} = K + l o g (e^{a_{1} - K} + e^{a_{2} - K} + . . .)

$a' =K + log\left( e^{a_1 - K} + e^{a_2 - K } + ... \right)$

e^{a^{'}} \equiv e^{a_{1}} + e^{a_{2}} + . . .

$e^{a'} \equiv e^{a_1} + e^{a_2} + ...$

Dieser Ansatz ist sinnvoll, wenn alle Elemente von $a$ groß sind, aber keine so gute Idee, wenn sie nicht groß sind. Natürlich tragen die kleineren Elemente sowieso nicht zur Gleitkommasumme bei, aber ich bin mir nicht sicher, wie ich mit ihnen zuverlässig umgehen soll. In R-Code sieht mein Ansatz folgendermaßen aus:

if ( max(abs(a)) > max(a) )
  K <-  min(a)
else
  K <- max(a)
ans <- log(sum(exp(a-K))) + K

Es scheint ein weit verbreitetes Problem zu sein, dass es eine Standardlösung geben sollte, aber ich bin mir nicht sicher, was es ist. Vielen Dank für alle Vorschläge.

monte-carlo floating-point statistics

— cboettig
quelle

1

Das ist eine Sache. Google für 'logsumexp'.

15

Es gibt eine einfache Lösung mit nur zwei Durchgängen durch die Daten:

Berechne zuerst

K := max_{i} a_{i},

$K := \max_i\; a_i,$

die besagt, dass, wenn es Begriffe, dann $n$

\sum_{i} e^{a_{i}} \leq n e^{K} .

$\sum_i e^{a_i} \le n e^K.$

Da Sie vermutlich annähernd so groß wie , sollten Sie sich keine Gedanken über ein Überlaufen bei der Berechnung von mit doppelter Genauigkeit machen. $n$ $10^{20}$

τ := \sum_{i} e^{a_{i} - K} \leq n

$\tau := \sum_i e^{a_i-K} \le n$

Berechne also und dann ist deine Lösung . $\tau$ $e^K \tau$

— Jack Poulson
quelle

a_{i}

$a_i$

Ah, ich sehe jetzt, worauf du hinaus willst. Sie müssen sich eigentlich keine Gedanken über Unterlauf machen, da das Hinzufügen von außergewöhnlich kleinen Ergebnissen zu Ihrer Lösung dies nicht ändern sollte. Wenn es eine außergewöhnlich große Anzahl von ihnen gab, sollten Sie zuerst die kleinen Werte summieren.

— Jack Poulson

An den Abwähler: Würde es Ihnen etwas ausmachen, mich wissen zu lassen, was mit meiner Antwort nicht stimmt?

— Jack Poulson

e^{a_{i} - K} \approx 0

$e^{a_i - K} \approx 0$

scicomp.stackexchange.com/q/24624/988

— becko

10

Um die Genauigkeit beim Addieren von Doppelwerten zu erhalten, müssen Sie Kahan Summation verwenden . Dies ist die Software, die einem Carry-Register entspricht.

$e^{709.783}$ doubleMax - sumSoFar < valueToAddexponent > 709.783

$\mathit{value}\times2^\mathit{shift}$

#!/usr/bin/env python
from math import exp, log, ceil

doubleMAX = (1.0 + (1.0 - (2 ** -52))) * (2 ** (2 ** 10 - 1))

def KahanSumExp(expvalues):
  expvalues.sort() # gives precision improvement in certain cases 
  shift = 0 
  esum = 0.0 
  carry = 0.0 
  for exponent in expvalues:
    if exponent - shift * log(2) > 709.783:
      n = ceil((exponent - shift * log(2) - 709.783)/log(2))
      shift += n
      carry /= 2*n
      esum /= 2*n
    elif exponent - shift * log(2) < -708.396:
      n = floor((exponent - shift * log(2) - -708.396)/log(2))
      shift += n
      carry *= 2*n
      esum *= 2*n
    exponent -= shift * log(2)
    value = exp(exponent) - carry 
    if doubleMAX - esum < value:
      shift += 1
      esum /= 2
      value /= 2
    tmp = esum + value 
    carry = (tmp - esum) - value 
    esum = tmp
  return esum, shift

values = [10, 37, 34, 0.1, 0.0004, 34, 37.1, 37.2, 36.9, 709, 710, 711]
value, shift = KahanSumExp(values)
print "{0} x 2^{1}".format(value, shift)

— Gareth A. Lloyd
quelle

Die Kahan-Summation ist nur eine von mehreren Methoden der "kompensierten Summation". Wenn Kahan aus irgendeinem Grund nicht richtig funktioniert, gibt es eine Reihe anderer Methoden, um Terme unterschiedlicher Größen und entgegengesetzter Vorzeichen richtig zu addieren.

— JM,

@JM Könnten Sie mir die Namen dieser anderen Methoden mitteilen, ich wäre sehr daran interessiert, sie einzulesen. Vielen Dank.

— Gareth A. Lloyd

1

Ihr Ansatz ist solide.

$K$ $K$

— John D. Cook
quelle

0

Es gibt ein R-Paket, das eine schnelle und effiziente Implementierung des "Log-Sum-Exp-Tricks" liefert.

http://www.inside-r.org/packages/cran/matrixStats/docs/logSumExp

Die logSumExp-Funktion akzeptiert einen numerischen Vektor lX und gibt log (sum (exp (lX))) aus, wobei Unterlauf- und Überlaufprobleme mit der von Ihnen beschriebenen Methode vermieden werden.

— Kantai
quelle