टिंकर ट्यूटोरियल: थिंकिंग मशीनज़ लैब के साथ LLMs का फाइन-ट्यूनिंग

बड़े भाषा मॉडल्स का फाइन-ट्यूनिंग आम तौर पर डिस्ट्रीब्यूटेड GPU इन्फ्रास्ट्रक्चर, क्लस्टर फेल्योर मैनेजमेंट, और जटिल ट्रेनिंग स्क्रिप्ट्स की डिबगिंग से जूझना होता है। Tinker इसी समस्या का हल है।

Mira Murati की Thinking Machines Lab द्वारा 1 अक्टूबर, 2025 को जारी किया गया Tinker एक ट्रेनिंग API है, जो इन्फ्रास्ट्रक्चर की सारी जटिलता संभालते हुए आपको अपने एल्गोरिद्म और डेटा पर पूरा नियंत्रण देता है। यह चार कोर फ़ंक्शंस के साथ साधारण Python स्क्रिप्ट्स लिखने में सक्षम बनाता है, और Tinker उन्हें Llama 70B या Qwen 235B जैसे विभिन्न ओपन-सोर्स मॉडलों पर डिस्ट्रीब्यूटेड GPUs में चलाता है।

यह प्लेटफ़ॉर्म लागत घटाने के लिए Low-Rank Adaptation (LoRA) फाइन-ट्यूनिंग का उपयोग करता है और सुपरवाइज़्ड लर्निंग से लेकर रिइनफोर्समेंट लर्निंग तक सबका समर्थन करता है। Princeton, Stanford और Berkeley की रिसर्च टीमें पहले से ही अपने काम के लिए इसका उपयोग कर रही हैं।

इस ट्यूटोरियल में, मैं आपको Tinker इंस्टॉल करने, उसकी API समझने और Qwen3-8B बेस मॉडल का उपयोग कर एक संपूर्ण वित्तीय Q&A मॉडल को फाइन-ट्यून करने की प्रक्रिया से गुजरूँगा। अगर आप फाइन-ट्यूनिंग को हाथों-हाथ सीखना चाहते हैं, तो मैं Fine-Tuning with Llama 3 कोर्स देखने की सलाह देता हूँ।

Tinker क्या है?

Thinking Machines Lab ने Tinker उन लोगों के लिए बनाया है जो यह कस्टमाइज़ करना चाहते हैं कि मॉडल्स कैसे सीखें—वह भी इन्फ्रास्ट्रक्चर एक्सपर्ट बने बिना।

कौन Tinker का उपयोग करता है?

यह प्लेटफ़ॉर्म तीन समूहों को टार्गेट करता है: 

• नए प्रशिक्षण तरीकों की खोज करने वाले शोधकर्ता
• ऐसे डेवलपर्स जो कस्टम बिहेवियर वाले AI प्रोडक्ट्स बना रहे हैं
• ऐसे बिल्डर्स जो एंटरप्राइज़ संसाधनों के बिना भी प्रोडक्शन-क्वालिटी नतीजे चाहते हैं 

हर समूह की एक समान ज़रूरत है: वे जानते हैं कि वे अपने मॉडल से क्या करवाना चाहते हैं, लेकिन मानक फाइन-ट्यूनिंग इंटरफेस उन्हें पर्याप्त नियंत्रण नहीं देते।

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

इन सभी उपयोग मामलों में साझा बात यह है कि इन्हें केवल डेटासेट बदलने के बजाय प्रशिक्षण प्रक्रिया में बदलाव की ज़रूरत होती है।

Tinker अलग कैसे है?

अधिकांश प्लेटफ़ॉर्म या तो उपयोग में सरलता या लचीलापन, इनमें से किसी एक को प्राथमिकता देते हैं। Tinker का नज़रिया है कि दोनों में टकराव ज़रूरी नहीं। यह प्लेटफ़ॉर्म चार कोर ऑपरेशंस के माध्यम से आपको प्रशिक्षण पर लो-लेवल एक्सेस देता है, जबकि बाकी सब कुछ अपने आप संभालता है:

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

Tinker इन क्षमताओं को चार API प्रिमिटिव्स के माध्यम से एक्सपोज़ करता है, जिन्हें आप आगे के हैंड्स-ऑन सेक्शन में सीखेंगे।

यह इसलिए काम करता है क्योंकि ट्रेनिंग की ज़्यादातर जटिलता इन्फ्रास्ट्रक्चर से आती है, एल्गोरिद्म्स से नहीं। कस्टम ट्रेनिंग लूप को लैपटॉप पर चलाना सरल है। वही काम 100 GPUs पर फेल्योर रिकवरी और रिसोर्स शेड्यूलिंग के साथ चलाना मुश्किल है। Tinker दूसरा हिस्सा संभालता है ताकि आप पहले पर फ़ोकस कर सकें।

Tinker की भूमिका कहाँ फिट होती है

AI टूलिंग इकोसिस्टम मोटे तौर पर तीन लेयर्स में बंटा है: क्लाउड कंप्यूट प्रोवाइडर्स जो रॉ GPUs देते हैं, मैनेज्ड प्लेटफ़ॉर्म्स जो प्री-डिफ़ाइंड वर्कफ़्लोज़ चलाते हैं, और फ़्रेमवर्क्स जो आपको शून्य से ट्रेनिंग सिस्टम बनाने में मदद करते हैं। Tinker मैनेज्ड प्लेटफ़ॉर्म्स और फ़्रेमवर्क्स के बीच बैठता है। आपको Hugging Face AutoTrain जैसे प्लेटफ़ॉर्म्स से ज़्यादा नियंत्रण मिलता है, पर Google Cloud Platform (GCP) पर कस्टम क्लस्टर सेटअप करने जितना इन्फ्रास्ट्रक्चर काम नहीं करना पड़ता।

Tinker की कीमत और क्रेडिट्स

Tinker पारदर्शी प्रति-टोकन प्राइसिंग अपनाता है, जो मॉडल के आकार और ऑपरेशन टाइप के अनुसार बदलता है। Qwen3-8B की ट्रेनिंग का खर्च $0.40 प्रति मिलियन टोकन है। अच्छी बात: वेटलिस्ट से क्लियर होने पर नए यूज़र्स को $150 के क्रेडिट्स मिलते हैं, जो इस ट्यूटोरियल जैसे कई एक्सपेरिमेंटल ट्रेनिंग रन्स के लिए पर्याप्त हैं।

Source: Thinking Machines Lab

Tinker उदाहरण: वित्तीय Q&A के लिए Qwen3-8B का फाइन-ट्यूनिंग

इस सेक्शन में, मैं आपको Tinker की API का उपयोग करके एक संपूर्ण फाइन-ट्यूनिंग वर्कफ़्लो बनाना सिखाऊँगा। हम LoRA का उपयोग करके वित्तीय प्रश्नोत्तर डेटा पर Qwen3-8B को फाइन-ट्यून करेंगे, चारों कोर API प्रिमिटिव्स सीखते हुए और प्रोडक्शन बेस्ट प्रैक्टिसेज़ को एक्शन में देखते हुए।

मॉडल का विस्तृत अवलोकन पाने के लिए, यह Qwen3 पर यह लेख ज़रूर देखें।

महत्वपूर्ण नोट: Tinker वर्तमान में बीटा में है और वेटलिस्ट-आधारित ऐक्सेस देता है। यदि आपके पास ऐक्सेस है, तो आप साथ चलकर कोड चला सकते हैं। अगर आप वेटलिस्ट में हैं, तब भी आप पढ़कर समझ सकते हैं कि Tinker के साथ फाइन-ट्यूनिंग प्रक्रिया कितनी सरल है। ऐक्सेस मिलते ही, आप तुरंत शुरू करने के लिए तैयार होंगे।

ट्रेनिंग परिणाम और चेकपॉइंट चयन

पहले ट्रेनिंग परिणाम देखते हैं। यह समझना कि क्या हुआ, आपको अपने फाइन-ट्यूनिंग जॉब्स में ऐसे पैटर्न पहचानने में मदद करता है।

हमने Qwen3-8B को FinCoT डेटासेट—एक चेन-ऑफ-थॉट वित्तीय रीज़निंग डेटासेट—पर रैंक 32 के LoRA के साथ फाइन-ट्यून किया। 10,000 टोकन से लंबे सीक्वेंस फ़िल्टर करने के बाद, हमारे पास 7,244 ट्रेनिंग उदाहरण और वैलिडेशन के लिए 500 उदाहरण बचे। 

ट्रेनिंग चार epochs में 904 iterations तक चली, लगभग तीन घंटे में पूरी हुई, और इस दौरान Tinker ने सभी डिस्ट्रीब्यूटेड GPU कोऑर्डिनेशन संभाला। 

एक epoch का मतलब है पूरे ट्रेनिंग डेटासेट पर एक बार पूरा पास। चूँकि प्रति epoch 226 बैच थे (7,244 उदाहरण ÷ बैच साइज़ 32), चार epochs मिलाकर कुल 904 iterations हुए।

ट्रेनिंग परिणामों का विश्लेषण

निम्न चार्ट तीन मेट्रिक्स को ट्रैक करता है: ट्रेनिंग लॉस (नीला), वैलिडेशन लॉस (लाल), और लर्निंग रेट (हरा)।

शुरुआती ट्रेनिंग (iterations 0-400) स्वस्थ दिखती है: ट्रेनिंग और वैलिडेशन दोनों लॉस तेज़ी से साथ-साथ घटते हैं, 1.4 से ऊपर से 0.8 से नीचे तक, और एक-दूसरे के लगभग 0.1 के भीतर रहते हैं। 

यह अवधि दिखाती है कि मॉडल डेटा में जनरलाइज़ेबल पैटर्न प्रभावी ढंग से सीख रहा है। लर्निंग रेट (हरी रेखा) पहले 200 iterations में स्मूदली बढ़ती है, क्योंकि वार्मअप ट्रेनिंग को स्थिर करता है। 

लगभग iteration 400-600 के बीच स्थिति बदलती है। ट्रेनिंग लॉस गिरता रहता है, लेकिन वैलिडेशन लॉस 0.75-0.8 के आसपास ठहरता है, गैप 0.13 तक बढ़ता है, जो दर्शाता है कि मॉडल ओवरफिट होने लगता है। iteration 600-900 तक आते-आते डाइवर्जेंस स्पष्ट हो जाता है: ट्रेनिंग लॉस 0.39 तक गिर जाता है जबकि वैलिडेशन लॉस 0.8 तक बढ़ता है, यानी मॉडल ने रीज़निंग पैटर्न सीखने से उदाहरण याद करने की ओर शिफ्ट कर लिया है। 

रीज़निंग मॉडल्स को फाइन-ट्यून करते समय यह पैटर्न आम है। अगर आपको ट्रेनिंग के दौरान रीज़निंग क्षमताएँ कैसे विकसित होती हैं, यह जानने में रुचि है, तो DeepSeek R1 का फाइन-ट्यूनिंग वाला यह ट्यूटोरियल देखें, जो समान डायनेमिक्स की पड़ताल करता है।

checkpoint-400 पर सेव किया गया मॉडल सबसे अच्छा जनरलाइज़ करता है—ट्रेनिंग लॉस 0.68, वैलिडेशन लॉस 0.73, और सिर्फ 0.05 का छोटा गैप। अंतिम चेकपॉइंट की तुलना में ट्रेनिंग लॉस अधिक होने के बावजूद यह नए प्रश्नों को बेहतर तरीके से संभालता है। सबसे कम ट्रेनिंग लॉस शायद ही सबसे अच्छा मॉडल देता है, इसलिए वैलिडेशन मेट्रिक्स मायने रखते हैं।

हम इसे बाद में LLM जज का उपयोग कर checkpoint-400 के मॉडल को बेस मॉडल के विरुद्ध तुलना करके सत्यापित करेंगे। फिलहाल, इस फाइन-ट्यूनिंग वर्कफ़्लो को चरण-दर-चरण बनाना देखते हैं।

चरण 1: Tinker इंस्टॉल करें और अपना वातावरण सेट करें

नोट: निम्न चरण लगभग 300 पंक्तियों की एक स्क्रिप्ट को विभाजित करते हैं। चूँकि व्याख्याएँ कोड के हिस्सों में बुनी गई हैं, हम सुझाव देते हैं कि आप साथ चलते हुए पूरी स्क्रिप्ट एक नए टैब में खोल लें ताकि पूरी तस्वीर दिखे।

आपको Python 3.11 या बाद का संस्करण और एक स्थिर इंटरनेट कनेक्शन चाहिए। क्योंकि Tinker अपने सर्वर्स पर GPU ट्रेनिंग संभालता है, एक अच्छा कनेक्शन, शक्तिशाली कंप्यूटर से अधिक महत्वपूर्ण है।

शुरुआत Tinker कंसोल में साइन इन कर और एक API कुंजी बनाकर करें। इस कुंजी को अपने प्रोजेक्ट डायरेक्टरी में .env फ़ाइल में स्टोर करें:

TINKER_API_KEY=your_key_here

सेटअप हो जाने के बाद, Tinker कंसोल आपके ट्रेनिंग रन्स की मॉनिटरिंग और चेकपॉइंट मैनेजमेंट के लिए आपका केंद्रीय हब बन जाता है।

Tinker कंसोल आपके सभी ट्रेनिंग रन्स को प्रमुख विवरणों के साथ ट्रैक करता है: यूनिक रन IDs, बेस मॉडल, LoRA रैंक, और अंतिम रिक्वेस्ट समय। आप इस इंटरफ़ेस से कई प्रयोगों को खोज, फ़िल्टर और मैनेज कर सकते हैं।

आवश्यक पैकेज इंस्टॉल करें। Tinker के कुछ peer dependencies हैं जो स्वतः इंस्टॉल नहीं होते, इसलिए उन्हें स्पष्ट रूप से निर्दिष्ट करें:

pip install tinker transformers torch datasets python-dotenv numpy

transformers और torch पैकेज टोकनाइज़ेशन और टेन्सर ऑपरेशंस उपलब्ध कराते हैं, जिनका Tinker आंतरिक रूप से उपयोग करता है। datasets लाइब्रेरी Hugging Face से ट्रेनिंग डेटा लोड करने का काम संभालती है।

अब अपने imports और एक retry हेल्पर फ़ंक्शन सेट करें। रिमोट सर्वर्स पर ट्रेनिंग के दौरान आपको अस्थायी कनेक्शन एरर्स दिख सकते हैं, जो ज़रूरी नहीं कि किसी वास्तविक समस्या का संकेत हों। आपका ट्रेनिंग जॉब Tinker के इन्फ्रास्ट्रक्चर पर ठीक चलता रहता है। यह retry wrapper ऐसे अस्थायी फेल्योर को स्वतः हैंडल करता है:

import time
import numpy as np
from dotenv import load_dotenv
from datasets import load_dataset
import tinker
from tinker import types

def with_retry(future, max_attempts=3, delay=5):
    """Simple retry logic for API futures"""
    for attempt in range(max_attempts):
        try:
            return future.result()
        except Exception as e:
            if attempt == max_attempts - 1:
                raise
            time.sleep(delay)

यह फ़ंक्शन Tinker की API से आने वाले एक future ऑब्जेक्ट (ऐसा ऑब्जेक्ट जो अभी पूरा नहीं हुआ ऑपरेशन दर्शाता है) को लेता है और पाँच-पाँच सेकंड के अंतराल पर अधिकतम तीन बार परिणाम पाने की कोशिश करता है। अधिकतर अस्थायी फेल्योर इसी विंडो में सुलझ जाते हैं।

चरण 2: ServiceClient इनिशियलाइज़ करें और डेटासेट लोड करें

ServiceClient Tinker का आपका एंट्री पॉइंट है। यह उपलब्ध मॉडलों को ढूँढता है और ऑथेंटिकेशन संभालता है:

load_dotenv()
service_client = tinker.ServiceClient()

इसके बाद आप इसे ज़्यादा इस्तेमाल नहीं करेंगे। यह मुख्यतः विशिष्ट मॉडलों के लिए ट्रेनिंग और सैंपलिंग क्लाइंट बनाने के लिए मौजूद है।

अब FinCoT डेटासेट लोड करने का समय है।  इसमें वित्तीय प्रश्न, step-by-step रीज़निंग चेन और अंतिम उत्तरों के साथ दिए गए हैं। साधारण Q&A डेटासेट्स के विपरीत, FinCoT मॉडल को उत्तर देने से पहले अपना काम दिखाना सिखाता है—जो वित्तीय सलाहकारी अनुप्रयोगों में महत्वपूर्ण है, जहाँ उपयोगकर्ताओं को सिफारिशों के पीछे की वजह समझनी होती है।

dataset = load_dataset("TheFinAI/FinCoT")

डेटासेट में SFT (supervised fine-tuning) स्प्लिट है जिसमें पूरी रीज़निंग चेन हैं, और RL स्प्लिट है जो रिइनफोर्समेंट लर्निंग के लिए है। ट्रेनिंग के लिए SFT स्प्लिट उपयोग करें और वैलिडेशन के लिए RL स्प्लिट से सैंपल लें ताकि मॉडल अलग-अलग उदाहरणों पर जनरलाइज़ करना सीखे।

train_data_raw = dataset["SFT"]  # 7,686 examples with reasoning chains
val_data_raw = dataset["RL"].shuffle(seed=42).select(range(500))  # 500 validation examples

print(f"Loaded {len(train_data_raw)} training examples")
print(f"Loaded {len(val_data_raw)} validation examples")

चरण 3: अपना LoRA ट्रेनिंग क्लाइंट बनाएं

अब Qwen3-8B के लिए एक LoRA ट्रेनिंग क्लाइंट बनाएं:

training_client = service_client.create_lora_training_client(
    base_model="Qwen/Qwen3-8B",
    rank=32
)

आइए समझते हैं यहाँ क्या हो रहा है:

• Qwen/Qwen3-8B: यह 8 बिलियन पैरामीटर्स वाला मॉडल है—वास्तविक टास्क्स के लिए पर्याप्त शक्तिशाली, फिर भी ट्रेन करने में कुशल। सीखने के लिए अच्छा संतुलन है। आप Tinker के मॉडल लाइनअप में उपलब्ध सभी मॉडल्स देख सकते हैं।
• LoRA (Low-Rank Adaptation): सारे 8 बिलियन पैरामीटर्स अपडेट करने के बजाय, LoRA छोटे “एडॉप्टर” लेयर्स ट्रेन करता है जो बेस मॉडल के व्यवहार को संशोधित करते हैं। इसे ऐसे समझें जैसे आप पूरे कैमरे को दुबारा बनाने के बजाय उस पर कस्टम लेंस जोड़ रहे हों। बेस मॉडल Tinker के सर्वर्स पर फ़्रीज़ रहता है; आप केवल इन छोटे एडॉप्टर्स को ट्रेन करते हैं।
• rank=32: यह नियंत्रित करता है कि आपके LoRA एडॉप्टर्स में कितने ट्रेन करने योग्य पैरामीटर्स होंगे। 5,000-10,000 उदाहरणों वाले डेटासेट्स के लिए 32 अच्छा काम करता है। बड़े डेटासेट्स के लिए rank=64 या rank=128 की ज़रूरत पड़ सकती है।

LoRA गणितीय रूप से कैसे काम करता है और rank पैरामीटर्स कैसे ट्यून करें, इस पर गहराई से जानने के लिए Tinker का LoRA प्राइमर या DataCamp की लो-रैंक एडॉप्टेशन गाइड देखें।

भाषा मॉडल सीधे शब्दों पर काम नहीं करते। वे “टोकन्स” पर काम करते हैं, जो टेक्स्ट के हिस्से दर्शाते हैं। एक टोकनाइज़र टेक्स्ट को इन हिस्सों में तोड़ता है। उदाहरण के लिए, “financial” एक टोकन हो सकता है, जबकि “understanding” “under” और “standing” में बँट सकता है। 

टोकनाइज़र टेक्स्ट को संख्याओं (टोकन IDs) में बदलता है जिन्हें मॉडल प्रोसेस कर सके। ट्रेनिंग क्लाइंट से टोकनाइज़र लेने पर आप वही टोकनाइज़ेशन उपयोग करेंगे जिसकी Qwen3-8B अपेक्षा करता है।

tokenizer = training_client.get_tokenizer()

चरण 4: डेटा को Tinker के फ़ॉर्मैट में बदलें

Tinker को आपका ट्रेनिंग डेटा types.Datum नामक फ़ॉर्मैट में चाहिए। यह फ़ॉर्मैट मॉडल इनपुट को loss फ़ंक्शन कॉन्फ़िगरेशन से अलग करता है, जिससे आपको यह नियंत्रित करने में सटीकता मिलती है कि कौन-से टोकन ट्रेनिंग में योगदान दें।

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

• प्रॉम्प्ट टोकन (प्रश्न): वेट = 0.0 (इनसे न सीखें)
• कम्प्लीशन टोकन (उत्तर): वेट = 1.0 (इनसे सीखें)

डेटा ट्रांसफ़ॉर्मेशन फ़ंक्शन चरण-दर-चरण बनाते हैं। फ़ंक्शन सिग्नेचर से शुरू करें:

def prepare_datum(example, max_length=10000):

Qwen3 के चैट टेम्पलेट से वार्तालाप फ़ॉर्मैट करें

अलग-अलग मॉडल मल्टी-टर्न वार्तालापों के लिए अलग फ़ॉर्मैटिंग की अपेक्षा करते हैं। Qwen3 संदेश सीमाओं को चिह्नित करने के लिए <|im_start|> और <|im_end|> जैसे विशेष टोकन उपयोग करता है। प्रत्येक संदेश को “observation” हिस्सों (role हेडर्स) और “action” हिस्सों (वास्तविक सामग्री) में बाँटें:

   # Qwen3 chat format - split into observation and action parts
    user_ob = "<|im_start|>user\n"
    user_ac = f"{example['Question']}<|im_end|>"
    
    assistant_ob = "\n<|im_start|>assistant\n"
    # Include both reasoning process AND final answer
    assistant_ac = f"{example['Reasoning_process']}\n\nFinal Answer: {example['Final_response']}<|im_end|>"

FinCoT डेटासेट स्ट्रक्चर्ड रीज़निंग देता है, इसलिए हम Reasoning_process और Final_response फ़ील्ड्स को जोड़ते हैं। यह मॉडल को उत्तर देने से पहले अपना काम दिखाना सिखाता है।

प्रत्येक हिस्से को अलग-अलग टोकनाइज़ करें 

जहाँ वेट्स लागू होने चाहिए, इसे ट्रैक करने के लिए संदेश के प्रत्येक हिस्से को अलग-अलग टोकनाइज़ करना ज़रूरी है।

   # Tokenize each part separately to track weight boundaries
    user_ob_tokens = tokenizer.encode(user_ob, add_special_tokens=False)
    user_ac_tokens = tokenizer.encode(user_ac, add_special_tokens=False)
    assistant_ob_tokens = tokenizer.encode(assistant_ob, add_special_tokens=False)
    assistant_ac_tokens = tokenizer.encode(assistant_ac, add_special_tokens=False)
    
    # Combine all tokens
    all_tokens = user_ob_tokens + user_ac_tokens + assistant_ob_tokens + assistant_ac_tokens

बहुत लंबे सीक्वेंस फ़िल्टर करें

कुछ FinCoT उदाहरणों में अत्यधिक विस्तृत रीज़निंग चेन होती हैं जो Qwen3-8B की आरामदायक कॉन्टेक्स्ट विंडो से अधिक हैं। तकनीकी रूप से मॉडल 32,768 टोकन सपोर्ट करता है, पर बहुत लंबे सीक्वेंस ट्रेनिंग अस्थिरता पैदा कर सकते हैं:

   # Check if sequence exceeds max length
    if len(all_tokens) > max_length:
        return None  # Skip this example

10,000 टोकन से ऊपर के उदाहरणों को फ़िल्टर करने से केवल 5-6% डेटा हटता है, जबकि ट्रेनिंग की विश्वसनीयता काफी बढ़ जाती है।

यह नियंत्रित करने के लिए वेट्स असाइन करें कि मॉडल किससे सीखे

प्रश्न के लिए वेट 0.0 सेट करें (ताकि मॉडल प्रश्न प्रेडिक्ट करना न सीखे) और उत्तर के लिए 1.0 (ताकि वह अच्छे उत्तर जनरेट करना सीखे):

   # Weights: only train on assistant's answer (action part)
    weights = np.array(
        [0.0] * len(user_ob_tokens) +
        [0.0] * len(user_ac_tokens) +
        [0.0] * len(assistant_ob_tokens) +
        [1.0] * len(assistant_ac_tokens)
    )

नेक्स्ट-टोकन प्रेडिक्शन के लिए टोकन और वेट्स शिफ्ट करें

भाषा मॉडल किसी सीक्वेंस में अगला टोकन प्रेडिक्ट करते हैं। जब मॉडल टोकन 0-9 देखता है, तो उसे टोकन 10 प्रेडिक्ट करना चाहिए। इसलिए आपके टार्गेट हमेशा इनपुट से एक पोजीशन आगे शिफ्ट होते हैं:

   # CRITICAL: Shift tokens AND weights for next-token prediction
    input_tokens_model = all_tokens[:-1]
    target_tokens = all_tokens[1:]
    weights_shifted = weights[1:]

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

फ़ॉर्मैट किया हुआ डेटा रिटर्न करें

अंत में, prepare_datum() फ़ंक्शन फ़ॉर्मैट किया हुआ डेटा लौटाता है, जो प्रोसेसिंग के लिए तैयार है।

   return types.Datum(
        model_input=types.ModelInput.from_ints(tokens=input_tokens_model),
        loss_fn_inputs=dict(weights=weights_shifted, target_tokens=target_tokens),
    )

परिभाषित फ़ंक्शन को रॉ ट्रेनिंग और वैलिडेशन सबसेट्स पर लागू करके, अब हम पूरे डेटासेट को प्रोसेस कर सकते हैं:

# Process and filter training data
training_data_raw = [prepare_datum(example) for example in train_data_raw]
training_data = [d for d in training_data_raw if d is not None]
skipped = len(train_data_raw) - len(training_data)

print(f"Processed {len(training_data)} examples (skipped {skipped} too-long sequences)")
# Output: Processed 7,244 examples (skipped 442 too-long sequences)

# Process validation data
val_data_raw_processed = [prepare_datum(example) for example in val_data_raw]
val_data = [d for d in val_data_raw_processed if d is not None]

print(f"Validation set: {len(val_data)} examples")

चरण 5: ट्रेनिंग लूप के साथ मॉडल ट्रेन करें

ट्रेनिंग लूप Tinker के दो कोर API प्रिमिटिव्स का उपयोग करता है: forward_backward और optim_step। ओवरफिटिंग जल्दी पकड़ने के लिए वैलिडेशन ट्रैकिंग के साथ इसे चरण-दर-चरण बनाते हैं।

वैलिडेशन लॉस फ़ंक्शन परिभाषित करें

पहले, वैलिडेशन लॉस फ़ंक्शन परिभाषित करें। ट्रेनिंग लॉस के विपरीत, वैलिडेशन लॉस बताता है कि आपका मॉडल अनदेखे डेटा पर कितना अच्छा जनरलाइज़ करता है। ओवरफिटिंग पकड़ने के लिए यह महत्वपूर्ण है।

def compute_validation_loss(val_data, batch_size=100):
    """Compute loss on validation set (forward only, no backward)"""
    batch_indices = np.random.choice(
        len(val_data), size=min(batch_size, len(val_data)), replace=False
    )
    batch = [val_data[i] for i in batch_indices]
    
    # Forward pass only (no backward!)
    fwd_future = training_client.forward(batch, loss_fn="cross_entropy")
    fwd_result = with_retry(fwd_future)
    
    # Calculate per-token loss
    loss_sum = fwd_result.metrics["loss:sum"]
    total_completion_tokens = sum(
        np.sum(np.array(val_data[i].loss_fn_inputs["weights"].data) > 0)
        for i in batch_indices
    )
    return loss_sum / total_completion_tokens if total_completion_tokens > 0 else 0

forward() मेथड बिना ग्रेडिएंट्स कैलकुलेट किए loss गणना करता है, जो इवैल्यूएशन के लिए कुशल है जहाँ आपको वज़न अपडेट नहीं करने, सिर्फ़ प्रदर्शन नापने की ज़रूरत होती है। वैलिडेशन लॉस निकालना न्यूनतम ओवरहेड जोड़ता है (सिर्फ़ फॉरवर्ड पास, कोई ग्रेडिएंट नहीं), पर यह जल्द चेतावनी देता है जब ट्रेनिंग और वैलिडेशन लॉस के बीच का गैप 0.2 से अधिक हो, जो बताता है कि आपका मॉडल सीखने के बजाय याद कर रहा है।

ट्रेनिंग पैरामीटर्स कॉन्फ़िगर करें

हमें epochs की संख्या और learning rate तय करनी है। LoRA को फुल फाइन-ट्यूनिंग की तुलना में कहीं अधिक learning rates चाहिए होती हैं—आमतौर पर 10-20 गुना बड़ी।

# Training configuration
n_samples = len(training_data)  # 7,244
n_epochs = 4  # More epochs for smaller dataset
batch_size = 32

# Calculate optimal LR for Qwen3-8B with LoRA
# Formula: base_lr * lora_multiplier * (2000 / hidden_size) ** exponent
# For Qwen: base=5e-5, multiplier=10, hidden_size=4096, exponent=0.0775
learning_rate = 5e-5 * 10.0 * (2000 / 4096) ** 0.0775  # ≈ 4.7e-4

यह फ़ॉर्मूला मॉडल साइज़ (Qwen3-8B का hidden size 4,096 है) को ध्यान में रखता है और उन अनुभवजन्य घातांकों का उपयोग करता है जो मॉडल परिवार के अनुसार बदलते हैं, जैसा कि Tinker कुकबुक में दस्तावेज़ित है। Qwen मॉडलों के लिए एक्स्पोनेंट 0.0775 है, जबकि Llama मॉडलों के लिए 0.781। हमारे मामले में, इससे ~4.7e-4 के आसपास का learning rate मिलता है, जो ग्रेडिएंट एक्सप्लोज़न के बिना स्थिर कन्वर्जेन्स देता है।

लर्निंग रेट वार्मअप सेट करें

शुरू से पूरा learning rate लेने पर, शुरुआती ट्रेनिंग में ग्रेडिएंट एक्सप्लोज़न हो सकते हैं जब मॉडल अभी टास्क के अनुरूप नहीं हुआ होता। वार्मअप पहले 200 iterations में learning rate को लगभग शून्य से टार्गेट वैल्यू तक धीरे-धीरे बढ़ाता है। इसे आप पहले दिखी ट्रेनिंग विज़ुअलाइज़ेशन में साफ़ देख सकते हैं, जहाँ learning rate (हरी रेखा) पहले 200 iterations में स्मूदली बढ़ती है।

# Warmup configuration
warmup_steps = 200

# Calculate iterations from epochs
num_iterations = n_epochs * (n_samples // batch_size)  # 4 * 226 = 904
checkpoint_interval = 200
validation_interval = 50

ट्रेनिंग लूप शुरू करें

लॉसेस ट्रैक करने के लिए सूचियाँ इनिशियलाइज़ करने के बाद, हम ट्रेनिंग लूप शुरू कर सकते हैं:

losses = []
per_token_losses = []
val_losses = []

for iteration in range(num_iterations):
    # Sample random batch
    batch_indices = np.random.choice(len(training_data), size=batch_size, replace=False)
    batch = [training_data[i] for i in batch_indices]
    
    # Apply learning rate warmup
    if iteration < warmup_steps:
        current_lr = learning_rate * (iteration + 1) / warmup_steps
    else:
        current_lr = learning_rate

वार्मअप लॉजिक पहले 200 iterations में learning rate को धीरे-धीरे स्केल करता है, जिससे शुरुआती अस्थिरता से बचाव होता है।

Tinker के कोर ट्रेनिंग प्रिमिटिव्स कॉल करें

हर iteration में, Tinker के कोर प्रिमिटिव्स इस तरह कॉल होते हैं:

   # API Primitive 1: forward_backward - compute gradients
    fwdbwd_future = training_client.forward_backward(batch, loss_fn="cross_entropy")

    # API Primitive 2: optim_step - update parameters
    optim_future = training_client.optim_step(types.AdamParams(learning_rate=current_lr))

    # Wait for results with retry logic
    fwdbwd_result = with_retry(fwdbwd_future)
    optim_result = with_retry(optim_future)

forward_backward ग्रेडिएंट्स कैलकुलेट करता है—यानी मॉडल की भविष्यवाणियाँ कितनी गलत हैं और हर पैरामीटर को किस दिशा में समायोजित करना है। यह cross-entropy loss का उपयोग करता है, जो यह मापता है कि मॉडल की भविष्यवाणी की गई प्रॉबैबिलिटी डिस्ट्रीब्यूशन वास्तविक अगले टोकन्स से कितनी मेल खाती है। optim_step Adam optimizer का उपयोग कर उन ग्रेडिएंट्स के आधार पर मॉडल पैरामीटर्स अपडेट करता है।

ध्यान दें कि दोनों मेथड्स तुरंत “future” ऑब्जेक्ट्स लौटाते हैं। इससे Tinker कई ऑपरेशंस को एक साथ प्रोसेस कर पाता है, जिससे स्पीड बढ़ती है। with_retry(future) कॉल करने पर वही ऑपरेशन पूरा होने का इंतजार होता है।

लॉस मेट्रिक्स ट्रैक और प्रदर्शित करें

हम कुल और प्रति-टोकन दोनों तरह के लॉसेस की गणना करते हैं और उन्हें सूचियों में जोड़ते हैं:

   # Track loss
    loss_sum = fwdbwd_result.metrics["loss:sum"]
    total_completion_tokens = sum(
        np.sum(np.array(training_data[i].loss_fn_inputs["weights"].data) > 0)
        for i in batch_indices
    )
    per_token_loss = loss_sum / total_completion_tokens

    losses.append(loss_sum)
    per_token_losses.append(per_token_loss)

    if iteration % 10 == 0:
        warmup_indicator = "🔥" if iteration < warmup_steps else ""
        print(f"{warmup_indicator} Iteration {iteration} | Train: {per_token_loss:.4f} | LR: {current_lr:.6f}")

पर-टोकन लॉस उत्तर टोकन्स की संख्या से loss को normalize करता है, जिससे अलग बैच साइज़ पर समझना आसान होता है। एक अच्छी ट्रेनिंग आमतौर पर ~1.2-1.5 पर शुरू होती है और checkpoint-400 तक 0.8 से नीचे आ जाती है। अगर आपका लॉस 2.0 से ऊपर शुरू होता है या 50 iterations के बाद भी नहीं घटता, तो अपने डेटा प्रेप और learning rate की जाँच करें।

पериऑडिक वैलिडेशन चेक्स और चेकपॉइंट्स जोड़ें

हर 200 iterations पर वेट्स सेव करने से ऐसे स्नैपशॉट बनते हैं जिनकी आप तुलना कर सकते हैं। जैसा कि आपने पहले ट्रेनिंग परिणामों में देखा, checkpoint-400 अंतिम चेकपॉइंट से बेहतर जनरलाइज़ करता है, भले ही उसका ट्रेनिंग लॉस अधिक हो। हमेशा कई चेकपॉइंट्स सेव करें और उन्हें होल्ड-आउट डेटा पर इवैल्यूएट करें। स्क्रिप्ट के खत्म होने के बाद भी चेकपॉइंट्स Tinker के सर्वर्स पर बने रहते हैं।

   # Compute validation loss periodically
    if iteration % validation_interval == 0:
        val_loss = compute_validation_loss(val_data)
        val_losses.append((iteration, val_loss))
        gap = val_loss - per_token_loss
        print(f"  📊 Iteration {iteration} | Train: {per_token_loss:.4f} | Val: {val_loss:.4f} | Gap: {gap:+.4f}")

    # Checkpoint every 200 iterations
    if iteration > 0 and iteration % checkpoint_interval == 0:
        training_client.save_weights_for_sampler(name=f"fincot-checkpoint-{iteration}")

Tinker चेकपॉइंट्स को दो श्रेणियों में व्यवस्थित करता है: फुल-स्टेट चेकपॉइंट्स (इंटरप्शन होने पर ट्रेनिंग फिर से शुरू करने के लिए) और सैंपलर वेट्स (इंफ़रेंस के लिए हल्के चेकपॉइंट)। ध्यान दें कि checkpoint-400 दोनों फ़ॉर्मैट्स में दिखता है, जिससे ट्रेनिंग जारी रखना और मॉडल डिप्लॉय करना—दोनों आसान हैं।

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

इन मेथड्स पर पूरी API रेफ़रेंस के लिए Tinker की ट्रेनिंग और सैंपलिंग डाक्यूमेंटेशन देखें।

चरण 6: अपना फाइन-ट्यून किया हुआ मॉडल सेव करें

ट्रेनिंग पूरी होने के बाद, अंतिम मॉडल वेट्स सेव करें:

sampling_client = training_client.save_weights_and_get_sampling_client(
    name="financial-qa-qwen3-8b-lora"
)

वेट्स आपके कंप्यूटर पर नहीं, Tinker के सर्वर्स पर सेव होते हैं। LoRA एडॉप्टर्स आमतौर पर कुछ दसियों मेगाबाइट्स ही लेते हैं। यदि आप मॉडल को उनकी इन्फ्रास्ट्रक्चर के बाहर डिप्लॉय करना चाहते हैं, तो Tinker उन्हें बाहरी इंफ़रेंस प्रोवाइडर्स के लिए एक्सपोर्ट भी कर सकता है।

चरण 7: नमूना प्रश्नों से मॉडल का परीक्षण करें

अंत में, sample API प्रिमिटिव का उपयोग कर अपने फाइन-ट्यून किए मॉडल का परीक्षण करें। पहले, सैंपलिंग पैरामीटर्स कॉन्फ़िगर करें:

sampling_params = types.SamplingParams(
    max_tokens=200,
    temperature=0.7,
    top_p=0.9,
    stop_sequences=["<|im_end|>"]
)

इन पैरामीटर्स का अर्थ:

• max_tokens: जनरेटेड उत्तर की अधिकतम लंबाई (200 टोकन लगभग 150 शब्द होते हैं)।

• temperature: जनरेशन में रैंडमनेस नियंत्रित करता है। कम वैल्यू (0.1-0.5) आउटपुट को अधिक केंद्रित और नियतात्मक बनाती हैं; अधिक वैल्यू (0.7-1.0) अधिक रचनात्मकता देती हैं। 0.7 संतुलित विकल्प है।

• top_p (न्यूक्लियस सैंपलिंग): सिर्फ़ उन सबसे छोटे टोकन्स सेट पर विचार करता है जिनकी सामूहिक प्रॉबैबिलिटी इस मान से अधिक हो। 0.9 का मतलब है “सिर्फ़ उन टोकन्स पर विचार करें जो मिलकर 90% प्रॉबैबिलिटी मास कवर करते हैं।” इससे बहुत कम संभावना वाले टोकन्स चुनने से बचाव होता है।

• stop_sequences: मॉडल को बताता है कि इस सीक्वेंस पर पहुँचते ही जनरेशन रोक दे। <|im_end|> एंड-ऑफ-सीक्वेंस मार्कर है।

टेस्ट प्रश्नों के लिए जवाब जनरेट करें:

questions = [
    "What are the main risks associated with investing in stocks?",
    "How does diversification help reduce portfolio risk?"
]

for question in questions:
    model_input = types.ModelInput.from_ints(tokenizer.encode(question))

    response = with_retry(
        sampling_client.sample(
            prompt=model_input,
            num_samples=1,
            sampling_params=sampling_params
        )
    )

    answer = tokenizer.decode(response.sequences[0].tokens)
    print(f"Q: {question}")
    print(f"A: {answer}\n")

फाइन-ट्यून किए गए मॉडल के दो उदाहरण आउटपुट यहाँ हैं (चित्रण के लिए ट्रंकेटेड):

Q: What are the main risks associated with investing in stocks?
A: Investing in stocks carries several key risks. Market risk represents the potential for stock prices to decline due to economic downturns or market volatility. Company-specific risk arises from poor management decisions, competitive pressures, or operational failures that affect individual stocks. Liquidity risk occurs when you cannot sell shares quickly without significantly impacting the price. Additionally, investors face inflation risk, where returns may not keep pace with rising prices...

Q: How does diversification help reduce portfolio risk?
A: Diversification reduces portfolio risk by spreading investments across different asset classes, sectors, and geographic regions. When you hold multiple uncorrelated assets, losses in one investment can be offset by gains in others. For example, if technology stocks decline but healthcare stocks rise, a diversified portfolio experiences less volatility than one concentrated in technology alone. The key principle is that different assets respond differently to market conditions...

response ऑब्जेक्ट में sequences लिस्ट होती है क्योंकि आप प्रति प्रॉम्प्ट कई सैंपल्स माँग सकते हैं। sequences[0].tokens के ज़रिए टोकन्स एक्सेस करें और उसी टोकनाइज़र से उन्हें टेक्स्ट में डिकोड करें।

आपने अब चारों कोर API प्रिमिटिव्स सफलतापूर्वक डेमो कर दिए हैं:

1. forward_backward: अपने ट्रेनिंग डेटा से ग्रेडिएंट्स कैलकुलेट करें

2. optim_step: Adam optimizer से मॉडल पैरामीटर्स अपडेट करें

3. save_weights_and_get_sampling_client: अपने फाइन-ट्यून मॉडल को परसिस्ट करें

4. sample: फाइन-ट्यून मॉडल से प्रेडिक्शंस जनरेट करें

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

पर आपको कैसे पता चले कि फाइन-ट्यूनिंग ने वाकई प्रदर्शन सुधारा है? सब्जेक्टिव इम्प्रेशन पर निर्भर होने के बजाय कड़ी इवैल्यूएशन चाहिए। अगले सेक्शन में, आप LLM-as-judge इवैल्यूएशन के परिणाम देखेंगे, जो 10 विविध वित्तीय प्रश्नों पर फाइन-ट्यून मॉडल की तुलना बेस Qwen3-8B से करता है।

LLM जज के साथ फाइन-ट्यून मॉडल का मूल्यांकन

प्रदर्शन को निष्पक्ष रूप से मापने के लिए, हमने LLM-as-judge अपनाया: GPT-4o ने 10 विविध वित्तीय प्रश्नों पर checkpoint-400 की तुलना बेस Qwen3-8B से की, और हर उत्तर को accuracy, clarity, completeness, और financial terminology पर स्कोर किया।

फाइन-ट्यून मॉडल ने 8.5/10 स्कोर किया, जबकि बेस मॉडल 6.5 रहा—और सभी 10 तुलनाएँ जीतीं। फ़ैसले बताते हैं क्यों: यह आत्मविश्वासी, संरचित रीज़निंग के साथ संपूर्ण व्याख्याएँ देता है, जबकि बेस मॉडल “I think” और “maybe” जैसे हेजिंग के साथ विचार अधूरे छोड़ देता है।

यह checkpoint-400 के बेहतर वास्तविक-विश्व प्रदर्शन की पुष्टि करता है। iteration 900 पर कम ट्रेनिंग लॉस हमें रीज़निंग नहीं, याद करना देता।

इसी तरह के इवैल्यूएशन अपनी मॉडलों पर चलाने के लिए तुलना स्क्रिप्ट और विस्तृत परिणाम देखें।

निष्कर्ष

आपने देखा कि Tinker कैसे नियंत्रण खोए बिना फाइन-ट्यूनिंग को सरल बनाता है। चार कोर API प्रिमिटिव्स—forward_backward, optim_step, save_weights_and_get_sampling_client, और sample—कस्टम ट्रेनिंग वर्कफ़्लो बनाने के बिल्डिंग ब्लॉक्स देते हैं, जबकि Tinker डिस्ट्रीब्यूटेड इन्फ्रास्ट्रक्चर संभालता है।

जो वित्तीय Q&A मॉडल हमने बनाया, वह बेहतरीन प्रोडक्शन प्रैक्टिसेज़ दर्शाता है: वैलिडेशन ट्रैकिंग ने ओवरफिटिंग जल्दी पकड़ ली, checkpoint-400 ने जनरलाइज़ेशन पर ध्यान देकर अंतिम मॉडल से बेहतर प्रदर्शन किया, और LLM-as-judge इवैल्यूएशन ने बेस मॉडल पर 2-पॉइंट सुधार की पुष्टि की। ये पैटर्न 8B से 70B पैरामीटर मॉडलों तक लागू होते हैं।

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

अगला कदम? अपने डोमेन-विशिष्ट डेटा पर फाइन-ट्यून करें, अलग-अलग LoRA रैंक्स और learning rates के साथ प्रयोग करें, या मानव फ़ीडबैक से रिइनफोर्समेंट लर्निंग जैसे उन्नत पैरेडाइम्स एक्सप्लोर करें। Tinker कुकबुक में इन परिदृश्यों के उदाहरण हैं। अभी से अपने उपयोग मामले पर सोचें—आप अपने मॉडल को कौन-सा व्यवहार सिखाना चाहते हैं?

यदि आप प्रोडक्शन के लिए नवीनतम AI मॉडलों के प्रशिक्षण और फाइन-ट्यूनिंग में व्यापक कौशल विकसित करना चाहते हैं, तो Associate AI Engineer for Developers करियर ट्रैक ज़रूर देखें।