Flux 2 पर कस्टम LoRA ट्रेनिंग का एक व्यावहारिक गाइड, जिसमें डेटासेट क्यूरेशन और कैप्शनिंग से लेकर ट्रेनिंग पैरामीटर, लॉस मॉनिटरिंग और किसी भी प्लेटफ़ॉर्म पर अपने फ़ाइन-ट्यून्ड वेट्स से इनफ़रेंस चलाने तक सब कुछ शामिल है।
Flux 2-Dev पर कस्टम LoRA ट्रेन करना आधुनिक डिफ़्यूज़न मॉडल के साथ किया जा सकने वाला सबसे शक्तिशाली काम है। चाहे आप किसी खास आर्ट स्टाइल को दोहराना चाहते हों, मॉडल को अपना चेहरा पहचानना सिखाना चाहते हों, या किसी प्रोडक्ट को पिक्सल-परफ़ेक्ट कंसिस्टेंसी के साथ कैप्चर करना चाहते हों, LoRA फ़ाइन-ट्यूनिंग आपको यह नियंत्रण देती है, और इसमें हफ़्तों और हज़ारों डॉलर खर्च नहीं करने पड़ते। 2027 में यह प्रक्रिया काफ़ी आसान हो गई है, और यह लेख कच्चे डेटासेट से लेकर आपके पहले सफल इनफ़रेंस तक हर चरण के बारे में बताता है।
LoRA, यानी Low-Rank Adaptation, पूरे मॉडल को दोबारा ट्रेन नहीं करता। यह फ़्रोज़न बेस मॉडल की कुछ खास लेयर्स में छोटे, ट्रेन होने वाले वेट मैट्रिक्स डालता है और केवल उन्हीं को ट्रेन करता है। नतीजा एक कॉम्पैक्ट एडेप्टर फ़ाइल होती है, आम तौर पर 50MB से 300MB के बीच, जिसे बेस मॉडल के साथ लोड करने पर उसके आउटपुट उस स्टाइल, सब्जेक्ट या कॉन्सेप्ट की ओर झुक जाते हैं जिस पर आपने उसे ट्रेन किया है।
| तरीका | फ़ाइल साइज़ | ट्रेनिंग लागत | क्वालिटी की सीमा |
|---|---|---|---|
| फ़ुल फ़ाइन-ट्यून | 10+ GB | बहुत ज़्यादा | सबसे ऊँची |
| DreamBooth | 2-8 GB | ज़्यादा | ऊँची |
| LoRA | 50-300 MB | कम | ऊँची |
| LyCORIS | 100-500 MB | मध्यम | बहुत ऊँची |
इसका आर्थिक गणित साफ़ है। LoRA से आप तेज़ी से प्रयोग कर सकते हैं, अलग-अलग डेटासेट आज़मा सकते हैं और पूरा मॉडल साझा किए बिना अपने ट्रेन किए वेट्स साझा कर सकते हैं। ज़्यादातर क्रिएटर्स और डेवलपर्स के लिए यही सही टूल है।
पिछले डिफ़्यूज़न आर्किटेक्चर LoRA ट्रेनिंग पर एकसमान प्रतिक्रिया नहीं देते थे। SDXL से साफ़ स्टाइल ट्रांसफ़र पाने के लिए अक्सर सैकड़ों सावधानी से चुनी गई इमेज और कई हाइपरपैरामीटर ट्यूनिंग सत्र लगते थे। Flux 2-Dev इससे बुनियादी तौर पर अलग है। इसका फ़्लो मैचिंग आर्किटेक्चर लो-रैंक एडेप्टेशन पर ज़्यादा सीधे प्रतिक्रिया देता है, यानी किसी व्यक्ति के लिए सिर्फ़ 10 से 20 इमेज और कुल कम ट्रेनिंग स्टेप्स से भी मज़बूत कॉन्सेप्ट कैप्चर हो सकता है। क्वालिटी की सीमा भी ऊँची है: जब LoRA सही तरीके से लगाया जाता है, तो Flux 2-Pro और Flux 2-Max पिछले वर्ज़न की तुलना में कहीं ज़्यादा शार्प और सुसंगत आउटपुट देते हैं।
कस्टम LoRA ट्रेनिंग में आपका डेटासेट सबसे अहम कारक है। खराब डेटा से खराब LoRA बनता है, और कितनी भी चतुर ट्रेनिंग कॉन्फ़िगरेशन टूटे हुए डेटासेट को ठीक नहीं कर सकती।
सब्जेक्ट-ड्रिवन जनरेशन (किसी खास व्यक्ति, कैरेक्टर या ऑब्जेक्ट को ट्रेन करने) के लिए:
हर इमेज शार्प और अच्छी तरह रोशन होनी चाहिए। धुंधली फ़ोटो, भारी कम्प्रेशन आर्टिफ़ैक्ट और मिले-जुले रिज़ॉल्यूशन LoRA की कॉन्सेप्ट को साफ़ तरीके से निकालने की क्षमता को कम कर देते हैं। कम से कम 512x512 रिज़ॉल्यूशन पर शूट करें; Flux 2 LoRA के लिए 1024x1024 बेहतर है।
💡 विविधता मात्रा से ज़्यादा मायने रखती है। दस शार्प और अलग-अलग इमेज, पचास एक जैसी इमेज से बेहतर हैं। अलग-अलग एंगल, रोशनी की स्थितियाँ और बैकग्राउंड शामिल करें, ताकि आपका LoRA किसी एक माहौल को अपने में न समेट ले।
कैप्शनिंग में ही ज़्यादातर शुरुआती लोग क्वालिटी खो देते हैं। हर ट्रेनिंग इमेज को एक टेक्स्ट कैप्शन चाहिए जो इमेज में मौजूद हर चीज़ का वर्णन करे, सिवाय उस कॉन्सेप्ट के जो आप सिखा रहे हैं। उस कॉन्सेप्ट को एक यूनिक ट्रिगर वर्ड से दर्शाया जाना चाहिए, जो बेस मॉडल की शब्दावली में पहले से मौजूद न हो।
उदाहरण के लिए, Sarah नाम के व्यक्ति को ट्रेन करते समय:
sks person smiling in a park, warm afternoon light, casual clothing"ट्रिगर वर्ड sks (या कोई भी छोटा, यूनिक टोकन जो आप चुनें) एंकर बन जाता है। बाद में जब आप किसी प्रॉम्प्ट में sks person लिखते हैं, तो मॉडल ठीक-ठीक समझ जाता है कि किस खास व्यक्ति को जनरेट करना है।
ऑटो-कैप्शनिंग के टूल:
Flux 2 LoRA ट्रेनिंग कुछ मुख्य पैरामीटर के प्रति संवेदनशील है। इन्हें सही रखने से एक कसा हुआ, काम का LoRA और धुंधला या ओवरफ़िट LoRA अलग होता है।
लर्निंग रेट (LR) तय करता है कि हर ट्रेनिंग स्टेप के साथ मॉडल के वेट कितनी तेज़ी से बदलते हैं। बहुत ज़्यादा हो तो आपका LoRA जल्दी ओवरफ़िट हो जाता है। बहुत कम हो तो मॉडल आपके डेटा पर लगभग कोई प्रतिक्रिया नहीं देता।
| LoRA का प्रकार | सुझाया गया LR | शेड्यूलर |
|---|---|---|
| सब्जेक्ट / व्यक्ति | 1e-4 से 4e-4 | रीस्टार्ट के साथ कोसाइन |
| आर्ट स्टाइल | 5e-5 से 2e-4 | वॉर्मअप के साथ कॉन्स्टेंट |
| ऑब्जेक्ट / प्रोडक्ट | 1e-4 से 3e-4 | कोसाइन |
कोसाइन डिके शेड्यूल सामान्य रूप से सबसे सुरक्षित विकल्प है। यह आपके सेट किए LR से शुरू होता है, धीरे-धीरे घटता है, और आखिरी स्टेप्स की ओर उन अचानक गिरावटों से बचता है जो ट्रेनिंग को अस्थिर कर सकती हैं।
Flux 2 LoRA के लिए ट्रेनिंग स्टेप्स आम तौर पर 500 से 2000 के बीच होते हैं। एक मोटे शुरुआती अनुमान के लिए अपनी इमेज की संख्या को 100 से गुणा करें (20 इमेज = 2000 स्टेप्स)। अपना लॉस कर्व देखते रहें, और अगर वह स्थिर होने लगे या ऊपर जाने लगे तो जल्दी रोक दें।
LoRA रैंक (r के रूप में लिखी जाती है) एडेप्टर की जटिलता तय करती है:
अल्फ़ा प्रभावी लर्निंग रेट स्केलिंग को नियंत्रित करता है। एक आम तरीका है अल्फ़ा को रैंक के बराबर रखना (रैंक 16 हो तो अल्फ़ा = 16), या ज़्यादा सूक्ष्म एडेप्टेशन के लिए रैंक का आधा।
ज़्यादातर कंज़्यूमर GPU सेटअप (24GB VRAM वाले RTX 3090 / RTX 4090) के लिए:
512px पर ट्रेनिंग से VRAM बचता है, लेकिन नतीजे साफ़ तौर पर नरम आते हैं। Flux 2 1024px आउटपुट के लिए अनुकूलित है, और उस रिज़ॉल्यूशन पर ट्रेन किए गए LoRA एडेप्टर इनफ़रेंस के दौरान कहीं बेहतर प्रदर्शन करते हैं।
2027 में Flux 2 LoRA के लिए सबसे ज़्यादा इस्तेमाल होने वाला ट्रेनिंग फ़्रेमवर्क SimpleTuner है, हालाँकि जो उपयोगकर्ता पहले से उस इकोसिस्टम से परिचित हैं, उनके लिए Flux 2 ब्रांच वाला kohya-ss/sd-scripts भी अच्छा काम करता है।
# Clone SimpleTuner
git clone https://github.com/bghira/SimpleTuner
cd SimpleTuner
# Create Python environment
python -m venv venv
source venv/bin/activate
# Install dependencies
pip install -r requirements.txt
आपको क्या चाहिए:
अपनी ट्रेनिंग डायरेक्टरी में एक config.json बनाएँ, जिसमें ये सेटिंग्स शुरुआती बिंदु के तौर पर हों:
{
"model_type": "flux",
"pretrained_model_name_or_path": "black-forest-labs/FLUX.1-dev",
"output_dir": "./output/my-lora",
"train_batch_size": 1,
"gradient_accumulation_steps": 4,
"learning_rate": 1e-4,
"lr_scheduler": "cosine",
"max_train_steps": 1500,
"lora_rank": 16,
"lora_alpha": 16,
"resolution": 1024,
"mixed_precision": "bf16"
}
फिर ट्रेनिंग शुरू करें:
python train_network.py --config_file config.json
इन सेटिंग्स पर एक RTX 4090 में ट्रेनिंग में स्टेप्स की संख्या और डेटासेट के आकार के हिसाब से लगभग 30 से 90 मिनट लगते हैं।
लॉस कर्व बताते हैं कि आपका LoRA सच में सीख रहा है या नहीं। एक स्वस्थ ट्रेनिंग रन में:
💡 हर 250 से 500 स्टेप पर चेकपॉइंट सेव करें। सबसे अच्छा LoRA अक्सर आखिरी स्टेप पर नहीं होता। ओवरफ़िट होने से पहले अपना सही बिंदु खोजने के लिए कुछ प्रॉम्प्ट के साथ बीच के चेकपॉइंट्स आज़माएँ।
Flux 2 सब्जेक्ट LoRA के लिए लगभग 0.05 से 0.15 का ट्रेनिंग लॉस आम है। स्टाइल LoRA आम तौर पर 0.08 से 0.20 के बीच स्थिर होते हैं, जो इस पर निर्भर करता है कि स्टाइल बेस मॉडल की ट्रेनिंग डिस्ट्रीब्यूशन से कितना दूर है।
ट्रेनिंग पूरी होने के बाद, अपनी पसंद के इनफ़रेंस फ़्रेमवर्क का उपयोग करके Flux 2-Dev या Flux 2-Pro के साथ अपनी .safetensors LoRA फ़ाइल लोड करें। Flux 2 एक्सटेंशन वाला ComfyUI या Automatic1111 सेटअप यह सीधे संभाल लेता है।
अपने ट्रिगर वर्ड के साथ एक सरल प्रॉम्प्ट से शुरुआत करें:
a portrait of sks person in a coffee shop, natural light, 85mm lens
अगर मॉडल आपके ट्रेन किए गए सब्जेक्ट का पहचाना जा सकने वाला रूप बनाता है, तो LoRA काम कर रहा है। अगर नतीजे सामान्य या असंगत हैं, तो आपके ट्रिगर वर्ड की जगह या कैप्शनिंग में सुधार की ज़रूरत हो सकती है।
| इस्तेमाल का मामला | ट्रिगर वर्ड की उदाहरण जगह |
|---|---|
| व्यक्ति | "a photo of sks person" |
| आर्ट स्टाइल | "in the style of myart" |
| प्रोडक्ट / ऑब्जेक्ट | "a brd product on a white table" |
| कैरेक्टर | "mychar character standing outdoors" |
ट्रिगर वर्ड को हमेशा प्रॉम्प्ट की शुरुआत में रखें और उसके साथ साफ़ संदर्भ वाला विवरण जोड़ें। मॉडल सिर्फ़ टोकन पर नहीं, बल्कि ट्रिगर के आसपास के पूरे अर्थगत संदर्भ पर प्रतिक्रिया देता है।
PicassoIA आपको बिना किसी लोकल सेटअप के LoRA-पावर्ड Flux 2 मॉडल का सीधा एक्सेस देता है। अगर आप ट्रेनिंग के तुरंत बाद अपने फ़ाइन-ट्यून्ड Flux 2 आउटपुट टेस्ट करना चाहते हैं, तो प्लेटफ़ॉर्म पर कई तैयार विकल्प हैं।
PicassoIA पर LoRA-आधारित जनरेशन के लिए सबसे प्रासंगिक मॉडल ये हैं:
.safetensors वेट्स को सीधे HuggingFace URL से लोड करें और तुरंत इनफ़रेंस चलाएँ, आपकी तरफ़ किसी GPU की ज़रूरत नहीं।अपने LoRA को ज़्यादा व्यापक रूप से लगाने से पहले आउटपुट क्वालिटी जाँचने के लिए, उच्च-गुणवत्ता वाले बेस इनफ़रेंस के लिए आप Flux 2-Dev, Flux 2-Pro, Flux 2-Flex और Flux 2-Max भी इस्तेमाल कर सकते हैं।
.safetensors फ़ाइल का सार्वजनिक HuggingFace URL पेस्ट करें💡 LoRA Scale टिप: 1.0 से ऊपर का स्केल कॉन्सेप्ट को ज़्यादा संतृप्त कर सकता है और आर्टिफ़ैक्ट पैदा कर सकता है। ज़्यादातर उपयोगों के लिए 0.6 से 0.9 के बीच रहें।
कस्टम LoRA के लिए प्रभावी प्रॉम्प्ट लिखना सामान्य प्रॉम्प्टिंग से अलग है। कुछ नियम जो लगातार क्वालिटी सुधारते हैं:
1. बहुत मिलती-जुलती इमेज पर ट्रेनिंग। अगर आपकी 20 में से 80% इमेज एक ही कमरे में एक ही रोशनी में ली गई हैं, तो आपका LoRA उस माहौल में ओवरफ़िट हो जाता है। मॉडल माहौल को ही कॉन्सेप्ट का हिस्सा बना लेता है। अपने डेटासेट में बैकग्राउंड, रोशनी और फ़्रेमिंग को खुलकर बदलें।
2. कैप्शन रिव्यू स्टेप छोड़ना। कई ट्रेनिंग पाइपलाइन ऑटो-कैप्शनिंग देती हैं, और उपयोगकर्ता उसके आउटपुट को बिना जाँचे भरोसा कर लेते हैं। ऑटो-कैप्शन में अक्सर सब्जेक्ट की खास विशेषताएँ ट्रिगर वर्ड तक सीमित रखने के बजाय विवरण वाले टेक्स्ट में शामिल हो जाती हैं। ट्रेनिंग से पहले कैप्शन हमेशा जाँचें और हाथ से सुधारें।
3. बीच के चेकपॉइंट्स न आज़माना। ओवरफ़िट LoRA अचानक फ़ेल नहीं होते। वे एक निश्चित स्टेप संख्या के बाद धीरे-धीरे बिगड़ते हैं। सब्जेक्ट LoRA के लिए स्टेप 1000 वाला वर्ज़न अक्सर स्टेप 2000 वाले से काफ़ी बेहतर होता है। शुरू से ही चेकपॉइंट मूल्यांकन को अपने वर्कफ़्लो में शामिल करें।
💡 तेज़ क्वालिटी टेस्ट: ट्रिगर वर्ड का उपयोग करके बिल्कुल अलग-अलग प्रॉम्प्ट से 5 इमेज जनरेट करें। मज़बूत LoRA सभी 5 में सब्जेक्ट को बनाए रखता है। कमज़ोर LoRA तभी काम करता है जब प्रॉम्प्ट आपकी ट्रेनिंग इमेज की परिस्थितियों से काफ़ी मेल खाता हो।
कस्टम LoRA ट्रेनिंग वह तरीका है जिससे आप AI को केवल एक सामान्य इमेज मशीन की तरह इस्तेमाल करना बंद करते हैं और उसे अपने खास क्रिएटिव विज़न को दर्शाने वाले टूल की तरह इस्तेमाल करने लगते हैं। चाहे वह आपकी फ़ोटोग्राफ़ी की स्टाइल हो, कोई काल्पनिक कैरेक्टर, प्रोडक्ट लाइन, या ऐसा चेहरा जिसे मॉडल ने कभी नहीं देखा, ऊपर बताया गया वर्कफ़्लो वह सब कुछ देता है जो इसे संभव बनाने के लिए चाहिए।
PicassoIA के LoRA-कम्पैटिबल मॉडल का संग्रह, जिसमें flux-dev-lora, p-image-lora और पूरा Flux 2 परिवार शामिल है, का मतलब है कि आप बिना हाई-एंड लोकल GPU के क्लाउड में तुरंत अपने ट्रेन किए वेट्स टेस्ट कर सकते हैं। एक मॉडल चुनें, अपना LoRA लोड करें, अपना ट्रिगर वर्ड लिखें, और देखें कि मॉडल उस चीज़ के साथ क्या करता है जिस पर आपने उसे ट्रेन किया है।
इसमें माहिर होने का सबसे अच्छा तरीका है कुछ ट्रेन करना, उसका ईमानदारी से मूल्यांकन करना, पहचानना कि वह कहाँ विफल होता है, और बेहतर डेटा के साथ उसे फिर से ट्रेन करना। हर चक्र में कुछ ऐसा सामने आता है जिसे कोई लिखित संसाधन पूरी तरह दोहरा नहीं सकता।
अपनी भाषा चुनें
