Model İzleme İçin TensorFlow, Keras ve TensorBoard

Google Brain tarafından geliştirilen ve 2015'te yayınlanan TensorFlow, sadece bir derin öğrenme kütüphanesi değildir — her ölçekte makine öğrenmesi modelleri inşa etmek, eğitmek, dağıtmak ve izlemek için eksiksiz bir ekosistemdir. PyTorch araştırmaya hakim olsa da, TensorFlow üretim güç merkezi olarak kalır ve Google, Airbnb, Twitter ve binlerce başka şirkette günlük milyarlarca tahmin işleyen sistemlerde konuşlandırılır.

Ekosistem, ML yaşam döngüsünün tamamına yayılır:

• Keras — Model inşa etmek ve eğitmek için yüksek seviyeli API, artık TensorFlow'a tf.keras olarak tam entegre edilmiştir
• TensorBoard — Eğitimi izlemek, deneyleri karşılaştırmak ve modelleri hata ayıklamak için görselleştirme araç seti
• tf.data — Modellere büyük veri kümeleri beslemek için yüksek performanslı veri boru hatları
• TensorFlow Serving — Sürüm oluşturma, gruplama ve donanım hızlandırma ile üretim seviyesinde model sunumu
• TensorFlow Lite — Mobil ve edge cihazlar için optimize edilmiş çalışma zamanı
• TensorFlow.js — Modelleri doğrudan tarayıcıda çalıştır

Bu genişlik, TensorFlow'un en büyük gücüdür. Keras ile bir Jupyter notebook'unda bir modeli prototiple yapabilir, bir GPU kümesinde eğitebilir, TensorBoard ile eğitimi izleyebilir, bir API'nin ardında TF Serving ile sunabilir ve sıkıştırılmış bir sürümü bir Raspberry Pi'ye dağıtabilirsin — hepsi aynı çerçeve içinde. Hem bulut tabanlı bir işlem motorunda (GaiaEx'in API'sine bağlı) hem de araştırma için yerel bir iş istasyonunda çalışan modellere ihtiyacın olabilecek finansal uygulamalar için bu esneklik önemlidir.

Keras, sinir ağları inşa etmenin bilişsel yükünü azaltmak amacıyla tek bir yol gösterici ilkeyle tasarlandı. Bunu, her biri farklı karmaşıklık seviyelerine uygun iki model inşa API'si aracılığıyla gerçekleştirir.

Sequential API en basitidir — katmanların doğrusal bir yığını:

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"),
])

Birden fazla girişi, birden fazla çıkışı, paylaşılan katmanları veya atlama bağlantıları olan modeller için, Functional API sana tam grafik seviyesinde kontrol sağlar:

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)

Bu model iki giriş alır — yığılmış LSTM'ler tarafından işlenen 60 adımlık bir fiyat dizisi ve statik özelliklerin bir meta veri vektörü — bunları birleştirir ve yönlü bir tahmin çıkarır. Bu mimari, zamansal kalıpları (son fiyat hareketi) bağlamsal bilgiyle (oynaklık rejimi, fonlama oranı, haftanın günü) harmanlamak istediğin finansal ML'de yaygındır.

Finansal uygulamalar için önemli katman türleri: tablo özellikleri için Dense, zaman serileri için LSTM ve GRU, yerel zamansal kalıpları öğrenmek için Conv1D ve transformer tarzı dizi modellemesi için MultiHeadAttention.

İnşa edildikten sonra, bir Keras modelinin üç bileşenle derlenmesi gerekir: bir optimize edici, bir kayıp fonksiyonu ve değerlendirme metrikleri.

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'ler, eğitim sırasında belirli noktalarda — her epoch'tan, her batch'ten sonra veya belirli koşullar karşılandığında — çalışan hooklardır. Aksi takdirde manuel izleme gerektirecek eğitim yönetimini otomatikleştirirler:

• EarlyStopping — Doğrulama kaybı patience epoch boyunca iyileşmeyi durdurduğunda eğitimi durdurur. Aşırı uyumu ve boşa harcanan hesaplamayı önler. Otomatik olarak en iyi kontrol noktasına geri dönmek için restore_best_weights=True ayarla.
• ModelCheckpoint — Doğrulama performansı her iyileştiğinde modeli kaydeder. En iyi modelini bir eğitim çökmesine veya sonraki epoch'larda aşırı uyuma asla kaybetme.
• ReduceLROnPlateau — Doğrulama kaybı platoya ulaştığında öğrenme oranını düşürür. Bu, sabit bir öğrenme oranının kaçırdığı ek performansı genellikle açığa çıkarır — model önce büyük adımlar atar, sonra daha küçük adımlarla ince ayar yapar.

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, TensorFlow'un görselleştirme araç setidir ve TensorFlow, PyTorch veya JAX kullanıp kullanmadığından bağımsız olarak, herhangi bir ML uygulayıcısının iş akışındaki en değerli araçlardan biridir. Ham eğitim kayıtlarını, modelinin içinde ne olduğunu ortaya çıkaran interaktif panolara dönüştürür.

TensorBoard'u kayıt dizinine yönlendirerek başlat:

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

# Veya bir Jupyter notebook'unda
%load_ext tensorboard
%tensorboard --logdir ./logs

Finansal model geliştirme için önemli görselleştirmeler:

Scalars — Zaman içinde çizilen eğitim ve doğrulama kayıp eğrileri. İkisi arasındaki boşluk, aşırı uyumu ortaya çıkarır: azalmayı sürdüren bir eğitim kaybı, artan bir doğrulama kaybıyla birlikte, modelinin gürültüyü ezberlediği anlamına gelir. Sağlıklı eğitim, ikisinin de birlikte azaldığını, doğrulama eğrisinin eğitimin biraz üzerinde olduğunu gösterir.

Histograms — Katmanlar ve epoch'lar boyunca ağırlıkların, biasların ve aktivasyonların dağılımları. Sıfıra çöken ağırlık dağılımlarına (kaybolan gradyanlar), büyük değerlere patlayanlara (kararsız eğitim) veya 0 veya 1'de doyan aktivasyonlara (ölü nöronlar) dikkat et. Bu sorunlar kayıp eğrilerinde görünmez ama histogramlarda belirgindir.

Embeddings — Yüksek boyutlu temsilleri t-SNE veya PCA kullanarak 2D veya 3D alana yansıt. Modelinin, iç temsillerinde farklı piyasa rejimlerini, varlık sınıflarını veya oynaklık durumlarını ayırmayı öğrenip öğrenmediğini görselleştir.

HParams — Deneyler arasında hiperparametre taramalarını karşılaştır. Farklı öğrenme oranları, mimariler ve dropout değerleriyle aynı modeli çalıştır, sonra hangi kombinasyonların en iyi doğrulama metriklerini ürettiğini belirle. Bu sistematik karşılaştırma, gelişigüzel deneylemeyi kanıta dayalı model seçimiyle değiştirir.

TensorBoard, torch.utils.tensorboard.SummaryWriter sınıfı aracılığıyla PyTorch ile de çalışır — görselleştirme araçları çerçeveden bağımsızdır, bu da TensorBoard'un ML ekosistemi boyunca de facto standart haline gelmesinin bir nedenidir.

Veri kümen belleğe sığmayacak kadar büyük olduğunda — GaiaEx gibi borsalardan tick seviyesi verilerle çalışırken yaygın bir durum — tf.data, her şeyi bir kerede yüklemeden GPU'nu besleyen, verimli, paralelleştirilmiş bir veri boru hattı sağlar.

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)
)

prefetch(AUTOTUNE) çağrısı kritiktir — veri yüklemesinin ve model hesaplamasının örtüşmesine izin verir, bu yüzden GPU bir sonraki batch'i beklerken hiçbir zaman boş oturmaz. Karmaşık özellik mühendisliği olan finansal veri kümeleri için, önceden hesaplayıp saklamak yerine göstergeleri ve normalleştirmeleri anında hesaplayan, paralel çalışan .map() dönüşümlerini zincirleyebilirsin.

TensorFlow Serving, modelleri yüksek performanslı bir gRPC veya REST API'nin ardında dağıtmak için üretim seviyesinde bir sistemdir. Model sürüm oluşturmayı (eski modeli bir yedek olarak tutarken yeni modeli sunmak), istek gruplandırmayı (GPU verimliliği için birden fazla çıkarım isteğini birleştirmek) ve donanım hızlandırmayı yönetir — hem gecikmenin hem güvenilirliğin önemli olduğu işlem sistemleri için hepsi kritiktir.

# Bir SavedModel dışa aktar
model.save("models/price_predictor/1")

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

Tipik bir üretim mimarisi: işlem bot'un GaiaEx'in WebSocket beslemesine bağlanır, özellikleri gerçek zamanlı hesaplar, TF Serving'e çıkarım istekleri gönderir ve tek hane milisaniyeler içinde tahminler alır. Yeni verilerle yeniden eğitim yaptığında, güncellenmiş modeli 2. sürüm olarak dağıt — TF Serving onu sıfır kesinti ile değiştirir.

TensorFlow Lite, modelleri mobil cihazlar, gömülü sistemler ve edge donanımlarında dağıtım için sıkıştırır. Nicemleştirme (32-bit kayan noktalı ağırlıkları 8-bit tam sayılara dönüştürme), budama (sıfıra yakın ağırlıkları çıkarma) ve mimari optimizasyonu gibi teknikler aracılığıyla, TF Lite bir modeli çoğu doğruluğu koruyarak 4 kat veya daha fazla küçültebilir. Bu, sınırlı hesaplama gücüne sahip cihazlarda doğrudan çıkarım çalıştırmayı sağlar — bulut altyapısından bağımsız çalışması gereken edge işlem düğümleri veya izleme panoları için kullanışlıdır.

# Bir Keras modelini TF Lite'a dönüştür
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 — finansal uygulamalar için hangisini seçmelisin?

• Araştırma ve prototipleme için: PyTorch. Dinamik grafikleri, Python'a uygun API'si ve akademik araştırmada hâkim konumu, daha fazla makalenin PyTorch kodu içerdiği, daha fazla eğitimin PyTorch kullandığı ve hata ayıklamanın daha sezgisel olduğu anlamına gelir.
• Büyük ölçekte üretim dağıtımı için: TensorFlow hâlâ avantajlara sahip. TF Serving, TF Lite ve TensorFlow.js, PyTorch'un TorchServe ve ONNX Runtime'ının hâlâ olgunlaşmakta olduğu, savaş testinden geçmiş dağıtım yolları sağlar.
• Özellikle finansal ML için: Model geliştirme ve deneyleme için PyTorch ile başla. Üretim gereksinimlerin TF Serving'in olgunluğunu veya TF Lite'ın edge dağıtımını gerektiriyorsa, en iyi modellerini dönüştür. Birçok ekip araştırma için PyTorch, dağıtım için TensorFlow kullanır, aralarındaki köprüyü ONNX (Open Neural Network Exchange) formatı aracılığıyla kurar.

Dürüst gerçek: her iki çerçeve de yakınsıyor. TensorFlow eager execution'ı benimsedi; PyTorch grafik seviyesinde optimizasyon için torch.compile ekledi. Keras'ın kendisi artık backend olarak PyTorch, JAX ve TensorFlow'u destekliyor. En iyi çerçeve, ekibinin iyi bildiği ve üretim koduyla gönderim yapabildiği çerçevedir. Birini seç, ustalaş ve araçlar üzerinde tartışmak yerine gerçek sorunu — piyasaları tahmin etmeyi — çöz.