Traffine I/O

Bahasa Indonesia

Apa itu RNN

RNN adalah singkatan dari Recurrent Neural Network. RNN adalah jenis jaringan saraf untuk memproses urutan data input, seperti data deret waktu atau bahasa alami, yang cocok untuk memproses data input kontinu, seperti data deret waktu atau bahasa alami.

RNN dapat mengambil urutan input, seperti data deret waktu, dan memprosesnya dengan mempertimbangkan ketergantungan temporal; RNN, tidak seperti jaringan saraf tradisional, dapat mempertahankan status untuk input mereka dan menyampaikan status sebelumnya ke langkah berikutnya. Hal ini memungkinkan RNN untuk menyimpan informasi masa lalu.

Dalam diagram RNN berikut, bagian dari output neural net pada waktu t digunakan sebagai input ke neural net pada waktu t+1. Dengan cara ini, memungkinkan adanya pertimbangan mengenai deret waktu.

RNN | 2
Understanding LSTM Networks

Arsitektur utama RNN meliputi RNN sederhana, LSTM, dan GRU. Arsitektur ini dapat menyimpan data input historis dan menggabungkannya dengan input saat ini untuk menghasilkan output. Arsitektur ini digunakan untuk tugas-tugas seperti prediksi data deret waktu, pemrosesan bahasa alami, pengenalan suara, dan keterangan gambar.

RNN | 3
A simple overview of RNN, LSTM and Attention Mechanism

Keadaan tersembunyi

Keadaan tersembunyi adalah istilah yang digunakan dalam bidang-bidang seperti pembelajaran mesin dan pemrosesan bahasa alami untuk merujuk pada keadaan yang tidak teramati yang dipertahankan oleh model secara internal.

Dalam RNN, keadaan tersembunyi dihitung dari input masa lalu dan outputnya sendiri dan digunakan untuk memprediksi dan memproses informasi tentang input berikutnya. RNN mengubah urutan input menjadi vektor tunggal dan memperbarui keadaan tersembunyi berdasarkan vektor tersebut. Kehadiran hidden state membuat model lebih ekspresif untuk masalah yang lebih kompleks dan memungkinkan prediksi yang memperhitungkan konsep deret waktu.

Keadaan tersembunyi pada t diwakili oleh sebuah fungsi dari keadaan tersembunyi pada t-1 dan masukan x_t.

h_t = g(h_{t-1}, x_t)

Karena output dari neuron berulang pada langkah waktu tertentu t adalah fungsi dari inputnya hingga langkah waktu t-1, mekanisme ini dapat dianggap sebagai semacam memori. Bagian dari jaringan saraf yang memiliki konsep menyimpan keadaan, bahkan sebagian, di seluruh langkah waktu biasanya disebut sebagai sel memori.

Hidden State
Understanding LSTM Networks

Perbedaan antara lapisan tersembunyi dan keadaan tersembunyi

Hidden state dan hidden layer adalah istilah yang digunakan dalam deep learning yang merupakan konsep yang mirip, tetapi memiliki arti yang sedikit berbeda.

Hidden state adalah istilah yang digunakan dalam model seperti RNN dan LSTM untuk menggambarkan keadaan internal, termasuk output pada waktu sebelumnya. dalam RNN, hidden state digunakan untuk memproses data deret waktu karena hal tersebut mempengaruhi input pada waktu berikutnya. Dalam LSTM, keadaan tersembunyi juga digunakan untuk menyimpan informasi masa lalu. Lapisan tersembunyi digunakan untuk memproses data deret waktu, karena mempengaruhi input pada waktu berikutnya.

Lapisan tersembunyi, di sisi lain, adalah istilah yang digunakan dalam jaringan saraf seperti multilayer perceptron (MLP) untuk merujuk pada lapisan perantara antara lapisan input dan output. Lapisan tersembunyi terdiri dari beberapa neuron, yang masing-masing menerima sinyal dari lapisan sebelumnya, menghitung jumlah tertimbang, dan menghasilkan output melalui fungsi aktivasi. Ketika ada beberapa lapisan tersembunyi, output dari setiap lapisan tersembunyi adalah input ke lapisan tersembunyi berikutnya atau lapisan output.

Dengan kata lain, hidden state dan hidden layer merupakan konsep yang merepresentasikan keadaan internal dalam machine learning, tetapi keduanya digunakan dalam konteks yang berbeda dan untuk tujuan yang berbeda. Hidden state digunakan untuk memproses data deret waktu, sedangkan hidden layer mewakili lapisan tengah dari jaringan saraf tiruan.

Tantangan RNN

Masalah utama yang membuat pelatihan RNN sangat lambat dan tidak efisien adalah masalah menghilangnya gradien Proses untuk jaringan saraf Feed Forward adalah sebagai berikut

  1. Keluarkan beberapa hasil dalam umpan maju
  2. gunakan hasil tersebut untuk menghitung nilai kerugian
  3. gunakan nilai kerugian tersebut untuk merambat balik dan menghitung gradien sehubungan dengan bobot
  4. menyebarkan kembali gradien ini sehubungan dengan bobot untuk menyempurnakan bobot dan meningkatkan kinerja jaringan

Karena bobot dimanipulasi sesuai dengan lapisan sebelumnya, gradien kecil cenderung menurun secara signifikan dengan setiap perubahan lapisan dan menjadi sangat dekat dengan nol, yang mengakibatkan pembelajaran yang buruk pada lapisan awal dan pembelajaran yang tidak efektif secara keseluruhan.

Hidden State | 3
A simple overview of RNN, LSTM and Attention Mechanism

Thus, if the gradient disappears, the RNN will not be able to learn long-range dependencies across time steps well. In other words, even if the initial input of a sequence is important to the overall context, it will not be important. Therefore, it cannot learn long sequences, resulting in short-term memory.

Hidden State | 4
Understanding LSTM Networks

Implementasi RNN

Berikut adalah beberapa contoh implementasi RNN menggunakan PyTorch dan Keras.

PyTorch

Berikut ini adalah contoh dasar penggunaan PyTorch untuk mendeskripsikan model RNN. Contoh ini menggunakan arsitektur RNN sederhana untuk melakukan tugas mengklasifikasikan kata.

import torch
import torch.nn as nn

class RNN(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(RNN, self).__init__()

        self.hidden_size = hidden_size
        self.rnn = nn.RNN(input_size, hidden_size)
        self.fc = nn.Linear(hidden_size, output_size)

    def forward(self, input):
        hidden = torch.zeros(1, 1, self.hidden_size)
        output, hidden = self.rnn(input, hidden)
        output = self.fc(output[-1, :, :])
        return output

Model ini mengambil kata-kata dengan ukuran input_size, melewatkannya melalui RNN dengan ukuran lapisan tersembunyi hidden_size, dan akhirnya menghasilkan keluaran klasifikasi dengan ukuran output_size. Kelas nn.RNN adalah lapisan RNN bawaan dalam PyTorch, dan nn.Linear mewakili lapisan yang terhubung sepenuhnya.

Metode forward melakukan penerusan pada input yang diberikan. Pertama, lapisan tersembunyi diinisialisasi. Kemudian, input dan keadaan tersembunyi saat ini diteruskan ke RNN untuk mendapatkan output dan keadaan tersembunyi yang baru. Akhirnya, hanya output dari langkah terakhir yang diambil dan dilewatkan melalui lapisan yang terhubung sepenuhnya untuk menghasilkan output klasifikasi.

Tautan di bawah ini adalah contoh lain.

https://pytorch.org/tutorials/intermediate/char_rnn_classification_tutorial.html

Keras

Mari kita implementasikan RNN dengan Keras.

Pertama, buatlah data pelatihan untuk RNN. Buat data dengan menambahkan noise pada fungsi sinus dengan angka acak.

%matplotlib inline

import numpy as np
import matplotlib.pyplot as plt


x_data = np.linspace(-2*np.pi, 2*np.pi)  # -2π to 2π
sin_data = np.sin(x_data)  + 0.1*np.random.randn(len(x_data))  # add noise to sin func

plt.style.use('ggplot')
plt.figure(figsize=(12, 8))
plt.plot(x_data, sin_data)
plt.show()

n_rnn = 10  # num of time series
n_sample = len(x_data)-n_rnn  # num of samples
x = np.zeros((n_sample, n_rnn))  # input
t = np.zeros((n_sample, n_rnn))  # label
for i in range(0, n_sample):
    x[i] = sin_data[i:i+n_rnn]
    t[i] = sin_data[i+1:i+n_rnn+1]

x = x.reshape(n_sample, n_rnn, 1)
t = t.reshape(n_sample, n_rnn, 1)

keras1

Membangun model RNN untuk memprediksi nilai masa depan dari data deret waktu sebelumnya.

from keras.models import Sequential
from keras.layers import Dense, SimpleRNN

batch_size = 8  # batch size
n_in = 1  # num of neurons in input layer
n_mid = 20  # num of neurons in mid layer
n_out = 1  # num of neurons in output layer

model = Sequential()
model.add(SimpleRNN(n_mid, input_shape=(n_rnn, n_in), return_sequences=True))
model.add(Dense(n_out, activation="linear"))
model.compile(loss="mean_squared_error", optimizer="sgd")
print(model.summary())

>> Model: "sequential"
>> _________________________________________________________________
>>  Layer (type)                Output Shape              Param #
>> =================================================================
>>  simple_rnn (SimpleRNN)      (None, 10, 20)            440
>>
>>  dense (Dense)               (None, 10, 1)             21
>>
>> =================================================================
>> Total params: 461
>> Trainable params: 461
>> Non-trainable params: 0
>> _________________________________________________________________
>> None

Pelatihan dilakukan dengan menggunakan model RNN yang telah dibangun.

history = model.fit(x, t, epochs=20, batch_size=batch_size, validation_split=0.1)

>> Epoch 1/20
>> 5/5 [==============================] - 2s 79ms/step - loss: 0.6561 - val_loss: 0.3590
>> Epoch 2/20
>> 5/5 [==============================] - 0s 13ms/step - loss: 0.4701 - val_loss: 0.2707
>> Epoch 3/20
>> 5/5 [==============================] - 0s 11ms/step - loss: 0.3694 - val_loss: 0.2240
>> Epoch 4/20
>> 5/5 [==============================] - 0s 11ms/step - loss: 0.3051 - val_loss: 0.1892
>> Epoch 5/20
>> 5/5 [==============================] - 0s 15ms/step - loss: 0.2613 - val_loss: 0.1696
>> Epoch 6/20
>> 5/5 [==============================] - 0s 13ms/step - loss: 0.2289 - val_loss: 0.1593
>> Epoch 7/20
>> 5/5 [==============================] - 0s 12ms/step - loss: 0.2058 - val_loss: 0.1501
>> Epoch 8/20
>> 5/5 [==============================] - 0s 12ms/step - loss: 0.1889 - val_loss: 0.1414
>> Epoch 9/20
>> 5/5 [==============================] - 0s 13ms/step - loss: 0.1750 - val_loss: 0.1345
>> Epoch 10/20
>> 5/5 [==============================] - 0s 14ms/step - loss: 0.1633 - val_loss: 0.1274
>> Epoch 11/20
>> 5/5 [==============================] - 0s 12ms/step - loss: 0.1540 - val_loss: 0.1233
>> Epoch 12/20
>> 5/5 [==============================] - 0s 12ms/step - loss: 0.1456 - val_loss: 0.1188
>> Epoch 13/20
>> 5/5 [==============================] - 0s 11ms/step - loss: 0.1377 - val_loss: 0.1133
>> Epoch 14/20
>> 5/5 [==============================] - 0s 12ms/step - loss: 0.1317 - val_loss: 0.1097
>> Epoch 15/20
>> 5/5 [==============================] - 0s 11ms/step - loss: 0.1256 - val_loss: 0.1063
>> Epoch 16/20
>> 5/5 [==============================] - 0s 11ms/step - loss: 0.1199 - val_loss: 0.1025
>> Epoch 17/20
>> 5/5 [==============================] - 0s 13ms/step - loss: 0.1152 - val_loss: 0.1025
>> Epoch 18/20
>> 5/5 [==============================] - 0s 11ms/step - loss: 0.1105 - val_loss: 0.0958
>> Epoch 19/20
>> 5/5 [==============================] - 0s 11ms/step - loss: 0.1065 - val_loss: 0.0932
>> Epoch 20/20
>> 5/5 [==============================] - 0s 15ms/step - loss: 0.1025 - val_loss: 0.0897

Periksa tren kesalahan.

loss = history.history['loss']
vloss = history.history['val_loss']

plt.figure(figsize=(12, 8))
plt.plot(np.arange(len(loss)), loss)
plt.plot(np.arange(len(vloss)), vloss)
plt.show()

keras2

Prediksi dibuat dengan menggunakan model terlatih RNN.

predicted = x[0].reshape(-1)

for i in range(0, n_sample):
    y = model.predict(predicted[-n_rnn:].reshape(1, n_rnn, 1))
    predicted = np.append(predicted, y[0][n_rnn-1][0])

plt.figure(figsize=(12, 8))
plt.plot(np.arange(len(sin_data)), sin_data, label="training")
plt.plot(np.arange(len(predicted)), predicted, label="predicted")
plt.legend()
plt.show()

keras3

Referensi

https://colah.github.io/posts/2015-08-Understanding-LSTMs/
https://medium.com/swlh/a-simple-overview-of-rnn-lstm-and-attention-mechanism-9e844763d07b
https://pytorch.org/tutorials/intermediate/char_rnn_classification_tutorial.html
https://github.com/spro/practical-pytorch/tree/master/char-rnn-classification
https://www.youtube.com/watch?v=UNmqTiOnRfg&ab_channel=Serrano.Academy

Ryusei Kakujo

researchgatelinkedingithub

Focusing on data science for mobility

Bench Press 100kg!