जवाबों:
np.random.seed(0) यादृच्छिक संख्या का अनुमान लगाता है
>>> numpy.random.seed(0) ; numpy.random.rand(4)
array([ 0.55, 0.72, 0.6 , 0.54])
>>> numpy.random.seed(0) ; numpy.random.rand(4)
array([ 0.55, 0.72, 0.6 , 0.54])बीज रीसेट (हर बार) के साथ, हर बार संख्या का एक ही सेट दिखाई देगा।
यदि यादृच्छिक बीज को रीसेट नहीं किया जाता है, तो हर आह्वान के साथ अलग-अलग संख्याएं दिखाई देती हैं:
>>> numpy.random.rand(4)
array([ 0.42, 0.65, 0.44, 0.89])
>>> numpy.random.rand(4)
array([ 0.96, 0.38, 0.79, 0.53])(छद्म-) यादृच्छिक संख्या एक संख्या (बीज) के साथ शुरू करके काम करती है, इसे एक बड़ी संख्या से गुणा करना, एक ऑफसेट जोड़ना, फिर उस राशि का मोडुलो लेना। परिणामी संख्या को अगले "यादृच्छिक" संख्या उत्पन्न करने के लिए बीज के रूप में उपयोग किया जाता है। जब आप बीज (हर बार) सेट करते हैं, तो यह हर बार एक ही काम करता है, आपको एक ही नंबर देता है।
यदि आप प्रतीत होता है यादृच्छिक संख्या, बीज सेट नहीं है। यदि आपके पास कोड है जो यादृच्छिक संख्याओं का उपयोग करता है जिसे आप डिबग करना चाहते हैं, हालांकि, प्रत्येक रन से पहले बीज को सेट करने में बहुत मदद मिल सकती है ताकि कोड आपके द्वारा चलाने पर हर बार एक ही काम करे।
प्रत्येक रन के लिए सबसे यादृच्छिक संख्या प्राप्त करने के लिए, कॉल करें numpy.random.seed()। यह बीज को एक यादृच्छिक संख्या से /dev/urandomया इसके विंडोज एनालॉग से प्राप्त बीज को सेट करने के लिए सुन्न पैदा करेगा या, यदि उनमें से कोई भी उपलब्ध नहीं है, तो यह घड़ी का उपयोग करेगा।
छद्म यादृच्छिक संख्या उत्पन्न करने के लिए बीज का उपयोग करने के बारे में अधिक जानकारी के लिए, विकिपीडिया देखें ।
numpy.random.seed(None), तो यह "घड़ी से बीज उपलब्ध या अन्यथा होने पर / dev / urandom (या Windows एनालॉग) से डेटा पढ़ने की कोशिश करेगा"।
numpy.random.seed(None)। मैंने उस जानकारी और डॉक्स के लिंक के साथ उत्तर को अपडेट किया।
seedसंगत भी शामिल है।
यदि आप np.random.seed(a_fixed_number)हर बार जब आप numpy के अन्य यादृच्छिक फ़ंक्शन को कॉल करते हैं, तो परिणाम समान होगा:
>>> import numpy as np
>>> np.random.seed(0)
>>> perm = np.random.permutation(10)
>>> print perm
[2 8 4 9 1 6 7 3 0 5]
>>> np.random.seed(0)
>>> print np.random.permutation(10)
[2 8 4 9 1 6 7 3 0 5]
>>> np.random.seed(0)
>>> print np.random.permutation(10)
[2 8 4 9 1 6 7 3 0 5]
>>> np.random.seed(0)
>>> print np.random.permutation(10)
[2 8 4 9 1 6 7 3 0 5]
>>> np.random.seed(0)
>>> print np.random.rand(4)
[0.5488135 0.71518937 0.60276338 0.54488318]
>>> np.random.seed(0)
>>> print np.random.rand(4)
[0.5488135 0.71518937 0.60276338 0.54488318]हालाँकि, यदि आप इसे एक बार कॉल करते हैं और विभिन्न यादृच्छिक कार्यों का उपयोग करते हैं, तो परिणाम अभी भी अलग होंगे:
>>> import numpy as np
>>> np.random.seed(0)
>>> perm = np.random.permutation(10)
>>> print perm
[2 8 4 9 1 6 7 3 0 5]
>>> np.random.seed(0)
>>> print np.random.permutation(10)
[2 8 4 9 1 6 7 3 0 5]
>>> print np.random.permutation(10)
[3 5 1 2 9 8 0 6 7 4]
>>> print np.random.permutation(10)
[2 3 8 4 5 1 0 6 9 7]
>>> print np.random.rand(4)
[0.64817187 0.36824154 0.95715516 0.14035078]
>>> print np.random.rand(4)
[0.87008726 0.47360805 0.80091075 0.52047748]np.randomजब तक बीज नहीं बदला जाता है तब तक सभी बाद की कॉल के लिए यादृच्छिक बीज सेट किया जाता है? हर बार इसे कॉल करने के बाद अनावश्यक रूप से क्रिया करना और भूलना आसान लगता है।
def seed_first(fun, seed=0):| \tdef wrapped(*args, **kwargs):| \t\tnp.random.seed(seed)| \t\treturn fun(*args, **kwargs)| \treturn wrapped, और फिर for m in np.random.__all__:| \tif m != 'seed':| \t\tsetattr(np.random, m, seed_first(getattr(np.random, m)))हालांकि, यह लंबे समय में बहुत ही सूक्ष्म कीड़े और अजीब व्यवहार का कारण बन सकता है। (चार स्थानों के साथ \ t बदलें, और लाइन विराम के साथ ...)
np.random.seed()एक कार्यक्रम की शुरुआत में एक बार कॉल करना हमेशा एक ही परिणाम उत्पन्न करेगा बाद के np.randomकार्यों के लिए कॉल के बाद से एक ही बीज के लिए बाद के कॉल के लिए बीज को बदल देगा। कॉलिंग np.random.seed()के लिए हर कॉल से पहले np.randomकार्यों शायद अवांछित परिणाम देगा।
जैसा कि उल्लेख किया गया है, numpy.random.seed (0) यादृच्छिक बीज को 0 पर सेट करता है, इसलिए यादृच्छिक से आपको मिलने वाला छद्म क्रमांक उसी बिंदु से शुरू होगा। यह कुछ मामलों में डिबगिंग के लिए अच्छा हो सकता है। फिर भी, कुछ पढ़ने के बाद, यह उस पर जाने का गलत तरीका लगता है, अगर आपके पास थ्रेड्स हैं क्योंकि यह थ्रेड सुरक्षित नहीं है।
अंतर- से -खस्ता-यादृच्छिक-और-यादृच्छिक-यादृच्छिक-में-अजगर :
Numpy.random.seed () के लिए, मुख्य कठिनाई यह है कि यह थ्रेड-सुरक्षित नहीं है - अर्थात, यदि आपके पास निष्पादन के कई अलग-अलग धागे हैं, तो इसका उपयोग करना सुरक्षित नहीं है, क्योंकि यह काम करने की गारंटी नहीं है यदि दो अलग-अलग थ्रेड निष्पादित हो रहे हैं। एक ही समय में समारोह। यदि आप थ्रेड का उपयोग नहीं कर रहे हैं, और यदि आप यथोचित अपेक्षा कर सकते हैं कि आपको भविष्य में इस तरह से अपने कार्यक्रम को फिर से लिखने की आवश्यकता नहीं होगी, तो परीक्षण के प्रयोजनों के लिए numpy.random.seed () ठीक होना चाहिए। यदि आपको संदेह करने का कोई कारण है कि आपको भविष्य में थ्रेड्स की आवश्यकता हो सकती है, तो यह लंबे समय तक सुझाव के रूप में करने के लिए सुरक्षित है, और numpy.random.Random वर्ग का एक स्थानीय उदाहरण बनाने के लिए। जहाँ तक मैं बता सकता हूँ, random.random.seed () धागा सुरक्षित है (या कम से कम, मुझे इसके विपरीत कोई सबूत नहीं मिला है)।
इस बारे में जाने का उदाहरण:
from numpy.random import RandomState
prng = RandomState()
print prng.permutation(10)
prng = RandomState()
print prng.permutation(10)
prng = RandomState(42)
print prng.permutation(10)
prng = RandomState(42)
print prng.permutation(10)दे सकते हैं:
[३ ० ४ ६ 1 २ १ ९ 5 ५]
[१ ६ ९ ० २ २ 3 5 ३ ५ ४]
[[१ ५ ५ 8 २ २ ९ ४ ३ ६]
[[१ ५ ५ 8 २ २ ९ ४ ३ ६]
अंत में, ध्यान दें कि ऐसे मामले हो सकते हैं जहां 0 पर आरंभीकरण करना (एक बीज के विपरीत जो सभी बिट्स 0 नहीं है) के परिणामस्वरूप गैर-समान वितरण हो सकता है क्योंकि कुछ ही पहले पुनरावृत्तियों के लिए xor काम करता है, लेकिन यह एल्गोरिथ्म पर निर्भर करता है , और मेरी वर्तमान चिंताओं और इस प्रश्न के दायरे से परे है।
मैंने इसका उपयोग तंत्रिका नेटवर्क में बहुत बार किया है। यह सर्वविदित है कि जब हम एक तंत्रिका नेटवर्क को प्रशिक्षित करना शुरू करते हैं तो हम बेतरतीब ढंग से वजन को कम करते हैं। मॉडल को इन वेट पर एक विशेष डेटासेट पर प्रशिक्षित किया जाता है। युगों की संख्या के बाद आपको भार का प्रशिक्षित सेट मिलता है।
अब मान लीजिए कि आप फिर से खरोंच से प्रशिक्षित होना चाहते हैं या आप अपने परिणामों को पुन: पेश करने के लिए दूसरों को मॉडल पास करना चाहते हैं, तो वज़न फिर से एक यादृच्छिक संख्याओं के लिए शुरू हो जाएगा, जो ज्यादातर पहले वाले से अलग होगा। पहले से ही अलग-अलग संख्या में युगों (समान डेटा और अन्य मापदंडों को ध्यान में रखते हुए) के बाद प्रशिक्षित वजन होगा। समस्या यह है कि आपका मॉडल कोई और अधिक प्रतिलिपि प्रस्तुत करने योग्य नहीं है जो हर बार जब आप अपने मॉडल को खरोंच से प्रशिक्षित करते हैं तो यह आपको वजन के विभिन्न सेट प्रदान करता है। ऐसा इसलिए है क्योंकि मॉडल को हर बार अलग-अलग यादृच्छिक संख्याओं द्वारा आरंभ किया जा रहा है।
क्या होगा अगर हर बार जब आप स्क्रैच से प्रशिक्षण शुरू करते हैं तो मॉडल को रैंडम इनिशियल वेट के एक ही सेट से शुरू किया जाता है? इस मामले में आपका मॉडल प्रजनन योग्य हो सकता है। यह numpy.random.seed (0) द्वारा प्राप्त किया गया है। एक विशेष संख्या में बीज () का उल्लेख करके, आप हमेशा यादृच्छिक संख्याओं के एक ही सेट पर लटके रहते हैं।
कल्पना कीजिए कि आप किसी को "यादृच्छिक" संख्याओं के समूह के साथ कुछ कोड करने का तरीका दिखा रहे हैं। सुन्न बीज का उपयोग करके वे एक ही बीज संख्या का उपयोग कर सकते हैं और "यादृच्छिक" संख्याओं के समान सेट प्राप्त कर सकते हैं।
इसलिए यह बिल्कुल यादृच्छिक नहीं है क्योंकि एक एल्गोरिथ्म संख्याओं को बाहर निकालता है लेकिन यह एक यादृच्छिक रूप से उत्पन्न गुच्छा जैसा दिखता है।
एक यादृच्छिक बीज प्रारंभ बिंदु को निर्दिष्ट करता है जब एक कंप्यूटर एक यादृच्छिक संख्या अनुक्रम उत्पन्न करता है।
उदाहरण के लिए, मान लें कि आप एक्सेल में एक यादृच्छिक संख्या उत्पन्न करना चाहते थे (नोट: एक्सेल बीज के लिए 9999 की सीमा निर्धारित करता है)। यदि आप प्रक्रिया के दौरान रैंडम सीड बॉक्स में एक नंबर दर्ज करते हैं, तो आप फिर से रैंडम संख्याओं के एक ही सेट का उपयोग कर पाएंगे। यदि आपने बॉक्स में "77" टाइप किया है, और अगली बार जब आप यादृच्छिक संख्या जनरेटर चलाते हैं, तो "77" टाइप किया, एक्सेल यादृच्छिक संख्याओं के उसी सेट को प्रदर्शित करेगा। यदि आप "99" टाइप करते हैं, तो आपको संख्याओं का एक अलग सेट मिलेगा। लेकिन अगर आप वापस 77 के बीज पर वापस जाते हैं, तो आपको उसी यादृच्छिक संख्या का एक सेट मिलेगा जो आपने शुरू किया था।
उदाहरण के लिए, "एक नंबर x लें, 900 + x जोड़ें, फिर 52 घटाएँ।" प्रक्रिया शुरू करने के लिए, आपको एक प्रारंभिक संख्या, x (बीज) निर्दिष्ट करनी होगी। चलिए शुरू संख्या 77 लेते हैं:
900 + 77 = 977 घटाएँ 52 = 925 समान एल्गोरिथ्म के बाद, दूसरा "रैंडम" नंबर होगा:
900 + 925 = 1825 घटाना 52 = 1773 यह सरल उदाहरण एक पैटर्न का अनुसरण करता है, लेकिन कंप्यूटर नंबर पीढ़ी के पीछे एल्गोरिदम बहुत अधिक जटिल हैं
Numpy डॉक्स में एक अच्छी व्याख्या है: https://docs.scipy.org/doc/numpy-1.15.1/reference/generated/numpy.random.RandomState.html यह Mersenne Sister छद्म-यादृच्छिक संख्या जनरेटर को संदर्भित करता है । यहाँ एल्गोरिथ्म पर अधिक जानकारी: https://en.wikipedia.org/wiki/Mersenne_Twister
numpy.random.seed(0)
numpy.random.randint(10, size=5)यह निम्न आउटपुट का उत्पादन करता है:
array([5, 0, 3, 3, 7])
फिर से, यदि हम समान कोड चलाते हैं तो हमें समान परिणाम मिलेगा।
अब अगर हम बीज का मान 0 से 1 या अन्य बदलते हैं:
numpy.random.seed(1)
numpy.random.randint(10, size=5)यह निम्न आउटपुट का उत्पादन करता है: array([5 8 9 5 0])लेकिन अब आउटपुट ऊपर जैसा नहीं है।
उपरोक्त सभी उत्तर के कार्यान्वयन को दर्शाता है np.random.seed() कोड में । मैं संक्षेप में समझाने की पूरी कोशिश करूँगा कि वास्तव में ऐसा क्यों होता है। कंप्यूटर ऐसी मशीनें हैं जिन्हें पूर्वनिर्धारित एल्गोरिदम के आधार पर डिज़ाइन किया गया है। कंप्यूटर से कोई भी आउटपुट इनपुट पर लागू किए गए एल्गोरिदम का परिणाम है। इसलिए जब हम यादृच्छिक संख्याओं को उत्पन्न करने के लिए कंप्यूटर से अनुरोध करते हैं, तो सुनिश्चित करें कि वे यादृच्छिक हैं, लेकिन कंप्यूटर केवल यादृच्छिक रूप से उनके साथ नहीं आया है!
इसलिए जब हम लिखते हैं np.random.seed(any_number_here) एल्गोरिथ्म संख्याओं के एक विशेष सेट का उत्पादन होगा जो तर्क के लिए अद्वितीय है any_number_here। यदि हम सही तर्क पास करते हैं तो यह लगभग रैंडम संख्याओं के एक विशेष सेट की तरह प्राप्त किया जा सकता है। लेकिन इसके लिए हमें यह जानना होगा कि एल्गोरिथ्म कैसे काम करता है जो काफी थकाऊ है।
इसलिए, उदाहरण के लिए, अगर मैं np.random.seed(10)संख्याओं के विशेष सेट को लिखता हूं जो मुझे प्राप्त होता है, तो मैं एक ही रहेगा, भले ही मैं 10 साल बाद उसी रेखा को निष्पादित करता हूं जब तक कि एल्गोरिथ्म नहीं बदलता।