Tutorial Jaringan Syaraf Tiruan dengan Contoh TensorFlow ANN

Apa itu Jaringan Syaraf Tiruan?

An Jaringan Saraf Buatan (ANN) adalah sistem komputer yang terinspirasi oleh jaringan saraf biologis untuk menciptakan otak buatan berdasarkan kumpulan unit terhubung yang disebut neuron buatan. Ini dirancang untuk menganalisis dan memproses informasi sebagai manusia. Jaringan Syaraf Tiruan memiliki kemampuan belajar mandiri untuk memberikan hasil yang lebih baik seiring dengan semakin banyaknya data yang tersedia.

Jaringan Syaraf Tiruan (JST) terdiri dari empat objek utama:

• Lapisan: semua pembelajaran terjadi di lapisan. Ada 3 lapisan 1) Input 2) Tersembunyi dan 3) Output
• Fitur dan label: Input data ke jaringan (fitur) dan output dari jaringan (label)
• Fungsi kerugian: Metrik yang digunakan untuk memperkirakan kinerja fase pembelajaran
• Pengoptimal: Meningkatkan pembelajaran dengan memperbarui pengetahuan di jaringan

Jaringan saraf akan mengambil data masukan dan memasukkannya ke dalam kumpulan lapisan. Jaringan perlu mengevaluasi kinerjanya dengan fungsi kerugian. Fungsi kerugian memberi jaringan gambaran tentang jalur yang perlu diambil sebelum jaringan menguasai pengetahuan. Jaringan perlu meningkatkan pengetahuannya dengan bantuan pengoptimal.

Jika Anda melihat gambar di atas, Anda akan memahami mekanisme yang mendasarinya.

Program ini mengambil beberapa nilai masukan dan memasukkannya ke dalam dua lapisan yang terhubung sepenuhnya. Bayangkan Anda memiliki soal matematika, hal pertama yang Anda lakukan adalah membaca bab terkait untuk menyelesaikan soal tersebut. Anda menerapkan pengetahuan baru Anda untuk memecahkan masalah. Ada kemungkinan besar Anda tidak akan mendapatkan skor yang baik. Hal yang sama berlaku untuk jaringan. Saat pertama kali melihat data dan membuat prediksi, tidak akan cocok dengan data sebenarnya.

Untuk meningkatkan pengetahuannya, jaringan menggunakan pengoptimal. Dalam analogi kami, pengoptimal dapat dianggap sebagai membaca ulang bab tersebut. Anda mendapatkan wawasan/pelajaran baru dengan membaca lagi. Demikian pula, jaringan menggunakan pengoptimal, memperbarui pengetahuannya, dan menguji pengetahuan barunya untuk memeriksa seberapa banyak yang masih perlu dipelajari. Program akan mengulangi langkah ini hingga menghasilkan kesalahan serendah mungkin.

Dalam analogi masalah matematika kita, ini berarti Anda membaca bab buku teks berkali-kali hingga Anda benar-benar memahami konten kursus. Bahkan setelah membaca berkali-kali, jika Anda terus membuat kesalahan, ini berarti Anda telah mencapai kapasitas pengetahuan dengan materi saat ini. Anda perlu menggunakan buku teks yang berbeda atau menguji metode yang berbeda untuk meningkatkan skor Anda. Untuk jaringan saraf, prosesnya sama. Jika kesalahannya jauh dari 100%, tetapi kurvanya datar, ini berarti dengan arsitektur saat ini; jaringan tersebut tidak dapat mempelajari hal lain. Jaringan harus dioptimalkan dengan lebih baik untuk meningkatkan pengetahuan.

Jaringan syaraf Architekstur

Jaringan Syaraf Tiruan ArchiTekstur terdiri dari komponen-komponen berikut:

• Lapisan
• Fungsi aktivasi
• Fungsi kerugian
• Pengoptimal

Lapisan

Lapisan adalah tempat semua pembelajaran berlangsung. Di dalam sebuah lapisan, terdapat bobot (neuron) yang jumlahnya tak terhingga. Jaringan saraf tipikal sering kali diproses oleh lapisan yang terhubung secara padat (juga disebut lapisan yang terhubung sepenuhnya). Artinya semua input terhubung ke output.

Jaringan saraf tipikal mengambil vektor masukan dan skalar yang berisi label. Pengaturan yang paling nyaman adalah klasifikasi biner dengan hanya dua kelas: 0 dan 1.

Jaringan mengambil masukan, mengirimkannya ke semua node yang terhubung dan menghitung sinyal dengan pengaktifan fungsi.

Gambar di atas menggambarkan ide ini. Lapisan pertama merupakan nilai masukan, sedangkan lapisan kedua disebut lapisan tersembunyi, menerima masukan berbobot dari lapisan sebelumnya

1. Node pertama adalah nilai input
2. Neuron didekomposisi menjadi bagian input dan fungsi aktivasi. Bagian kiri menerima semua masukan dari lapisan sebelumnya. Bagian kanan adalah jumlah masukan yang masuk ke fungsi aktivasi.
3. Nilai keluaran dihitung dari lapisan tersembunyi dan digunakan untuk membuat prediksi. Untuk klasifikasi sama dengan jumlah kelas. Untuk regresi, hanya satu nilai yang diprediksi.

Fungsi aktivasi

Fungsi aktivasi sebuah node mendefinisikan keluaran berdasarkan sekumpulan masukan. Anda memerlukan fungsi aktivasi agar jaringan dapat mempelajari pola non-linier. Fungsi aktivasi yang umum adalah a Relu, Unit linier yang diperbaiki. Fungsi ini memberikan nol untuk semua nilai negatif.

Fungsi aktivasi lainnya adalah:

• Linier Sepotong-sepotong
• sigmoid
• Tanho
• Relu bocor

Keputusan penting yang harus diambil saat membangun jaringan saraf adalah:

• Berapa banyak lapisan dalam jaringan saraf
• Berapa banyak unit tersembunyi untuk setiap lapisan

Jaringan saraf dengan banyak lapisan dan unit tersembunyi dapat mempelajari representasi data yang kompleks, tetapi membuat komputasi jaringan menjadi sangat mahal.

Fungsi kerugian

Setelah Anda menentukan lapisan tersembunyi dan fungsi aktivasi, Anda perlu menentukan fungsi kerugian dan pengoptimal.

Untuk klasifikasi biner, praktik umum menggunakan fungsi kerugian entropi silang biner. Dalam regresi linier, Anda menggunakan mean square error.

Fungsi kerugian merupakan metrik penting untuk memperkirakan kinerja pengoptimal. Selama pelatihan, metrik ini akan diminimalkan. Anda harus memilih jumlah ini dengan hati-hati tergantung pada jenis masalah yang Anda hadapi.

Pengoptimal

Fungsi kerugian adalah ukuran performa model. Pengoptimal akan membantu meningkatkan bobot jaringan untuk mengurangi kerugian. Ada berbagai macam pengoptimal yang tersedia, tetapi yang paling umum adalah Stochastic Gradient Descent.

Pengoptimal konvensional adalah:

• Momentum pengoptimalan,
• Gradien yang Dipercepat Nesterov,
• AdaGrad,
• Optimasi Adam

Keterbatasan Jaringan Neural

Berikut ini adalah keterbatasan Jaringan Syaraf Tiruan:

overfitting

Masalah umum dengan jaringan saraf kompleks adalah kesulitan dalam menggeneralisasi data yang tidak terlihat. Jaringan saraf dengan banyak bobot dapat mengidentifikasi detail tertentu dalam rangkaian rangkaian dengan sangat baik, tetapi sering kali menyebabkan overfitting. Jika data tidak seimbang dalam kelompok (misalnya, tidak cukup data yang tersedia dalam beberapa kelompok), jaringan akan belajar dengan sangat baik selama pelatihan, tetapi tidak akan memiliki kemampuan untuk menggeneralisasi pola tersebut ke data yang belum pernah terlihat sebelumnya.

Ada trade-off dalam pembelajaran mesin antara pengoptimalan dan generalisasi.

Pengoptimalan model memerlukan menemukan parameter terbaik yang meminimalkan hilangnya set pelatihan.

Generalisasi, bagaimanapun, menunjukkan bagaimana model berperilaku terhadap data yang tidak terlihat.

Untuk mencegah model menangkap detail tertentu atau pola yang tidak diinginkan dari data pelatihan, Anda dapat menggunakan berbagai teknik. Metode terbaik adalah memiliki kumpulan data yang seimbang dengan jumlah data yang cukup. Seni mengurangi overfitting disebut regularisasi. Mari kita tinjau beberapa teknik konvensional.

Ukuran jaringan

Jaringan neural dengan terlalu banyak lapisan dan unit tersembunyi dikenal sangat canggih. Cara mudah untuk mengurangi kompleksitas model adalah dengan mengurangi ukurannya. Tidak ada praktik terbaik untuk menentukan jumlah lapisan. Anda perlu memulai dengan sedikit lapisan dan menambah ukurannya hingga Anda menemukan model yang terlalu pas.

Regularisasi Berat Badan

Teknik standar untuk mencegah overfitting adalah dengan menambahkan batasan pada bobot jaringan. Batasan tersebut memaksa ukuran jaringan mengambil nilai yang kecil saja. Batasan ditambahkan ke fungsi kerugian dari kesalahan. Ada dua jenis regularisasi:

L1: Lasso: Biaya sebanding dengan nilai absolut koefisien bobot

L2: Ridge: Biaya sebanding dengan kuadrat nilai koefisien bobot

Keluar

Dropout adalah teknik yang aneh namun berguna. Jaringan dengan dropout berarti beberapa bobot akan disetel ke nol secara acak. Bayangkan Anda memiliki array dengan bobot [0.1, 1.7, 0.7, -0.9]. Jika jaringan saraf mengalami dropout, maka akan menjadi [0.1, 0, 0, -0.9] dengan distribusi acak 0. Parameter yang mengontrol dropout adalah tingkat dropout. Nilai ini menentukan berapa banyak bobot yang harus disetel ke nol. Memiliki tingkat antara 0.2 dan 0.5 adalah hal biasa.

Contoh Jaringan Neural di TensorFlow

Mari kita lihat contoh Jaringan Syaraf Tiruan yang sedang beraksi tentang cara kerja jaringan syaraf untuk masalah klasifikasi yang umum. Ada dua masukan, x1 dan x2 dengan nilai acak. Keluarannya adalah kelas biner. Tujuannya adalah untuk mengklasifikasikan label berdasarkan dua fitur tersebut. Untuk melaksanakan tugas ini, arsitektur jaringan syaraf didefinisikan sebagai berikut:

• Dua lapisan tersembunyi
  • Lapisan pertama memiliki empat neuron yang terhubung sepenuhnya
  • Lapisan kedua memiliki dua neuron yang terhubung sepenuhnya
• Fungsi aktivasinya adalah Relu
• Tambahkan Regularisasi L2 dengan kecepatan pembelajaran 0.003

Jaringan akan mengoptimalkan bobot selama 180 epoch dengan ukuran batch 10. Dalam video contoh ANN di bawah, Anda dapat melihat bagaimana bobot berevolusi dan bagaimana jaringan meningkatkan pemetaan klasifikasi.

Pertama-tama, jaringan memberikan nilai acak untuk semua bobot.

• Dengan bobot acak, yaitu tanpa optimasi, output loss adalah 0.453. Gambar di bawah mewakili jaringan dengan warna berbeda.
• Secara umum warna oranye mewakili nilai negatif sedangkan warna biru menunjukkan nilai positif.
• Poin data memiliki representasi yang sama; yang biru adalah label positif dan yang oranye adalah label negatif.

Di dalam lapisan tersembunyi kedua, garis-garis diwarnai mengikuti tanda bobot. Garis oranye menetapkan bobot negatif dan garis biru menetapkan bobot positif.

Seperti yang Anda lihat, dalam pemetaan keluaran, jaringan membuat banyak kesalahan. Mari kita lihat bagaimana perilaku jaringan setelah optimasi.

Gambar contoh ANN di bawah ini menggambarkan hasil optimasi jaringan. Pertama-tama, Anda melihat jaringan telah berhasil mempelajari cara mengklasifikasikan titik data. Anda dapat melihat dari gambar sebelumnya; bobot awal sebesar -0.43 sedangkan setelah optimasi menghasilkan bobot -0.95.

Idenya dapat digeneralisasikan untuk jaringan dengan lebih banyak lapisan dan neuron tersembunyi. Anda bisa bermain-main di link.

Cara Melatih Jaringan Neural dengan TensorFlow

Berikut adalah proses langkah demi langkah tentang cara melatih jaringan neural dengan TensorFlow ANN menggunakan estimator API DNNClassifier.

Kami akan menggunakan kumpulan data MNIST untuk melatih jaringan saraf pertama Anda. Melatih jaringan saraf dengan TensorFlow tidak terlalu rumit. Langkah preprocessingnya terlihat sama persis seperti pada tutorial sebelumnya. Anda akan melanjutkan sebagai berikut:

• Langkah 1: Impor data
• Langkah 2: Transformasikan data
• Langkah 3: Buat tensor
• Langkah 4: Bangun modelnya
• Langkah 5: Latih dan evaluasi model
• Langkah 6: Tingkatkan modelnya

Langkah 1) Impor data

Pertama-tama, Anda perlu mengimpor perpustakaan yang diperlukan. Anda dapat mengimpor kumpulan data MNIST menggunakan scikit learn seperti yang ditunjukkan pada contoh Jaringan Neural TensorFlow di bawah.

Dataset MNIST adalah dataset yang umum digunakan untuk menguji teknik atau algoritma baru. Dataset ini merupakan kumpulan gambar berukuran 28×28 piksel dengan digit tulisan tangan dari 0 hingga 9. Saat ini error terendah pada pengujian adalah 0.27 persen dengan panitia 7 jaringan saraf konvolusional.

import numpy as np
import tensorflow as tf
np.random.seed(1337)

Anda dapat mengunduh scikit learn sementara di alamat ini. Salin dan tempel kumpulan data ke dalam folder yang nyaman. Untuk mengimpor data ke python, Anda dapat menggunakan mengambil_mldata dari scikit learn. Tempel jalur file di dalam mengambil_mldata untuk mengambil data.

from sklearn.datasets import fetch_mldata
mnist = fetch_mldata(' /Users/Thomas/Dropbox/Learning/Upwork/tuto_TF/data/mldata/MNIST original')
print(mnist.data.shape)
print(mnist.target.shape)

Setelah itu, Anda mengimpor data dan mendapatkan bentuk kedua dataset tersebut.

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(mnist.data, mnist.target, test_size=0.2, random_state=42)
y_train  = y_train.astype(int)
y_test  = y_test.astype(int)
batch_size =len(X_train)

print(X_train.shape, y_train.shape,y_test.shape )

Langkah 2) Transformasikan data

Di tutorial sebelumnya, Anda mempelajari bahwa Anda perlu mengubah data untuk membatasi efek outlier. Dalam tutorial Neural Networks ini, Anda akan mengubah data menggunakan min-max scaler. Rumusnya adalah:

(X-min_x)/(max_x - min_x)

Scikit learn sudah memiliki fungsi untuk itu: MinMaxScaler()

## resclae
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler()
# Train
X_train_scaled = scaler.fit_transform(X_train.astype(np.float64))
# test
X_test_scaled = scaler.fit_transform(X_test.astype(np.float64))

Langkah 3) Buat tensor

Anda sekarang sudah familiar dengan cara membuat tensor di Tensorflow. Anda dapat mengonversi kumpulan kereta menjadi kolom numerik.

feature_columns = [tf.feature_column.numeric_column('x', shape=X_train_scaled.shape[1:])]

Langkah 4) Bangun modelnya

Arsitektur jaringan saraf berisi 2 lapisan tersembunyi dengan 300 unit untuk lapisan pertama dan 100 unit untuk lapisan kedua. Kami menggunakan nilai ini berdasarkan pengalaman kami sendiri. Anda dapat menyetel nilai ini dan melihat bagaimana hal itu memengaruhi keakuratan jaringan.

Untuk membangun model, Anda menggunakan estimator DNNClassifier. Anda dapat menambahkan jumlah lapisan ke argumen feature_columns. Anda perlu mengatur jumlah kelas menjadi 10 karena ada sepuluh kelas dalam set pelatihan. Anda sudah familiar dengan sintaks objek estimator. Argumen fitur kolom, jumlah kelas dan model_dir sama persis seperti pada tutorial sebelumnya. Argumen baru Hidden_unit mengontrol jumlah lapisan dan berapa banyak node yang akan dihubungkan ke jaringan saraf. Pada kode di bawah ini, ada dua lapisan tersembunyi, yang pertama menghubungkan 300 node dan yang kedua dengan 100 node.

Untuk membangun estimator, gunakan tf.estimator.DNNClassifier dengan parameter berikut:

• feature_columns: Tentukan kolom yang akan digunakan dalam jaringan
• Hidden_units: Tentukan jumlah neuron tersembunyi
• n_classes: Tentukan jumlah kelas yang akan diprediksi
• model_dir: Tentukan jalur TensorBoard

estimator = tf.estimator.DNNClassifier(
    feature_columns=feature_columns,
    hidden_units=[300, 100], 
    n_classes=10, 
    model_dir = '/train/DNN')

Langkah 5) Latih dan evaluasi model

Anda dapat menggunakan metode numpy untuk melatih model dan mengevaluasinya

# Train the estimator
train_input = tf.estimator.inputs.numpy_input_fn(
    x={"x": X_train_scaled},
    y=y_train,
    batch_size=50,
    shuffle=False,
    num_epochs=None)
estimator.train(input_fn = train_input,steps=1000) 
eval_input = tf.estimator.inputs.numpy_input_fn(
    x={"x": X_test_scaled},
    y=y_test, 
    shuffle=False,
    batch_size=X_test_scaled.shape[0],
    num_epochs=1)
estimator.evaluate(eval_input,steps=None) 

Keluaran:

{'accuracy': 0.9637143,
 'average_loss': 0.12014342,
 'loss': 1682.0079,
 'global_step': 1000}

Arsitektur saat ini menghasilkan akurasi pada set evaluasi sebesar 96 persen.

Langkah 6) Tingkatkan modelnya

Anda dapat mencoba menyempurnakan model dengan menambahkan parameter regularisasi.

Kami akan menggunakan pengoptimal Adam dengan tingkat putus 0.3, L1 dari X dan L2 dari y. Di TensorFlow Neural Network, Anda dapat mengontrol pengoptimal menggunakan rangkaian objek yang diikuti dengan nama pengoptimal. TensorFlow adalah API bawaan untuk pengoptimal AdaGrad Proksimal.

Untuk menambahkan regularisasi ke jaringan saraf dalam, Anda dapat menggunakan tf.train.ProximalAdagradOptimizer dengan parameter berikut

• Kecepatan pembelajaran: kecepatan_belajar
• Regularisasi L1: l1_regularisasi_kekuatan
• Regularisasi L2: l2_regularisasi_kekuatan

estimator_imp = tf.estimator.DNNClassifier(
    feature_columns=feature_columns,
    hidden_units=[300, 100],
    dropout=0.3, 
    n_classes = 10,
    optimizer=tf.train.ProximalAdagradOptimizer(
      learning_rate=0.01,
      l1_regularization_strength=0.01, 
      l2_regularization_strength=0.01
    ),
    model_dir = '/train/DNN1')
estimator_imp.train(input_fn = train_input,steps=1000) 
estimator_imp.evaluate(eval_input,steps=None) 

Keluaran:

{'accuracy': 0.95057142,
 'average_loss': 0.17318928,
 'loss': 2424.6499,
 'global_step': 2000}

Nilai yang dipilih untuk mengurangi overfitting tidak meningkatkan akurasi model. Model pertama Anda memiliki akurasi 96% sedangkan model dengan pengatur L2 memiliki akurasi 95%. Anda dapat mencoba dengan nilai yang berbeda dan melihat pengaruhnya terhadap keakuratan.

Ringkasan

Dalam tutorial ini, Anda mempelajari cara membangun jaringan saraf. Jaringan saraf memerlukan:

• Jumlah lapisan tersembunyi
• Jumlah node yang terhubung sepenuhnya
• Fungsi aktivasi
• Pengoptimal
• Jumlah kelas

Di TensorFlow ANN, Anda dapat melatih jaringan neural untuk masalah klasifikasi dengan:

• tf.estimator.DNNClassifier

Estimator perlu menentukan:

• feature_columns=fitur_kolom,
• unit_tersembunyi=[300, 100]
• n_kelas=10
• model_dir

Anda dapat meningkatkan model dengan menggunakan pengoptimal yang berbeda. Dalam tutorial ini, Anda mempelajari cara menggunakan pengoptimal Adam Grad dengan kecepatan pembelajaran dan menambahkan kontrol untuk mencegah overfitting.