Belajar Deep Learning - Keras 3 & TensorFlow Dasar

#Pendahuluan

Di episode 3 kalian sudah membangun model PyTorch dari scratch dan memahami siklus zero_grad → backward → step. Kali ini kita melihat sisi lain dari ekosistem: Keras 3 dan TensorFlow 2.21, pendekatan yang jauh lebih tinggi level untuk mendefinisikan dan melatih jaringan.

Mengapa mempelajari keduanya? Karena pilihan framework menentukan produktivitas tim. PyTorch memberi kontrol penuh dan cocok untuk riset; Keras mempersingkat boilerplate dan cocok untuk prototyping cepat serta tim yang fokus ke aplikasi. Di akhir episode kalian akan tahu persis kapan memakai yang mana — keputusan yang sering menjadi perdebatan di dunia kerja.

#Apa Itu Keras 3

Keras adalah high-level API untuk jaringan saraf yang ditulis ulang di Keras 3 untuk mendukung multi-backend: kode Keras yang sama bisa dijalankan di atas JAX, TensorFlow, atau PyTorch. Backend dipilih lewat variabel lingkungan KERAS_BACKEND.

export KERAS_BACKEND=tensorflow   # atau jax, pytorch
python -c "import keras; print(keras.backend.backend())"

Filosofinya: tulis model sekali, jalankan di backend mana pun. Ini membuat Keras 3 sangat menarik untuk enterprise yang ingin menghindari lock-in framework.

#Sequential API: Definisi Paling Sederhana

Cara tercepat mendefinisikan model berurutan:

MLP dengan Sequential API

import keras
 
model = keras.Sequential([
    keras.layers.Input(shape=(784,)),
    keras.layers.Dense(128, activation="relu"),
    keras.layers.Dense(10, activation="softmax"),
])
 
model.compile(
    optimizer="adam",
    loss="categorical_crossentropy",
    metrics=["accuracy"],
)
model.summary()

Perhatikan: tidak ada forward eksplisit, tidak ada loop training manual. model.compile menyiapkan optimizer, loss, dan metrik; model.summary() menampilkan arsitektur dan jumlah parameter sekaligus — fitur yang tidak dimiliki PyTorch secara default.

#Functional API: Lebih Fleksibel

Sequential hanya untuk alur lurus. Untuk model dengan input ganda, output ganda, atau shared layer, gunakan Functional API — model dibangun sebagai grafik:

Functional API

inputs = keras.Input(shape=(784,))
x = keras.layers.Dense(128, activation="relu")(inputs)
x = keras.layers.Dropout(0.2)(x)
outputs = keras.layers.Dense(10, activation="softmax")(x)
 
model = keras.Model(inputs=inputs, outputs=outputs)
model.compile(optimizer="adam", loss="categorical_crossentropy", metrics=["accuracy"])

Setiap layer dipanggil seperti fungsi (Dense(...)(x)), dan hasilnya dirangkai menjadi grafik. Ini padanan konseptual dari nn.Module di PyTorch, tetapi lebih ringkas untuk pola yang umum.

#Training Loop: Tingkat Tinggi vs Bawah

#Tingkat Tinggi: model.fit

Training satu baris

history = model.fit(
    x_train, y_train,
    batch_size=32,
    epochs=10,
    validation_split=0.1,
)

Satu panggilan menangani batching, shuffling, progress bar, dan validasi — yang di PyTorch harus kita tulis manual. Untuk prototyping ini sangat nyaman.

#Tingkat Rendah: GradientTape

Saat butuh kontrol penuh (loop custom, model yang tidak cocok dengan fit), TensorFlow menyediakan tf.GradientTape — padanan langsung dari siklus autograd PyTorch:

Training loop manual di TensorFlow

import tensorflow as tf
 
optimizer = tf.keras.optimizers.Adam(learning_rate=1e-3)
loss_fn = tf.keras.losses.CategoricalCrossentropy()
 
with tf.GradientTape() as tape:
    logits = model(x_batch, training=True)
    loss = loss_fn(y_batch, logits)
 
grads = tape.gradient(loss, model.trainable_variables)
optimizer.apply_gradients(zip(grads, model.trainable_variables))

GradientTape merekam operasi, lalu tape.gradient menghitung turunan — persis seperti requires_grad dan loss.backward() di PyTorch, hanya dengan sintaks yang berbeda.

#Komparasi PyTorch vs Keras

#Common Pitfalls

• Mixed API: jangan mencampur operasi Keras dan TensorFlow mentah secara sembarangan dalam satu grafik; pastikan tipe tensor konsisten.
• Data format: Keras secara default memakai channel-last (height, width, channels). Ini berbeda dari kebiasaan beberapa framework lain — detail yang akan sangat terasa saat membangun CNN di episode 7.
• Mengabaikan validation_split: tanpa set validasi, kalian menilai model pada data yang sama dengan yang dipelajari — overfit luput dari deteksi.

#Penutup

Pada episode 4 ini, kalian telah menguasai jalur Keras 3 dan TensorFlow.

Inti yang harus dibawa pulang:

• Keras 3 adalah high-level API multi-backend (JAX/TensorFlow/PyTorch).
• Sequential API untuk model lurus; Functional API untuk grafik yang lebih kompleks.
• model.fit menangani training sekali panggil; GradientTape memberi kontrol penuh.
• PyTorch = fleksibilitas & riset; Keras = produktivitas & enterprise.
• Keras 3 dengan backend PyTorch menggabungkan keunggulan keduanya.

Di episode 5 selanjutnya kita akan memakai semua yang sudah dipelajari untuk membangun MLP untuk klasifikasi & regresi — Fashion-MNIST classification dan tabular regression, lengkap dengan tuning arsitektur, Dropout, dan evaluasi. Sampai jumpa di episode 5!