Transfer Learning dengan TensorFlow: Fine-tune Pre-trained Model untuk Klasifikasi Gambar

Mengenal Konsep Transfer Learning dalam Deep Learning

Transfer learning adalah teknik yang memanfaatkan pengetahuan dari model yang telah dilatih sebelumnya (pre-trained model) untuk tugas baru yang berbeda tetapi terkait. Alih-alih membangun model dari nol, kita menggunakan bobot (weights) dari model yang sudah dilatih pada dataset besar seperti ImageNet. Pendekatan ini menghemat waktu training dan resource komputasi secara signifikan.

Dalam konteks klasifikasi gambar, pre-trained model seperti MobileNetV2 atau ResNet50 sudah mempelajari representasi fitur visual yang kaya dari jutaan gambar. Lapisan awal model tersebut mendeteksi edges dan textures, sementara lapisan yang lebih dalam mengenali shapes dan objects. Pengetahuan hierarkis ini dapat kita transfer ke dataset baru dengan sedikit modifikasi. Teknik ini sangat efektif ketika dataset target terbatas atau komputasi tidak memadai untuk training dari nol.

Mengapa Fine-Tune Pre-trained Model Lebih Efisien

Training model deep learning dari awal membutuhkan dataset besar dan komputasi yang intensif. Transfer learning mengatasi dua masalah utama ini. Pertama, kita tidak perlu dataset berukuran jutaan gambar untuk mendapatkan performa yang baik. Kedua, waktu training berkurang drastis karena sebagian besar parameter sudah terlatih dengan baik.

Proses fine-tune memungkinkan kita untuk menyesuaikan pre-trained model dengan karakteristik data spesifik. Kita dapat membekukan (freeze) lapisan dasar untuk menjaga fitur umum, kemudian melatih ulang lapisan atas atau menambahkan custom layers. Strategi ini memberikan akurasi tinggi bahkan pada dataset dengan ratusan gambar saja. Model yang dihasilkan juga lebih stabil dan tidak mudah overfitting dibandingkan training dari nol pada data terbatas.

Memilih Arsitektur Pre-trained Model yang Tepat

TensorFlow menyediakan berbagai pre-trained model melalui modul tf.keras.applications. Pemilihan arsitektur bergantung pada trade-off antara akurasi dan efisiensi.

MobileNetV2 cocok untuk deployment di mobile dan edge devices karena ukuran model yang ringan. ResNet50 menawarkan keseimbangan antara kedalaman model dan performa. EfficientNetB0 memberikan akurasi tinggi dengan parameter yang lebih sedikit dibandingkan arsitektur konvensional.

Untuk tutorial ini, kita akan menggunakan MobileNetV2 karena kecepatan training-nya yang optimal untuk demonstration dan kompatibilitasnya dengan berbagai platform deployment. Model ini telah dilatih pada ImageNet dengan 1000 kelas dan dapat kita adaptasi untuk klasifikasi biner atau multi-class.

Mempersiapkan Dataset Gambar untuk Training

Kita akan menggunakan tf.keras.utils.image_dataset_from_directory untuk memuat dataset dari folder. Fungsi ini secara otomatis membagi data menjadi batch dan menerapkan label berdasarkan struktur direktori.

!pip install tensorflow matplotlib

import tensorflow as tf
from tensorflow.keras import layers, models
import matplotlib.pyplot as plt

# Set random seed untuk reproducibility
tf.random.set_seed(42)

# Load dataset dari direktori
train_ds = tf.keras.utils.image_dataset_from_directory(
    'path/to/dataset',
    validation_split=0.2,
    subset='training',
    seed=42,
    image_size=(160, 160),
    batch_size=32
)

val_ds = tf.keras.utils.image_dataset_from_directory(
    'path/to/dataset',
    validation_split=0.2,
    subset='validation',
    seed=42,
    image_size=(160, 160),
    batch_size=32
)

# Normalisasi pixel values ke rentang [0, 1]
normalization_layer = layers.Rescaling(1./255)
train_ds = train_ds.map(lambda x, y: (normalization_layer(x), y))
val_ds = val_ds.map(lambda x, y: (normalization_layer(x), y))

# Prefetch untuk optimasi pipeline
AUTOTUNE = tf.data.AUTOTUNE
train_ds = train_ds.cache().prefetch(buffer_size=AUTOTUNE)
val_ds = val_ds.cache().prefetch(buffer_size=AUTOTUNE)

print(f"Jumlah kelas: {len(train_ds.class_names)}")
print(f"Class names: {train_ds.class_names}")

Pipeline data ini memastikan input memiliki ukuran konsisten dan normalisasi yang sesuai dengan ekspektasi pre-trained model. Parameter cache() menyimpan data di memory setelah epoch pertama untuk mempercepat training berikutnya.

Membangun Model dengan Base Pre-trained dan Custom Layers

Langkah pertama adalah memuat MobileNetV2 tanpa lapisan klasifikasi teratas. Kita menggunakan weights dari ImageNet dan menetapkan input shape sesuai dengan dataset. Base model kemudian dibekukan agar tidak ikut terupdate selama initial training.

# Load pre-trained MobileNetV2
base_model = tf.keras.applications.MobileNetV2(
    input_shape=(160, 160, 3),
    include_top=False,
    weights='imagenet'
)

# Bekukan base model
base_model.trainable = False

# Bangun model lengkap dengan custom layers
model = models.Sequential([
    base_model,
    layers.GlobalAveragePooling2D(),
    layers.Dropout(0.2),
    layers.Dense(128, activation='relu'),
    layers.Dense(len(train_ds.class_names), activation='softmax')
])

# Compile model
model.compile(
    optimizer=tf.keras.optimizers.Adam(learning_rate=0.0001),
    loss='sparse_categorical_crossentropy',
    metrics=['accuracy']
)

# Summary arsitektur
model.summary()

Custom layers terdiri dari Global Average Pooling untuk mereduksi dimensionalitas output convolutional, dropout untuk regularisasi, dan dense layers untuk klasifikasi. Learning rate yang rendah (0.0001) penting agar training tidak merusak weights yang sudah terlatih.

Melakukan Training pada Custom Layers

Pada fase ini, hanya weights dari dense layers yang diupdate karena base_model telah dibekukan. Fase ini disebut feature extraction karena kita memanfaatkan representasi fitur dari MobileNetV2.

# Training fase 1: Feature extraction
history = model.fit(
    train_ds,
    validation_data=val_ds,
    epochs=10
)

# Visualisasi hasil training
acc = history.history['accuracy']
val_acc = history.history['val_accuracy']
loss = history.history['loss']
val_loss = history.history['val_loss']

plt.figure(figsize=(12, 4))
plt.subplot(1, 2, 1)
plt.plot(acc, label='Training Accuracy')
plt.plot(val_acc, label='Validation Accuracy')
plt.legend()
plt.title('Accuracy')

plt.subplot(1, 2, 2)
plt.plot(loss, label='Training Loss')
plt.plot(val_loss, label='Validation Loss')
plt.legend()
plt.title('Loss')
plt.show()

Training ini biasanya konvergen cepat karena beban parameter yang dilatih relatif sedikit. Validation accuracy memberikan indikasi apakah representasi fitur dari pre-trained model cocok untuk dataset baru.

Melakukan Fine-Tune pada Lapisan Atas Base Model

Setelah custom layers terlatih dengan baik, kita dapat melanjutkan ke fase fine-tune. Proses ini membuka sebagian lapisan base model untuk training dengan learning rate yang sangat kecil.

# Unfreeze base model
base_model.trainable = True

# Bekukan semua layer kecuali 20 layer teratas
for layer in base_model.layers[:-20]:
    layer.trainable = False

# Recompile dengan learning rate lebih kecil
model.compile(
    optimizer=tf.keras.optimizers.Adam(learning_rate=0.00001),
    loss='sparse_categorical_crossentropy',
    metrics=['accuracy']
)

# Training fase 2: Fine-tune
fine_tune_epochs = 10
total_epochs = 10 + fine_tune_epochs

history_fine = model.fit(
    train_ds,
    validation_data=val_ds,
    epochs=total_epochs,
    initial_epoch=history.epoch[-1]
)

# Evaluasi akhir
final_loss, final_acc = model.evaluate(val_ds)
print(f"Final validation accuracy: {final_acc:.4f}")

Fine-tune lapisan atas memungkinkan model untuk menyesuaikan fitur spesifik dengan domain data baru. Learning rate yang sangat kecil (1e-5) mencegah catastrophic forgetting, yaitu penghapusan pengetahuan yang sudah dipelajari sebelumnya.

Strategi Mengoptimalkan Hasil Transfer Learning

Beberapa praktik penting dapat meningkatkan performa model. Pertama, gunakan data augmentation seperti random flip dan rotation untuk meningkatkan generalisasi. Kedua, eksperimen dengan jumlah layer yang di-unfreeze. Terlalu banyak layer dapat menyebabkan overfitting pada dataset kecil.

Ketiga, monitoring validation loss dengan EarlyStopping untuk menghentikan training sebelum overfitting terjadi. Callback ini secara otomatis menyimpan weights terbaik berdasarkan validation metric.

# Callback untuk early stopping
early_stop = tf.keras.callbacks.EarlyStopping(
    monitor='val_loss',
    patience=3,
    restore_best_weights=True
)

# Data augmentation layer
data_augmentation = tf.keras.Sequential([
    layers.RandomFlip('horizontal'),
    layers.RandomRotation(0.2),
    layers.RandomZoom(0.1)
])

Augmentation harus diterapkan hanya pada training data, bukan validation data. Callback EarlyStopping dengan restore_best_weights=True memastikan model kembali ke state dengan validation loss terendah. Penggunaan callback ini sangat direkomendasikan untuk menjaga stabilitas training pada dataset berukuran kecil.

Kesimpulan

Transfer learning dengan TensorFlow adalah pendekatan yang powerful untuk klasifikasi gambar. Kita memanfaatkan pengetahuan dari model yang telah dilatih pada dataset besar, kemudian menyesuaikannya dengan tugas spesifik melalui fine-tune. Proses ini mengurangi waktu training, menghemat resource, dan menghasilkan akurasi yang kompetitif bahkan pada dataset berukuran kecil.

Pemahaman mendalam tentang kapan membekukan layer, kapan melakukan fine-tune, dan bagaimana mengatur learning rate adalah kunci keberhasilan implementasi. Teknik ini merupakan fondasi bagi banyak aplikasi computer vision modern.

Siap menguasai computer vision dan deep learning secara praktis? Di Rumah Coding, kami menyediakan kurikulum Machine Learning Bootcamp yang mencakup transfer learning, object detection, dan model deployment. Bergabunglah dengan komunitas kami untuk belajar langsung dari mentor berpengalaman.