यह कैसे सीखता है
यह सेक्शन पूरा करने के बाद, आप तीन वाक्यों में समझा सकेंगे कि KiT की ट्रेनिंग का हर कदम क्या करता है, और अगले सेक्शन में ट्रेनिंग स्क्रिप्ट के मुख्य दर्जन भर लाइनें समझ आ जाएँगी।
पहले एक खेल के बारे में सोचें
एक साफ़ फोटो लें और उस पर बर्फ़ के दानों जैसा नॉइज़ छिड़क दें। थोड़ा छिड़कें तो मूल तस्वीर अभी भी दिखती है; बहुत छिड़कें तो सिर्फ़ बर्फ़ के दाने ही बचते हैं।
एक व्यक्ति को अभ्यास करने दें: उसे नॉइज़ वाली फोटो दें, यह भी बताएँ कि “कितना छिड़का गया”, और उससे कहें कि वह बताए “बर्फ़ के दाने कहाँ हैं और किस दिशा में पोंछना है”। काफ़ी अभ्यास के बाद वह पूरी स्क्रीन भर बर्फ़ से शुरू करके, धीरे-धीरे एक ठीक-ठाक फोटो बना सकेगा।
KiT की ट्रेनिंग यही खेल है, बस फोटो की जगह “भविष्य की 20 K-लाइनें” हैं।
ट्रेनिंग का एक कदम
डेटा से कोई भी एक हिस्सा काटें: पहली 400 लाइनें इतिहास हैं, बाद की 20 लाइनें असली भविष्य हैं (1 घंटे की लाइन को उदाहरण मानें)।
- 1?
- 2?
- 3?
- 4?
- 5?
क्रम के अनुसार, एक-एक करके क्लिक करें।
सूत्र रूप में लिखें तो यह पेपर के सेक्शन 3.1 और 3.5 की तीन लाइनें हैं:
- मिश्रण: z = (1 − t)·x + t·ε, जहाँ x असली भविष्य है और ε नॉइज़ है
- सही उत्तर (“वेग”): v = ε − x
- लॉस: मॉडल के आउटपुट और v के बीच माध्य वर्ग त्रुटि, जिसका औसत केवल भविष्य की Lh लाइनों पर लिया जाता है
“वेग” की भविष्यवाणी क्यों करवाई जाती है, सीधे उत्तर की नहीं
z, x और ε के बीच की एक सीधी रेखा है: जब t, 0 से 1 तक जाता है, तो z डेटा से एकसमान गति से नॉइज़ तक पहुँचता है। इस सीधी रेखा की दिशा हर जगह एक ही होती है, यानी ε − x। मॉडल यह सीख जाता है कि “किसी भी स्थिति, किसी भी t पर यह रेखा किधर इशारा करती है”, और इन्फ़ेरेंस के समय नॉइज़ से उसके उलट डेटा तक वापस चल सकता है।
रेखा सीधी है, इसलिए उलट चलते समय कदम बड़े रखे जा सकते हैं: 32 कदमों वाला यूलर तरीका पर्याप्त है। तुलना के लिए, पेपर के परिशिष्ट में दिए गए डिफ़्यूज़न-आधारित बेसलाइन: TimeGrad को भविष्य की हर एक K-लाइन बनाने के लिए 100 डिफ़्यूज़न स्टेप चाहिए (और वह भी एक-एक करके आगे बनाना पड़ता है), जबकि Diffusion-TS सैंपलिंग में 200 स्टेप लेता है।
टेंसर का आकार
1 घंटे की लाइन और batch B को उदाहरण मानें:
| टेंसर | आकार | विवरण |
|---|---|---|
x_ctx | [B, 400, 5] | इतिहास, मानकीकृत पाँच संख्याएँ |
x_tgt | [B, 20, 5] | असली भविष्य, इसी तरह मानकीकृत |
t | [B] | हर सैंपल के लिए एक फ्लो समय |
eps | [B, 20, 5] | मानक सामान्य नॉइज़ |
| मॉडल इनपुट | [B, 420, 5] | इतिहास और नॉइज़ वाले भविष्य को जोड़ा जाता है (मॉडल के अंदर 4 और रजिस्टर जोड़े जाते हैं) |
मॉडल आउटपुट v | [B, 20, 5] | केवल भविष्य का वह हिस्सा |
इनपुट को पहले स्टैंडर्डाइज़ किया जाता है: MAD + tanh सॉफ्ट क्लिपिंग
पाँच अनुपातों के आकार में बहुत बड़ा अंतर होता है, और इनमें अत्यधिक मान भी होते हैं (ऊपरी लिमिट में लॉक, फ्लैश क्रैश, वॉल्यूम में विस्फोट)। मॉडल में जाने से पहले, प्रत्येक (बाज़ार, ग्रैन्युलैरिटी, फ़ीचर) को एक निश्चित स्केल s से स्केल किया जाता है, फिर सॉफ्ट क्लिप किया जाता है (kit_v1/data/normalize.py):
- s = 1.4826 × माध्य निरपेक्ष विचलन (MAD), केवल प्रशिक्षण अवधि के डेटा से गणना की जाती है,
stats.jsonमें संग्रहीत किया जाता है - y = 6 · tanh(x / s / 6)
tanh सामान्य रेंज के मानों को लगभग अपरिवर्तित रखता है, और अत्यधिक मानों को सीधे काटने के बजाय उन्हें धीरे-धीरे ±6 के भीतर दबा देता है। पेपर के अनुसार “प्रशिक्षण स्थिर रहता है, और आउटलेयर भी खो नहीं जाते”। भविष्यवाणी के बाद atanh से उल्टा करके मूल रूप में वापस लाया जाता है।
अनुमान (इन्फ़ेरेंस) के समय इसे उल्टा किया जाता है: t = 1 (शुद्ध नॉइज़) से शुरू करके, हर कदम पर मॉडल द्वारा बताई गई दिशा में थोड़ा पीछे चला जाता है, और t = 0 तक पहुँचने पर वही भविष्यवाणी होती है। यही वह स्लाइडर है जिसे आप कोर्स के होमपेज पर खींचते हैं।
मॉडल पहले इतिहास पढ़ता है: पिछली 400 1-घंटे की K लाइनें (यहाँ सिर्फ आखिरी 48 दिखाई गई हैं)।
t को कैसे चुना जाता है
t को समान रूप से (यूनिफ़ॉर्म) नहीं चुना जाता। पेपर logit-normal का उपयोग करता है: पहले मानक सामान्य वितरण से एक संख्या निकाली जाती है, फिर उसे एक sigmoid से गुज़ारा जाता है। इस तरह t अधिकतर 0.5 के आसपास रहता है, और प्रशिक्षण का ज़ोर मुख्य रूप से “आधा डेटा, आधा नॉइज़” वाली मध्यम कठिनाई पर लगता है; पूरा नॉइज़ या लगभग बिना नॉइज़ वाले मामलों में सीखने के लिए ज़्यादा जानकारी नहीं होती।
कोड में यह केवल एक पंक्ति है: t = torch.sigmoid(torch.randn(B))।
“जानबूझकर कुछ छोड़ने” की तीन और तकनीकें
प्रशिक्षण के दौरान कुछ शर्तों (कंडीशन) को यादृच्छिक रूप से हटा दिया जाता है (पेपर का अनुभाग 3.5):
- स्टॉक और उद्योग की पहचान को “अज्ञात” से बदल दिया जाता है
- बाज़ार, उद्योग, स्टॉक, ग्रैन्युलैरिटी — इन सभी पहचानों को पूरी तरह मिटा दिया जाता है
- पूरे इतिहास को शून्य कर दिया जाता है
इस तरह मॉडल एक साथ सीख जाता है कि “पहचान के साथ / पहचान के बिना” और “इतिहास के साथ / इतिहास के बिना” होने पर भविष्यवाणी कैसे करनी है। अनुमान के समय के --cfg-w और --hist-cfg-w इन्हीं कई भविष्यवाणियों के अंतर को लेकर किसी शर्त के प्रभाव को बढ़ाते हैं (क्लासिफ़ायर-फ़्री गाइडेंस, CFG)। पिछले अध्याय में कहा गया था कि यह डिफ़ॉल्ट रूप से बंद रहता है।
पेपर की प्रशिक्षण संरचना
| मद | मान |
|---|---|
| ऑप्टिमाइज़र | AdamW, β1 = 0.9, β2 = 0.95, वेट डिके 0.1 |
| लर्निंग रेट | पीक 1e-4, पहले 1000 स्टेप वॉर्मअप |
| प्रिसिज़न | BF16 |
| ग्लोबल batch | 4096 |
| ग्रेडिएंट क्लिपिंग | 1.0 |
| पैरामीटर EMA | डिके 0.9999 (ओपन-सोर्स वेट वही EMA वाला है) |
| हार्डवेयर | 128 NVIDIA H200 GPU |
| स्टॉपिंग कंडीशन | प्रत्येक (मार्केट, ग्रैन्युलैरिटी) का औसत वैलिडेशन लॉस अब और नहीं घटता |
| मॉडल साइज़ | KiT-S 3100 दस हज़ार, KiT-M 1.01 दस करोड़, KiT-L 2.84 दस करोड़ पैरामीटर |
128 H200 GPU हमारे पास नहीं हैं। अगले सेक्शन में एक 16GB वाली GPU और 100 स्टॉक्स के साथ वही ट्रेनिंग ऑब्जेक्टिव चलाकर देखेंगे कि क्या होता है।
ऑफिशियल ट्रेनिंग कोड अभी तक रिलीज़ नहीं हुआ है
ऑफिशियल रिपॉज़िटरी के kit_v1/train/README.md में लिखा है "TBD. Training code will be released here." अगला सेक्शन इस कोर्स का खुद लिखा हुआ मिनिमल स्क्रिप्ट उपयोग करता है, केवल रिपॉज़िटरी में पहले से सार्वजनिक मॉडल और डेटा कोड के साथ, और ट्रेनिंग ऑब्जेक्टिव पेपर के अनुसार लिखा गया है।
आपकी परीक्षाट्रेनिंग के समय, लॉस किस हिस्से पर गणना होती है?
एक बार जाँच लें
- मैं ट्रेनिंग के एक स्टेप की पाँच बातें बता सकता हूँ
- मुझे पता है कि "वेग" का सही उत्तर है नॉइज़ − एक्चुअल
- मुझे पता है कि t ज़्यादातर 0.5 के पास से क्यों चुना जाता है
अगला सेक्शन: एक छोटे KiT को ज़ीरो से ट्रेन करना।