मॉडल मॉनिटरिंग के लिए TensorFlow, Keras, और TensorBoard

Google Brain द्वारा विकसित और 2015 में रिलीज़ किया गया TensorFlow सिर्फ़ एक डीप लर्निंग लाइब्रेरी नहीं है — यह किसी भी स्केल पर मशीन लर्निंग मॉडल बनाने, ट्रेन करने, डिप्लॉय करने, और मॉनिटर करने के लिए एक पूरा इकोसिस्टम है। जबकि PyTorch रिसर्च में हावी है, TensorFlow अब भी प्रोडक्शन का पावरहाउस है, जो Google, Airbnb, Twitter, और हज़ारों दूसरी कंपनियों में हर दिन अरबों प्रेडिक्शन प्रोसेस करने वाले सिस्टम्स में डिप्लॉय है।

यह इकोसिस्टम पूरे ML लाइफसाइकल में फैला है:

• Keras — मॉडल बनाने और ट्रेन करने के लिए हाई-लेवल API, जो अब TensorFlow में tf.keras के रूप में पूरी तरह इंटीग्रेटेड है
• TensorBoard — ट्रेनिंग मॉनिटर करने, प्रयोगों की तुलना करने, और मॉडल्स को डीबग करने के लिए विज़ुअलाइज़ेशन टूलकिट
• tf.data — मॉडल्स को बड़े डेटासेट देने के लिए हाई-परफ़ॉर्मेंस डेटा पाइपलाइन्स
• TensorFlow Serving — वर्ज़निंग, बैचिंग, और हार्डवेयर एक्सेलरेशन के साथ प्रोडक्शन-ग्रेड मॉडल सर्विंग
• TensorFlow Lite — मोबाइल और एज डिवाइसेस के लिए ऑप्टिमाइज़्ड रनटाइम
• TensorFlow.js — मॉडल्स को सीधे ब्राउज़र में चलाना

यह विस्तार ही TensorFlow की सबसे बड़ी ताकत है। आप एक Jupyter नोटबुक में Keras के साथ एक मॉडल का प्रोटोटाइप बना सकते हैं, इसे एक GPU क्लस्टर पर ट्रेन कर सकते हैं, TensorBoard से ट्रेनिंग मॉनिटर कर सकते हैं, इसे TF Serving से एक API के पीछे सर्व कर सकते हैं, और इसका एक कंप्रेस्ड वर्ज़न Raspberry Pi पर डिप्लॉय कर सकते हैं — सब एक ही फ्रेमवर्क के भीतर। वित्तीय ऐप्लिकेशन्स के लिए जहां आपको एक क्लाउड ट्रेडिंग इंजन (GaiaEx के API से जुड़ा) और रिसर्च के लिए एक लोकल वर्कस्टेशन, दोनों पर मॉडल्स चलाने की ज़रूरत हो सकती है, यह लचीलापन मायने रखता है।

Keras एक मार्गदर्शक सिद्धांत के साथ बनाया गया था: न्यूरल नेटवर्क बनाने के मानसिक भार को घटाना। यह दो मॉडल-बनाने वाले API के ज़रिए ऐसा करता है, हर एक अलग जटिलता-स्तर के लिए बना।

सीक्वेंशियल API सबसे सरल है — लेयर्स का एक रैखिक ढेर:

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

कई इनपुट्स, कई आउटपुट्स, साझा लेयर्स, या स्किप कनेक्शन वाले मॉडल्स के लिए, फ़ंक्शनल API आपको पूरा ग्राफ़-स्तरीय नियंत्रण देता है:

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)

यह मॉडल दो इनपुट्स लेता है — स्टैक्ड LSTM द्वारा प्रोसेस किया गया एक 60-स्टेप प्राइस सीक्वेंस, और स्टैटिक फ़ीचर्स का एक मेटाडेटा वेक्टर — उन्हें मिलाता है, और एक दिशात्मक प्रेडिक्शन आउटपुट करता है। यह आर्किटेक्चर वित्तीय ML में सामान्य है जहां आप टेंपोरल पैटर्न (हाल की प्राइस एक्शन) को कॉन्टेक्स्टुअल जानकारी (वोलैटिलिटी रेजीम, फंडिंग रेट, हफ़्ते का दिन) के साथ मिलाना चाहते हैं।

वित्तीय ऐप्लिकेशन्स के लिए मुख्य लेयर टाइप्स: टैबुलर फ़ीचर्स के लिए Dense, टाइम सीरीज़ के लिए LSTM और GRU, लोकल टेंपोरल पैटर्न सीखने के लिए Conv1D, और ट्रांसफ़ॉर्मर-स्टाइल सीक्वेंस मॉडलिंग के लिए MultiHeadAttention।

एक बार बन जाने पर, एक Keras मॉडल को तीन हिस्सों के साथ कंपाइल करना होता है: एक ऑप्टिमाइज़र, एक लॉस फ़ंक्शन, और इवैल्यूएशन मेट्रिक्स।

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

कॉलबैक्स ऐसे हुक होते हैं जो ट्रेनिंग के दौरान खास बिंदुओं पर चलते हैं — हर एपोक, बैच, या जब कुछ शर्तें पूरी होती हैं तब। ये वह ट्रेनिंग मैनेजमेंट ऑटोमेट करते हैं जिसके लिए वर्ना मैनुअल मॉनिटरिंग चाहिए होती:

• EarlyStopping — जब वैलिडेशन लॉस patience एपोक्स तक सुधरना बंद कर दे तो ट्रेनिंग रोक देता है। ओवरफिटिंग और बर्बाद कंप्यूट रोकता है। सबसे बेहतर चेकपॉइंट पर अपने-आप लौटने के लिए restore_best_weights=True सेट करें।
• ModelCheckpoint — जब भी वैलिडेशन परफ़ॉर्मेंस सुधरता है, मॉडल सेव कर देता है। बाद के एपोक्स में किसी ट्रेनिंग क्रैश या ओवरफिटिंग से अपना सबसे बेहतर मॉडल कभी न गंवाएं।
• ReduceLROnPlateau — जब वैलिडेशन लॉस पठार पर पहुंच जाए तो लर्निंग रेट घटा देता है। यह अक्सर वह अतिरिक्त परफ़ॉर्मेंस खोलता है जो एक तय लर्निंग रेट छूट जाता है — मॉडल शुरुआत में बड़े कदम उठाता है, फिर छोटे कदमों के साथ फ़ाइन-ट्यून करता है।

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 का विज़ुअलाइज़ेशन टूलकिट है, और यह किसी भी ML प्रैक्टिशनर के वर्कफ़्लो में सबसे कीमती टूल्स में से एक है — चाहे आप TensorFlow, PyTorch, या JAX इस्तेमाल करें। यह कच्चे ट्रेनिंग लॉग्स को इंटरैक्टिव डैशबोर्ड्स में बदल देता है जो दिखाते हैं कि आपके मॉडल के अंदर क्या हो रहा है।

TensorBoard को अपने लॉग डायरेक्टरी की ओर इशारा करके लॉन्च करें:

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

# Or in a Jupyter notebook
%load_ext tensorboard
%tensorboard --logdir ./logs

वित्तीय मॉडल डेवलपमेंट के लिए मुख्य विज़ुअलाइज़ेशन:

स्केलर्स — समय के साथ प्लॉट किए गए ट्रेनिंग और वैलिडेशन लॉस कर्व। दोनों के बीच का अंतर ओवरफिटिंग दिखाता है: एक ट्रेनिंग लॉस जो घटता रहता है जबकि वैलिडेशन लॉस बढ़ता है, मतलब आपका मॉडल शोर याद कर रहा है। स्वस्थ ट्रेनिंग दोनों कर्व को साथ घटता दिखाती है, वैलिडेशन कर्व ट्रेनिंग से थोड़ा ऊपर रहते हुए।

हिस्टोग्राम्स — लेयर्स और एपोक्स में वेट्स, बायास, और एक्टिवेशन्स के डिस्ट्रिब्यूशन। वेट डिस्ट्रिब्यूशन के ज़ीरो पर सिमट जाने (वैनिशिंग ग्रेडिएंट्स), बड़ी वैल्यूज़ पर फट जाने (अस्थिर ट्रेनिंग), या एक्टिवेशन्स के 0 या 1 पर सैचुरेट होने (डेड न्यूरॉन्स) पर नज़र रखें। ये समस्याएं लॉस कर्व्स में अदृश्य होती हैं पर हिस्टोग्राम्स में साफ़ दिखती हैं।

एम्बेडिंग्स — t-SNE या PCA का उपयोग करके हाई-डाइमेंशनल रिप्रेजेंटेशन्स को 2D या 3D स्पेस में प्रोजेक्ट करें। देखें कि क्या आपके मॉडल ने अपने अंतर्निहित रिप्रेजेंटेशन्स में अलग-अलग मार्केट रेजीम, एसेट क्लासेस, या वोलैटिलिटी स्टेट्स को अलग करना सीखा है।

HParams — प्रयोगों में हाइपरपैरामीटर स्वीप की तुलना करें। एक ही मॉडल को अलग-अलग लर्निंग रेट्स, आर्किटेक्चर्स, और ड्रॉपआउट वैल्यूज़ के साथ चलाएं, फिर पहचानें कि किस कॉम्बिनेशन से सबसे बेहतर वैलिडेशन मेट्रिक्स आते हैं। यह व्यवस्थित तुलना तात्कालिक प्रयोग को सबूत-आधारित मॉडल-चयन से बदल देती है।

TensorBoard PyTorch के साथ भी torch.utils.tensorboard.SummaryWriter क्लास के ज़रिए काम करता है — विज़ुअलाइज़ेशन टूल्स फ्रेमवर्क-अज्ञेय (framework-agnostic) हैं, जो एक कारण है कि TensorBoard ML इकोसिस्टम में एक व्यवहारिक मानक बन गया है।

जब आपका डेटासेट मेमोरी में फ़िट होने के लिए बहुत बड़ा हो — GaiaEx जैसे एक्सचेंजेस से टिक-स्तरीय डेटा के साथ काम करते वक्त एक सामान्य स्थिति — tf.data एक कुशल, पैरेलल डेटा पाइपलाइन देता है जो आपके GPU को एक साथ सब कुछ लोड किए बिना खिलाता रहता है।

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) कॉल अहम है — यह डेटा लोडिंग और मॉडल कंप्यूटेशन को एक साथ चलने देता है, तो GPU कभी अगले बैच का इंतज़ार करते हुए खाली नहीं बैठता। जटिल फ़ीचर इंजीनियरिंग वाले वित्तीय डेटासेट्स के लिए, आप .map() ट्रांसफ़ॉर्मेशन्स को चेन कर सकते हैं जो पैरेलल में चलते हैं, इंडिकेटर्स और नॉर्मलाइज़ेशन्स को पहले से कैलकुलेट और स्टोर करने के बजाय तुरंत कैलकुलेट करते हुए।

TensorFlow Serving एक प्रोडक्शन-ग्रेड सिस्टम है जो मॉडल्स को एक हाई-परफ़ॉर्मेंस gRPC या REST API के पीछे डिप्लॉय करता है। यह मॉडल वर्ज़निंग (नया मॉडल सर्व करते हुए पुराने को फ़ॉलबैक के रूप में रखना), रिक्वेस्ट बैचिंग (GPU दक्षता के लिए कई इनफ़रेंस रिक्वेस्ट्स को मिलाना), और हार्डवेयर एक्सेलरेशन संभालता है — सभी ट्रेडिंग सिस्टम्स के लिए अहम हैं जहां लेटेंसी और भरोसेमंदी दोनों मायने रखते हैं।

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

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

एक सामान्य प्रोडक्शन आर्किटेक्चर: आपका ट्रेडिंग बॉट GaiaEx के WebSocket फ़ीड से जुड़ता है, रीयल टाइम में फ़ीचर्स कैलकुलेट करता है, TF Serving को इनफ़रेंस रिक्वेस्ट्स भेजता है, और सिंगल-डिजिट मिलीसेकंड्स में प्रेडिक्शन्स पाता है। जब आप नए डेटा पर फिर से ट्रेन करते हैं, अपडेटेड मॉडल को वर्ज़न 2 के रूप में डिप्लॉय करें — TF Serving इसे बिना डाउनटाइम बदल देता है।

TensorFlow Lite मॉडल्स को मोबाइल डिवाइसेस, एम्बेडेड सिस्टम्स, और एज हार्डवेयर पर डिप्लॉयमेंट के लिए कंप्रेस करता है। क्वांटाइज़ेशन (32-बिट फ़्लोटिंग-पॉइंट वेट्स को 8-बिट इंटीजर में बदलना), प्रूनिंग (शून्य-के-पास वेट्स हटाना), और आर्किटेक्चर ऑप्टिमाइज़ेशन जैसी तकनीकों से, TF Lite ज़्यादातर सटीकता बचाते हुए एक मॉडल को 4x या ज़्यादा सिकोड़ सकता है। यह सीमित कंप्यूट वाले डिवाइसेस पर सीधे इनफ़रेंस चलाना संभव बनाता है — एज ट्रेडिंग नोड्स या मॉनिटरिंग डैशबोर्ड्स के लिए उपयोगी जिन्हें क्लाउड इंफ्रास्ट्रक्चर से स्वतंत्र रूप से काम करना है।

# Convert a Keras model to 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 बनाम PyTorch — वित्तीय ऐप्लिकेशन्स के लिए किसे चुनना चाहिए?

• रिसर्च और प्रोटोटाइपिंग के लिए: PyTorch। इसके डायनैमिक ग्राफ़, पाइथॉनिक API, और अकादमिक रिसर्च में इसकी दबदबे वाली स्थिति का मतलब है कि ज़्यादा पेपर्स में PyTorch कोड शामिल है, ज़्यादा ट्यूटोरियल्स PyTorch इस्तेमाल करते हैं, और डीबगिंग ज़्यादा सहज है।
• बड़े स्केल पर प्रोडक्शन डिप्लॉयमेंट के लिए: TensorFlow अब भी फ़ायदे रखता है। TF Serving, TF Lite, और TensorFlow.js आज़माए-परखे डिप्लॉयमेंट रास्ते देते हैं जिनकी ओर PyTorch के TorchServe और ONNX Runtime अभी परिपक्व हो रहे हैं।
• खासतौर से वित्तीय ML के लिए: मॉडल डेवलपमेंट और प्रयोग के लिए PyTorch से शुरू करें। अगर आपकी प्रोडक्शन ज़रूरतें TF Serving की परिपक्वता या TF Lite के एज डिप्लॉयमेंट की मांग करती हैं, तो अपने सबसे बेहतर मॉडल्स को कन्वर्ट करें। कई टीमें रिसर्च के लिए PyTorch और डिप्लॉयमेंट के लिए TensorFlow इस्तेमाल करती हैं, इन्हें ONNX (Open Neural Network Exchange) फ़ॉर्मैट के ज़रिए जोड़ते हुए।

ईमानदार सच्चाई यह है: दोनों फ्रेमवर्क आपस में मिल रहे हैं। TensorFlow ने ईगर एक्ज़ीक्यूशन अपनाया; PyTorch ने ग्राफ़-स्तरीय ऑप्टिमाइज़ेशन के लिए torch.compile जोड़ा। Keras खुद अब PyTorch, JAX, और TensorFlow को बैकएंड के रूप में सपोर्ट करता है। सबसे बेहतर फ्रेमवर्क वही है जिसे आपकी टीम अच्छे से जानती है और जिसके साथ प्रोडक्शन कोड शिप कर सकती है। एक चुनें, उसमें माहिर बनें, और असली समस्या हल करें — बाज़ारों की भविष्यवाणी करना — टूल्स पर बहस करने के बजाय।