TensorFlow, Keras i TensorBoard do monitorowania modeli

TensorFlow, opracowany przez Google Brain i wydany w 2015 roku, to nie tylko biblioteka do głębokiego uczenia — to cały ekosystem do budowania, trenowania, wdrażania i monitorowania modeli uczenia maszynowego w każdej skali. Podczas gdy PyTorch dominuje w badaniach, TensorFlow pozostaje siłownią produkcyjną, wdrożoną w systemach przetwarzających miliardy predykcji dziennie w Google, Airbnb, Twitterze i tysiącach innych firm.

Ten ekosystem obejmuje cały cykl życia modelu ML:

• Keras — Interfejs wysokiego poziomu do budowania i trenowania modeli, obecnie w pełni zintegrowany z TensorFlow jako tf.keras
• TensorBoard — Zestaw narzędzi do wizualizacji monitorowania treningu, porównywania eksperymentów i debugowania modeli
• tf.data — Wysokowydajne potoki danych do zasilania modeli dużymi zbiorami danych
• TensorFlow Serving — Serwowanie modeli klasy produkcyjnej z wersjonowaniem, grupowaniem zapytań (batching) i akceleracją sprzętową
• TensorFlow Lite — Zoptymalizowane środowisko wykonawcze dla urządzeń mobilnych i edge
• TensorFlow.js — Uruchamianie modeli bezpośrednio w przeglądarce

Ta rozpiętość jest największą siłą TensorFlow. Możesz stworzyć prototyp modelu w notatniku Jupyter za pomocą Keras, wytrenować go na klastrze GPU, monitorować trening za pomocą TensorBoard, serwować go za pomocą TF Serving za API, i wdrożyć skompresowaną wersję na Raspberry Pi — wszystko w ramach tego samego frameworka. W zastosowaniach finansowych, gdzie możesz potrzebować modeli działających jednocześnie w chmurowym silniku handlowym (połączonym z API GaiaEx) i na lokalnej stacji roboczej do badań, ta wszechstronność ma znaczenie.

Keras został zaprojektowany wokół jednej zasady: zmniejszyć obciążenie poznawcze przy budowaniu sieci neuronowych. Osiąga to za pomocą dwóch interfejsów do budowania modeli, każdego przeznaczonego do innego poziomu złożoności.

Sequential API jest najprostszy — liniowy stos warstw:

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

Dla modeli z wieloma wejściami, wieloma wyjściami, współdzielonymi warstwami lub połączeniami pomijającymi (skip connections), Functional API daje pełną kontrolę na poziomie grafu:

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)

Ten model przyjmuje dwa wejścia — 60-krokową sekwencję cenową przetwarzaną przez ułożone w stos LSTM oraz wektor metadanych ze statycznymi cechami — łączy je i zwraca predykcję kierunkową. Ta architektura jest powszechna w finansowym ML, gdzie chcesz połączyć wzorce czasowe (niedawna akcja cenowa) z informacją kontekstową (reżim zmienności, stopa finansowania, dzień tygodnia).

Kluczowe typy warstw dla zastosowań finansowych: Dense dla cech tabelarycznych, LSTM i GRU dla szeregów czasowych, Conv1D do uczenia lokalnych wzorców czasowych, oraz MultiHeadAttention do modelowania sekwencji w stylu transformera.

Po zbudowaniu, model Keras musi zostać skompilowany z trzema komponentami: optymalizatorem, funkcją straty i metrykami ewaluacji.

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=[...],
)

Callbacki to haki, które wykonują się w określonych momentach treningu — po każdej epoce, po każdej partii (batch), lub gdy zostaną spełnione określone warunki. Automatyzują zarządzanie treningiem, które inaczej wymagałoby ręcznego monitorowania:

• EarlyStopping — Zatrzymuje trening, gdy strata walidacyjna przestaje się poprawiać przez patience epok. Zapobiega przeuczeniu i niepotrzebnemu zużyciu mocy obliczeniowej. Ustaw restore_best_weights=True, aby automatycznie wrócić do najlepszego checkpointu.
• ModelCheckpoint — Zapisuje model każdorazowo, gdy wydajność walidacyjna się poprawia. Nigdy nie utracisz swojego najlepszego modelu przez awarię treningu lub przeuczenie w późniejszych epokach.
• ReduceLROnPlateau — Zmniejsza tempo uczenia, gdy strata walidacyjna osiąga plateau. Często odblokowuje to dodatkową wydajność, którą pomija stałe tempo uczenia — model robi duże kroki na początku, a potem dostraja się mniejszymi krokami.

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 to zestaw narzędzi do wizualizacji od TensorFlow i jedno z najbardziej wartościowych narzędzi w codziennym warsztacie każdego praktyka ML — niezależnie od tego, czy używasz TensorFlow, PyTorch, czy JAX. Przekształca surowe logi treningowe w interaktywne panele (dashboardy), które odsłaniają, co dzieje się wewnątrz modelu.

Uruchom TensorBoard, wskazując go na swój katalog logów:

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

# Lub w notatniku Jupyter
%load_ext tensorboard
%tensorboard --logdir ./logs

Kluczowe wizualizacje dla rozwoju modeli finansowych:

Scalars — Krzywe straty treningowej i walidacyjnej wykreślone w czasie. Odstęp między nimi ujawnia przeuczenie: strata treningowa, która wciąż spada, podczas gdy strata walidacyjna rośnie, oznacza, że model zapamiętuje szum. Zdrowy trening pokazuje obie krzywe spadające razem, z krzywą walidacyjną nieznacznie powyżej treningowej.

Histograms — Rozkłady wag, obciążeń (biasów) i aktywacji w warstwach i epokach. Uważaj na rozkłady wag zapadające się do zera (zanikające gradienty), rosnące do dużych wartości (niestabilny trening), lub aktywacje nasycone przy 0 lub 1 (martwe neurony). Te problemy są niewidoczne na krzywych straty, ale oczywiste na histogramach.

Embeddings — Projekcja reprezentacji wysokowymiarowych w przestrzeń 2D lub 3D za pomocą t-SNE lub PCA. Zwizualizuj, czy twój model nauczył się rozdzielać różne reżimy rynkowe, klasy aktywów lub stany zmienności w swoich wewnętrznych reprezentacjach.

HParams — Porównanie przeszukań hiperparametrów między eksperymentami. Uruchom ten sam model z różnymi tempami uczenia, architekturami i wartościami dropoutu, a następnie zidentyfikuj, które kombinacje dają najlepsze metryki walidacyjne. To systematyczne porównanie zastępuje eksperymentowanie ad hoc doborem modelu opartym na dowodach.

TensorBoard działa również z PyTorch poprzez klasę torch.utils.tensorboard.SummaryWriter — narzędzia wizualizacyjne są niezależne od frameworka, co jest jednym z powodów, dla których TensorBoard stał się faktycznym standardem w całym ekosystemie ML.

Gdy twój zbiór danych jest za duży, by zmieścić się w pamięci — częsta sytuacja przy pracy z danymi tickowymi z giełd takich jak GaiaEx — tf.data zapewnia wydajny, zrównoleglony potok danych, który zasila GPU bez wczytywania wszystkiego naraz.

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

Wywołanie prefetch(AUTOTUNE) jest kluczowe — pozwala nakładać wczytywanie danych i obliczenia modelu na siebie, dzięki czemu GPU nigdy nie stoi bezczynnie, czekając na kolejną partię (batch). Dla zbiorów danych finansowych ze złożonym feature engineeringiem możesz łączyć w łańcuch transformacje .map(), które działają równolegle, obliczając wskaźniki i normalizacje na bieżąco, a nie wstępnie je licząc i zapisując.

TensorFlow Serving to system klasy produkcyjnej do wdrażania modeli za wysokowydajnym API gRPC lub REST. Obsługuje wersjonowanie modeli (serwowanie nowego modelu z zachowaniem starego jako opcji zapasowej), grupowanie zapytań (batching) (łączenie wielu żądań inferencji dla efektywności GPU) oraz akcelerację sprzętową — wszystko to kluczowe dla systemów handlowych, gdzie liczy się i opóźnienie, i wiarygodność.

# Eksport modelu SavedModel
model.save("models/price_predictor/1")

# Serwowanie za pomocą Dockera
# docker run -p 8501:8501 \
#   --mount type=bind,source=$(pwd)/models,target=/models \
#   -e MODEL_NAME=price_predictor \
#   tensorflow/serving

Typowa architektura produkcyjna: twój bot handlowy łączy się z kanałem WebSocket GaiaEx, oblicza cechy w czasie rzeczywistym, wysyła żądania inferencji do TF Serving i otrzymuje predykcje w jednocyfrowych milisekundach. Kiedy retrenujesz na nowych danych, wdrażasz zaktualizowany model jako wersję 2 — TF Serving podmienia go bez żadnego przestoju.

TensorFlow Lite kompresuje modele do wdrożenia na urządzeniach mobilnych, systemach wbudowanych i sprzęcie edge. Za pomocą technik takich jak kwantyzacja (konwersja 32-bitowych wag zmiennoprzecinkowych na 8-bitowe liczby całkowite), pruning (usuwanie wag bliskich zeru) oraz optymalizacja architektury, TF Lite może zmniejszyć model 4-krotnie lub więcej, zachowując przy tym większość jego dokładności. To umożliwia uruchamianie inferencji bezpośrednio na urządzeniach o ograniczonej mocy obliczeniowej — przydatne dla węzłów handlowych na edge lub paneli monitorujących, które muszą działać niezależnie od infrastruktury chmurowej.

# Konwersja modelu Keras do 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 — który wybrać do zastosowań finansowych?

• Do badań i prototypowania: PyTorch. Jego dynamiczne grafy, pythonowe API i dominująca pozycja w badaniach akademickich oznaczają, że więcej publikacji zawiera kod w PyTorch, więcej tutoriali używa PyTorch, a debugowanie jest bardziej intuicyjne.
• Do wdrożenia produkcyjnego w skali: TensorFlow wciąż ma przewagi. TF Serving, TF Lite i TensorFlow.js dostarczają sprawdzone bojowo drogi wdrożenia, do których TorchServe i ONNX Runtime od PyTorch wciąż dorastają.
• Dla finansowego ML konkretnie: Zacznij od PyTorch do rozwoju modelu i eksperymentowania. Jeśli twoje wymagania produkcyjne wymagają dojrzałości TF Serving lub wdrożenia na edge za pomocą TF Lite, przekonwertuj swoje najlepsze modele. Wiele zespołów używa PyTorch do badań i TensorFlow do wdrożenia, łącząc je za pomocą formatu ONNX (Open Neural Network Exchange).

Uczciwa prawda: oba frameworki zbiegają się. TensorFlow przyjął eager execution; PyTorch dodał torch.compile do optymalizacji na poziomie grafu. Sam Keras teraz wspiera PyTorch, JAX i TensorFlow jako backendy. Najlepszy framework to ten, który twój zespół dobrze zna i z którym może wysyłać kod produkcyjny. Wybierz jeden, opanuj go i rozwiąż rzeczywisty problem — predykcję rynków — zamiast debatować o narzędziach.