random.seed (): Qu'est-ce que ça fait?
Je suis un peu confus sur ce que random.seed() fait en 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 pu trouver une 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.
La génération d'un générateur de nombres pseudo-aléatoires lui donne sa première valeur "précédente". Chaque valeur initiale 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 deux fois la même séquence de chiffres.
En règle générale, vous souhaitez doter votre générateur de nombres aléatoires d'une valeur qui modifiera 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 de nombres connue.
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 valeur aléatoire ('random.randint ()') qui génère ces valeurs à partir de cette graine. L'une des propriétés essentielles des nombres aléatoires est qu'ils doivent être reproductibles. Une fois que vous mettez la même graine, vous obtenez le même motif de nombres aléatoires. Donc, vous les générez dès le début. Vous donnez une graine différente, elle commence par une initiale différente (supérieure à 3).
Vous avez maintenant donné une graine qui générera des 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.
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 nous-mêmes en utilisant random.seed(x) où x pourrait être un nombre ou une chaîne quelconque, etc.
Par conséquent, random.random() n'est pas réellement un nombre aléatoire parfait, il peut ê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 s’appuie 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: affiche 5 nombres 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: idem
.....Bientôt
Explication: Chaque fois que nous exécutons le programme ci-dessus, nous définissons un nombre initial de 10, puis le générateur aléatoire prend cela 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, si la valeur de départ est définie sur 10 lors de la prochaine exécution, le numéro de référence est à nouveau défini à 10 et le même comportement commence à nouveau.
Dès que nous réinitialisons la valeur de départ, cela donne les mêmes plantes.
Remarque: Modifiez la valeur de départ et exécutez le programme. Une séquence aléatoire différente de la précédente apparaîtra.
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 va générer à chaque fois la même séquence numérique. Si vous voulez que cela change, vous devrez changer votre graine. Beaucoup de gens aiment générer une graine en fonction de l'heure ou de quelque chose.
À mon humble avis, il est utilisé pour générer le même résultat de parcours 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
Définissez la 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 un petit test qui montre que le fait de nourrir la méthode seed() avec le même argument entraîne 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 prochain appel random.function est associé à cette "étiquette". Ainsi, la prochaine fois que vous appelez la même valeur de départ et la même fonction random.function, vous obtiendrez 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