# UAS — Pembelajaran Mesin Mendalam [KOMB] (2024) — Model Answers

> Final Exam · Odd Semester 2024/2025 · Universitas Gadjah Mada
> Answers to `UAS_Deep Learning_2024.md`. The exam is in Indonesian, so these answers are in Indonesian.

| Field | Value |
|---|---|
| **Course** | Pembelajaran Mesin Mendalam [KOMB] |
| **Exam type** | Ujian Akhir Semester (UAS) |
| **Semester** | Gasal 2024/2025 |
| **Date** | Rabu, 4 Desember 2024 |
| **Time** | 10:00–12:00 (120 menit) |
| **Lecturer** | Wahyono, Ph.D. |
| **Exam mode** | Open Book, Tanpa Alat Elektronik |
| **Weight** | PLO3; CO-5 → 10%; PLO3; CO-6 → 10% |

**Institution:** Program Studi Sarjana Ilmu Komputer, Fakultas Matematika dan Ilmu Pengetahuan Alam, Universitas Gadjah Mada

> **Catatan penilaian:** Soal 1 = 100 poin (a 10 + b 15 + c 15 + d 20 + e 40); Soal 2 = 100 poin (a 20 + b 20 + c 25 + d 35). Jawaban di bawah ditulis sepanjang yang diperlukan untuk poinnya — bagian bernilai besar (1e, 2d) diberi penjabaran paling panjang.

---

## Soal 1a — Pengaruh Hiperparameter terhadap Akurasi CNN (10 poin)

Hiperparameter CNN mengendalikan **kapasitas** model dan **cara optimasi**-nya. Akurasi akhir adalah hasil trade-off antara keduanya terhadap jumlah data yang tersedia.

### 1. Ukuran kernel (*kernel size*, k)

Kernel menentukan *receptive field* satu neuron dan jumlah parameter per filter (k² × C_in).

| Ukuran kernel | Dampak | Efek pada akurasi |
|---|---|---|
| **Kecil** (1×1, 3×3) | Receptive field sempit; parameter sedikit; komputasi murah; dapat ditumpuk untuk memperluas field | Umumnya **lebih akurat per parameter** — dua lapis 3×3 punya field 5×5 dengan parameter lebih sedikit *dan* dua non-linearitas. Inilah alasan VGG mengganti 5×5/7×7 dengan tumpukan 3×3. Risiko: butuh lebih banyak *layer* untuk menangkap objek besar |
| **Besar** (5×5, 7×7, 11×11) | Field luas dalam satu lapis; parameter & FLOPs naik kuadratik (k²) | Menangkap pola besar langsung, tetapi lebih rawan **overfitting** pada dataset kecil, lebih lambat, dan gradien lebih sulit mengalir. AlexNet memakai 11×11 di lapis pertama karena citra input besar (224×224) |

Catatan penting: 1×1 kernel tidak melihat tetangga sama sekali — perannya adalah **mengubah jumlah kanal** (bottleneck) dan menambah non-linearitas, bukan mengekstraksi fitur spasial.

### 2. Jumlah kernel (jumlah filter / lebar layer, C_out)

Menentukan **jumlah feature map** (kedalaman kanal) yang dihasilkan tiap lapis, yaitu kekayaan representasi.

- **Terlalu sedikit** → representasi tidak cukup kaya → **underfitting**; model tidak mampu memisahkan kelas yang kompleks.
- **Terlalu banyak** → parameter & memori naik linear terhadap C_out, waktu latih naik → **overfitting** pada data terbatas, dan marginal gain menurun.
- Kurva akurasi terhadap jumlah kernel biasanya **naik lalu mendatar (plateau)**, kadang menurun bila overfitting mulai dominan.

### 3. Jumlah layer (kedalaman)

Kedalaman membentuk **hierarki fitur**: lapis awal menangkap tepi/warna → lapis tengah tekstur & motif → lapis dalam bagian objek → lapis akhir objek utuh. Kedalaman juga memperbesar receptive field efektif, yang dibutuhkan untuk mengenali objek besar.

- Menambah layer umumnya **menaikkan akurasi** sampai titik tertentu.
- Namun muncul tiga kendala: (i) **vanishing/exploding gradient** — gradien dikalikan berantai sehingga lapis awal hampir tidak ter-update; (ii) **degradasi** — pada *plain network* yang sangat dalam, *training error* justru **naik** setelah melewati kedalaman tertentu (bukan karena overfitting, melainkan karena optimasi makin sulit); (iii) waktu latih, memori, dan kebutuhan data/regularisasi naik. Karena itu jaringan sangat dalam memerlukan *residual connection* atau *batch normalization* agar tetap dapat dilatih.

### 4. Learning rate (η)

Learning rate adalah hiperparameter **paling sensitif** dan paling menentukan apakah model konvergen sama sekali.

| Nilai η | Gejala | Akibat pada akurasi |
|---|---|---|
| **Terlalu besar** | Loss berosilasi, meledak (*divergence*), NaN | Model tidak pernah konvergen → akurasi rendah/acak |
| **Terlalu kecil** | Konvergensi sangat lambat; butuh epoch sangat banyak | Terjebak pada minimum lokal/*saddle* atau berhenti sebelum konvergen; akurasi suboptimal |
| **Tepat + schedule** | Turun stabil | Menemukan *flat minima* yang menggeneralisasi lebih baik |

Praktik terbaik: *warmup* di awal, lalu *decay* (step decay, cosine annealing), dan/atau optimizer adaptif (Adam, RMSProp) yang menyesuaikan η per-parameter. Bukti empiris menunjukkan η juga memengaruhi **kualitas minimum** yang ditemukan: η besar cenderung berakhir di *sharp minima* (generalisasi buruk), η kecil+schedule di *flat minima* (generalisasi baik).

### 5. Ringkasan trade-off

| Hiperparameter | Naikkan → | Turunkan → |
|---|---|---|
| Ukuran kernel | Receptive field, parameter ↑ | Parameter ↓, butuh lebih banyak layer |
| Jumlah kernel | Kapasitas ↑, risiko overfit ↑ | Underfitting |
| Jumlah layer | Hierarki fitur ↑, vanishing gradient ↑ | Kapasitas kurang |
| Learning rate | Divergensi | Konvergensi lambat |

Kesimpulannya: hiperparameter **tidak independen** — menambah kedalaman tanpa menambah data dan regularisasi justru menurunkan akurasi, sedangkan memperbesar kernel bisa digantikan tumpukan kernel kecil dengan hasil lebih baik. Tuning (grid/random/Bayesian search) diperlukan untuk menemukan kombinasi kapasitas vs data yang optimal.

---

## Soal 1b — *Depthwise Convolution* Mengurangi Parameter MobileNet (15 poin)

### Konvolusi standar: biaya parameter

Satu filter konvolusi standar berukuran K×K bekerja pada **seluruh** C_in kanal input sekaligus, dan menghasilkan satu kanal output. Untuk menghasilkan C_out kanal:

```text
Parameter  = K² · C_in · C_out  (+ C_out bias)
Komputasi  = K² · C_in · C_out · H · W
```

Perhatikan: biaya mengandung **perkalian C_in × C_out** — inilah sumber ledakan parameter.

### Konvolusi *depthwise separable*: dekomposisi menjadi dua langkah

MobileNet menggantinya dengan **dua** operasi berurutan [2]:

**Langkah 1 — Depthwise convolution (filtering spasial, per kanal).**
Setiap kanal input mendapat **satu** filter K×K sendiri-sendiri; tidak ada pencampuran antar-kanal.

```text
Parameter  = K² · C_in        (tidak ada C_out!)
Komputasi  = K² · C_in · H · W
```

**Langkah 2 — Pointwise convolution (1×1, pencampuran kanal).**
Konvolusi 1×1 memproyeksikan C_in kanal → C_out kanal. Di sinilah (dan hanya di sini) pencampuran antar-kanal terjadi.

```text
Parameter  = C_in · C_out
Komputasi  = C_in · C_out · H · W
```

### Perbandingan parameter

```text
                          K² · C_in + C_in · C_out        1        1
Rasio = ────────────────────────────────  =  ───────  +  ─────
                    K² · C_in · C_out           C_out      K²
```

Untuk K = 3 (kasus MobileNet): rasio ≈ **1/9 + 1/C_out** → pengurangan parameter sekitar **8–9×**; paper melaporkan pengurangan komputasi 8–9× dengan akurasi hanya turun sedikit [2].

### Contoh numerik (K = 3, C_in = C_out = 64)

| | Rumus | Parameter |
|---|---|---|
| Konvolusi standar 3×3 | 3²·64·64 | **36.864** |
| Depthwise 3×3 | 3²·64 | 576 |
| Pointwise 1×1 | 64·64 | 4.096 |
| **Total depthwise separable** | | **4.672** |

Reduksi = 4.672 / 36.864 ≈ **0,127** → **~7,9× lebih sedikit parameter (≈87% pengurangan)**.

### Mengapa ini penting dan bagaimana MobileNet memanfaatkannya

- Yang mahal pada CNN adalah perkalian **C_in × C_out**; memisahkannya menjadi "spasial dulu (per kanal), campur kanal kemudian (1×1)" memutus perkalian tersebut menjadi **penjumlahan**.
- MobileNetV1 dibangun dari blok **depthwise 3×3 → BatchNorm → ReLU → pointwise 1×1 → BatchNorm → ReLU** (hanya lapis pertama berupa konvolusi standar), sehingga modelnya berukuran ~4,2 juta parameter dan hanya butuh ratusan juta MACs — cukup untuk ponsel dan perangkat *embedded*.
- Paper juga memperkenalkan dua hiperparameter global untuk trade-off *latency*–akurasi [2]: **width multiplier α** (menipiskan seluruh layer secara seragam) dan **resolution multiplier ρ** (menurunkan resolusi input) — α·ρ bertindak sebagai pengali biaya komputasi.
- Konsekuensi teori: *depthwise separable convolution* mengasumsikan bahwa korelasi **spasial** dan korelasi **antar-kanal** dapat dipisah (*decoupled*), asumsi yang secara empiris cukup baik untuk citra.

---

## Soal 1c — *Residual Connection* ResNet vs *Vanishing Gradient* (15 poin)

### Akar masalah: gradien sebagai hasil perkalian berantai

Pada jaringan *feed-forward* dalam, backpropagation mengalikan Jacobian setiap lapis:

```text
∂L/∂x₁ = ∂L/∂x_L · ∏ᵢ ∂x_{i+1}/∂x_i
```

Jika faktor-faktor ini bernorma < 1 (khas untuk aktivasi sigmoid/tanh, atau bobot yang kecil), hasil kali untuk L lapis menyusut **eksponensial** → gradien pada lapis awal ≈ 0 → bobot lapis awal praktis tidak ter-update, dan jaringan gagal belajar fitur dasar. Inilah *vanishing gradient*. Kebalikannya (norma > 1) memberi *exploding gradient*.

ResNet juga mengidentifikasi masalah kedua yang berbeda: **degradasi** — pada *plain network* yang sangat dalam, *training error* justru naik seiring bertambahnya lapis, bukan karena overfitting tetapi karena optimasi menjadi sulit [1].

### Solusi ResNet: mempelajari *residual* terhadap identitas

Blok residual mengubah target pembelajaran dari `H(x)` menjadi `F(x) = H(x) − x`, dengan output blok:

```text
y = F(x, {Wᵢ}) + x
```

Kuncinya ada pada **jalur identitas (*identity shortcut*) `+ x`** yang *parameter-free*. Saat backpropagation, turunan blok menjadi:

```text
∂y/∂x = 1 + ∂F(x)/∂x
```

Suku **"+1"** inilah yang menjadi *gradient superhighway*:

1. **Gradien selalu punya jalur bernorma ≥ 1 menuju lapis awal.** Meskipun `∂F/∂x` sangat kecil (mendekati 0, yaitu blok hampir tidak mengubah apa pun), gradien tetap dapat mengalir utuh lewat jalur identitas. Secara matematis, gradien tidak lagi berupa hasil kali murni yang dapat menyusut ke nol — ia berupa **jumlah** yang selalu mengandung suku identitas.
2. **Optimasi menjadi mudah.** Belajar fungsi identitas berarti mendorong `F → 0`, yang jauh lebih mudah daripada memaksa tumpukan lapis non-linear mempelajari pemetaan identitas secara implisit.
3. **Menghilangkan masalah degradasi.** Karena sebuah blok dapat selalu memilih `F = 0` (identitas), jaringan yang lebih dalam **tidak pernah lebih buruk** daripada versi yang lebih dangkal — kedalaman ekstra sekurang-kurangnya setara dengan menambahkan lapis identitas. Ini menghapus anomali *training error* yang naik pada *plain net* [1].
4. **Informasi mengalir lancar ke depan maupun ke belakang** melalui *shortcut*, sehingga sinyal (fitur dan gradien) tidak harus melewati rantai transformasi non-linear yang panjang.
5. **Tidak menambah parameter dan hampir tidak menambah komputasi.** *Shortcut* identitas tidak punya bobot; bila dimensi berubah (mis. karena stride 2), digunakan *projection shortcut* 1×1 konvolusi untuk mencocokkan bentuk.

### Hasil empiris

Dengan kerangka ini, ResNet berhasil melatih jaringan hingga **152 lapis** (8× lebih dalam dari VGG, namun kompleksitasnya lebih rendah) dan mencapai **3,57% error** top-5 pada ImageNet test set — juara 1 ILSVRC 2015 — serta mendemonstrasikan jaringan **1000 lapis** pada CIFAR-10 [1]. Sebelumnya, jaringan sedalam ini tidak dapat dilatih.

> Catatan: ResNet mengatasi *degradasi* dan mempermudah aliran gradien, tetapi bukan obat mujarab untuk *exploding gradient* maupun masalah overfitting pada data kecil — keduanya masih perlu ditangani dengan inisialisasi, BatchNorm, dan regularisasi.

---

## Soal 1d — GoogleNet (Inception) Mengatasi Pelatihan Jaringan Dalam yang Rumit (20 poin)

### Masalah yang harus dipecahkan

Soal menyatakan dilemanya dengan tepat: menambah lapis menaikkan akurasi, **tetapi** membuat pelatihan lebih rumit dan lebih lama. Secara konkret, "menambah lapis" pada arsitektur biasa (mis. VGG) berarti:

1. **Parameter dan FLOPs meledak** — lapis *fully connected* di ujung jaringan mendominasi jumlah parameter (AlexNet ~60 juta parameter), dan konvolusi besar (5×5, 7×7) dengan banyak kanal sangat mahal.
2. **Vanishing gradient** — gradien sulit mencapai lapis awal jaringan 20+ lapis.
3. **Overfitting** — puluhan juta parameter pada dataset terbatas.
4. **Boros komputasi** — anggaran komputasi (*computational budget*) menjadi penghalang utama untuk memperdalam jaringan.

### Tiga gagasan inti Inception

**Gagasan 1 — Modul Inception: pemrosesan multi-skala secara paralel.**
Satu modul Inception menjalankan beberapa cabang konvolusi dengan ukuran kernel berbeda **secara bersamaan** (1×1, 3×3, 5×5, dan *max pooling* 3×3), lalu **menggabungkan (*concatenate*) hasilnya pada dimensi kanal**. Alih-alih memilih satu ukuran kernel terbaik, jaringan melihat semua skala sekaligus (berdasarkan intuisi *multi-scale processing* dan prinsip Hebbian) [3]. Hasilnya jaringan bertambah **dalam dan lebar sekaligus**, bukan hanya dalam.

**Gagasan 2 — Reduksi dimensi dengan konvolusi 1×1 (bottleneck): menahan biaya komputasi tetap.**
Modul Inception naif akan meledak: konvolusi 5×5 pada ratusan kanal sangat mahal. Solusinya, sebelum setiap konvolusi 3×3 dan 5×5 disisipkan **konvolusi 1×1** yang memangkas jumlah kanal terlebih dahulu; setelah *max pooling* juga disisipkan 1×1. Karena konvolusi 1×1 hanya berbiaya C_in·C_out, langkah ini sangat murah tetapi memangkas biaya konvolusi besar secara drastis — **memungkinkan menambah kedalaman dan lebar sambil menjaga anggaran komputasi tetap konstan** [3]. Bonusnya, setiap 1×1 menambahkan non-linearitas ReLU.

**Gagasan 3 — Arsitektur hemat parameter + regularisasi gradien.**
- **Tanpa lapis fully connected besar di ujung**: jaringan diakhiri *global average pooling* → 5 kanal → softmax. Ini memangkas puluhan juta parameter dan sangat menekan overfitting.
- **Dua *auxiliary classifier*** di lapis tengah, dengan softmax tambahan berbobot kecil (~0,3) pada total loss, disuntikkan agar gradien tetap kuat di lapis tengah (melawan vanishing gradient) sekaligus bertindak sebagai regularizer.
- **Dropout** pada lapis pengklasifikasi akhir.

### Hasilnya

GoogLeNet adalah jaringan **22 lapis** dengan hanya **~5 juta parameter — sekitar 12× lebih sedikit daripada AlexNet (~60 juta)** — dan hanya **1,5 miliar operasi multiply-add** saat inferensi, namun mencapai **6,67% error top-5** pada ILSVRC 2014 dan memenangkan kompetisi klasifikasi [3].

### Inti jawaban

GoogleNet memecahkan dilema "dalam tapi mahal" bukan dengan satu trik, melainkan dengan **mengubah cara biaya dihitung**: modul Inception membuat jaringan tumbuh *lebar dan dalam* tanpa menaikkan anggaran komputasi (karena tiap cabang hanya beroperasi pada kanal yang sudah dipangkas oleh bottleneck 1×1), menghapus *fully connected layer* yang boros parameter, dan menambahkan *auxiliary classifier* agar gradien tetap sehat pada jaringan dalam. Dengan kata lain: **kedalaman dan lebar diperoleh dengan menjaga jumlah parameter dan FLOPs tetap rendah**, sehingga pelatihan menjadi lebih cepat, lebih stabil, dan tidak mudah overfit — persis kebalikan dari pendekatan "perbesar segalanya".

---

## Soal 1e — Arsitektur, Ukuran Activation Map, dan Jumlah Parameter (40 poin)

### Asumsi dan rumus

- Format tensor **C × H × W**; input `1×24×24` berarti **1 kanal (grayscale)**, 24×24 piksel.
- Konvolusi *valid* (no-padding), stride 1 → `H_out = H_in − K + 1`.
- Max pooling 2×2, stride 2 → `H_out = ⌊(H_in − 2)/2⌋ + 1`.
- Parameter konvolusi = `(K² · C_in + 1) · C_out` — **bias dihitung** (satu bias per filter), sesuai konvensi Keras/TensorFlow.
- Parameter dense = `C_in · C_out + C_out`.
- Pooling tidak punya parameter.

### Diagram arsitektur

```text
   Input
   1×24×24
      │
      ▼
┌──────────────────────────────┐
│ Conv 3×3, 10 kernel, s=1     │   params = (3·3·1+1)·10 = 100
│ ReLU                         │
└──────────────────────────────┘
      │  10×22×22
      ▼
┌──────────────────────────────┐
│ Conv 5×5, 10 kernel, s=1     │   params = (5·5·10+1)·10 = 2.510
│ ReLU                         │
└──────────────────────────────┘
      │  10×18×18
      ▼
┌──────────────────────────────┐
│ Max Pool 2×2, s=2            │   params = 0
└──────────────────────────────┘
      │  10×9×9
      ▼
┌──────────────────────────────┐
│ Conv 3×3, 8 kernel, s=1      │   params = (3·3·10+1)·8 = 728
│ ReLU                         │
└──────────────────────────────┘
      │  8×7×7
      ▼
┌──────────────────────────────┐
│ Conv 5×5, 8 kernel, s=1      │   params = (5·5·8+1)·8 = 1.608
│ ReLU                         │
└──────────────────────────────┘
      │  8×3×3
      ▼
┌──────────────────────────────┐
│ Max Pool 2×2, s=2            │   params = 0
└──────────────────────────────┘
      │  8×1×1
      ▼
   Flatten ──────────────────►  8 vektor fitur
      │
      ▼
┌──────────────────────────────┐
│ Dense 15 (ReLU)              │   params = 8·15+15 = 135
└──────────────────────────────┘
      │  15
      ▼
┌──────────────────────────────┐
│ Dense 5 (Softmax)            │   params = 15·5+5 = 80
└──────────────────────────────┘
      │
      ▼
   5 kelas (output)
```

### Ukuran activation map tiap lapisan

| # | Lapisan | Rumus ukuran | Ukuran activation map | Parameter |
|---|---|---|---|---|
| 0 | Input Layer | — | **1 × 24 × 24** | 0 |
| 1 | Conv 3×3, 10 kernel, s1, no-pad | (24−3+1)=22 | **10 × 22 × 22** | (3·3·1+1)·10 = **100** |
| 2 | Conv 5×5, 10 kernel, s1, no-pad | (22−5+1)=18 | **10 × 18 × 18** | (5·5·10+1)·10 = **2.510** |
| 3 | Max Pool 2×2, s2 | ⌊(18−2)/2⌋+1=9 | **10 × 9 × 9** | **0** |
| 4 | Conv 3×3, 8 kernel, s1, no-pad | (9−3+1)=7 | **8 × 7 × 7** | (3·3·10+1)·8 = **728** |
| 5 | Conv 5×5, 8 kernel, s1, no-pad | (7−5+1)=3 | **8 × 3 × 3** | (5·5·8+1)·8 = **1.608** |
| 6 | Max Pool 2×2, s2 | ⌊(3−2)/2⌋+1=1 | **8 × 1 × 1** | **0** |
| 7 | Flatten | 8·1·1 | **8** | **0** |
| 8 | Fully Connected (Dense 15) | — | **15** | 8·15+15 = **135** |
| 9 | Output Layer (Dense 5) | — | **5** | 15·5+5 = **80** |

### Rincian perhitungan parameter

**Lapisan 1 — Conv 3×3, 10 kernel, input 1 kanal:**
Satu filter 3×3 pada 1 kanal = 3·3·1 = 9 bobot, ditambah 1 bias → 10 parameter per filter.
`10 × 10 = 100`

**Lapisan 2 — Conv 5×5, 10 kernel, input 10 kanal:**
Satu filter 5×5 pada 10 kanal = 5·5·10 = 250 bobot, ditambah 1 bias → 251 parameter per filter.
`251 × 10 = 2.510`

**Lapisan 4 — Conv 3×3, 8 kernel, input 10 kanal:**
`(3·3·10 + 1) × 8 = 91 × 8 = 728`

**Lapisan 5 — Conv 5×5, 8 kernel, input 8 kanal:**
`(5·5·8 + 1) × 8 = 201 × 8 = 1.608`

**Lapisan 8 — Dense 15, input 8 (hasil flatten):**
`8 × 15 + 15 = 120 + 15 = 135`

**Lapisan 9 — Dense 5, input 15:**
`15 × 5 + 5 = 75 + 5 = 80`

### Total parameter yang harus dioptimalkan

| Lapisan | Parameter |
|---|---|
| Conv 3×3 (10 kernel) | 100 |
| Conv 5×5 (10 kernel) | 2.510 |
| Max Pool 2×2 | 0 |
| Conv 3×3 (8 kernel) | 728 |
| Conv 5×5 (8 kernel) | 1.608 |
| Max Pool 2×2 | 0 |
| Flatten | 0 |
| Dense 15 | 135 |
| Dense 5 (output) | 80 |
| **TOTAL** | **5.161** |

> **Total parameter = 5.161** (dengan bias dihitung pada setiap lapisan konvolusi dan dense).

### Catatan tambahan (nilai plus)

- **Alternatif jika bias konvolusi diabaikan** (konvensi beberapa pustaka): 100−10 = 90; 2.510−10 = 2.500; 728−8 = 720; 1.608−8 = 1.600 → total **5.125**. Jika *semua* bias (termasuk dense) diabaikan: **5.105**. Jawaban 5.161 adalah yang konsisten dengan "jangan lupa menghitung bias" yang biasa diminta di soal UGM.
- **Kebetulan struktural yang menarik:** setelah pooling terakhir, tensor sudah menjadi **8 × 1 × 1**, sehingga `Flatten` di sini identik dengan *global average pooling* — tidak ada informasi spasial tersisa. Konsekuensinya, hampir seluruh kapasitas spasial jaringan (lapis 1–5) hanya berfungsi sebagai ekstraktor fitur, dan pengklasifikasi akhir bekerja pada vektor 8 dimensi.
- **Beban komputasi (MACs), sebagai pembanding:** lapis 1 ≈ 43.560; lapis 2 = 810.000; lapis 4 = 35.280; lapis 5 = 14.400; Dense 15 = 120; Dense 5 = 75 → **≈ 903.435 MACs (~0,9 M)**. Perhatikan bahwa **lapis 2 mendominasi ~90% komputasi** meskipun parameternya hanya separuh total — konsekuensi langsung dari konvolusi 5×5 dengan input 10 kanal.
- **Penurunan dimensi yang agresif:** 24→22→18→9→7→3→1. Ukuran spasial menyusut ~24×, sementara jumlah kanal hanya berubah 1→10→8. Ini arsitektur yang "menipis secara spasial" sangat cepat; menambah padding (*same*) pada lapis konvolusi akan mempertahankan resolusi lebih lama.
- **Catatan pembulatan pooling:** rumus yang dipakai adalah *floor* (standar Keras/TensorFlow). Bila dipakai *ceil*, lapis 6 akan menghasilkan 2×2 alih-alih 1×1, dan total parameter menjadi `8·4·15+15 = 495` pada Dense 15 → total **5.521**. Karena itu, tuliskan asumsi pembulatan Anda di lembar jawaban.

---

## Soal 2a — Cara Kerja RNN pada Data Sekuensial dan Kendala Utamanya (20 poin)

### Mengapa data sekuensial butuh RNN

Data sekuensial (teks, audio, deret waktu, DNA) memiliki tiga sifat yang tidak ditangani MLP/CNN biasa: **urutan penting** (kata yang sama di posisi berbeda bermakna berbeda), **panjang bervariasi**, dan **ketergantungan jarak jauh** (kata ke-1 menentukan kata ke-20). MLP tidak punya konsep "sebelumnya"; CNN hanya melihat jendela lokal dengan ukuran tetap.

### Mekanisme kerja

RNN memproses sekuens **satu langkah waktu pada satu waktu** sambil memelihara sebuah **hidden state** `h_t` yang berperan sebagai ringkasan memori seluruh input sebelumnya:

```text
h_t = tanh(W_hh · h_{t-1} + W_xh · x_t + b_h)
y_t = softmax(W_hy · h_t + b_y)
```

Tiga sifat kunci:

1. **Parameter dibagi antar-langkah waktu (*parameter sharing*).** Bobot `W_hh`, `W_xh`, `W_hy` sama di setiap t. Ini membuat jumlah parameter tidak bergantung pada panjang sekuens, memungkinkan generalisasi ke posisi/panjang yang belum pernah dilihat, dan memperbolehkan panjang input berapa pun.
2. **Rekurensi = "unrolling" sepanjang waktu.** Secara konseptual jaringan direplikasi T kali dan dihubungkan berantai; pelatihannya memakai **Backpropagation Through Time (BPTT)** — gradien dihitung pada graf yang sudah di-unroll, lalu dijumlahkan atas semua langkah waktu.
3. **Output tiap langkah bergantung pada seluruh riwayat** yang telah diringkas ke dalam `h_t` (dengan bobot yang makin kecil untuk masa lalu yang jauh).

### Kendala utama

| # | Kendala | Penjelasan |
|---|---|---|
| 1 | **Vanishing gradient** | Gradien BPTT adalah hasil kali Jacobian `∂h_t/∂h_{t-1}` untuk setiap langkah. Karena normanya < 1 (tanh/sigmoid menyaturasi, bobot kecil), gradien menyusut eksponensial → **tidak mampu belajar ketergantungan jarak jauh** (mis. kesesuaian subjek–predikat yang terpisah jauh). |
| 2 | **Exploding gradient** | Bila norma > 1, gradien meledak → pembaruan bobot tak stabil, loss menjadi NaN. Perlu *gradient clipping*. |
| 3 | **Memori jangka pendek / bottleneck informasi** | `h_t` berukuran tetap, tetapi harus memuat seluruh riwayat. Terjadi kompetisi antar-informasi; informasi lama tertimpa (bias *recency*). |
| 4 | **Tidak dapat diparalelkan** | Perhitungan langkah t menunggu langkah t−1 → tidak dapat diparalelkan sepanjang waktu → pelatihan sangat lambat untuk sekuens panjang. Ini justru motivasi utama Transformer. |
| 5 | **Sulit dilatih & di-tuning** | Sangat sensitif terhadap learning rate, inisialisasi, dan kedalaman; rentan terhadap saturasi aktivasi; memerlukan banyak trik (gradient clipping, truncated BPTT). |
| 6 | **Kesulitan pada sekuens sangat panjang** | Bahkan dengan LSTM, sekuens puluhan ribu langkah (mis. audio mentah) tidak praktis di-BPTT penuh. |

### Mitigasi

Gated RNN (LSTM/GRU) dengan jalur aditif, *gradient clipping*, inisialisasi ortogonal/identitas, *truncated BPTT*, *layer normalization*, dan mekanisme *attention* yang memberi jalur langsung antar-posisi.

---

## Soal 2b — Mekanisme *Update Gate* dan *Reset Gate* pada GRU (20 poin)

GRU (*Gated Recurrent Unit*) diperkenalkan Cho et al. (2014) sebagai penyederhanaan LSTM: **dua gerbang, satu hidden state, tanpa cell state terpisah** [4].

### Notasi

`x_t` = input pada langkah t; `h_{t-1}` = hidden state sebelumnya; `σ` = sigmoid; `⊙` = perkalian elemen-per-elemen (*Hadamard*).

### 1. Reset gate (gerbang reset)

```text
r_t = σ(W_r · [h_{t-1}, x_t])
```

Menentukan **seberapa banyak memori masa lalu yang perlu diingat saat menghitung kandidat state baru**:

```text
h̃_t = tanh(W · [r_t ⊙ h_{t-1}, x_t])
```

- **r_t → 0** ⇒ `h_{t-1}` "direset"/dilupakan untuk sementara, kandidat `h̃_t` bergantung hampir hanya pada `x_t`. Perilaku ini seperti membaca **simbol pertama** sekuens — berguna ketika konteks sebelumnya tidak relevan atau ketika terjadi perubahan topik/rezim yang mendadak.
- **r_t → 1** ⇒ seluruh state sebelumnya dipakai; kandidat memperhitungkan riwayat penuh.
- Karena `r_t` adalah vektor (bukan skalar), setiap dimensi memori dapat direset secara independen — model dapat membuang sebagian memori tanpa membuang semuanya.

### 2. Update gate (gerbang update)

```text
z_t = σ(W_z · [h_{t-1}, x_t])
```

Menentukan **berapa banyak state lama yang dipertahankan vs berapa banyak kandidat baru yang dipakai**, lewat interpolasi linear:

```text
h_t = (1 − z_t) ⊙ h_{t-1} + z_t ⊙ h̃_t        (konvensi modern)
```

*(Pada makalah asli Cho et al. (2014) notasi kebalikannya: `h_t = z_t ⊙ h_{t-1} + (1 − z_t) ⊙ h̃_t` [4] — keduanya ekuivalen, hanya penamaan perannya yang tertukar. Tuliskan konvensi yang Anda pakai.)*

- **z_t → 1** ⇒ `h_t ≈ h_{t-1}`: state **disalin utuh**; memori lama dipertahankan, informasi baru diabaikan.
- **z_t → 0** ⇒ `h_t ≈ h̃_t`: state **ditimpa** dengan kandidat baru.

### 3. Bagaimana kedua gerbang memengaruhi aliran informasi

**a. Kombinasi aditif = "leaky integrator" dan jalan tol gradien.**
Karena `h_t` dibentuk dari **penjumlahan** `h_{t-1}` dan `h̃_t` (bukan perkalian berantai seperti RNN vanilla), gradien dapat mengalir mundur melalui jalur identitas saat `z_t ≈ 1`. Turunannya:

```text
∂h_t/∂h_{t-1} = (1 − z_t) + suku lain yang mengandung ∂h̃_t/∂h_{t-1}
```

Suku `(1 − z_t)` berperan analog dengan **residual connection** pada ResNet — inilah alasan GRU jauh lebih tahan terhadap *vanishing gradient* daripada RNN vanilla. Model dapat memilih, per dimensi, untuk **mempertahankan memori selama ratusan langkah** (z ≈ 1) tanpa gradien menyusut.

**b. Pembagian kerja yang bersih antara "kapan mengingat" dan "apa yang diingat".**
- **Reset gate** mengendalikan **isi** kandidat — apakah konteks lama relevan untuk membentuk informasi baru (bersifat *jangka pendek*).
- **Update gate** mengendalikan **durasi** memori — berapa lama informasi dipertahankan (bersifat *jangka panjang*).
Kombinasi ini memberi GRU kemampuan adaptif untuk **menyesuaikan skala waktu** yang dibutuhkan tugas: tugas dengan ketergantungan panjang mendorong z ≈ 1 pada dimensi terkait, tugas dengan sinyal berubah cepat mendorong r ≈ 0.

**c. Efisiensi dibanding LSTM.**
GRU hanya punya 2 gerbang (vs 3 di LSTM: input, forget, output) dan tidak punya cell state terpisah, sehingga parameternya **~25% lebih sedikit** dan lebih cepat dilatih; pada banyak tugas akurasinya setara LSTM, dan pada dataset kecil GRU cenderung lebih unggul karena lebih sedikit overfitting.

---

## Soal 2c — Aplikasi Nyata di Mana GRU Lebih Baik daripada LSTM (25 poin)

### Contoh terpilih: *keyword spotting* / deteksi kata kunci "on-device" pada perangkat tertanam

**Skenario.** Sistem mendeteksi kata pemicu (mis. "Hey Siri"-style wake word, atau perintah "nyalakan lampu") langsung di mikrokontroler/perangkat *wearable* dengan RAM ratusan kilobyte dan tanpa GPU. Audio di-*frame* 10 ms → MFCC/log-mel (mis. 40 dimensi), menghasilkan sekuens ratusan langkah, lalu dipetakan ke kelas kata kunci + "unknown" + "silence".

**Mengapa GRU lebih baik di sini:**

| Faktor | Penjelasan |
|---|---|
| **Parameter lebih sedikit** | GRU ~25% lebih kecil dari LSTM (2 gerbang vs 3, tanpa cell state). Pada perangkat tertanam, batas kerasnya adalah **memori dan daya**, bukan akurasi absolut. |
| **Latensi & *throughput*** | Perhitungan per langkah lebih ringan → respons *real-time* dan baterai lebih hemat. |
| **Data terbatas** | Dataset *wake word* yang berlabel mahal; kapasitas lebih kecil = risiko overfitting lebih rendah. |
| **Ketergantungan tidak terlalu panjang** | Kata pemicu hanya ~0,5–1 detik; LSTM yang dirancang untuk ketergantungan sangat panjang tidak memberi keunggulan berarti. |
| **Konvergensi lebih cepat** | Lebih sedikit parameter & gerbang → lebih cepat mencapai akurasi setara, penting untuk iterasi produk. |

### Contoh pendukung lain

1. **Deteksi kejang EEG / klasifikasi sinyal klinis pada dataset kecil.** Data pasien jumlahnya sedikit dan sangat beragam; GRU dengan kapasitas lebih kecil menggeneralisasi lebih baik dan lebih mudah divalidasi silang antar-pasien. (*Caveat:* pada korpus besar multi-rumah-sakit, LSTM/Transformer dapat menyusul.)
2. **Prediksi lalu lintas jangka pendek & peramalan beban listrik.** Pola harian/mingguan tidak ekstrem panjang; GRU memberi akurasi setara LSTM dengan waktu latih lebih singkat — penting karena model harus dilatih ulang berkala.
3. **Pengenalan aktivitas manusia (HAR) dari sensor *wearable*.** Sekuens pendek (jendela beberapa detik), sumber daya terbatas, dan GRU berkinerja setara atau lebih baik.
4. **Pemodelan musik polifonik dan pemodelan sinyal ucapan.** Evaluasi sistematis Chung et al. (2014) — makalah yang memperkenalkan GRU — menemukan bahwa **GRU mencapai kinerja setara atau lebih baik daripada LSTM pada tugas pemodelan musik polifonik dan pemodelan sinyal ucapan, dengan jumlah parameter lebih sedikit dan konvergensi lebih cepat** [4].

### Kejujuran akademik: kapan LSTM tetap lebih baik

Keunggulan GRU **bukan universal**. LSTM cenderung menang ketika:
- ketergantungan sangat panjang (ratusan–ribuan langkah) — cell state terpisah dan gerbang output memberi kontrol lebih halus;
- data pelatihan sangat besar — kapasitas ekstra LSTM terpakai, bukan menjadi beban;
- tugas memerlukan pemisahan tegas antara "memori internal" dan "output" (mis. pada beberapa tugas *sequence-to-sequence*).

**Kalimat kunci jawaban:** GRU lebih baik ketika **anggaran (memori/komputasi/waktu latih) adalah kendala utama, data terbatas, dan panjang ketergantungan moderat** — yaitu justru kondisi tipikal aplikasi *edge* dan *real-time*. Pada kondisi itu, efisiensi GRU menjadi keunggulan akurasi, bukan sekadar efisiensi.

---

## Soal 2d — Tantangan Melatih LSTM untuk Pengenalan Suara dan Solusinya (35 poin)

### Karakteristik masalah

Pengenalan suara memetakan sinyal audio variabel-panjang → rangkaian kata/karakter, dengan **variabilitas akustik yang besar** (penutur, aksen, kanal mikrofon, derau, gema, kecepatan bicara) dan **tanpa korespondensi satu-satu** antara frame audio dan simbol output. LSTM dipilih karena mampu memodelkan konteks temporal, tetapi justru sifat-sifat inilah yang menciptakan tantangan berikut.

### Tantangan 1 — Sekuens sangat panjang dan BPTT yang tidak praktis

**Masalah.** Audio 16 kHz = 16.000 sampel/detik. Kalimat 10 detik = 160.000 langkah waktu; unrolling penuh untuk BPTT meledakkan memori dan gradien.

**Solusi.**
- **Ekstraksi fitur ber-*frame***: MFCC atau log-mel spectrogram dengan frame 20–25 ms dan *hop* 10 ms → ~100 frame/detik, memangkas panjang sekuens ~160×.
- **Subsampling bertingkat / front-end CNN**: letakkan CNN atau pooling di depan LSTM (arsitektur **CNN–LSTM**), atau gunakan *pyramidal BiLSTM* yang memangkas resolusi waktu tiap lapis.
- **Truncated BPTT** + pelatihan per segmen, atau *chunked* training untuk utterance panjang.
- **Bucketing by length** agar batch tidak dipenuhi padding.

### Tantangan 2 — Masalah penyelarasan (alignment) audio ↔ teks

**Masalah.** Tidak diketahui frame mana yang bersesuaian dengan huruf/fonem mana; ini masalah *latent alignment*.

**Solusi.**
- **CTC (Connectionist Temporal Classification)** — Graves et al.: menambahkan simbol *blank* dan memarginalkan (menjumlahkan) probabilitas **semua** penyelarasan yang mungkin, sehingga model dapat dilatih **tanpa anotasi batas** dan memungkinkan decoding *greedy*/beam search. Ini pendekatan standar untuk LSTM-CTC.
- **Attention-based encoder–decoder (mis. Listen-Attend-Spell)**: encoder LSTM merangkum audio, decoder LSTM dengan *attention* menghasilkan karakter/kata sekaligus menyelaraskan secara lunak (*soft alignment*) dan memberi interpretabilitas.

### Tantangan 3 — Vanishing/exploding gradient dan ketergantungan jarak jauh

**Masalah.** Bahkan dengan gerbang LSTM, konteks antar-kata yang berjauhan atau prosodi lintas-frasa dapat hilang; pelatihan berlapis-lapis tidak stabil.

**Solusi.**
- **Gradient clipping** (mis. norma maksimum 1–5) — wajib untuk mengatasi *exploding gradient*.
- **Layer normalization** pada koneksi rekuren, **residual connections** antar lapis, dan **dropout rekuren** (variational dropout) yang diterapkan pada state, bukan pada input.
- **Inisialisasi identitas/ortogonal** untuk matriks rekuren.
- Arsitektur **bidirectional LSTM** untuk mode *offline* (konteks kiri-kanan sekaligus); **uni-directional + latensi rendah** untuk *streaming*.
- Berpindah ke **Transformer/Conformer** bila anggaran data besar dan paralelisasi dibutuhkan.

### Tantangan 4 — Kebutuhan data besar dan overfitting

**Masalah.** LSTM dengan jutaan parameter sangat rakus data berlabel, sedangkan transkripsi audio mahal.

**Solusi.**
- **Data augmentation**: perturbasi kecepatan & *pitch*, penambahan derau dan gema (*reverberation*), simulasi kanal berbeda, serta **SpecAugment** (masking blok waktu dan frekuensi pada spectrogram).
- **Dropout** (termasuk *variational dropout* rekuren), *weight decay*, *early stopping*.
- **Transfer learning / pretraining self-supervised**: **wav2vec 2.0**, **HuBERT**, **WavLM** — melatih representasi dari audio tak berlabel, lalu *fine-tune* LSTM/Transformer di atasnya dengan data berlabel sedikit. Ini mengubah lanskap: pra-pelatihan besar mengurangi kebutuhan label secara drastis.
- **Multi-condition training** dan **speaker adaptation** (i-vector/x-vector, *speaker embedding*), **CMVN** (cepstral mean & variance normalization) untuk menyeragamkan kanal.

### Tantangan 5 — Ambiguitas akustik (homofon) dan kebutuhan model bahasa

**Masalah.** "to / two / too" identik secara akustik; model akustik saja tidak cukup.

**Solusi.** Sistem **hybrid** atau **CTC + language model**: beam search yang menggabungkan skor akustik dengan **n-gram/neural LM** dan leksikon pengucapan (*pronunciation dictionary*), serta *LM fusion* pada model *sequence-to-sequence*. Ini menaikkan akurasi kata (*word error rate*) secara signifikan.

### Tantangan 6 — Komputasi sekuensial, latensi, dan memori aktivasi

**Masalah.** Rekurensi tidak dapat diparalelkan sepanjang waktu → pelatihan lambat; inferensi *streaming* menuntut latensi rendah; memori aktivasi BPTT besar.

**Solusi.**
- Pelatihan terdistribusi, presisi campuran (fp16 + *loss scaling*), kernel cuDNN yang dioptimalkan.
- *Chunking* + *state carry-over* untuk inferensi *streaming*; *lookahead*/delayed output untuk keseimbangan akurasi–latensi.
- Gunakan **Conformer/Transformer** yang melatih jauh lebih paralel saat data dan komputasi tersedia — sering kali sekarang menjadi pilihan utama, dengan LSTM tetap relevan untuk perangkat terbatas sumber daya.

### Rangkuman tantangan → solusi

| # | Tantangan | Solusi utama |
|---|---|---|
| 1 | Sekuens sangat panjang, BPTT tak praktis | MFCC frame 10 ms, CNN front-end / pyramidal subsampling, truncated BPTT, bucketing |
| 2 | Alignment audio↔teks tak diketahui | **CTC** (blank + marginalisasi alignment); **attention seq2seq** (LAS) |
| 3 | Vanishing/exploding gradient | Gradient clipping, LayerNorm, residual, variational dropout, init ortogonal, BiLSTM |
| 4 | Data berlabel terbatas → overfitting | Augmentasi (speed/pitch/noise), **SpecAugment**, dropout, **pretraining self-supervised** (wav2vec 2.0/HuBERT), CMVN, speaker adaptation |
| 5 | Ambiguitas homofon | CTC/LAS + **language model** & leksikon (beam search, LM fusion) |
| 6 | Sekuensial & latensi | fp16 + distribusi, chunked streaming, alternatif Transformer/Conformer |

**Kesimpulan.** Tantangan LSTM untuk pengenalan suara bukan satu masalah tunggal, melainkan kombinasi **panjang sekuens, penyelarasan laten, gradien, kelangkaan data, dan ambiguitas akustik**. Solusinya bertingkat: rekayasa representasi (frame + subsampling), fungsi loss yang tepat (**CTC**), teknik optimasi (clipping, normalisasi, dropout), augmentasi dan pra-pelatihan, serta penggabungan **model bahasa**. Kombinasi inilah yang membuat sistem LSTM-CTC hybrid bertahun-tahun menjadi *state of the art* sebelum era Transformer.

---

## References

1. K. He, X. Zhang, S. Ren, J. Sun, *Deep Residual Learning for Image Recognition*, arXiv:1512.03385 (2015) — formulasi `y = F(x) + x`, analisis degradasi dan vanishing gradient, ResNet-152 (3,57% error top-5 ImageNet), eksperimen 1000 lapis pada CIFAR-10. https://arxiv.org/abs/1512.03385
2. A. G. Howard, M. Zhu, B. Chen, D. Kalenichenko, W. Wang, T. Weyand, M. Andreetto, H. Adam, *MobileNets: Efficient Convolutional Neural Networks for Mobile Vision Applications*, arXiv:1704.04861 (2017) — *depthwise separable convolution*, pengurangan komputasi 8–9×, hiperparameter *width multiplier* α dan *resolution multiplier* ρ. https://arxiv.org/abs/1704.04861
3. C. Szegedy, W. Liu, Y. Jia, P. Sermanet, S. Reed, D. Anguelov, D. Erhan, V. Vanhoucke, A. Rabinovich, *Going Deeper with Convolutions*, arXiv:1409.4842 (2014) — modul Inception, GoogLeNet 22 lapis, peningkatan kedalaman & lebar dengan anggaran komputasi tetap. https://arxiv.org/abs/1409.4842
4. K. Cho, B. van Merriënboer, Ç. Gülçehre, D. Bahdanau, F. Bougares, H. Schwenk, Y. Bengio, *Learning Phrase Representations using RNN Encoder-Decoder for Statistical Machine Translation*, arXiv:1406.1078 (EMNLP 2014) — makalah asal GRU (reset gate & update gate), evaluasi pada pemodelan musik polifonik dan sinyal ucapan. https://arxiv.org/abs/1406.1078
5. S. Hochreiter, J. Schmidhuber, *Long Short-Term Memory*, Neural Computation 9(8), 1997 — gerbang input/forget/output dan cell state LSTM; dasar perbandingan GRU vs LSTM.
6. A. Graves, S. Fernández, F. Gomez, J. Schmidhuber, *Connectionist Temporal Classification: Labelling Unsegmented Sequence Data with Recurrent Neural Networks*, ICML 2006 — CTC untuk penyelarasan audio–teks tanpa anotasi batas.
7. D. S. Park et al., *SpecAugment: A Simple Data Augmentation Method for Automatic Speech Recognition*, arXiv:1904.08779 (2019) — masking waktu/frekuensi pada spectrogram.
8. J. Chung, Ç. Gülçehre, K. Cho, Y. Bengio, *Empirical Evaluation of Gated Recurrent Neural Networks on Sequence Modeling*, arXiv:1412.3555 (2014) — perbandingan GRU vs LSTM (GRU unggul/ setara dengan parameter lebih sedikit pada pemodelan musik & ucapan).
9. Verifikasi numerik: seluruh ukuran activation map dan hitungan parameter pada Soal 1e dihitung dan diperiksa dengan skrip Python lokal — hasil: `1×24×24 → 10×22×22 → 10×18×18 → 10×9×9 → 8×7×7 → 8×3×3 → 8×1×1`, total parameter **5.161** (dengan bias), ≈903.435 MACs.

---

*Model answers prepared for revision; soal mengikuti transkripsi `UAS_Deep Learning_2024.md` (hasil pembacaan visual atas `UAS_Deep Learning_2024.jpg`, 1 halaman). Diagram arsitektur dan perhitungan parameter pada Soal 1e adalah hasil kerja sendiri, bukan bagian dari lembar soal.*