Un réseau de neurones peut-il être utilisé pour prédire le prochain nombre pseudo aléatoire?

Est-il possible d'alimenter un réseau de neurones en sortie d'un générateur de nombres aléatoires et de s'attendre à ce qu'il apprenne la fonction de hachage (ou générateur), afin qu'il puisse prédire quel sera le prochain nombre pseudo-aléatoire généré ?

Est-ce que quelque chose comme ça existe déjà? Si des recherches sont déjà effectuées sur ce sujet ou sur quelque chose de similaire (à la prédiction de nombres pseudo-aléatoires), quelqu'un peut-il me diriger vers les bonnes ressources?

Actuellement, je regarde cette bibliothèque et ses liens connexes. https://github.com/Vict0rSch/deep_learning/tree/master/keras/recurrent

Si nous parlons d'un RNG parfait, la réponse est clairement non . Il est impossible de prédire un nombre vraiment aléatoire, sinon il ne serait pas vraiment aléatoire.

Quand on parle de pseudo RNG, les choses changent un peu. Selon la qualité du PRNG, le problème varie de facile à presque impossible. Un PRNG très faible comme celui publié par XKCD pourrait bien sûr être facilement prédit par un réseau neuronal peu entraîné. Mais dans le monde réel, les choses semblent différentes.

Le réseau neuronal pourrait être formé pour trouver certains modèles dans l'histoire des nombres aléatoires générés par un PRNG pour prédire le bit suivant. Plus le PRNG est fort, plus il faut de neurones d'entrée, en supposant que vous utilisez un neurone pour chaque bit de caractère aléatoire antérieur généré par le PRNG. Moins le PRNG est prévisible, plus il faudra de données pour trouver une sorte de modèle. Pour les PRNG forts, cela n'est pas possible.

Sur une note positive, il est utile que vous puissiez générer une quantité arbitraire de modèles d'entraînement pour le réseau neuronal, en supposant que vous avez le contrôle sur le PRNG et que vous pouvez produire autant de nombres aléatoires que vous le souhaitez.

Étant donné que les PRNG modernes sont un élément clé de la cryptographie, des recherches approfondies ont été menées pour vérifier qu'ils sont "suffisamment aléatoires" pour résister à de telles attaques de prédiction. Par conséquent, je suis à peu près sûr qu'il n'est pas possible, avec les ressources informatiques actuellement disponibles, de créer un réseau neuronal pour attaquer avec succès un PRNG considéré comme sécurisé pour la cryptographie.

Il convient également de noter qu'il n'est pas nécessaire de prévoir exactement la sortie d'un PRNG pour briser la cryptographie - il pourrait être suffisant de prédire le bit suivant avec une certitude d'un peu plus de 50% pour affaiblir considérablement une implémentation. Donc, si vous êtes en mesure de construire un réseau de neurones qui prédit le prochain bit d'un PRNG (considéré comme sécurisé pour la cryptographie) avec un taux de réussite de 55%, vous ferez probablement les gros titres des actualités de sécurité pendant un bon moment.

Étant un débutant complet dans l'apprentissage automatique, j'ai fait cette expérience (en utilisant Scikit-learn):

• Généré un grand nombre (N) d'extractions pseudo-aléatoires, en utilisant la fonction python random.choices pour sélectionner N nombres sur 90.

• Formé un classificateur MLP avec des données de formation composées comme suit:

  • ième échantillon: X <- lotteryResults [i: i + 100], Y <- lotteryResults [i]

  En pratique, je visais une fonction qui, étant donné N nombres, pourrait prédire la suivante.

• A demandé au classificateur qualifié de prédire les chiffres restants.

Résultats:

• bien sûr, le classificateur a obtenu un score gagnant comparable à celui de la devinette aléatoire ou d'autres techniques non basées sur des réseaux de neurones (j'ai comparé les résultats avec plusieurs classificateurs disponibles dans les bibliothèques scikit-learn)

• cependant, si je génère les extractions de loterie pseudo-aléatoires avec une fonction de distribution spécifique, alors les nombres prédits par le réseau neuronal sont grossièrement générés avec la même courbe de distribution (si vous tracez les occurrences des nombres aléatoires et des prédictions du réseau neuronal, vous pouvez voir que les deux ont la même tendance, même si dans la courbe de prédicytions il y a beaucoup de pics. Alors peut-être que le réseau neuronal est capable d'en apprendre plus sur les distributions de nombres pseudo-aléatoires?

• Si je réduis la taille de l'ensemble d'apprentissage sous une certaine limite, je vois que le classificateur commence à prédire toujours les mêmes quelques nombres, qui sont parmi les plus fréquents dans la génération pseudo-aléatoire. Curieusement (ou peut-être pas), ce comportement semble augmenter légèrement le score gagnant.

Vieille question, mais je pensais que ça valait une réponse pratique. Il m'est arrivé de tomber dessus juste après avoir regardé un guide sur la façon de construire un tel réseau de neurones, démontrant l'écho du randint de python à titre d' exemple . Voici le code final sans explication détaillée, toujours assez simple et utile au cas où le lien se déconnecte:

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

Je viens d'essayer et ça marche assez bien! Ça m'a pris quelques minutes sur mon vieux netbook lent. Voici ma propre sortie, différente du lien ci-dessus et vous pouvez voir que la correspondance n'est pas parfaite, donc je suppose que les critères de sortie sont un peu trop permissifs:

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

Si un générateur de nombres aléatoires pseudo jette des nombres, alors dans l'analyse de ces nombres, vous pourrez déterminer l'algorithme qui les a produits car les nombres ne sont pas aléatoires, ils sont déterminés par cet algorithme et ne sont pas le hasard. Si le monde est composé de lois physiques qui peuvent être comprises et reproduites, le hasard apparent que nous observons dans les événements est dû à ces lois physiques. et le générateur de pseudo n'est plus, et c'est le hasard réel qui, de par sa définition, est indéterminable, et présente un paradoxe. Comment les règles peuvent-elles créer un caractère aléatoire par définition, notre perception apparente du caractère aléatoire des événements que nous observons est certainement une allusion et est en fait une certitude que nous ne pouvons pas prédire.

En plus de ce que Demento a dit, l'étendue du caractère aléatoire dans l'algorithme de génération de nombres aléatoires est le problème clé. Voici quelques conceptions qui peuvent rendre le RNG faible:
Séquences cachées
Supposons que ce soit les quelques séquences de caractères générées précédentes: (Juste un exemple, pour une utilisation pratique, une plus grande plage est utilisée)

lwjVJA
Ls3Ajg
xpKr+A
XleXYg
9hyCzA
jeFuNg
JaZZoA

Au départ, vous ne pouvez pas observer de modèle dans les générations, mais en les changeant en encodage Base64 puis en hexadécimal, nous obtenons ce qui suit:

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

Maintenant, si nous soustrayons chaque nombre du précédent, nous obtenons ceci:

FF97C4EB6A
97C4EB6A
FF97C4EB6A
97C4EB6A
FF97C4EB6A
FF97C4EB6A

Cela indique que l'algorithme ajoute simplement 0x97C4EB6A à la valeur précédente, tronque le résultat en un nombre 32 bits et Base64-code les données.
Ce qui précède est un exemple de base. Les algorithmes et systèmes ML d'aujourd'hui sont suffisamment capables pour apprendre et prédire des modèles plus complexes.

Dépendance temporelle
Certains algorithmes RNG utilisent le temps comme entrée principale pour générer des nombres aléatoires, en particulier ceux créés par les développeurs eux-mêmes pour être utilisés dans leur application.

Chaque fois que des algorithmes RNG faibles sont implémentés et semblent stochastiques, ils peuvent être extrapolés en avant ou en arrière avec une précision parfaite dans le cas où un ensemble de données suffisant est disponible.