Abliterated मॉडल क्या होता है?

20 अग॰ 2026 · 7 मिनट में पढ़ें · abliteration, uncensored-models

Abliterated मॉडल (abliteration — वेट्स की सर्जरी से इनकार हटाना) एक सामान्य ओपन-वेट मॉडल होता है जिसके इनकार करने के व्यवहार को उसके वेट्स में सीधे बदलाव करके सर्जिकल तरीक़े से हटा दिया गया है — न उसे दोबारा ट्रेन करके, न किसी चालाक प्रॉम्प्ट में लपेटकर। यह नाम ablate और obliterate को जोड़कर बना है, और यह तंत्र को सटीक रूप से बताता है: आप एक्टिवेशन स्पेस में वह एक दिशा पहचानते हैं जो "मुझे इसे मना कर देना चाहिए" का भाव लिए चलती है, और फिर नेटवर्क के लिए उस दिशा में दोबारा कभी कुछ लिख पाना असंभव बना देते हैं।

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

इनकार residual stream में रहता है

ट्रांसफ़ॉर्मर का residual stream वह चलता हुआ वेक्टर है — हर टोकन पोज़िशन के लिए एक — जिसे हर ब्लॉक पढ़ता है और जिसमें वापस लिखता है। अटेंशन हेड और MLP अपने आउटपुट उसमें जोड़ते हैं; कोई उसे ओवरराइट नहीं करता। इसी जोड़ने वाली (additive) संरचना की वजह से residual stream की किसी दिशा का मतलब लेयर 10 और लेयर 40 पर लगभग एक जैसा होता है, और ठीक यही गुण आपको "इनकार की दिशा" (refusal direction) को चालीस अलग-अलग चीज़ों की बजाय एक ही वस्तु की तरह देखने देता है।

इसे ढूँढ़ने के लिए आपको प्रॉम्प्ट के दो सेट चाहिए: एक जिसे मॉडल भरोसेमंद ढंग से मना करता है, और एक जिसका वह भरोसेमंद ढंग से जवाब देता है। दोनों चलाएँ, एक तय लेयर और टोकन पोज़िशन पर residual-stream की एक्टिवेशन कैप्चर करें (इंस्ट्रक्शन के आख़िरी कुछ टोकन अच्छा काम करते हैं, क्योंकि वहाँ तक मॉडल अनुरोध पढ़ चुका होता है पर जवाब देना शुरू नहीं किया होता), और दोनों के औसत (mean) का अंतर निकाल लें।

python

import torch

def refusal_direction(harmful: torch.Tensor, harmless: torch.Tensor) -> torch.Tensor:
    """Difference-in-means estimate of the refusal direction, unit-normalised.

    Both tensors are [n_prompts, d_model] residual-stream activations captured at
    the same layer and token position. Difference-in-means beats a trained probe
    here: with a few hundred prompts a probe overfits, a mean shift does not.
    """
    r = harmful.mean(dim=0) - harmless.mean(dim=0)
    return r / r.norm()

यह आप हर उम्मीदवार लेयर और पोज़िशन पर करते हैं, जिससे दर्जनों उम्मीदवार दिशाएँ मिलती हैं, और फिर उनमें से एक चुनते हैं। चयन निकालने से ज़्यादा मायने रखता है: सही कसौटी है — इस उम्मीदवार को ablate करो, फिर मापो कि होल्ड-आउट हानिकारक प्रॉम्प्ट पर इनकार कितना घटा और हानिरहित प्रॉम्प्ट पर अगले टोकन का वितरण (next-token distribution) कितना खिसका। वह दूसरा आँकड़ा — आम तौर पर बिना बदले मॉडल के मुक़ाबले KL डाइवर्जेंस — आपका नुक़सान का मीटर है। जो उम्मीदवार इनकार तो ख़त्म कर देता है पर हानिरहित वितरण को बुरी तरह हिला देता है, वह उससे बदतर विकल्प है जो थोड़ा कम इनकार हटाए पर उसका साइड-इफ़ेक्ट बहुत कम हो।

Abliterated मॉडल बनता कैसे है

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

दूसरा — असली abliteration — इसे वेट्स में ही पका देता है। residual stream में लिखने वाली हर मैट्रिक्स को एक रैंक-वन अपडेट मिलता है जो उसके आउटपुट स्पेस से r को हटा देता है: एम्बेडिंग मैट्रिक्स, हर अटेंशन आउटपुट प्रोजेक्शन, हर MLP डाउन-प्रोजेक्शन।

python

def orthogonalize_(weight: torch.Tensor, r: torch.Tensor) -> None:
    """Project r out of a matrix that writes into the residual stream, in place.

    weight is [d_model, d_in]. After W <- (I - r rT) W, the product W @ x has zero
    component along r for every possible x, so no amount of prompting can put the
    direction back. Rank-one per matrix; no gradients, no optimiser, no dataset of
    answers — only the few hundred prompts used to estimate r.
    """
    weight -= torch.outer(r, r @ weight)

नतीजा एक साधारण चेकपॉइंट होता है। वही आर्किटेक्चर, वही फ़ाइल फ़ॉर्मैट, वही इन्फ़रेंस लागत, vLLM या llama.cpp में बिना किसी बदलाव के लोड हो जाता है। एक अकेले GPU पर पूरी प्रक्रिया मिनटों में चल जाती है, और महँगा हिस्सा उम्मीदवारों का स्वीप है, संपादन नहीं।

यह फ़ाइन-ट्यूनिंग से कैसे अलग है

इनकार हटाने के लिए फ़ाइन-ट्यूनिंग — आज्ञाकारी जवाबों के कॉर्पस पर SFT या DPO — बुनियादी तौर पर एक अलग ऑपरेशन है। वह ग्रेडिएंट डिसेंट से हर वेट को हिलाता है, उसे सिर्फ़ प्रॉम्प्ट नहीं बल्कि जवाबों का डेटासेट चाहिए, उसमें GPU-घंटे लगते हैं, और वह मौजूदा व्यवहार मिटाने की बजाय नया व्यवहार सिखाता है। साथ ही, फ़ाइन-ट्यूनिंग कॉर्पस में जो भी शैली, लंबाई का झुकाव और तथ्यों की अजीबियत मौजूद हैं, वह उन्हें भी घसीट लाता है, और असंबंधित क्षमताओं के catastrophic forgetting का ख़तरा पैदा करता है।

Abliteration एक रैंक-वन सबस्पेस को छूती है और कुछ नहीं। यही सटीकता इसकी सबसे बड़ी ख़ूबी है और इसकी सबसे बड़ी नाकामी का स्रोत भी: अगर r की दिशा में इनकार के अलावा कुछ और भी रहता हो, तो वह भी नष्ट हो जाता है, और स्वीप में कितनी भी सावधानी बरतो, यह पूरी तरह टाला नहीं जा सकता।

यह जेलब्रेक प्रॉम्प्टिंग से कैसे अलग है

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

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

समझौतों के बारे में ईमानदार रहें

Abliterated मॉडल कोई बेहतर मॉडल नहीं है। यह एक ऐसा मॉडल है जिसने "नहीं" कहना बंद कर दिया है, और यह दावा जितना लगता है उससे कहीं संकरा है।

क्षमता में गिरावट (capability drift)। हर write मैट्रिक्स से एक दिशा हटाने की मापने लायक़ लागत है। Abliterated चेकपॉइंट आम तौर पर एज केस में कमज़ोर इंस्ट्रक्शन-फ़ॉलोइंग, प्रॉम्प्ट में दी गई ग़लत पूर्वधारणाओं से ज़्यादा सहमति, और रीज़निंग बेंचमार्क पर छोटी-मोटी गिरावट दिखाते हैं।
इनकार पूरी तरह एक-आयामी नहीं है। एक दिशा ज़्यादातर व्यवहार पकड़ती है, पूरा नहीं। उम्मीद रखें कि कुछ इनकार बचे रहेंगे, और उन व्यवहारों पर भी कुछ साइड-इफ़ेक्ट होगा जो वही दिशा साझा करते हैं।
कोई नया ज्ञान नहीं। Abliteration कुछ जोड़ती नहीं। जहाँ बेस मॉडल सावधानी का लिबास ओढ़े अज्ञान की वजह से मना कर देता, वहाँ अब आपको आत्मविश्वास से भरी मनगढ़ंत बात मिलती है — जो किसी इवैल्यूएशन पाइपलाइन के लिए इनकार से भी बदतर हो सकती है, क्योंकि इनकार कम से कम एक ईमानदार संकेत है जिसे आप पकड़ सकते हैं।
प्रॉम्प्ट सेट ही संपादन तय करते हैं। संकरा हानिकारक सेट संकरी दिशा देता है। एक ही बेस मॉडल की दो abliteration एक-दूसरे की जगह नहीं ले सकतीं।

बहुत से प्रकाशित abliterated मॉडलों को बाद में घटी हुई क्षमता वापस पाने के लिए एक हल्का मरम्मती फ़ाइन-ट्यून दिया जाता है — जो चुपचाप वही लागत वापस ले आता है जिससे बचना इस तकनीक का मक़सद था।

यह कहाँ काम आता है

ईमानदार उपयोग वह काम है जहाँ इनकार सुरक्षा की जीत नहीं बल्कि माप की त्रुटि है: रेड-टीमिंग हार्नेस, इनकार-दर की बेसलाइन, रोबस्टनेस इवैल्यूएशन, और ऐसा सुरक्षा विश्लेषण जहाँ विषय-वस्तु गार्डरेल को ट्रिगर कर देती है, भले ही काम रक्षात्मक हो। unbleep abliterated मॉडलों को एक OpenAI-संगत एंडपॉइंट के पीछे परोसता है, ताकि आप अपना मौजूदा क्लाइंट उनकी ओर मोड़ सकें और एक स्थिर बेसलाइन पा सकें। उससे आप क्या बनाते हैं, यह आपकी ज़िम्मेदारी है — जिन लकीरों को हम पार नहीं करते, उनके लिए स्वीकार्य उपयोग नीति देखें।

API कुंजी लें और फ़र्क़ ख़ुद मापें।