Menyelesaikan Persamaan Matematika Dasar Menggunakan RNN [Dengan Contoh Coding]

Diterbitkan: 2020-12-07

Jika hidup memberi Anda RNN, buatlah kalkulator

Jaringan Syaraf Tiruan Berulang adalah salah satu jaringan syaraf tiruan klasik, di mana hubungan antar node membentuk graf berarah sekuensial. RNN terkenal dengan aplikasi seperti pengenalan suara, pengenalan tulisan tangan, dll karena memori keadaan internalnya untuk memproses urutan panjang variabel.

RNN selanjutnya diklasifikasikan menjadi dua jenis. Yang pertama adalah impuls hingga yang jaringan sarafnya berupa grafik asiklik berarah di mana satu node dapat dihubungkan dengan satu atau lebih node yang berada di depan tanpa terlihat siklus dalam jaringan. Yang lain adalah impuls tak terbatas yang jaringan sarafnya dalam bentuk grafik siklik terarah yang tidak dapat dibuka menjadi jaringan saraf umpan-maju.

Daftar isi

Apa yang akan kita lakukan?

Mari kita buat model yang memprediksi output dari ekspresi aritmatika. Misalnya, jika saya memberikan input '11+88', maka model harus memprediksi kata berikutnya dalam urutan sebagai '99'. Input dan output adalah urutan karakter karena RNN berhubungan dengan data sekuensial.

Sekarang merancang arsitektur model tampak seperti tugas sederhana jika dibandingkan dengan pengumpulan dataset. Menghasilkan data atau mengumpulkan kumpulan data adalah tugas yang berat karena model AI kelaparan data memerlukan cukup banyak data untuk akurasi yang dapat diterima.

Jadi model ini dapat diimplementasikan dalam 6 langkah dasar:

  1. Menghasilkan data
  2. Membangun model
  3. Vektorisasi dan De-vektorisasi data
  4. Membuat kumpulan data
  5. Melatih model
  6. Menguji model

Sebelum kita masuk ke dalam mengimplementasikan model, mari kita impor semua library yang diperlukan.

impor numpy sebagai np

impor tensorflow sebagai tf

dari tensorflow.keras.models import Sequential

dari tensorflow.keras.layers impor Padat, Dropout, SimpleRNN, RepeatVector, TimeDistributed

dari tensorflow.keras.callbacks impor EarlyStopping, LambdaCallback

dari termcolor impor berwarna

1. Menghasilkan Data

Mari kita definisikan string char yang berisi semua karakter yang kita butuhkan untuk menulis persamaan aritmatika dasar. Jadi, string terdiri dari semua karakter dari 0-9 dan semua operator aritmatika seperti /, *, +, -, .(desimal).

Kami tidak dapat secara langsung memasukkan data numerik ke dalam model kami, kami harus meneruskan data dalam bentuk tensor. Mengonversi string dalam data menjadi vektor enkode satu-panas akan memberi kita kinerja model yang dioptimalkan. Vektor satu-panas yang disandikan adalah larik dengan panjang yang sama dengan panjang string karakter kami, setiap vektor satu-panas hanya memiliki satu di indeks masing-masing karakter yang ada di setiap string.

Sebagai contoh, katakanlah string karakter kita adalah '0123456789', dan jika kita ingin mengkodekan string seperti '12' maka vektor one-hot adalah [ [0,1,0,0,0,0,0,0 ,0,0], [0,0,1,0,0,0,0,0,0,0] ]. Untuk melakukan itu kita perlu membuat dua kamus dengan satu indeks sebagai kunci dan karakter sebagai nilai dan yang lainnya sebagai sebaliknya.

char_string = ' 0123456789/*+-. '

num_chars = len (char_string)

character_to_index = dict ((c, i) for i, c in enumerate (char_string))

index_to_character = dict ((i, c) untuk i, c dalam enumerate (char_string))

Sekarang mari kita tulis fungsi yang mengembalikan persamaan aritmatika acak beserta hasil persamaan tersebut.

pembagian def (n, d):

kembali n / d jika d != 0 lain 0

def datagen ():

random1 = np.random.randint(rendah = 0 ,tinggi = 100 )

random2 = np.random.randint(rendah = 0 ,tinggi = 100 )

op = np.random.randint(rendah = 0 , tinggi = 4 )

jika op == 1 :

arith = str (acak1) + ' + ' + str (acak2)

res = str (acak1 + acak2)

elif op == 1 :

arith = str (acak1) + ' ' + str (acak2)

res = str (acak1 acak2)

elif op == 2 :

arith = str (acak1) + ' * ' + str (acak2)

res = str (acak1 * acak2)

lain :

arith = str (acak1) + ' / ' + str (acak2)

res = str ( bulat (pembagian (acak1, acak2), 2 ))

kembalikan arith, res

Baca Juga: Ide Proyek Neural Network yang Menarik

2. Membangun Model

Model akan memiliki encoder dan decoder. Encoder adalah model RNN sederhana dengan bentuk input sebagai (None,num_chars) dan 128 unit tersembunyi, alasan mengapa kami memilih unit tersembunyi sebagai 32.64.128, dll adalah karena kinerja CPU atau GPU yang lebih baik dengan unit tersembunyi sebagai kekuatan 2.

Encoder kami akan menjadi jaringan yang sepenuhnya terhubung dan outputnya akan diumpankan kembali ke jaringan, begitulah cara kerja RNN. Lapisan RNN menggunakan aktivasi 'tanh' secara default, kami tidak akan mengubahnya karena paling sesuai dengan encoder. Output dari layer ini akan menjadi satu vektor dan untuk mendapatkan satu vektor dari keseluruhan output kita akan menggunakan layer RepeatVector() dengan jumlah waktu yang diperlukan sebagai parameter.

Sekarang vektor keluaran akan memiliki esensi dari masukan yang diberikan, dan vektor ini akan dimasukkan ke dalam dekoder.

Dekoder terdiri dari lapisan RNN sederhana dan ini akan menghasilkan urutan output karena kita membutuhkan lapisan RNN untuk mengembalikan urutan yang diprediksi, kita akan menandai 'return_sequences' sebagai True. Dengan menetapkan 'return_sequences' sebagai True, lapisan RNN akan mengembalikan urutan yang diprediksi untuk setiap langkah waktu (banyak ke banyak RNN).

Output dari layer RNN ini dimasukkan ke dalam layer Dense dengan 'num_chars' jumlah unit tersembunyi dan kita akan menggunakan aktivasi softmax karena kita membutuhkan probabilitas setiap karakter. Sebelum kita men-deploy layer Dense, kita perlu meringkas layer ini menjadi layer TimeDistributed karena kita perlu men-deploy layer Dense untuk output dari setiap langkah waktu.

hidden_units = 128

max_time_steps = 5 #kami meng-hardcoding output menjadi 5 karakter

model def ():

model = Berurutan()

model.add(SimpleRNN(hidden_units, input_shape = ( None , num_chars)))

model.add(RepeatVector(max_time_steps))

model.add(SimpleRNN(hidden_units, return_sequences = True ))

model.add(TimeDistributed(Dense(num_chars, activation = ' softmax ' )))

kembali model

model = model()

model.ringkasan()

model.compile(loss = ' categorical_crossentropy ' , pengoptimal = ' adam ' , metrics = [ ' akurasi ' ])

Arsitektur model akan seperti yang ditunjukkan di atas

Harus Dibaca: Tutorial Jaringan Saraf

3. Membuat Vektor dan De-vektorisasi Data

Mari kita definisikan fungsi untuk membuat vektorisasi dan de-vektorisasi data.

Berikut adalah fungsi untuk membuat vektor ekspresi aritmatika dan hasilnya bersama-sama.

def vectorize (arith, res):

x = np.zeros((max_time_steps, num_chars))

y = np.zeros((max_time_steps, num_chars))

x_remaining = max_time_steps len (arith)

y_remaining = max_time_steps len (res)

untuk i, c dalam enumerate (arith):

x[x_remaining + i, character_to_index[c]] = 1

untuk i dalam jangkauan (x_remaining):

x[i, character_to_index[ ' 0 ' ]] = 1

untuk i, c dalam enumerate (res):

y[y_remaining + i, character_to_index[c]] = 1

untuk i dalam jangkauan (y_remaining):

y[i, character_to_index[ ' 0 ' ]] = 1

kembali x, y

Demikian pula, inilah fungsi untuk de-vektorisasi string. Karena output yang kami terima adalah vektor probabilitas, kami akan menggunakan np.argmax() untuk memilih karakter dengan probabilitas tertinggi. Sekarang kamus index_to_character digunakan untuk melacak kembali karakter pada indeks itu.

def devectorize (masukan):

res = [index_to_character[np.argmax(vec)] for i, vec in enumerate ( input )]

kembali ' ' .join(res)

Sekarang batasan yang kita miliki dengan fungsi 'devectorize' adalah, itu akan mengisi karakter tambahan dengan nol. Misalnya, jika vektor input adalah ('1-20', '-19') maka output yang di-vektorkan adalah ('01-20', '00-19'). Kita perlu menjaga nol ekstra empuk ini. Mari kita menulis fungsi untuk melepaskan string.

def pengupasan (masukan):

bendera = Salah

keluaran = ' '

untuk c di masukan :

jika tidak tandai dan c == ' 0 ' :

melanjutkan

jika c == ' + ' atau c == ' ' atau c == ' * ' atau c == ' / ' atau c == ' . ' :

bendera = Salah

lain :

bendera = benar

keluaran += c

kembali keluaran

4. Membuat Kumpulan Data

Sekarang setelah kita selesai mendefinisikan fungsi untuk menghasilkan data, mari gunakan fungsi itu dan buat kumpulan data dengan banyak pasangan (ekspresi aritmatika, hasil) seperti itu.

def create_dataset (jumlah_persamaan):

x_train = np.zeros((num_equations, max_time_steps, num_chars))

y_train = np.zeros((num_equations, max_time_steps, num_chars))

untuk i dalam jangkauan (num_equations):

e, l = datagen()

x, y = vektorisasi (e, l)

x_kereta[i] = x

y_train[i] = y

kembali x_train, y_train

5. Melatih Model

Mari buat kumpulan data 50.000 sampel yang merupakan jumlah yang wajar untuk melatih model kelaparan data kita, kita akan menggunakan 25% dari data ini untuk validasi. Juga, mari buat panggilan balik untuk interupsi pelatihan cerdas jika akurasi tetap tidak berubah selama 8 epoch. Ini dapat dicapai dengan mengatur parameter kesabaran ke 8.

x_train, y_train = buat_set data( 50000 )

simple_logger = LambdaCallback(

on_epoch_end = lambda e, l: print ( ' {:.2f} ' .format(l[ ' val_accuracy ' ]), end = ' _ ' )

)

early_stopping = EarlyStopping(monitor = ' val_loss ' , kesabaran = 8 )

model.fit(x_train, y_train, epochs = 100 , validasi_split = 0.25 , verbose = 0 ,

panggilan balik = [simple_logger, early_stopping])

6. Menguji Model

Sekarang mari kita uji model kita dengan membuat kumpulan data berukuran 30.

x_test, y_test = create_dataset(num_equations = 20 )

preds = model.predict(x_test)

full_seq_acc = 0

untuk saya, pred di enumerate (preds):

pred_str = pengupasan(devectorize(pred))

y_test_str = pengupasan(devectorize(y_test[i]))

x_test_str = pengupasan(devectorize(x_test[i])))

col = ' hijau ' jika pred_str == y_test_str lain ' merah '

full_seq_acc += 1 / len (preds) * int (pred_str == y_test_str)

outstring = ' Input: {}, Output: {}, Prediksi: {} ' .format(x_test_str, y_test_str, pred_str)

print (berwarna (outstring, col))

print ( ' \n Akurasi urutan penuh: {:.3f} % ' .format( 100 * full_seq_acc))

Outputnya akan seperti berikut

Kita dapat melihat akurasinya sedikit buruk di sini, bagaimanapun kita dapat mengoptimalkannya dengan mengutak-atik beberapa hyperparameter seperti jumlah unit tersembunyi, pemisahan validasi, jumlah epoch, dll.

Kesimpulan

Kami telah memahami alur kerja dasar RNN, memahami bahwa RNN paling cocok untuk data sekuensial, menghasilkan kumpulan data persamaan aritmatika acak, mengembangkan model sekuensial untuk memprediksi output dari ekspresi aritmatika dasar, melatih model tersebut dengan kumpulan data yang kami telah membuat, dan akhirnya menguji model itu dengan kumpulan data kecil yang belum pernah dilihat model sebelumnya.

Jika Anda tertarik untuk mempelajari lebih lanjut tentang RNN, pembelajaran mesin, lihat PG Diploma IIIT-B & upGrad dalam Pembelajaran Mesin & AI yang dirancang untuk para profesional yang bekerja dan menawarkan 450+ jam pelatihan ketat, 30+ studi kasus & tugas, Status Alumni IIIT-B, 5+ proyek batu penjuru praktis & bantuan pekerjaan dengan perusahaan-perusahaan top.

Apa saja jenis jaringan saraf dalam pembelajaran mesin?

Dalam pembelajaran mesin, jaringan saraf tiruan pada dasarnya adalah model komputasi yang telah dirancang menyerupai otak manusia. Ada berbagai jenis jaringan saraf tiruan yang digunakan pembelajaran mesin berdasarkan perhitungan matematis yang perlu dicapai. Jaringan saraf ini adalah bagian dari berbagai teknik pembelajaran mesin yang belajar dari data dengan cara yang berbeda. Beberapa jenis jaringan saraf yang paling banyak digunakan adalah – jaringan saraf berulang – memori jangka pendek, jaringan saraf feedforward – neuron buatan, jaringan saraf fungsi radial basis, jaringan saraf pengorganisasian diri Kohonen, jaringan saraf convolutional, dan jaringan saraf modular, diantara yang lain.

Apa keuntungan dari jaringan saraf berulang?

Jaringan saraf berulang adalah salah satu jaringan saraf tiruan yang paling umum digunakan dalam pembelajaran mendalam dan pembelajaran mesin. Dalam model jaringan saraf jenis ini, hasil yang diperoleh dari langkah sebelumnya diumpankan sebagai input ke langkah berikutnya. Jaringan saraf berulang hadir dengan beberapa keuntungan seperti – ia dapat menyimpan setiap bit informasi dari waktu ke waktu, termasuk input sebelumnya, yang membuatnya ideal untuk prediksi deret waktu. Jenis ini adalah contoh terbaik dari memori panjang-pendek. Juga, jaringan saraf berulang menyediakan lingkungan piksel konstruktif dengan menggunakan lapisan konvolusi.

Bagaimana jaringan saraf digunakan dalam aplikasi dunia nyata?

Jaringan saraf tiruan adalah bagian integral dari pembelajaran mendalam, yang sekali lagi merupakan cabang super khusus dari pembelajaran mesin dan kecerdasan buatan. Jaringan saraf digunakan di berbagai industri untuk mencapai berbagai tujuan penting. Beberapa aplikasi dunia nyata yang paling menarik dari jaringan saraf tiruan termasuk peramalan pasar saham, pengenalan wajah, auto-piloting kinerja tinggi dan diagnosis kesalahan dalam industri kedirgantaraan, analisis serangan bersenjata dan lokasi objek di sektor pertahanan, pemrosesan gambar, penemuan obat dan deteksi penyakit di sektor kesehatan, verifikasi tanda tangan, analisis tulisan tangan, prakiraan cuaca dan prakiraan tren media sosial, antara lain.