random.seed (): Que fait-il?


177

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.


30
La génération de nombres aléatoires n'est pas vraiment "aléatoire". Il est déterministe et la séquence qu'il génère est dictée par la valeur de départ dans laquelle vous passez random.seed. En général, vous appelez simplement random.seed()et il utilise l'heure actuelle comme valeur de départ, ce qui signifie que chaque fois que vous exécutez le script, vous obtiendrez une séquence de valeurs différente.
Asad Saeeduddin

3
Passer la même graine au hasard, puis l'appeler vous donnera le même ensemble de nombres. Cela fonctionne comme prévu, et si vous voulez que les résultats soient différents à chaque fois, vous devrez le semer avec quelque chose de différent chaque fois que vous démarrez une application (par exemple, sortie de / dev / random ou time)
Tymoteusz Paul

5
La graine est ce qui est fourni au RNG pour générer le premier nombre aléatoire. Après cela, ils RNG sont auto-alimentés. Vous ne voyez pas la même réponse de manière cohérente à cause de cela. Si vous exécutez à nouveau ce script, vous obtiendrez la même séquence de nombres «aléatoires». La définition de la valeur de départ est utile si vous souhaitez reproduire les résultats, car tous les nombres «aléatoires» générés seront toujours les mêmes.
Blink

À noter: la séquence montrée dans cet article est en Python 2. Python 3 donne une séquence différente.
ggorlen

1
L'utilisation du "nombre aléatoire" par @Blink est trompeuse. Le RNG a un état interne qui est auto-alimenté. À partir de cet état interne, la sortie de randint (1,10) et d'autres appels sont dérivées. Si le RNG alimentait à partir de la sortie de randint (1,10), la séquence se réduirait à 1 sur au plus 10 séquences et la séquence se répéterait après au plus 10 nombres.
Joachim Wagner le

Réponses:


213

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.


39
Peut-être vaut-il la peine de mentionner que parfois nous voulons donner des semences pour que la même séquence aléatoire soit générée à chaque exécution du programme. Parfois, le caractère aléatoire des programmes logiciels est évité pour garder le comportement du programme déterministe et la possibilité de reproduire les problèmes / bogues.
ViFI

1
À la suite de ce que @ViFI a dit, garder le comportement du programme déterministe (avec une graine fixe ou une séquence fixe de graines) peut également vous permettre de mieux évaluer si un changement de votre programme est bénéfique ou non.
shaneb

pourriez-vous expliquer avec un scénario de la vie réelle. Je ne peux pas comprendre un cas d'utilisation pour le même. Avons-nous quelque chose de similaire dans un autre langage de programmation?
Shashank Vivek

1
Voici un scénario réel: stackoverflow.com/questions/5836335/… . Les graines aléatoires sont également courantes pour créer des résultats reproductibles pour la recherche. Par exemple, si vous êtes un data scientist et que vous souhaitez publier vos résultats avec un type de modèle qui utilise le caractère aléatoire (par exemple, une forêt aléatoire), vous voudrez inclure une graine dans votre code publié afin que les gens puissent s'assurer que votre les calculs sont reproductibles.
Galen Long

89

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

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


15

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)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().


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

11
# 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.


7

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.


6

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

4

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

3

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

1

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)

4
Contrôle d'égalité plus court:len(set(l))<=1
Oliver Ni

0

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 .

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.