Czy sieć neuronowa może służyć do przewidywania kolejnej liczby pseudolosowej?

Czy możliwe jest zasilanie sieci neuronowej wyjściem z generatora liczb losowych i oczekiwanie, że nauczy się funkcji mieszania (lub generatora), aby mógł przewidzieć, jaka będzie kolejna generowana liczba pseudolosowa ?

Czy coś takiego już istnieje? Jeśli badania zostały już przeprowadzone w tej sprawie lub w związku z czymś (z przewidywaniem liczb pseudolosowych), czy ktoś może wskazać mi odpowiednie zasoby?

Obecnie patrzę na tę bibliotekę i powiązane linki. https://github.com/Vict0rSch/deep_learning/tree/master/keras/recurrent

Jeśli mówimy o idealnym RNG, odpowiedź brzmi „ nie” . Nie można przewidzieć prawdziwie losowej liczby, w przeciwnym razie nie byłby to prawdziwy los.

Kiedy mówimy o pseudo RNG, rzeczy się nieco zmieniają. W zależności od jakości PRNG problem waha się od łatwego do prawie niemożliwego. Bardzo słaby PRNG, taki jak opublikowany XKCD, można oczywiście łatwo przewidzieć za pomocą sieci neuronowej o niewielkim stopniu szkolenia. Ale w prawdziwym świecie rzeczy wyglądają inaczej.

Sieć neuronowa może zostać przeszkolona do znajdowania pewnych wzorców w historii liczb losowych generowanych przez PRNG w celu przewidywania następnego bitu. Im silniejszy staje się PRNG, tym więcej neuronów wejściowych jest wymaganych, zakładając, że używasz jednego neuronu na każdy bit wcześniejszej losowości wygenerowanej przez PRNG. Im mniej przewidywalny jest PRNG, tym więcej danych będzie potrzebnych do znalezienia jakiegoś wzorca. W przypadku silnych PRNG nie jest to możliwe.

Pozytywnie, pomocne jest wygenerowanie dowolnej liczby wzorców treningowych dla sieci neuronowej, przy założeniu, że masz kontrolę nad PRNG i możesz wygenerować dowolną liczbę losową.

Ponieważ współczesne PRNG są kluczowym składnikiem kryptografii, przeprowadzono szeroko zakrojone badania w celu sprawdzenia, czy są one „wystarczająco losowe”, aby wytrzymać takie ataki predykcyjne. Dlatego jestem pewien, że przy obecnie dostępnych zasobach obliczeniowych nie jest możliwe zbudowanie sieci neuronowej w celu skutecznego ataku na PRNG, który jest uważany za bezpieczny dla kryptografii.

Warto również zauważyć, że nie jest konieczne dokładne przewidywanie wyniku PRNG, aby złamać kryptografię - może być wystarczające, aby przewidzieć następny bit z pewnością nieco ponad 50%, aby znacznie osłabić implementację. Więc jeśli jesteś w stanie zbudować sieć neuronową, która przewiduje następny kawałek PRNG (uważany za bezpieczny dla kryptografii) z 55% wskaźnikiem sukcesu, prawdopodobnie trafisz na nagłówki wiadomości o bezpieczeństwie przez dłuższy czas.

Będąc kompletnym nowicjuszem w uczeniu maszynowym, przeprowadziłem ten eksperyment (używając Scikit-learn):

• Wygenerowano dużą liczbę (N) ekstrakcji pseudolosowych, używając funkcji random.choices w Pythonie do wybrania N liczb spośród 90.

• Przeszkoliłem klasyfikatora MLP z danymi treningowymi złożonymi w następujący sposób:

  • i próbka: X <- wyniki loterii [i: i + 100], Y <- wyniki loterii [i]

  W praktyce dążyłem do funkcji, która dała N liczb, mogłem przewidzieć następną.

• Poprosił przeszkolonego klasyfikatora, aby przewidział pozostałe liczby.

Wyniki:

• oczywiście klasyfikator uzyskał zwycięski wynik porównywalny z losowym zgadywaniem lub innymi technikami nieopartymi na sieciach neuronowych (porównałem wyniki z kilkoma klasyfikatorami dostępnymi w bibliotekach scikit-learn)

• jeśli jednak wygeneruję pseudolosowe ekstrakcje loterii z określoną funkcją rozkładu, wówczas liczby przewidywane przez sieć neuronową są generowane z grubsza z tą samą krzywą rozkładu (jeśli wykreślisz występowanie liczb losowych i prognoz sieci neuronowej, widać, że oba mają ten sam trend, nawet jeśli na krzywej predykcji jest wiele pików. Może więc sieć neuronowa jest w stanie dowiedzieć się o rozkładach liczb pseudolosowych?

• Jeśli zmniejszę rozmiar zestawu treningowego poniżej pewnego limitu, widzę, że klasyfikator zaczyna przewidywać zawsze te same liczby, które należą do najczęstszych w generowaniu pseudolosowym. O dziwo (a może nie) to zachowanie wydaje się nieznacznie zwiększać wygrany wynik.

Stare pytanie, ale pomyślałem, że warto jedną praktyczną odpowiedź. Zdarzyło mi się, że natknąłem się na nią zaraz po przejrzeniu przewodnika, jak zbudować taką sieć neuronową, demonstrując echo randintonu pytona jako przykład . Oto końcowy kod bez szczegółowego wyjaśnienia, wciąż dość prosty i przydatny w przypadku, gdy link przejdzie w tryb offline:

from random import randint
from numpy import array
from numpy import argmax
from pandas import concat
from pandas import DataFrame
from keras.models import Sequential
from keras.layers import LSTM
from keras.layers import Dense

# generate a sequence of random numbers in [0, 99]
def generate_sequence(length=25):
    return [randint(0, 99) for _ in range(length)]

# one hot encode sequence
def one_hot_encode(sequence, n_unique=100):
    encoding = list()
    for value in sequence:
        vector = [0 for _ in range(n_unique)]
        vector[value] = 1
        encoding.append(vector)
    return array(encoding)

# decode a one hot encoded string
def one_hot_decode(encoded_seq):
    return [argmax(vector) for vector in encoded_seq]

# generate data for the lstm
def generate_data():
    # generate sequence
    sequence = generate_sequence()
    # one hot encode
    encoded = one_hot_encode(sequence)
    # create lag inputs
    df = DataFrame(encoded)
    df = concat([df.shift(4), df.shift(3), df.shift(2), df.shift(1), df], axis=1)
    # remove non-viable rows
    values = df.values
    values = values[5:,:]
    # convert to 3d for input
    X = values.reshape(len(values), 5, 100)
    # drop last value from y
    y = encoded[4:-1,:]
    return X, y

# define model
model = Sequential()
model.add(LSTM(50, batch_input_shape=(5, 5, 100), stateful=True))
model.add(Dense(100, activation='softmax'))
model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['acc'])
# fit model
for i in range(2000):
    X, y = generate_data()
    model.fit(X, y, epochs=1, batch_size=5, verbose=2, shuffle=False)
    model.reset_states()
# evaluate model on new data
X, y = generate_data()
yhat = model.predict(X, batch_size=5)
print('Expected:  %s' % one_hot_decode(y))
print('Predicted: %s' % one_hot_decode(yhat))

Właśnie próbowałem i to naprawdę działa całkiem dobrze! Zajęło mi to tylko kilka minut na moim starym wolnym netbooku. Oto moje własne wyniki, inne niż powyższy link, i widać, że dopasowanie nie jest idealne, więc przypuszczam, że kryteria wyjścia są nieco zbyt liberalne:

...
 - 0s - loss: 0.2545 - acc: 1.0000
Epoch 1/1
 - 0s - loss: 0.1845 - acc: 1.0000
Epoch 1/1
 - 0s - loss: 0.3113 - acc: 0.9500
Expected:  [14, 37, 0, 65, 30, 7, 11, 6, 16, 19, 68, 4, 25, 2, 79, 45, 95, 92, 32, 33]
Predicted: [14, 37, 0, 65, 30, 7, 11, 6, 16, 19, 68, 4, 25, 2, 95, 45, 95, 92, 32, 33]

Jeśli generator liczb losowych w psuedo wyrzuca liczby, wówczas w analizie tych liczb będziesz mógł określić algorytm, który je wytworzył, ponieważ liczby nie są losowe, są one określane przez ten algorytm i nie są przypadkowe. Jeśli świat składa się z praw fizycznych, które można zrozumieć i powielić, to pozorna przypadkowość, którą obserwujemy w wydarzeniach, zależy od tych praw fizycznych. a generator psuedo nie jest już i jest faktyczną przypadkowością, która z jego definicji jest nieokreślona i stanowi paradoks. W jaki sposób reguły mogą tworzyć losowość z definicji, z pewnością nasze pozorne postrzeganie losowości obserwowanych zdarzeń jest aluzją i jest w rzeczywistości pewnością, której nie jesteśmy w stanie przewidzieć.

Oprócz tego, co powiedział Demento, kluczową kwestią jest zakres losowości w algorytmie generowania liczb losowych. Poniżej znajdują się niektóre projekty, które mogą osłabić RNG:
Sekwencje ukryte
Załóżmy, że jest to kilka poprzednich wygenerowanych sekwencji znaków: (Dla przykładu użyto większego zakresu)

lwjVJA
Ls3Ajg
xpKr+A
XleXYg
9hyCzA
jeFuNg
JaZZoA

Początkowo nie można zaobserwować żadnego wzorca w pokoleniach, ale zmieniając go na kodowanie Base64, a następnie na hex, otrzymujemy:

9708D524
2ECDC08E
C692ABF8
5E579762
F61C82CC
8DE16E36
25A659A0

Teraz, jeśli odejmiemy każdą liczbę od poprzedniej, otrzymamy:

FF97C4EB6A
97C4EB6A
FF97C4EB6A
97C4EB6A
FF97C4EB6A
FF97C4EB6A

Wskazuje to, że algorytm po prostu dodaje 0x97C4EB6A do poprzedniej wartości, obcina wynik do liczby 32-bitowej i koduje Base64 dane.
Powyżej jest podstawowym przykładem. Dzisiejsze algorytmy i systemy ML są w stanie uczyć się i przewidywać bardziej złożone wzorce.

Zależność czasowa
Niektóre algorytmy RNG wykorzystują czas jako główny wkład do generowania liczb losowych, zwłaszcza te stworzone przez samych programistów do wykorzystania w ich aplikacji.

Ilekroć wdrażane są słabe algorytmy RNG, które wydają się stochastyczne, można je ekstrapolować do przodu lub do tyłu z idealną dokładnością, jeśli dostępny jest wystarczający zestaw danych.