Deep Learning dengan TensorFlow

📋 Daftar Isi

Pengenalan Deep Learning
TensorFlow: Dasar-dasar
Keras API
Convolutional Neural Network (CNN)
Recurrent Neural Network (RNN)
Training Model yang Efektif
Quiz Pemahaman

1. Pengenalan Deep Learning

Deep Learning adalah sub-bidang dari Machine Learning yang menggunakan artificial neural networks (jaringan saraf tiruan) dengan banyak lapisan (deep) untuk mempelajari pola kompleks dari data. Deep Learning telah merevolusi bidang kecerdasan buatan dan menjadi teknologi di balik pengenalan wajah, mobil otonom, asisten virtual, dan banyak lagi.

Machine Learning vs Deep Learning

Aspek	Machine Learning Tradisional	Deep Learning
Feature Engineering	Manual oleh manusia	Otomatis oleh jaringan
Jumlah Data	Bisa dengan data kecil	Membutuhkan data besar
Hardware	CPU cukup	GPU/TPU diperlukan
Interpretasi	Lebih mudah dijelaskan	Sulit (black box)
Akurasi (data besar)	🟡 Terbatas	🟢 Sangat tinggi
Contoh Algoritma	SVM, Random Forest, KNN	CNN, RNN, Transformer

Anatomi Neural Network

Diagram: Struktur Neural Network

┌─────────────────────────────────────────────────────────────────┐
│                  ARTIFICIAL NEURAL NETWORK                       │
│                                                                  │
│  Input Layer     Hidden Layer 1    Hidden Layer 2    Output Layer│
│                                                                  │
│   ┌─────┐        ┌─────┐          ┌─────┐         ┌─────┐      │
│   │ x₁  │───────→│ h₁₁ │─────────→│ h₂₁ │────────→│ y₁  │      │
│   └─────┘   ┌───→│     │───┐  ┌──→│     │──┐  ┌──→└─────┘      │
│             │    └─────┘   │  │   └─────┘  │  │                  │
│   ┌─────┐   │    ┌─────┐   │  │   ┌─────┐  │  │   ┌─────┐      │
│   │ x₂  │───┼───→│ h₁₂ │───┼──┼──→│ h₂₂ │──┼──┼──→│ y₂  │      │
│   └─────┘   │    │     │   │  │   │     │  │  │   └─────┘      │
│             │    └─────┘   │  │   └─────┘  │  │                  │
│   ┌─────┐   │    ┌─────┐   │  │   ┌─────┐  │  │   ┌─────┐      │
│   │ x₃  │───┴───→│ h₁₃ │───┴──┴──→│ h₂₃ │──┴──┴──→│ y₃  │      │
│   └─────┘        └─────┘          └─────┘         └─────┘      │
│                                                                  │
│  • Setiap neuron memiliki bobot (weight) dan bias               │
│  • Fungsi aktivasi menentukan output neuron                     │
│  • Data mengalir dari input ke output (feedforward)             │
│  • Bobot disesuaikan saat training (backpropagation)            │
└─────────────────────────────────────────────────────────────────┘

Fungsi Aktivasi

Fungsi	Rumus	Penggunaan
ReLU	f(x) = max(0, x)	Hidden layer (paling umum)
Sigmoid	f(x) = 1 / (1 + e⁻ˣ)	Output layer (binary classification)
Softmax	f(xᵢ) = eˣⁱ / Σeˣʲ	Output layer (multi-class classification)
Tanh	f(x) = (eˣ - e⁻ˣ) / (eˣ + e⁻ˣ)	Hidden layer (RNN)
Linear	f(x) = x	Output layer (regression)

💡 Tips

Untuk memulai Deep Learning, pastikan Anda sudah memahami dasar Python, numpy, dan konsep matematika dasar (aljabar linear, kalkulus, dan statistik). Tidak perlu jadi ahli matematika, tapi pemahaman dasar sangat membantu dalam memahami model training.

2. TensorFlow: Dasar-dasar

TensorFlow adalah framework open-source untuk numerical computation dan machine learning yang dikembangkan oleh Google. TensorFlow menyediakan ekosistem lengkap untuk membangun, melatih, dan menerapkan model Deep Learning di berbagai platform.

Instalasi

Bash

# Instal TensorFlow
pip install tensorflow

# Verifikasi instalasi
python -c "import tensorflow as tf; print(tf.__version__)"

# Output: 2.x.x

# Cek apakah GPU tersedia
python -c "import tensorflow as tf; print(tf.config.list_physical_devices('GPU'))"

# Instal untuk Apple Silicon (M1/M2 Mac)
pip install tensorflow-macos tensorflow-metal

Tensor: Data Fundamental

Python — TensorFlow Basics

import tensorflow as tf
import numpy as np

# Tensor adalah array multidimensi — data fundamental di TensorFlow

# Scalar (0D tensor)
scalar = tf.constant(42)
print(scalar)  # tf.Tensor(42, shape=(), dtype=int32)

# Vector (1D tensor)
vector = tf.constant([1, 2, 3, 4, 5])
print(vector)  # tf.Tensor([1 2 3 4 5], shape=(5,), dtype=int32)

# Matrix (2D tensor)
matrix = tf.constant([[1, 2, 3],
                       [4, 5, 6],
                       [7, 8, 9]])
print(matrix.shape)  # (3, 3)

# 3D tensor (misalnya: batch gambar RGB)
tensor_3d = tf.random.normal([32, 28, 28])  # 32 gambar 28x28
print(tensor_3d.shape)  # (32, 28, 28)

# Operasi dasar
a = tf.constant([[1, 2], [3, 4]])
b = tf.constant([[5, 6], [7, 8]])

print(tf.add(a, b))       # Penambahan
print(tf.matmul(a, b))    # Perkalian matriks
print(tf.reduce_sum(a))   # Jumlah semua elemen: 10
print(tf.transpose(a))    # Transpose

Gradient dan Automatic Differentiation

Python — GradientTape

import tensorflow as tf

# GradientTape — fitur kunci untuk training neural network
# Secara otomatis menghitung gradien (turunan) untuk backpropagation

x = tf.Variable(3.0)

with tf.GradientTape() as tape:
    y = x ** 2 + 2 * x + 1  # y = x² + 2x + 1

# dy/dx = 2x + 2 → pada x=3, dy/dx = 8
dy_dx = tape.gradient(y, x)
print(dy_dx)  # tf.Tensor(8.0, shape=(), dtype=float32)

# Gradient untuk multiple variables
w = tf.Variable(tf.random.normal([3, 1]))
b = tf.Variable(tf.zeros([1]))

x_data = tf.constant([[1.0, 2.0, 3.0]])
y_true = tf.constant([[10.0]])

with tf.GradientTape() as tape:
    y_pred = tf.matmul(x_data, w) + b
    loss = tf.reduce_mean((y_pred - y_true) ** 2)

# Hitung gradien terhadap w dan b
gradients = tape.gradient(loss, [w, b])
print("Gradien w:", gradients[0])
print("Gradien b:", gradients[1])

3. Keras API

Keras adalah API tingkat tinggi yang terintegrasi dalam TensorFlow untuk membangun dan melatih neural network. Keras menyediakan antarmuka yang intuitif dan mudah dipahami, menjadikannya pilihan ideal untuk pemula maupun peneliti berpengalaman.

Sequential API

Python — Keras Sequential

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers

# Model Sequential — layer ditambahkan secara berurutan
model = keras.Sequential([
    # Input layer: 784 input features (28x28 pixel gambar)
    layers.Dense(128, activation='relu', input_shape=(784,)),

    # Hidden layer
    layers.Dense(64, activation='relu'),

    # Dropout — mencegah overfitting
    layers.Dropout(0.3),

    # Output layer: 10 kelas (angka 0-9)
    layers.Dense(10, activation='softmax')
])

# Compile model
model.compile(
    optimizer='adam',
    loss='sparse_categorical_crossentropy',
    metrics=['accuracy']
)

# Ringkasan model
model.summary()

# Output:
# Model: "sequential"
# _________________________________________________________________
#  Layer (type)                Output Shape              Param #
# =================================================================
#  dense (Dense)               (None, 128)               100480
#  dense_1 (Dense)             (None, 64)                8256
#  dropout (Dropout)           (None, 64)                0
#  dense_2 (Dense)             (None, 10)                650
# =================================================================
# Total params: 109,386
# Trainable params: 109,386
# Non-trainable params: 0

Functional API

Python — Keras Functional API

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers

# Functional API — lebih fleksibel untuk model kompleks
# Mendukung model dengan multiple input/output dan branching

# Input layer
inputs = keras.Input(shape=(784,))

# Hidden layers
x = layers.Dense(256, activation='relu')(inputs)
x = layers.BatchNormalization()(x)
x = layers.Dropout(0.3)(x)

x = layers.Dense(128, activation='relu')(x)
x = layers.BatchNormalization()(x)
x = layers.Dropout(0.3)(x)

# Output layer
outputs = layers.Dense(10, activation='softmax')(x)

# Buat model
model = keras.Model(inputs=inputs, outputs=outputs, name='mnist_model')

model.compile(
    optimizer=keras.optimizers.Adam(learning_rate=0.001),
    loss='sparse_categorical_crossentropy',
    metrics=['accuracy']
)

model.summary()

Training Model dengan MNIST

Python — Training MNIST

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
import numpy as np

# Load dataset MNIST (gambar tulisan tangan angka 0-9)
(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()

# Preprocessing
# Flatten: 28x28 → 784, normalisasi ke 0-1
x_train = x_train.reshape(-1, 784).astype('float32') / 255.0
x_test = x_test.reshape(-1, 784).astype('float32') / 255.0

print(f"Training data: {x_train.shape}")  # (60000, 784)
print(f"Test data: {x_test.shape}")       # (10000, 784)
print(f"Labels: {np.unique(y_train)}")    # [0 1 2 3 4 5 6 7 8 9]

# Buat model
model = keras.Sequential([
    layers.Dense(256, activation='relu', input_shape=(784,)),
    layers.Dropout(0.3),
    layers.Dense(128, activation='relu'),
    layers.Dropout(0.3),
    layers.Dense(10, activation='softmax'),
])

model.compile(
    optimizer='adam',
    loss='sparse_categorical_crossentropy',
    metrics=['accuracy']
)

# Training
history = model.fit(
    x_train, y_train,
    epochs=20,
    batch_size=128,
    validation_split=0.2,  # 20% data training untuk validasi
    verbose=1
)

# Evaluasi
test_loss, test_acc = model.evaluate(x_test, y_test)
print(f"Test accuracy: {test_acc:.4f}")  # ~0.98 (98%)

# Prediksi
predictions = model.predict(x_test[:5])
predicted_classes = np.argmax(predictions, axis=1)
print(f"Prediksi: {predicted_classes}")
print(f"Aktual:   {y_test[:5]}")

# Simpan model
model.save('mnist_model.h5')

# Load model kembali
loaded_model = keras.models.load_model('mnist_model.h5')

💡 Tips

Gunakan validation_split atau validation_data saat training untuk memantau overfitting. Jika akurasi training terus naik tapi akurasi validasi mulai turun, model Anda mulai overfit. Gunakan Early Stopping untuk menghentikan training otomatis.

4. Convolutional Neural Network (CNN)

CNN (Convolutional Neural Network) adalah jenis neural network yang dirancang khusus untuk memproses data grid seperti gambar. CNN menggunakan operasi convolution untuk mengekstrak fitur-fitur visual seperti tepi, tekstur, dan pola dari gambar.

Komponen CNN

Layer	Fungsi
Conv2D	Memproses gambar dengan filter/kernel untuk mengekstrak fitur
MaxPooling2D	Menurunkan resolusi spatial (downsampling) untuk mengurangi komputasi
BatchNormalization	Menstabilisasi dan mempercepat training
Flatten	Mengubah output 2D menjadi 1D untuk layer Dense
Dense	Fully connected layer untuk klasifikasi akhir
Dropout	Mencegah overfitting dengan menonaktifkan neuron secara acak

Diagram: Arsitektur CNN untuk Klasifikasi Gambar

┌─────────────────────────────────────────────────────────────────┐
│                     CNN ARCHITECTURE                             │
│                                                                  │
│  Input       Conv2D    Pool    Conv2D    Pool   Flatten  Dense  Output│
│  Image       +ReLU           +ReLU                              │
│                                                                  │
│  ┌─────┐    ┌─────┐  ┌───┐  ┌─────┐  ┌───┐                     │
│  │     │    │░░░░░│  │   │  │▒▒▒▒▒│  │   │  ┌─────┐ ┌───┐ ┌──┐│
│  │     │───→│░░░░░│─→│   │─→│▒▒▒▒▒│─→│   │─→│─────│─→│ 10│→│  ││
│  │     │    │░░░░░│  │   │  │▒▒▒▒▒│  │   │  │─────│ │cls│ │  ││
│  │28x28│    │     │  │   │  │     │  │   │  │     │ └───┘ └──┘│
│  └─────┘    └─────┘  └───┘  └─────┘  └───┘  └─────┘           │
│                                                                  │
│  28×28×1   26×26×32 13×13   11×11×64 5×5    1600    128   10   │
│                                                                  │
│  Feature maps bertambah (32 → 64) = lebih banyak fitur          │
│  Ukuran spatial berkurang (28 → 5) = lebih kompak               │
└─────────────────────────────────────────────────────────────────┘

Implementasi CNN

Python — CNN dengan Keras

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
import numpy as np

# Load CIFAR-10 dataset (10 kategori gambar berwarna)
(x_train, y_train), (x_test, y_test) = keras.datasets.cifar10.load_data()

# Normalisasi pixel ke 0-1
x_train = x_train.astype('float32') / 255.0
x_test = x_test.astype('float32') / 255.0

# Label kelas
class_names = ['Pesawat', 'Mobil', 'Burung', 'Kucing', 'Rusa',
               'Anjing', 'Kodok', 'Kuda', 'Kapal', 'Truk']

print(f"Training: {x_train.shape}")  # (50000, 32, 32, 3)
print(f"Test: {x_test.shape}")       # (10000, 32, 32, 3)

# Arsitektur CNN
model = keras.Sequential([
    # Blok Konvolusi 1
    layers.Conv2D(32, (3, 3), activation='relu', padding='same', input_shape=(32, 32, 3)),
    layers.BatchNormalization(),
    layers.Conv2D(32, (3, 3), activation='relu', padding='same'),
    layers.MaxPooling2D((2, 2)),
    layers.Dropout(0.25),

    # Blok Konvolusi 2
    layers.Conv2D(64, (3, 3), activation='relu', padding='same'),
    layers.BatchNormalization(),
    layers.Conv2D(64, (3, 3), activation='relu', padding='same'),
    layers.MaxPooling2D((2, 2)),
    layers.Dropout(0.25),

    # Blok Konvolusi 3
    layers.Conv2D(128, (3, 3), activation='relu', padding='same'),
    layers.BatchNormalization(),
    layers.Conv2D(128, (3, 3), activation='relu', padding='same'),
    layers.MaxPooling2D((2, 2)),
    layers.Dropout(0.25),

    # Klasifikasi
    layers.Flatten(),
    layers.Dense(512, activation='relu'),
    layers.BatchNormalization(),
    layers.Dropout(0.5),
    layers.Dense(10, activation='softmax'),
])

model.compile(
    optimizer='adam',
    loss='sparse_categorical_crossentropy',
    metrics=['accuracy']
)

model.summary()

# Data Augmentation — memperkaya dataset secara virtual
data_augmentation = keras.Sequential([
    layers.RandomFlip("horizontal"),
    layers.RandomRotation(0.1),
    layers.RandomZoom(0.1),
    layers.RandomTranslation(0.1, 0.1),
])

# Training dengan data augmentation
history = model.fit(
    data_augmentation(x_train), y_train,
    epochs=50,
    batch_size=64,
    validation_split=0.2,
    callbacks=[
        keras.callbacks.EarlyStopping(patience=10, restore_best_weights=True),
        keras.callbacks.ReduceLROnPlateau(factor=0.5, patience=5),
    ],
)

# Evaluasi
test_loss, test_acc = model.evaluate(x_test, y_test)
print(f"Test accuracy: {test_acc:.4f}")  # ~0.90+

5. Recurrent Neural Network (RNN)

RNN (Recurrent Neural Network) adalah jenis neural network yang dirancang untuk memproses data berurutan (sequential) seperti teks, time series, audio, dan video. RNN memiliki memori yang memungkinkan informasi dari langkah sebelumnya mempengaruhi langkah berikutnya.

Masalah RNN Klasik

Masalah	Penjelasan	Solusi
Vanishing Gradient	Gradien mengecil saat backpropagation melalui banyak timestep	Gunakan LSTM atau GRU
Exploding Gradient	Gradien membesar secara tidak stabil	Gradient clipping
Short-term Memory	Sulit mengingat informasi jangka panjang	LSTM gates

LSTM (Long Short-Term Memory)

Python — LSTM untuk Time Series

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
import numpy as np

# Contoh: Prediksi time series (suhu harian)

# Generate data dummy (di nyata, gunakan dataset real)
def create_time_series_data(n_samples=1000):
    """Membuat data time series sintetis"""
    time = np.arange(n_samples)
    # Pola: tren + musiman + noise
    series = 0.1 * time + np.sin(0.05 * time) * 10 + np.random.randn(n_samples) * 2
    return series

data = create_time_series_data()

# Buat sequences untuk input LSTM
def create_sequences(data, seq_length=30):
    X, y = [], []
    for i in range(len(data) - seq_length):
        X.append(data[i:i + seq_length])
        y.append(data[i + seq_length])
    return np.array(X), np.array(y)

SEQ_LENGTH = 30
X, y = create_sequences(data, SEQ_LENGTH)

# Split train/test
split = int(len(X) * 0.8)
X_train, X_test = X[:split], X[split:]
y_train, y_test = y[:split], y[split:]

# Reshape untuk LSTM: (samples, timesteps, features)
X_train = X_train.reshape(-1, SEQ_LENGTH, 1)
X_test = X_test.reshape(-1, SEQ_LENGTH, 1)

# Model LSTM
model = keras.Sequential([
    layers.LSTM(64, return_sequences=True, input_shape=(SEQ_LENGTH, 1)),
    layers.Dropout(0.2),
    layers.LSTM(32),
    layers.Dropout(0.2),
    layers.Dense(16, activation='relu'),
    layers.Dense(1)  # Output: prediksi suhu
])

model.compile(
    optimizer='adam',
    loss='mse',
    metrics=['mae']
)

model.summary()

# Training
history = model.fit(
    X_train, y_train,
    epochs=50,
    batch_size=32,
    validation_split=0.2,
    callbacks=[
        keras.callbacks.EarlyStopping(patience=10, restore_best_weights=True),
    ],
)

# Evaluasi
test_loss, test_mae = model.evaluate(X_test, y_test)
print(f"Test MAE: {test_mae:.4f}")

GRU (Gated Recurrent Unit)

Python — GRU Layer

# GRU — alternatif LSTM yang lebih ringan dan cepat
# Memiliki 2 gates (reset, update) dibanding LSTM yang 3 gates

model_gru = keras.Sequential([
    layers.GRU(64, return_sequences=True, input_shape=(SEQ_LENGTH, 1)),
    layers.Dropout(0.2),
    layers.GRU(32),
    layers.Dropout(0.2),
    layers.Dense(1),
])

model_gru.compile(optimizer='adam', loss='mse', metrics=['mae'])

# Bidirectional LSTM — memproses sequence dari dua arah
model_bidi = keras.Sequential([
    layers.Bidirectional(layers.LSTM(64, return_sequences=True), input_shape=(SEQ_LENGTH, 1)),
    layers.Dropout(0.2),
    layers.Bidirectional(layers.LSTM(32)),
    layers.Dropout(0.2),
    layers.Dense(1),
])

model_bidi.compile(optimizer='adam', loss='mse', metrics=['mae'])

⚠️ LSTM vs GRU

LSTM lebih powerful untuk sequence yang sangat panjang dan pola kompleks. GRU lebih cepat dan ringan, cocok untuk dataset kecil atau ketika sumber daya terbatas. Dalam banyak kasus, performa keduanya mirip. Coba keduanya dan bandingkan hasilnya.

6. Training Model yang Efektif

Training neural network memerlukan strategi yang tepat untuk mendapatkan model yang akurat tanpa overfitting. Berikut adalah teknik-teknik penting dalam training Deep Learning.

Callbacks

Python — Callbacks

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import callbacks

# 1. Early Stopping — hentikan training saat validasi tidak membaik
early_stop = callbacks.EarlyStopping(
    monitor='val_loss',
    patience=10,           # Tunggu 10 epoch sebelum berhenti
    restore_best_weights=True,  # Kembalikan bobot terbaik
    verbose=1
)

# 2. Model Checkpoint — simpan model terbaik
checkpoint = callbacks.ModelCheckpoint(
    'best_model.h5',
    monitor='val_accuracy',
    save_best_only=True,
    verbose=1
)

# 3. Reduce Learning Rate — kurangi LR saat plateau
reduce_lr = callbacks.ReduceLROnPlateau(
    monitor='val_loss',
    factor=0.5,       # Kurangi LR setengah
    patience=5,
    min_lr=1e-7,
    verbose=1
)

# 4. TensorBoard — visualisasi training
tensorboard = callbacks.TensorBoard(
    log_dir='./logs',
    histogram_freq=1
)

# Gunakan semua callbacks saat training
history = model.fit(
    X_train, y_train,
    epochs=100,
    batch_size=32,
    validation_split=0.2,
    callbacks=[early_stop, checkpoint, reduce_lr, tensorboard],
)

# Jalankan TensorBoard:
# tensorboard --logdir ./logs

Mencegah Overfitting

Python — Anti-Overfitting

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers, regularizers

# 1. Dropout — menonaktifkan neuron secara acak
model = keras.Sequential([
    layers.Dense(256, activation='relu'),
    layers.Dropout(0.5),    # 50% neuron dinonaktifkan

    layers.Dense(128, activation='relu'),
    layers.Dropout(0.3),    # 30% neuron dinonaktifkan

    layers.Dense(10, activation='softmax'),
])

# 2. L2 Regularization — penalize bobot besar
model_reg = keras.Sequential([
    layers.Dense(256, activation='relu',
                 kernel_regularizer=regularizers.l2(0.01)),
    layers.Dense(128, activation='relu',
                 kernel_regularizer=regularizers.l2(0.01)),
    layers.Dense(10, activation='softmax'),
])

# 3. Batch Normalization — menstabilisasi training
model_bn = keras.Sequential([
    layers.Dense(256),
    layers.BatchNormalization(),
    layers.Activation('relu'),

    layers.Dense(128),
    layers.BatchNormalization(),
    layers.Activation('relu'),

    layers.Dense(10, activation='softmax'),
])

# 4. Data Augmentation (untuk gambar)
data_aug = keras.Sequential([
    layers.RandomFlip("horizontal"),
    layers.RandomRotation(0.2),
    layers.RandomZoom(0.2),
    layers.RandomContrast(0.2),
])

Transfer Learning

Python — Transfer Learning

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers

# Transfer Learning — menggunakan model pre-trained
# Model seperti VGG16, ResNet, EfficientNet sudah dilatih di ImageNet

# Load model pre-trained (tanpa top classification layer)
base_model = keras.applications.EfficientNetB0(
    weights='imagenet',     # Gunakan bobot dari ImageNet
    include_top=False,      # Tanpa layer klasifikasi
    input_shape=(224, 224, 3)
)

# Freeze base model — jangan latih ulang bobot pre-trained
base_model.trainable = False

# Bangun model baru di atas base model
model = keras.Sequential([
    base_model,
    layers.GlobalAveragePooling2D(),
    layers.Dense(256, activation='relu'),
    layers.Dropout(0.3),
    layers.Dense(10, activation='softmax'),  # 10 kelas kita
])

model.compile(
    optimizer='adam',
    loss='sparse_categorical_crossentropy',
    metrics=['accuracy']
)

# Training hanya layer baru
history = model.fit(
    train_dataset,
    epochs=10,
    validation_data=val_dataset,
)

# Fine-tuning — buka beberapa layer terakhir base model
base_model.trainable = True
for layer in base_model.layers[:-20]:
    layer.trainable = False  # Freeze semua kecuali 20 layer terakhir

model.compile(
    optimizer=keras.optimizers.Adam(learning_rate=1e-5),  # LR sangat kecil
    loss='sparse_categorical_crossentropy',
    metrics=['accuracy']
)

# Training ulang dengan fine-tuning
history_fine = model.fit(
    train_dataset,
    epochs=10,
    validation_data=val_dataset,
)

💡 Tips

Transfer Learning adalah teknik paling powerful dalam Deep Learning. Dengan menggunakan model pre-trained, Anda bisa mendapatkan akurasi tinggi dengan data yang sangat sedikit. Gunakan EfficientNet atau ResNet untuk tugas pengenalan gambar, dan BERT/GPT untuk tugas NLP.

7. Quiz: Uji Pemahamanmu!

Setelah membaca tutorial di atas, jawablah 5 pertanyaan berikut untuk menguji pemahamanmu tentang Deep Learning dan TensorFlow:

Pertanyaan 1: Apa fungsi utama dari operasi convolution dalam CNN?

a) Mengurangi ukuran gambar menjadi 1D

b) Mengekstrak fitur-fitur dari gambar seperti tepi dan pola

c) Menambah noise pada gambar

d) Mengubah gambar berwarna menjadi grayscale

Pertanyaan 2: Mengapa LSTM lebih baik dari RNN klasik untuk sequence panjang?

a) LSTM memiliki lebih banyak layer

b) LSTM menggunakan "gates" untuk mengontrol aliran informasi, mengatasi vanishing gradient

c) LSTM tidak memerlukan data training

d) LSTM hanya untuk data gambar

Pertanyaan 3: Apa fungsi dari Dropout dalam neural network?

a) Mempercepat training

b) Menambah layer baru

c) Mencegah overfitting dengan menonaktifkan neuron secara acak

d) Mengubah fungsi aktivasi

Pertanyaan 4: Apa keuntungan utama dari Transfer Learning?

a) Model tidak perlu dilatih sama sekali

b) Bisa mendapatkan akurasi tinggi dengan data sedikit menggunakan model pre-trained

c) Menghapus kebutuhan akan GPU

d) Membuat model berjalan lebih cepat di browser

Pertanyaan 5: Fungsi aktivasi apa yang paling umum digunakan untuk hidden layer?

a) Sigmoid

b) Softmax

c) Linear

d) ReLU

Deep Learning dengan TensorFlow

1. Pengenalan Deep Learning

Machine Learning vs Deep Learning

Anatomi Neural Network

Fungsi Aktivasi

2. TensorFlow: Dasar-dasar

Instalasi

Tensor: Data Fundamental

Gradient dan Automatic Differentiation

3. Keras API

Sequential API

Functional API

Training Model dengan MNIST

4. Convolutional Neural Network (CNN)

Komponen CNN

Implementasi CNN

5. Recurrent Neural Network (RNN)

Masalah RNN Klasik

LSTM (Long Short-Term Memory)

GRU (Gated Recurrent Unit)

6. Training Model yang Efektif

Callbacks

Mencegah Overfitting

Transfer Learning

7. Quiz: Uji Pemahamanmu!

Pertanyaan 1: Apa fungsi utama dari operasi convolution dalam CNN?

Pertanyaan 2: Mengapa LSTM lebih baik dari RNN klasik untuk sequence panjang?

Pertanyaan 3: Apa fungsi dari Dropout dalam neural network?

Pertanyaan 4: Apa keuntungan utama dari Transfer Learning?

Pertanyaan 5: Fungsi aktivasi apa yang paling umum digunakan untuk hidden layer?

📬 Dapatkan Tutorial Terbaru