Dapatkah jaringan saraf digunakan untuk memprediksi nomor acak semu berikutnya?

Apakah mungkin untuk memberi makan jaringan saraf output dari generator angka acak dan mengharapkannya mempelajari fungsi hashing (atau generator), sehingga dapat memprediksi apa yang akan menjadi nomor pseudo-acak berikutnya yang dihasilkan ?

Apakah sesuatu seperti ini sudah ada? Jika penelitian sudah dilakukan terkait hal ini atau sesuatu (dengan prediksi angka pseudo-acak), adakah yang bisa mengarahkan saya ke sumber daya yang tepat?

Saat ini, saya melihat perpustakaan ini dan tautan terkaitnya. https://github.com/Vict0rSch/deep_learning/tree/master/keras/recurrent

Jika kita berbicara tentang RNG yang sempurna, jawabannya adalah tidak . Tidak mungkin untuk memprediksi angka yang benar-benar acak, jika tidak maka tidak akan benar-benar acak.

Ketika kita berbicara tentang pseudo RNG, segalanya berubah sedikit. Bergantung pada kualitas PRNG, masalahnya berkisar dari yang mudah hingga yang hampir mustahil. PRNG yang sangat lemah seperti XKCD yang diterbitkan tentu saja dapat dengan mudah diprediksi oleh jaringan saraf dengan sedikit pelatihan. Tetapi di dunia nyata segalanya terlihat berbeda.

Jaringan saraf dapat dilatih untuk menemukan pola tertentu dalam sejarah bilangan acak yang dihasilkan oleh PRNG untuk memprediksi bit berikutnya. Semakin kuat PRNG, semakin banyak input neuron yang diperlukan, dengan asumsi Anda menggunakan satu neuron untuk setiap bit keacakan sebelumnya yang dihasilkan oleh PRNG. Semakin tidak dapat diprediksi PRNG, semakin banyak data yang diperlukan untuk menemukan semacam pola. Untuk PRNG yang kuat, ini tidak layak.

Pada catatan positif, akan sangat membantu jika Anda dapat menghasilkan jumlah pola pelatihan yang sewenang-wenang untuk jaringan saraf, dengan asumsi bahwa Anda memiliki kendali atas PRNG dan dapat menghasilkan angka acak sebanyak yang Anda inginkan.

Karena PRNG modern adalah komponen kunci untuk kriptografi, penelitian ekstensif telah dilakukan untuk memverifikasi bahwa mereka "cukup acak" untuk menahan serangan prediksi seperti itu. Oleh karena itu saya cukup yakin bahwa tidak mungkin dengan sumber daya komputasi yang tersedia saat ini untuk membangun jaringan saraf untuk berhasil menyerang PRNG yang dianggap aman untuk kriptografi.

Penting juga dicatat bahwa tidak perlu memprediksi dengan tepat keluaran PRNG untuk memecahkan kriptografi - mungkin cukup untuk memprediksi bit berikutnya dengan kepastian lebih dari 50% untuk melemahkan implementasi secara signifikan. Jadi jika Anda dapat membangun jaringan saraf yang memprediksi bit PRNG berikutnya (dianggap aman untuk kriptografi) dengan tingkat keberhasilan 55%, Anda mungkin akan membuat berita utama berita keamanan cukup lama.

Menjadi pemula yang lengkap dalam pembelajaran mesin, saya melakukan percobaan ini (menggunakan Scikit-belajar):

• Menghasilkan sejumlah besar (N) ekstraksi pseudo-acak, menggunakan fungsi python random.choices untuk memilih angka N dari 90.

• Melatih classifier MLP dengan data pelatihan yang disusun sebagai berikut:

  • dengan sampel: X <- lotteryResults [i: i + 100], Y <- lotteryResults [i]

  Dalam praktiknya, saya mengarahkan ke suatu fungsi yang diberi angka N, dapat memprediksi yang berikutnya.

• Meminta classifikator terlatih untuk memprediksi angka yang tersisa.

Hasil:

• tentu saja, pengklasifikasi memperoleh skor kemenangan yang sebanding dengan salah satu tebakan acak atau teknik lain yang tidak didasarkan pada jaringan saraf (saya membandingkan hasil dengan beberapa pengklasifikasi yang tersedia di perpustakaan scikit-learning)

• namun, jika saya menghasilkan ekstraksi lotre pseudo-acak dengan fungsi distribusi tertentu, maka angka yang diprediksi oleh jaringan saraf secara kasar dihasilkan dengan kurva distribusi yang sama (jika Anda memetakan kejadian angka acak dan prediksi jaringan saraf, Anda dapat melihat bahwa keduanya memiliki tren yang sama, bahkan jika dalam kurva prediseksi ada banyak lonjakan, jadi mungkin jaringan saraf dapat belajar tentang distribusi angka pseudo-acak?

• Jika saya mengurangi ukuran pelatihan yang ditetapkan di bawah batas tertentu, saya melihat bahwa classifier mulai memprediksi selalu beberapa angka yang sama, yang merupakan yang paling sering dalam generasi pseudo-acak. Anehnya (atau mungkin tidak) perilaku ini tampaknya sedikit meningkatkan skor kemenangan.

Pertanyaan lama, tapi saya pikir itu layak untuk satu jawaban praktis. Saya kebetulan menemukannya tepat setelah melihat panduan bagaimana membangun jaringan saraf seperti itu, menunjukkan gema randint python sebagai contoh . Ini adalah kode terakhir tanpa penjelasan terperinci, masih cukup sederhana dan bermanfaat jika tautannya 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))

Saya baru saja mencoba dan itu memang bekerja dengan cukup baik! Butuh hanya beberapa menit di netbook lama saya yang lambat. Ini hasil saya sendiri, berbeda dari tautan di atas dan Anda dapat melihat kecocokan tidak sempurna, jadi saya kira kriteria keluar agak terlalu permisif:

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

Jika generator angka acak psuedo mengeluarkan angka maka dalam analisis angka-angka ini Anda akan dapat menentukan algoritma yang menghasilkannya karena angka-angka tidak acak mereka ditentukan oleh algoritma itu dan bukan kebetulan. Jika dunia terdiri dari hukum-hukum fisik yang dapat dipahami dan direplikasi daripada keacakan yang kita amati dalam peristiwa-peristiwa itu tergantung pada hukum-hukum fisik itu. dan generator psuedo tidak lagi, dan merupakan keacakan aktual yang dari definisinya tidak dapat ditentukan, dan menyajikan sebuah paradoks. Bagaimana aturan dapat menciptakan keacakan berdasarkan definisi tentu persepsi kita tentang keacakan peristiwa yang kita amati adalah kiasan dan sebenarnya kepastian yang tidak dapat kita prediksi.

Menambah apa yang dikatakan Demento, tingkat keacakan dalam Algoritma Generasi Angka Acak adalah masalah utama. Berikut ini adalah beberapa desain yang dapat membuat RNG lemah:
Urutan Tersembunyi
Misalkan ini adalah beberapa urutan karakter yang dihasilkan sebelumnya: (Sebagai contoh, untuk penggunaan praktis rentang yang lebih besar, digunakan)

lwjVJA
Ls3Ajg
xpKr+A
XleXYg
9hyCzA
jeFuNg
JaZZoA

Awalnya, Anda tidak dapat mengamati pola apa pun di dalam generasi tetapi mengubahnya menjadi pengkodean Base64 dan kemudian ke hex, kami mendapatkan yang berikut ini:

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

Sekarang jika kita kurangi setiap angka dari yang sebelumnya, kita dapatkan ini:

FF97C4EB6A
97C4EB6A
FF97C4EB6A
97C4EB6A
FF97C4EB6A
FF97C4EB6A

Ini menunjukkan bahwa algoritma hanya menambahkan 0x97C4EB6A ke nilai sebelumnya, memotong hasilnya ke angka 32-bit, dan Base64-mengkodekan data.
Di atas adalah contoh dasar. Algoritma dan sistem ML saat ini cukup mampu untuk mempelajari dan memprediksi pola yang lebih kompleks.

Ketergantungan Waktu
Beberapa algoritma RNG menggunakan waktu sebagai input utama untuk menghasilkan angka acak, terutama yang dibuat oleh pengembang sendiri untuk digunakan dalam aplikasi mereka.

Setiap kali algoritma RNG yang lemah diimplementasikan yang tampaknya bersifat stokastik, mereka dapat diekstrapolasi ke depan atau ke belakang dengan akurasi sempurna jika tersedia data yang memadai.