2014-12-20 7 views
12

मेरे पास एक ऐसी स्क्रिप्ट है जो कोई यादृच्छिकरण नहीं करती है जो मुझे चलाने पर अलग-अलग उत्तर देती है। मैं उम्मीद करता हूं कि जब भी मैं स्क्रिप्ट चलाता हूं, तो जवाब समान होता है। समस्या केवल कुछ (बीमार वातानुकूलित) इनपुट डेटा के लिए होती है।निर्धारित पाइथन लिपि गैर-निर्धारक तरीके से व्यवहार करता है

स्निपेट एक रैखिक प्रणाली के लिए एक विशिष्ट प्रकार के नियंत्रक की गणना करने के लिए एक एल्गोरिदम से आता है, और इसमें ज्यादातर रैखिक बीजगणित (मैट्रिक्स इनवर्जन, रिकिका समीकरण, eigenvalues) शामिल होते हैं।

जाहिर है, यह मेरे लिए एक प्रमुख चिंता है, मैं अब मुझे सही परिणाम देने के लिए मेरे कोड पर भरोसा नहीं कर सकते हैं। मुझे पता है कि खराब स्थिति वाले डेटा के लिए परिणाम गलत हो सकता है, लेकिन मैं लगातार गलत की उम्मीद करता हूं। उत्तर मेरी विंडोज मशीन पर हमेशा क्यों नहीं है? लिनक्स & विंडोज मशीन एक ही परिणाम क्यों नहीं देती?

मैं Python 2.7.9 (default, Dec 10 2014, 12:24:55) [MSC v.1500 32 bit (Intel)] on win 32 उपयोग कर रहा हूँ, Numpy संस्करण 1.8.2 और SciPy 0.14.0 साथ। (विंडोज 8, 64 बिट)।

कोड नीचे है। मैंने दो लिनक्स मशीनों पर कोड चलाने का भी प्रयास किया है, और वहां स्क्रिप्ट हमेशा एक ही जवाब देती है (लेकिन मशीनों ने अलग-अलग जवाब दिए)। एक पाइथन 2.7.8 चला रहा था, Numpy 1.8.2 और Scipy 0.14.0 के साथ। दूसरा पाइथन 2.7.3 चला रहा था जिसमें नम्पी 1.6.1 और सिसिसी 0.12.0 था।

मैं रिकिकती समीकरण को तीन बार हल करता हूं, और फिर उत्तर प्रिंट करता हूं। मैं हर बार एक ही जवाब की उम्मीद करता हूं, इसके बजाय मुझे अनुक्रम '1.75305103767e-09 मिलता है; 3.25501787302e-07; 3.25501787302e-07 '।

import numpy as np 
    import scipy.linalg 

    matrix = np.matrix 

    A = matrix([[ 0.00000000e+00, 2.96156260e+01, 0.00000000e+00, 
         -1.00000000e+00], 
        [ -2.96156260e+01, -6.77626358e-21, 1.00000000e+00, 
         -2.11758237e-22], 
        [ 0.00000000e+00, 0.00000000e+00, 2.06196064e+00, 
         5.59422224e+01], 
        [ 0.00000000e+00, 0.00000000e+00, 2.12407340e+01, 
         -2.06195974e+00]]) 
    B = matrix([[  0.  ,  0.  ,  0.  ], 
        [  0.  ,  0.  ,  0.  ], 
        [ -342.35401351, -14204.86532216,  31.22469724], 
        [ 1390.44997337, 342.33745324, -126.81720597]]) 
    Q = matrix([[ 5.00000001, 0.  , 0.  , 0.  ], 
        [ 0.  , 5.00000001, 0.  , 0.  ], 
        [ 0.  , 0.  , 0.  , 0.  ], 
        [ 0.  , 0.  , 0.  , 0.  ]]) 
    R = matrix([[ -3.75632852e+04, -0.00000000e+00, 0.00000000e+00], 
        [ -0.00000000e+00, -3.75632852e+04, 0.00000000e+00], 
        [ 0.00000000e+00, 0.00000000e+00, 4.00000000e+00]]) 

    counter = 0 
    while counter < 3: 
      counter +=1 

      X = scipy.linalg.solve_continuous_are(A, B, Q, R) 
      print(-3449.15531628 - X[0,0]) 

मेरे numpy config नीचे के रूप में print np.show_config()

 
lapack_opt_info: 
    libraries = ['mkl_blas95', 'mkl_lapack95', 'mkl_intel_c', 'mkl_intel_thread', 'mkl_core', 'libiomp5md', 'mkl_blas95', 'mkl_lapack95', 'mkl_intel_c', 'mkl_intel_thread', 'mkl_core', 'libiomp5md'] 
    library_dirs = ['c:/Program Files (x86)/Intel/Composer XE 2013 SP1/mkl/lib/ia32', 'C:/Program Files (x86)/Intel/Composer XE 2013 SP1/compiler/lib/ia32'] 
    define_macros = [('SCIPY_MKL_H', None)] 
    include_dirs = ['c:/Program Files (x86)/Intel/Composer XE 2013 SP1/mkl/include'] 
blas_opt_info: 
    libraries = ['mkl_blas95', 'mkl_lapack95', 'mkl_intel_c', 'mkl_intel_thread', 'mkl_core', 'libiomp5md'] 
    library_dirs = ['c:/Program Files (x86)/Intel/Composer XE 2013 SP1/mkl/lib/ia32', 'C:/Program Files (x86)/Intel/Composer XE 2013 SP1/compiler/lib/ia32'] 
    define_macros = [('SCIPY_MKL_H', None)] 
    include_dirs = ['c:/Program Files (x86)/Intel/Composer XE 2013 SP1/mkl/include'] 
openblas_info: 
    NOT AVAILABLE 
lapack_mkl_info: 
    libraries = ['mkl_blas95', 'mkl_lapack95', 'mkl_intel_c', 'mkl_intel_thread', 'mkl_core', 'libiomp5md', 'mkl_blas95', 'mkl_lapack95', 'mkl_intel_c', 'mkl_intel_thread', 'mkl_core', 'libiomp5md'] 
    library_dirs = ['c:/Program Files (x86)/Intel/Composer XE 2013 SP1/mkl/lib/ia32', 'C:/Program Files (x86)/Intel/Composer XE 2013 SP1/compiler/lib/ia32'] 
    define_macros = [('SCIPY_MKL_H', None)] 
    include_dirs = ['c:/Program Files (x86)/Intel/Composer XE 2013 SP1/mkl/include'] 
blas_mkl_info: 
    libraries = ['mkl_blas95', 'mkl_lapack95', 'mkl_intel_c', 'mkl_intel_thread', 'mkl_core', 'libiomp5md'] 
    library_dirs = ['c:/Program Files (x86)/Intel/Composer XE 2013 SP1/mkl/lib/ia32', 'C:/Program Files (x86)/Intel/Composer XE 2013 SP1/compiler/lib/ia32'] 
    define_macros = [('SCIPY_MKL_H', None)] 
    include_dirs = ['c:/Program Files (x86)/Intel/Composer XE 2013 SP1/mkl/include'] 
mkl_info: 
    libraries = ['mkl_blas95', 'mkl_lapack95', 'mkl_intel_c', 'mkl_intel_thread', 'mkl_core', 'libiomp5md'] 
    library_dirs = ['c:/Program Files (x86)/Intel/Composer XE 2013 SP1/mkl/lib/ia32', 'C:/Program Files (x86)/Intel/Composer XE 2013 SP1/compiler/lib/ia32'] 
    define_macros = [('SCIPY_MKL_H', None)] 
    include_dirs = ['c:/Program Files (x86)/Intel/Composer XE 2013 SP1/mkl/include'] 
None 

+0

क्या आपने जेनरेटर बीज दिया था? http://docs.scipy.org/doc/numpy/reference/generated/numpy.random.seed.html – NPE

+0

मैंने कोड की पहली पंक्ति के रूप में 'np.random.seed (0)' जोड़ा है (इनपुट के बाद), और इससे कोई फर्क नहीं पड़ता। प्रश्न अपडेट करेंगे। – mwmwm

+0

क्षमाप्रार्थी, मैं किसी भी तरह से आपके प्रश्न को गलत तरीके से पढ़ता हूं कि यह बताता है कि कोड * करता है * यादृच्छिकरण का उपयोग करता है। उफ़। – NPE

उत्तर

7

सामान्य में, विंडोज पर linalg पुस्तकालयों मशीन परिशुद्धता स्तर पर विभिन्न रन पर अलग अलग जवाब देने के (नीचे सवाल ट्रिम करने के लिए संपादन) है । मैंने कभी स्पष्टीकरण के बारे में नहीं सुना कि यह केवल या मुख्य रूप से विंडोज पर क्यों होता है।

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

मैं पर देखा और scipy मेलिंग सूची के लिए विंडोज पर इस के लिए कई उदाहरण पोस्ट किया है, मैं ज्यादातर एटलस BLAS/LAPACK के साथ आधिकारिक 32 बिट बाइनरी उपयोग कर रहा था।

एकमात्र समाधान यह है कि आपकी गणना का परिणाम फ़्लोटिंग पॉइंट परिशुद्धता के मुद्दों और संख्यात्मक शोर पर निर्भर न हो, उदाहरण के लिए मैट्रिक्स उलटा नियमित करें, सामान्यीकृत उलटा, पिनव, रिपैमेटेराइज़ या इसी तरह का उपयोग करें।

+3

संख्यात्मक शोर का हिस्सा स्मृति में डेटा संरेखण से आता है, यानी सीपीयू के एसएस आदि के लिए उपयुक्त स्थिति में सीधे झूठ बोलना होता है या नहीं --- दोनों मामले अलग-अलग क्रम में संचालन करते हैं, इसलिए फ्लोटिंग पॉइंट राउंडिंग त्रुटि है विभिन्न। Win32 मानक मेमोरी आवंटक afaik स्मृति की ब्लॉक को वापस करने के लिए जाता है जो औसत लिनक्स आवंटकों की तुलना में कम गठबंधन होते हैं, इसलिए वहाँ और अधिक जिटर है। यदि आपके परिणाम महत्वपूर्ण रूप से निर्भर करते हैं कि एफपी राउंडिंग त्रुटि किस तरह से जाती है, तो आपकी समस्या फॉर्मूलेशन संख्यात्मक रूप से अस्थिर है। –

2

pvcomments to user333700's answer में नोट किया गया, रिककाटी सॉल्वर के पिछले फॉर्मूलेशन थे, हालांकि सैद्धांतिक रूप से सही, संख्यात्मक रूप से स्थिर नहीं थे। यह मुद्दा SciPy के विकास संस्करण पर तय किया गया है और हलकर्ता सामान्यीकृत रिकाटी समीकरणों का भी समर्थन करते हैं।

रिककाटी सॉल्वर अपडेट किए गए हैं और परिणामस्वरूप सॉल्वर संस्करण 0.1 9 और बाद में उपलब्ध होंगे। आप development branch docs here देख सकते हैं।

हैं, प्रश्न में दिए गए उदाहरण का उपयोग मैं

for _ in range(5): 
    x = scipy.linalg.solve_continuous_are(A, B, Q, R) 
    Res = [email protected] + [email protected] + q - [email protected]@ np.linalg.solve(r,b.T)@ x 
    print(Res) 

के साथ पिछले पाश की जगह मैं (विंडोज़ 10, py3.5.2)

[[ 2.32314924e-05 -2.55086270e-05 -7.66709854e-06 -9.01878229e-06] 
[ -2.62447211e-05 2.61182140e-05 8.27328768e-06 1.00345896e-05] 
[ -7.92257197e-06 8.57094892e-06 2.50908488e-06 3.05714639e-06] 
[ -9.51046241e-06 9.80847472e-06 3.13103374e-06 3.60747799e-06]] 
[[ 2.32314924e-05 -2.55086270e-05 -7.66709854e-06 -9.01878229e-06] 
[ -2.62447211e-05 2.61182140e-05 8.27328768e-06 1.00345896e-05] 
[ -7.92257197e-06 8.57094892e-06 2.50908488e-06 3.05714639e-06] 
[ -9.51046241e-06 9.80847472e-06 3.13103374e-06 3.60747799e-06]] 
[[ 2.32314924e-05 -2.55086270e-05 -7.66709854e-06 -9.01878229e-06] 
[ -2.62447211e-05 2.61182140e-05 8.27328768e-06 1.00345896e-05] 
[ -7.92257197e-06 8.57094892e-06 2.50908488e-06 3.05714639e-06] 
[ -9.51046241e-06 9.80847472e-06 3.13103374e-06 3.60747799e-06]] 
[[ 2.32314924e-05 -2.55086270e-05 -7.66709854e-06 -9.01878229e-06] 
[ -2.62447211e-05 2.61182140e-05 8.27328768e-06 1.00345896e-05] 
[ -7.92257197e-06 8.57094892e-06 2.50908488e-06 3.05714639e-06] 
[ -9.51046241e-06 9.80847472e-06 3.13103374e-06 3.60747799e-06]] 
[[ 2.32314924e-05 -2.55086270e-05 -7.66709854e-06 -9.01878229e-06] 
[ -2.62447211e-05 2.61182140e-05 8.27328768e-06 1.00345896e-05] 
[ -7.92257197e-06 8.57094892e-06 2.50908488e-06 3.05714639e-06] 
[ -9.51046241e-06 9.80847472e-06 3.13103374e-06 3.60747799e-06]] 

संदर्भ के लिए मिलता है, समाधान लौटे है

array([[-3449.15531305, 4097.1707738 , 1142.52971904, 1566.51333847], 
     [ 4097.1707738 , -4863.70533241, -1356.66524959, -1860.15980716], 
     [ 1142.52971904, -1356.66524959, -378.32586814, -518.71965102], 
     [ 1566.51333847, -1860.15980716, -518.71965102, -711.21062988]]) 
संबंधित मुद्दे