Siri Belajar AI : Mari Kita Kenal Jaringan Neural Berturut (Recurrent NeuraL Network)

Bahagian 1

Jaringan neural berturut. Gambar dari

Dalam siri-siri yang lepas kita dah pun kenal jaringan neural dari asas. Kita juga dah mempelajari tentang model-model jaringan neural yang lain seperti jaringan neural berlingkar (convolutional neural network, CNN) dan juga sedikit sebanyak tentang transformer. Untuk kali ini kita akan cuba untuk mengenali jaringan neural berturut (recurrent neural network).

Dari Idea Pemenang Nobel

Dalam minggu yang lepas, seluruh dunia dikejutkan dengan berita pemenang Hadiah Nobel untuk Fizik. Yang mengejutkan orang ramai adalah hadiah itu diberikan kepada penyelidik kecerdasan buatan (AI), Geoffrey Hinton dan juga John Hopfield. Geoffrey Hinton memang dikenali oleh ramai penyelidik AI sebagai “Godfather of AI”. John Hopfield pula adalah salah seorang penyelidik AI yang bertanggungjawab membentuk Jaringan Hopfield (Hopfield Network). Dan Hopfield Network merupakan antara bentuk terawal RNN.

Gambar dari Yayasan Nobel

Apa itu Jaringan Neural Berturut?

Seperti namanaya, RNN ialah sejenis jaringan neural tiruan di mana sambungan antara unit membentuk satu kitaran berarah. Ini menjadikan RNN sangat sesuai untuk memproses data berurutan seperti siri masa, bahasa (narutal languange), atau apa-apa jenis yang berbentuk urutan (sequence). Apa yang membuatan RNN boleh memproses urutan adalah sistem keadaan tersembunyi (hidden state) yang membolehkan ia menyimpan memori. Dengan ini apa-apa keadaa urutan yang datang sebelum itu boleh diingat oleh RNN ketika latihan membolehkan ia secara teori menangkap nuansa dan juga konteks data yang berturut.

Arkitekture dan Matematik

Dalam RNN, pada setiap langkah masa atau time-step (t) , jaringan mempunyai:

Gambar dari Penulis

Persamaan kemas kini (update equations):

Gambar dari penulis

Persamaan kemas kini di atas membolehkan pemberat dari langkah masa sebelumnya (previous time-step) disimpan di dalam keadaan tersembunyi (hidden state)

Output pada masa t dibentuk melalui transformasi linear yang dilakukan mengikut persamaan matematik di bawah:

Gambar dari penulis

Mari kita bina jaringan neural berturut

Melihat fungsi matematik sahaja mungkin tak cukup untuk membuatkan kita faham. Ada eloknya kita tunjukkan bagaimana fungsi matematik ini diterjemahkan ke dalam kod. Katakanlah kita cuba untuk memproses data urutan sebegini

Gambar dari penulis

Untuk orang dewasa seperti kita, melihat sahaja nombor ni kita dah tahu yang ia akan diikuti oleh nombor 15. Sebab otak kita memang telah dilatih untuk melihat corak (pattern) dan pola. Disebabkan itulah kita cuba untuk mimik bagaimana otak kita berfikir dengan menggunakan jaringan neural berturut. Mari kita gunakan pola turutan di atas sebagai input kita

# kita bina urutan 3,6,9,12 dan bina ia sebagai satu tatasusunan vektor
import numpy as np
x = np.array([[3], [6], [9], [12]])

Seterusnya kita perlu tetapkan parameter jaringan neural kita

#mari kita tetapkan parameter jaringan neural kita
# Parameter RNN
N_x = 1  # Dimensi input 
N_h = 3  # Dimensi keadaan tersembunyi
N_y = 1  # Dimensi output

Kita ada 1 dimensi input, kerana kita akan masukkan satu demi satu nombor mengikut turutan. Kemudian kita ada 3 keadaan tersembunyi, yang berfungsi sebagai penyimpan memori yang boleh menyimpan sehingga 3 nombor sebelum. Dan kita akan keluarkan 1 sahaja output, bermaksud, nombor yang kita ingin ramalkan.

Seterusnya, kita perlu letakkan nilai awal untuk semua parameter yang lain seperti pemberat, bias dan juga nilai awal keadaan tersembunyi (hidden state). Untuk itu kita perlu gunakan fungsi python untuk mewujudkan nilai rambang bagi semua parameter jaringan neural kita.

Perlu diingatkan yang kita sepatutnya ada 3 lapisan tersembunyi. Yang pertama dengan lapisan input, yang kedua berhubung dengan lapisan yang pertama. Dan yang terakhir adalah lapisan tersembunyi yang mengeluarkan output. Berikut adalah kodnya seperti di bawah.

#mari kita letak semua nilai awal pada parameter kita
#kita masukkan nilai rambang dengan menggunakan fungsi 
# Matriks berat dari input ke keadaan tersembunyi (W_hx) dan dari keadaan tersembunyi ke keadaan tersembunyi (W_hh)
W_hx = np.random.randn(N_h, N_x)
W_hh = np.random.randn(N_h, N_h)

# Bias untuk keadaan tersembunyi
b_h = np.random.randn(N_h)

# Matriks berat dari keadaan tersembunyi ke output (W_hy) dan bias untuk output (b_y)
W_hy = np.random.randn(N_y, N_h)
b_y = np.random.randn(N_y)

# Inisialisasi keadaan tersembunyi awal (h_0)
h_t = np.random.randn(N_h)

Selepas ini, kita akan gunakan semua lapisan yang kita dah bentuk di atas untuk membentuk satu baris output. Kita akan gunakan proses iterasi, di mana ia akan melalui setiap langkah masa (setiap urutan nombor) dan diproses mengikut langkah masa.

# Simpan output untuk setiap langkah masa
outputs = []

# iterasi setiap operasi matematik melalui langkah masa yang berbeza
for t in range(len(x)):
    # Mengira keadaan tersembunyi untuk langkah masa t
    h_t = np.tanh(np.dot(W_hx, x[t]) + np.dot(W_hh, h_t) + b_h)
    
    # dapatkan nilai output (y_t)menggunakan transformasi linear
    y_t = np.dot(W_hy, h_t) + b_y
    outputs.append(y_t)

Kita dah masukkan data urutan kita ke dalam jaringan neural yang kita sudah bentuk menggunakan persamaan matematik yang kita sudah pelajari di atas. Kita bentuk satu matriks output bagi menyipmpan nilai matriks y tadi. Mari kita visualkan nilai matriks y yang sudah kita bentuk tadi dan lalukan pada jaringan neural kita. Kita plotkan hasilnya di atas graf.

import matplotlib.pyplot as plt
import matplotlib.animation as animation
# Tukarkan senarai output kepada array
outputs = np.array(outputs)

# Cetak output untuk setiap langkah masa
for t, y_t in enumerate(outputs):
    print(f"Output pada langkah masa {t + 1}: {y_t}")

# Visualisasi menggunakan matplotlib dan animasi GIF
fig, ax = plt.subplots(figsize=(10, 6))
ax.set_xlim(1, len(outputs) + 1)
ax.set_ylim(np.min(outputs) - 1, np.max(outputs) + 1)
ax.set_xlabel('Langkah Masa')
ax.set_ylabel('Nilai Output')
ax.set_title('Output RNN pada Setiap Langkah Masa untuk Urutan Yang Diberikan')
ax.grid(True)

line, = ax.plot([], [], marker='o', label='Output')
ax.legend()

def init():
    line.set_data([], [])
    return [line]

def update(frame):
    line.set_data(range(1, frame + 2), outputs[:frame + 1, 0])
    return [line]

ani = animation.FuncAnimation(fig, update, frames=len(outputs), init_func=init, blit=True, repeat=False)

# Simpan animasi sebagai GIF
ani.save('rnn_output_iq_prediction_augmented.gif', writer='pillow')

# Tunjukkan animasi
plt.show()

Gambar dari penulis

Eh, kenapa teruk benar? Para pembaca, yang kita lakukan di atas hanyalah memasukkan nilai input kita kepada jaringan neural berturut. Jaringan neural kita dilengkapi dengan pemberat, bias dan juga keadaan tersembunyi yang masih belum optimum. Ia hanya diberikan nilai rambang berdasarkan fungsi python yang kita masukkan (np.random). Disebabkan ini adalah nilai rambang, maka ia belum lagi dikemaskinikan melalui proses pembelajaran. Buat masa ini, mari kita cuba visualkan jaringan neural yang baru kita bina.

import graphviz
# Visualisasi rangkaian RNN menggunakan Graphviz
dot = graphviz.Digraph(comment='RNN Visualization')

# Menambah nod input
for t in range(len(x)):
    dot.node(f'Input_{t}', f'x{t+1}', shape='circle', color='blue')

# Menambah nod keadaan tersembunyi
for t in range(len(x)):
    for h in range(N_h):
        dot.node(f'Hidden_{t}_{h}', f'h{t+1}_{h+1}', shape='circle', color='red')
        if t > 0:
            for h_prev in range(N_h):
                dot.edge(f'Hidden_{t-1}_{h_prev}', f'Hidden_{t}_{h}', color='gray')

# Menambah nod output
for t in range(len(x)):
    dot.node(f'Output_{t}', f'y{t+1}', shape='circle', color='green')
    for h in range(N_h):
        dot.edge(f'Hidden_{t}_{h}', f'Output_{t}', color='green')

# Menambah sambungan input ke keadaan tersembunyi
for t in range(len(x)):
    for h in range(N_h):
        dot.edge(f'Input_{t}', f'Hidden_{t}_{h}', color='blue')

# Render grafik
dot.render('rnn_visualization', format='png', view=True)

Gambar dari penulis

Alhamdulillah, kita berjaya membentuk jaringan neural berturut kita, lengkap dengan tiga lapisan/keadaan tersembunyi. Setiap lapisan tersembunyi ini membawa nilai pemberat dari lapisan yang sebelumnya dan membantu membentuk nilai output. Tapi perlu diingatkan yang jaringan neural berturut yang kita bina ini hanyalah sehala. Belum ada proses pembelajaran lagi yang berlaku. Ini sesuatu yang kita pelajari dalam bahagian yang akan datang.

Jumpa lagi