random.seed (): यह क्या करता है?

Question

random.seed()पायथन में जो कुछ होता है, उस पर मैं थोड़ा भ्रमित हूं । उदाहरण के लिए, नीचे वाले परीक्षण क्यों करते हैं कि वे क्या करते हैं (लगातार)?

>>> import random
>>> random.seed(9001)
>>> random.randint(1, 10)
1
>>> random.randint(1, 10)
3
>>> random.randint(1, 10)
6
>>> random.randint(1, 10)
6
>>> random.randint(1, 10)
7

मुझे इस पर अच्छा प्रलेखन नहीं मिला।

Comments

यादृच्छिक संख्या पीढ़ी वास्तव में "यादृच्छिक" नहीं है। यह नियतात्मक है, और यह जो क्रम उत्पन्न करता है, वह आपके द्वारा पारित बीज मूल्य से तय होता है random.seed। आमतौर पर आप सिर्फ आह्वान करते हैं random.seed(), और यह वर्तमान समय को बीज मूल्य के रूप में उपयोग करता है, जिसका अर्थ है कि जब भी आप स्क्रिप्ट चलाते हैं तो आपको मूल्यों का एक अलग क्रम मिलेगा।

— असद सईदुद्दीन

एक ही बीज को यादृच्छिक रूप से पास करना, और फिर इसे कॉल करना आपको समान संख्याओं का सेट देगा। यह इरादा के अनुसार काम कर रहा है, और यदि आप चाहते हैं कि परिणाम हर बार अलग-अलग हों, तो आपको हर बार जब आप एक ऐप शुरू करते हैं तो कुछ अलग करना होगा (उदाहरण के लिए / dev / random या time से आउटपुट)

— Tymoteusz Paul

पहला यादृच्छिक संख्या उत्पन्न करने के लिए बीज को RNG को खिलाया जाता है। उसके बाद, वे आरएनजी स्वयं-खिलाया जाता है। आप इसका कारण लगातार एक ही जवाब नहीं देखते हैं। यदि आप इस स्क्रिप्ट को फिर से चलाते हैं, तो आपको "यादृच्छिक" संख्याओं का समान अनुक्रम मिलेगा। यदि आप परिणामों को पुन: उत्पन्न करना चाहते हैं तो बीज को स्थापित करना सहायक है, क्योंकि उत्पन्न सभी "यादृच्छिक" संख्याएँ हमेशा समान रहेंगी।

— पलक

वर्थ उल्लेख: इस पोस्ट में दिखाया गया अनुक्रम पायथन 2 में है। पायथन 3 एक अलग अनुक्रम देता है।

— गोरगलेन

"यादृच्छिक संख्या" का @Blink का उपयोग भ्रामक है। RNG में एक आंतरिक अवस्था होती है जो स्व-पोषित होती है। इस आंतरिक स्थिति से, रैंडिंट (1,10) और अन्य कॉल के लिए आउटपुट प्राप्त होते हैं। यदि RNG रैंडिन्ट (1,10) के आउटपुट से फीडिंग कर रहा था, तो अनुक्रम 10 अनुक्रमों में से 1 तक ढह जाएगा और अनुक्रम 10 संख्याओं के बाद दोहराएगा।

— जोआचिम वैग्नर

Answer 1

छद्म यादृच्छिक संख्या जनरेटर एक मान पर कुछ ऑपरेशन करके काम करते हैं। आम तौर पर यह मान जनरेटर द्वारा उत्पन्न पिछली संख्या है। हालांकि, पहली बार जब आप जनरेटर का उपयोग करते हैं, तो कोई पिछला मूल्य नहीं होता है।

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

आम तौर पर, आप अपने यादृच्छिक संख्या जनरेटर को कुछ मूल्य के साथ बीज देना चाहते हैं जो कार्यक्रम के प्रत्येक निष्पादन को बदल देगा। उदाहरण के लिए, वर्तमान समय एक अक्सर इस्तेमाल किया जाने वाला बीज है। ऐसा स्वचालित रूप से नहीं होने का कारण यह है कि यदि आप चाहें, तो आप संख्याओं का ज्ञात क्रम प्राप्त करने के लिए एक विशिष्ट बीज प्रदान कर सकते हैं।

Comments

यह उल्लेख के लायक है कि कभी-कभी हम बीज देना चाहते हैं ताकि कार्यक्रम के प्रत्येक रन पर एक ही यादृच्छिक अनुक्रम उत्पन्न हो। कभी-कभी, सॉफ्टवेयर प्रोग्राम (रों) में यादृच्छिकता को प्रोग्राम व्यवहार निर्धारक रखने और मुद्दों / बगों को पुन: पेश करने की संभावना से बचा जाता है।

— ViFI

@ViFI ने जो कहा, उसके बाद कार्यक्रम व्यवहार निर्धारक (एक निश्चित बीज, या बीजों के निश्चित अनुक्रम) को ध्यान में रखते हुए आप बेहतर आकलन कर सकते हैं कि आपके कार्यक्रम में कुछ बदलाव फायदेमंद है या नहीं।

— शनैब

क्या आप कुछ वास्तविक जीवन परिदृश्य के साथ समझाना चाहेंगे। मैं उसी के लिए उपयोग के मामले को नहीं समझ सकता। क्या हमारे पास अन्य प्रोग्रामिंग भाषा में भी ऐसा ही कुछ है?

— शशांक विवेक

यहाँ एक वास्तविक जीवन परिदृश्य है: stackoverflow.com/questions/5836335/… । अनुसंधान के लिए प्रजनन योग्य परिणाम बनाने के लिए यादृच्छिक बीज भी आम हैं। उदाहरण के लिए, यदि आप एक डेटा वैज्ञानिक हैं और आप अपने परिणामों को किसी प्रकार के मॉडल के साथ प्रकाशित करना चाहते हैं जो यादृच्छिकता का उपयोग करता है (उदाहरण के लिए एक यादृच्छिक वन), तो आप अपने प्रकाशित कोड में एक बीज शामिल करना चाहेंगे ताकि लोग यह सुनिश्चित कर सकें कि आपके गणना प्रजनन योग्य है।

— गालेन लॉन्ग

Answer 2

अन्य सभी उत्तर random.seed () के उपयोग की व्याख्या नहीं करते हैं। यहाँ एक सरल उदाहरण ( स्रोत ) है:

import random
random.seed( 3 )
print "Random number with seed 3 : ", random.random() #will generate a random number 
#if you want to use the same random number once again in your program
random.seed( 3 )
random.random()   # same random number as before

Answer 3

>>> random.seed(9001)   
>>> random.randint(1, 10)  
1     
>>> random.seed(9001)     
>>> random.randint(1, 10)    
1           
>>> random.seed(9001)          
>>> random.randint(1, 10)                 
1                  
>>> random.seed(9001)         
>>> random.randint(1, 10)          
1     
>>> random.seed(9002)                
>>> random.randint(1, 10)             
3

आप यह कोशिश करें।

मान लें कि 'random.seed' यादृच्छिक मान जनरेटर ('random.randint ()') को एक मान देता है जो इस बीज के आधार पर इन मूल्यों को उत्पन्न करता है। यादृच्छिक संख्याओं के गुणों में से एक यह है कि उन्हें प्रतिलिपि प्रस्तुत करने योग्य होना चाहिए। जब आप एक ही बीज डालते हैं, तो आपको यादृच्छिक संख्याओं का समान पैटर्न मिलता है। इस तरह आप उन्हें शुरू से ही सही पैदा कर रहे हैं। आप एक अलग बीज देते हैं- यह एक अलग प्रारंभिक (3 से ऊपर) से शुरू होता है।

एक बीज को देखते हुए, यह एक के बाद एक और 10 के बीच यादृच्छिक संख्या उत्पन्न करेगा। तो आप एक बीज के मूल्य के लिए संख्याओं का एक सेट मान लें।

Answer 4

पिछले मान पर कुछ ऑपरेशन द्वारा एक यादृच्छिक संख्या उत्पन्न की जाती है।

यदि कोई पिछला मान नहीं है, तो वर्तमान समय पिछले मूल्य के रूप में स्वचालित रूप से है। हम का उपयोग कर खुद से यह पिछले मूल्य प्रदान कर सकते हैं random.seed(x)जहां xकिसी भी संख्या या स्ट्रिंग आदि हो सकता है

इसलिए random.random()वास्तव में सही यादृच्छिक संख्या नहीं है, इसके माध्यम से भविष्यवाणी की जा सकती है random.seed(x)।

import random 
random.seed(45)            #seed=45  
random.random()            #1st rand value=0.2718754143840908
0.2718754143840908  
random.random()            #2nd rand value=0.48802820785090784
0.48802820785090784  
random.seed(45)            # again reasign seed=45  
random.random()
0.2718754143840908         #matching with 1st rand value  
random.random()
0.48802820785090784        #matching with 2nd rand value

इसलिए, एक यादृच्छिक संख्या उत्पन्न करना वास्तव में यादृच्छिक नहीं है, क्योंकि यह एल्गोरिदम पर चलता है। एल्गोरिदम हमेशा एक ही इनपुट के आधार पर एक ही आउटपुट देते हैं। इसका मतलब है, यह बीज के मूल्य पर निर्भर करता है। इसलिए, इसे और अधिक यादृच्छिक बनाने के लिए, समय स्वचालित रूप से सौंपा गया है seed()।

Answer 5

Seed() can be used for later use ---

Example:
>>> import numpy as np
>>> np.random.seed(12)
>>> np.random.rand(4)
array([0.15416284, 0.7400497 , 0.26331502, 0.53373939])
>>>
>>>
>>> np.random.seed(10)
>>> np.random.rand(4)
array([0.77132064, 0.02075195, 0.63364823, 0.74880388])
>>>
>>>
>>> np.random.seed(12) # When you use same seed as before you will get same random output as before
>>> np.random.rand(4)
array([0.15416284, 0.7400497 , 0.26331502, 0.53373939])
>>>
>>>
>>> np.random.seed(10)
>>> np.random.rand(4)
array([0.77132064, 0.02075195, 0.63364823, 0.74880388])
>>>

Answer 6

# Simple Python program to understand random.seed() importance

import random

random.seed(10)

for i in range(5):    
    print(random.randint(1, 100))

उपरोक्त कार्यक्रम को कई बार निष्पादित करें ...

पहला प्रयास: 1 - 100 की सीमा में 5 यादृच्छिक पूर्णांक प्रिंट करता है

दूसरा प्रयास: उक्त निष्पादन में समान 5 यादृच्छिक संख्याएँ दिखाई देती हैं।

तीसरा प्रयास: वही

.....जल्द ही

स्पष्टीकरण: हर बार जब हम उपरोक्त कार्यक्रम चला रहे होते हैं तो हम बीज को 10 पर सेट कर रहे हैं, तब यादृच्छिक जनरेटर इसे संदर्भ चर के रूप में लेता है। और फिर कुछ पूर्वनिर्धारित सूत्र करके, यह एक यादृच्छिक संख्या उत्पन्न करता है।

इसलिए अगले निष्पादन में 10 से बीज सेट करना फिर से संदर्भ संख्या को 10 पर सेट करता है और फिर से वही व्यवहार शुरू होता है ...

जैसे ही हम बीज मूल्य को रीसेट करते हैं यह उसी पौधों को देता है।

नोट: बीज का मूल्य बदलें और कार्यक्रम को चलाएं, आपको पिछले वाले की तुलना में एक अलग यादृच्छिक अनुक्रम दिखाई देगा।

Answer 7

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

Answer 8

Imho, यह एक ही यादृच्छिक पाठ्यक्रम परिणाम उत्पन्न करने के लिए उपयोग किया जाता है जब आप random.seed(samedigit)फिर से उपयोग करते हैं।

In [47]: random.randint(7,10)

Out[47]: 9


In [48]: random.randint(7,10)

Out[48]: 9


In [49]: random.randint(7,10)

Out[49]: 7


In [50]: random.randint(7,10)

Out[50]: 10


In [51]: random.seed(5)


In [52]: random.randint(7,10)

Out[52]: 9


In [53]: random.seed(5)


In [54]: random.randint(7,10)

Out[54]: 9

Answer 9

seed(x)यादृच्छिक संख्याओं का एक सेट उत्पन्न करने से पहले सेट करें और यादृच्छिक संख्याओं के समान सेट को उत्पन्न करने के लिए एक ही बीज का उपयोग करें। मुद्दों को पुन: प्रस्तुत करने के मामले में उपयोगी है।

>>> from random import *
>>> seed(20)
>>> randint(1,100)
93
>>> randint(1,100)
88
>>> randint(1,100)
99
>>> seed(20)
>>> randint(1,100)
93
>>> randint(1,100)
88
>>> randint(1,100)
99
>>> 

Answer 10

यहाँ मेरी समझ है। हर बार जब हम एक बीज मूल्य निर्धारित करते हैं, तो एक "लेबल" या "संदर्भ" उत्पन्न होता है। अगली रैंडम.फंक्शन कॉल इस "लेबल" से जुड़ी होती है, इसलिए अगली बार जब आप एक ही सीड वैल्यू और रैंडम.फंक्शन कहते हैं, तो यह आपको वही परिणाम देगा।

np.random.seed( 3 )
print(np.random.randn()) # output: 1.7886284734303186

np.random.seed( 3 )
print(np.random.rand()) # different function. output: 0.5507979025745755

np.random.seed( 5 )
print(np.random.rand()) # different seed value. output: 0.22199317108973948

Answer 11

यहां एक छोटा परीक्षण है जो दर्शाता है कि seed()विधि को एक ही तर्क के साथ खिलाने से एक ही छद्म यादृच्छिक परिणाम होगा:

# testing random.seed()

import random

def equalityCheck(l):
    state=None
    x=l[0]
    for i in l:
        if i!=x:
            state=False
            break
        else:
            state=True
    return state


l=[]

for i in range(1000):
    random.seed(10)
    l.append(random.random())

print "All elements in l are equal?",equalityCheck(l)

Comments

शॉर्टर समानता की जाँच:len(set(l))<=1

— ओलिवर नी

Answer 12

random.seed(a, version)अजगर में छद्म यादृच्छिक संख्या जनरेटर (PRNG) को इनिशियलाइज़ करने के लिए उपयोग किया जाता है ।

PRNG एल्गोरिथ्म है जो यादृच्छिक संख्याओं के गुणों का अनुमान लगाने वाली संख्याओं के अनुक्रम को उत्पन्न करता है। बीज मूल्य का उपयोग करके इन यादृच्छिक संख्याओं को पुन: पेश किया जा सकता है । इसलिए, यदि आप बीज का मूल्य प्रदान करते हैं, तो PRNG एक बीज का उपयोग करके मनमाने ढंग से शुरू होने वाले राज्य से शुरू होता है।

तर्क a बीज मूल्य है। यदि कोई मान है None, तो डिफ़ॉल्ट रूप से, वर्तमान सिस्टम समय का उपयोग किया जाता है।

और versionएक पूर्णांक निर्दिष्ट करता है कि पैरामीटर को पूर्णांक में कैसे परिवर्तित किया जाए। डिफ़ॉल्ट मान 2 है।

import random
random.seed(9001)
random.randint(1, 10) #this gives output of 1
# 1

यदि आप चाहते हैं कि एक ही यादृच्छिक संख्या का पुनरुत्पादन किया जाए तो वही बीज दोबारा प्रदान करें

random.seed(9001)
random.randint(1, 10) # this will give the same output of 1
# 1

यदि आप बीज प्रदान नहीं करते हैं, तो यह अलग संख्या उत्पन्न करता है और पहले की तरह 1 नहीं

random.randint(1, 10) # this gives 7 without providing seed
# 7

यदि आप पहले की तुलना में अलग बीज प्रदान करते हैं , तो यह आपको एक अलग यादृच्छिक संख्या देगा

random.seed(9002)
random.randint(1, 10) # this gives you 5 not 1
# 5

तो, सारांश में, यदि आप चाहते हैं कि एक ही यादृच्छिक संख्या को पुन: पेश किया जाए, तो बीज प्रदान करें। विशेष रूप से, एक ही बीज ।