Deep Learning: Artificial Neural Networks (aplikasi)

Sebelum kita mulai, silakan download dulu datasetnya di link ini.


Bahasa Python

# Mengimpor library yang diperlukan
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd

# Mengimpor dataset
dataset = pd.read_csv('Data_bank_churn.csv')
X = dataset.iloc[:, 3:13].values
y = dataset.iloc[:, 13].values

# Mengonversi data kategori (negara dan jenis kelamin)
from sklearn.preprocessing import LabelEncoder, OneHotEncoder
labelencoder= LabelEncoder()
X[:, 1] = labelencoder.fit_transform(X[:, 1])
X[:, 2] = labelencoder.fit_transform(X[:, 2])
X_df = pd.DataFrame(X)

# Membuat dummy variable untuk kolom negara
onehotencoder = OneHotEncoder(categorical_features = [1])
X = onehotencoder.fit_transform(X).toarray()

# Menghilangkan 1 dummy variabel di kolom negara
X = X[:, 1:]

# Membagi data ke test dan training set
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, random_state = 0)

# Proses feature scaling
from sklearn.preprocessing import StandardScaler
sc = StandardScaler()
X_train = sc.fit_transform(X_train)
X_test = sc.transform(X_test)

# Mengimpor library Keras dan turunannya
import keras
from keras.models import Sequential
from keras.layers import Dense

# Inisialisasi ANN
MesinKlasifikasi = Sequential()

# Menambah input layer dan hidden layer pertama
MesinKlasifikasi.add(Dense(units = 6, kernel_initializer = 'uniform', activation = 'relu', input_dim = 11))

# Menambah hidden layer kedua
MesinKlasifikasi.add(Dense(units = 6, kernel_initializer = 'uniform', activation = 'relu'))

# Menambah output layer
MesinKlasifikasi.add(Dense(units = 1, kernel_initializer = 'uniform', activation = 'sigmoid'))

# Meenjalankan ANN
MesinKlasifikasi.compile(optimizer = 'adam', loss = 'binary_crossentropy', metrics = ['accuracy'])

# Fitting ANN ke training set
MesinKlasifikasi.fit(X_train, y_train, batch_size = 10, nb_epoch = 100)

# Memprediksi hasil test set
y_pred = MesinKlasifikasi.predict(X_test)
y_pred = (y_pred > 0.5)

# Membuat confusion matrix
from sklearn.metrics import confusion_matrix
cm = confusion_matrix(y_test, y_pred)

Penjelasan:

  • Line 2-4 mengimpor library dasar yang diperlukan dalam pembahasan kali ini (belum memasukkan library keras).
  • Line 7 mengimpor dataset.

Jika kita klik 2x pada dataset pada tampilannya sebagai berikut:

Tampilan dataset di Python
  • Line 8 melakukan slicing untuk variabel independen X. Kita memerlukan kolom ke 3-14. Perlu diingat dalam python indeks dimulai dari nol, dan indeks terakhir tidak diikutkan.
  • Line 9 melakukan slicing untuk variabel dependen y, yaitu kolom terakhir yang menunjukkan status keluar/tidaknya pegawai.

Perlu diperhatikan bahwa jika kita mencoba klik 2x pada variabel X di spyder, maka ia akan memberikan tanda error. Hal ini dikarenakan variabel X terdiri dari beberapa jenis tipe data (float dan kategori). Ini adalah bug (kesalahan) pada spyder yang akan diperbaiki oleh developernya di tahun 2019.

Walau demikian, jika pembaca ingin melihat isi variabel X, maka bisa menulis X di console, sehingga tampilannya sebagai berikut.

Tampilan variabel X di console spyder

Atau bisa juga dengan mengonversi variabel X menjadi data frame terlebih dahulu seperti di line 16 (akan dibahas kemudian).

Sekarang tahapan selanjutnya adalah merubah data berjenis kategori menjadi data berjenis angka. Kita bisa melihat di dataset bahwa 2 kolom data kita yaitu kolom Geography dan Gender merupakan data berjenis kategori. Kita perlu merubahnya dengan library khusus.

Agar pembaca masih ingat tentang alasan mengapa harus diencode (dikonversi) datanya, silakan klik link ini.

  • Line 12 mengimpor library untuk konversi dari data kategori ke angka.
  • Line 13 membuat objek labelencoder sebagai fungsi dari LabelEncoder.
  • Line 14 merubah kolom ke 1 (kolom Geography) menjadi nilai 0, 1 atau 2 (karena ada 3 kategori/ 3 negara).
  • Line 15 merubah kolom ke 2 (Gender) menjadi nilai 0, atau 1 karena ada 2 kategori.
  • Line 16 membuat objek X_df untuk mengonversi variabel X menjadi data frame agar bisa kita lihat isinya (opsional). Tampilan X_df adalah sebagai berikut:
Tampilan dataset dan X_df

Bisa dilihat pada ilustrasi di atas bahwa X_df sama dengan dataset. Hanya saja kolom ke 2 dan 3 sudah melalui proses konversi. Misal nama France menjadi 0, dan Spain menjadi 2, kemudian Female menjadi 0 dan Male menjadi 1.

  • Line 19 membuat dummy variabel untuk kolom negara. Mengapa diperlukan? Karena kita tidak ingin membuat komputer bingung bahwasanya negara 0 (France) bukan berarti lebih rendah daripada negara 2 (Spain). Kita hanya ingin memberi nama saja, dan hal ini juga merupakan hasil konversi dari perintah sebelumnya. Yang ingin kita buat dummy variabel hanyalah kolom negara saja, karena memiliki lebih dari 2 kategori, sementara gender tidak perlu karena hanya 2 kategori saja. Oleh karena itu, kita definisikan objek onehotencoder untuk menjalankan fungsi OneHotEncoder. Kita juga jelaskan kolom yang dimaksud adalah kolom ke 1 (kolom geography).
  • Line 20 adalah perintah membuat dummy untuk variabel X. Indeksnya tidak perlu ditulis lagi karena sudah dijelaskan di line sebelumnya yaitu indeks kolom ke 1 (kolom geography).

Jika kita klik 2x pada variabel X, maka tampilannya adalah sebagai berikut:

Tampilan variabel X setelah ditambah dummy variabel

Bisa dilihat bahwa kolom Geography sekarang berubah menjadi 3 kolom dengan nilai 1 sampai 0. Nilai 1 menandakan bahwa ia menjadi bagian dari kolom tersebut, sementara nilai 0 adalah sebaliknya.

Kita juga bisa melihat bahwa posisinya bergeser ke kiri (di sebelah kiri kolom CreditScore). Hal ini biasa terjadi di python jadi tidak perlu bingung.

Yang penting diperhatikan adalah jika kita memiliki n kategori, maka yang data yang harus digunakan adalah n-1 kategori. Hal ini untuk menghindari dummy variable trap, sehingga di line selanjutnya kita hilangkan salah satu kolom ini.

  • Line 23 menghilangkah salah satu kolom di variabel X untuk menghindari dummy variable trap. Yang kita hilangkan adalah kolom ke nol.
  • Line 26-27 membagi dataset ke dalam training dan test set.
  • Line 30-33 melakukan proses feature scaling. Hal ini adalah langkah wajib dalam deep learning, karena kita berhubungan dengan banyak sekali komputasi (beberapa kali epoch), sehingga kita tidak ingin skala satu kolom lebih mendominasi daripada skala kolom lainnya. Untuk memahami dan mereview feature scaling silakan baca artikel saya di link ini.

Sampai di tahap ini, dataset kita sudah siap dan ready (sudah melalui preprocessing). Sekarang saatnya kita beralih ke Keras.

  • Line 36 mengimpor library keras. Jika dieksekusi maka akan memunculkan tulisan ini di console spyder: Using TensorFlow backend. Artinya Keras kita menggunakan basis dari TensorFlow.
  • Line 37 mengimpor modul dari keras yang disebut dengan Sequential. Modul ini diperlukan untuk memulai neural networks. Kita mengimpornya dari sublibrary models pada keras, sehingga ditulisnya from keras.models import Sequential.
  • Line 38 mengimpor modul kedua dari keras yaitu Dense. Modul ini diperlukan untuk membuat layers di neural networks. Kita mengimpornya dari sublibrary layers di keras, jadi penulisannya adalah from keras.layers import Dense.
  • Line 41 mendefinisikan objek MesinKlasifikasi sebagai nama artificial neural networks kita. Tentu saja penamaan ini bebas. Caranya adalah cukup menjalankan fungsi (class) Sequential terhadap nama objek ini.

Sebelum kita lanjut, saya ingin pembaca untuk mereview tahapan dari ANN. Saya sudah membahasnya di artikel saya sebelumnya di bagian teori ANN. Bagi pembaca yang ingin mereview silakan klik link ini.

  • Line 44 menambah input layer (11 variabel independen) dan hidden layer (beberapa nodes di depan input layer). Caranya adalah menggunakan method add, kemudian diikuti dengan perintah Dense untuk menambahkan layernya. Di dalam perintah Dense, kita perlu mendefinisikan beberapa parameter. Cukup arahkan kursor pada Dense lalu ketik CTRL+i di keyboard, maka akan memunculkan tampilan help sebagai berikut.
Tampilan help untuk perintah Dense di Spyder

Beberapa parameter yang kita perlukan antara lain:

  1. units = berapa banyak nodes (neuron) dalam hidden layer ini. Tidak ada aturan pasti, namun umumnya dipilih angka rata-rata antara jumlah variabel independen (11) dan variabel dependen (1), yaitu 12/2 = 6.
  2. kernel_initializer = adalah distribusi yang digunakan untuk menginisialisasi (mengenerate) bobot W untuk setiap input. Kita pilih distribusi uniform.
  3. activation = kita pilih relu yang merupakan rectifier function.
  4. input_dim = 11, karena ada 11 variabel independen.

Dengan demikian desain dari input layer dan hidden layer pertama kita adalah:

Desain input layer dan hidden layer pertama

Sekarang kita lanjut membuat NN untuk layer selanjutnya. Karena kita sudah mendefinisikan input layer (11 variabel independen), untuk layer selanjutnya kita tidak perlu mendefinisikan ini lagi.

Kita sebenarnya tidak perlu menambahkan hidden layer kedua, karena kasus ini masih sangat sederhana (1 hidden layer sudah lebih dari cukup). Tapi untuk menunjukkan ke pembaca cara pemakaian hidden layer lebih dari 1 (jika nanti permasalahannya sangat kompleks, dengan jutaan data), maka untuk pembahasan kali ini kita gunakan 2 lapis hidden layer.

  • Line 47 menambahkan hidden layer kedua, dengan jumlah neuron yang sama yaitu 6. Dengan demikian, desain NN kita menjadi sebagai berikut:
Desain dengan penambahan hidden layer kedua
  • Line 50 membuat output layer. Mirip dengan line-line sebelumnya, kali ini kita memilih activation function yang berbeda yaitu sigmoid function, dan units=1 karena hanya ada 2 kategori (0/1).

Jika pembaca memiliki kategori lebih dari 2, misal ada 5 kategori, maka ganti nilai units=5, dan ubah activation=softmax. Softmax adalah turunan dari fungsi sigmoid. Softmax dengan units=5 artinya ada 5 probabilitas sebagai outputnya.

  • Line 53 adalah menjalankan (meng-compile) neural network yang sudah kita desain dengan metode stochastic gradient descent. Kita menggunakan metode compile. Untuk bisa melihat parameter apa saja yang diperlukan, ketik CTRL+i di bagian compile. Tampilannya adalah sebagai berikut.
Tampilan help untuk compile di Spyder

Parameter yang kita perlukan adalah:

  1. optimizer. Ini adalah parameter yang menentukan nilai bobot yang tepat untuk setiap jalur sinaps neuronnya. Kita pilih menggunakan metode stochastic gradient descent (SGD). Ada beberapa jenis SGD yang bisa dipilih. Agar tidak pusing kita pilih metode SGD yang cocok yaitu adam.
  2. loss. Ini adalah loss function yang harus kita tentukan yaitu perhitungan nilai error (seberapa jauh y model dari y real). Contoh loss function adalah SSE, MSE, dan lain-lain. Agar mudah, di sini kita gunakan logaritmic loss. Kita tidak akan bahas detail, karena terlalu teknis. Perintah logaritmic loss yang digunakan kali ini namanya binary_crossentropy yang berhubungan erat dengan metode adam di parameter sebelumnya.
  3. metrics. Ini merupakan kriteria yang akan kita gunakan untuk mengevaluasi performanya. Sesuai informasi di tampilan help, kita gunakan accuracy. Intinya ketika setiap epoch berlalu, maka model ANN kita akan berusaha menaikkan tingkat akurasinya sedikit demi sedikit sampai tercapai akurasi yang paling tinggi. Dalam penjelasan sebelumnya, kita juga menyebutnya dengan istilah meminimasi nilai C (cost function). Karena accuracy adalah sebuah list, maka penulisannya di dalam sebuah kurung tutup = [‘accuracy’].
  • Line 56 adalah menjalankan (men-training) ANN dengan beberapa epoch yang kita tentukan, di mana setiap epoch ANN akan mengupdate nilai W dan terus berusaha meningkatkan akurasinya. Kita gunakan parameter batch_size=10, artinya kita lakukan forward dan back propagation setiap 10 baris data yang diproses. Kita tentukan jumlah epoch sebanyak 100 kali. Tentu saja semua parameter ini bebas. Walau demikian angka parameternya jangan terlalu besar dan sesuaikan dengan kemampuan komputer masing-masing.

Saat dieksekusi, tunggu sampai prosesnya selesai. Tampilan prosesnya kurang lebih sebagai berikut:

Tampilan iterasi epoch di Spyder

Pada tampilan di atas kita bisa melihat kita berada di epoch ke berapa dan nilai akurasi (paling kanan) untuk setiap epochnya. Nilai akurasinya akan naik turun sampai akhirnya menjadi converged.

Hasil akhir dari proses iterasinya tampilannya sebagai berikut:

Tampilan akhir iterasi epoch

Hasil akurasi bisa berbeda-beda untuk setiap komputer. Tentunya tidak akan berubah jauh dari 0.83-0.86

  • Line 59 kita memprediksi hasil dari model ini ke test set.

Setelah dieksekusi dan kit aklik 2x pada y_pred maka tampilannya adalah sebagai berikut:

Tampilan y_pred di Spyder

Sekarang kita memiliki 2000 data y_pred, di mana setiap barisnya menunjukkan probabilitas apakah nasabah ini akan keluar atau tidak. Mengapa muncul probabilitas? Karena kita sebelumnya menggunakan fungsi sigmoid saat menggunakan activation function.

Karena yang kita butuhkan bukanlah probabilitas, namun dua nilai antara 0 dan 1, maka kita konversi nilai probabilitas ini. Nilai probabilitas > 0.5 akan bernilai 1 (True), dan sebaliknya bernilai 0 (False).

  • Line 60 mendefinisikan bahwa nilai 1 untuk variabel dependen adalah jika nilai probabilitasnya (p) lebih besar dari 0.5.

Jika dieksekusi, sekarang tampilan y_pred adalah sebagai berikut:

Tampilan y_pred akhir di Spyder

Sekarang kita bisa melihat apakah nasabah meninggalkan bank (True) atau tetap di bank(False).

  • Line 63-64 mengimpor library sekaligus membuat confusion matrix.

Jika kita klik 2x pada variabel cm, tampilannya adalah sebagai berikut:

Confusion matrix ANN

Kita bisa lihat bahwa kita memiliki (1550+131 = 1681) prediksi benar dan (274+45 = 319) prediksi salah. Dengan demikian akurasinya adalah (1681/2000 = 0.84) 84%. Ternyata artificial neural networks (ANN) kita mampu memprediksi dengan cukup baik bahkan di atas 80%.

Pembaca juga bisa menggunakan metode klasifikasi ML lainnya seperti SVM, naive bayes dan lain-lain. Kemudian bandingkan hasilnya dengan deep learning. Dengan demikian, pembaca bisa membandingkan secara lansung performa deep learning dibandingkan dengan teknik ML konvensional lainnya.

Tentu saja dalam pembahasan ANN kali ini pembaca bisa merubah-ubah parameter di dalamnya, dan bisa membandingkan perbedaan parameter satu dengan lainnya.

Sampai di sini saya harap pembaca bisa memahami dan mempraktekkan penggunaan deep learning untuk memecahkan masalah nyata. Semoga bermanfaat!

Untuk melanjutkan membaca dan belajar menggunakan deep learning di bahasa R, silakan klik halaman selanjutnya di bawah ini.

Bagikan artikel ini:

Pages: 1 2 3 4

Leave a Reply

avatar
  Subscribe  
Notify of