पाइथन बनाम जूलिया ऑटोकैरेलेशन

Question

मैं जूलिया का उपयोग करके ऑटोक्रेलेशन करने की कोशिश कर रहा हूं और इसकी तुलना पायथन के परिणाम से कर रहा हूं। वे अलग-अलग परिणाम कैसे देते हैं?

जूलिया कोड

using StatsBase

t = range(0, stop=10, length=10)
test_data = sin.(exp.(t.^2))

acf = StatsBase.autocor(test_data)

देता है

10-element Array{Float64,1}:
  1.0                   
  0.13254954979179642   
 -0.2030283419321465    
  0.00029587850872956104
 -0.06629381497277881   
  0.031309038331589614  
 -0.16633393452504994   
 -0.08482388975165675   
  0.0006905628640697538 
 -0.1443650483145533

पायथन कोड

from statsmodels.tsa.stattools import acf
import numpy as np

t = np.linspace(0,10,10)
test_data = np.sin(np.exp(t**2))

acf_result = acf(test_data)

देता है

array([ 1.        ,  0.14589844, -0.10412699,  0.07817509, -0.12916543,
       -0.03469143, -0.129255  , -0.15982435, -0.02067688, -0.14633346])

Comments

दोनों मामलों में परीक्षण डेटा मुद्रित करें

— मैड फिजिसिस्ट

Answer 1

यह इसलिए है क्योंकि आपका test_dataअलग है:

अजगर:

array([ 0.84147098, -0.29102733,  0.96323736,  0.75441021, -0.37291918,
        0.85600145,  0.89676529, -0.34006519, -0.75811102, -0.99910501])

जूलिया:

[0.8414709848078965, -0.2910273263243299, 0.963237364649543, 0.7544102058854344,
 -0.3729191776326039, 0.8560014512776061, 0.9841238290665676, 0.1665709194875013,
 -0.7581110212957692, -0.9991050130774393]

ऐसा इसलिए होता है क्योंकि आप sinभारी संख्या में ले रहे हैं । उदाहरण के लिए, t10 में अंतिम संख्या के साथ , exp(10^2)~ 2.7 * 10 ^ 43 है। इस पैमाने पर, फ्लोटिंग पॉइंट गलतियाँ लगभग 3 * 10 ^ 9 हैं। तो अगर पायथन और जूलिया के लिए भी कम से कम महत्वपूर्ण बिट अलग है, तो sinमान बंद हो जाएगा।

वास्तव में, हम प्रारंभिक सरणी के अंतर्निहित द्विआधारी मूल्यों का निरीक्षण कर सकते हैं t। उदाहरण के लिए, वे तीसरे अंतिम मूल्य में भिन्न हैं:

जूलिया:

julia> reinterpret(Int, range(0, stop=10, length=10)[end-2])
4620443017702830535

अजगर:

>>> import struct
>>> s = struct.pack('>d', np.linspace(0,10,10)[-3])
>>> struct.unpack('>q', s)[0]
4620443017702830536

हम वास्तव में देख सकते हैं कि वे एक मशीन एप्सिलॉन से असहमत हैं। और अगर हम sinपायथन द्वारा प्राप्त मूल्य के जूलिया का उपयोग करते हैं :

julia> sin(exp(reinterpret(Float64, 4620443017702830536)^2))
-0.3400651855865199

हमें वही मूल्य मिलता है जो पायथन करता है।

Answer 2

बस उत्तर पर थोड़ा विस्तार करना (एक उत्तर के रूप में जोड़ना क्योंकि यह एक टिप्पणी के लिए बहुत लंबा है)। जूलिया में आप निम्नलिखित हैं:

julia> t = collect(range(0, stop=10, length=10))
10-element Array{Float64,1}:
  0.0               
  1.1111111111111112
  2.2222222222222223
  3.3333333333333335
  4.444444444444445 
  5.555555555555555 
  6.666666666666667 
  7.777777777777778 
  8.88888888888889  
 10.0               

julia> t .- [10*i / 9 for i in 0:9]
10-element Array{Float64,1}:
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0

पायथन में रहते हुए:

>>> t = np.linspace(0,10,10)
>>> t - [10*i/9 for i in range(10)]
array([0.0000000e+00, 0.0000000e+00, 0.0000000e+00, 0.0000000e+00,
       0.0000000e+00, 0.0000000e+00, 0.0000000e+00, 8.8817842e-16,
       0.0000000e+00, 0.0000000e+00])

और आप देखते हैं कि अजगर में 8 वें नंबर की एक गलत अनुमान होता है 70/9, जबकि इस मामले में जूलिया में आप के निकटतम अनुमानों के अनुक्रम मिल 10*i/9का उपयोग करते हुए Float64।

तो ऐसा लगता है कि क्योंकि मूल अनुक्रम अलग आप बाकी है जो @Jakob निसान टिप्पणी की थी निम्नानुसार होगा।

हालाँकि चीजें इतनी सरल नहीं हैं। expजूलिया और पायथन में फ़ंक्शन के रूप में वे जो कुछ भी पैदा करते हैं, उसमें थोड़ा अंतर होता है। अजगर देखें:

>>> from math import exp
>>> from mpmath import mp
>>> mp.dps = 1000
>>> float(mp.exp((20/3)**2) - exp((20/3)**2))
-1957.096392544307

जबकि जूलिया में:

julia> setprecision(1000)
1000

julia> Float64(exp(big((20/3)^2)) - exp((20/3)^2))
2138.903607455693

julia> Float64(exp(big((20/3)^2)) - nextfloat(exp((20/3)^2)))
-1957.096392544307

(आप जांच सकते हैं कि जूलिया और पायथन दोनों में (20/3)^2एक ही है Float64)।

तो इस मामले में expपायथन जूलिया की तुलना में थोड़ा अधिक सटीक है। इसलिए यहां तक ​​कि फिक्सिंग t(जो इसके बजाय पायथन में एक समझ का उपयोग करके आसान है linspace) एसीएफ को समान नहीं बनाएगा।

सभी निष्कर्षों में जो @Jakob Nissen ने इतने बड़े मूल्यों के लिए टिप्पणी की है कि परिणाम संख्यात्मक अशुद्धियों से दृढ़ता से प्रभावित होंगे।