एलएलएम के लिए लोरा फाइन-ट्यूनिंग: रैंक, टारगेट मॉड्यूल और मेमोरी गणित

पूरा फाइन-ट्यून कुछ कामों पर अभी भी जीतता है। ज़्यादातर प्रॉडक्ट वर्क में यह गलत डिफ़ॉल्ट है। लोरा बेस वेट को फ्रीज़ रखता है और चुनी हुई हर लेयर पर लो-रैंक मैट्रिक्स की जोड़ी ट्रेन करता है। क्यूलोरा वही आइडिया रखता है और बेस मॉडल को ४-बिट में लोड करता है, ताकि ७बी या १३बी मॉडल एक अकेली २४ जीबी कार्ड पर ट्रेन हो सके।

जीपीयू घंटे जलाने से पहले मैं यही चेकलिस्ट चलाता हूँ।

लोरा कब सही औज़ार है

लोरा (या क्यूलोरा) चुनें जब:

१. आपके पास मज़बूत बेस मॉडल है और आपको सिर्फ स्टाइल, फॉर्मैट, डोमेन जार्गन या टूल-कॉलिंग की आदतें चाहिए। इंस्ट्रक्शन-ट्यून्ड ७बी-७०बी चेकपॉइंट पहले से भाषा जानते हैं। आप स्टीयर कर रहे हैं, अंग्रेज़ी शुरू से नहीं सिखा रहे। २. वीरैम बाधा है। ७बी मॉडल पर एफपी१६ में पूरा एडमडब्ल्यू मोटे तौर पर वेट + ग्रेडिएंट + ऑप्टिमाइज़र के दो स्टेट: लगभग १४ + १४ + २८ = ५६ जीबी, एक्टिवेशन और केवी कैश से पहले। २४ जीबी जीपीयू वह जॉब साफ नहीं खत्म करता। ३. सस्ते कई एडाप्टर चाहिए। एक फ्रोज़न बेस, ग्राहक या प्रॉडक्ट के लिए एन लोरा पैक। लोड टाइम पर एडाप्टर बदलें। पूरा फाइन-ट्यून एन पूरी कॉपी स्टोर और सर्व करने को मजबूर करता है। ४. डेटा छोटा या मध्यम है। हज़ारों से लेकर कुछ लाख उदाहरण लोरा का आम रेंज है। अगर मल्टी-बिलियन-टोकन डोमेन कॉर्पस है और पीक क्वालिटी चाहिए, तो फुल (या कंटिन्यूड प्रीट्रेन) की जगह अभी भी है।

लोरा छोड़ें जब गहरी क्षमता बदलनी हो: प्रीट्रेन में लगभग शून्य कवरेज वाली भाषाएँ, भारी मल्टी-स्टेप रीज़निंग लिफ्ट, या बड़ी आर्किटेक्चर सर्जरी। लो रैंक वह क्षमता नहीं बना सकता जो बेस में कभी नहीं थी।

लोरा असल में क्या ट्रेन करता है

फ्रोज़न वेट मैट्रिक्स डब्ल्यू (आकार डी×के) के लिए लोरा दो छोटी मैट्रिक्स सीखता है: ए (रैंक×के) और बी (डी×रैंक)। फॉरवर्ड पास बनता है: मूल वेट का आउटपुट + बी गुणा ए गुणा इनपुट, साथ में स्केल फैक्टर अल्फा/रैंक।

प्रति मैट्रिक्स ट्रेन करने वाले पैरामीटर: रैंक×(डी+के)। अटेंशन प्रोजेक्शन पर डी = के = ४०९६ और रैंक = १६ हो तो:

१६ × (४०९६ + ४०९६) = १,३१,०७२ पैरामीटर

पूरी ४०९६×४०९६ मैट्रिक्स (१६.७एम वेट) के आगे यह बहुत छोटा है। सारी टारगेट लेयर मिलाकर अक्सर बेस पैरामीटर का ०.१% से २% बचता है, इसलिए ऑप्टिमाइज़र स्टेट आखिर फिट होता है।

क्यूलोरा (डेटमर्स आदि, २०२३) बेस वेट को एनएफ४ में क्वांटाइज़ करता है, कॉन्स्टेंट पर डबल-क्वांट कर सकता है, और पेज्ड ऑप्टिमाइज़र इस्तेमाल करता है ताकि ऑप्टिमाइज़र स्पाइक ओओएम न करें। एडाप्टर फिर भी ऊँची प्रिसिजन में ट्रेन होते हैं (आमतौर पर बीएफ१६/एफपी१६)।

रैंक: छोटा शुरू करें, मापें, फिर बढ़ाएँ

रैंक	आम इस्तेमाल	नोट
४-८	स्टाइल, चैट टोन, हल्का फॉर्मैटिंग	तेज़, छोटे सेट पर ओवरफिट का कम जोखिम
१६	इंस्ट्रक्शन / डोमेन एसएफटी का डिफ़ॉल्ट पहला प्रयास	७बी-१३बी पर अच्छा क्वालिटी / लागत संतुलन
३२-६४	कठिन डोमेन शिफ्ट, मल्टी-टास्क एडाप्टर	ज़्यादा वीरैम और ज़्यादा डेटा
१२८+	एसएफटी में शायद ही ज़रूरत	अक्सर फुल फाइन-ट्यून जितनी लागत, बराबर नतीजा नहीं

अंगूठे का नियम: रैंक १६, अल्फा ३२ (अल्फा = २आर) लामा-क्लास मॉडल पर समझदार स्टार्ट है। अगर इवैल ठहर जाए और डेटा साफ हो, ३२ या ६४ पर जाएँ। अगर ट्रेन लॉस गिरे और इवैल बिगड़े, रैंक (या लर्निंग रेट) सेट साइज़ के हिसाब से बहुत आक्रामक है।

अल्फा एडाप्टर योगदान को स्केल करता है। फिक्स्ड अल्फा या अल्फा = २आर चुनें, रैंक स्वीप के दौरान स्कीम फिक्स रखें, और दोनों वैल्यू लॉग करें। दोनों एक साथ बदलने से अबलेशन बेकार हो जाते हैं।

टारगेट मॉड्यूल जितना लोग मानते हैं उससे ज़्यादा मायने रखते हैं

क्लासिक लोरा पेपर अक्सर सिर्फ क्वेरी और वैल्यू अडैप्ट करते थे। सस्ता पड़ता है। आधुनिक डिकोडर एलएलएम पर अटेंशन और एमएलपी की सारी लीनियर प्रोजेक्शन अडैप्ट करना अक्सर जीतता है:

# Llama-style names (PEFT / Hugging Face)
target_modules = [
  "q_proj", "k_proj", "v_proj", "o_proj",
  "gate_proj", "up_proj", "down_proj",
]

वीरैम तंग हो तो पहले एमएलपी हटाएँ, अटेंशन रखें। क्वालिटी सपाट हो तो रैंक १६ से १२८ कूदने से पहले मॉड्यूल जोड़ें। मॉड्यूल कवरेज अक्सर अंधे रैंक इज़ाफे से ज़्यादा सुई हिलाती है।

एम्बेडिंग / एलएम-हेड न भूलें जब टास्क कई नए टोकन जोड़ता हो (टूल टैग, डोमेन कोड)। टोकन-लेवल व्यवहार गलत हो तभी छोड़ें, वरना फ्रोज़न रखें।

मेमोरी गणित जो नैपकिन पर हो

७बी डेंस मॉडल के लिए मोटा स्थिर वीरैम (ऑर्डर ऑफ मैग्निट्यूड, प्रोफाइलर नहीं):

सेटअप	बेस वेट	ट्रेन + एडम स्टेट	मोटा कुल*
फुल एफटी, एफपी१६	~१४ जीबी	~४२ जीबी	५६ जीबी+
लोरा आर=१६, एफपी१६ बेस	~१४ जीबी	कुछ सौ एमबी	१६-२० जीबी
क्यूलोरा ४-बिट + लोरा	~३.५-४.५ जीबी	कुछ सौ एमबी	६-१२ जीबी

*एक्टिवेशन, सीक्वेंस लंबाई, बैच साइज़ और ग्रेडिएंट चेकपॉइंटिंग बाकी तय करते हैं। लंबा कॉन्टेक्स्ट (४के-८के) बड़े माइक्रो-बैच के साथ "थ्योरी में फिट" सेटअप को भी ओओएम कर सकता है।

सीमा के पास: gradient_checkpointing=True, माइक्रो-बैच १-२ + एक्यूमुलेशन, सीक्वेंस पैक या लंबाई ग्रुपिंग, एंपियर+ पर बीएफ१६, और क्यूलोरा पर बिट्सएंडबाइट्स एनएफ४ + डबल क्वांट।

रैंक १६ और सीक्वेंस २०४८ वाला १३बी क्यूलोरा एसएफटी अक्सर एक २४ जीबी जीपीयू पर बैठता है। ७०बी क्यूलोरा जॉब को मल्टी-जीपीयू या ऑफलोड चाहिए।

आम असफलताएँ (और उबाऊ फिक्स)

१. स्टाइल कोलैप्स या "मैं सिर्फ लैंग्वेज मॉडल हूँ" लूप
लर्निंग रेट बहुत ऊँचा, या बहुत छोटे सेट पर बहुत एपॉक। लोरा के लिए १ई-४ से २ई-४ के आसपास शुरू करें (अक्सर फुल एफटी से ऊँचा)। होल्ड-आउट पर अर्ली स्टॉप। कई एसएफटी सेट पर एक से तीन एपॉक काफी।

२. ट्रेन लॉस शानदार, प्रॉडक्ट इवैल बेकार
टेम्पलेट मिसमैच। इन्फरेंस वाला ठीक वही चैट टेम्पलेट और सिस्टम प्रॉम्प्ट ट्रेन में लगाएँ। प्रॉडक्शन टूल को एक्सएमएल में लपेटे और ट्रेनिंग प्लेन टेक्स्ट रही हो, तो एडाप्टर गलत सतह सीखता है।

३. क्यूलोरा पर स्टेप १ में ओओएम
एडाप्टर नहीं। एक्टिवेशन मेमोरी या अनपेज्ड ऑप्टिमाइज़र स्पाइक। ग्रेडिएंट चेकपॉइंटिंग चालू करें, max_seq_length काटें, पेज्ड एडमडब्ल्यू ऑन करें, और जाँचें कि पूरा मॉडल गलती से अनफ्रीज़ तो नहीं।

४. मर्ज के बाद एडाप्टर कुछ नहीं करता
आर्किटेक्चर के लिए गलत target_modules नाम, या सिर्फ ऑप्टिमाइज़र स्टेट सेव हुआ। स्टार्टअप पर ट्रेन करने वाले पैरामीटर गिनती प्रिंट करें। शून्य या बेहद छोटी हो तो रात वाला रन रोक दें।

५. रैंक ६४ पर कुछ सौ उदाहरणों का ओवरफिट
लोरा लेयर पर ड्रॉपआउट (०.०५-०.१), रैंक घटाएँ, विविध डेटा, या इवैल-आधारित मज़बूत अर्ली स्टॉप। ऊँची रैंक मुफ्त क्षमता नहीं; याद करने की मुफ्त क्षमता है।

६. मल्टी-जीपीयू एक जीपीयू से धीमा
कम्युनिकेशन ओवरहेड और छोटे ट्रेन टेन्सर। छोटे लोरा जॉब पर एक मज़बूत कार्ड + एक्यूमुलेशन अक्सर खराब स्केल्ड डीडीपी को हराता है।

एक मिनिमल ट्रेनिंग आकार जो काम करता है

from peft import LoraConfig, get_peft_model, TaskType

config = LoraConfig(
    r=16,
    lora_alpha=32,
    lora_dropout=0.05,
    bias="none",
    task_type=TaskType.CAUSAL_LM,
    target_modules=[
        "q_proj", "k_proj", "v_proj", "o_proj",
        "gate_proj", "up_proj", "down_proj",
    ],
)
model = get_peft_model(model, config)
model.print_trainable_parameters()

डेटा को चैट टेम्पलेट पर पैक करें, अगर सिर्फ कम्प्लीशन लॉस चाहिए तो प्रॉम्प्ट टोकन मास्क करें, हर एन स्टेप पर असली टास्क इवैल करें (सिर्फ परप्लेक्सिटी नहीं), और एडाप्टर तथा मर्ज्ड चेकपॉइंट एक्सपोर्ट करें अगर सर्व स्टैक रनटाइम पर पीईएफटी नहीं लोड करता।

संक्षेप

लोरा डेटा क्वालिटी का विकल्प नहीं। यह जीपीयू बजट उन नेटवर्क स्लाइस पर खर्च करता है जो प्रॉडक्ट मीट्रिक हिलाती हैं। मज़बूत इंस्ट्रक्शन बेस पर क्यूलोरा + रैंक १६ + पूरे अटेंशन/एमएलपी मॉड्यूल से शुरू करें। वही प्रॉम्प्ट मापें जो शिप करते हैं। रैंक बढ़ाएँ या और अनफ्रीज़ करें तभी जब इवैल क्षमता माँगे।

अगर ऑफलाइन सूट पर पूरा फाइन-ट्यून अभी भी जीते और हार्डवेयर सँभाल सकें, उसे लें। वरना एडाप्टर शिप करें और बेस फ्रोज़न रखें।