Flux और Stable Diffusion जैसे ओपन सोर्स AI मॉडल अपने आप पूरी तरह तैयार होकर नहीं आए। इन्हें महीनों के डेटा संग्रह, बार-बार चलने वाले ट्रेनिंग लूप और बहुत बड़े पैमाने के हार्डवेयर से बनाया गया। यह लेख बताता है कि यह प्रक्रिया असल में कैसे काम करती है, कोई मॉडल सच में ओपन कैसे होता है, और वही ट्रेन किए गए वेट्स आज आप जिन AI इमेज टूल्स का इस्तेमाल करते हैं उन्हें कैसे चलाते हैं।
जब आप किसी AI इमेज जेनरेटर में प्रॉम्प्ट लिखते हैं और कुछ सेकंड में फोटोरियलिस्टिक इमेज सामने आ जाती है, तो यह भूलना आसान है कि वह मॉडल शुरू में इतना सक्षम नहीं था। वह एक खाली स्लेट की तरह शुरू हुआ था, अरबों रैंडम नंबरों के रूप में, और एक ऐसी प्रक्रिया से उसे उपयोगी बनाया गया जिसमें महीनों लगे, हज़ारों GPU लगे और पेटाबाइट्स डेटा लगा। इस प्रक्रिया को ट्रेनिंग कहते हैं, और ओपन सोर्स AI मॉडल के लिए यह ऐसी प्रक्रिया है जिसे सिद्धांत रूप में कोई भी दोहरा सकता है, जाँच सकता है या आगे बढ़ा सकता है।
यह लेख बताता है कि ओपन सोर्स AI मॉडल असल में कैसे ट्रेन होते हैं, कच्चे डेटा के संग्रह से लेकर अंतिम वेट्स के समुदाय के हाथों तक पहुँचने तक।
ट्रेनिंग शुरू होने से पहले एक न्यूरल नेटवर्क सिर्फ़ संख्यात्मक पैरामीटर्स का एक बड़ा संग्रह होता है, जिन्हें वेट्स कहते हैं। इनिशियलाइज़ेशन के समय ये वेट्स आम तौर पर रैंडम होते हैं। नेटवर्क को नहीं पता होता कि बिल्ली कैसी दिखती है, व्याकरण क्या होता है, या इमेज का अगला पिक्सल कैसे अनुमानित किया जाए। यह सब ज्ञान डेटा के संपर्क से आता है।
ट्रेनिंग का मतलब है इन वेट्स को लाखों इटरेशन तक लगातार एडजस्ट करना, जब तक मॉडल भरोसेमंद ढंग से उपयोगी आउटपुट न देने लगे। इसे बार-बार दोहराकर सीखने जैसा समझें, बस फर्क यह है कि "सीखने वाला" इंसानी दिमाग नहीं, बल्कि एक गणितीय फंक्शन है जिसमें अरबों एडजस्ट होने वाले नॉब होते हैं।
ट्रेनिंग में सबसे अहम चीज़ आर्किटेक्चर या हार्डवेयर नहीं, बल्कि डेटा है। मॉडल उतना ही अच्छा होता है जितना उसे दिखाया गया। अगर डेटासेट पक्षपाती, अधूरा या कम गुणवत्ता वाला है, तो उसकी खामियाँ सीधे मॉडल के व्यवहार में बैठ जाती हैं।
Flux Dev या Stable Diffusion जैसे इमेज जेनरेशन मॉडल के लिए ट्रेनिंग डेटा सैकड़ों मिलियन इमेज-टेक्स्ट जोड़ों से बना होता है: सूर्यास्त की एक फोटो के साथ कैप्शन "समुद्र के ऊपर गोल्डन आवर", और इसी तरह। इन जोड़ों को पर्याप्त संख्या में देखकर मॉडल विज़ुअल कंटेंट को भाषा से जोड़ना सीखता है।
बड़े ओपन सोर्स AI मॉडल के ज़्यादातर ट्रेनिंग डेटा वेब क्रॉल से आते हैं। Common Crawl जैसे प्रोजेक्ट अरबों वेब पेज स्क्रैप करते हैं और यह डेटा रिसर्च और कमर्शियल उपयोग के लिए उपलब्ध कराते हैं। खासकर इमेज मॉडल के लिए, LAION-5B जैसे डेटासेट इंटरनेट से इमेज-टेक्स्ट जोड़े इकट्ठा करते हैं, जो बड़े पैमाने पर मॉडल ट्रेन करने का कच्चा माल देते हैं।
सार्वजनिक वेब क्रॉल के साथ-साथ संस्थाएँ स्टॉक फोटो लाइब्रेरी, वैज्ञानिक प्रकाशनों और क्यूरेटेड रिपॉज़िटरी से लाइसेंस्ड डेटासेट का उपयोग भी बढ़ा रही हैं। ट्रेनिंग डेटा से जुड़े कानूनी परिदृश्य के बदलते रहने के कारण यह पहले से कहीं ज़्यादा मायने रखता है।
नोट: इंटरनेट पर मिलने वाला हर डेटा ट्रेनिंग के लिए कानूनी रूप से उपलब्ध नहीं होता। ओपन सोर्स मॉडल इस बात में काफ़ी अलग हैं कि वे अपने डेटा के स्रोत के बारे में कितने पारदर्शी हैं, और कानूनी चुनौतियाँ बढ़ने के साथ यह पारदर्शिता का अंतर भी बढ़ रहा है।
बड़े डेटासेट अपने आप बेहतर मॉडल नहीं बनाते। Stability AI और Black Forest Labs (जो Flux Schnell और Flux Pro के पीछे की टीम है) के शोधकर्ताओं ने लगातार पाया है कि कम गुणवत्ता वाली इमेज हटाना, डुप्लिकेट हटाना और सब्जेक्ट के बीच प्रतिनिधित्व को संतुलित रखना, बस और डेटा जोड़ने की तुलना में कहीं बेहतर आउटपुट देता है।
डेटा क्यूरेशन अपने आप में एक अलग अनुशासन है। एनोटेटर्स की टीमें और ऑटोमेटेड फ़िल्टरिंग पाइपलाइन इस बात पर काफ़ी मेहनत करती हैं कि ट्रेनिंग लूप में जो जाए, वह सच में ट्रेनिंग के लायक हो।
डेटा तैयार होने के बाद ट्रेनिंग एक लगातार चलने वाले लूप में होती है। हर इटरेशन में मॉडल ट्रेनिंग उदाहरणों का एक बैच लेता है और अनुमान लगाता है। इमेज जेनरेशन मॉडल के लिए इसका मतलब हो सकता है: किसी इमेज का नॉइज़ वाला संस्करण और एक टेक्स्ट प्रॉम्प्ट दिए जाने पर अनुमान लगाना कि मूल साफ़ इमेज कैसी दिखती थी।
मॉडल के अनुमान और सही उत्तर के बीच के अंतर को लॉस फ़ंक्शन से मापा जाता है। लॉस एक ही संख्या होती है: कम का मतलब मॉडल का प्रदर्शन बेहतर, ज़्यादा का मतलब खराब। ट्रेनिंग की शुरुआत में लॉस ज़्यादा होता है क्योंकि वेट्स अभी लगभग रैंडम होते हैं। पूरी ट्रेनिंग का लक्ष्य लाखों इटरेशन में इस संख्या को लगातार नीचे लाना है।
लॉस निकालने के बाद मॉडल को यह पता लगाना होता है कि कौन से वेट्स गलती में कितना योगदान दे रहे थे। यह बैकप्रोपेगेशन से होता है, एक एल्गोरिदम जो नेटवर्क की परतों में पीछे की ओर चलता है और हर वेट के सापेक्ष लॉस का ग्रेडिएंट निकालता है।
ग्रेडिएंट एक दिशा और एक परिमाण होता है: यह बताता है कि किसी खास वेट को बढ़ाने से लॉस बढ़ेगा या घटेगा। आधुनिक मॉडल में सैकड़ों अरब वेट्स होते हैं, इसलिए इन सबके ग्रेडिएंट एक साथ निकालने के लिए काफ़ी गणितीय तंत्र चाहिए, लेकिन उसके पीछे का तर्क सीधा है।
बैकप्रोपेगेशन ग्रेडिएंट निकालने के बाद ग्रेडिएंट डिसेंट उनका उपयोग वेट्स अपडेट करने में करता है। विचार सीधा है: हर वेट को थोड़ा उस दिशा में खिसकाना जो लॉस को घटाए।
हर कदम का आकार लर्निंग रेट से तय होता है। यह बहुत बड़ा हो तो मॉडल ओवरशूट करता है और कभी स्थिर नहीं होता। बहुत छोटा हो तो ट्रेनिंग में बहुत समय लगता है।
एक उपयोगी उदाहरण: लॉस को पहाड़ों और घाटियों वाले एक भौतिक भू-दृश्य की तरह सोचें। मॉडल के मौजूदा वेट्स उसे उस भू-दृश्य के किसी बिंदु पर रखते हैं। ग्रेडिएंट डिसेंट सबसे निचली घाटी की ओर बार-बार छोटे कदम उतरने की प्रक्रिया है।
यह लूप, यानी फ़ॉरवर्ड पास, लॉस निकालना, बैकप्रोपेगेट करके ग्रेडिएंट लेना, वेट्स अपडेट करना, एक ट्रेनिंग रन में अरबों बार दोहराया जाता है। डेटा के एक बैच से गुज़रने को स्टेप कहते हैं; पूरे डेटासेट से एक पूरा गुज़रना एपॉक है।
| शब्द | इसका मतलब |
|---|---|
| लॉस फ़ंक्शन | अनुमान और वास्तविकता के बीच की गलती मापता है |
| बैकप्रोपेगेशन | पता लगाता है कि कौन से वेट्स गलती के लिए ज़िम्मेदार थे |
| ग्रेडिएंट डिसेंट | गलती घटाने के लिए वेट्स अपडेट करता है |
| लर्निंग रेट | हर वेट अपडेट कितना बड़ा होगा, यह नियंत्रित करता है |
| एपॉक | ट्रेनिंग डेटासेट से एक पूरा गुज़रना |
यह फर्क ज़्यादातर लोगों की उम्मीद से कहीं ज़्यादा मायने रखता है। ओपन वेट्स वाला मॉडल अपने ट्रेन किए गए पैरामीटर्स सार्वजनिक रूप से डाउनलोड करने योग्य बनाता है। आप उसे लोकल चला सकते हैं, फाइन-ट्यून कर सकते हैं और उसके ऊपर एप्लिकेशन बना सकते हैं। SDXL और Stable Diffusion 3.5 Large इसी श्रेणी में आते हैं।
पूरी तरह ओपन सोर्स मॉडल ट्रेनिंग कोड, डेटासेट और पूरी पाइपलाइन को कवर करने वाला डॉक्युमेंटेशन भी जारी करता है। इस ऊँचे मानक तक बहुत कम मॉडल पहुँच पाते हैं।
जानने लायक बात: AI में "ओपन सोर्स" का मतलब हमेशा वही नहीं होता जो सॉफ़्टवेयर में होता है। कई लोकप्रिय AI मॉडल, जिन्हें लोग ओपन सोर्स कहते हैं, सिर्फ़ वेट्स साझा करते हैं, उन्हें बनाने में इस्तेमाल हुई पूरी रेसिपी नहीं।
ओपन वेट्स प्रैक्टिशनर्स के लिए बेहद मायने रखते हैं। ये API खर्च के बिना इनफ़रेंस चलाने, मॉडल को अपने हार्डवेयर पर चलाने, और खास उपयोग के लिए वेट्स बदलने की सुविधा देते हैं। ये समुदाय को मॉडल में पक्षपात की जाँच करने, सेफ़्टी टूल्स बनाने और बेहतर वर्ज़न जारी करने की भी अनुमति देते हैं।
Flux 1.1 Pro Ultra और Imagen 4 इस स्पेक्ट्रम पर अलग-अलग दर्शन दर्शाते हैं। कुछ ओपन वेट्स के ज़रिए पहुँच को प्राथमिकता देते हैं, जबकि कुछ क्वालिटी या सेफ़्टी कारणों से प्रोप्राइटरी बने रहते हैं।
प्री-ट्रेनिंग एक सामान्य-उद्देश्य मॉडल बनाती है, लेकिन यह शायद ही कभी आखिरी कदम होता है। फाइन-ट्यूनिंग एक प्री-ट्रेन्ड मॉडल को किसी खास डोमेन या स्टाइल पर बेहतर काम करने के लिए ढालती है। समस्या यह है कि एक अरब पैरामीटर वाले मॉडल की पूरी फाइन-ट्यूनिंग महँगी और धीमी होती है।
LoRA (Low-Rank Adaptation) मूल मॉडल के वेट्स को फ्रीज़ करके और कुछ परतों में छोटे ट्रेनेबल मैट्रिक्स डालकर इसे हल करता है। हर चीज़ दोबारा ट्रेन करने के बजाय आप सिर्फ़ LoRA एडेप्टर वेट्स ट्रेन करते हैं, जो कुल पैरामीटर संख्या का एक छोटा हिस्सा होते हैं। नतीजा ऐसा मॉडल है जो निशाना बनाकर अलग तरह से व्यवहार करता है, और फिर भी अपना पूरा बेस ज्ञान बनाए रखता है।
PicassoIA पर Flux Dev LoRA ठीक इसी तरह काम करता है। बेस Flux Dev मॉडल स्थिर रहता है, जबकि वेट्स का एक छोटा सेट आउटपुट को खास विज़ुअल स्टाइल, कैरेक्टर या सब्जेक्ट की ओर मोड़ता है। मामूली हार्डवेयर वाला कोई भी व्यक्ति कुछ सौ इमेज पर LoRA ट्रेन कर सकता है और ऐसा मॉडल बना सकता है जो एक खास एस्थेटिक भरोसेमंद ढंग से जेनरेट करे।
लार्ज लैंग्वेज मॉडल के लिए, और तेज़ी से इमेज जेनरेटर के लिए भी, Reinforcement Learning from Human Feedback (RLHF) प्री-ट्रेनिंग के बाद इस्तेमाल होता है, ताकि आउटपुट लोगों की असली चाहत के साथ ज़्यादा मेल खाएँ। इसमें मानव रेटर मॉडल के आउटपुट को स्कोर करते हैं, उन स्कोर पर एक अलग रिवार्ड मॉडल ट्रेन होता है, और फिर रीइन्फ़ोर्समेंट लर्निंग से मुख्य मॉडल को ज़्यादा रेटिंग वाले व्यवहार की ओर धकेला जाता है।
RLHF ही उस कच्चे प्री-ट्रेन्ड मॉडल को, जो कुछ भी बना सकता है, उस मॉडल से अलग करता है जो भरोसेमंद ढंग से उपयोगी, सुरक्षित और उच्च-गुणवत्ता वाले आउटपुट देता है। यह कम्प्यूटेशनल रूप से महँगा है और सावधानीपूर्वक डिज़ाइन माँगता है, लेकिन आउटपुट की समझी गई गुणवत्ता पर इसका असर काफ़ी बड़ा होता है।
एक बड़ा AI मॉडल ट्रेन करने के लिए सैकड़ों या हज़ारों GPU का एक समन्वित क्लस्टर चाहिए, जो हफ़्तों या महीनों तक समानांतर चलता है। फ्रंटियर मॉडल के आधुनिक ट्रेनिंग रन NVIDIA H100 क्लस्टर इस्तेमाल करते हैं, जो हाई-बैंडविड्थ NVLink और InfiniBand नेटवर्किंग से जुड़े होते हैं, ताकि गणना को हज़ारों चिप्स पर एक साथ बाँटा जा सके।
पैरेलिज़्म की ज़रूरत का कारण सीधा है: किसी बड़े मॉडल से एक फ़ॉरवर्ड-बैकवर्ड पास में इतने फ्लोटिंग-पॉइंट ऑपरेशन होते हैं कि कोई एक GPU उन्हें उचित समय में पूरा नहीं कर सकता। काम को कई GPU पर बाँटना, जिनमें से हर एक डेटा का एक हिस्सा या मॉडल का एक खंड प्रोसेस करे, बड़े पैमाने पर एकमात्र व्यावहारिक तरीका है।
एक NVIDIA H100 GPU की कीमत $25,000 से ऊपर है, और एक प्रतिस्पर्धी ट्रेनिंग रन इनमें से हज़ारों को महीनों तक इस्तेमाल कर सकता है। हार्डवेयर की लागत के ऊपर बिजली (बड़े ट्रेनिंग रन मेगावाट खपत करते हैं), कूलिंग इन्फ्रास्ट्रक्चर, क्लाउड कंप्यूट फीस और रिसर्च टीमों की मेहनत भी लगती है।
इसी वजह से गिने-चुने संगठन ही सचमुच बड़े फ़ाउंडेशन मॉडल शून्य से ट्रेन कर पाते हैं। ओपन सोर्स समुदाय आम तौर पर इन फ़ाउंडेशन मॉडल के ऊपर फाइन-ट्यूनिंग और अडैप्टेशन से काम करता है, जो दस गुना या उससे भी ज़्यादा सस्ता है और फिर भी शानदार नतीजे देता है।
| ट्रेनिंग तरीका | अनुमानित लागत | कौन करता है |
|---|---|---|
| शून्य से प्री-ट्रेनिंग | $1M से $100M+ | बड़ी रिसर्च लैब, अच्छे फंड वाले स्टार्टअप |
| फुल फाइन-ट्यूनिंग | $10K से $500K | मध्यम आकार की रिसर्च टीमें |
| LoRA फाइन-ट्यूनिंग | $50 से $5,000 | व्यक्तिगत शोधकर्ता, छोटी टीमें |
| इनफ़रेंस चलाना | हर रिक्वेस्ट के कुछ सेंट | कोई भी |
आधुनिक AI इमेज जेनरेशन को शक्ति देने वाले लगभग सभी मॉडल ओपन सोर्स परंपरा से ही निकले हैं। Stable Diffusion ने 2022 में दिखाया कि एक उच्च-गुणवत्ता वाला इमेज जेनरेशन मॉडल ट्रेन करके खुले रूप में जारी किया जा सकता है, जिससे समुदाय में नवाचार का विस्फोट हुआ। कुछ ही महीनों में हज़ारों फाइन-ट्यून, LoRA और डेरिवेटिव मॉडल आ गए।
Black Forest Labs के Flux Dev और Flux Pro अगला कदम दर्शाते हैं: एक ट्रांसफ़ॉर्मर-आधारित आर्किटेक्चर, जो बड़े पैमाने पर ट्रेन हुआ है और जिसमें टेक्स्ट समझ और फोटोरियलिज़्म काफ़ी बेहतर हैं। इसका ट्रेनिंग तरीका इस लेख में बताए गए उन्हीं सिद्धांतों पर आधारित है, जिन्हें ज़्यादा डेटा, ज़्यादा कंप्यूट और आर्किटेक्चर के उन सुधारों के साथ लागू किया गया है जिन्होंने कोहेरेंस और प्रॉम्प्ट पालन को बेहतर बनाया।
SDXL ने मूल Stable Diffusion को मॉडल और ट्रेनिंग डेटासेट, दोनों को बढ़ाकर आगे बढ़ाया, जिससे साफ़ तौर पर ज़्यादा रेज़ोल्यूशन और ज़्यादा डिटेल वाले आउटपुट मिले। Stable Diffusion 3.5 Large इससे भी आगे गया, उसने एक मल्टीमोडल डिफ़्यूज़न ट्रांसफ़ॉर्मर आर्किटेक्चर अपनाया, जो तीखी कंपोज़िशन और बेहतर सिमैंटिक अलाइनमेंट देता है।
इन सभी मॉडलों ने एक ही बुनियादी प्रक्रिया से गुज़रकर आकार लिया: डेटासेट क्यूरेशन, ग्रेडिएंट डिसेंट से लॉस मिनिमाइज़ेशन के साथ प्री-ट्रेनिंग, और फिर आउटपुट को इंसानी पसंद से मिलाने के लिए फाइन-ट्यूनिंग।
यहाँ चर्चा किए गए सभी मॉडल सीधे PicassoIA पर चलाने के लिए उपलब्ध हैं। कोई लोकल सेटअप नहीं, कोई हार्डवेयर आवश्यकता नहीं, और वेट फ़ाइलों या Python एनवायरनमेंट को संभालने की ज़रूरत नहीं। आप इन्हें आज़मा सकते हैं:
"ट्रेनिंग कैसे काम करती है" और "आप असल में क्या बना सकते हैं" के बीच का फासला जितना दिखता है उससे छोटा है। जब आप टेक्स्ट-टू-इमेज इंटरफ़ेस में प्रॉम्प्ट लिखते हैं, तो जिन वेट्स को क्वेरी किया जा रहा है, वे ऊपर बताई गई सारी चीज़ों का सीधा नतीजा हैं: महीनों की डेटा क्यूरेशन, अरबों ग्रेडिएंट अपडेट और सावधानीपूर्वक अलाइनमेंट का काम। आउटपुट में जो गुणवत्ता दिखती है, वह पाइपलाइन के हर चरण पर लिए गए फ़ैसलों को दर्शाती है।
ज़्यादातर क्रिएटर्स के लिए काम की बात यह नहीं है कि मॉडल शून्य से कैसे ट्रेन करें, बल्कि यह है कि प्री-ट्रेन्ड वेट्स के ऊपर बैठी एडेप्टेशन परतों के साथ कैसे काम करें। LoRA फाइन-ट्यून आपको कुछ सौ ट्रेनिंग इमेज और मामूली हार्डवेयर से किसी शक्तिशाली बेस मॉडल को एक खास चेहरे, आर्ट स्टाइल या विज़ुअल कॉन्सेप्ट की ओर मोड़ने देते हैं। ओपन सोर्स AI ट्रेनिंग का यही हिस्सा आज व्यक्तियों के लिए सचमुच सुलभ है, अभी, बिना किसी रिसर्च बजट के।
आज़माने लायक: देखना चाहते हैं कि अलग-अलग ट्रेनिंग तरीके आउटपुट की गुणवत्ता पर कैसे असर डालते हैं, तो PicassoIA पर एक ही प्रॉम्प्ट Flux Schnell, Flux Dev और SDXL पर साथ-साथ चलाएँ। फोटोरियलिज़्म, प्रॉम्प्ट पालन और कंपोज़िशन के अंतर सीधे उन ट्रेनिंग विकल्पों को दर्शाते हैं जो हर मॉडल के लिए चुने गए थे।
हर बार जब आप इमेज जेनरेट करते हैं, आप उस पाइपलाइन का आखिरी नोड होते हैं जो पेटाबाइट्स डेटा, अरबों पैरामीटर अपडेट और उन शोधकर्ताओं की साझा मेहनत से शुरू हुई, जिन्होंने अपना काम खुले रूप में साझा करना चुना। PicassoIA के मॉडल उसी काम का नतीजा हैं, और बिना ट्रेनिंग का एक भी कोड छुए इस्तेमाल के लिए तैयार हैं।
Flux Dev या Stable Diffusion 3.5 Large से शुरू करें, और देखें कि एक ही वाक्य से लाखों ट्रेनिंग इटरेशन क्या बना सकते हैं।
अपनी भाषा चुनें
