aléatoire.seed(): Que fait-il?

Toutes les autres réponses ne semblent pas expliquer l'utilisation de random.graine(). Voici un exemple simple (source):

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

>>> 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

Vous essayez ceci. Disons aléatoire.seed ' donne une valeur au générateur de valeur aléatoire ('random.randint()') qui génère ces valeurs sur la base de cette graine. Une des propriétés de nombres aléatoires est qu'ils doivent être reproductibles. Une fois que vous mettez la même graine, vous obtenez le même modèle de nombres aléatoires. Donc, vous les générez dès le début à nouveau. Vous donnez une graine différente, elle commence par une initiale différente (au-dessus de 3).

Vous avez donné une graine maintenant qu'elle va générer nombres aléatoires entre 1 et 10, l'un après l'autre. Vous pouvez donc supposer un ensemble de nombres pour une valeur de départ.

Dans ce cas, random est en fait pseudo-aléatoire. Donné une graine, il va générer des nombres, avec une répartition égale. Mais avec la même graine, il va générer la même séquence de nombres à chaque fois. Si vous voulez qu'il change, vous devrez changer votre graine. Beaucoup de gens aiment générer une graine en fonction de l'heure actuelle ou quelque chose.

 #Simple python programme to understand random.seed() importance

 import random

 random.seed(10)

 for i in range(5):

      print(random.randint(1,100))

Exécutez le programme ci-dessus plusieurs fois....

1ère tentative: affiche 5 entiers aléatoires dans la plage de 1 à 100

2ème tentative: imprime les mêmes 5 nombres aléatoires apparus dans l'exécution ci-dessus.

3ème tentative: même

.....ainsi de suite

Explication: chaque fois que nous exécutons le programme ci-dessus , nous mettons seed à 10, alors random generator prend cela comme variable de référence.Et puis en faisant une formule prédéfinie il génère un aléatoire nombre.

Par conséquent, la définition de seed à 10 dans l'exécution suivante définit à nouveau le numéro de référence à 10 et le même comportement commence à nouveau....

Dès que nous réinitialisons la valeur de la graine, elle donne les mêmes plantes.

Remarque: Modifiez la valeur de départ et exécutez le programme, vous verrez une séquence aléatoire différente de la précédente.

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])
>>>

À mon humble avis, il est utilisé pour générer le même résultat de cours aléatoire lorsque vous utilisez à nouveau 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

Un nombre aléatoire est généré par une opération sur une valeur précédente.

S'il n'y a pas de valeur précédente, alors l'heure actuelle comme valeur précédente automatiquement. nous pouvons fournir cette valeur précédente en utilisant random.seed(x) où x pourrait être n'importe quel nombre ou chaîne, etc.

Par conséquent random.random() n'est pas un nombre aléatoire réellement parfait, il pourrait être prédit via 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

Par conséquent, générer un nombre aléatoire n'est pas réellement aléatoire, car il fonctionne sur des algorithmes. Algorithme toujours donner la même sortie basée sur la même entrée. Cela signifie, il dépend de la valeur de la graine. Ainsi, afin de le rendre plus aléatoire, le temps est automatiquement attribué à seed().

Voici un petit test qui démontre que l'alimentation de la méthode seed() avec le même argument provoquera le même résultat pseudo-aléatoire:

# 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)

Voici ma compréhension. Chaque fois que nous définissons une valeur de départ, une "étiquette" ou une "référence" est générée. Le côté aléatoire.l'appel de fonction est attaché à cette "étiquette", donc la prochaine fois que vous appelez la même valeur de départ et aléatoire.fonction, il vous donnera le même résultat.

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