Co robi numpy.przypadkowe.seed (0) do?

Jeśli ustawisz np.random.seed(a_fixed_number) za każdym razem, gdy wywołasz inną losową funkcję numpy, wynik będzie taki sam:

>>> import numpy as np
>>> np.random.seed(0) 
>>> perm = np.random.permutation(10) 
>>> print perm 
[2 8 4 9 1 6 7 3 0 5]
>>> np.random.seed(0) 
>>> print np.random.permutation(10) 
[2 8 4 9 1 6 7 3 0 5]
>>> np.random.seed(0) 
>>> print np.random.permutation(10) 
[2 8 4 9 1 6 7 3 0 5]
>>> np.random.seed(0) 
>>> print np.random.permutation(10) 
[2 8 4 9 1 6 7 3 0 5]
>>> np.random.seed(0) 
>>> print np.random.rand(4) 
[0.5488135  0.71518937 0.60276338 0.54488318]
>>> np.random.seed(0) 
>>> print np.random.rand(4) 
[0.5488135  0.71518937 0.60276338 0.54488318]

Jeśli jednak wywołasz go raz i użyjesz różnych funkcji losowych, wyniki nadal będą różne:

>>> import numpy as np
>>> np.random.seed(0) 
>>> perm = np.random.permutation(10)
>>> print perm 
[2 8 4 9 1 6 7 3 0 5]
>>> np.random.seed(0) 
>>> print np.random.permutation(10)
[2 8 4 9 1 6 7 3 0 5]
>>> print np.random.permutation(10) 
[3 5 1 2 9 8 0 6 7 4]
>>> print np.random.permutation(10) 
[2 3 8 4 5 1 0 6 9 7]
>>> print np.random.rand(4) 
[0.64817187 0.36824154 0.95715516 0.14035078]
>>> print np.random.rand(4) 
[0.87008726 0.47360805 0.80091075 0.52047748]

Jak zauważyłam, numpy.przypadkowe.seed (0) ustawia losowy seed na 0, więc pseudo losowe liczby, które otrzymujesz od losowego, zaczną się od tego samego punktu. W niektórych przypadkach może to być dobre do debugowania. Jednak po pewnym przeczytaniu wydaje się, że jest to niewłaściwy sposób, jeśli masz wątki, ponieważ nie jest to bezpieczne dla wątków.

From różnice-miedzy-numpy-random-and-random-random-in-python :

Dla numpy.przypadkowe.seed (), główną trudnością jest to, że nie jest thread-safe - oznacza to, że nie jest bezpieczny w użyciu, jeśli masz wiele różnych wątki wykonania, bo nie ma gwarancji, że zadziała, jeśli dwa różne wątki wykonują tę funkcję w tym samym czasie. Jeśli nie używasz wątków, a jeśli możesz racjonalnie oczekiwać, że nie będziesz musiał przepisywać swojego programu w ten sposób w przyszłości, numpy.przypadkowe.seed() Jeśli jest każdy powód, aby podejrzewać, że możesz potrzebować wątków w przyszłości, to znacznie bezpieczniej na dłuższą metę, aby zrobić to, co sugerowano, i zrobić lokalny przykład numpy.przypadkowe.Przypadkowa Klasa. Z tego co wiem, przypadkowe.przypadkowe.seed() jest bezpieczny dla wątków (a przynajmniej nie znalazłem żadnego dowody przeciwne).

Przykład jak to zrobić:

from numpy.random import RandomState
prng = RandomState()
print prng.permutation(10)
prng = RandomState()
print prng.permutation(10)
prng = RandomState(42)
print prng.permutation(10)
prng = RandomState(42)
print prng.permutation(10)

Może dać:

[3 0 4 6 8 2 1 9 7 5]

[1 6 9 0 2 7 8 3 5 4]

[8 1 5 0 7 2 9 4 3 6]

[8 1 5 0 7 2 9 4 3 6]

Na koniec zauważ, że mogą być przypadki, w których inicjalizacja na 0 (w przeciwieństwie do ziarna, które nie wszystkie bity 0) mogą skutkować nierównomiernymi rozkładami dla kilku pierwszych iteracji ze względu na sposób działania xor, ale to zależy od algorytmu i jest poza moimi obecnymi zmartwieniami i zakresem tego pytania.

Używałem tego bardzo często w sieciach neuronowych. Powszechnie wiadomo, że kiedy zaczynamy trenować sieć neuronową, losowo inicjalizujemy ciężary. Model jest szkolony na tych wagach na określonym zbiorze danych. Po wielu epok masz wyszkolony zestaw ciężarów.

Teraz Załóżmy, że chcesz ponownie trenować od podstaw lub chcesz przekazać model innym, aby odtworzyć swoje wyniki, wagi zostaną ponownie zainicjowane do liczb losowych, które w większości będą różne od wcześniejsze. Uzyskane ćwiczone ciężary po tej samej liczbie epok ( zachowując te same dane i inne parametry ) jak wcześniej będą się różnić. Problem polega na tym, że twój model nie jest już powtarzalny, ponieważ za każdym razem, gdy trenujesz swój model od podstaw, zapewnia Ci różne zestawy ciężarów. Dzieje się tak dlatego, że model jest inicjowany przez różne liczby losowe za każdym razem.

Co jeśli za każdym razem, gdy rozpoczynasz trening od zera, model jest inicjowany na ten sam zestaw losowych inicjalizacji wagi? W takim przypadku twój model może stać się powtarzalny. Jest to osiągane przez numpy.przypadkowe.nasiona (0) Wspominając seed () do określonej liczby, zawsze trzymasz się tego samego zbioru liczb losowych.

Wyobraź sobie, że pokazujesz komuś, jak kodować coś za pomocą kilku "przypadkowych" liczb. Za pomocą numpy seed mogą użyć tej samej liczby nasion i uzyskać ten sam zestaw "losowych" liczb.

Więc nie jest to zupełnie losowe, ponieważ algorytm wypluwa liczby, ale wygląda jak losowo wygenerowana wiązka.

Mam nadzieję dać naprawdę krótką odpowiedź:

seed spraw, aby (następna seria) liczby losowe były przewidywalne. Możesz myśleć, że za każdym razem po wywołaniu seed, to wstępnie definiuje numery serii i numpy random zachowuje iterator tego, a następnie za każdym razem, gdy otrzymasz losową liczbę, to po prostu wywoła get next.

Np.:

np.random.seed(2)
np.random.randn(2) # array([-0.41675785, -0.05626683])
np.random.randn(1) # array([-1.24528809])

np.random.seed(2)
np.random.randn(1) # array([-0.41675785])
np.random.randn(2) # array([-0.05626683, -1.24528809])

Możesz zauważyć, kiedy ustawiam to samo ziarno, bez względu na to, ile losowych liczb zażądasz od numpy za każdym razem, zawsze daje tę samą serię liczb, w tym przypadku czyli array([-0.41675785, -0.05626683, -1.24528809]).

Losowe ziarno określa punkt początkowy, gdy komputer generuje losowy ciąg liczb.

Załóżmy na przykład, że chcesz wygenerować losową liczbę w programie Excel(Uwaga: program Excel ustawia limit 9999 dla nasion). Jeśli w trakcie procesu wprowadzisz liczbę do losowego pola nasion, będziesz mógł ponownie użyć tego samego zestawu liczb losowych. Jeśli wpisałeś "77" w polu i wpisałeś " 77 " przy następnym uruchomieniu generatora liczb losowych, program Excel wyświetli ten sam zestaw losowych liczby. Jeśli wpiszesz "99", otrzymasz zupełnie inny zestaw liczb. Ale jeśli powrócisz do ziarna 77, otrzymasz ten sam zestaw liczb losowych, od których zacząłeś.

Na przykład "weź liczbę x, dodaj 900 + x ,a następnie odjmij 52."Aby rozpocząć proces, musisz podać numer początkowy, x (zalążek). Weźmy liczbę początkową 77:

Dodaj 900 + 77 = 977 Odjąć 52 = 925 Stosując ten sam algorytm, druga "losowa" liczba be:

900 + 925 = 1825 Odjąć 52 = 1773 Ten prosty przykład podąża za wzorcem, ale algorytmy generowania liczb komputerowych są znacznie bardziej skomplikowane

Wszystkie powyższe odpowiedzi pokazują implementację np.random.seed() w kodzie. Postaram się krótko wyjaśnić, dlaczego tak się dzieje. Komputery to maszyny zaprojektowane w oparciu o predefiniowane algorytmy. Każde wyjście z komputera jest wynikiem algorytmu zaimplementowanego na wejściu. Więc kiedy poprosimy komputer do generowania liczb losowych, na pewno są one losowe, ale komputer nie tylko wymyślił je losowo!

Więc kiedy napiszemy np.random.seed(any_number_here) algorytm wykaże konkretną zbiór liczb unikalnych dla argumentu any_number_here. To prawie tak, jakby konkretny zbiór liczb losowych można uzyskać, jeśli podamy poprawny argument. Ale to będzie wymagało od nas wiedzy o tym, jak działa algorytm, co jest dość żmudne.

Więc, na przykład, jeśli napiszę np.random.seed(10) konkretny zbiór liczb, które uzyskam, pozostanie taki sam, nawet jeśli wykonam tę samą linię po 10 latach, chyba że algorytm się zmieni.

Wszystkie liczby losowe wygenerowane po ustawieniu określonej wartości zalążkowej są takie same we wszystkich platformach / systemach.

Jest ładne wyjaśnienie w Numpy docs: https://docs.scipy.org/doc/numpy-1.15.1/reference/generated/numpy.random.RandomState.html odnosi się do Mersenne Twister pseudo-generatora liczb losowych . Więcej szczegółów na temat algorytmu tutaj: https://en.wikipedia.org/wiki/Mersenne_Twister

numpy.random.seed(0)
numpy.random.randint(10, size=5)

Daje to następujące wyjście: array([5, 0, 3, 3, 7]) Ponownie, jeśli uruchomimy ten sam kod, otrzymamy ten sam wynik.

Teraz jeśli zmienimy wartość zalążkową 0 Na 1 lub inne:

numpy.random.seed(1)
numpy.random.randint(10, size=5)

Daje to następujące Wyjście: array([5 8 9 5 0]) ale teraz wyjście nie jest takie samo jak powyżej.