PyTorch फंडामेंटल्स: मॉडल बनाना और ट्रेन करना

PyTorch डिफ़ॉल्ट रूप से ईगर एग्ज़ीक्यूशन इस्तेमाल करता है: टेंसर Python के ऑपरेशंस के ज़रिए बहते हैं और आप उन्हें सामान्य डेटा की तरह प्रिंट, स्लाइस, और डिबग कर सकते हैं। यह फाइनेंस में मायने रखता है, जहाँ आधा काम फीचर्स की गड़बड़ पैनल्स को दोबारा आकार देना और यह पुष्टि करना है कि जो टेंसर आप मॉडल को देते हैं, उसमें कोई लुक-अहेड नहीं घुसा है।

इसे पुराने “पहले एक स्टैटिक ग्राफ़ बनाओ, फिर एक सेशन चलाओ” वर्कफ़्लो से तुलना करें। रिसर्चर अब भी डिप्लॉयमेंट के लिए मॉडल एक्सपोर्ट करते हैं, पर रोज़ का काम फ़ौरीपन से फ़ायदा उठाता है: एक लेयर बदलें, एक सेल दोबारा चलाएँ, एक्टिवेशन देखें।

एक टेंसर एक मल्टीडायमेंशनल ऐरे है; requires_grad=True उन लीफ़ को मार्क करता है जिन पर आप डेरिवेटिव चाहते हैं। ऑटोग्रैड ऑपरेशंस को रेकॉर्ड करता है एक बैकवर्ड ग्राफ़ बनाने के लिए, ताकि loss.backward() पैरामीटर्स पर .grad भर सके।

import torch
x = torch.randn(32, 10, requires_grad=True)
w = torch.randn(10, 1, requires_grad=True)
y = (x @ w).mean()
y.backward()
print(w.grad.shape)

जब उपलब्ध हो, टेंसर को cuda या mps पर रखें; डिवाइस प्लेसमेंट को एक जैसा रखें ताकि आप गलती से हर स्टेप में छोटे टेंसर को आगे-पीछे न हिलाएँ।

nn.Module को सबक्लास करें, __init__ में लेयर्स तय करें, और उन्हें forward में जोड़ें। रजिस्ट्रेशन यह सुनिश्चित करता है कि ऑप्टिमाइज़र के लिए पैरामीटर्स model.parameters() में दिखें।

import torch.nn as nn

class MLP(nn.Module):
    def __init__(self, n):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(n, 64), nn.ReLU(), nn.Linear(64, 1)
        )
    def forward(self, x):
        return self.net(x)

सीक्वेंस मॉडल के लिए, nn.LSTM और nn.TransformerEncoder लेयर आम हैं; टेबुलर अल्फा के लिए, MLP और ग्रेडिएंट बूस्टिंग अभी भी आमने-सामने हैं — फ़ैशन के अनुसार नहीं, बल्कि वैलिडेशन के अनुशासन के अनुसार चुनें।

ट्रेनिंग जानबूझकर दोहरावदार है: फ़ॉरवर्ड, लॉस, ज़ीरो ग्रैड, बैकवर्ड, स्टेप। अतिरिक्त बातें भी मायने रखती हैं: model.train() बनाम model.eval() ड्रॉपआउट और बैच नॉर्म को टॉगल करते हैं; torch.no_grad() मेमोरी बचाने के लिए वैलिडेशन को घेरता है।

फीचर्स और लेबल तैयार करने के लिए Dataset को सबक्लास करें; बैचिंग के लिए इसे DataLoader से लपेटें। कालानुक्रमिक डेटा के लिए, आम तौर पर वैलिडेशन पर shuffle=False रखें, और अक्सर ट्रेनिंग पर भी अगर आप लगातार विंडो काटते हैं — नहीं तो जानकारी समय में फैल जाती है।

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

लो-लेटेंसी इन्फ़रेंस के लिए, टीमें अक्सर मॉडल को ट्रेस या स्क्रिप्ट करती हैं, फिर उसे C++ रनटाइम या एक साइडकार सर्विस में चलाती हैं। ट्रेनिंग एनवायरनमेंट (लाइब्रेरी वर्ज़न) को उसी पर पिन रखें जिसका इस्तेमाल आपने एक्सपोर्ट के लिए किया था।

PyTorch Lightning और इसी तरह के फ्रेमवर्क मल्टी-GPU ट्रेनिंग और लॉगिंग के लिए बॉयलरप्लेट घटाते हैं; वे सावधान फीचर डिज़ाइन की जगह नहीं लेते। ट्रेडिंग में बढ़त आम तौर पर डेटा हाइजीन और रेजिम-जागरूकता से आती है, थोड़े और फैंसी ऑप्टिमाइज़र से नहीं।