Come aggiungere in modo affidabile termini esponenziali di grandi dimensioni senza errori di overflow?

24

Un problema molto comune nella catena di Markov Monte Carlo riguarda le probabilità di calcolo che sono la somma di termini esponenziali di grandi dimensioni,

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

dove i componenti di $a$ lattina possono variare da molto piccoli a molto grandi. Il mio approccio è stato quello di fattorizzare il termine esponenziale più grande modo che: $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} + ...$

Questo approccio è ragionevole se tutti gli elementi di $a$ sono grandi, ma non è una buona idea se non lo sono. Naturalmente, gli elementi più piccoli non contribuiscono comunque alla somma in virgola mobile, ma non sono sicuro di come gestirli in modo affidabile. Nel codice R, il mio approccio è simile a:

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

Sembra un problema abbastanza comune che ci dovrebbe essere una soluzione standard, ma non sono sicuro di cosa si tratti. Grazie per eventuali suggerimenti.

monte-carlo floating-point statistics

— cboettig
fonte

1

Questa è una cosa Google per "logsumexp".

15

Esiste una soluzione semplice con solo due passaggi tra i dati:

Primo calcolo

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

$K := \max_i\; a_i,$

che ti dice che, se ci sono termini, allora $n$

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

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

Dato che presumibilmente non hai nessun punto vicino pari a , non dovresti preoccuparti di traboccare nel calcolo di $n$ $10^{20}$

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

$\tau := \sum_i e^{a_i-K} \le n$ in doppia precisione.

Quindi, calcola e quindi la tua soluzione è . $\tau$ $e^K \tau$

— Jack Poulson
fonte

Grazie per la chiara notazione - ma credo che questo sia essenzialmente quello che ho proposto (?) Se devo evitare errori di underflow quando alcuni

sono piccoli, mi accorgo di aver bisogno dell'approccio di somma Kahan proposto da @gareth ?

a_{i}

$a_i$

— cboettig,

Ah, ora vedo a cosa stavi arrivando. In realtà non devi preoccuparti di underflow, poiché l'aggiunta di risultati eccezionalmente piccoli alla tua soluzione non dovrebbe modificarlo. Se ce n'era un numero eccezionalmente elevato, dovresti prima sommare i valori piccoli.

— Jack Poulson il

Al downvoter: ti dispiacerebbe farmi sapere cosa c'è che non va nella mia risposta?

— Jack Poulson,

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

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

scicomp.stackexchange.com/q/24624/988

— becko

10

Per mantenere la precisione mentre si sommano i doppi, è necessario utilizzare Kahan Summation , questo è il software equivalente ad avere un registro di trasporto.

$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
fonte

La somma di Kahan non fa che parte di una famiglia di metodi di "somma sommatoria compensata". Se per qualche motivo Kahan non funziona abbastanza bene, ci sono molti altri metodi per sommare correttamente termini di grandezza variabile e segni opposti.

— JM

@JM potresti fornirmi i nomi di quegli altri metodi, sarei piuttosto interessato a leggerli. Grazie.

— Gareth A. Lloyd,

1

Il tuo approccio è solido.

$K$ $K$

— John D. Cook
fonte

0

Esiste un pacchetto R che fornisce un'implementazione rapida ed efficiente del "trucco log-sum-exp"

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

La funzione logSumExp accetta un vettore numerico lX e genera un log (sum (exp (lX))) evitando problemi di underflow e overflow utilizzando il metodo descritto.

— kantai
fonte