अतिप्रवाह त्रुटियों के बिना मज़बूती से बड़े घातीय शब्दों को कैसे जोड़ा जाए?

Question

मार्कोव चेन मोंटे कार्लो में एक बहुत ही आम समस्या में कंप्यूटिंग संभावनाएं शामिल हैं जो बड़े घातीय शब्दों का योग हैं,

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

जहां के घटकों $a$ बहुत बड़ी करने के लिए बहुत छोटे से लेकर कर सकते हैं। मेरा दृष्टिकोण सबसे बड़ा घातीय शब्द करने के लिए किया गया है:$K := \max_{i}(a_{i})$

ई एक ' ≡ ई एक 1 + ई एक 2 + । ।

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

यह दृष्टिकोण उचित है अगर के सभी तत्वों को $a$ करता है, तो वे नहीं हैं बड़े हैं, लेकिन नहीं एक अच्छा विचार। बेशक, छोटे तत्व वैसे भी फ्लोटिंग-पॉइंट योग में योगदान नहीं दे रहे हैं, लेकिन मुझे यकीन नहीं है कि उनके साथ मज़बूती से कैसे निपटें। R कोड में, मेरा दृष्टिकोण ऐसा दिखता है:

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

यह एक सामान्य पर्याप्त समस्या है कि एक मानक समाधान होना चाहिए, लेकिन मुझे यकीन नहीं है कि यह क्या है। किसी भी सुझाव के लिए धन्यवाद।

Comments

यह एक बात है। Google 'logumexp' के लिए।

Answer 1

डेटा के माध्यम से केवल दो पास के साथ एक सीधा समाधान है:

पहली गणना

$$K := \max_i\; a_i,$$

जो आपको बताता है कि, यदि शब्द हैं, तो Σ मैं ई एक मैं ≤ n ई कश्मीर$n$

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

चूँकि आपके पास संभवतः आसपास कहीं भी नहीं है , इसलिए आपको डबल परिशुद्धता में की गणना में अतिप्रवाह के बारे में कोई चिंता नहीं होनी चाहिए। ।$n$$10^{20}$

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

इस प्रकार, कंप्यूट और फिर आपका समाधान ।$\tau$$e^K \tau$

Comments

स्पष्ट संकेतन के लिए धन्यवाद - लेकिन मेरा मानना ​​है कि यह अनिवार्य रूप से है जो मैंने प्रस्तावित किया है (?) अगर मुझे कुछ छोटे होने पर अंडरफ्लो त्रुटियों से बचने की आवश्यकता है , तो मुझे लगता है कि मुझे @gareth द्वारा प्रस्तावित काहन योग दृष्टिकोण की आवश्यकता है ? $a_i$

— cboettig

आह, अब मैं देख रहा हूँ कि तुम क्या कर रहे थे। आपको वास्तव में अंडरफ्लो के बारे में चिंता करने की ज़रूरत नहीं है, क्योंकि आपके समाधान में असाधारण छोटे परिणामों को जोड़ने से इसे बदलना नहीं चाहिए। यदि उनमें से एक बड़ी संख्या थी, तो आपको पहले छोटे मूल्यों का योग करना चाहिए।

— जैक पॉल्सन

नीच व्यक्ति के लिए: क्या आप मुझे यह बताना चाहेंगे कि मेरे जवाब में क्या गलत है?

— जैक पॉल्सन

क्या हुआ अगर आपके पास कई बहुत छोटे मामले? ऐसा हो सकता है कि इनके लिए । यदि इस तरह की कई शर्तें हैं, तो आपको बड़ी त्रुटि होगी। $e^{a_i - K} \approx 0$

— बेकाओ

scicomp.stackexchange.com/q/24624/988

— becko

Answer 2

जब आप एक साथ युगल जोड़ते हैं तो सटीकता रखने के लिए आपको काहन सारांश का उपयोग करने की आवश्यकता होती है , यह एक कैरी रजिस्टर रखने के बराबर सॉफ्टवेयर है।

यह अधिकांश मूल्यों के लिए ठीक है, लेकिन यदि आप अतिप्रवाह कर रहे हैं तो आप IEEE 754 डबल-परिशुद्धता की सीमा मार रहे हैं जो कि बारे में होगा । इस बिंदु पर आपको एक नए प्रतिनिधित्व की आवश्यकता है। आप इसके अलावा समय के साथ एक अतिप्रवाह का पता लगा सकते हैं और मूल्यांकन करने के लिए बड़े से बड़े भागीदारों का भी पता लगा सकते हैं । इस बिंदु पर आप प्रतिपादक को शिफ्ट करने और इस बदलाव पर नज़र रखते हुए एक डबल की व्याख्या को संशोधित कर सकते हैं।$e^{709.783}$doubleMax - sumSoFar < valueToAddexponent > 709.783

अधिकांश भाग के लिए यह आपके घातांक ऑफसेट दृष्टिकोण के समान है, लेकिन इस संस्करण को इसे बेस 2 में रखा गया है और सबसे बड़े घातांक को खोजने के लिए प्रारंभिक खोज की आवश्यकता नहीं है। इसलिए ।$\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)

Comments

कहन सम्‍मिलन लेकिन "क्षतिपूर्ति सम्‍मिलन" विधियों के परिवार में से एक है। यदि किसी कारण से काहान काफी सही काम नहीं करता है, तो अलग-अलग परिमाण और विपरीत संकेतों को ठीक से जोड़ने के लिए कई अन्य तरीके हैं।

— JM

@ जेएम आप मुझे उन अन्य तरीकों के नाम प्रदान कर सकते हैं, मैं उन्हें पढ़ने के लिए काफी इंट्रस्ट करूंगा। धन्यवाद।

— गैरेथ ए लॉयड

Answer 3

आपका दृष्टिकोण ठोस है।

$K$$K$

Answer 4

एक आर पैकेज है जो "लॉग-सम-एक्सप-ट्रिक" के तेज और कुशल कार्यान्वयन की आपूर्ति करता है

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

LogSumExp फ़ंक्शन एक संख्यात्मक वेक्टर LX को स्वीकार करता है और आपके द्वारा बताई गई विधि का उपयोग करके अंडरफ़्लो और अतिप्रवाह समस्याओं से बचने के दौरान लॉग (योग (एक्सएक्स)) को आउटपुट करता है।