Optimasi Model Deep Learning untuk Edge Device: Konsep Quantization dan Pruning dengan TensorFlow Lite

Mengapa Model Deep Learning Perlu Dioptimasi Sebelum Masuk ke Edge Device

Edge device seperti Raspberry Pi, smartphone low-end, atau mikrokontroler memiliki keterbatasan memori, compute, dan daya baterai yang tidak dimiliki server cloud. Model deep learning dalam format FP32 biasanya berukuran besar dan membutuhkan komputasi floating-point yang intensif.

Model klasifikasi gambar berukuran 90 MB dengan presisi FP32 tidak feasible untuk dijalankan di perangkat dengan RAM 512 MB. Inference pada CPU edge bisa memakan waktu ratusan milidetik per frame. Konsumsi daya juga meningkat karena operasi floating-point membutuhkan lebih banyak siklus clock.

Optimasi bertujuan menjaga akurasi tetap tinggi sambil menurunkan ukuran model dan latensi inference. Kita mengevaluasi trade-off antara kompresi dan degradasi akurasi. Targetnya adalah model yang ringan, cepat, dan hemat energi tanpa kehilangan kemampuan generalisasi.

Memahami Cara Kerja Quantization untuk Mengurangi Presisi Model

Quantization adalah teknik mapping bobot dan aktivasi dari FP32 ke format presisi lebih rendah seperti INT8 atau FP16. Proses ini mengurangi ukuran model hingga 4x dan mempercepat inference di hardware yang mendukung komputasi integer.

Setiap nilai terkuantisasi direpresentasikan dengan scale dan zero-point. Rumus konversinya adalah real_value = scale * (quantized_value - zero_point). Parameter ini menentukan rentang nilai asli yang dipetakan ke 256 bucket integer.

Kita mengenal dua pendekatan utama. Post-Training Quantization menerapkan konversi setelah training selesai dan cocok untuk iterasi cepat. Quantization-Aware Training mensimulasikan efek quantization selama training sehingga model belajar beradaptasi dengan noise kuantisasi.

Post-Training Quantization lebih mudah diimplementasikan dan tidak memerlukan retraining. Quantization-Aware Training memberikan akurasi lebih baik untuk model sensitif, namun membutuhkan waktu training tambahan. Pilihan tergantung toleransi drop akurasi dan ketersediaan data kalibrasi. Analogi singkatnya, quantization seperti memetakan spektrum warna kontinu ke palet 256 warna diskrit agar file lebih ringan namun tetap dikenali.

Dampak quantization sangat signifikan pada ukuran file dan kecepatan. Model 90 MB dalam FP32 bisa menyusut menjadi sekitar 23 MB dalam INT8. Risiko utama adalah penurunan akurasi jika representative_dataset untuk kalibrasi tidak merepresentasikan distribusi data produksi.

Gambar: Ilustrasi sirkuit dan prosesor hardware yang mendukung komputasi integer INT8 untuk akselerasi model terkuantisasi — Sumber: Unsplash — Lisensi: Unsplash License

!pip install tensorflow

import tensorflow as tf
import numpy as np
import os
import tempfile

# We buat model CNN sederhana untuk klasifikasi gambar 28x28
model = tf.keras.Sequential([
    tf.keras.layers.Input(shape=(28, 28, 1)),
    tf.keras.layers.Conv2D(16, 3, activation='relu'),
    tf.keras.layers.MaxPooling2D(),
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dense(10, activation='softmax')
])

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

# Dummy data untuk demonstrasi konversi
x_train = np.random.rand(100, 28, 28, 1).astype(np.float32)
y_train = np.random.randint(0, 10, 100)
model.fit(x_train, y_train, epochs=1, verbose=0)

# Konversi ke TFLite tanpa optimasi (FP32)
converter_fp32 = tf.lite.TFLiteConverter.from_keras_model(model)
tflite_fp32 = converter_fp32.convert()

# Konversi dengan Post-Training Quantization ke INT8
def representative_dataset():
    for _ in range(100):
        yield [np.random.rand(1, 28, 28, 1).astype(np.float32)]

converter_int8 = tf.lite.TFLiteConverter.from_keras_model(model)
converter_int8.optimizations = [tf.lite.Optimize.DEFAULT]
converter_int8.representative_dataset = representative_dataset
converter_int8.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS_INT8]
converter_int8.inference_input_type = tf.int8
converter_int8.inference_output_type = tf.int8
tflite_int8 = converter_int8.convert()

# Bandingkan ukuran file
with tempfile.NamedTemporaryFile(delete=False, suffix='.tflite') as f:
    f.write(tflite_fp32)
    size_fp32 = os.path.getsize(f.name) / 1024
    print(f"Ukuran model FP32: {size_fp32:.2f} KB")

with tempfile.NamedTemporaryFile(delete=False, suffix='.tflite') as f:
    f.write(tflite_int8)
    size_int8 = os.path.getsize(f.name) / 1024
    print(f"Ukuran model INT8: {size_int8:.2f} KB")
    print(f"Rasio kompresi: {size_fp32/size_int8:.2f}x")

Output:

Ukuran model FP32: 109.39 KB
Ukuran model INT8: 30.66 KB
Rasio kompresi: 3.57x

Kode di atas menunjukkan workflow Post-Training Quantization dengan TFLiteConverter. Kita mendefinisikan representative_dataset untuk kalibrasi scale dan zero-point. Output yang diharapkan adalah perbandingan ukuran file dalam KB dan rasio kompresi sekitar 3x hingga 4x.

Memahami Cara Kerja Pruning untuk Menghilangkan Bobot yang Tidak Penting

Pruning adalah teknik menghapus koneksi atau bobot dengan magnitude kecil yang kontribusinya minimal terhadap prediksi. Tujuan pruning adalah meningkatkan sparsity dan mengurangi jumlah parameter aktif.

Kita mengenal dua jenis pruning. Unstructured pruning menghapus bobot individual secara acak berdasarkan threshold magnitude. Structured pruning menghapus seluruh channel, filter, atau neuron secara terstruktur.

Unstructured pruning menghasilkan kompresi tinggi namun tidak selalu mempercepat inference tanpa hardware yang mendukung sparse computation. Structured pruning lebih ramah hardware karena mengurangi dimensi tensor secara langsung. Pilihan tergantung target deployment dan dukungan akselerator.

Konsep sparsity mengukur persentase bobot yang bernilai nol. Sparsity 70% berarti 70% bobot telah dihapus. Kita biasanya menerapkan gradual pruning schedule selama training. Jadwal ini meningkatkan sparsity secara bertahap dari 30% ke 80% agar model beradaptasi.

Pruning memerlukan fine-tuning setelah pemangkasan untuk memulihkan akurasi. Model yang langsung di-prune tanpa retraining akan mengalami drop signifikan. Keterbatasan penting adalah sparsity tinggi di atas 80% tanpa validasi dapat merusak kapasitas representasi model.

Gambar: Visualisasi prosesor dan perangkat edge yang menjalankan model hasil pruning dengan sparsity tinggi — Sumber: Unsplash — Lisensi: Unsplash License

!pip install tensorflow tensorflow-model-optimization

import tensorflow as tf
import numpy as np
import tensorflow_model_optimization as tfmot

# We siapkan dataset MNIST untuk demonstrasi pruning
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()
x_train = x_train[:1000].reshape(-1, 28, 28, 1).astype(np.float32) / 255.0
x_test = x_test[:200].reshape(-1, 28, 28, 1).astype(np.float32) / 255.0

# Model baseline CNN sederhana
baseline_model = tf.keras.Sequential([
    tf.keras.layers.Conv2D(32, 3, activation='relu', input_shape=(28, 28, 1)),
    tf.keras.layers.MaxPooling2D(),
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dense(64, activation='relu'),
    tf.keras.layers.Dense(10, activation='softmax')
])

baseline_model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
baseline_model.fit(x_train, y_train, epochs=2, verbose=0)
_, acc_before = baseline_model.evaluate(x_test, y_test, verbose=0)
print(f"Akurasi sebelum pruning: {acc_before:.4f}")

# Terapkan magnitude-based pruning dengan gradual sparsity
pruning_params = {
    'pruning_schedule': tfmot.sparsity.keras.PolynomialDecay(
        initial_sparsity=0.30, final_sparsity=0.70,
        begin_step=0, end_step=500)
}

pruned_model = tfmot.sparsity.keras.prune_low_magnitude(baseline_model, **pruning_params)
pruned_model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])

callbacks = [tfmot.sparsity.keras.UpdatePruningStep()]
pruned_model.fit(x_train, y_train, epochs=2, callbacks=callbacks, verbose=0)

# Strip wrapper untuk deployment dan evaluasi sparsity
stripped_model = tfmot.sparsity.keras.strip_pruning(pruned_model)
_, acc_after = stripped_model.evaluate(x_test, y_test, verbose=0)
print(f"Akurasi setelah pruning: {acc_after:.4f}")

# Hitung sparsity per layer
for layer in stripped_model.layers:
    weights = layer.get_weights()
    if weights:
        w = weights[0]
        sparsity = 1.0 - np.count_nonzero(w) / w.size
        print(f"Layer {layer.name}: sparsity {sparsity:.2%}")

Output:

Akurasi sebelum pruning: 0.8650
Akurasi setelah pruning: 0.9100
Layer conv2d: sparsity 0.00%
Layer dense: sparsity 0.00%
Layer dense_1: sparsity 0.00%

Workflow pruning di atas menggunakan tensorflow_model_optimization dengan PolynomialDecay schedule. Kita membungkus model dengan prune_low_magnitude lalu melakukan fine-tuning. Output yang diharapkan adalah laporan sparsity per layer dan perbandingan akurasi sebelum serta sesudah pruning.

Mengimplementasikan Alur Kombinasi Pruning dan Quantization dengan TensorFlow Lite

Workflow end-to-end yang perlu kita ikuti adalah latih baseline, terapkan pruning, lakukan fine-tuning, lalu konversi ke TFLite dengan optimasi quantization. Urutan ini memastikan model sudah sparse sebelum dikuantisasi sehingga kompresi maksimal.

Konfigurasi TFLiteConverter untuk full integer quantization menggunakan optimizations = [tf.lite.Optimize.DEFAULT] dan representative_dataset. Dataset representatif harus mencerminkan distribusi input produksi agar kalibrasi akurat.

Validasi model TFLite dilakukan menggunakan tf.lite.Interpreter. Kita membandingkan output inference model asli dan model terkuantisasi pada sampel yang sama. Perbedaan kecil masih dapat diterima selama dalam batas toleransi.

Pengukuran meliputi pengurangan ukuran file .tflite dan estimasi latency di perangkat edge. Kita mencatat waktu inference rata-rata dalam milidetik dengan melakukan loop prediksi berulang.

!pip install tensorflow

import tensorflow as tf
import numpy as np
import os
import time
import tempfile

# Asumsikan stripped_model dari section sebelumnya sudah tersedia
# Untuk demonstrasi mandiri, We buat model pruned sederhana
model = tf.keras.Sequential([
    tf.keras.layers.Input(shape=(28, 28, 1)),
    tf.keras.layers.Conv2D(16, 3, activation='relu'),
    tf.keras.layers.MaxPooling2D(),
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dense(10, activation='softmax')
])
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy')

# Konversi model pruned ke TFLite dengan quantization
def representative_dataset():
    for _ in range(100):
        yield [np.random.rand(1, 28, 28, 1).astype(np.float32)]

converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
converter.representative_dataset = representative_dataset
converter.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS_INT8]
converter.inference_input_type = tf.int8
converter.inference_output_type = tf.int8
tflite_quant = converter.convert()

# Simpan dan ukur ukuran file
with tempfile.NamedTemporaryFile(delete=False, suffix='.tflite') as f:
    f.write(tflite_quant)
    tflite_path = f.name

size_kb = os.path.getsize(tflite_path) / 1024
print(f"Ukuran file .tflite terkuantisasi: {size_kb:.2f} KB")

# Inference dan benchmark latency dengan Interpreter
interpreter = tf.lite.Interpreter(model_path=tflite_path)
interpreter.allocate_tensors()
input_details = interpreter.get_input_details()
output_details = interpreter.get_output_details()

# Benchmark latency rata-rata
sample_input = np.random.rand(1, 28, 28, 1).astype(np.float32)
# Kuantisasi input sesuai scale dan zero-point
input_scale, input_zero_point = input_details[0]['quantization']
if input_scale != 0:
    sample_input_int8 = (sample_input / input_scale + input_zero_point).astype(np.int8)
else:
    sample_input_int8 = sample_input.astype(np.int8)

latencies = []
for _ in range(50):
    start = time.time()
    interpreter.set_tensor(input_details[0]['index'], sample_input_int8)
    interpreter.invoke()
    output = interpreter.get_tensor(output_details[0]['index'])
    latencies.append((time.time() - start) * 1000)

print(f"Latency rata-rata: {np.mean(latencies):.2f} ms")
print(f"Output shape: {output.shape}, sample output: {output[0][:3]}")

Output:

Ukuran file .tflite terkuantisasi: 30.22 KB
Latency rata-rata: 0.03 ms
Output shape: (1, 10), sample output: [ -92 -110 -114]

Kode ini mengintegrasikan pruning dan quantization dalam satu alur TFLiteConverter. Kita melakukan kalibrasi dengan representative_dataset lalu mengukur ukuran file dan latency melalui Interpreter. Output yang diharapkan adalah ukuran .tflite dalam KB, latency rata-rata dalam ms, dan verifikasi output inference.

Mengevaluasi Hasil Optimasi dan Memilih Strategi yang Tepat untuk Deployment di Edge

Evaluasi optimasi harus memonitor empat metrik utama. Akurasi mengukur degradasi setelah kompresi. Ukuran model menentukan kelayakan penyimpanan di flash memory terbatas. Latency mengukur waktu inference per sampel. Penggunaan memori saat runtime mempengaruhi stabilitas di perangkat dengan RAM kecil.

Panduan pemilihan strategi tergantung kebutuhan. Gunakan Post-Training Quantization jika waktu deployment singkat dan drop akurasi di bawah 2% masih dapat diterima. Pilih Quantization-Aware Training untuk model yang sensitif terhadap presisi seperti deteksi objek kecil. Tambahkan pruning jika ukuran masih terlalu besar setelah quantization atau jika target adalah kompresi di atas 4x.

Best practices yang perlu kita terapkan meliputi beberapa hal. Gunakan dataset kalibrasi yang representatif dan mencakup variasi input produksi. Hindari sparsity di atas 80% tanpa validasi menyeluruh karena risiko collapse akurasi. Selalu benchmark di target device, bukan hanya di laptop development.

We mengukur quantization error dengan membandingkan output FP32 dan INT8 pada sampel yang sama menggunakan metrik MSE atau cosine similarity. Nilai error kecil menandakan kalibrasi berhasil. Ukuran calibration dataset memengaruhi kualitas kalibrasi. Rentang 100 hingga 500 sampel representatif biasanya cukup. Dataset terlalu kecil menyebabkan bias kalibrasi dan meningkatkan error. Dataset representatif membantu menjaga accuracy drop di bawah 1 hingga 2 persen sambil memperoleh gain latensi yang signifikan.

Tools monitoring yang tersedia adalah TensorFlow Lite Benchmark Tool untuk mengukur latency dan memori di perangkat edge. Tool ini dijalankan via benchmark_model --graph=model.tflite --num_runs=100 untuk mendapatkan statistik performa.

Kesalahan umum adalah mengoptimasi tanpa mengukur baseline terlebih dahulu. Tanpa baseline akurasi, ukuran, dan latency, kita tidak dapat menilai apakah optimasi memberikan nilai tambah atau justru merusak performa.

Ingin membawa model deep learning ke production di edge device dengan percaya diri? Program bootcamp Deep Learning dan kelas Edge AI di Rumah Coding membahas workflow optimasi end-to-end secara hands-on. We belajar dari setup TensorFlow Lite sampai deployment di perangkat nyata.