DL-01 ~ Pendahuluan Deep Learning (Model network)

"Artificial intelligence refers to a machine's ability to learn, adapt, and solve complex problems automatically that benefit society." --Amit Ray

• Watch The Video Here: https://youtu.be/WiCv0vTKWG4

taudata Analytics

Pendahuluan Neural Network & Deep Learning

(C) Taufik Sutanto

https://taudataid.github.io/dl01/

Sejarah Perkembangan Metode di Machine Learning, Neural network & Deep Learning

Sejarah Beberapa Metode di Machine Learning:¶

• Bayesian : 1763 Thomas Bayes, Statisticians
• Regresi : Abad 19 (~18XX), Francis Galton (biologist)
• Decision Tree : 1959, William Belson, biologist (popular oleh R. Quinlan 80-an ID3 & CART oleh )
• Perceptron : 1962, Frank Rosenblatt, psychologist
• SVM : 1963, Vapnik, Mathematics and Statistics.
• Neural network : 1974, Werbos (backprop), 1990 Hecht-Nielsen (MLP)(setelah perceptron)
• Semi-Supervised : 1965 Scruder, tapi popular 2008 Zhu (comp scientist)
• Ensemble : 1979, Dasarathy,
• Deep learning : ...

Sejarah Deep Learning:¶

• Ketika ML (SVM) sedang populer di tahun 2010, beberapa peneliti tetap mendalami NN, diantaranya nama-nama tenar seperti Geoffrey Hinton di the University of Toronto, dan Yann LeCun di New York University.
• Deep Learning dengan GPU dimulai di tahun 2011 (Dan Ciresan dari  IDSIA-Swiss)
• Namun di 2012 baru terkenal karena permasalahan klasifikasi ImageNet (~1,4 juta image dikategorikan ke 1000 kelas) mampu diselesaikan oleh Hinton. Awalnya akurasinya 'hanya' ~74% (2011), lalu ~83(2012), dan di anggap telah solved di 2015 dengan akurasi ~96% (Deep Convolutional Neural Network - convnets).
• Sejak itu convnets menjadi model dasar computer vision.
• Di Kaggle (2016-2017) ada trend untuk data terstruktur biasanya diselesaikan dengan Gradient Boosting (e.g. XGBoost) dan data tidak terstruktur dengan DL (e.g. Keras).

Penantian Lama Aplikasi Teori di Deep learning¶

Theory Deep Learning sebenarnya sudah cukup lama ada (dibahas):

• convolutional neural networks dan backpropagation — 1989
• The Long Short-Term Memory ( LSTM ) algorithm (timeseries DL) — 1997

Lalu mengapa baru tenar di 2012?

• Hardware (terutama GPU)
• Dataset (Big Data)
• Perkembangan Algoritma terbaru : Better activation functions, weight-initialization schemes, optimization schemes (e.g.Adam W)

Tapi apa sebenarnya Deep Learning?

Neural network VS Deep Learning¶

• Yang menjadi pembeda utama DL dengan ML adalah DL "Learning representations from data". Misal Word Embedding (bandingkan dengan VSM di Machine Learning).
• Makna "Deep" di DL sendiri bermakna "successive layers of representations" biasa juga disebut sebagai layered representations learning atau hierarchical representations learning.

Deep Learning & "Big Data"

• Seringnya DL butuh data yang besar untuk memperoleh performa (akurasi) yang baik.
• "Transfer Learning" di Deep learning diperkenalkan untuk mengatasi hal ini.

Pendahuluan model Jaringan¶

Alur Perhitungan pada Model Jaringan¶

• 
• 

Training Neural Network ¶

Fungsi Aktivasi¶

• Fungsi aktivasi adalah fungsi yang memutuskan apakah suatu neuron harus diaktifkan atau tidak berdasarkan hasil perhitungan kombinasi linear antara variabel input dengan masing-masing bobotnya. Selain itu fungsi aktivasi bisa berfungsi untuk merubah kombinasi linear tersebut menjadi output yang non linear
• Terdapat beberapa activation function, di antaranya sebagai berikut:
</ul>

Contoh Fungsi tanh memetakan [-Inf, Inf] ke [-1, 1]¶

Fungsi Aktivasi Sigmoid yang bisa digunakan untuk menginat dan melupakan¶

• Fungsi sigmoid mirip dengan tanh, namun intervalnya adalah [0, 1].
• Semakin dekat ke 0 ==> melupakan (forget): informasi tidak relevan.
• Semakin dekat ke 1 ==> mengingat: informasi relevan/penting.
• 

Tanpa fungsi aktivasi apa yang akan terjadi?¶

• Tanpa fungsi aktivasi, weights bisa membesar tak berbatas ketika iterasinya berjalan

Dengan Fungsi Aktivasi, nilai weights selalu terbatas (misal) di -1 dan 1, namun tingkat kepentingan weight tetap terjaga.¶

• Perhatikan nilai weight yang pertama

Contoh Cara Kerja/Perhitungan Neural Network¶

link: https://youtu.be/o20mBWPHGEw

"Toy Data" Contoh Perhitungan Neural Network (Back Propagation)¶

Memilih Fungsi Aktivasi dan Fungsi Loss¶

Peran Optimizer¶

Optimizer : http://ruder.io/optimizing-gradient-descent/ 

Loss function dan Error¶

Loss Function, Optimizer, & metric

1. Loss function (objective function) — fungsi yang akan di minimize. Hasilnya merepresentasikan tingkat sukses pada setiap iterasi.
   https://keras.io/losses/ 
2. Optimizer — Berfungsi untuk menentukan bagaimana (weights) di network akan di update berdasarkan loss-functionnya. (e.g. variasi dari SGD)
   https://keras.io/optimizers/
3. Metrics — Satuan evaluasi
   https://keras.io/metrics/

Multiclassification di Model Jaringan¶

Empirical Analysis Parameter di Model Jaringan¶

• Tensorflow PlayGround: https://goo.gl/3rcnc9

• Memahami "Bias" di Model jaringan: Mengapa dengan fungsi linear bisa membentuk "boundary" yang melengkung (kurva)?

  http://s.id/j6i

Deep learning (Popular) Frameworks¶

• https://morioh.com/p/ae3bdc889d0c
• https://marutitech.com/top-8-deep-learning-frameworks/

Kelebihan dan Kekurangan¶

image source:

• https://slidetodoc.com/neural-networks-and-support-vector-machines-outline-neural/

Penerapan Neural Network¶

source: https://www.youtube.com/watch?v=me3QEYPsFWE

Studi Kasus¶

• Sebagai ilustrasi, kita gunakan data konsumsi energi tiap rumah untuk membuat model neural network
• Data tersebut terdiri dari 504 baris dan 4 kolom, kolom tersebut di antaranya yaitu:

1. jumlah ruangan
2. jumlah penghuni
3. luas bangunan
4. banyaknya energi listrik yang digunakan dalam satuan KWh per bulan

• Data tersebut merupakan hasil modifikasi dari data boston housing (link: https://www.kaggle.com/c/boston-housing)
• Model neural network yang akan dibuat bertujuan untuk memprediksi kolom energi listrik berdasarkan kolom lainnya.

Import Modul Standar¶

In [6]:

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
%matplotlib inline
import seaborn as sns
sns.set_theme(style="whitegrid")
import warnings; warnings.filterwarnings("ignore")

Import Data Konsumsi Energi¶

• Data konsumsi energi diimport menggunakan pandas
• karena format datanya csv maka untuk mengimportnya menggunakan pd.read_csv()
• setelah diimport dan simpan dalam variabel energi, kita coba lihat 5 data teratas menggunakan energi.head()

In [7]:

file_ = 'data/konsumsi_energi.csv'
try: # Running Locally
    energi = pd.read_csv(file_)
except: # Running in Google Colab
    !mkdir data
    !wget -P data/ https://raw.githubusercontent.com/taudata-indonesia/eLearning/main/{file_}
    energi = pd.read_csv(file_)
energi.head(10)

Out[7]:

	jumlah_ruangan	jumlah_penghuni	luas_bangunan	listrik
0	2	1	49.8	24.0
1	7	2	91.4	21.6
2	7	2	40.3	34.7
3	2	3	29.4	33.4
4	2	3	53.3	36.2
5	2	3	52.1	28.7
6	7	5	124.3	22.9
7	7	5	191.5	27.1
8	7	5	299.3	16.5
9	7	5	171.0	18.9

Visualisasi Data¶

In [8]:

sns.pairplot(energi, y_vars='listrik')

Out[8]:

<seaborn.axisgrid.PairGrid at 0x1bbd6220520>

• Dari hasil visualisasi data terlihat bahwa terdapat keanehan pada data.
• Hal tersebut dikarenakan data yang digunakan bukan data sebenarnya.
• Tetapi coba kita tetap gunakan sebagai contoh.

Melihat Statistika Deskriptif dari Data¶

• Sebelum melakukan pembuatan model, sebaiknya dilakukan analisa terhadap statistika deskriptif dari data
• Dari statistika deskriptif tersebut, kita dapat meilhat range dari data dan ukuran pusat data

In [9]:

energi.describe()

Out[9]:

	jumlah_ruangan	jumlah_penghuni	luas_bangunan	listrik
count	504.000000	504.000000	504.000000	504.000000
mean	10.750000	9.575397	126.859325	22.474008
std	6.914488	8.714506	71.355341	9.132927
min	1.000000	1.000000	17.300000	5.000000
25%	5.000000	4.000000	70.925000	16.950000
50%	9.000000	5.000000	113.950000	21.200000
75%	18.000000	24.000000	169.925000	25.000000
max	27.000000	24.000000	379.700000	50.000000

• Dari statistika deskriptif di atas terlihat perbedaan range antara jumlah_keluarga, jumlah_ruangan dengan luas_bangunan dan listrik
• Karena perbedaan range tersebut, nanti kita akan lakukan feature scalling menggunakan MinMaxScaler agar range dari seluruh data tersebut berada di antara 0 dan 1

Menentukan variabel target dan variabel input¶

Karena tujuan kita adalah memprediksi kolom listrik berdasarkan kolom lainnya, maka:

• kita tetapkan kolom listrik sebagai variabel target (y)
• dan kolom lainnya sebagai variabel input (X)

In [10]:

y = energi[['listrik']].values
X = energi.drop(columns=['listrik']).values

# Check the shape of training data
print(X.shape,y.shape)
print(type(y),type(X))

(504, 3) (504, 1)
<class 'numpy.ndarray'> <class 'numpy.ndarray'>

• Perhatikan bahwa code di atas menggunakan .values saat menetapkan variabel y dan X
• Hal tersebut dilakukan untuk merubah tipe data dataframe menjadi numpy array
• Tensorflow sebenarnya dapat memproses tipe data dataframe, namun tipe data numpy array akan lebih cepat diproses

Split Data¶

• Split data dilakukan agar model yang telah dilatih dapat dievaluasi kemampuannya.
• Kita gunakan train_test_split dari modul sklearn untuk melakukan split data
• train_test_split tersebut melakukan split data dengan stratified sampling
• Kita juga akan melakukan cross validation menggunakan data train sehingga pastikan data train yang digunakan cukup besar.
• Pada contoh ini kita gunakan 80% data train dan 20% data test
• random_state ditetapkan berupa bilangan integer agar hasil split data yang dilakukan secara acak selalu sama

In [12]:

# Create training and test split
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=1)

print('Banyak data train:', len(X_train))
print('Banyak data test :', len(X_test))

Banyak data train: 403
Banyak data test : 101

Feature Scalling¶

• Perbedaan range antara variabel-variabel yang digunakan akan menyulitkan proses pelatihan model neural network
• Selain itu range yang besar juga dapat menyebabkan suatu ketika nilai loss function sangat besar sehingga proses pelatihan model neural network tidak mencapai nilai minimum
• Oleh karena itu perlu dilakukan feature scalling menggunakan MinMaxScaler agar seluruh data memiliki range yang sama yaitu dari 0 sampai 1
• Rumus MinMaxScaler: # $x^*=\frac{x-x_{min}}{x_{max}-x_{min}}$

• MinMaxScaler difit pada data train agar dapat digunakan kembali pada data test maupun data observasi baru
• MinMaxScaler diterapkan secara terpisah antara variabel target dan input karena ketika ingin memprediksi variabel target dengan data observasi baru, data tersebut hanya terdiri dari variabel input

In [13]:

from sklearn.preprocessing import MinMaxScaler
scaler1 = MinMaxScaler()
scaler1.fit(X_train)
scaler2 = MinMaxScaler()
scaler2.fit(y_train)

X_train_scaled = scaler1.transform(X_train)
X_test_scaled = scaler1.transform(X_test)
y_train_scaled = scaler2.transform(y_train)
y_test_scaled = scaler2.transform(y_test)

Neural Network Menggunakan Tensorflow dan Keras¶

• tensorflow: https://www.tensorflow.org/overview
• keras: https://keras.io/about/

Instalasi Lokal GPU Support (TensorFlow-CUDA) untuk model Deep Learning.¶

• Link ini akan membantu menyesuaikan versi CUDA dan CudNN yang tepat untuk semua versi TensorFlow. Hati-hati!!!.... requirement CUDA dan CudNN berbeda antara Linux & Windows (Walau versi tensorflow-nya sama!!!).
• Berikut Versi Keras-TensorFlow yang bersesuaiannya: https://docs.floydhub.com/guides/environments/ Download Cuda dan CudNN yang bersesuaian (seringnya BUKAN versi terakhir) dari sini (need to register):
• https://developer.nvidia.com/rdp/cudnn-archive

• https://developer.nvidia.com/cuda-downloads

• Setelah install Cuda/Cudnn, jika compiler terinstall dengan baik, maka perintah pip install --upgrade tensorflow-gpu bisa digunakan di terminal/command prompt.

Untuk "PyTorch" cenderung lebih mudah: https://pytorch.org/get-started/locally/

Google Colaboratory¶

• Free with GPU (& TPU) support (Max run ~ 10jam)
• Login dengan Username dan password Google
• Kunjungi https://colab.research.google.com
• New Python 3 Notebook, rename/save Notebook
• Runtime>Change runtime type and select GPU as Hardware accelerator.

In [14]:

import warnings, matplotlib.pyplot as plt; warnings.simplefilter('ignore')
import pickle, numpy as np, tensorflow as tf, time, os, matplotlib.pyplot as plt, seaborn as sns
from collections import Counter
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report, confusion_matrix, accuracy_score
from tensorflow import keras    
from tensorflow.keras import regularizers
from tensorflow.keras.preprocessing.text import Tokenizer
from tensorflow.keras.preprocessing.sequence import pad_sequences
from tensorflow.keras import regularizers
from tensorflow.keras.callbacks import EarlyStopping

sns.set(style="darkgrid")
"Done"

Out[14]:

'Done'

Testing GPU¶

In [15]:

print("TensorFlow version = ", tf.__version__)
if tf.test.is_built_with_cuda():
    physical_devices = tf.config.list_physical_devices('GPU') 
    print("CUDA enabled TF, Num GPUs:", len(physical_devices), physical_devices) 
    try:
        tf.config.experimental.set_memory_growth(physical_devices[0], enable=True)
    except:
        print("No Compatible GPU detected.")

TensorFlow version =  2.8.0
CUDA enabled TF, Num GPUs: 1 [PhysicalDevice(name='/physical_device:GPU:0', device_type='GPU')]

Struktur neural network di keras API¶

• Sequential model

Sequential model memungkinkan kita untuk membuat model layer demi layer secara berurutan. Untuk membuat variabel Sequential model dilakukan sebagai berikut:

from keras.models import Sequential
model = Sequential()

• Dense layer

Dense layer membuat fully connected layer dengan neuron-neuron yang terhubung pada layer sebelumnya. Pada dense layer ini kita dapat menentukan berapa banyak neuron dan fungsi aktivasi apa yang digunakan. Sebagai contoh untuk menambahkan Dense layer dengan neuron sebanyak 32 dan fungsi aktivasi sigmoid pada Sequential model dilakukan sebagai berikut:

model = Sequential()
model.add(Dense(32, input_dim=3, activation='sigmoid'))

input_dim berfungsi untuk menentukan banyaknya variabel input dan hanya ditentukan pada layer pertama.

• Dropout layer

Dropout layer adalah layer penting untuk mengurangi over-fitting dalam model neural network. Dropout layer akan mengurangi kompleksitas model neural network dengan mengurangi jumlah neuron secara acak sehingga hal ini dapat mencegah over-fitting. persentase jumlah neuron yang dikurangi dapat dilakukan dengan menentukan nilai dropout antara 0 sampai 1.

image source: https://www.tech-quantum.com/implementing-drop-out-regularization-in-neural-networks/

Untuk melakukan dropout pada layer sebelumnya sebesar 20% dapat dilakukan sebagai berikut:

model = Sequential()
model.add(Dense(32, input_dim=3, activation='sigmoid'))
model.add(Dropout(0.2))

• Compiler

Setelah membangun arsitektur neural network, kita perlu memilih tiga hal lagi pada tahap "kompilasi":

1. Loss Function: adalah bagaimana neural network dapat mengukur seberapa besar kesalahan pelatihan yang dilakukan pada data trainnya, dengan demikian model dapat meminimumkan kesalahan tersebut. Beberapa loss function pada Keras API dapat pilih tergantung pada permasalahannya

image source: https://keras.io/api/losses/

Pada contoh ini permasalahannya adalah regresi karena variabel targetnya berupa variabel kontinu sehingga kita akan memilih loss function untuk regresi. Loss function yang sering digunakan pada permasalahan regresi adalah Mean squared error (MSE). MSE berfungsi untuk menghitung rata-rata error kuadrat antara nilai prediksi dan nilai sebenarnya.

image source: https://towardsdatascience.com/deep-learning-which-loss-and-activation-functions-should-i-use-ac02f1c56aa8

1. Optimizer: adalah algoritma untuk meminimalkan loss function dengan memperbarui bobot-bobot pada model neural network secara iteratif. terdapat bebrapa optimizer pada Keras, di antaranya sebagai berikut:

Dari beberapa optimizer di atas, yang paling sering digunakan adalah Adam Optimizer. Pemilihan optimizer tersebut akan mempengaruhi lamanya proses pelatihan model untuk mencapai loss function yang minimum. berikut disajikan perbandingan proses meminimalkan loss function dengan beberapa optimzer

image source: https://machinelearningknowledge.ai/keras-optimizers-explained-with-examples-for-beginners/

1. Metric: adalah fungsi yang digunakan untuk menilai kinerja model yang telah dibuat. Fungsi metric mirip dengan loss function. Hanya saja tidak semua fungsi metric dapat dijadikan loss function (misal akurasi, karena kita tidak ingin meminimalkan akurasi). Sebaliknya seluruh loss function dapat dijadikan metric karena nilai loss function yang kecil dapat mengindikasi bahwa model cukup baik. Berikut metric-metric yang ada di Keras:

Pada contoh ini kita akan gunakan Mean Absolute Error (MAE) sebagai metric. MAE berfungsi untuk menghitung rata-rata selisih antara nilai prediksi dan nilai sebenarnya.

Untuk menambahkan compiler pada arsitektur neural network yang telah dibuat dapat dilakukan sebagai berikut:

model = Sequential()
model.add(Dense(32, input_dim=3, activation='sigmoid'))
model.add(Dropout(0.2))
model.compile(loss='mse', optimizer='adam', metrics=['mae'])

Membuat Model Neural Network¶

1. Import Modul¶

In [16]:

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

2. Membuat Fungsi Model Neural Network¶

Dalam membuat model neural network tidak harus berupa fungsi, namun dengan membuat fungsi model neural network akan lebih mudah dalam merubah parameter-parameternya.

Fungsi model neural network yang akan dibuat terdiri:

• input layer dengan 3 feature (jumlah_ruangan, jumlah_penghuni, luas_bangunan)
• 1 Dense hidden layer
• Dropout antara Dense hidden layer dan Dense output layer
• Dense output layer dengan 1 neuron (prediksi jumlah penggunaan energi)
• loss function yang digunakan adalah Mean Squared Error (MSE)
• optimizer yang digunakan adalah adam
• metric yang digunakan adalah Mean Absolute Error (MAE)

Parameter-parameter yang dijadikan sebagai input dari fungsi tersebut adalah:

• neurons: banyaknya neuron pada Dense layer (default = 10)
• activation: fungsi aktivasi yang digunakan (default = 'relu')
• dropout: persentase dropout (default = 0.2)

In [17]:

def create_model(neurons=10, activation='relu', dropout=0.2):
    # create model
    model = Sequential()
    model.add(Dense(neurons, input_dim=3, activation=activation))
    model.add(Dropout(dropout))
    model.add(Dense(1))
    # Compile model
    model.compile(loss='mse', optimizer='adam', metrics=['mae'])
    return model

3. Membuat Model¶

Misalkan kita akan membuat model dengan parameter-parameter input sebagai berikut:

• neuron = 32
• activation = 'sigmoid'
• dropout = 0.1

Maka kita dapat membuat model neural network sebagai berikut:

model = create_model(32,'sigmoid',0.1)

Atau jika ingin membuat model dengan input default:

model = create_model()

Kita dapat melihat arsitektur model yang kita buat dengan cara berikut:

model.summary()

In [18]:

model = create_model(32,'sigmoid',0.1)
model.summary()

Model: "sequential"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 dense (Dense)               (None, 32)                128       
                                                                 
 dropout (Dropout)           (None, 32)                0         
                                                                 
 dense_1 (Dense)             (None, 1)                 33        
                                                                 
=================================================================
Total params: 161
Trainable params: 161
Non-trainable params: 0
_________________________________________________________________

4. Training Model¶

Training model dapat dilakukan sebagai berkut:

history = model.fit(X_train_scaled,y_train_scaled, batch_size=32, epochs=100, validation_split=0.1, verbose=2)

Perhatikan parameter epochs dan batch_size

image source: https://jerryan.medium.com/batch-size-a15958708a6

Stochastic Gradient Descent, Clearly Explained!!!: https://www.youtube.com/watch?v=vMh0zPT0tLI

Parameter-parameter model.fit()

• bacth_size: adalah banyaknya sampel pada satu kali training yang digunakan untuk memperbarui seluruh bobot
• epochs: adalah banyaknya proses training dengan seluruh sampel.
• validation_split: adalah persentase data yang digunakan sebagai data validasi
• verbose: adalah opsi untuk menampilkan proses training (0 = silent, 1 = progress bar, 2 = one line per epoch)

In [19]:

# fit model

history = model.fit(X_train_scaled,y_train_scaled, epochs=100, batch_size=32, validation_split=0.1, verbose=2)

Epoch 1/100
12/12 - 2s - loss: 0.7733 - mae: 0.8225 - val_loss: 0.4848 - val_mae: 0.6490 - 2s/epoch - 178ms/step
Epoch 2/100
12/12 - 0s - loss: 0.4198 - mae: 0.5796 - val_loss: 0.2534 - val_mae: 0.4299 - 44ms/epoch - 4ms/step
Epoch 3/100
12/12 - 0s - loss: 0.2393 - mae: 0.3985 - val_loss: 0.1337 - val_mae: 0.2946 - 47ms/epoch - 4ms/step
Epoch 4/100
12/12 - 0s - loss: 0.1284 - mae: 0.2756 - val_loss: 0.0891 - val_mae: 0.2270 - 42ms/epoch - 4ms/step
Epoch 5/100
12/12 - 0s - loss: 0.1050 - mae: 0.2553 - val_loss: 0.0778 - val_mae: 0.2078 - 47ms/epoch - 4ms/step
Epoch 6/100
12/12 - 0s - loss: 0.1022 - mae: 0.2483 - val_loss: 0.0762 - val_mae: 0.2038 - 47ms/epoch - 4ms/step
Epoch 7/100
12/12 - 0s - loss: 0.0922 - mae: 0.2432 - val_loss: 0.0746 - val_mae: 0.2009 - 46ms/epoch - 4ms/step
Epoch 8/100
12/12 - 0s - loss: 0.0944 - mae: 0.2393 - val_loss: 0.0725 - val_mae: 0.1976 - 44ms/epoch - 4ms/step
Epoch 9/100
12/12 - 0s - loss: 0.0951 - mae: 0.2463 - val_loss: 0.0705 - val_mae: 0.1945 - 36ms/epoch - 3ms/step
Epoch 10/100
12/12 - 0s - loss: 0.0896 - mae: 0.2325 - val_loss: 0.0687 - val_mae: 0.1921 - 37ms/epoch - 3ms/step
Epoch 11/100
12/12 - 0s - loss: 0.1040 - mae: 0.2574 - val_loss: 0.0672 - val_mae: 0.1901 - 34ms/epoch - 3ms/step
Epoch 12/100
12/12 - 0s - loss: 0.0970 - mae: 0.2450 - val_loss: 0.0647 - val_mae: 0.1857 - 33ms/epoch - 3ms/step
Epoch 13/100
12/12 - 0s - loss: 0.0854 - mae: 0.2300 - val_loss: 0.0621 - val_mae: 0.1801 - 35ms/epoch - 3ms/step
Epoch 14/100
12/12 - 0s - loss: 0.0862 - mae: 0.2353 - val_loss: 0.0602 - val_mae: 0.1762 - 37ms/epoch - 3ms/step
Epoch 15/100
12/12 - 0s - loss: 0.0824 - mae: 0.2315 - val_loss: 0.0583 - val_mae: 0.1726 - 42ms/epoch - 4ms/step
Epoch 16/100
12/12 - 0s - loss: 0.0763 - mae: 0.2196 - val_loss: 0.0568 - val_mae: 0.1707 - 55ms/epoch - 5ms/step
Epoch 17/100
12/12 - 0s - loss: 0.0838 - mae: 0.2268 - val_loss: 0.0553 - val_mae: 0.1686 - 47ms/epoch - 4ms/step
Epoch 18/100
12/12 - 0s - loss: 0.0759 - mae: 0.2152 - val_loss: 0.0537 - val_mae: 0.1648 - 39ms/epoch - 3ms/step
Epoch 19/100
12/12 - 0s - loss: 0.0812 - mae: 0.2291 - val_loss: 0.0523 - val_mae: 0.1618 - 52ms/epoch - 4ms/step
Epoch 20/100
12/12 - 0s - loss: 0.0858 - mae: 0.2271 - val_loss: 0.0509 - val_mae: 0.1613 - 44ms/epoch - 4ms/step
Epoch 21/100
12/12 - 0s - loss: 0.0643 - mae: 0.1988 - val_loss: 0.0498 - val_mae: 0.1616 - 44ms/epoch - 4ms/step
Epoch 22/100
12/12 - 0s - loss: 0.0816 - mae: 0.2292 - val_loss: 0.0482 - val_mae: 0.1573 - 44ms/epoch - 4ms/step
Epoch 23/100
12/12 - 0s - loss: 0.0723 - mae: 0.2069 - val_loss: 0.0473 - val_mae: 0.1602 - 40ms/epoch - 3ms/step
Epoch 24/100
12/12 - 0s - loss: 0.0650 - mae: 0.1994 - val_loss: 0.0458 - val_mae: 0.1548 - 44ms/epoch - 4ms/step
Epoch 25/100
12/12 - 0s - loss: 0.0710 - mae: 0.2032 - val_loss: 0.0446 - val_mae: 0.1519 - 40ms/epoch - 3ms/step
Epoch 26/100
12/12 - 0s - loss: 0.0713 - mae: 0.2138 - val_loss: 0.0436 - val_mae: 0.1477 - 41ms/epoch - 3ms/step
Epoch 27/100
12/12 - 0s - loss: 0.0690 - mae: 0.2036 - val_loss: 0.0426 - val_mae: 0.1470 - 47ms/epoch - 4ms/step
Epoch 28/100
12/12 - 0s - loss: 0.0707 - mae: 0.2100 - val_loss: 0.0419 - val_mae: 0.1523 - 42ms/epoch - 3ms/step
Epoch 29/100
12/12 - 0s - loss: 0.0619 - mae: 0.1984 - val_loss: 0.0408 - val_mae: 0.1491 - 38ms/epoch - 3ms/step
Epoch 30/100
12/12 - 0s - loss: 0.0658 - mae: 0.1993 - val_loss: 0.0399 - val_mae: 0.1444 - 36ms/epoch - 3ms/step
Epoch 31/100
12/12 - 0s - loss: 0.0686 - mae: 0.2063 - val_loss: 0.0396 - val_mae: 0.1530 - 38ms/epoch - 3ms/step
Epoch 32/100
12/12 - 0s - loss: 0.0626 - mae: 0.1942 - val_loss: 0.0390 - val_mae: 0.1533 - 36ms/epoch - 3ms/step
Epoch 33/100
12/12 - 0s - loss: 0.0669 - mae: 0.1978 - val_loss: 0.0379 - val_mae: 0.1478 - 37ms/epoch - 3ms/step
Epoch 34/100
12/12 - 0s - loss: 0.0592 - mae: 0.1864 - val_loss: 0.0374 - val_mae: 0.1469 - 36ms/epoch - 3ms/step
Epoch 35/100
12/12 - 0s - loss: 0.0671 - mae: 0.2030 - val_loss: 0.0367 - val_mae: 0.1445 - 36ms/epoch - 3ms/step
Epoch 36/100
12/12 - 0s - loss: 0.0699 - mae: 0.2004 - val_loss: 0.0359 - val_mae: 0.1414 - 38ms/epoch - 3ms/step
Epoch 37/100
12/12 - 0s - loss: 0.0553 - mae: 0.1810 - val_loss: 0.0355 - val_mae: 0.1445 - 37ms/epoch - 3ms/step
Epoch 38/100
12/12 - 0s - loss: 0.0605 - mae: 0.1905 - val_loss: 0.0352 - val_mae: 0.1464 - 35ms/epoch - 3ms/step
Epoch 39/100
12/12 - 0s - loss: 0.0596 - mae: 0.1900 - val_loss: 0.0346 - val_mae: 0.1429 - 37ms/epoch - 3ms/step
Epoch 40/100
12/12 - 0s - loss: 0.0570 - mae: 0.1817 - val_loss: 0.0341 - val_mae: 0.1369 - 37ms/epoch - 3ms/step
Epoch 41/100
12/12 - 0s - loss: 0.0609 - mae: 0.1873 - val_loss: 0.0340 - val_mae: 0.1435 - 35ms/epoch - 3ms/step
Epoch 42/100
12/12 - 0s - loss: 0.0613 - mae: 0.1922 - val_loss: 0.0338 - val_mae: 0.1448 - 38ms/epoch - 3ms/step
Epoch 43/100
12/12 - 0s - loss: 0.0511 - mae: 0.1757 - val_loss: 0.0331 - val_mae: 0.1380 - 42ms/epoch - 4ms/step
Epoch 44/100
12/12 - 0s - loss: 0.0547 - mae: 0.1793 - val_loss: 0.0328 - val_mae: 0.1365 - 43ms/epoch - 4ms/step
Epoch 45/100
12/12 - 0s - loss: 0.0593 - mae: 0.1884 - val_loss: 0.0330 - val_mae: 0.1445 - 44ms/epoch - 4ms/step
Epoch 46/100
12/12 - 0s - loss: 0.0592 - mae: 0.1914 - val_loss: 0.0329 - val_mae: 0.1458 - 38ms/epoch - 3ms/step
Epoch 47/100
12/12 - 0s - loss: 0.0631 - mae: 0.1946 - val_loss: 0.0321 - val_mae: 0.1390 - 36ms/epoch - 3ms/step
Epoch 48/100
12/12 - 0s - loss: 0.0558 - mae: 0.1859 - val_loss: 0.0318 - val_mae: 0.1350 - 37ms/epoch - 3ms/step
Epoch 49/100
12/12 - 0s - loss: 0.0513 - mae: 0.1791 - val_loss: 0.0317 - val_mae: 0.1385 - 36ms/epoch - 3ms/step
Epoch 50/100
12/12 - 0s - loss: 0.0534 - mae: 0.1783 - val_loss: 0.0315 - val_mae: 0.1385 - 39ms/epoch - 3ms/step
Epoch 51/100
12/12 - 0s - loss: 0.0452 - mae: 0.1679 - val_loss: 0.0313 - val_mae: 0.1384 - 37ms/epoch - 3ms/step
Epoch 52/100
12/12 - 0s - loss: 0.0529 - mae: 0.1786 - val_loss: 0.0310 - val_mae: 0.1359 - 36ms/epoch - 3ms/step
Epoch 53/100
12/12 - 0s - loss: 0.0593 - mae: 0.1886 - val_loss: 0.0309 - val_mae: 0.1309 - 43ms/epoch - 4ms/step
Epoch 54/100
12/12 - 0s - loss: 0.0577 - mae: 0.1791 - val_loss: 0.0307 - val_mae: 0.1375 - 39ms/epoch - 3ms/step
Epoch 55/100
12/12 - 0s - loss: 0.0540 - mae: 0.1867 - val_loss: 0.0312 - val_mae: 0.1440 - 50ms/epoch - 4ms/step
Epoch 56/100
12/12 - 0s - loss: 0.0441 - mae: 0.1693 - val_loss: 0.0307 - val_mae: 0.1407 - 63ms/epoch - 5ms/step
Epoch 57/100
12/12 - 0s - loss: 0.0454 - mae: 0.1630 - val_loss: 0.0302 - val_mae: 0.1325 - 43ms/epoch - 4ms/step
Epoch 58/100
12/12 - 0s - loss: 0.0488 - mae: 0.1733 - val_loss: 0.0302 - val_mae: 0.1365 - 47ms/epoch - 4ms/step
Epoch 59/100
12/12 - 0s - loss: 0.0549 - mae: 0.1824 - val_loss: 0.0302 - val_mae: 0.1385 - 45ms/epoch - 4ms/step
Epoch 60/100
12/12 - 0s - loss: 0.0479 - mae: 0.1701 - val_loss: 0.0298 - val_mae: 0.1320 - 47ms/epoch - 4ms/step
Epoch 61/100
12/12 - 0s - loss: 0.0474 - mae: 0.1648 - val_loss: 0.0297 - val_mae: 0.1315 - 37ms/epoch - 3ms/step
Epoch 62/100
12/12 - 0s - loss: 0.0486 - mae: 0.1670 - val_loss: 0.0297 - val_mae: 0.1365 - 38ms/epoch - 3ms/step
Epoch 63/100
12/12 - 0s - loss: 0.0440 - mae: 0.1623 - val_loss: 0.0296 - val_mae: 0.1354 - 39ms/epoch - 3ms/step
Epoch 64/100
12/12 - 0s - loss: 0.0472 - mae: 0.1697 - val_loss: 0.0294 - val_mae: 0.1339 - 37ms/epoch - 3ms/step
Epoch 65/100
12/12 - 0s - loss: 0.0430 - mae: 0.1592 - val_loss: 0.0294 - val_mae: 0.1296 - 44ms/epoch - 4ms/step
Epoch 66/100
12/12 - 0s - loss: 0.0487 - mae: 0.1722 - val_loss: 0.0297 - val_mae: 0.1388 - 44ms/epoch - 4ms/step
Epoch 67/100
12/12 - 0s - loss: 0.0493 - mae: 0.1680 - val_loss: 0.0295 - val_mae: 0.1382 - 41ms/epoch - 3ms/step
Epoch 68/100
12/12 - 0s - loss: 0.0549 - mae: 0.1808 - val_loss: 0.0290 - val_mae: 0.1320 - 41ms/epoch - 3ms/step
Epoch 69/100
12/12 - 0s - loss: 0.0416 - mae: 0.1596 - val_loss: 0.0288 - val_mae: 0.1283 - 45ms/epoch - 4ms/step
Epoch 70/100
12/12 - 0s - loss: 0.0520 - mae: 0.1727 - val_loss: 0.0286 - val_mae: 0.1315 - 52ms/epoch - 4ms/step
Epoch 71/100
12/12 - 0s - loss: 0.0426 - mae: 0.1613 - val_loss: 0.0286 - val_mae: 0.1275 - 41ms/epoch - 3ms/step
Epoch 72/100
12/12 - 0s - loss: 0.0465 - mae: 0.1588 - val_loss: 0.0285 - val_mae: 0.1276 - 41ms/epoch - 3ms/step
Epoch 73/100
12/12 - 0s - loss: 0.0476 - mae: 0.1671 - val_loss: 0.0286 - val_mae: 0.1341 - 37ms/epoch - 3ms/step
Epoch 74/100
12/12 - 0s - loss: 0.0504 - mae: 0.1740 - val_loss: 0.0284 - val_mae: 0.1318 - 38ms/epoch - 3ms/step
Epoch 75/100
12/12 - 0s - loss: 0.0453 - mae: 0.1641 - val_loss: 0.0284 - val_mae: 0.1261 - 36ms/epoch - 3ms/step
Epoch 76/100
12/12 - 0s - loss: 0.0519 - mae: 0.1692 - val_loss: 0.0283 - val_mae: 0.1310 - 36ms/epoch - 3ms/step
Epoch 77/100
12/12 - 0s - loss: 0.0423 - mae: 0.1554 - val_loss: 0.0285 - val_mae: 0.1346 - 34ms/epoch - 3ms/step
Epoch 78/100
12/12 - 0s - loss: 0.0405 - mae: 0.1583 - val_loss: 0.0284 - val_mae: 0.1329 - 35ms/epoch - 3ms/step
Epoch 79/100
12/12 - 0s - loss: 0.0433 - mae: 0.1583 - val_loss: 0.0284 - val_mae: 0.1335 - 36ms/epoch - 3ms/step
Epoch 80/100
12/12 - 0s - loss: 0.0383 - mae: 0.1530 - val_loss: 0.0282 - val_mae: 0.1325 - 38ms/epoch - 3ms/step
Epoch 81/100
12/12 - 0s - loss: 0.0430 - mae: 0.1638 - val_loss: 0.0280 - val_mae: 0.1290 - 37ms/epoch - 3ms/step
Epoch 82/100
12/12 - 0s - loss: 0.0470 - mae: 0.1651 - val_loss: 0.0280 - val_mae: 0.1238 - 34ms/epoch - 3ms/step
Epoch 83/100
12/12 - 0s - loss: 0.0475 - mae: 0.1691 - val_loss: 0.0279 - val_mae: 0.1243 - 37ms/epoch - 3ms/step
Epoch 84/100
12/12 - 0s - loss: 0.0398 - mae: 0.1532 - val_loss: 0.0278 - val_mae: 0.1287 - 40ms/epoch - 3ms/step
Epoch 85/100
12/12 - 0s - loss: 0.0428 - mae: 0.1537 - val_loss: 0.0277 - val_mae: 0.1275 - 33ms/epoch - 3ms/step
Epoch 86/100
12/12 - 0s - loss: 0.0420 - mae: 0.1572 - val_loss: 0.0277 - val_mae: 0.1280 - 45ms/epoch - 4ms/step
Epoch 87/100
12/12 - 0s - loss: 0.0370 - mae: 0.1477 - val_loss: 0.0277 - val_mae: 0.1281 - 41ms/epoch - 3ms/step
Epoch 88/100
12/12 - 0s - loss: 0.0399 - mae: 0.1523 - val_loss: 0.0280 - val_mae: 0.1343 - 38ms/epoch - 3ms/step
Epoch 89/100
12/12 - 0s - loss: 0.0366 - mae: 0.1534 - val_loss: 0.0277 - val_mae: 0.1314 - 46ms/epoch - 4ms/step
Epoch 90/100
12/12 - 0s - loss: 0.0387 - mae: 0.1498 - val_loss: 0.0276 - val_mae: 0.1264 - 43ms/epoch - 4ms/step
Epoch 91/100
12/12 - 0s - loss: 0.0367 - mae: 0.1448 - val_loss: 0.0275 - val_mae: 0.1256 - 44ms/epoch - 4ms/step
Epoch 92/100
12/12 - 0s - loss: 0.0426 - mae: 0.1571 - val_loss: 0.0276 - val_mae: 0.1282 - 50ms/epoch - 4ms/step
Epoch 93/100
12/12 - 0s - loss: 0.0397 - mae: 0.1523 - val_loss: 0.0275 - val_mae: 0.1285 - 49ms/epoch - 4ms/step
Epoch 94/100
12/12 - 0s - loss: 0.0376 - mae: 0.1459 - val_loss: 0.0276 - val_mae: 0.1302 - 50ms/epoch - 4ms/step
Epoch 95/100
12/12 - 0s - loss: 0.0390 - mae: 0.1477 - val_loss: 0.0279 - val_mae: 0.1345 - 42ms/epoch - 3ms/step
Epoch 96/100
12/12 - 0s - loss: 0.0399 - mae: 0.1562 - val_loss: 0.0274 - val_mae: 0.1272 - 43ms/epoch - 4ms/step
Epoch 97/100
12/12 - 0s - loss: 0.0363 - mae: 0.1409 - val_loss: 0.0273 - val_mae: 0.1271 - 52ms/epoch - 4ms/step
Epoch 98/100
12/12 - 0s - loss: 0.0393 - mae: 0.1464 - val_loss: 0.0273 - val_mae: 0.1265 - 45ms/epoch - 4ms/step
Epoch 99/100
12/12 - 0s - loss: 0.0429 - mae: 0.1569 - val_loss: 0.0273 - val_mae: 0.1269 - 46ms/epoch - 4ms/step
Epoch 100/100
12/12 - 0s - loss: 0.0362 - mae: 0.1469 - val_loss: 0.0273 - val_mae: 0.1279 - 51ms/epoch - 4ms/step

Kita dapat melihat grafik loss function MSE dan metric MAE terhadap epoch untuk melihat performa model kita dengan cara sebagai berikut

In [20]:

# grafik loss function MSE

plt.plot(history.history['loss'], label='Training loss')
plt.plot(history.history['val_loss'], label='Validation loss')
plt.title('loss function MSE')
plt.ylabel('MSE')
plt.xlabel('Epoch')
plt.legend()

Out[20]:

<matplotlib.legend.Legend at 0x1bb82fe61f0>

In [21]:

# grafik metric MAE
plt.plot(history.history['mae'], label='Training MAE')
plt.plot(history.history['val_mae'], label='Validation MAE')
plt.title('metric MAE')
plt.ylabel('MAE')
plt.xlabel('Epoch')
plt.legend()

Out[21]:

<matplotlib.legend.Legend at 0x1bbdebb2fa0>

Perhatikan kedua grafik di atas. Kita dapat lihat kurang lebih pada epoch ke 40 nilai loss function dan metric sudah cukup stabil. sehingga sebenarnya kita cukup menentukan epochs = 40

Early Stopping¶

Bagaimana menentukan nilai epochs?

Perhatikan gambar berikut!¶

• Training seharusnya dihentikan saat epoch berada pada garis optimal seperti gambar di atas. Yaitu ketika nilai loss function pada data validasi mulai naik (sebelum terjadi overfitting) ataupun bisa juga ketika nilainya cukup stabil seperti pada kasus model kita.
• Hal tersebut dapat dilakukan dengan menambahkan Early Stopping yang memiliki parameter sebagai berikut:

1. monitor: nilai yang diamati, biasanya adalah nilai loss function pada data validasi (bisa juga metric validasi)
2. mode: terdapat 3 mode yaitu "min" (training berhenti ketika nilai yang diamati berhenti turun), "max" (training berhenti ketika nilai yang diamati berhenti naik), dan "auto"
3. min_delta: besarnya selisih mutlak yang tidak dianggap mengalami perbaikan (naik/turun)
4. patience: banyaknya epoch setelah nilai yang diamati tidak mengalami perbaikan
5. verbose: adalah opsi untuk menampilkan epoch ke berapa saat proses training berhenti (0 = silent, 1 = display)

Mari kita coba membuat model menggunakan Early Stopping dengan parameter-parameter berikut

• monitor = 'val_loss' (nilai yang diamati adalah loss function pada data validasi)
• mode = "min" (mode "min" karena kita mengharapkan val_loss selalu turun)
• min_delta = 0.01 (ketika val_loss turun kurang dari 0.01 dianggap tidak terjadi penurunan, maka training berhenti)
• patience = 10 (ketika tidak terjadi penurunan, maka training berhenti setelah 10 epoch lagi dilakukan)
• verbose = 1 (menampilkan epoch ke berapa saat proses training berhenti)

In [22]:

# Create model
model = create_model(32,'sigmoid',0.1)

# Early Stopping
from keras.callbacks import EarlyStopping
es = EarlyStopping(monitor = 'val_loss', mode = "min", min_delta = 0.01, patience = 10, verbose = 1)

# fit model
history = model.fit(X_train_scaled,y_train_scaled,
                    epochs=100, batch_size=32,
                    validation_split=0.1, callbacks = [es],
                    verbose=2)

Epoch 1/100
12/12 - 0s - loss: 0.1657 - mae: 0.3509 - val_loss: 0.0768 - val_mae: 0.2442 - 433ms/epoch - 36ms/step
Epoch 2/100
12/12 - 0s - loss: 0.0831 - mae: 0.2299 - val_loss: 0.0477 - val_mae: 0.1571 - 45ms/epoch - 4ms/step
Epoch 3/100
12/12 - 0s - loss: 0.0725 - mae: 0.2124 - val_loss: 0.0487 - val_mae: 0.1534 - 48ms/epoch - 4ms/step
Epoch 4/100
12/12 - 0s - loss: 0.0878 - mae: 0.2311 - val_loss: 0.0460 - val_mae: 0.1539 - 47ms/epoch - 4ms/step
Epoch 5/100
12/12 - 0s - loss: 0.0771 - mae: 0.2193 - val_loss: 0.0453 - val_mae: 0.1610 - 44ms/epoch - 4ms/step
Epoch 6/100
12/12 - 0s - loss: 0.0619 - mae: 0.1914 - val_loss: 0.0439 - val_mae: 0.1530 - 42ms/epoch - 4ms/step
Epoch 7/100
12/12 - 0s - loss: 0.0719 - mae: 0.2073 - val_loss: 0.0430 - val_mae: 0.1513 - 44ms/epoch - 4ms/step
Epoch 8/100
12/12 - 0s - loss: 0.0699 - mae: 0.2025 - val_loss: 0.0423 - val_mae: 0.1558 - 43ms/epoch - 4ms/step
Epoch 9/100
12/12 - 0s - loss: 0.0726 - mae: 0.2159 - val_loss: 0.0412 - val_mae: 0.1489 - 41ms/epoch - 3ms/step
Epoch 10/100
12/12 - 0s - loss: 0.0801 - mae: 0.2120 - val_loss: 0.0405 - val_mae: 0.1508 - 43ms/epoch - 4ms/step
Epoch 11/100
12/12 - 0s - loss: 0.0753 - mae: 0.2052 - val_loss: 0.0397 - val_mae: 0.1511 - 39ms/epoch - 3ms/step
Epoch 12/100
12/12 - 0s - loss: 0.0690 - mae: 0.2070 - val_loss: 0.0389 - val_mae: 0.1521 - 42ms/epoch - 4ms/step
Epoch 12: early stopping

In [23]:

# grafik loss function MSE

plt.plot(history.history['loss'], label='Training loss')
plt.plot(history.history['val_loss'], label='Validation loss')
plt.title('loss function MSE')
plt.ylabel('MSE')
plt.xlabel('Epoch')
plt.legend()

Out[23]:

<matplotlib.legend.Legend at 0x1bbe4c10640>

Perhatikan Grafik di Atas.¶

Walaupun kita menetapkan epoch = 100, proses training terhenti pada epoch ke 15 karena kita menggunakan Early Stopping

5. Evaluasi Model dengan Data Test¶

• Sebelum melakukan evaluasi model dengan data test, kita akan melakukan prediksi pada data test dengan cara berikut:

y_pred = model.predict(X_test_scaled)

• Karena nilai prediksi di atas masih dalam scala MinMaxScaler (scaler2), maka kita perlu membalikkannya menggunakan fungsi inverse_transform() sebagai berikut:

y_pred = scaler2.inverse_transform(y_pred)

In [24]:

y_pred = model.predict(X_test_scaled)
y_pred = scaler2.inverse_transform(y_pred)

• Setelah melakukan prediksi barulah kita melakukan evaluasi terhadap nilai prediksi tersebut menggunakan metric yang digunakan yaitu MAE

In [25]:

# Mean Absolute Error (MAE) test data
mae = np.mean(np.abs(y_test-y_pred))
print('MAE data test sebesar:', mae)

MAE data test sebesar: 5.452018968185577

Apakah Nilai MAE Tersebut Bagus???¶

Melihat boxplot dari nilai error mutlak

In [26]:

abs_error = np.abs(y_test-y_pred)
sns.boxplot(y = abs_error)

Out[26]:

<AxesSubplot:>

Melihat range data test

In [27]:

print('minimum y_test', y_test.min())
print('maksimum y_test', y_test.max())

minimum y_test 8.3
maksimum y_test 50.0

TensorBoard¶

• Dalam machine learning, untuk meningkatkan suatu model kita sering kali harus bisa mengukurnya.
• TensorBoard adalah alat yang menyediakan pengukuran dan visualisasi yang diperlukan dalam proses kerja machine learning.
• Hal ini memungkinkan untuk mengamati eksperimen yang dilakukan seperti loss function dan metric evaluation, memvisualisasikan graf model, memproyeksikan embeddings ke ruang dimensi yang lebih rendah, dan banyak lagi.
• link :https://www.tensorflow.org/tensorboard/get_started

Untuk menggunakan TensorBoard pada model neural network, dapat dilakukan dengan cara berikut

In [28]:

# Load the TensorBoard notebook extension
%load_ext tensorboard

from tensorflow.keras.callbacks import TensorBoard
import datetime, os

In [29]:

# Create model
model = create_model(32,'sigmoid',0.1)

logdir = os.path.join("logs", datetime.datetime.now().strftime("%Y-%m-%d;%H-%M-%S"))
tensorboard_callback = TensorBoard(logdir, histogram_freq=1)

# Early Stopping
es = EarlyStopping(monitor = 'val_loss', mode = "min", min_delta = 0.01, patience = 10, verbose = 1)

# fit model
history = model.fit(X_train_scaled,y_train_scaled,
                    epochs=100, batch_size=32,
                    validation_split=0.1, callbacks = [es, tensorboard_callback],
                    verbose=2)

Epoch 1/100
12/12 - 0s - loss: 0.3210 - mae: 0.4647 - val_loss: 0.1636 - val_mae: 0.3259 - 320ms/epoch - 27ms/step
Epoch 2/100
12/12 - 0s - loss: 0.1858 - mae: 0.3496 - val_loss: 0.1082 - val_mae: 0.2618 - 55ms/epoch - 5ms/step
Epoch 3/100
12/12 - 0s - loss: 0.1395 - mae: 0.2955 - val_loss: 0.1048 - val_mae: 0.2464 - 60ms/epoch - 5ms/step
Epoch 4/100
12/12 - 0s - loss: 0.1438 - mae: 0.2979 - val_loss: 0.0994 - val_mae: 0.2375 - 57ms/epoch - 5ms/step
Epoch 5/100
12/12 - 0s - loss: 0.1388 - mae: 0.2963 - val_loss: 0.0926 - val_mae: 0.2291 - 57ms/epoch - 5ms/step
Epoch 6/100
12/12 - 0s - loss: 0.1367 - mae: 0.2984 - val_loss: 0.0856 - val_mae: 0.2203 - 60ms/epoch - 5ms/step
Epoch 7/100
12/12 - 0s - loss: 0.1303 - mae: 0.2889 - val_loss: 0.0801 - val_mae: 0.2117 - 60ms/epoch - 5ms/step
Epoch 8/100
12/12 - 0s - loss: 0.1267 - mae: 0.2816 - val_loss: 0.0750 - val_mae: 0.2036 - 65ms/epoch - 5ms/step
Epoch 9/100
12/12 - 0s - loss: 0.1167 - mae: 0.2675 - val_loss: 0.0709 - val_mae: 0.1966 - 76ms/epoch - 6ms/step
Epoch 10/100
12/12 - 0s - loss: 0.1085 - mae: 0.2618 - val_loss: 0.0686 - val_mae: 0.1937 - 69ms/epoch - 6ms/step
Epoch 11/100
12/12 - 0s - loss: 0.1152 - mae: 0.2655 - val_loss: 0.0635 - val_mae: 0.1836 - 59ms/epoch - 5ms/step
Epoch 12/100
12/12 - 0s - loss: 0.0987 - mae: 0.2516 - val_loss: 0.0601 - val_mae: 0.1769 - 60ms/epoch - 5ms/step
Epoch 13/100
12/12 - 0s - loss: 0.0947 - mae: 0.2446 - val_loss: 0.0570 - val_mae: 0.1716 - 61ms/epoch - 5ms/step
Epoch 14/100
12/12 - 0s - loss: 0.0930 - mae: 0.2401 - val_loss: 0.0542 - val_mae: 0.1668 - 60ms/epoch - 5ms/step
Epoch 15/100
12/12 - 0s - loss: 0.1017 - mae: 0.2540 - val_loss: 0.0525 - val_mae: 0.1694 - 59ms/epoch - 5ms/step
Epoch 16/100
12/12 - 0s - loss: 0.0865 - mae: 0.2314 - val_loss: 0.0497 - val_mae: 0.1625 - 66ms/epoch - 5ms/step
Epoch 17/100
12/12 - 0s - loss: 0.0882 - mae: 0.2284 - val_loss: 0.0475 - val_mae: 0.1610 - 60ms/epoch - 5ms/step
Epoch 18/100
12/12 - 0s - loss: 0.0878 - mae: 0.2372 - val_loss: 0.0452 - val_mae: 0.1517 - 62ms/epoch - 5ms/step
Epoch 19/100
12/12 - 0s - loss: 0.0834 - mae: 0.2290 - val_loss: 0.0444 - val_mae: 0.1601 - 66ms/epoch - 6ms/step
Epoch 20/100
12/12 - 0s - loss: 0.0859 - mae: 0.2293 - val_loss: 0.0429 - val_mae: 0.1585 - 67ms/epoch - 6ms/step
Epoch 21/100
12/12 - 0s - loss: 0.0837 - mae: 0.2298 - val_loss: 0.0408 - val_mae: 0.1474 - 68ms/epoch - 6ms/step
Epoch 22/100
12/12 - 0s - loss: 0.0852 - mae: 0.2309 - val_loss: 0.0403 - val_mae: 0.1391 - 62ms/epoch - 5ms/step
Epoch 23/100
12/12 - 0s - loss: 0.0807 - mae: 0.2217 - val_loss: 0.0385 - val_mae: 0.1472 - 65ms/epoch - 5ms/step
Epoch 24/100
12/12 - 0s - loss: 0.0861 - mae: 0.2266 - val_loss: 0.0386 - val_mae: 0.1583 - 67ms/epoch - 6ms/step
Epoch 25/100
12/12 - 0s - loss: 0.0842 - mae: 0.2288 - val_loss: 0.0364 - val_mae: 0.1390 - 61ms/epoch - 5ms/step
Epoch 26/100
12/12 - 0s - loss: 0.0822 - mae: 0.2230 - val_loss: 0.0356 - val_mae: 0.1431 - 70ms/epoch - 6ms/step
Epoch 27/100
12/12 - 0s - loss: 0.0732 - mae: 0.2131 - val_loss: 0.0351 - val_mae: 0.1462 - 62ms/epoch - 5ms/step
Epoch 28/100
12/12 - 0s - loss: 0.0744 - mae: 0.2158 - val_loss: 0.0346 - val_mae: 0.1456 - 59ms/epoch - 5ms/step
Epoch 29/100
12/12 - 0s - loss: 0.0679 - mae: 0.2076 - val_loss: 0.0340 - val_mae: 0.1434 - 62ms/epoch - 5ms/step
Epoch 30/100
12/12 - 0s - loss: 0.0599 - mae: 0.1963 - val_loss: 0.0336 - val_mae: 0.1439 - 59ms/epoch - 5ms/step
Epoch 31/100
12/12 - 0s - loss: 0.0644 - mae: 0.1947 - val_loss: 0.0334 - val_mae: 0.1457 - 61ms/epoch - 5ms/step
Epoch 32/100
12/12 - 0s - loss: 0.0607 - mae: 0.1956 - val_loss: 0.0328 - val_mae: 0.1420 - 60ms/epoch - 5ms/step
Epoch 33/100
12/12 - 0s - loss: 0.0767 - mae: 0.2172 - val_loss: 0.0323 - val_mae: 0.1357 - 62ms/epoch - 5ms/step
Epoch 34/100
12/12 - 0s - loss: 0.0727 - mae: 0.2084 - val_loss: 0.0319 - val_mae: 0.1420 - 60ms/epoch - 5ms/step
Epoch 35/100
12/12 - 0s - loss: 0.0693 - mae: 0.2114 - val_loss: 0.0314 - val_mae: 0.1347 - 60ms/epoch - 5ms/step
Epoch 36/100
12/12 - 0s - loss: 0.0631 - mae: 0.1965 - val_loss: 0.0311 - val_mae: 0.1385 - 61ms/epoch - 5ms/step
Epoch 37/100
12/12 - 0s - loss: 0.0643 - mae: 0.1960 - val_loss: 0.0316 - val_mae: 0.1464 - 65ms/epoch - 5ms/step
Epoch 37: early stopping

In [30]:

%tensorboard --logdir=logs

Hyper-parameter Tuning¶

Berapa Banyak Neuron yang Diperlukan? Fungsi Aktivasi Apa yang Harus Digunakan? Berapa Persen Dropout yang Ditentukan?¶

• Pertanyaan di atas dapat dijawab dengan melakukan hyper-parameter tuning atau melakukan beberapa percobaan dan memilih hasil yang terbaik
• Hyper-parameter tuning dapat lakukan menggunakan fungsi GridSearchCV dari modul sklearn

• Namun untuk membuat model neural network menggunakan GridSearchCV, kita harus menggunakan fungsi model neural network dan dimasukan ke dalam KerasRegressor
• Selain fungsi model neural network, parameter-parameter yang dimasukan pada model.fit() seperti contoh sebelumnya juga dimasukan ke dalam KerasRegressor

Membuat Model Neural Network dengan Hyper-parameter Tuning¶

1. Import Modul¶

In [31]:

from sklearn.model_selection import GridSearchCV
from keras.wrappers.scikit_learn import KerasRegressor

2. Membuat Model dengan KerasRegressor¶

In [32]:

# Early Stopping
es = EarlyStopping(monitor = 'val_loss', mode = "min", min_delta = 0.005, patience = 5, verbose = 0)

# create model
model = KerasRegressor(build_fn=create_model, epochs=500, validation_split=0.1, batch_size=32, callbacks=[es], verbose=0)

3. Menentukan parameter-parameter¶

• Pada contoh ini kita akan melakukan percobaan terhadap jumlah neuron, fungsi aktivasi, dan persentase dropout.
• ketiga parameter tersebut beserta nila-nilai yang ingin digunakan kemudian dimasukan pada variabel param_grid dengan tipe data dictionary

In [33]:

# define the grid search parameters
neurons = [32, 64, 128]
activation = ['relu','sigmoid','tanh']
dropout=[0.1, 0.2, 0.3]
param_grid = dict(neurons=neurons, activation=activation, dropout=dropout)

4. Membuat Model dengan GridSearchCV¶

Model dengan GridSearchCV dibuat dengan memasukan beberapa parameter yaitu:

• estimator: model yang ingin dilakukan gridsearch
• param_grid: parameter yang ingin diuji
• n_jobs: Jumlah pekerjaan untuk dijalankan secara paralel. (-1 artinya menggunakan seluruh core processor)
• cv: banyaknya k-fold cross validation

In [34]:

grid = GridSearchCV(estimator=model, param_grid=param_grid, n_jobs=-1, cv=3)

5. Training Model dengan GridSearchCV¶

In [ ]:

grid_result = grid.fit(X_train_scaled, y_train_scaled)

6. Memilih Parameter Terbaik¶

In [ ]:

# summarize results
print("Best: %f using %s" % (grid_result.best_score_, grid_result.best_params_))
means = grid_result.cv_results_['mean_test_score']
stds = grid_result.cv_results_['std_test_score']
params = grid_result.cv_results_['params']
for mean, stdev, param in zip(means, stds, params):
    print("%f (%f) with: %r" % (mean, stdev, param))

Dari Hasil Training menggunakan GridSearchCV, kita peroleh:

• parameter terbaiknya adalah: {'activation': 'relu', 'dropout': 0.3, 'neurons': 128}
• Rata-rata Loss Function dari hasil Cross Validation adalah 0.047091

• Model terbaik dari hasil GridSearchCV kita masukan ke dalam variabel best_model dengan cara

best_model = grid_result.best_estimator_.model

• Kemudian coba kita lihat grafik loss function MSE dan metric MAE terhadap epoch untuk melihat performa model terbaik kita dengan cara sebagai berikut

In [ ]:

best_model = grid_result.best_estimator_.model
history = best_model.history

In [ ]:

# grafik loss function MSE

plt.plot(history.history['loss'], label='Training loss')
plt.plot(history.history['val_loss'], label='Validation loss')
plt.title('loss function MSE')
plt.ylabel('MSE')
plt.xlabel('Epoch')
plt.legend()

In [ ]:

# grafik metric MAE

plt.plot(history.history['mae'], label='Training MAE')
plt.plot(history.history['val_mae'], label='Validation MAE')
plt.title('metric MAE')
plt.ylabel('MAE')
plt.xlabel('Epoch')
plt.legend()

7. Evaluasi Model dengan Data Test¶

Dengan cara yang sama seperti pada contoh sebelumnya kita akan menghitung MAE pada data test.

In [ ]:

y_pred = best_model.predict(X_test_scaled)
y_pred = scaler2.inverse_transform(y_pred)

abs_error = np.abs(y_test-y_pred)

# Mean Absolute Error (MAE) test data
mae = np.mean(abs_error)
print('MAE data test sebesar:', mae)

sns.boxplot(y = abs_error)

Apakah Nilai MAE Tersebut Lebih Bagus dari Sebelumnya???¶

Membandingkan Nilai MAE dari Hasil Regresi Linear¶

In [ ]:

from sklearn.linear_model import LinearRegression

reg = LinearRegression()

reg.fit(X_train, y_train)
reg_pred = reg.predict(X_test)

abs_error = np.abs(y_test-reg_pred)

# Mean Absolute Error (MAE) test data dari model regresi
mae = np.mean(abs_error)
print('MAE data test sebesar:', mae)

sns.boxplot(y = abs_error)

Latihan¶

Dengan menggunakan data konsumsi energi tiap rumah di atas, buatlah model neural network untuk memprediksi kolom listrik berdasarkan input kolom luas_bangunan dengan ketentuan sebagai berikut!¶

1. Arsitektur neural network terdiri dari:

• Input layer, hidden layer (Dense layer, Dropout, Dense layer), Dense ouput layer
• Fungsi aktivasi yang digunakan pada kedua Dense layer adalah 'ReLu'
• Persentase Dropout yang digunakan 10%
• Compiler: loss='mse', optimizer='adam', metrics=['mae']

1. Model dibuat menggunakan GridSearchCV dengan paramater yang diuji:

• banyaknya neuron pada Dense layer pertama = [16,32,64]
• banyaknya neuron pada Dense layer kedua = [10,20,30]

1. Early Stopping diterapkan sehingga training berhenti pada saat epoch yang optimal

2. Lakukan evaluasi pada data test dan simpulkan hasil evaluasi tersebut

Akhir Modul DL-01 Introduction to Network Model and Tensorflow¶

---