Modul 12: Pengenalan Deep Learning untuk

Perencanaan Perkotaan
Tujuan Pembelajaran

1. Menjelaskan konsep deep learning sebagai bagian dari machine learning

2. Memahami arsitektur jaringan saraf (layer, neuron, activation, loss, optimizer)
3. Membangun, melatih, dan mengevaluasi model artificial neural network sederhana dengan paket
"Keras"embangun

1. Konsep Dasar Deep Learning

Deep learning pada dasarnya adalah bentuk algoritma machine learning. Penamaan khususnya disebabkan
oleh mekanisme pembelajarannya yang memiliki karakteristik yang juga khusus, yakni menyerupai sistem
kerja saraf manusia.

1.1. Jaringan Saraf Manusia dan Sistemnya

Sebelum kita mendalami deep learning sebagai model algoritma machine learning, mari kita pelajari terlebih
dahulu sistem saraf manusia yang merupakan "sumber inspirasinya."

Segala bentuk aktivitas tubuh kita yang dilakukan secara sadar, menurut biologi adalah karena adanya
perintah dari otak manusia kepada otot atau respon yang diterima otak dari berbagai sel pengindra. Perintah-
perintah tersebut beredar dalam bentuk sinyal listrik yang mengalir melalui jaringan saraf manusia.

Sel saraf manusia. Sumber: Roboguru by Ruangguru

1 / 12
Jaringan saraf manusia tersusun dari sel-sel saraf (neuron) yang saling terhubung satu sama lain. Setiap
neuron terdiri dari:

Dendrit: Menerima sinyal input dari neuron lain

Soma: Badan sel yang memproses sinyal
Akson: Mengirimkan sinyal output ke neuron lain

Cara kerjanya adalah perintah untuk pekerjaan yang kita lakukan dimulai dari otak sebagai pusatnya. Otak
akan mengirimkan sinyal-sinyal listrik yang khusus dikirimkan ke berbagai otot dalam tubuh kita yang
mendukung pergerakan tersebut. Sinyal-sinyal ini hanya akan diteruskan jika mencapai ambang batas
kekuatan tertentu, mirip dengan bagaimana sebuah saklar listrik hanya akan menyala jika tegangan
yang cukup diberikan.

1.2. Persamaan Mekanismenya dengan Deep Learning

Sistem kerja jaringan saraf ini menjadi inspirasi dari pengembangan deep learning. Di dalam deep learning
juga terdapat jaringan-jaringan yang saling terhubung untuk mempelajari hubungan atau pola yang
tersembunyi dalam sebuah dataset.

Meskipun demikian, deep learning lebih tepat disebut sebagai sifat. Sifat ini dilekatkan pada algoritma yang
akan kita pelajari hari ini, yaitu Artificial Neural Network (ANN).

Sumber: IBM

1.3. Elemen-elemen Artificial Neural Network dan Cara Kerjanya

Kita sudah mengetahui bahwa jaringan saraf menjadi dasar dari cara kerja algoritma deep learning untuk
mempelajari data. Sistem Artificial Neural Network ini terdiri atas elemen-elemen berupa node atau dikenal
juga sebagai neuron. Neuron-neuron berkumpul membentuk lapisan-lapisan (layers) yang terhubung satu
sama lain untuk memproses informasi.

2 / 12
Sumber: ProjectPro

Seperti halnya sel saraf manusia, pemrosesan data dalam model ANN juga mengalir dari satu neuron ke
neuron lain. Penentuan neuron mana yang terhubung ditentukan oleh yang disebut dengan activation
function.

Untuk menghindari bahasan yang membuat kita sulit memahami, kami serahkan kepada kalian pengertian
dari loss function dan optimizer untuk dipelajari. Kalian dapat mempelajarinya dari web di sumber gambar di
atas. Alternatifnya, kita akan mempelajari langsung penggunaannya pada bagian praktik di bawah.

Jadi, secara umum kita dapat mengelompokkan jenis layer dalam ANN menjadi tiga: input, hidden, dan output
layer. Input layer adalah layer yang menerima data sebagai masukan. Hasil pemrosesan dari input layer
dialirkan ke banyak hidden layer dan akhirnya ditampilkan oleh output layer.

Penting! Istilah deep ("dalam") pada deep learning mengacu pada jumlah layer yang terlibat
dalam model. Semakin banyak layer yang terlibat dalam model kita, semakin "dalam" model
pembelajaran mesin kita.

2. Praktik Membuat Model Deep Learning

Dalam praktik kita sekarang, kita akan berkenalan dengan library TensorFlow dan Keras sebagai library khusus
untuk deep learning. TensorFlow adalah paket khusus deep learning yang dikembangkan oleh Google,
sedangkan Keras adalah API (application programming interface) untuk menjalankan TensorFlow dalam
platform Python.

Kita juga akan mempelajari cara untuk mengimpor dataset langsung dari direktori Google Drive kita.

⚠ Perhatian

Selain algoritma yang berbeda, deep learning juga khusus memanfaatkan perangkat keras yang
berbeda dengan algoritma machine learning lainnya untuk melakukan pembelajaran. Deep learning
pada umumnya dikhususkan untuk memanfaatkan GPU (graphical processing unit), sedangkan
algoritma machine learning lainnya, seperti scikit-learn, hanya memanfaatkan CPU (central
processing unit).

3 / 12
Kasus kita saat ini adalah memprediksi waktu tempuh (Waktu (menit)) berdasarkan karakteristik
lingkungan (neighborhoods) menggunakan model deep learning. Dataset yang digunakan adalah
[Link].

2.1. Menyiapkan Lingkungan Kerja

Untuk mulai bekerja kita perlu mengatur lingkungannya (working environment) terlebih dahulu. Yang
dimaksud lingkungan kerja adalah susunan direktori (folder) dan file-file yang ada di dalamnya. Kali ini kita
akan memanfaatkan direktori Google Drive yang sudah terintegrasi dengan Google Colab.

1. Pastikan Anda menggunakan e-mail student Anda ketika membuka Colab ini.
2. Pergi ke Google Drive. Dalam folder My Drive Anda, buat folder baru bernama analitika-deep-
learning
3. Unggah file dataset_perkotaan_id_100.csv ke dalam folder tersebut
4. Klik + New > More > Google Colaboratory. Masukkan "Deep_learning_[NIM]_[Nama]" sebagai
judulnya. Ganti [NIM] dan [Nama] dengan NIM dan nama Anda tanpa tanda kurung siku.
5. Lingkungan kerja kita akan berbentuk seperti ini:

My Drive
└── analitika-deep-learning
├── dataset_perkotaan_id_100.csv
└── Deep_Learning_122220999_NamaAnda.ipynb

6. Buka file Colab Anda dalam folder tadi.

4 / 12
2.2. Instalasi dan Memuat Paket/Library
Instalasi TensorFlow dan Keras dilakukan dengan perintah berikut:

!pip install tensorflow

!pip install keras

Akan tetapi, jika kita menggunakan Google Colab, paket-paket tersebut sudah otomatis terpasang sehingga
kita cukup memuatnya.

# Mengimpor pustaka tensorflow dan kawan-kawannya

import tensorflow as tf
from [Link] import Sequential # Digunakan untuk membuat model
neural network secara berurutan
from [Link] import Dense # Digunakan untuk mendefinisikan lapisan
(layer) dalam neural network
from [Link] import EarlyStopping # Digunakan untuk
menghentikan pelatihan lebih awal jika tidak ada peningkatan

Selain TensorFlow dan Keras, tentunya kita memerlukan paket-paket lain seperti pandas, numpy, matplotlib,
seaborn, dan juga scikit-learn.

Berikut adalah peran singkat dari masing-masing paket dalam kasus kita:

Pandas: Digunakan untuk memuat dataset [Link] dan melakukan manipulasi awal data
karakteristik lingkungan.
Numpy: Mendukung operasi numerik efisien pada array data, yang menjadi dasar pemrosesan data
lingkungan.
Matplotlib: Untuk membuat visualisasi seperti kurva pelatihan model (loss dan validation loss) dan plot
perbandingan waktu tempuh aktual vs. prediksi.
Seaborn: Membantu dalam membuat visualisasi statistik yang lebih menarik dan informatif, seperti
scatter plot untuk menganalisis hubungan antara waktu tempuh aktual dan prediksi.
Scikit-learn: Penting untuk membagi data lingkungan menjadi set pelatihan dan pengujian, melakukan
standarisasi fitur-fitur lingkungan, dan mengevaluasi metrik kinerja model prediksi waktu tempuh (MSE,
R^2).

# Mengimpor pustaka-pustaka lain yang diperlukan untuk mengolah data

import pandas as pd
import numpy as np
import [Link] as plt
import seaborn as sns
from sklearn.model_selection import train_test_split
from [Link] import StandardScaler
from [Link] import mean_squared_error, r2_score

5 / 12
2.3. Membaca Data
Setelah kita mengatur lingkungan kerja kita, kita perlu memberi tahu Colab untuk dapat mengakses file-file
dalam direktori Google Drive kita. Istilah lainnya adalah me-mount Drive kita.

Cara kita memberitahunya adalah dengan menjalankan perintah berikut.

from [Link] import drive

[Link]('/content/drive')

Setelah Anda menjalankan perintah tersebut, klik 'Sambungkan ke Google Drive'. Akan muncul jendela baru
untuk login ke akun student Itera Anda. Ikuti 'Continue' sampai selesai.

Setelah direktori kita ter-mount, kita siap untuk membaca data kita dari path yang sesuai di Google Drive.

file = '/content/drive/MyDrive/analitika-deep-
learning/dataset_perkotaan_id_100.csv'

df = pd.read_csv(file)
[Link]()

2.4. Prapemrosesan Data

Pemisahan Fitur dan Target

Kita memisahkan data kita menjadi dua bagian: fitur (variabel independen, X) yang akan digunakan untuk
membuat prediksi, dan target (variabel dependen, y) yang ingin kita prediksi, yaitu Waktu (menit).

# Mengeset kolom-kolom selain `waktu_tempuh_min` sebagai variabel fitur

X = [Link](columns=['waktu_tempuh_min'])
# Mengeset 'waktu_tempuh_min' sebagai target
y = df['waktu_tempuh_min']

Pembagian Data Latih dan Uji

Dataset dibagi menjadi dua set: data latih (80%) untuk melatih model, dan data uji (20%) untuk mengevaluasi
performanya pada data yang belum pernah dilihat sebelumnya.

X_train, X_test, y_train, y_test = train_test_split(

X, y, test_size=0.2, random_state=42)

Normalisasi Fitur

6 / 12
Skala nilai pada fitur-fitur kita sangat bervariasi. Normalisasi (dengan StandardScaler) diperlukan agar
semua fitur memiliki skala yang seragam, yang membantu model deep learning belajar lebih efisien.

scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = [Link](X_test)

# Menampilkan hasil
print(f"Hasil normalisasi train: {X_train_scaled}")
print(f"Hasil normalisasi test: {X_test_scaled}")

2.5. Membangun Model Deep Learning

Arsitektur Model

Kita akan membangun model Sequential sederhana yang terdiri dari beberapa layer Dense. Layer Dense
adalah implementasi praktis dari layer neuron yang saling terhubung penuh (fully-connected) seperti yang
telah kita bahas pada konsep elemen ANN di awal. Setiap neuron di dalam satu lapisan Dense terhubung ke
semua neuron di lapisan sebelumnya.

Arsitektur kita terdiri dari:

1. Input Layer: Lapisan pertama yang secara implisit menerima bentuk dari data input kita.
2. Hidden Layer 1: Lapisan tersembunyi pertama dengan 8 neuron. Angka 8 ini adalah pilihan desain,
yang berarti kita ingin lapisan ini menangkap pola dalam data melalui 8 "sudut pandang" yang
berbeda.
3. Hidden Layer 2: Lapisan tersembunyi kedua dengan 4 neuron. Jumlah neuron yang lebih sedikit ini
bertujuan untuk lebih memadatkan informasi yang dipelajari dari lapisan sebelumnya.
4. Output Layer: Lapisan terakhir dengan 1 neuron. Karena tujuan kita adalah regresi (memprediksi satu
nilai numerik), kita hanya memerlukan satu neuron untuk mengeluarkan hasil prediksi akhir, yaitu waktu
tempuh.

Fungsi Aktivasi relu

Pada hidden layers, kita menggunakan activation='relu' (Rectified Linear Unit). Ingat kembali konsep sel
saraf manusia; sebuah sinyal hanya akan diteruskan jika stimulusnya cukup kuat. Fungsi aktivasi relu bekerja
dengan cara yang mirip:

Jika sebuah neuron menerima total sinyal input yang positif, relu akan "mengaktifkan" neuron
tersebut dan meneruskan sinyal itu apa adanya.
Jika total sinyal inputnya negatif atau nol, relu akan "mematikan" neuron tersebut, dan sinyal tidak
diteruskan (outputnya nol).

Secara sederhana, relu bertindak seperti saklar "on/off" yang efisien, yang memutuskan apakah informasi
yang dipelajari oleh sebuah neuron cukup penting untuk diteruskan ke lapisan berikutnya. Ini membantu
model belajar pola yang kompleks secara efisien.

7 / 12
 model = Sequential([
Dense(8, activation='relu', input_shape=(X_train_scaled.shape[1],)),
Dense(4, activation='relu'),
Dense(1)
])

Kompilasi Model

Sebelum model bisa dilatih, kita perlu melakukan langkah 'kompilasi'. Anggap saja ini seperti memberikan
strategi belajar pada model kita. Kita perlu memberitahu tiga hal:

1. Optimizer (optimizer='adam'): Ini adalah cara model akan belajar dan memperbaiki diri. 'adam'
adalah salah satu metode belajar yang paling populer dan efektif.
2. Loss Function (loss='mse'): Ini adalah tolok ukur kesalahan. Model akan menggunakan ini untuk
melihat seberapa jauh prediksinya meleset dari nilai sebenarnya. Tujuannya adalah membuat nilai 'loss'
ini sekecil mungkin.
3. Metrics (metrics=['mae']): Ini adalah skor performa tambahan yang ingin kita pantau selama
proses belajar, agar lebih mudah kita pahami.

Singkatnya, [Link]() adalah tahap di mana kita menyiapkan model dengan memberinya "aturan
main" untuk proses belajar.

[Link](optimizer='adam',
loss='mse', # Mean Squared Error, cocok untuk regresi
metrics=['mae']) # Mean Absolute Error

2.6. Melatih Model

Sekarang kita melatih model menggunakan data latih. Proses ini ibarat menyuruh model untuk "belajar" dari
data yang kita berikan.

Menghindari Overfitting dengan EarlyStopping

Salah satu risiko dalam melatih model adalah overfitting. Overfitting terjadi ketika model menjadi terlalu
hafal dengan data latih, termasuk noise atau kebetulan yang ada di dalamnya. Akibatnya, model menjadi
"kaku" dan tidak bisa memberikan prediksi yang baik untuk data baru yang belum pernah ia lihat. Ini seperti
seorang siswa yang hanya menghafal soal-soal dari buku tanpa memahami konsepnya, sehingga ia tidak bisa
mengerjakan soal lain yang sedikit berbeda.

Untuk menghindarinya, kita menggunakan EarlyStopping. Ini adalah mekanisme untuk menghentikan
proses belajar secara otomatis jika performa model pada data validasi (data "ujian" kecil) tidak lagi
membaik.

Atribut yang kita gunakan:

monitor='val_loss': Kita memantau skor loss pada data validasi.

8 / 12
 patience=10: Kita memberi toleransi sebanyak 10 epoch (putaran belajar). Jika setelah 10 putaran tidak
ada perbaikan, proses belajar akan berhenti.
restore_best_weights=True: Setelah berhenti, model akan mengembalikan bobot (pengetahuan)
terbaik yang pernah ia capai selama proses belajar.

Menjalankan Proses Pelatihan dengan [Link]

Perintah [Link] adalah perintah untuk memulai proses pelatihan. Atribut yang kita gunakan adalah:

X_train_scaled, y_train: Data fitur dan target yang digunakan untuk melatih model.
validation_split=0.2: 20% dari data latih akan disisihkan sebagai data validasi untuk mengukur
performa di setiap akhir putaran.
epochs=200: Jumlah maksimal putaran belajar. Model akan belajar dari keseluruhan data latih sebanyak
200 kali, kecuali jika dihentikan lebih awal oleh EarlyStopping.
batch_size=4: Model akan melihat 4 data sekaligus, menghitung kesalahan, lalu memperbaiki dirinya.
callbacks=[es]: Menerapkan aturan EarlyStopping yang sudah kita definisikan.
verbose=1: Menampilkan log proses belajar untuk setiap epoch agar prosesnya terasa. Jika kita
mengatur nilainya menjadi 0, prosesnya jadi senyap.

es = EarlyStopping(monitor='val_loss', patience=10, restore_best_weights=True)

history = [Link](X_train_scaled, y_train,
validation_split=0.2,
epochs=200,
batch_size=4,
callbacks=[es],
verbose=1)

Anda akan melihat proses fitting berjalan dari epoch 1/200 hingga 200/200 dalam beberapa lama. Proses ini
berjalan di unit-unit komputasi berupa GPU yang ada di data center Google yang tersebar di lokasi-lokasi
tertentu seluruh dunia.

Jika Anda menjalankan model ini secara offline di komputer Anda masing-masing, prosesnya akan dijalankan
pada GPU Anda. Pengaturan TensorFlow juga akan berbeda dengan yang ada di modul ini.

2.7. Mengevaluasi Model

Visualisasi Kurva Pelatihan

Dengan memplot loss pada data latih dan validasi, kita dapat melihat bagaimana model belajar dari waktu ke
waktu.

[Link](figsize=(8,4))
[Link]([Link]['loss'], label='train loss')
[Link]([Link]['val_loss'], label='val loss')
[Link]('Epoch')
[Link]('MSE')
[Link]('Training Curve')

9 / 12
 [Link]()
[Link]()

Interpretasi Kurva Pelatihan

Grafik di atas menunjukkan bagaimana tingkat kesalahan (loss) model berubah selama proses pelatihan.

Garis 'train loss': Menunjukkan seberapa baik model belajar dari data latih. Idealnya, garis ini terus
menurun.
Garis 'val loss': Menunjukkan seberapa baik performa model pada data validasi yang tidak ia gunakan
untuk belajar. Ini adalah indikator performa model pada data baru.

Model yang baik ditandai dengan kedua garis yang sama-sama menurun dan kemudian mendatar
(konvergen). Jika train loss terus turun sementara val loss mulai naik, itu adalah tanda overfitting.

Metrik Evaluasi

Kita menggunakan data uji untuk mengevaluasi seberapa baik model kita. Metrik yang digunakan adalah
Mean Squared Error (MSE) dan R-squared (R²).

y_pred = [Link](X_test_scaled).flatten()
mse = mean_squared_error(y_test, y_pred)
r2 = r2_score(y_test, y_pred)
print(f'MSE: {mse:.2f}, R^2: {r2:.2f}')

Interpretasi Metrik Evaluasi

MSE (Mean Squared Error): Ini adalah rata-rata dari kuadrat selisih antara nilai aktual dan nilai
prediksi. Semakin kecil nilai MSE, semakin baik performa model karena artinya kesalahan prediksinya
kecil.
R² (R-squared): Metrik ini menunjukkan seberapa besar persentase variasi dari data target (waktu
tempuh) yang dapat dijelaskan oleh model kita. Nilainya berkisar antara 0 hingga 1. Semakin mendekati
1, semakin baik modelnya. Misalnya, nilai R² 0.75 berarti model dapat menjelaskan 75% variasi data
waktu tempuh.

Perbandingan Hasil Aktual vs. Prediksi

Visualisasi ini membantu kita melihat seberapa dekat prediksi model dengan nilai aktual. Semakin dekat titik-
titik ke garis diagonal, semakin baik prediksinya.

[Link](figsize=(6,6))
[Link](x=y_test, y=y_pred)
[Link]([y_test.min(), y_test.max()], [y_test.min(), y_test.max()], '--',
color='red')
[Link]('Actual Waktu Tempuh (min)')
[Link]('Predicted Waktu Tempuh (min)')

10 / 12
 [Link]('Actual vs Predicted')
[Link]()

Interpretasi Plot Aktual vs. Prediksi

Grafik ini adalah cara visual untuk mengevaluasi performa model pada data uji.

Sumbu X (Actual): Nilai waktu tempuh yang sebenarnya.

Sumbu Y (Predicted): Nilai waktu tempuh yang diprediksi oleh model.
Garis Merah Putus-putus: Garis prediksi sempurna, di mana nilai aktual sama dengan nilai prediksi.

Model yang baik akan menghasilkan titik-titik biru yang berkumpul rapat di sekitar garis merah. Semakin jauh
sebuah titik dari garis merah, semakin besar kesalahan prediksi model untuk data tersebut.

3. Memanfaatkan Model untuk Prediksi

Setelah model kita dilatih, kita tidak hanya berhenti pada evaluasi. Kita bisa menggunakannya sebagai
'kalkulator' untuk memprediksi waktu tempuh pada berbagai skenario hipotetis. Mari kita coba buat beberapa
skenario untuk melihat bagaimana model kita memberikan prediksi.

# Skenario 1: Kondisi Rata-rata

# Kita ambil nilai rata-rata dari setiap fitur di data latih
skenario_rata_rata = {
'kepadatan_penduduk': [X_train['kepadatan_penduduk'].mean()],
'pendapatan_rata_rata': [X_train['pendapatan_rata_rata'].mean()],
'jarak_ke_pusat_kota': [X_train['jarak_ke_pusat_kota'].mean()],
'jumlah_stasiun_transport_publik':
[X_train['jumlah_stasiun_transport_publik'].mean()],
'ukuran_rumah_rata_rata': [X_train['ukuran_rumah_rata_rata'].mean()],
'jumlah_rambu_lalu_lintas': [X_train['jumlah_rambu_lalu_lintas'].mean()]
}

# Skenario 2: Kondisi Ideal (Waktu Tempuh Cepat)

# Kita tentukan nilai-nilai yang secara logis seharusnya menghasilkan waktu tempuh
cepat
skenario_ideal = {
'kepadatan_penduduk': [5000], # Kepadatan rendah
'pendapatan_rata_rata': [30000000], # Pendapatan tinggi (asumsi
infrastruktur lebih baik)
'jarak_ke_pusat_kota': [5], # Jarak dekat
'jumlah_stasiun_transport_publik': [10],# Banyak stasiun (opsi transportasi)
'ukuran_rumah_rata_rata': [150], # Ukuran rumah tidak terlalu
berpengaruh
'jumlah_rambu_lalu_lintas': [5] # Sedikit rambu
}

# Skenario 3: Kondisi Buruk (Waktu Tempuh Lama)

skenario_buruk = {
'kepadatan_penduduk': [25000], # Kepadatan sangat tinggi

11 / 12
 'pendapatan_rata_rata': [3000000], # Pendapatan rendah
'jarak_ke_pusat_kota': [30], # Jarak sangat jauh
'jumlah_stasiun_transport_publik': [1], # Sedikit stasiun
'ukuran_rumah_rata_rata': [60], # Ukuran rumah kecil (asumsi area
kumuh)
'jumlah_rambu_lalu_lintas': [50] # Sangat banyak rambu
}

# Gabungkan skenario ke dalam DataFrame

df_rata = [Link](skenario_rata_rata, index=['Rata-rata'])
df_ideal = [Link](skenario_ideal, index=['Ideal'])
df_buruk = [Link](skenario_buruk, index=['Buruk'])

df_skenario = [Link]([df_rata, df_ideal, df_buruk])

df_skenario

Lakukan Prediksi

Penting! Kita harus menggunakan scaler yang sama dengan yang kita gunakan untuk data latih untuk
menormalisasi data skenario kita sebelum membuat prediksi.

# Normalisasi data skenario

skenario_scaled = [Link](df_skenario)

# Lakukan prediksi
prediksi_waktu = [Link](skenario_scaled)

# Tampilkan hasil
df_skenario['prediksi_waktu_tempuh_min'] = prediksi_waktu
print("Hasil Prediksi Waktu Tempuh untuk Berbagai Skenario:")
print(df_skenario[['prediksi_waktu_tempuh_min']])

Dari hasil di atas, kita dapat melihat estimasi waktu tempuh untuk setiap skenario berdasarkan "pengetahuan"
yang telah dipelajari oleh model. Skenario "Ideal" yang kita rancang berhasil diprediksi memiliki waktu
tempuh tercepat. Ini menunjukkan bagaimana model deep learning dapat digunakan sebagai alat bantu untuk
simulasi dan perencanaan kota.

Penutup

12 / 12