---
# System prepended metadata

title: Module 3 How Models Become Smart

---

# Anatomi Proses Belajar: Bagaimana Model Menjadi Pintar

Di minggu kedua, kita telah sukses merancang "kerangka" atau arsitektur dari sebuah *Convolutional Neural Network* (CNN). Kita sudah tahu ada *Convolutional Layer* untuk mencari pola, *Pooling Layer* untuk merangkum, dan *Fully Connected Layer* untuk mengambil keputusan. Namun, kerangka ini pada dasarnya masih "kosong" dan "bodoh". Ia belum memiliki pengetahuan apa pun.

Pertanyaan besarnya adalah: Bagaimana cara kita mengisinya dengan "pengetahuan"? Bagaimana sebuah model bisa secara otomatis menyesuaikan jutaan parameter internalnya (yang kita sebut *weights* atau bobot) agar mampu mengenali perbedaan antara angka '7' dan '1'?

Jawabannya terletak pada sebuah proses iteratif yang elegan bernama **Training**. Hari ini, kita akan menyelami setiap aspek dari proses ini.

### Analogi Utama: Melatih Model = Mengajari Siswa untuk Ujian

Untuk membuat semua konsep ini lebih mudah dicerna, kita akan menggunakan satu analogi utama sepanjang modul ini.

*   **Siswa:** Adalah **Model CNN** kita
*   **Materi Belajar:** Adalah **Data Training** kita
*   **Guru Penilai:** Adalah **Loss Function**
*   **Tutor Cerdas:** Adalah **Optimizer**
*   **Rapor Akhir:** Adalah **Metrics** (seperti akurasi)

### Tujuan Pembelajaran

Di akhir modul ini, Anda akan mampu:
1.  Menjelaskan siklus belajar fundamental: Prediksi → Evaluasi Kesalahan → Koreksi
2.  Mengidentifikasi peran dan fungsi dari tiga pilar training: *Loss Function*, *Optimizer*, dan *Metrics*
3.  Memahami mekanisme training seperti *Epochs* dan *Batch Size*
4.  Menjelaskan **mengapa** setiap langkah *preprocessing* data itu krusial

---

### Bagian 1: Siklus Belajar - Satu Langkah Menuju Kepintaran

Proses belajar pada model AI tidak terjadi dalam sekejap. Ia terjadi dalam sebuah siklus yang berulang ribuan, bahkan jutaan kali. Setiap siklusnya adalah satu langkah kecil bagi model untuk menjadi sedikit lebih pintar dari sebelumnya.

Siklus ini terdiri dari tiga langkah utama:



1.  **Langkah 1: Prediksi (*Forward Pass*)**
    *   **Apa yang terjadi?** Model menerima satu *batch* (sekelompok kecil) data dari materi belajar. Data ini kemudian "dialirkan" dari lapisan pertama hingga lapisan terakhir. Di akhir, model akan menghasilkan sebuah tebakan (prediksi) awal.
    *   **Analogi:** Siswa diberikan satu set soal latihan dan mencoba menjawabnya dengan pengetahuan yang ia miliki saat ini.

2.  **Langkah 2: Evaluasi Kesalahan (*Loss Calculation*)**
    *   **Apa yang terjadi?** Tebakan model dari langkah pertama dibandingkan dengan jawaban yang sebenarnya (label data). **Loss Function** (Sang Guru) kemudian menghitung sebuah skor yang merepresentasikan "seberapa parah" kesalahan yang dibuat model. Skor ini kita sebut **loss**.
    *   **Analogi:** Guru memeriksa jawaban siswa menggunakan kunci jawaban. Untuk setiap jawaban yang salah, guru memberikan "nilai penalti". Total dari semua penalti adalah skor *loss*.

3.  **Langkah 3: Koreksi (*Backpropagation & Optimization*)**
    *   **Apa yang terjadi?** Ini adalah langkah paling ajaib. Informasi tentang kesalahan (*loss*) "dialirkan kembali" (*backpropagation*) dari lapisan terakhir ke lapisan pertama. Selama proses ini, **Optimizer** (Sang Tutor) menganalisis kontribusi setiap *weight* di dalam model terhadap kesalahan total. Berdasarkan analisis ini, *optimizer* akan sedikit mengubah setiap *weight* agar di siklus berikutnya, kesalahan yang dihasilkan menjadi lebih kecil.
    *   **Analogi:** Setelah menerima skor dari guru, tutor memberikan feedback yang sangat spesifik kepada siswa: "Kamu salah menjawab soal ini karena pemahamanmu tentang konsep X kurang. Coba perbaiki caramu berpikir tentang X." Siswa pun menyesuaikan cara belajarnya.

Siklus **Prediksi → Evaluasi → Koreksi** inilah yang menjadi jantung dari *Deep Learning*. Proses ini diulang terus-menerus hingga model menjadi sangat baik dalam menebak jawaban yang benar.

---

### Bagian 2: Tiga Pilar Training - Para Aktor di Balik Layar

Sekarang, mari kita kenali lebih dalam para "aktor" utama yang menjalankan siklus belajar ini.

#### Pilar #1: Loss Function (Sang Guru yang Objektif)

*Loss Function* adalah komponen yang memberikan tujuan yang jelas bagi proses training: **membuat nilai *loss* sekecil mungkin**.

*   **Mengapa ini Penting?** Tanpa adanya skor kesalahan yang terukur, *optimizer* tidak akan tahu apakah perubahan yang ia buat sudah benar atau salah. *Loss function* memberikan sinyal yang kuantitatif dan objektif untuk memandu proses belajar.
*   **Contoh Populer:** Untuk masalah klasifikasi multi-kelas (seperti mengenali angka 0-9), kita menggunakan `categorical_crossentropy`. Anda tidak perlu tahu formulanya, cukup pahami bahwa ia dirancang khusus untuk memberikan *loss* yang tinggi jika model menebak kelas yang salah, dan *loss* yang rendah jika model menebak kelas yang benar dengan keyakinan tinggi.

#### Pilar #2: Optimizer (Sang Tutor yang Efisien)

Jika *loss function* adalah "apa" yang harus diminimalkan, maka *optimizer* adalah "bagaimana" cara meminimalkannya. Ia adalah mesin penggerak dari proses belajar.

*   **Intuisi Cara Kerja: *Gradient Descent***
    Bayangkan Anda berada di puncak sebuah gunung di tengah kabut tebal, dan tujuan Anda adalah mencapai titik terendah di lembah. Karena kabut, Anda hanya bisa melihat tanah di sekitar kaki Anda. Strategi apa yang paling masuk akal? Tentu saja, Anda akan melihat ke sekeliling, merasakan ke arah mana turunan yang paling curam, lalu mengambil satu langkah ke arah tersebut. Anda mengulangi proses ini terus-menerus, dan perlahan tapi pasti, Anda akan tiba di lembah.
    *   **Gunung:** Representasi dari *loss function*.
    *   **Posisi Anda:** Representasi dari nilai *weights* model saat ini.
    *   **Lembah Terendah:** Representasi dari nilai *loss* minimum (model yang optimal).
    *   **Langkah ke Turunan Tercuram:** Adalah apa yang dilakukan *optimizer*. Ia menghitung "turunan" (*gradient*) dari *loss function* untuk menemukan arah koreksi yang paling efektif.

*   **Contoh Populer: `Adam`**
    Adam (*Adaptive Moment Estimation*) adalah *optimizer* yang sangat populer dan seringkali menjadi pilihan utama. Anggap saja Adam adalah seorang pendaki gunung yang cerdas; ia tidak hanya tahu arah turunan tercuram, tetapi juga bisa secara adaptif menyesuaikan "ukuran langkahnya"—mengambil langkah besar saat turunan jelas dan langkah kecil saat mendekati lembah. Ini membuatnya sangat efisien dan andal.

#### Pilar #3: Metrics (Rapor yang Mudah Dibaca)

Setelah proses belajar yang rumit, kita butuh cara sederhana untuk mengetahui "seberapa pintar" model kita sekarang. Di sinilah *metrics* berperan.

*   **Mengapa ini Penting?** Nilai *loss* (misal: 0.054) itu abstrak dan sulit diinterpretasikan oleh manusia. Sebaliknya, sebuah *metric* seperti akurasi (misal: 98.5%) sangat mudah kita pahami.
*   **Perbandingan Kritis: Loss vs. Accuracy**

| Kriteria | Loss Function | Metric (Accuracy) |
| :--- | :--- | :--- |
| **Tujuan** | Memandu proses training **untuk mesin** | Mengevaluasi performa akhir **untuk manusia** |
| **Audiens** | Optimizer | Manusia (Data Scientist, Engineer) |
| **Interpretasi**| Semakin **rendah** semakin baik | Semakin **tinggi** semakin baik |

---

### Bagian 3: Mekanisme Proses Training - Aturan Mainnya

#### Epochs: Siklus Belajar Skala Besar

*   **Definisi:** Satu *epoch* berarti model telah melihat dan belajar dari **seluruh sampel** di dalam dataset training satu kali penuh.
*   **Analogi:** Siswa telah selesai membaca **seluruh buku materi** dari halaman pertama hingga terakhir, lengkap dengan latihannya.
*   **Trade-off:** Menentukan jumlah *epochs* adalah hal yang penting.
    *   **Terlalu sedikit epochs:** Model belum cukup belajar (*underfitting*). Analogi: Siswa baru membaca setengah buku sebelum ujian.
    *   **Terlalu banyak epochs:** Model menjadi terlalu hafal dengan soal latihan dan buruk saat mengerjakan soal ujian yang baru (*overfitting*). Analogi: Siswa hanya menghafal kunci jawaban buku materi, bukan konsepnya.

#### Batch Size: Belajar dalam Dosis Kecil

*   **Definisi:** Jumlah sampel data training yang diproses dalam satu kali siklus belajar (satu *forward/backward pass*).
*   **Analogi:** Siswa tidak membaca seluruh buku dalam sekali duduk. Ia membacanya per **bab** atau per beberapa halaman (**batch**), lalu berhenti sejenak untuk mereview pemahamannya sebelum lanjut.
*   **Alasan Praktis:** Komputer memiliki memori (RAM/VRAM) yang terbatas. Kita tidak bisa memuat jutaan gambar ke dalam memori secara bersamaan. Dengan memecah data menjadi *batches*, proses training menjadi mungkin dilakukan.

#### Iterations (Steps per Epoch): Langkah-langkah Kecil

*   **Definisi:** Jumlah *batch* yang dibutuhkan untuk menyelesaikan satu *epoch*.
*   **Rumus:** `Iterations = Total Ukuran Data Training / Batch Size`
*   **Contoh:** Jika kita punya 60.000 gambar training dan *batch size* kita 128, maka dibutuhkan `60.000 / 128 ≈ 469` iterasi untuk menyelesaikan satu *epoch*. Angka inilah yang akan Anda lihat saat log `model.fit()` berjalan.

---

### Bagian 4: Persiapan Data - Kunci Sukses Training (Preprocessing)

Prinsip paling fundamental dalam Machine Learning adalah **"Garbage In, Garbage Out"**. Se-canggih apapun model kita, ia tidak akan belajar dengan baik jika data yang diberikan "berantakan". Oleh karena itu, *preprocessing* adalah langkah yang wajib dilakukan.

#### Langkah 1: Reshaping Input

*   **Why?** Arsitektur CNN di library modern seperti Keras/TensorFlow mengharapkan data input dalam format tensor 4D yang spesifik: `(jumlah_sampel, tinggi, lebar, jumlah_channel)`. Data MNIST yang kita load awalnya hanya 3D `(jumlah_sampel, tinggi, lebar)`. Kita perlu menambahkan dimensi untuk *channel*.
*   **How?** Kita mengubah *shape* dari `(60000, 28, 28)` menjadi `(60000, 28, 28, 1)`. Angka `1` di akhir menandakan ini adalah gambar *grayscale* (1 channel).

#### Langkah 2: Normalisasi

*   **Why?** Nilai piksel asli berada dalam rentang `[0, 255]`. Skala yang lebar ini dapat membuat "permukaan gunung" (*loss landscape*) menjadi sangat curam dan tidak beraturan, sehingga menyulitkan *optimizer* untuk menemukan lembah terendah. Dengan menyamakan skala menjadi `[0, 1]`, proses training menjadi lebih cepat dan stabil.
*   **How?** Caranya sangat sederhana: bagi semua nilai piksel dengan 255.0.

#### Langkah 3: One-Hot Encoding Label

*   **Why?** *Output layer* dari model klasifikasi kita (yang menggunakan aktivasi `softmax`) akan menghasilkan sebuah vektor probabilitas untuk setiap kelas. Misalnya, untuk gambar angka '5', output yang ideal adalah vektor `[0, 0, 0, 0, 0, 1, 0, 0, 0, 0]`. Label asli kita hanya berupa angka tunggal `5`. *Loss function* perlu membandingkan "apel dengan apel", jadi kita harus mengubah format label kita agar cocok dengan format output model.
*   **How?** Kita mengubah setiap label integer menjadi sebuah vektor biner.
    *   `2` → `[0, 0, 1, 0, 0, 0, 0, 0, 0, 0]`
    *   `7` → `[0, 0, 0, 0, 0, 0, 0, 1, 0, 0]`

---

### Bagian 5: Dari Teori ke Kode - Sebuah Preview Hands-on

Semua teori yang telah kita bahas—*loss*, *optimizer*, *metrics*, *epochs*, dan *preprocessing*—mungkin terasa sangat konseptual. Sekarang, mari kita lihat bagaimana semua konsep tersebut diterjemahkan menjadi kode Python yang sesungguhnya menggunakan library Keras.

Cuplikan kode di bawah ini adalah *preview* dari apa yang akan kita bangun bersama di sesi *hands-on*. Tujuannya adalah agar Anda bisa melihat bagaimana setiap baris kode secara langsung merepresentasikan ide-ide yang telah kita pelajari.

#### Contoh Lengkap: Membangun Classifier MNIST

Berikut adalah alur kerja *end-to-end* untuk melatih sebuah model CNN sederhana pada dataset MNIST.

**Langkah 0: Setup Awal**

```python
# Mengimpor semua 'tools' yang kita butuhkan dari TensorFlow dan Keras
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense
from tensorflow.keras.datasets import mnist
from tensorflow.keras.utils import to_categorical

print("Setup selesai. Siap untuk memulai!")
```
*   **Penjelasan:** Sama seperti seorang koki menyiapkan semua bahan dan pisaunya, kita memulai dengan mengimpor semua fungsi dan *class* yang akan kita gunakan. `Sequential` untuk membangun model lapis demi lapis, `Conv2D`, `MaxPooling2D`, dll., untuk arsitekturnya, dan `mnist` untuk datanya.

**Langkah 1 & 2: Load Data dan Preprocessing**

```python
# 1. Me-load dataset MNIST
(x_train, y_train), (x_test, y_test) = mnist.load_data()

# 2. Preprocessing - Mengubah data agar 'model-ready'

# Reshaping: Menambahkan dimensi channel (dari 28x28 -> 28x28x1)
x_train = x_train.reshape((60000, 28, 28, 1))
x_test = x_test.reshape((10000, 28, 28, 1))

# Normalisasi: Mengubah skala piksel dari [0, 255] menjadi [0, 1]
x_train = x_train.astype('float32') / 255
x_test = x_test.astype('float32') / 255

# One-Hot Encoding: Mengubah label (e.g., 5 -> [0,0,0,0,0,1,0,0,0,0])
y_train = to_categorical(y_train)
y_test = to_categorical(y_test)

print("Data berhasil di-load dan di-preprocess!")
print("Shape x_train setelah reshape:", x_train.shape)
print("Shape y_train setelah one-hot encoding:", y_train.shape)
```
*   **Penjelasan:** Di sini kita melakukan persis seperti yang dibahas di **Bagian 4**. Kita me-load data, lalu melakukan tiga langkah *preprocessing* krusial: *reshaping* agar formatnya cocok untuk input CNN, *normalisasi* untuk membantu proses belajar, dan *one-hot encoding* agar format label cocok dengan output model.

**Langkah 3: Membangun Arsitektur Model (The Blueprint)**

```python
# Membuat 'kerangka' model kita, lapis demi lapis
model = Sequential()

# Menambahkan lapisan-lapisan 'feature extractor'
model.add(Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)))
model.add(MaxPooling2D((2, 2)))
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(MaxPooling2D((2, 2)))

# Meratakan (flatten) output dari feature extractor menjadi vektor 1D
model.add(Flatten())

# Menambahkan lapisan 'decision maker'
model.add(Dense(64, activation='relu'))
model.add(Dense(10, activation='softmax')) # 10 neuron untuk 10 kelas (0-9)

# Menampilkan ringkasan arsitektur model
model.summary()
```
*   **Penjelasan:** Ini adalah implementasi dari arsitektur yang kita pelajari di Minggu 2. Kita menggunakan `Sequential()` untuk menumpuk lapisan secara berurutan. Perhatikan bagaimana `Conv2D` dan `MaxPooling2D` digunakan untuk ekstraksi fitur, `Flatten` untuk transisi, dan `Dense` untuk membuat keputusan akhir. `activation='softmax'` di layer terakhir sangat penting untuk masalah klasifikasi multi-kelas, karena ia akan mengubah output menjadi distribusi probabilitas.

**Langkah 4: Meng-compile Model (Menyiapkan Sesi Belajar)**

```python
# Menentukan 'aturan main' untuk proses training
model.compile(optimizer='adam',
              loss='categorical_crossentropy',
              metrics=['accuracy'])

print("Model berhasil di-compile.")
```
*   **Penjelasan:** Inilah momen di mana kita menghubungkan semua pilar dari **Bagian 2**.
    *   `optimizer='adam'`: Kita memilih **Adam** sebagai "Tutor Cerdas" kita.
    *   `loss='categorical_crossentropy'`: Kita menugaskan **Categorical Crossentropy** sebagai "Guru Penilai".
    *   `metrics=['accuracy']`: Kita meminta model untuk melaporkan **Akurasi** sebagai "Rapor"-nya.


**Langkah 5: Melatih Model (The Training Montage!)**

```python
# Memulai proses belajar!
print("Memulai training model...")
history = model.fit(x_train, y_train,
                    epochs=5,
                    batch_size=128,
                    validation_split=0.1) # Menggunakan 10% data training untuk validasi

print("Training selesai!")
```
*   **Penjelasan:** Baris `model.fit()` adalah puncak dari semua persiapan kita. Di sinilah siklus **Prediksi → Evaluasi → Koreksi** terjadi berulang kali.
    *   `epochs=5`: Model akan melihat keseluruhan dataset training sebanyak 5 kali.
    *   `batch_size=128`: Dalam setiap *epoch*, model akan belajar dalam kelompok-kelompok data berukuran 128.

**Langkah 6: Mengevaluasi Model (Ujian Akhir)**

```python
# Menguji seberapa baik performa model pada data yang belum pernah ia lihat
test_loss, test_acc = model.evaluate(x_test, y_test)

print(f"\nAkurasi pada test set: {test_acc*100:.2f}%")
```
*   **Penjelasan:** Setelah "belajar" menggunakan `x_train`, sekarang saatnya "ujian" menggunakan `x_test`. Ini adalah ukuran performa yang paling jujur, karena model belum pernah melihat data ini sebelumnya.

---