Skip to content

शून्य से एक छोटे KiT को ट्रेन करें ​

यह सेक्शन पूरा करने पर, आपके पास अपना खुद का ट्रेन किया हुआ KiT होगा (3100 万 = 3.1 करोड़ पैरामीटर, पेपर के KiT-S जितना बड़ा), जिससे आप प्रेडिक्शन प्लॉट निकाल सकते हैं; और आप अपनी आँखों से देखेंगे कि "जितनी देर ट्रेन करें, उतना और खराब" कैसे होता है।

1. ट्रेनिंग स्क्रिप्ट प्राप्त करें ​

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

train_mini.py डाउनलोड करें

इसे KiT डायरेक्टरी में रखें (eval/ के समान स्तर पर)। यह जो करता है, वही है पिछले सेक्शन के वे पाँच चरण:

python
t = torch.sigmoid(torch.randn(B))                   # logit-normal 抽 t
eps = torch.randn_like(x_tgt)                       # 噪声
z = (1 - t)[:, None, None] * x_tgt + t[:, None, None] * eps
v = model(torch.cat([x_ctx, z], dim=1), t, cond, Lh)  # 历史干净 + 未来加噪
loss = ((v.float() - (eps - x_tgt)) ** 2).mean()    # 只在未来那段

स्क्रिप्ट में केवल चार फंक्शन हैं, लगभग 200 पंक्तियाँ:

फंक्शनक्या करता है
build_windowsहर स्टॉक के लिए यादृच्छिक एंकर पॉइंट चुनता है, आधिकारिक prepare_inference_window को कॉल करके हिस्ट्री x_ctx और कंडीशन cond प्राप्त करता है, फिर एंकर के बाद की Lh वास्तविक K-लाइनों को पाँच संख्याओं में बदलकर स्टैंडर्डाइज़ करता है, और उसे x_tgt बनाता है। ट्रेडिंग-रुकावट से कैलेंडर मेल न खाने वाली विंडो हटा दी जाती हैं
fm_lossऊपर की ये पाँच पंक्तियाँ: t निकालना, नॉइज़ जोड़ना, फॉरवर्ड, लॉस निकालना
val_lossफिक्स्ड सीड वाले t और नॉइज़ से वैलिडेशन विंडो पर लॉस निकालता है, ताकि अलग-अलग स्टेप्स के बीच की संख्याओं की सीधे तुलना हो सके
mainAdamW (β=0.9/0.95, वेट डिके 0.1), ग्रेडिएंट क्लिपिंग 1.0, लीनियर वॉर्मअप, समय-समय पर वैलिडेशन, best.pt और last.pt सेव करना

जो नहीं किया गया (पेपर में है): कंडीशन ड्रॉपआउट, हिस्ट्री ट्रंकेशन, मल्टी-मार्केट मल्टी-ग्रैन्युलैरिटी मिक्सिंग, मल्टी-GPU FSDP, पैरामीटर EMA। ये सब अभ्यास के अच्छे विषय हैं, इस सेक्शन के अंत में दो दिए गए हैं।

2. ट्रेनिंग शुरू करें ​

bash
python train_mini.py --scale 1d --steps 3000 --per-stock 60 --batch 32 --eval-every 250 --warmup 100 --lr 3e-4 --out runs/scratch-1d
  • --scale 1d: केवल डेली बार
  • मॉडल आकार configs/dit_30m.yaml (डिफ़ॉल्ट मान) से आता है
  • ट्रेनिंग विंडो: हर स्टॉक के लिए 2016 से 2025-06-30 के बीच यादृच्छिक रूप से 60 सेगमेंट काटे गए, कुल 6000 सेगमेंट
  • वैलिडेशन विंडो: 2025 का दूसरा छमाही, हर स्टॉक के लिए 4 सेगमेंट, कुल 400 सेगमेंट, ट्रेनिंग में शामिल नहीं

आपको यह दिखना चाहिए (RTX 4080 SUPER, कुल 227 सेकंड):

text
model 31.0M params (31.0M trainable) | scale 1d Lc=250 Lh=20 | windows train 6000 val 400 (10s)
step 0 | val 3.4190
step 250 | train 2.2832 | val 1.8879 | 19s | peak GPU 4.3 GB
  saved best.pt (val 1.8879)
step 500 | train 1.8537 | val 1.8116 | 38s | peak GPU 4.3 GB
  saved best.pt (val 1.8116)
step 750 | train 1.7955 | val 1.7866 | 57s | peak GPU 4.3 GB
  saved best.pt (val 1.7866)
step 1000 | train 1.7667 | val 1.7995 | 76s | peak GPU 4.3 GB
...
step 3000 | train 1.3409 | val 2.1159 | 227s | peak GPU 4.3 GB
saved runs/scratch-1d/last.pt

train इस अवधि की ट्रेनिंग लॉस का औसत है, val उन 400 सेगमेंट के अनदेखे डेटा पर लॉस है। संख्या जितनी छोटी, उतना बेहतर।

3. इस कर्व को समझें ​

नीचे दिए स्लाइडर को खींचकर हर चेकपॉइंट देखें:

ड्रैग करके देखेंज़ीरो से ट्रेनिंग: लॉस कर्व (असली रिकॉर्ड)RTX 4080 SUPER पर वास्तविक टेस्ट
0 步1500 步3000 步3.51.3
ट्रेनिंग लॉसवैलिडेशन लॉसवैलिडेशन का सबसे निचला बिंदु

第 750 स्टेप पर वैलिडेशन लॉस सबसे कम (1.787)। train_mini.py इस समय best.pt सेव करता है।

पहले 750 कदमों में दोनों लाइनें एक साथ नीचे जाती हैं, मॉडल असली चीज़ें सीख रहा है। उसके बाद ट्रेनिंग लॉस लगातार घटकर 1.34 तक पहुँचती है, लेकिन वैलिडेशन लॉस 1.79 से बढ़कर 2.12 हो जाती है: मॉडल इन 100 स्टॉक्स के इतिहास के विवरण याद करने लगता है, न कि सामान्यीकरण करने वाले पैटर्न सीखता है। इसे ओवरफिटिंग कहते हैं।

कारण सरल है: 100 स्टॉक्स के डेली बार कुल 20.6 万 = 2.06 लाख हैं, जबकि पेपर अरबों बार इस्तेमाल करता है। डेटा कम हो और मॉडल बड़ा हो, तो ऐसा ही होता है। इसलिए स्क्रिप्ट हर बार जब वैलिडेशन लॉस नया निचला स्तर बनाती है, एक best.pt सेव करती है; इस्तेमाल इसी का करना है, अंतिम last.pt का नहीं।

4. अपने मॉडल से प्रेडिक्शन चार्ट बनाएँ ​

ट्रेनिंग स्क्रिप्ट द्वारा सेव किया गया चेकपॉइंट फॉर्मेट आधिकारिक जैसा ही है, इसे सीधे प्रेडिक्शन स्क्रिप्ट को दें:

bash
python eval/infer_for_pred.py --ckpt runs/scratch-1d/best.pt --case 300368.SZ,1d,2026-01-05 --out results/mine

आपको यह दिखना चाहिए:

text
[warn] checkpoint has no ema key, falling back to model weights (step=750)
...
      terminal return actual -18.17%  predicted median -20.77% [q05 -43.96%, q95 +37.47%]  cumulative-return curve corr 0.900  0.4s

पहली लाइन की चेतावनी सामान्य है: हमने पैरामीटर EMA नहीं किया, इसलिए स्क्रिप्ट मॉडल के अपने वेट इस्तेमाल करती है।

आधिकारिक मॉडल के उसी उदाहरण पर प्रेडिक्शन से तुलना करें (पहला प्रेडिक्शन वाला पाठ): रेंज −37% से −6% थी। आपका छोटा मॉडल −44% से +37% की रेंज देता है, बहुत ज़्यादा चौड़ी: यह भी मानता है कि गिरावट आएगी, लेकिन खुद पर भरोसा नहीं करता। सिर्फ इस एक उदाहरण से ज़्यादा कुछ नहीं कहा जा सकता; गंभीर तुलना करनी हो तो पिछले अध्याय के infer_for_eval.py --ckpt और cal_metrics.py से पूरे टेस्ट अवधि पर RankIC निकालें।

5. और बेहतर ट्रेन करना चाहें तो ​

  • ज़्यादा डेटा: 100 स्टॉक्स बहुत कम हैं। पेपर में 4800 से ज़्यादा इंस्ट्रूमेंट, दस साल, सात ग्रैन्युलैरिटी हैं।
  • ज़्यादा ग्रैन्युलैरिटी: --scale को 1h, 30m से बदलकर दोबारा ट्रेन करें, या स्क्रिप्ट बदलें ताकि एक batch में कई ग्रैन्युलैरिटी मिली हों।
  • जल्दी रुकें: इस उदाहरण में लगभग 750 कदमों पर रुक जाना चाहिए था। --steps 1000 पर्याप्त है।
  • आधिकारिक वेट से शुरुआत करें: यही अगले सेक्शन का फ़ाइन-ट्यूनिंग है।

6. अभ्यास: पेपर की दो तकनीकें खुद जोड़ें ​

अगर आपने PyTorch सीखा है, तो नीचे दोनों बदलाव सिर्फ कुछ लाइनों के हैं:

  1. पैरामीटर EMA। ओपन-सोर्स वेट EMA वाली ही प्रति है। एक शैडो वेट ema = copy.deepcopy(model) रखें, हर कदम के बाद ema_p.lerp_(p, 1 - 0.999); वैलिडेशन और सेविंग दोनों में ema इस्तेमाल करें। सेव करते समय इसकी state_dict() को चेकपॉइंट की "ema" की में रखें; आधिकारिक लोड फ़ंक्शन इसे पहले पढ़ता है और वह no ema key वाली चेतावनी भी चली जाती है। पेपर 0.9999 इस्तेमाल करता है; छोटे डेटा, छोटी ट्रेनिंग के लिए 0.999 ज़्यादा उपयुक्त है।
  2. सशर्त ड्रॉपआउट (Conditional dropout)। fm_loss में, 10% की संभावना के साथ cond["inst"] और cond["sector"] को 0 पर सेट करें ("नहीं पहचानते"), और 10% की संभावना के साथ इतिहास x_ctx को शून्य कर दें, साथ ही इतिहास खंड के pad_mask को False पर सेट करें (संदर्भ के लिए kit_v1/infer/sampler.py में make_nohist_cond देखें)। पेपर के कॉन्फ़िगरेशन में इसके संगत हैं inst_dropout, allcond_dropout, hist_dropout (0.1, 0.05, 0.1, देखें configs/dit_30m.yaml)। सशर्त ड्रॉपआउट पर प्रशिक्षण के बाद ही अनुमान (inference) के समय --cfg-w और --hist-cfg-w सार्थक होते हैं।

आपकी परीक्षाट्रेनिंग लॉस अभी भी गिर रही है, वैलिडेशन लॉस बढ़ने लगी है, कौन सा चेकपॉइंट इस्तेमाल करें?

एक बार जाँच लें ​

  • मैंने प्रशिक्षण करके runs/scratch-1d/best.pt प्राप्त किया
  • मैं कर्व पर इंगित कर सकता/सकती हूँ कि ओवरफ़िटिंग किस स्टेप से शुरू होती है
  • मैंने अपने चेकपॉइंट से एक प्रेडिक्शन इमेज तैयार की

अगला भाग: आधिकारिक वेट पर फ़ाइनट्यून।

gaodong.aiAboutPrivacyContact

Independent tutorials, not affiliated with any product mentioned. Product names and trademarks belong to their owners. Check official pages for prices and policies.