यादृच्छिक संख्या के बीज के लिए संभावित स्रोत

Question

दो अंक - पहला, उदाहरण फोरट्रान में है, लेकिन मुझे लगता है कि इसे किसी भी भाषा के लिए रखना चाहिए; दूसरा, यादृच्छिक संख्या जनरेटर में निर्मित वास्तव में यादृच्छिक नहीं हैं और अन्य जनरेटर मौजूद हैं, लेकिन हम जो भी कर रहे हैं उसके लिए हम उनका उपयोग करने में रूचि नहीं रखते हैं।

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

हालांकि, बहु-कोर मशीन पर एमपीआई के साथ समानांतर में चलते समय, हमारे लिए सिस्टम घड़ी दृष्टिकोण उसी प्रकार की समस्याएं उत्पन्न करता है। जबकि अनुक्रम रन से चलने के लिए बदल गए, सभी प्रोसेसर को एक ही सिस्टम घड़ी मिली और इस प्रकार एक ही यादृच्छिक बीज और एक ही अनुक्रम मिला।

PROGRAM clock_test 
    IMPLICIT NONE 
    INCLUDE "mpif.h" 
    INTEGER :: ierr, rank, clock, i, n, method 
    INTEGER, DIMENSION(:), ALLOCATABLE :: seed 
    REAL(KIND=8) :: random 
    INTEGER, PARAMETER :: OLD_METHOD = 0, & 
         NEW_METHOD = 1 

    CALL MPI_INIT(ierr) 

    CALL MPI_COMM_RANK(MPI_COMM_WORLD, rank, ierr) 

    CALL RANDOM_SEED(SIZE=n) 
    ALLOCATE(seed(n)) 

    DO method = 0, 1 
     SELECT CASE (method) 
     CASE (OLD_METHOD) 
     CALL SYSTEM_CLOCK(COUNT=clock) 
     seed = clock + 37 * (/ (i - 1, i = 1, n) /) 
     CALL RANDOM_SEED(put=seed) 
     CALL RANDOM_NUMBER(random) 

     WRITE(*,*) "OLD Rank, dev = ", rank, random 
     CASE (NEW_METHOD) 
     OPEN(89,FILE='/dev/urandom',ACCESS='stream',FORM='UNFORMATTED') 
     READ(89) seed 
     CLOSE(89) 
     CALL RANDOM_SEED(put=seed) 
     CALL RANDOM_NUMBER(random) 

     WRITE(*,*) "NEW Rank, dev = ", rank, random 
     END SELECT 
     CALL MPI_BARRIER(MPI_COMM_WORLD, ierr) 
    END DO 

    CALL MPI_FINALIZE(ierr) 
END PROGRAM clock_test 

कौन सा जब 2 कोर के साथ मेरी कार्य केंद्र पर चलाने के लिए, देता है::

तो निम्न उदाहरण कोड पर विचार

OLD Rank, dev =   0 0.330676306089146  
OLD Rank, dev =   1 0.330676306089146  
NEW Rank, dev =   0 0.531503215980609  
NEW Rank, dev =   1 0.747413828750221  

तो, हम /dev/urandom से बीज को पढ़ कर घड़ी मुद्दे पर विजय बजाय। इस तरह प्रत्येक कोर को अपना खुद का यादृच्छिक नंबर मिलता है।

अन्य बीज दृष्टिकोण क्या हैं जो बहु-कोर, एमपीआई सिस्टम में काम करेंगे और फिर भी प्रत्येक कोर पर दौड़ने के लिए अद्वितीय होंगे?

Answer 1

यदि आप Katzgrabber द्वारा Random Numbers In Scientific Computing: An Introduction में एक नज़र डालें (जो तकनीकी कंप्यूटिंग के लिए पीआरएनजी का उपयोग करने के लिए इंस और आउट की उत्कृष्ट, स्पष्ट चर्चा है), समानांतर में वे समय के एक हैश फ़ंक्शन और पीआईडी ​​उत्पन्न करने का सुझाव देते हैं । उनके खंड 7.1 से:

long seedgen(void) { 
    long s, seed, pid; 

    pid = getpid(); 
    s = time (&seconds); /* get CPU seconds since 01/01/1970 */ 

    seed = abs(((s*181)*((pid-83)*359))%104729); 
    return seed; 
} 

निश्चित रूप से

, फोरट्रान में इस

function seedgen(pid) 
    use iso_fortran_env 
    implicit none 
    integer(kind=int64) :: seedgen 
    integer, intent(IN) :: pid 
    integer :: s 

    call system_clock(s) 
    seedgen = abs(mod((s*181)*((pid-83)*359), 104729)) 
end function seedgen 

की तरह कुछ यह भी कभी कभी बल्कि seedgen के भीतर से यह बुला से समय में पारित करने के लिए, सक्षम होने के लिए आसान है हो सकता है, ताकि जब आप परीक्षण कर रहे हों तो आप इसे निश्चित मान दे सकते हैं जो तब पुन: उत्पन्न करने योग्य (== टेस्टेबल) अनुक्रम उत्पन्न करते हैं।

Answer 2

सिस्टम समय आमतौर पर एक पूर्णांक प्रकार में (या कम से कम आसानी से परिवर्तित) में लौटाया जाता है: बस प्रक्रिया के रैंक को मूल्य में जोड़ें और यादृच्छिक संख्या जनरेटर को बीज के लिए उपयोग करें।