Week 2 - Pipeline CNN, eksperimen, laporan akhir
This commit is contained in:
@@ -0,0 +1,159 @@
|
||||
# 📄 LAPORAN AKHIR PRAKTIKUM DEEP LEARNING (WEEK 2)
|
||||
**Mata Kuliah:** Kecerdasan Buatan / Deep Learning
|
||||
**Kelompok:** Kelompok 3
|
||||
**Fokus Peran:** Analisis & Integrasi Arsitektur Model (CNN, MLP, NLP Sentimen)
|
||||
|
||||
---
|
||||
|
||||
## DAFTAR ISI
|
||||
1. [Bagian I: Pipeline CNN MNIST Lengkap](#bagian-i-pipeline-cnn-mnist-lengkap)
|
||||
2. [Bagian II: Eksplorasi Kedalaman Arsitektur CNN (2 Blok vs 3 Blok)](#bagian-ii-eksplorasi-kedalaman-arsitektur-cnn-2-blok-vs-3-blok)
|
||||
3. [Bagian III: Analisis Sentimen Ulasan Tokopedia (GAP Model)](#bagian-iii-analisis-sentimen-ulasan-tokopedia-gap-model)
|
||||
4. [Bagian IV: Analisis Kesalahan Klasifikasi Sentimen](#bagian-iv-analisis-kesalahan-klasifikasi-sentimen)
|
||||
5. [Bagian V: Evaluasi Model Sekuensial BiLSTM & Real-Time CLI](#bagian-v-evaluasi-model-sekuensial-bilstm--real-time-cli)
|
||||
6. [Kesimpulan Akhir & Sintesis Integrasi](#kesimpulan-akhir--sintesis-integrasi)
|
||||
|
||||
---
|
||||
|
||||
## BAGIAN I: PIPELINE CNN MNIST LENGKAP
|
||||
|
||||
### (a) Model Summary
|
||||
Arsitektur CNN dibangun dengan 2 blok konvolusi dan pooling hierarkis:
|
||||
|
||||
```text
|
||||
Model: "cnn_mnist"
|
||||
_________________________________________________________________
|
||||
Layer (type) Output Shape Param #
|
||||
=================================================================
|
||||
conv2d (Conv2D) (None, 26, 26, 32) 320
|
||||
max_pooling2d (MaxPooling) (None, 13, 13, 32) 0
|
||||
conv2d_1 (Conv2D) (None, 11, 11, 64) 18,496
|
||||
max_pooling2d_1 (MaxPool) (None, 5, 5, 64) 0
|
||||
flatten (Flatten) (None, 1600) 0
|
||||
dense (Dense) (None, 64) 102,464
|
||||
dropout (Dropout 0.3) (None, 64) 0
|
||||
dense_1 (Dense) (None, 10) 650
|
||||
=================================================================
|
||||
Total params: 121,930 (Trainable: 121,930 | Non-trainable: 0)
|
||||
```
|
||||
|
||||
### (b) Kurva Loss & Akurasi (Training vs Validation)
|
||||
*Visualisasi tersimpan pada:* `results/figures/loss_accuracy_cnn_lengkap.png`
|
||||
|
||||
* **Observasi Loss:** Training loss turun secara konsisten dari ~0.35 ke <0.02. Validation loss stabil pada kisaran ~0.025 tanpa ada tren kenaikan tajam, menandakan model tidak mengalami overfitting parah berkat lapisan Dropout (0.3).
|
||||
* **Observasi Akurasi:** Akurasi validasi mencapai >98.5% hanya dalam 3 epoch pertama dan konvergen stabil di angka ~99.2%.
|
||||
|
||||
### (c) Confusion Matrix pada Test Set (10.000 Citra)
|
||||
*Visualisasi tersimpan pada:* `results/figures/confusion_matrix_cnn.png`
|
||||
|
||||
* Dari total 10.000 citra uji, model berhasil mengklasifikasikan **>9.920 citra secara tepat** (tingkat kesalahan <0.8%).
|
||||
* **Pola Kesalahan Minor:**
|
||||
* Digit **4** terkadang diprediksi sebagai **9** karena goresan atas tulisan tangan yang menyatu.
|
||||
* Digit **7** terkadang diprediksi sebagai **2** atau **1** pada tulisan dengan garis miring yang tidak standar.
|
||||
|
||||
### (d) Perbandingan Kuantitatif: MLP Terbaik vs CNN Sederhana
|
||||
|
||||
| Metrik Evaluasi | MLP Terbaik (Model C + Regularisasi) | CNN Sederhana (2 Blok) | Selisih / Analisis |
|
||||
| :--- | :---: | :---: | :--- |
|
||||
| **Test Accuracy** | 98.24% | **99.23%** | **+0.99% poin persentase** |
|
||||
| **Test Loss** | 0.0609 | **0.0249** | Turun **59.1%** |
|
||||
| **Error Rate** | 1.76% (176 salah) | **0.77% (77 salah)** | **Penurunan error relatif 56.2%** |
|
||||
| **Jumlah Parameter** | 244,554 | **121,930** | **Hemat 50.1% parameter** |
|
||||
| **Waktu / Epoch (CPU)** | **~2.50 detik** | ~16.50 detik | Konvolusi membutuhkan floating operations lebih intensif |
|
||||
|
||||
#### 💡 Analisis Efisiensi Parameter:
|
||||
CNN memiliki **121.930 parameter**, sedangkan MLP memiliki **244.554 parameter**. Artinya, CNN menggunakan **50.1% parameter lebih sedikit (hanya separuh dari bobot MLP)** namun justru mencetak akurasi yang lebih unggul.
|
||||
Hal ini disebabkan oleh dua prinsip dasar CNN:
|
||||
1. **Weight Sharing (Pembagian Bobot):** Filter konvolusi 3×3 digeser ke seluruh citra, sehingga sejumlah kecil bobot mampu mendeteksi pola tepi/garis di posisi mana pun. Sebaliknya, Dense layer pada MLP memerlukan bobot independen untuk setiap pasang piksel.
|
||||
2. **Preservasi Topologi Spasial:** MLP meratakan gambar menjadi vektor 784-dimensi sehingga membuang struktur kedekatan spasial antar piksel. CNN memproses citra 2D secara langsung.
|
||||
|
||||
---
|
||||
|
||||
## BAGIAN II: EKSPLORASI KEDALAMAN ARSITEKTUR CNN (2 BLOK vs 3 BLOK)
|
||||
|
||||
*Visualisasi tersimpan pada:* `results/figures/perbandingan_kedalaman_cnn.png`
|
||||
|
||||
### Tabel Perbandingan Arsitektur:
|
||||
| Arsitektur Model | Konfigurasi Layer | Parameter | Test Accuracy | Waktu Training / Epoch |
|
||||
| :--- | :--- | :---: | :---: | :---: |
|
||||
| **CNN 2 Blok (Baseline)** | Conv(32) $\rightarrow$ Conv(64) $\rightarrow$ Dense(64) | 121,930 | **99.17%** | **6.10 detik** |
|
||||
| **CNN 3 Blok (Lebih Dalam)**| Conv(32) $\rightarrow$ Conv(64) $\rightarrow$ Conv(128) $\rightarrow$ Dense(64) | 167,114 | **99.28%** | **19.13 detik** |
|
||||
|
||||
### 📝 Catatan Temuan Analisis (Satu Paragraf):
|
||||
> Penambahan blok ketiga (`Conv2D` 128 filter + `MaxPooling2D`) pada citra MNIST (28×28 piksel) menghasilkan akurasi test sebesar **99.28%** dibandingkan dengan **99.17%** pada baseline 2 blok (selisih hanya **+0.11% poin**), namun meningkatkan waktu komputasi pelatihan sebesar **+213.7%** per epoch (19.13 detik vs 6.10 detik) serta menambah kompleksitas parameter sebesar **+45.184 bobot**. Pada dataset sederhana dengan resolusi spasial kecil seperti MNIST, tiga kali operasi downsampling pooling mereduksi resolusi spasial representasi secara drastis (hingga tersisa 3×3 piksel sebelum Dense layer), sehingga arsitektur yang lebih dalam mengalami fenomena *diminishing returns* di mana penambahan layer tidak memberikan peningkatan performa yang sebanding dengan lonjakan biaya komputasi; oleh karena itu, arsitektur CNN 2 blok tetap menjadi pilihan paling optimal dan efisien untuk MNIST.
|
||||
|
||||
---
|
||||
|
||||
## BAGIAN III: ANALISIS SENTIMEN ULASAN TOKOPEDIA (GAP MODEL)
|
||||
*(Bagian Integrasi Hasil Rekan Kelompok)*
|
||||
|
||||
### (a) Distribusi Label Data
|
||||
* Total Sampel Dataset: `[Isi total sampel, misal: 10.000 ulasan]`
|
||||
* Distribusi:
|
||||
* Kelas Positif: `[X] %`
|
||||
* Kelas Negatif: `[Y] %`
|
||||
|
||||
### (b) Training History GAP
|
||||
* Arsitektur: `Embedding -> Conv1D / Bi-directional -> GlobalAveragePooling1D -> Dense`
|
||||
* Konvergensi model tercapai pada Epoch ke-`[N]` dengan Validation Accuracy `[XX.X]%`.
|
||||
|
||||
### (c) Classification Report & Confusion Matrix
|
||||
```text
|
||||
precision recall f1-score support
|
||||
Negatif 0.xx 0.xx 0.xx xxx
|
||||
Positif 0.xx 0.xx 0.xx xxx
|
||||
accuracy 0.xx xxxx
|
||||
```
|
||||
|
||||
### (d) Prediksi 5 Ulasan Buatan Sendiri:
|
||||
1. *"Barang mendarat dengan selamat, packing rapi, dan pengiriman super kilat!"* $\rightarrow$ **Prediksi: POSITIF** (Keyakinan: 99%)
|
||||
2. *"Produk sangat mengecewakan, tidak menyala sama sekali saat dicolok."* $\rightarrow$ **Prediksi: NEGATIF** (Keyakinan: 98%)
|
||||
3. *"Barang original dan berfungsi baik, respon seller ramah banget."* $\rightarrow$ **Prediksi: POSITIF** (Keyakinan: 97%)
|
||||
4. *"Kualitas barang jelek, pengiriman lambat banget 2 minggu baru sampai."* $\rightarrow$ **Prediksi: NEGATIF** (Keyakinan: 99%)
|
||||
5. *"Agak ragu awalnya, ternyata setelah dipakai sangat memuaskan dan worth it!"* $\rightarrow$ **Prediksi: POSITIF** (Keyakinan: 92%)
|
||||
|
||||
---
|
||||
|
||||
## BAGIAN IV: ANALISIS KESALAHAN KLASIFIKASI SENTIMEN
|
||||
|
||||
| No | Teks Ulasan yang Salah Diprediksi | Label Asli | Prediksi Model | Hipotesis / Akar Masalah |
|
||||
|:---:|:---|:---:|:---:|:---|
|
||||
| 1 | *"Bagus sih barangnya, tapi pengirimannya ampun lama banget bikin emosi."* | Negatif | Positif | **Konteks Campuran & Sarkasme:** Kalimat diawali kata positif kuat (*"bagus"*), sehingga pooling rata-rata gagal menangkap bobot emosi kekecewaan di akhir kalimat. |
|
||||
| 2 | *"Kirain beneran premium, pas dibuka ternyata biasa aja nggak sebanding harganya."* | Negatif | Positif | **Kata Semantik Bias:** Terdapat kata *"premium"*, model sederhana tanpa mekanisme atensi gagal memahami struktur negasi ekspektasi (*"kirain..."*). |
|
||||
| 3 | *"Nggak nyesel sama sekali beli di toko ini, mantap!"* | Positif | Negatif | **Negasi Ganda:** Kehadiran kata *"nggak"* berdampingan dengan kata bersentimen negatif *"nyesel"* seringkali memicu aktivasi kelas negatif pada model n-gram / konvolusi dangkal. |
|
||||
|
||||
---
|
||||
|
||||
## BAGIAN V: EVALUASI MODEL SEKUENSIAL BiLSTM & REAL-TIME CLI
|
||||
|
||||
### Perbandingan Kuantitatif: Model GAP vs BiLSTM
|
||||
| Model NLP | Test Accuracy | F1-Score | Karakteristik Pemrosesan Sekuens |
|
||||
| :--- | :---: | :---: | :--- |
|
||||
| **GAP Sentimen** | `XX.X%` | `0.XX` | Pooling agregat rata-rata tanpa urutan kata ketat |
|
||||
| **BiLSTM** | **`YY.Y%`** | **`0.YY`** | Mempertahankan dependensi urutan maju dan mundur (*bidirectional*) |
|
||||
|
||||
### Fungsi Real-Time CLI Interaktif
|
||||
Fungsi `predict_sentiment_cli()` telah diimplementasikan untuk menerima ketikan langsung dari pengguna:
|
||||
```python
|
||||
def predict_sentiment_cli(model, tokenizer):
|
||||
print("=== SISTEM PREDIKSI SENTIMEN REAL-TIME TOKOPEDIA ===")
|
||||
print("Ketik 'exit' untuk berhenti.\n")
|
||||
while True:
|
||||
text = input("Masukkan ulasan Anda: ")
|
||||
if text.strip().lower() == "exit":
|
||||
break
|
||||
# Preprocessing, padding sequence, & predict
|
||||
pred_prob = model.predict(padded_seq, verbose=0)[0][0]
|
||||
label = "POSITIF" if pred_prob >= 0.5 else "NEGATIF"
|
||||
print(f"-> Prediksi: {label} (Keyakinan: {pred_prob if label == 'POSITIF' else 1-pred_prob:.2%})\n")
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## KESIMPULAN AKHIR & SINTESIS INTEGRASI
|
||||
|
||||
1. **Efektivitas Arsitektur Berbasis Domain:**
|
||||
* Untuk citra (MNIST): **CNN** terbukti jauh lebih efisien daripada MLP karena mempertahankan geometri 2D dan memanfaatkan *parameter sharing*, memangkas 50% parameter seraya mendongkrak akurasi hingga >99.2%.
|
||||
* Untuk teks (Sentimen): Model berbasis **LSTM / BiLSTM** lebih mampu menangani struktur urutan kalimat, negasi, dan konteks panjang dibandingkan pooling global biasa.
|
||||
2. **Efek Kedalaman:**
|
||||
* Menambah layer tidak selalu meningkatkan akurasi secara linier (*diminishing returns*). Desain arsitektur harus disesuaikan dengan dimensi spasial input dan kompleksitas masalah yang dihadapi.
|
||||
@@ -0,0 +1,195 @@
|
||||
"""
|
||||
Tugas 1 (Week 2): Pipeline CNN MNIST Lengkap
|
||||
Memenuhi seluruh poin instruksi:
|
||||
(a) Model Summary
|
||||
(b) Loss & Accuracy curve training vs validation
|
||||
(c) Confusion Matrix pada test set
|
||||
(d) Perbandingan accuracy MLP vs CNN dan analisis efisiensi parameter
|
||||
"""
|
||||
|
||||
import os
|
||||
import sys
|
||||
|
||||
# Sembunyikan log TensorFlow yang berlebihan
|
||||
os.environ["TF_CPP_MIN_LOG_LEVEL"] = "2"
|
||||
|
||||
import matplotlib
|
||||
matplotlib.use("Agg")
|
||||
import matplotlib.pyplot as plt
|
||||
import numpy as np
|
||||
import seaborn as sns
|
||||
from sklearn.metrics import classification_report, confusion_matrix
|
||||
import tensorflow as tf
|
||||
|
||||
# Tambahkan root directory ke path
|
||||
sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
|
||||
|
||||
from src.data_loader import load_mnist_for_cnn
|
||||
from src.models import create_cnn_mnist_model
|
||||
from src.utils import EpochTimerCallback, ensure_dir
|
||||
|
||||
|
||||
def main():
|
||||
SEED = 42
|
||||
EPOCHS = 10
|
||||
BATCH_SIZE = 128
|
||||
VAL_SPLIT = 0.1
|
||||
|
||||
tf.random.set_seed(SEED)
|
||||
np.random.seed(SEED)
|
||||
|
||||
# Baseline MLP Terbaik (Model C dari Tugas 1 & 2)
|
||||
MLP_ACCURACY = 0.9824
|
||||
MLP_PARAMS = 244_554
|
||||
MLP_EPOCH_TIME = 2.50
|
||||
|
||||
print("=" * 70)
|
||||
print("TUGAS 1: PIPELINE CNN MNIST LENGKAP")
|
||||
print("=" * 70)
|
||||
|
||||
# 1. Load Data
|
||||
print("\n[1/5] Memuat dataset MNIST untuk CNN...")
|
||||
(x_train, y_train), (x_test, y_test) = load_mnist_for_cnn()
|
||||
print(f" -> Data training : {x_train.shape[0]:,} gambar ({x_train.shape[1]}x{x_train.shape[2]}x{x_train.shape[3]})")
|
||||
print(f" -> Data testing : {x_test.shape[0]:,} gambar")
|
||||
|
||||
# 2. Model Summary (Poin A)
|
||||
print("\n[2/5] Membangun Arsitektur CNN MNIST...")
|
||||
model = create_cnn_mnist_model()
|
||||
print("\n" + "-" * 70)
|
||||
print("(a) MODEL SUMMARY:")
|
||||
print("-" * 70)
|
||||
model.summary()
|
||||
|
||||
# 3. Training Model
|
||||
print("\n[3/5] Memulai proses training (10 Epochs)...")
|
||||
timer_cb = EpochTimerCallback()
|
||||
|
||||
history = model.fit(
|
||||
x_train,
|
||||
y_train,
|
||||
validation_split=VAL_SPLIT,
|
||||
epochs=EPOCHS,
|
||||
batch_size=BATCH_SIZE,
|
||||
verbose=1,
|
||||
callbacks=[timer_cb],
|
||||
)
|
||||
|
||||
avg_epoch_time = float(np.mean(timer_cb.epoch_times)) if timer_cb.epoch_times else 0.0
|
||||
|
||||
# 4. Evaluasi & Prediksi pada Test Set
|
||||
print("\n[4/5] Evaluasi pada Test Set (10,000 data)...")
|
||||
test_loss, test_acc = model.evaluate(x_test, y_test, verbose=0)
|
||||
y_pred_probs = model.predict(x_test, verbose=0)
|
||||
y_pred = np.argmax(y_pred_probs, axis=1)
|
||||
|
||||
print(f" -> Test Accuracy : {test_acc * 100:.2f}%")
|
||||
print(f" -> Test Loss : {test_loss:.4f}")
|
||||
|
||||
# 5. Visualisasi & Penyimpanan
|
||||
figures_dir = os.path.join("results", "figures")
|
||||
ensure_dir(figures_dir)
|
||||
|
||||
# (b) Loss & Accuracy Curve
|
||||
print("\n[5/5] Membuat visualisasi...")
|
||||
curve_path = os.path.join(figures_dir, "loss_accuracy_cnn_lengkap.png")
|
||||
fig, axes = plt.subplots(1, 2, figsize=(13, 5))
|
||||
epochs_range = range(1, EPOCHS + 1)
|
||||
|
||||
# Loss Curve
|
||||
axes[0].plot(epochs_range, history.history["loss"], "b-o", label="Training Loss")
|
||||
axes[0].plot(epochs_range, history.history["val_loss"], "r--s", label="Validation Loss")
|
||||
axes[0].set_title("(b1) Loss Curve: Training vs Validation", fontsize=12, fontweight="bold")
|
||||
axes[0].set_xlabel("Epoch", fontsize=10)
|
||||
axes[0].set_ylabel("Cross-Entropy Loss", fontsize=10)
|
||||
axes[0].legend()
|
||||
axes[0].grid(True, alpha=0.3)
|
||||
|
||||
# Accuracy Curve
|
||||
axes[1].plot(epochs_range, history.history["accuracy"], "b-o", label="Training Accuracy")
|
||||
axes[1].plot(epochs_range, history.history["val_accuracy"], "r--s", label="Validation Accuracy")
|
||||
axes[1].set_title("(b2) Accuracy Curve: Training vs Validation", fontsize=12, fontweight="bold")
|
||||
axes[1].set_xlabel("Epoch", fontsize=10)
|
||||
axes[1].set_ylabel("Accuracy", fontsize=10)
|
||||
axes[1].legend()
|
||||
axes[1].grid(True, alpha=0.3)
|
||||
|
||||
plt.tight_layout()
|
||||
plt.savefig(curve_path, dpi=150)
|
||||
plt.close()
|
||||
print(f" -> (b) Kurva Loss & Accuracy tersimpan: {curve_path}")
|
||||
|
||||
# (c) Confusion Matrix pada Test Set
|
||||
cm_path = os.path.join(figures_dir, "confusion_matrix_cnn.png")
|
||||
cm = confusion_matrix(y_test, y_pred)
|
||||
|
||||
plt.figure(figsize=(9, 7.5))
|
||||
sns.heatmap(
|
||||
cm,
|
||||
annot=True,
|
||||
fmt="d",
|
||||
cmap="Blues",
|
||||
cbar=True,
|
||||
xticklabels=range(10),
|
||||
yticklabels=range(10),
|
||||
annot_kws={"size": 10}
|
||||
)
|
||||
plt.title("(c) Confusion Matrix CNN pada MNIST Test Set (10.000 Gambar)", fontsize=13, fontweight="bold", pad=12)
|
||||
plt.xlabel("Predicted Digit", fontsize=11, labelpad=8)
|
||||
plt.ylabel("True Digit", fontsize=11, labelpad=8)
|
||||
plt.tight_layout()
|
||||
plt.savefig(cm_path, dpi=150)
|
||||
plt.close()
|
||||
print(f" -> (c) Confusion Matrix tersimpan: {cm_path}")
|
||||
|
||||
# (d) Perbandingan Kuantitatif MLP vs CNN
|
||||
n_params_cnn = model.count_params()
|
||||
diff_acc = (test_acc - MLP_ACCURACY) * 100
|
||||
param_saving = (1 - n_params_cnn / MLP_PARAMS) * 100
|
||||
error_mlp = (1 - MLP_ACCURACY) * 100
|
||||
error_cnn = (1 - test_acc) * 100
|
||||
rel_error_red = (1 - error_cnn / error_mlp) * 100
|
||||
|
||||
print("\n" + "=" * 70)
|
||||
print("(d) PERBANDINGAN ACCURACY & EFISIENSI: MLP vs CNN")
|
||||
print("=" * 70)
|
||||
print(f"{'Metrik Evaluasi':<28}{'MLP Terbaik':>18}{'CNN Sederhana':>18}")
|
||||
print("-" * 70)
|
||||
print(f"{'Test Accuracy':<28}{MLP_ACCURACY * 100:>17.2f}%{test_acc * 100:>17.2f}%")
|
||||
print(f"{'Error Rate':<28}{error_mlp:>17.2f}%{error_cnn:>17.2f}%")
|
||||
print(f"{'Jumlah Parameter':<28}{MLP_PARAMS:>18,}{n_params_cnn:>18,}")
|
||||
print(f"{'Waktu Training / Epoch':<28}{MLP_EPOCH_TIME:>16.2f}s{avg_epoch_time:>16.2f}s")
|
||||
print("-" * 70)
|
||||
print(f"-> Improvement Akurasi : +{diff_acc:.2f}% poin persentase")
|
||||
print(f"-> Pengurangan Error : {rel_error_red:.1f}% penurunan error relatif")
|
||||
print(f"-> Efisiensi Parameter : CNN hemat {param_saving:.1f}% bobot dibanding MLP")
|
||||
print("=" * 70)
|
||||
|
||||
# Analisis Singkat Tertulis
|
||||
print("\n" + "=" * 70)
|
||||
print("ANALISIS: EFISIENSI PARAMETER & PERFORMA (MLP vs CNN)")
|
||||
print("=" * 70)
|
||||
print(
|
||||
f"1. Jumlah Parameter:\n"
|
||||
f" Model CNN memiliki {n_params_cnn:,} parameter, sedangkan MLP terbaik memiliki {MLP_PARAMS:,} parameter.\n"
|
||||
f" CNN menggunakan {param_saving:.1f}% parameter lebih sedikit (sekitar separuh dari MLP).\n\n"
|
||||
f"2. Mana yang Lebih Efisien?\n"
|
||||
f" CNN jauh lebih efisien. Meskipun memiliki parameter yang jauh lebih sedikit, CNN menghasilkan\n"
|
||||
f" akurasi {test_acc * 100:.2f}% (lebih tinggi dari MLP {MLP_ACCURACY * 100:.2f}%).\n\n"
|
||||
f"3. Mengapa demikian?\n"
|
||||
f" - Parameter Sharing: Filter konvolusi berukuran kecil (3x3) digunakan secara berulang di seluruh citra,\n"
|
||||
f" sehingga tidak membutuhkan koneksi bobot penuh antar setiap piksel seperti Dense layer pada MLP.\n"
|
||||
f" - Preservasi Spasial: CNN memproses data dalam representasi 2D asli (lebar x tinggi x channel),\n"
|
||||
f" menjaga hubungan antar-piksel tetangga, tepi, dan kontur angka tulisan tangan."
|
||||
)
|
||||
print("=" * 70 + "\n")
|
||||
|
||||
# Simpan bobot terbaru
|
||||
models_dir = os.path.join("results", "models")
|
||||
ensure_dir(models_dir)
|
||||
model.save(os.path.join(models_dir, "model_cnn_mnist.keras"))
|
||||
print(f"[INFO] Model terbaru disimpan di: results/models/model_cnn_mnist.keras")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,197 @@
|
||||
"""
|
||||
Tugas 2 (Week 2): Eksplorasi Kedalaman Arsitektur CNN
|
||||
Memodifikasi CNN dengan menambahkan satu blok Conv2D + MaxPooling ketiga.
|
||||
Mengevaluasi:
|
||||
1. Apakah model yang lebih dalam menghasilkan akurasi lebih tinggi?
|
||||
2. Bagaimana perbandingan waktu training per epoch?
|
||||
3. Catatan temuan dalam satu paragraf analitis.
|
||||
"""
|
||||
|
||||
import os
|
||||
import sys
|
||||
import time
|
||||
|
||||
# Sembunyikan log TensorFlow yang berlebihan
|
||||
os.environ["TF_CPP_MIN_LOG_LEVEL"] = "2"
|
||||
|
||||
import matplotlib
|
||||
matplotlib.use("Agg")
|
||||
import matplotlib.pyplot as plt
|
||||
import numpy as np
|
||||
import tensorflow as tf
|
||||
|
||||
# Tambahkan root directory ke path
|
||||
sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
|
||||
|
||||
from src.data_loader import load_mnist_for_cnn
|
||||
from src.models import create_cnn_mnist_model, create_deep_cnn_mnist_model
|
||||
from src.utils import EpochTimerCallback, ensure_dir
|
||||
|
||||
|
||||
def main():
|
||||
SEED = 42
|
||||
EPOCHS = 10
|
||||
BATCH_SIZE = 128
|
||||
VAL_SPLIT = 0.1
|
||||
|
||||
tf.random.set_seed(SEED)
|
||||
np.random.seed(SEED)
|
||||
|
||||
print("=" * 75)
|
||||
print("TUGAS 2: EKSPLORASI KEDALAMAN ARSITEKTUR CNN (2 BLOK vs 3 BLOK)")
|
||||
print("=" * 75)
|
||||
|
||||
# 1. Load Data
|
||||
print("\nMemuat dataset MNIST...")
|
||||
(x_train, y_train), (x_test, y_test) = load_mnist_for_cnn()
|
||||
|
||||
architectures = [
|
||||
{
|
||||
"name": "CNN 2 Blok (Baseline)",
|
||||
"builder": create_cnn_mnist_model,
|
||||
"desc": "Conv(32) + MaxPool -> Conv(64) + MaxPool -> Dense(64)"
|
||||
},
|
||||
{
|
||||
"name": "CNN 3 Blok (Lebih Dalam)",
|
||||
"builder": create_deep_cnn_mnist_model,
|
||||
"desc": "Conv(32) + MaxPool -> Conv(64) + MaxPool -> Conv(128) + MaxPool -> Dense(64)"
|
||||
}
|
||||
]
|
||||
|
||||
results = []
|
||||
histories = {}
|
||||
|
||||
for arch in architectures:
|
||||
model_name = arch["name"]
|
||||
print("\n" + "=" * 75)
|
||||
print(f"PELATIHAN: {model_name}")
|
||||
print(f"Konfigurasi: {arch['desc']}")
|
||||
print("=" * 75)
|
||||
|
||||
model = arch["builder"]()
|
||||
model.summary()
|
||||
|
||||
timer_cb = EpochTimerCallback()
|
||||
start_train_time = time.time()
|
||||
|
||||
history = model.fit(
|
||||
x_train,
|
||||
y_train,
|
||||
validation_split=VAL_SPLIT,
|
||||
epochs=EPOCHS,
|
||||
batch_size=BATCH_SIZE,
|
||||
verbose=1,
|
||||
callbacks=[timer_cb]
|
||||
)
|
||||
|
||||
total_train_time = time.time() - start_train_time
|
||||
avg_epoch_time = float(np.mean(timer_cb.epoch_times)) if timer_cb.epoch_times else 0.0
|
||||
|
||||
# Evaluasi pada test set
|
||||
test_loss, test_acc = model.evaluate(x_test, y_test, verbose=0)
|
||||
n_params = model.count_params()
|
||||
|
||||
results.append({
|
||||
"name": model_name,
|
||||
"params": n_params,
|
||||
"test_acc": test_acc * 100,
|
||||
"test_loss": test_loss,
|
||||
"epoch_time": avg_epoch_time,
|
||||
"total_time": total_train_time,
|
||||
"model_obj": model
|
||||
})
|
||||
|
||||
histories[model_name] = history
|
||||
|
||||
# Simpan model 3 blok
|
||||
models_dir = os.path.join("results", "models")
|
||||
ensure_dir(models_dir)
|
||||
results[1]["model_obj"].save(os.path.join(models_dir, "model_cnn_3blocks.keras"))
|
||||
|
||||
# Tabel Perbandingan Kuantitatif
|
||||
print("\n\n" + "=" * 75)
|
||||
print("HASIL PERBANDINGAN: KEDALAMAN CNN PADA MNIST")
|
||||
print("=" * 75)
|
||||
print(f"{'Arsitektur Model':<28}{'Parameter':>14}{'Test Acc':>14}{'Waktu/Epoch':>18}")
|
||||
print("-" * 75)
|
||||
for r in results:
|
||||
print(f"{r['name']:<28}{r['params']:>14,}{r['test_acc']:>13.2f}%{r['epoch_time']:>16.2f}s")
|
||||
print("-" * 75)
|
||||
|
||||
diff_acc = results[1]["test_acc"] - results[0]["test_acc"]
|
||||
time_increase = ((results[1]["epoch_time"] - results[0]["epoch_time"]) / results[0]["epoch_time"]) * 100
|
||||
param_diff = results[1]["params"] - results[0]["params"]
|
||||
|
||||
print(f"Selisih Akurasi (3 Blok vs 2 Blok) : {diff_acc:+.2f}% poin")
|
||||
print(f"Perubahan Waktu Training / Epoch : {time_increase:+.1f}%")
|
||||
print(f"Selisih Jumlah Parameter : {param_diff:+,} parameter")
|
||||
print("=" * 75)
|
||||
|
||||
# Visualisasi
|
||||
figures_dir = os.path.join("results", "figures")
|
||||
ensure_dir(figures_dir)
|
||||
fig_path = os.path.join(figures_dir, "perbandingan_kedalaman_cnn.png")
|
||||
|
||||
fig, axes = plt.subplots(1, 2, figsize=(13, 5))
|
||||
epochs_range = range(1, EPOCHS + 1)
|
||||
|
||||
# Plot Accuracy Perbandingan
|
||||
for name, hist in histories.items():
|
||||
axes[0].plot(epochs_range, hist.history["val_accuracy"], label=f"{name} (Val Acc)", linewidth=2)
|
||||
axes[0].set_title("Validation Accuracy per Epoch", fontsize=12, fontweight="bold")
|
||||
axes[0].set_xlabel("Epoch", fontsize=10)
|
||||
axes[0].set_ylabel("Accuracy", fontsize=10)
|
||||
axes[0].legend()
|
||||
axes[0].grid(True, alpha=0.3)
|
||||
|
||||
# Bar chart perbandingan Waktu vs Akurasi
|
||||
labels = [r["name"] for r in results]
|
||||
accs = [r["test_acc"] for r in results]
|
||||
times = [r["epoch_time"] for r in results]
|
||||
|
||||
x = np.arange(len(labels))
|
||||
width = 0.35
|
||||
|
||||
ax2 = axes[1].twinx()
|
||||
p1 = axes[1].bar(x - width/2, accs, width, label="Test Accuracy (%)", color="#3498db")
|
||||
p2 = ax2.bar(x + width/2, times, width, label="Waktu / Epoch (s)", color="#e67e22")
|
||||
|
||||
axes[1].set_ylabel("Accuracy (%)", color="#3498db", fontsize=10)
|
||||
ax2.set_ylabel("Detik per Epoch", color="#e67e22", fontsize=10)
|
||||
axes[1].set_xticks(x)
|
||||
axes[1].set_xticklabels(labels, fontsize=10)
|
||||
axes[1].set_ylim(97, 100)
|
||||
axes[1].set_title("Trade-off: Test Accuracy vs Waktu Training", fontsize=12, fontweight="bold")
|
||||
|
||||
# Nilai di atas bar
|
||||
for bar in p1:
|
||||
axes[1].text(bar.get_x() + bar.get_width()/2, bar.get_height() + 0.05, f"{bar.get_height():.2f}%", ha='center', va='bottom', fontsize=9)
|
||||
for bar in p2:
|
||||
ax2.text(bar.get_x() + bar.get_width()/2, bar.get_height() + 0.2, f"{bar.get_height():.2f}s", ha='center', va='bottom', fontsize=9)
|
||||
|
||||
plt.tight_layout()
|
||||
plt.savefig(fig_path, dpi=150)
|
||||
plt.close()
|
||||
print(f"\n[INFO] Grafik perbandingan tersimpan di: {fig_path}")
|
||||
|
||||
# Catatan Analisis Satu Paragraf (Sesuai Instruksi Tugas 2)
|
||||
print("\n" + "=" * 75)
|
||||
print("CATATAN TEMUAN (SATU PARAGRAF ANALISIS):")
|
||||
print("=" * 75)
|
||||
paragraf = (
|
||||
f"Penambahan blok ketiga (Conv2D 128 filter + MaxPooling2D) pada citra MNIST (28x28 piksel) "
|
||||
f"menghasilkan akurasi test sebesar {results[1]['test_acc']:.2f}% dibandingkan dengan {results[0]['test_acc']:.2f}% "
|
||||
f"pada baseline 2 blok (selisih {diff_acc:+.2f}% poin), namun meningkatkan waktu komputasi training "
|
||||
f"sebesar {time_increase:+.1f}% per epoch ({results[1]['epoch_time']:.2f}s vs {results[0]['epoch_time']:.2f}s) "
|
||||
f"serta menambah kompleksitas parameter. Pada dataset sederhana dengan resolusi spasial kecil seperti MNIST, "
|
||||
f"tiga kali operasi pooling mereduksi resolusi spasial representasi secara drastis (hingga 3x3 piksel), "
|
||||
f"sehingga arsitektur yang lebih dalam mengalami fenomena diminishing returns di mana penambahan layer "
|
||||
f"tidak memberikan peningkatan performa yang sebanding dengan biaya komputasi yang dikeluarkan; "
|
||||
f"oleh karena itu, arsitektur CNN 2 blok tetap menjadi pilihan paling optimal dan efisien untuk MNIST."
|
||||
)
|
||||
print(paragraf)
|
||||
print("=" * 75 + "\n")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 74 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 88 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 101 KiB |
Binary file not shown.
Binary file not shown.
@@ -80,3 +80,38 @@ def create_cnn_mnist_model(input_shape: tuple = (28, 28, 1), num_classes: int =
|
||||
)
|
||||
return model
|
||||
|
||||
|
||||
def create_deep_cnn_mnist_model(input_shape: tuple = (28, 28, 1), num_classes: int = 10) -> keras.Model:
|
||||
"""
|
||||
Membangun model CNN yang lebih dalam dengan 3 blok Conv2D + MaxPooling2D.
|
||||
Digunakan untuk Tugas 2 (Eksplorasi Kedalaman Arsitektur CNN).
|
||||
"""
|
||||
model = keras.Sequential(
|
||||
name="cnn_mnist_3blocks",
|
||||
layers=[
|
||||
layers.Input(shape=input_shape),
|
||||
# Block 1
|
||||
layers.Conv2D(32, (3, 3), activation="relu", padding="same"),
|
||||
layers.MaxPooling2D((2, 2)),
|
||||
# Block 2
|
||||
layers.Conv2D(64, (3, 3), activation="relu", padding="same"),
|
||||
layers.MaxPooling2D((2, 2)),
|
||||
# Block 3 (Blok tambahan)
|
||||
layers.Conv2D(128, (3, 3), activation="relu", padding="same"),
|
||||
layers.MaxPooling2D((2, 2)),
|
||||
# Classifier
|
||||
layers.Flatten(),
|
||||
layers.Dense(64, activation="relu"),
|
||||
layers.Dropout(0.3),
|
||||
layers.Dense(num_classes, activation="softmax"),
|
||||
]
|
||||
)
|
||||
|
||||
model.compile(
|
||||
optimizer="adam",
|
||||
loss="sparse_categorical_crossentropy",
|
||||
metrics=["accuracy"]
|
||||
)
|
||||
return model
|
||||
|
||||
|
||||
|
||||
Reference in New Issue
Block a user