🛠️ Teknik Rahasia Deep Learning : Dropout dan Batch Normalization

Halo temen”, setelah di bab sebelumnya kita belajar seni menyeimbangkan Kapasitas Model dan menerapkan Early Stopping untuk mencegah Overfitting, kini kita akan melangkah lebih jauh dengan dua teknik yang akan kita pelajari, yaitu Dropout dan Batch Normalization. Dimana ini adalah tool penting yang digunakan hampir di setiap Neural Network modern

📘 link kaggle materi Dropout and Batch Normalization

Dropout

Dropout adalah bentuk regularization/penghalusan yang efektif dan sederhana untuk mengatasi overfitting. Dimana selama training, Dropout secara acak menonaktifkan sejumlah neuron dengan probabilitas tertentu

Bayangkan sebuah komite yang terdiri dari banyak anggota/neuron. Jika komite selalu bekerja sama, beberapa anggota akan menjadi terlalu bergantung pada anggota lain. Dropout memaksa setiap anggota untuk berpikir secara independen, karena mereka tidak tahu neuron mana yang akan dinonaktifkan di langkah berikutnya

Dropout memaksa network untuk mempelajari fitur yang lebih independen dan kuat (robust) karena tidak ada neuron yang bisa terlalu bergantung pada kehadiran neuron lain. Ini seperti melatih banyak network kecil yang berbeda secara paralel. Kita menentukan rate atau laju dropout, yaitu fraksi neuron yang akan dinonaktifkan. Nilai umum biasanya antara 0,3 sampai 0,5. **Dropout hanya diterapkan selama fase training*. Selama validasi atau inferensi, Dropout* dimatikan agar model menggunakan semua neuron yang telah dilatih

Batch Normalization

Batch Normalization adalah teknik yang sangat kuat yang tidak hanya berfungsi sebagai regularizer ringan tetapi juga secara drastis mempercepat dan menstabilkan proses training

Selama proses SGD, weights pada layer awal terus berubah. Perubahan ini menyebabkan distribusi input ke layer yang lebih tinggi juga berubah secara terus-menerus. Fenomena ini disebut Internal Covariate Shift. Analoginya ada konveyor makanan (input) ke koki (neuron). Jika konveyornya tiba-tiba mengubah kecepatan dan ukuran makanan setiap detik, koki akan kesulitan menyesuaikan diri dan bekerja dengan efisien

Dengan input yang stabil, layer berikutnya dapat belajar lebih cepat dan lebih efisien. Batch Norm memungkinkan kita menggunakan learning rate yang lebih tinggi tanpa membuat proses training menjadi tidak stabil. Dan Batch Norm harus diletakkan sebelum fungsi aktivasi pada suatu layer

Contoh Penggunaan dalam Arsitektur Keras

layers.Dense(16, activation='relu'),
layers.BatchNormalization(),

atau diantara satu lapisan dan fungsi aktivasinya

layers.Dense(16),
layers.BatchNormalization(),
layers.Activation('relu'),

Kedua teknik ini sangat esensial dalam deep learning karena mereka memungkinkan kita membangun model yang sangat besar dan kompleks tanpa terlalu khawatir akan ketidakstabilan atau overfitting

Pengerjaan Exercise

📘 link exercise saya : Dropout and Batch Normalization

Setup, Import Library, dan Preprocessing Data

# Setup plotting
import matplotlib.pyplot as plt
plt.style.use('seaborn-v0_8-whitegrid')
# Set Matplotlib defaults
plt.rc('figure', autolayout=True)
plt.rc('axes', labelweight='bold', labelsize='large',
       titleweight='bold', titlesize=18, titlepad=10)
plt.rc('animation', html='html5')

# Setup feedback system
from learntools.core import binder
binder.bind(globals())
from learntools.deep_learning_intro.ex5 import *
import pandas as pd
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.compose import make_column_transformer
from sklearn.model_selection import GroupShuffleSplit

from tensorflow import keras
from tensorflow.keras import layers
from tensorflow.keras import callbacks

spotify = pd.read_csv('../input/dl-course-data/spotify.csv')

X = spotify.copy().dropna()
y = X.pop('track_popularity')
artists = X['track_artist']

features_num = ['danceability', 'energy', 'key', 'loudness', 'mode',
                'speechiness', 'acousticness', 'instrumentalness',
                'liveness', 'valence', 'tempo', 'duration_ms']
features_cat = ['playlist_genre']

preprocessor = make_column_transformer(
    (StandardScaler(), features_num),
    (OneHotEncoder(), features_cat),
)

def group_split(X, y, group, train_size=0.75):
    splitter = GroupShuffleSplit(train_size=train_size)
    train, test = next(splitter.split(X, y, groups=group))
    return (X.iloc[train], X.iloc[test], y.iloc[train], y.iloc[test])

X_train, X_valid, y_train, y_valid = group_split(X, y, artists)

X_train = preprocessor.fit_transform(X_train)
X_valid = preprocessor.transform(X_valid)
y_train = y_train / 100
y_valid = y_valid / 100

input_shape = [X_train.shape[1]]
print("Input shape: {}".format(input_shape))

Kita mengimpor semua tool yang dibutuhkan, termasuk GroupShuffleSplit untuk membagi data tanpa data leakage dan callbacks untuk teknik seperti Early Stopping, meskipun tidak digunakan di sini, tapi bagus untuk kontrol training. Dan data Spotify dimuat, fitur numerik distandardisasi denganStandardScaler, dan fitur kategorikal di-encode denganOneHotEncoder. Serta pembagian data menggunakan GroupShuffleSplit untuk memastikan lagu dari artis yang sama tidak bercampur antara training dan validation untuk menjaga validitas pengujian model.

Implementasi Dropout

Tujuan dari bagian ini adalah menggunakan Dropout untuk mengurangi overfitting yang terjadi pada model berkapasitas tinggi

# YOUR CODE HERE: Add two 30% dropout layers, one after 128 and one after 64
model = keras.Sequential([
    layers.Dense(128, activation='relu', input_shape=input_shape),
    layers.Dropout(0.3),
    layers.Dense(64, activation='relu'),
    layers.Dropout(0.3),
    layers.Dense(1)
])

# Check your answer
q_1.check()

Layer Dropout(0.3) secara acak menonaktifkan 30% neuron pada layer sebelumnya selama training. Ini memaksa neuron yang tersisa untuk belajar fitur yang lebih mandiri dan kuat, sehingga secara efektif mengurangi overfitting

Melatih Model dengan Dropout

model.compile(
    optimizer='adam',
    loss='mae',
)
history = model.fit(
    X_train, y_train,
    validation_data=(X_valid, y_valid),
    batch_size=512,
    epochs=50,
    verbose=0,
)
history_df = pd.DataFrame(history.history)
history_df.loc[:, ['loss', 'val_loss']].plot()
print("Minimum Validation Loss: {:0.4f}".format(history_df['val_loss'].min()))

Setelah di-plot,bisa kita lihat bahwa jarak antara kurva loss dan val_loss menjadi lebih kecil dibandingkan saat tidak ada Dropout. Ini adalah indikasi bahwa Dropout berhasil membuat model general dan menahan overfitting

Implementasi Batch Normalization

Bagian ini menggunakan dataset Concrete untuk menunjukkan bagaimana Batch Normalization dapat menstabilkan dan mempercepat training, terutama ketika menggunakan optimizer yang sensitif seperti SGD

import pandas as pd

concrete = pd.read_csv('../input/dl-course-data/concrete.csv')
df = concrete.copy()

df_train = df.sample(frac=0.7, random_state=0)
df_valid = df.drop(df_train.index)

X_train = df_train.drop('CompressiveStrength', axis=1)
X_valid = df_valid.drop('CompressiveStrength', axis=1)
y_train = df_train['CompressiveStrength']
y_valid = df_valid['CompressiveStrength']

input_shape = [X_train.shape[1]]

Model ini dilatih menggunakan optimizer SGD. Karena SGD sensitif terhadap perbedaan skala input antar layer / Internal Covariate Shift, training tanpa Batch Norm akan lambat dan loss sulit turun secara stabil

Menambahkan Layer Batch Normalization

model = keras.Sequential([
    layers.Dense(512, activation='relu', input_shape=input_shape),
    layers.Dense(512, activation='relu'),    
    layers.Dense(512, activation='relu'),
    layers.Dense(1),
])
model.compile(
    optimizer='sgd', # SGD is more sensitive to differences of scale
    loss='mae',
    metrics=['mae'],
)
history = model.fit(
    X_train, y_train,
    validation_data=(X_valid, y_valid),
    batch_size=64,
    epochs=100,
    verbose=0,
)

history_df = pd.DataFrame(history.history)
history_df.loc[0:, ['loss', 'val_loss']].plot()
print(("Minimum Validation Loss: {:0.4f}").format(history_df['val_loss'].min()))

Penempatan layers.BatchNormalization() sebelum layer Dense yang diikuti relu adalah praktik umum untuk menstabilkan distribusi input ke setiap layer, mengatasi masalah Internal Covariate Shift

Training dengan Batch Normalization

# YOUR CODE HERE: Add a BatchNormalization layer before each Dense layer
model = keras.Sequential([
    layers.BatchNormalization(input_shape=input_shape),
    layers.Dense(512, activation='relu'),
    layers.BatchNormalization(),
    layers.Dense(512, activation='relu'),
    layers.BatchNormalization(),
    layers.Dense(512, activation='relu'),
    layers.BatchNormalization(),
    layers.Dense(1),
])

# Check your answer
q_3.check()

model.compile(
    optimizer='sgd',
    loss='mae',
    metrics=['mae'],
)
EPOCHS = 100
history = model.fit(
    X_train, y_train,
    validation_data=(X_valid, y_valid),
    batch_size=64,
    epochs=EPOCHS,
    verbose=0,
)

history_df = pd.DataFrame(history.history)
history_df.loc[0:, ['loss', 'val_loss']].plot()
print(("Minimum Validation Loss: {:0.4f}").format(history_df['val_loss'].min()))

Jika dibandingkan dengan baseline, kurva loss pada sel ini menunjukkan bahwa training menjadi jauh lebih cepat dan stabil. Validation Loss akan turun lebih tajam karena Batch Normalization memungkinkan optimizer SGD bekerja secara efisien

Selamat, kitatelah berhasil mengimplementasikan dua teknik regularization paling vital dalam Deep Learning :

1. Dropout : Senjata untuk melawan Overfitting
2. Batch Normalization : Senjata untuk meningkatkan kecepatan dan stabilitas training

Kedua teknik ini memungkinkan kita membangun dan melatih network yang lebih dalam dan lebih lebar dengan hasil yang lebih baik dan waktu training yang lebih singkat

Perjalanan Deep Learning tinggal sedikit lagi, dan fondasi kita sekarang sangat kuat. Teruslah bereksperimen, teruslah bertanya, dan sampai jumpa di bab selanjutnya! 🚀