random.seed (): Que fait-il?

Je suis un peu confus sur ce que random.seed()fait Python. Par exemple, pourquoi les essais ci-dessous font-ils ce qu'ils font (systématiquement)?

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

Je n'ai pas trouvé de bonne documentation à ce sujet.

Les générateurs de nombres pseudo-aléatoires fonctionnent en effectuant une opération sur une valeur. Généralement, cette valeur est le numéro précédent généré par le générateur. Cependant, la première fois que vous utilisez le générateur, il n'y a pas de valeur précédente.

L'amorçage d'un générateur de nombres pseudo-aléatoires lui donne sa première valeur "précédente". Chaque valeur de départ correspondra à une séquence de valeurs générées pour un générateur de nombres aléatoires donné. Autrement dit, si vous fournissez deux fois la même graine, vous obtenez la même séquence de nombres deux fois.

Généralement, vous voulez amorcer votre générateur de nombres aléatoires avec une valeur qui changera chaque exécution du programme. Par exemple, l'heure actuelle est une graine fréquemment utilisée. La raison pour laquelle cela ne se produit pas automatiquement est que si vous le souhaitez, vous pouvez fournir une graine spécifique pour obtenir une séquence connue de nombres.

Toutes les autres réponses ne semblent pas expliquer l'utilisation de random.seed (). 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 que 'random.seed' donne une valeur au générateur de valeurs aléatoires ('random.randint ()') qui génère ces valeurs sur la base de cette graine. L'une des propriétés essentielles des nombres aléatoires est qu'ils doivent être reproductibles. Lorsque vous mettez la même graine, vous obtenez le même modèle de nombres aléatoires. De cette façon, vous les générez dès le début. Vous donnez une graine différente - elle commence par une initiale différente (au-dessus de 3).

Étant donné une graine, il générera des nombres aléatoires entre 1 et 10 l'un après l'autre. Vous supposez donc un ensemble de nombres pour une valeur de départ.

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

S'il n'y a pas de valeur précédente, l'heure actuelle est automatiquement la valeur précédente. Nous pouvons fournir cette valeur précédente par nous-mêmes en utilisant random.seed(x)où xpourrait être n'importe quel nombre ou chaîne, etc.

Ce random.random()n'est donc pas réellement un nombre aléatoire 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. Les algorithmes donnent toujours la même sortie basée sur la même entrée. Cela signifie que cela dépend de la valeur de la graine. Ainsi, afin de le rendre plus aléatoire, le temps est automatiquement attribué seed().

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

# Simple Python program 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: imprime 5 entiers aléatoires compris entre 1 et 100

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

3e tentative: même

.....Bientôt

Explication: Chaque fois que nous exécutons le programme ci-dessus, nous définissons la valeur de départ sur 10, puis le générateur aléatoire le prend comme variable de référence. Et puis en faisant une formule prédéfinie, il génère un nombre aléatoire.

Par conséquent, régler la valeur de départ à 10 lors de l'exécution suivante définit à nouveau le numéro de référence sur 10 et le même comportement commence à nouveau ...

Dès que nous réinitialisons la valeur de la graine, cela 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.

Dans ce cas, aléatoire est en fait pseudo-aléatoire. Étant donné une graine, il générera des nombres avec une distribution égale. Mais avec la même graine, il générera la même séquence de nombres à chaque fois. Si vous voulez que cela change, vous devrez changer votre semence. Beaucoup de gens aiment générer une graine basée sur l'heure actuelle ou quelque chose comme ça.

Imho, il est utilisé pour générer le même résultat de cours aléatoire lorsque vous utilisez à random.seed(samedigit)nouveau.

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

Définissez le seed(x)avant de générer un ensemble de nombres aléatoires et utilisez la même graine pour générer le même ensemble de nombres aléatoires. Utile en cas de reproduction des problèmes.

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

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 prochain appel random.function est attaché à cette "étiquette", donc la prochaine fois que vous appellerez la même valeur de départ et random.function, cela 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

Voici un petit test qui démontre que nourrir la seed()méthode 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)

random.seed(a, version)en python est utilisé pour initialiser le générateur de nombres pseudo-aléatoires (PRNG) .

PRNG est un algorithme qui génère une séquence de nombres approximant les propriétés de nombres aléatoires. Ces nombres aléatoires peuvent être reproduits en utilisant la valeur de départ . Ainsi, si vous fournissez une valeur de départ, PRNG démarre à partir d'un état de départ arbitraire en utilisant une valeur de départ.

L'argument a est la valeur de départ. Si la valeur a est None, alors par défaut, l'heure système actuelle est utilisée.

et versionest un entier spécifiant comment convertir le paramètre a en un entier. La valeur par défaut est 2.

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

Si vous voulez que le même nombre aléatoire à reproduire ensuite fournir la même graine à nouveau

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

Si vous ne fournissez pas la graine, cela génère un nombre différent et non 1 comme avant

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

Si vous fournissez une graine différente de celle d'avant , cela vous donnera un nombre aléatoire différent

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

Donc, en résumé, si vous voulez que le même nombre aléatoire soit reproduit, fournissez la graine. Plus précisément, la même graine .