TensorFlow, Keras, dan TensorBoard untuk Pemantauan Model

TensorFlow, dikembangkan oleh Google Brain dan dirilis pada 2015, bukan sekadar library deep learning — ia adalah ekosistem lengkap untuk membangun, melatih, men-deploy, dan memantau model machine learning pada skala apa pun. Meski PyTorch mendominasi riset, TensorFlow tetap menjadi kekuatan utama produksi, di-deploy dalam sistem yang memproses miliaran prediksi setiap hari di Google, Airbnb, Twitter, dan ribuan perusahaan lainnya.

Ekosistemnya membentang di seluruh lifecycle ML:

• Keras — API level tinggi untuk membangun dan melatih model, kini terintegrasi penuh ke dalam TensorFlow sebagai tf.keras
• TensorBoard — Toolkit visualisasi untuk memantau training, membandingkan eksperimen, dan men-debug model
• tf.data — Pipeline data berperforma tinggi untuk memasok dataset besar ke model
• TensorFlow Serving — Model serving level produksi dengan versioning, batching, dan akselerasi hardware
• TensorFlow Lite — Runtime yang dioptimalkan untuk perangkat mobile dan edge
• TensorFlow.js — Jalankan model langsung di browser

Keluasan ini adalah kekuatan terbesar TensorFlow. Kamu bisa membuat prototipe model di Jupyter notebook dengan Keras, melatihnya di cluster GPU, memantau training dengan TensorBoard, meng-serve-nya dengan TF Serving di belakang sebuah API, dan men-deploy versi terkompresi ke Raspberry Pi — semuanya dalam framework yang sama. Untuk aplikasi finansial di mana kamu mungkin membutuhkan model yang berjalan baik di cloud trading engine (terhubung ke API GaiaEx) maupun di workstation lokal untuk riset, fleksibilitas ini penting.

Keras didesain dengan satu prinsip utama: mengurangi beban kognitif dalam membangun neural network. Ia mencapai ini lewat dua API pembangunan model, masing-masing sesuai untuk level kompleksitas yang berbeda.

Sequential API adalah yang paling sederhana — sebuah stack layer yang linear:

import tensorflow as tf
from tensorflow import keras

model = keras.Sequential([
    keras.layers.Dense(128, activation="relu", input_shape=(20,)),
    keras.layers.Dropout(0.3),
    keras.layers.Dense(64, activation="relu"),
    keras.layers.Dropout(0.2),
    keras.layers.Dense(1, activation="sigmoid"),
])

Untuk model dengan multiple input, multiple output, layer bersama, atau skip connection, Functional API memberimu kontrol penuh di level graph:

price_input = keras.Input(shape=(60, 5), name="price_sequence")
meta_input = keras.Input(shape=(10,), name="metadata")

x = keras.layers.LSTM(64, return_sequences=True)(price_input)
x = keras.layers.LSTM(32)(x)

combined = keras.layers.concatenate([x, meta_input])
combined = keras.layers.Dense(64, activation="relu")(combined)
output = keras.layers.Dense(1, activation="sigmoid")(combined)

model = keras.Model(inputs=[price_input, meta_input],
                    outputs=output)

Model ini menerima dua input — sebuah urutan harga 60-langkah yang diproses oleh LSTM bertingkat, dan sebuah vektor metadata berisi fitur statis — mengombinasikannya, dan menghasilkan prediksi arah. Arsitektur ini umum dalam ML finansial di mana kamu ingin memadukan pola temporal (aksi harga terbaru) dengan informasi kontekstual (rezim volatilitas, funding rate, hari dalam seminggu).

Jenis layer kunci untuk aplikasi finansial: Dense untuk fitur tabular, LSTM dan GRU untuk time series, Conv1D untuk mempelajari pola temporal lokal, dan MultiHeadAttention untuk pemodelan sekuens bergaya transformer.

Setelah dibangun, model Keras harus di-compile dengan tiga komponen: sebuah optimizer, sebuah loss function, dan metrik evaluasi.

model.compile(
    optimizer=keras.optimizers.Adam(learning_rate=1e-3),
    loss="binary_crossentropy",
    metrics=["accuracy", keras.metrics.AUC(name="auc")],
)

history = model.fit(
    X_train, y_train,
    epochs=100,
    batch_size=64,
    validation_data=(X_val, y_val),
    callbacks=[...],
)

Callback adalah hook yang dieksekusi pada titik-titik tertentu selama training — setelah setiap epoch, batch, atau ketika kondisi tertentu terpenuhi. Mereka mengotomatisasi manajemen training yang jika tidak akan memerlukan pemantauan manual:

• EarlyStopping — Menghentikan training ketika validation loss berhenti membaik selama patience epoch. Mencegah overfitting dan pemborosan komputasi. Tetapkan restore_best_weights=True agar otomatis kembali ke checkpoint terbaik.
• ModelCheckpoint — Menyimpan model setiap kali performa validasi membaik. Kamu tidak akan pernah kehilangan model terbaikmu akibat training crash atau overfitting di epoch selanjutnya.
• ReduceLROnPlateau — Mengurangi learning rate ketika validation loss mendatar. Ini sering membuka performa tambahan yang terlewat oleh learning rate tetap — model mengambil langkah besar pada awalnya, lalu melakukan fine-tuning dengan langkah yang lebih kecil.

callbacks = [
    keras.callbacks.EarlyStopping(
        monitor="val_loss", patience=15,
        restore_best_weights=True),
    keras.callbacks.ModelCheckpoint(
        "best_model.keras", monitor="val_auc",
        mode="max", save_best_only=True),
    keras.callbacks.ReduceLROnPlateau(
        monitor="val_loss", factor=0.5,
        patience=5, min_lr=1e-6),
    keras.callbacks.TensorBoard(log_dir="./logs"),
]

TensorBoard adalah toolkit visualisasi TensorFlow, dan ia adalah salah satu alat paling berharga dalam workflow praktisi ML mana pun — baik kamu memakai TensorFlow, PyTorch, atau JAX. Ia mengubah log training mentah menjadi dashboard interaktif yang mengungkap apa yang terjadi di dalam modelmu.

Jalankan TensorBoard dengan mengarahkannya ke direktori log-mu:

# Terminal
tensorboard --logdir=./logs --port=6006

# Atau di Jupyter notebook
%load_ext tensorboard
%tensorboard --logdir ./logs

Visualisasi kunci untuk pengembangan model finansial:

Scalars — Kurva loss training dan validasi yang diplot seiring waktu. Kesenjangan antara keduanya mengungkap overfitting: training loss yang terus menurun sementara validation loss meningkat berarti modelmu menghafal noise. Training yang sehat menunjukkan kedua kurva menurun bersama-sama, dengan kurva validasi sedikit di atas training.

Histograms — Distribusi weight, bias, dan aktivasi di seluruh layer dan epoch. Perhatikan distribusi weight yang runtuh ke nol (vanishing gradients), meledak ke nilai besar (training tidak stabil), atau aktivasi yang jenuh di 0 atau 1 (dead neuron). Masalah-masalah ini tidak terlihat di kurva loss tapi jelas di histogram.

Embeddings — Memproyeksikan representasi berdimensi tinggi ke ruang 2D atau 3D memakai t-SNE atau PCA. Visualisasikan apakah modelmu telah mempelajari cara memisahkan rezim pasar, kelas aset, atau kondisi volatilitas yang berbeda dalam representasi internalnya.

HParams — Membandingkan sweep hyperparameter di berbagai eksperimen. Jalankan model yang sama dengan learning rate, arsitektur, dan nilai dropout yang berbeda, lalu identifikasi kombinasi mana yang menghasilkan metrik validasi terbaik. Perbandingan sistematis ini menggantikan eksperimen ad hoc dengan pemilihan model berbasis bukti.

TensorBoard juga bekerja dengan PyTorch lewat class torch.utils.tensorboard.SummaryWriter — alat visualisasinya bersifat agnostik terhadap framework, yang menjadi salah satu alasan TensorBoard menjadi standar de facto di seluruh ekosistem ML.

Ketika dataset-mu terlalu besar untuk masuk ke memori — situasi umum saat bekerja dengan data tick-level dari exchange seperti GaiaEx — tf.data menyediakan pipeline data yang efisien dan terparalelkan yang terus memasok GPU-mu tanpa memuat semuanya sekaligus.

dataset = tf.data.Dataset.from_tensor_slices((features, labels))
dataset = (dataset
    .window(60, shift=1, drop_remainder=True)
    .flat_map(lambda w: w.batch(60))
    .batch(64)
    .prefetch(tf.data.AUTOTUNE)
)

Panggilan prefetch(AUTOTUNE) sangat penting — ia memungkinkan pemuatan data dan komputasi model tumpang tindih, sehingga GPU tidak pernah menganggur menunggu batch selanjutnya. Untuk dataset finansial dengan feature engineering yang kompleks, kamu bisa merangkai transformasi .map() yang berjalan secara paralel, menghitung indikator dan normalisasi secara on-the-fly, bukan menghitung dan menyimpannya lebih dulu.

TensorFlow Serving adalah sistem level produksi untuk men-deploy model di belakang API gRPC atau REST berperforma tinggi. Ia menangani versioning model (meng-serve model baru sambil menyimpan yang lama sebagai fallback), batching request (menggabungkan beberapa request inferensi demi efisiensi GPU), dan akselerasi hardware — semuanya kritis untuk sistem trading di mana latensi dan reliabilitas sama-sama penting.

# Export sebuah SavedModel
model.save("models/price_predictor/1")

# Serve dengan Docker
# docker run -p 8501:8501 \
#   --mount type=bind,source=$(pwd)/models,target=/models \
#   -e MODEL_NAME=price_predictor \
#   tensorflow/serving

Arsitektur produksi yang tipikal: bot trading-mu terhubung ke feed WebSocket GaiaEx, menghitung fitur secara real time, mengirim request inferensi ke TF Serving, dan menerima prediksi dalam milidetik satu digit. Ketika kamu melatih ulang dengan data baru, deploy model yang diperbarui sebagai versi 2 — TF Serving menukarnya dengan zero downtime.

TensorFlow Lite mengompresi model untuk deployment di perangkat mobile, sistem embedded, dan hardware edge. Melalui teknik seperti quantization (mengubah weight floating-point 32-bit menjadi integer 8-bit), pruning (menghapus weight yang mendekati nol), dan optimisasi arsitektur, TF Lite bisa mengecilkan model hingga 4x atau lebih sambil tetap menjaga sebagian besar akurasinya. Ini memungkinkan menjalankan inferensi langsung di perangkat dengan komputasi terbatas — berguna untuk node trading edge atau dashboard pemantauan yang harus beroperasi independen dari infrastruktur cloud.

# Konversi model Keras ke TF Lite
converter = tf.lite.TFLiteConverter.from_saved_model("models/v1")
converter.optimizations = [tf.lite.Optimize.DEFAULT]
tflite_model = converter.convert()

with open("model.tflite", "wb") as f:
    f.write(tflite_model)

TensorFlow vs PyTorch — mana yang harus kamu pilih untuk aplikasi finansial?

• Untuk riset dan prototyping: PyTorch. Graph dinamisnya, API yang Pythonic, dan posisi dominannya dalam riset akademik berarti lebih banyak paper yang menyertakan kode PyTorch, lebih banyak tutorial memakai PyTorch, dan debugging lebih intuitif.
• Untuk deployment produksi berskala besar: TensorFlow masih memiliki keunggulan. TF Serving, TF Lite, dan TensorFlow.js menyediakan jalur deployment yang sudah teruji, yang masih terus disempurnakan oleh TorchServe dan ONNX Runtime milik PyTorch.
• Khusus untuk ML finansial: Mulai dengan PyTorch untuk pengembangan dan eksperimen model. Jika kebutuhan produksimu menuntut kematangan TF Serving atau deployment edge TF Lite, konversikan model terbaikmu. Banyak tim memakai PyTorch untuk riset dan TensorFlow untuk deployment, menjembatani keduanya lewat format ONNX (Open Neural Network Exchange).

Kebenaran yang jujur: kedua framework ini mengalami konvergensi. TensorFlow mengadopsi eager execution; PyTorch menambahkan torch.compile untuk optimisasi level graph. Keras sendiri kini mendukung PyTorch, JAX, dan TensorFlow sebagai backend. Framework terbaik adalah yang dikuasai timmu dengan baik dan bisa dipakai untuk mengirim kode produksi. Pilih satu, kuasai, dan selesaikan masalah sesungguhnya — memprediksi pasar — bukannya berdebat soal alat.