Tutorial RNN (Recurrent Neural Network): Contoh TensorFlow
Evelyn Clarke
Mengapa kita memerlukan Recurrent Neural Network (RNN)?
Jaringan Neural Berulang (RNN) memungkinkan Anda memodelkan unit memori untuk mempertahankan data dan memodelkan ketergantungan jangka pendek. Ini juga digunakan dalam peramalan deret waktu untuk mengidentifikasi korelasi dan pola data. Ini juga membantu menghasilkan hasil prediksi untuk data berurutan dengan memberikan perilaku serupa seperti otak manusia.
Struktur Jaringan Syaraf Tiruan relatif sederhana dan terutama tentang perkalian matriks. Pada langkah pertama, masukan dikalikan dengan bobot acak awalnya, dan bias, ditransformasikan dengan fungsi aktivasi dan nilai keluaran digunakan untuk membuat prediksi. Langkah ini memberikan gambaran seberapa jauh jarak jaringan dari kenyataan.
Metrik yang diterapkan adalah kerugian. Semakin tinggi fungsi kerugiannya, semakin bodoh modelnya. Untuk meningkatkan pengetahuan jaringan, diperlukan beberapa optimasi dengan mengatur bobot jaring. Penurunan gradien stokastik adalah metode yang digunakan untuk mengubah nilai bobot ke arah yang benar. Setelah penyesuaian dilakukan, jaringan dapat menggunakan kumpulan data lain untuk menguji pengetahuan barunya.
Untungnya, kesalahannya lebih rendah dari sebelumnya, namun tidak cukup kecil. Langkah optimasi dilakukan secara iteratif hingga error dapat diminimalkan, yakni tidak ada lagi informasi yang dapat diekstraksi.
Masalah dengan model jenis ini adalah tidak memiliki memori apa pun. Artinya input dan outputnya independen. Dengan kata lain, model tidak peduli dengan apa yang terjadi sebelumnya. Hal ini menimbulkan beberapa pertanyaan ketika Anda perlu memprediksi rangkaian waktu atau kalimat karena jaringan perlu memiliki informasi tentang data historis atau kata-kata masa lalu.
Untuk mengatasi masalah ini, jenis arsitektur baru telah dikembangkan: Jaringan Saraf Berulang (RNN)
Apa itu Jaringan Neural Berulang (RNN)?
A Jaringan Syaraf Berulang (RNN) adalah kelas dari Jaringan Saraf Buatan di mana hubungan antara node yang berbeda membentuk grafik terarah untuk memberikan perilaku dinamis temporal. Ini membantu untuk memodelkan data sekuensial yang berasal dari jaringan feedforward. Ia bekerja mirip dengan otak manusia untuk memberikan hasil prediksi.
Jaringan saraf berulang terlihat sangat mirip dengan jaringan saraf tradisional hanya saja keadaan memori ditambahkan ke neuron. Perhitungan untuk memasukkan memori itu sederhana.
Bayangkan sebuah model sederhana dengan hanya satu neuron yang diumpankan oleh sekumpulan data. Dalam jaringan saraf tradisional, model menghasilkan keluaran dengan mengalikan masukan dengan bobot dan fungsi aktivasi. Dengan RNN, keluaran ini dikirim kembali ke dirinya sendiri dalam jangka waktu tertentu. Kami memanggil langkah waktu lamanya waktu keluaran menjadi masukan perkalian matriks berikutnya.
Misalnya pada gambar di bawah, Anda dapat melihat jaringan terdiri dari satu neuron. Jaringan menghitung perkalian matriks antara input dan bobot dan menambahkan non-linearitas dengan fungsi aktivasi. Ini menjadi output pada t-1. Output ini merupakan input dari perkalian matriks kedua.
Di bawah ini, kami mengkodekan RNN sederhana di TensorFlow untuk memahami langkah dan juga bentuk outputnya.
Jaringan ini terdiri dari:
- Empat input
- Enam neuron
- langkah 2 kali
Jaringan akan berjalan seperti yang digambarkan pada gambar di bawah ini.
Jaringan ini disebut 'berulang' karena melakukan operasi yang sama di setiap kotak aktivasi. Jaringan menghitung bobot masukan dan keluaran sebelumnya untuk menggunakan fungsi aktivasi.
import numpy as np
import tensorflow as tf
n_inputs = 4
n_neurons = 6
n_timesteps = 2
The data is a sequence of a number from 0 to 9 and divided into three batches of data.
## Data
X_batch = np.array([
[[0, 1, 2, 5], [9, 8, 7, 4]], # Batch 1
[[3, 4, 5, 2], [0, 0, 0, 0]], # Batch 2
[[6, 7, 8, 5], [6, 5, 4, 2]], # Batch 3
])
Kita dapat membangun jaringan dengan placeholder untuk data, tahapan berulang, dan keluaran.
- Tentukan placeholder untuk data tersebut
X = tf.placeholder(tf.float32, [None, n_timesteps, n_inputs])
Sini:
- Tidak ada: Tidak diketahui dan akan sesuai dengan ukuran batch
- n_timesteps: Berapa kali jaringan mengirim output kembali ke neuron
- n_inputs: Jumlah input per batch
- Tentukan jaringan berulang
Seperti disebutkan pada gambar di atas, jaringan terdiri dari 6 neuron. Jaringan akan menghitung produk dua titik:
- Masukkan data dengan kumpulan bobot pertama (yaitu 6: sama dengan jumlah neuron)
- Keluaran sebelumnya dengan rangkaian bobot kedua (yaitu, 6: sesuai dengan jumlah keluaran)
Perhatikan bahwa, selama feedforward pertama, nilai output sebelumnya sama dengan nol karena kita tidak memiliki nilai apa pun.
Objek untuk membangun RNN adalah tf.contrib.rnn.BasicRNNCell dengan argumen num_units untuk menentukan jumlah input
basic_cell = tf.contrib.rnn.BasicRNNCell(num_units=n_neurons)
Sekarang setelah jaringan ditentukan, Anda dapat menghitung keluaran dan statusnya
outputs, states = tf.nn.dynamic_rnn(basic_cell, X, dtype=tf.float32)
Objek ini menggunakan loop internal untuk mengalikan matriks beberapa kali.
Perhatikan bahwa neuron berulang adalah fungsi dari semua masukan dari langkah waktu sebelumnya. Beginilah cara jaringan membangun memorinya sendiri. Informasi dari masa lalu dapat disebarkan di masa mendatang. Inilah keajaiban jaringan saraf berulang
## Define the shape of the tensor
X = tf.placeholder(tf.float32, [None, n_timesteps, n_inputs])
## Define the network
basic_cell = tf.contrib.rnn.BasicRNNCell(num_units=n_neurons)
outputs, states = tf.nn.dynamic_rnn(basic_cell, X, dtype=tf.float32)
init = tf.global_variables_initializer()
init = tf.global_variables_initializer()
with tf.Session() as sess:
init.run()
outputs_val = outputs.eval(feed_dict={X: X_batch})
print(states.eval(feed_dict={X: X_batch}))
[[ 0.38941205 -0.9980438 0.99750966 0.7892596 0.9978241 0.9999997 ]
[ 0.61096436 0.7255889 0.82977575 -0.88226104 0.29261455 -0.15597084]
[ 0.62091285 -0.87023467 0.99729395 -0.58261937 0.9811445 0.99969864]]
Untuk tujuan penjelasan, Anda mencetak nilai keadaan sebelumnya. Output yang dicetak di atas menunjukkan output dari keadaan terakhir. Sekarang cetak semua keluaran, Anda dapat melihat statusnya adalah keluaran sebelumnya dari setiap batch. Artinya, keluaran sebelumnya berisi informasi tentang keseluruhan rangkaian.e
print(outputs_val)
print(outputs_val.shape)
[[[-0.75934666 -0.99537754 0.9735819 -0.9722234 -0.14234993
-0.9984044 ]
[ 0.99975264 -0.9983206 0.9999993 -1. -0.9997506
-1. ]]
[[ 0.97486496 -0.98773265 0.9969686 -0.99950117 -0.7092863
-0.99998885]
[ 0.9326837 0.2673438 0.2808514 -0.7535883 -0.43337247
0.5700631 ]]
[[ 0.99628735 -0.9998728 0.99999213 -0.99999976 -0.9884324
-1. ]
[ 0.99962527 -0.9467421 0.9997403 -0.99999714 -0.99929446
-0.9999795 ]]]
(3, 2, 6)
Outputnya berbentuk (3, 2, 6):
- 3: Jumlah batch
- 2: Jumlah langkah waktu
- 6: Jumlah neuron
Optimalisasi jaringan saraf berulang identik dengan jaringan saraf tradisional. Anda akan melihat lebih detail cara melakukan optimasi kode di bagian selanjutnya dari tutorial Jaringan Neural Berulang ini.
Aplikasi RNN
RNN memiliki banyak kegunaan, terutama dalam memprediksi masa depan. Dalam industri keuangan, RNN dapat membantu dalam memprediksi harga saham atau tanda arah pasar saham (positif atau negatif).
RNN berguna untuk mobil otonom karena dapat menghindari kecelakaan mobil dengan mengantisipasi lintasan kendaraan.
RNN banyak digunakan dalam analisis teks, pembuatan teks gambar, analisis sentimen, dan terjemahan mesin. Misalnya, seseorang dapat menggunakan review film untuk memahami perasaan penonton setelah menonton film tersebut. Mengotomatiskan tugas ini sangat berguna ketika perusahaan film tidak memiliki cukup waktu untuk meninjau, memberi label, mengkonsolidasikan, dan menganalisis ulasan. Mesin dapat melakukan pekerjaan dengan tingkat akurasi yang lebih tinggi.
Keterbatasan RNN
Secara teori, RNN seharusnya membawa informasi terkini. Namun, cukup sulit untuk menyebarkan semua informasi ini jika jangka waktunya terlalu lama. Ketika suatu jaringan memiliki terlalu banyak lapisan dalam, jaringan tersebut menjadi tidak dapat dilatih. Masalah ini disebut: masalah gradien menghilang. Jika Anda ingat, jaringan saraf memperbarui bobot menggunakan algoritma penurunan gradien. Gradien semakin mengecil ketika jaringan turun ke lapisan yang lebih rendah.
Kesimpulannya, gradiennya tetap konstan, artinya tidak ada ruang untuk perbaikan. Model belajar dari perubahan gradien; perubahan ini mempengaruhi keluaran jaringan. Akan tetapi, jika perbedaan gradiennya terlalu kecil (yaitu bobotnya sedikit berubah), jaringan tidak dapat mempelajari apa pun sehingga menghasilkan output. Oleh karena itu, jaringan yang menghadapi masalah gradien hilang tidak dapat berkumpul menuju solusi yang baik.
Peningkatan LSTM
Untuk mengatasi potensi masalah hilangnya gradien yang dihadapi oleh RNN, tiga peneliti, Hochreiter, Schmidhuber, dan Bengio menyempurnakan RNN dengan arsitektur yang disebut Long Short-Term Memory (LSTM). Singkatnya, LSMT menyediakan informasi masa lalu yang relevan ke masa kini ke jaringan. Mesin menggunakan arsitektur yang lebih baik untuk memilih dan membawa informasi kembali ke masa mendatang.
Arsitektur LSTM tersedia di TensorFlow, tf.contrib.rnn.LSTMCell. LSTM berada di luar cakupan tutorial. Anda dapat merujuk ke situs resmi dokumentasi untuk informasi lebih lanjut
RNN dalam deret waktu
Dalam tutorial TensorFlow RNN ini, Anda akan menggunakan RNN dengan data deret waktu. Deret waktu bergantung pada waktu sebelumnya yang berarti nilai masa lalu mencakup informasi relevan yang dapat dipelajari oleh jaringan. Ide di balik prediksi deret waktu adalah untuk memperkirakan nilai masa depan dari suatu deret, misalnya harga saham, suhu, PDB, dan sebagainya.
Persiapan data untuk Keras RNN dan deret waktu bisa jadi sedikit rumit. Pertama-tama, tujuannya adalah untuk memprediksi nilai deret berikutnya, artinya, Anda akan menggunakan informasi masa lalu untuk memperkirakan nilai pada t + 1. Labelnya sama dengan barisan masukan dan bergeser satu periode ke depan. Kedua, jumlah input diatur ke 1, yaitu satu observasi per waktu. Terakhir, langkah waktu sama dengan urutan nilai numerik. Misalnya, jika Anda mengatur langkah waktu ke 10, urutan input akan kembali sepuluh kali berturut-turut.
Perhatikan grafik di bawah ini, kita telah merepresentasikan data deret waktu di sebelah kiri dan deret masukan fiktif di sebelah kanan. Anda membuat fungsi untuk mengembalikan kumpulan data dengan nilai acak untuk setiap hari dari Januari 2001 hingga Desember 2016
# To plot pretty figures
%matplotlib inline
import matplotlib
import matplotlib.pyplot as plt
import pandas as pd
def create_ts(start = '2001', n = 201, freq = 'M'):
rng = pd.date_range(start=start, periods=n, freq=freq)
ts = pd.Series(np.random.uniform(-18, 18, size=len(rng)), rng).cumsum()
return ts
ts= create_ts(start = '2001', n = 192, freq = 'M')
ts.tail(5)
Keluaran
2016-08-31 -93.459631 2016-09-30 -95.264791 2016-10-31 -95.551935 2016-11-30 -105.879611 2016-12-31 -123.729319 Freq: M, dtype: float64
ts = create_ts(start = '2001', n = 222)
# Left
plt.figure(figsize=(11,4))
plt.subplot(121)
plt.plot(ts.index, ts)
plt.plot(ts.index[90:100], ts[90:100], "b-", linewidth=3, label="A training instance")
plt.title("A time series (generated)", fontsize=14)
# Right
plt.subplot(122)
plt.title("A training instance", fontsize=14)
plt.plot(ts.index[90:100], ts[90:100], "b-", markersize=8, label="instance")
plt.plot(ts.index[91:101], ts[91:101], "bo", markersize=10, label="target", markerfacecolor='red')
plt.legend(loc="upper left")
plt.xlabel("Time")
plt.show()
Bagian kanan grafik menunjukkan semua rangkaian. Ini dimulai dari tahun 2001 dan berakhir pada tahun 2019. Tidak masuk akal untuk memasukkan semua data di jaringan, sebagai gantinya, Anda perlu membuat kumpulan data dengan panjang yang sama dengan langkah waktu. Batch ini akan menjadi variabel X. Variabel Y sama dengan X tetapi digeser satu periode (yaitu, Anda ingin memperkirakan t+1).
Kedua vektor mempunyai panjang yang sama. Anda dapat melihatnya di bagian kanan grafik di atas. Garis mewakili sepuluh nilai masukan X, sedangkan titik merah adalah sepuluh nilai label, Y. Perhatikan bahwa, label dimulai satu periode sebelum X dan berakhir satu periode setelahnya.
Buat RNN untuk memprediksi Rangkaian Waktu di TensorFlow
Nah pada pelatihan RNN kali ini saatnya membangun RNN pertama Anda untuk memprediksi rangkaian di atas. Anda perlu menentukan beberapa hyperparameter (parameter model, yaitu jumlah neuron, dll.) untuk model:
- Jumlah masukan: 1
- Langkah waktu (jendela dalam deret waktu): 10
- Jumlah neuron: 120
- Jumlah keluaran: 1
Jaringan Anda akan belajar dari urutan 10 hari dan berisi 120 neuron berulang. Anda memberi makan model dengan satu masukan, yaitu suatu hari. Jangan ragu untuk mengubah nilainya untuk melihat apakah modelnya membaik.
Sebelum membuat model, Anda perlu membagi kumpulan data menjadi kumpulan pelatihan dan kumpulan pengujian. Kumpulan data lengkap memiliki 222 titik data; Anda akan menggunakan 201 poin pertama untuk melatih model dan 21 poin terakhir untuk menguji model Anda.
Setelah Anda menentukan rangkaian pelatihan dan pengujian, Anda perlu membuat objek yang berisi batch. Dalam kumpulan ini, Anda memiliki nilai X dan nilai Y. Ingatlah bahwa nilai X tertinggal satu periode. Oleh karena itu, Anda menggunakan 200 observasi pertama dan langkah waktunya sama dengan 10. Objek X_batches harus berisi 20 batch berukuran 10*1. y_batches memiliki bentuk yang sama dengan objek X_batches tetapi dengan satu titik di depannya.
Langkah 1) Buat kereta dan uji
Pertama-tama, Anda mengubah deret tersebut menjadi a mati rasa array; lalu Anda menentukan jendelanya (yaitu, jumlah waktu jaringan akan belajar), jumlah masukan, keluaran, dan ukuran rangkaian kereta seperti ditunjukkan dalam contoh TensorFlow RNN di bawah ini.
series = np.array(ts) n_windows = 20 n_input = 1 n_output = 1 size_train = 201
Setelah itu, Anda cukup membagi array menjadi dua dataset.
## Split data train = series[:size_train] test = series[size_train:] print(train.shape, test.shape) (201,) (21,)
Langkah 2) Buat fungsi untuk mengembalikan X_batches dan y_batches
Untuk mempermudahnya, Anda bisa membuat fungsi yang mengembalikan dua array berbeda, satu untuk X_batches dan satu lagi untuk y_batches.
Mari kita tulis fungsi RNN TensorFlow untuk membuat batch.
Perhatikan bahwa, batch X tertinggal satu periode (kita ambil nilai t-1). Output fungsi tersebut harus memiliki tiga dimensi. Dimensi pertama sama dengan jumlah batch, dimensi kedua sama dengan ukuran jendela, dan dimensi terakhir sama dengan jumlah input.
Bagian tersulitnya adalah memilih titik data dengan benar. Untuk titik data X, Anda memilih observasi dari t = 1 hingga t =200, sedangkan untuk titik data Y, Anda mengembalikan observasi dari t = 2 hingga 201. Setelah Anda memiliki titik data yang benar, Anda dapat dengan mudah membentuknya kembali seri.
Untuk membuat objek dengan batch, Anda perlu membagi kumpulan data menjadi sepuluh batch dengan panjang yang sama (yaitu 20). Anda dapat menggunakan metode pembentukan ulang dan meneruskan -1 agar rangkaiannya serupa dengan ukuran batch. Nilai 20 adalah jumlah observasi per batch dan 1 adalah jumlah input.
Anda perlu melakukan langkah yang sama tetapi untuk labelnya.
Perhatikan bahwa, Anda perlu menggeser data ke berapa kali Anda ingin memperkirakan. Misalnya, jika Anda ingin memprediksi satu waktu ke depan, geser rangkaiannya sebanyak 1. Jika Anda ingin memperkirakan dua hari, geser datanya sebanyak 2.
x_data = train[:size_train-1]: Select all the training instance minus one day
X_batches = x_data.reshape(-1, windows, input): create the right shape for the batch e.g (10, 20, 1)
def create_batches(df, windows, input, output):
## Create X
x_data = train[:size_train-1] # Select the data
X_batches = x_data.reshape(-1, windows, input) # Reshape the data
## Create y
y_data = train[n_output:size_train]
y_batches = y_data.reshape(-1, windows, output)
return X_batches, y_batches
Sekarang fungsinya sudah ditentukan, Anda dapat memanggilnya untuk membuat batch seperti yang ditunjukkan pada contoh RNN di bawah.
X_batches, y_batches = create_batches(df = train,
windows = n_windows,
input = n_input,
output = n_output)
Anda dapat mencetak bentuknya untuk memastikan dimensinya benar.
print(X_batches.shape, y_batches.shape) (10, 20, 1) (10, 20, 1)
Anda perlu membuat set pengujian hanya dengan satu kumpulan data dan 20 observasi.
Perhatikan bahwa, Anda memperkirakan hari demi hari, artinya nilai prediksi kedua akan didasarkan pada nilai sebenarnya pada hari pertama (t+1) dari kumpulan data pengujian. Faktanya, nilai sebenarnya akan diketahui.
Jika Anda ingin memperkirakan t+2 (yaitu, dua hari ke depan), Anda perlu menggunakan nilai prediksi t+1; jika Anda ingin memprediksi t+3 (tiga hari ke depan), Anda perlu menggunakan nilai prediksi t+1 dan t+2. Masuk akal bahwa sulit untuk memprediksi secara akurat beberapa hari ke depan.
X_test, y_test = create_batches(df = test, windows = 20,input = 1, output = 1) print(X_test.shape, y_test.shape) (10, 20, 1) (10, 20, 1)
Baiklah, ukuran batch Anda sudah siap, Anda dapat membangun arsitektur RNN. Ingat, Anda memiliki 120 neuron berulang.
Langkah 3) Bangun model
Untuk membuat model, Anda perlu mendefinisikan tiga bagian:
- Variabel dengan tensor
- RNN
- Kerugian dan optimalisasi
Langkah 3.1) Variabel
Anda perlu menentukan variabel X dan y dengan bentuk yang sesuai. Langkah ini sepele. Tensor memiliki dimensi yang sama dengan objek X_batches dan y_batches.
Misalnya, tensor X adalah placeholder (Lihat tutorial Pengenalan aliran tensor untuk menyegarkan pikiran Anda tentang deklarasi variabel) memiliki tiga dimensi:
- Catatan: ukuran batch
- n_windows: Panjang jendela. Yaitu, berapa kali model melihat ke belakang
- n_input: Jumlah masukan
Hasilnya adalah:
tf.placeholder(tf.float32, [None, n_windows, n_input])
## 1. Construct the tensors X = tf.placeholder(tf.float32, [None, n_windows, n_input]) y = tf.placeholder(tf.float32, [None, n_windows, n_output])
Langkah 3.2) Buat RNNnya
Pada bagian kedua contoh RNN TensorFlow ini, Anda perlu menentukan arsitektur jaringan. Seperti sebelumnya, Anda menggunakan objek BasicRNNCell dan dynamic_rnn dari estimator TensorFlow.
## 2. create the model basic_cell = tf.contrib.rnn.BasicRNNCell(num_units=r_neuron, activation=tf.nn.relu) rnn_output, states = tf.nn.dynamic_rnn(basic_cell, X, dtype=tf.float32)
Bagian selanjutnya sedikit lebih rumit tetapi memungkinkan komputasi lebih cepat. Anda perlu mengubah keluaran proses menjadi lapisan padat dan kemudian mengonversinya lagi agar memiliki dimensi yang sama dengan masukan.
stacked_rnn_output = tf.reshape(rnn_output, [-1, r_neuron]) stacked_outputs = tf.layers.dense(stacked_rnn_output, n_output) outputs = tf.reshape(stacked_outputs, [-1, n_windows, n_output])
Langkah 3.3) Buat kerugian dan optimasi
Pengoptimalan model bergantung pada tugas yang Anda lakukan. Pada tutorial sebelumnya tentang CNN, tujuan Anda adalah mengklasifikasikan gambar, dalam tutorial RNN ini tujuannya sedikit berbeda. Anda diminta membuat prediksi pada variabel kontinu dibandingkan dengan suatu kelas.
Perbedaan ini penting karena akan mengubah masalah optimasi. Masalah optimasi untuk variabel kontinu adalah meminimalkan mean square error. Untuk membuat metrik ini di TF, Anda dapat menggunakan:
- tf.reduce_sum(tf.square(output – y))
Sisa kode RNN sama seperti sebelumnya; Anda menggunakan pengoptimal Adam untuk mengurangi kerugian (yaitu, MSE):
- tf.train.AdamOptimizer(tingkat_belajar=tingkat_belajar)
- pengoptimal.minimalkan (kerugian)
Selesai, Anda dapat mengemas semuanya, dan model Anda siap untuk dilatih.
tf.reset_default_graph() r_neuron = 120 ## 1. Construct the tensors X = tf.placeholder(tf.float32, [None, n_windows, n_input]) y = tf.placeholder(tf.float32, [None, n_windows, n_output]) ## 2. create the model basic_cell = tf.contrib.rnn.BasicRNNCell(num_units=r_neuron, activation=tf.nn.relu) rnn_output, states = tf.nn.dynamic_rnn(basic_cell, X, dtype=tf.float32) stacked_rnn_output = tf.reshape(rnn_output, [-1, r_neuron]) stacked_outputs = tf.layers.dense(stacked_rnn_output, n_output) outputs = tf.reshape(stacked_outputs, [-1, n_windows, n_output]) ## 3. Loss + optimization learning_rate = 0.001 loss = tf.reduce_sum(tf.square(outputs - y)) optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate) training_op = optimizer.minimize(loss) init = tf.global_variables_initializer()
Anda akan melatih model menggunakan 1500 epoch dan mencetak kerugian setiap 150 iterasi. Setelah model dilatih, Anda mengevaluasi model pada set pengujian dan membuat objek yang berisi prediksi seperti yang ditunjukkan pada contoh Jaringan Neural Berulang di bawah ini.
iteration = 1500
with tf.Session() as sess:
init.run()
for iters in range(iteration):
sess.run(training_op, feed_dict={X: X_batches, y: y_batches})
if iters % 150 == 0:
mse = loss.eval(feed_dict={X: X_batches, y: y_batches})
print(iters, "\tMSE:", mse)
y_pred = sess.run(outputs, feed_dict={X: X_test})
0 MSE: 502893.34
150 MSE: 13839.129
300 MSE: 3964.835
450 MSE: 2619.885
600 MSE: 2418.772
750 MSE: 2110.5923
900 MSE: 1887.9644
1050 MSE: 1747.1377
1200 MSE: 1556.3398
1350 MSE: 1384.6113
Terakhir dalam tutorial Pembelajaran Mendalam RNN ini, Anda dapat memplot nilai sebenarnya dari rangkaian tersebut dengan nilai prediksi. Jika model Anda diperbaiki, nilai prediksi harus ditempatkan di atas nilai sebenarnya.
Seperti yang Anda lihat, model ini masih bisa ditingkatkan. Terserah Anda untuk mengubah hiperparameter seperti jendela, ukuran batch dari jumlah neuron berulang.
plt.title("Forecast vs Actual", fontsize=14)
plt.plot(pd.Series(np.ravel(y_test)), "bo", markersize=8, label="Actual", color='green')
plt.plot(pd.Series(np.ravel(y_pred)), "r.", markersize=8, label="Forecast", color='red')
plt.legend(loc="lower left")
plt.xlabel("Time")
plt.show()
Ringkasan
Jaringan saraf berulang adalah arsitektur yang tangguh untuk menangani deret waktu atau analisis teks. Keluaran dari status sebelumnya adalah umpan balik untuk mempertahankan memori jaringan dari waktu ke waktu atau rangkaian kata.
Di TensorFlow, Anda dapat menggunakan kode berikut untuk melatih Jaringan Neural Berulang TensorFlow untuk deret waktu:
Parameter model
n_windows = 20 n_input = 1 n_output = 1 size_train = 201
Tentukan modelnya
X = tf.placeholder(tf.float32, [None, n_windows, n_input]) y = tf.placeholder(tf.float32, [None, n_windows, n_output]) basic_cell = tf.contrib.rnn.BasicRNNCell(num_units=r_neuron, activation=tf.nn.relu) rnn_output, states = tf.nn.dynamic_rnn(basic_cell, X, dtype=tf.float32) stacked_rnn_output = tf.reshape(rnn_output, [-1, r_neuron]) stacked_outputs = tf.layers.dense(stacked_rnn_output, n_output) outputs = tf.reshape(stacked_outputs, [-1, n_windows, n_output])
Bangun optimasi
learning_rate = 0.001 loss = tf.reduce_sum(tf.square(outputs - y)) optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate) training_op = optimizer.minimize(loss)
Latih modelnya
init = tf.global_variables_initializer()
iteration = 1500
with tf.Session() as sess:
init.run()
for iters in range(iteration):
sess.run(training_op, feed_dict={X: X_batches, y: y_batches})
if iters % 150 == 0:
mse = loss.eval(feed_dict={X: X_batches, y: y_batches})
print(iters, "\tMSE:", mse)
y_pred = sess.run(outputs, feed_dict={X: X_test})
