Frontier alignment researchएडवांस्डपाठ 3206 मिनट का पाठ

Debate और weak-to-strong generalisation

ज्यादा ताकतवर सिस्टम्स की निगरानी (supervision) के लिए रिसर्च के दो तरीके: इंसानी जज के सामने AI मॉडल्स को आपस में बहस करने दें, और यह देखें कि क्या एक कमजोर सुपरवाइजर किसी ताकतवर मॉडल को अच्छे से ट्रेन कर सकता है। जानें कि ये प्रयोग क्या दिखा सकते हैं और क्या नहीं।

✦ ट्यूटर से पूछें 🧪 लैब · 40 min 📝 पाठ का टेस्ट

स्पीड

पाठ वीडियो में

60 सेकंड में

Debate और weak-to-strong generalisation

ज्यादा ताकतवर सिस्टम्स की निगरानी (supervision) के लिए रिसर्च के दो तरीके: इंसानी जज के सामने AI मॉडल्स को आपस में बहस करने दें, और यह देखें कि क्या एक कमजोर सुपरवाइजर किसी ताकतवर…

1/6

आसान शब्दों में

अदालत में एक जज को डॉक्टरी के बारे में सब कुछ नहीं पता होता। लेकिन जब दो विशेषज्ञ गवाह आपस में बहस करते हैं और एक-दूसरे की गलतियां निकालते हैं, तो जज अक्सर समझ जाता है कि कौन सही है। AI में डिबेट (debate) भी इसी तरीके का इस्तेमाल करती है।

भाग 1: निगरानी के रूप में डिबेट

Debate में, दो AI सिस्टम किसी सवाल के दो अलग-अलग पक्षों पर होते हैं। वे बारी-बारी से अपने तर्क देते हैं और दूसरे पक्ष की कमियां निकालते हैं। एक इंसानी जज, जो अकेले उस सवाल का जवाब नहीं दे सकता था, तय करता है कि कौन जीता। जीतने वाले को रिवॉर्ड दिया जाता है, जिससे सिस्टम्स को अच्छी तरह बहस करने की ट्रेनिंग मिलती है।

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

1
एक सवाल
"क्या इस लंबे प्रूफ में कोई गलती है?" या "इस 50 पन्नों की रिपोर्ट के बारे में इन दोनों में से कौन सा जवाब सही है?"
2
दो डिबेटर
हर कोई एक जवाब चुनता है और बारी-बारी से उसके पक्ष में तर्क देता है।
3
सबूत दिखाना
डिबेटर सोर्स मटीरियल के छोटे हिस्से कोट (quote) कर सकते हैं जिन्हें जज सीधे चेक कर सके।
4
जज का फैसला
इंसान (या कोई कमजोर मॉडल) ज्यादा ठोस और भरोसेमंद लगने वाले पक्ष को चुनता है।
5
मापना
ऐसे सवालों पर जिनके जवाब पहले से पता हैं: क्या बिना डिबेट के मुकाबले डिबेट के साथ जज ज्यादा बार सही पक्ष को चुनता है?

डिबेट क्यों फेल हो सकती है

बात मनवा लेना ही सच नहीं होता। हो सकता है कि जज को ज्यादा आत्मविश्वासी, धाराप्रवाह या पसंद आने वाला पक्ष बेहतर लगे।
उलझाए हुए तर्क (Obfuscated arguments)। हो सकता है कि कोई बेईमान डिबेटर इतना लंबा और पेचीदा तर्क बना दे कि ईमानदार पक्ष दिए गए समय में उसकी असल गलती न पकड़ पाए।
साझा कमजोरियां (Shared blind spots)। अगर दोनों डिबेटर एक ही मॉडल की कॉपियां हैं, तो हो सकता है कि दोनों से एक ही गलती छूट जाए।
बड़े पैमाने पर टेस्ट करना मुश्किल। आज के प्रयोग उन कामों पर होते हैं जहां इंसान जवाब चेक कर सकते हैं, जो कि भविष्य में होने वाली स्थिति से बिल्कुल अलग है।

कुछ पब्लिश हुए प्रयोगों में पाया गया है कि कुछ खास सेटअप्स में डिबेट ने गैर-विशेषज्ञ जजों को सवालों के ज्यादा सटीक जवाब देने में मदद की—जैसे पढ़ने और समझने वाले (reading-comprehension) टास्क में, जहां केवल डिबेटर ही पूरा टेक्स्ट देख सकते थे। बाकी नतीजे मिले-जुले रहे। डिबेट को एक उम्मीद जगाने वाला लेकिन अभी तक अप्रमाणित आइडिया ही समझें।

भाग 2: Weak-to-strong generalisation

भविष्य में इंसानों को ऐसे AI की निगरानी करनी पड़ सकती है जो उनसे ज्यादा ताकतवर हो। हम अभी वह प्रयोग नहीं कर सकते। इसलिए रिसर्चर्स एक सादृश्य (analogy) पर अध्ययन करते हैं: एक छोटे, कमजोर मॉडल को सुपरवाइजर बनाएं, और एक बड़े, ताकतवर मॉडल को स्टूडेंट की तरह इस्तेमाल करें।

1
एक कमजोर सुपरवाइजर को ट्रेन करें
एक छोटा मॉडल सही लेबल्स (true labels) से काम सीखता है। यह कई गलतियां करता है।
2
कमजोर लेबल्स (Weak labels)
कमजोर सुपरवाइजर एक नए डेटासेट पर लेबल्स लगाता है, जिसमें गलतियां भी शामिल होती हैं।
3
ताकतवर स्टूडेंट को ट्रेन करें
एक बहुत ज्यादा ताकतवर मॉडल को सिर्फ उन्हीं कमजोर लेबल्स पर ट्रेन किया जाता है।
4
अधिकतम क्षमता (ceiling) से तुलना करें
उसी ताकतवर मॉडल को सही लेबल्स (true labels) पर ट्रेन करें। इससे पता चलता है कि वह सबसे बेहतर क्या कर सकता था।
5
सवाल पूछें
क्या स्टूडेंट सिर्फ अपने टीचर की गलतियों की नकल करता है, या वह टीचर से बेहतर प्रदर्शन करता है?

इसे नापने का एक उपयोगी पैमाना performance gap recovered (PGR) है। अगर कमजोर सुपरवाइजर का स्कोर W है, ताकतवर सीलिंग का स्कोर C है, और स्टूडेंट का स्कोर S है, तो PGR = (S − W) ÷ (C − W)। 0 PGR का मतलब है कि स्टूडेंट अपने टीचर से बिल्कुल भी बेहतर नहीं है। 1 PGR का मतलब है कि कमजोर लेबल्स के बावजूद स्टूडेंट अपनी पूरी क्षमता तक पहुंच गया।

कुछ पब्लिश हुए प्रयोगों में, ताकतवर स्टूडेंट्स ने अपने कमजोर सुपरवाइजर्स से बेहतर प्रदर्शन किया, लेकिन वे अपनी पूरी क्षमता (ceiling) तक नहीं पहुंच पाए। कुछ सेटिंग्स में ट्रेनिंग की कुछ अतिरिक्त तरकीबों से मदद मिली। उम्मीद यह है कि ताकतवर मॉडल्स प्रीट्रेनिंग से पहले ही सही कॉन्सेप्ट "जानते" हैं, और कमजोर लेबल्स को बस उन्हें उस दिशा में मोड़ना होता है।

ये प्रयोग क्या दिखा सकते हैं और क्या नहीं

वे दिखा सकते हैं

क्या कोई तरीका आज के टास्क्स पर किसी ताकतवर मॉडल को कमजोर सुपरवाइजर से आगे निकलने में मदद करता है
स्टूडेंट सुपरवाइजर की किस तरह की गलतियों की नकल करता है
एक साफ नंबर के साथ निगरानी के तरीकों की तुलना कैसे करें

वे नहीं दिखा सकते

कि यही तरीका बहुत ज्यादा समझदार AI की निगरानी करने वाले इंसानों के लिए भी काम करेगा
क्या होगा अगर ताकतवर मॉडल सुपरवाइजर को धोखा देने की कोशिश कर रहा हो
कि किसी एक टास्क का नतीजा बिल्कुल अलग टास्क्स पर भी लागू होगा

एक अहम अंतर

हो सकता है कि किसी छोटे मॉडल की गलतियां इंसानी गलतियों से बिल्कुल अलग तरह की हों। और भविष्य का कोई ताकतवर मॉडल इंसानी गलतियों को बहुत अच्छे से समझ सकता है, जिससे उसके लिए उनकी नकल करना ज्यादा आसान हो जाता है। तरीके तैयार करने के लिए यह तुलना उपयोगी है, लेकिन रिसर्चर्स में इस बात पर बहस है कि यह हमें असली स्थिति के बारे में कितना कुछ बताती है।

इसे आजमाएं। नीचे दिया गया लैब शुद्ध Python में बना एक छोटा weak-to-strong प्रयोग है। इसे चलाने से पहले अंदाजा लगाएं: क्या ताकतवर स्टूडेंट कमजोर टीचर की गलतियों की नकल करेगा, या उन्हें सुधार देगा?

और देखें और पढ़ें

arXiv: search for "weak-to-strong generalization" and "AI safety via debate"arXiv · reading

लैब

शुद्ध Python में एक छोटा weak-to-strong प्रयोग, एक कंट्रोल कंडीशन और एक संक्षिप्त विवरण के साथ।

~40 min

समस्या

शुरुआती कोड एक आसान क्लासिफ़िकेशन टास्क बनाता है। एक weak मॉडल 6 इनपुट फ़ीचर्स में से सिर्फ़ 3 ही देख सकता है। एक strong मॉडल सभी 6 देख सकता है। आप इनकी तुलना करेंगे:

weak मॉडल के लेबल्स (एक पैटर्न वाली गलतियाँ) पर ट्रेन किए गए strong स्टूडेंट, और
एक कंट्रोल: लेबल्स में उतनी ही संख्या में गलतियों के साथ ट्रेन किए गए strong स्टूडेंट, लेकिन जहाँ गलतियाँ रैंडम तरीके से की गई हों।

कोड चलाने से पहले दोनों PGR वैल्यूज़ के लिए अपना अनुमान लिखें।
कोड चलाएँ (Python 3, कोई अतिरिक्त पैकेज नहीं)। फिर इसे random.seed(...) में 3 अलग-अलग वैल्यूज़ के साथ दोबारा चलाएँ।
एक छोटी सी टेबल में हर रन के लिए accuracy और PGR रिकॉर्ड करें।
आधा पेज लिखें: पैटर्न वाली गलतियाँ और रैंडम गलतियाँ यहाँ इतना अलग व्यवहार क्यों करती हैं? प्रीट्रेन्ड लैंग्वेज मॉडल्स वाले असली weak-to-strong प्रयोगों की तुलना में इस टॉय में किस चीज़ की कमी है?

प्रैक्टिस लैब

कोड में बदलाव करें और इसे रन करें। Python आपके ब्राउज़र में चलता है — हमारे सर्वर पर कुछ नहीं भेजा जाता।

रन करने के लिए Ctrl + Enter दबाएं

# Toy weak-to-strong experiment. Standard library only.
import math, random

random.seed(0)
D = 6                                   # number of features
TRUE_W = [1.0, -2.0, 0.5, 1.5, -1.0, 2.0]

def make_data(n):
    xs = [[random.gauss(0, 1) for _ in range(D)] for _ in range(n)]
    ys = [1 if sum(w * v for w, v in zip(TRUE_W, x)) > 0 else 0 for x in xs]
    return xs, ys

def train(xs, ys, features, epochs=20, lr=0.01):
    """Logistic regression that may only look at some features."""
    w = [0.0] * D
    for _ in range(epochs):
        for x, y in zip(xs, ys):
            z = sum(w[i] * x[i] for i in features)
            p = 1 / (1 + math.exp(-max(-30, min(30, z))))
            for i in features:
                w[i] += lr * (y - p) * x[i]
    return lambda x: 1 if sum(w[i] * x[i] for i in features) > 0 else 0

def accuracy(model, xs, ys):
    return sum(model(x) == y for x, y in zip(xs, ys)) / len(ys)

ALL, FEW = list(range(D)), [0, 1, 5]     # the weak model sees only 3 features
train_x, train_y = make_data(2000)
test_x, test_y = make_data(2000)

weak = train(train_x, train_y, FEW)                  # weak supervisor
ceiling = train(train_x, train_y, ALL)               # strong model, true labels
weak_labels = [weak(x) for x in train_x]             # patterned mistakes
student = train(train_x, weak_labels, ALL)           # strong model, weak labels

# Control: the same number of wrong labels, but placed at random.
wrong = sum(a != b for a, b in zip(weak_labels, train_y))
flip = set(random.sample(range(len(train_y)), wrong))
noisy_labels = [1 - y if i in flip else y for i, y in enumerate(train_y)]
student_random = train(train_x, noisy_labels, ALL)

w_acc, c_acc = accuracy(weak, test_x, test_y), accuracy(ceiling, test_x, test_y)
for name, m in [("strong on weak labels", student),
                ("strong on random-noise labels", student_random)]:
    s_acc = accuracy(m, test_x, test_y)
    pgr = (s_acc - w_acc) / (c_acc - w_acc)
    print(f"{name:30s} acc={s_acc:.3f}  PGR={pgr:.2f}")
print(f"weak supervisor acc={w_acc:.3f}   strong ceiling acc={c_acc:.3f}")

आउटपुट

कोई आउटपुट नहीं। वैल्यूज़ देखने के लिए print(...) जोड़ें।

आपका काम तब पूरा होगा जब

कोड चलाने से पहले अनुमान लिखे गए थे
सिर्फ़ एक रन के नहीं, बल्कि कम से कम 3 random seeds के नतीजे बताए गए हैं
राइट-अप में यह समझाया गया है कि स्टूडेंट पैटर्न वाली गलतियों की हूबहू नकल कर सकता है, जबकि रैंडम गलतियाँ आम तौर पर बेअसर हो जाती हैं
राइट-अप में कम से कम एक ऐसी चीज़ का ज़िक्र है जिसकी कमी इस टॉय में है, जैसे कि एक ऐसा प्रीट्रेन्ड मॉडल जो कॉन्सेप्ट को पहले से जानता हो

कठिन सवाल

उत्तर देखने से पहले ख़ुद जवाब देने की कोशिश करें। अगर आप इनके जवाब दे सकते हैं, तो आप पाठ समझ गए हैं।

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

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

Q2strong AI की निगरानी करते समय इंसानों की कौन सी गलतियाँ सबसे ज़्यादा खतरनाक होती हैं, इस बारे में यह टॉय क्या इशारा करता है?दिखाएं

रैंडम, कभी-कभार होने वाली गलतियाँ औसत में छिप सकती हैं। व्यवस्थित गलतियाँ, जहाँ इंसान लगातार एक तय तरीके से गलत होते हैं (उदाहरण के लिए, हमेशा आत्मविश्वास से भरे लगने वाले जवाबों को पसंद करना), उन्हें मॉडल सीख सकता है और उनकी हूबहू नकल कर सकता है, क्योंकि उनसे मेल खाने पर रिवॉर्ड मिलता है। एक सक्षम मॉडल ऐसे पैटर्न्स को पहचानने में भी बेहतर होता है। इसलिए oversight रिसर्च को सिर्फ़ कुल गलतियों की दर पर ही नहीं, बल्कि इंसानों के व्यवस्थित पूर्वाग्रहों (systematic biases) पर भी खास ध्यान देना चाहिए।

जारी रखने के लिए कृपया साइन इन करें।

अक्सर पूछे जाने वाले सवाल

क्या बड़े कमर्शियल मॉडल्स को ट्रेन करने के लिए डिबेट का इस्तेमाल किया गया है?

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

कमजोर सुपरवाइजर के तौर पर असली इंसानों के बजाय छोटे मॉडल का इस्तेमाल क्यों करें?

यह सस्ता है, इसे बार-बार दोहराया जा सकता है और इससे बहुत सारा डेटा मिलता है। आप यह भी ठीक-ठीक माप सकते हैं कि सुपरवाइजर कितना कमजोर है। इंसानों पर की जाने वाली स्टडीज ज्यादा वास्तविक होती हैं लेकिन धीमी और उनमें वेरिएशन (शोर) ज्यादा होता है। अच्छे रिसर्च प्रोग्राम्स दोनों का इस्तेमाल करते हैं।

1 से ज्यादा PGR का क्या मतलब है?

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

क्या डिबेट से मॉडल्स हेरफेर (manipulation) करने में और माहिर हो सकते हैं?

यह एक वास्तविक चिंता है। बहस जीतने के लिए सिस्टम्स को ट्रेन करने से बात मनवाने वाली चालाकियों को बढ़ावा मिल सकता है। यही वजह है कि डिबेट की स्टडीज में यह मापा जाता है कि क्या जज ज्यादा सटीक हुए हैं, न कि केवल यह कि कौन सा पक्ष जीता, और इसीलिए कुछ रिसर्चर्स इसे लेकर सतर्क रहते हैं।

पाठ का टेस्ट

5 सवाल। पास होने और इस पाठ को पूरा करने के लिए 3 सही होने चाहिए (60%)।

टेस्ट देने और अपनी प्रोग्रेस सेव करने के लिए साइन इन करें

Debate और weak-to-strong generalisation

Debate और weak-to-strong generalisation

भाग 1: निगरानी के रूप में डिबेट

एक सवाल

दो डिबेटर

सबूत दिखाना

जज का फैसला

मापना

डिबेट क्यों फेल हो सकती है

भाग 2: Weak-to-strong generalisation

एक कमजोर सुपरवाइजर को ट्रेन करें

कमजोर लेबल्स (Weak labels)

ताकतवर स्टूडेंट को ट्रेन करें

अधिकतम क्षमता (ceiling) से तुलना करें

सवाल पूछें

ये प्रयोग क्या दिखा सकते हैं और क्या नहीं

एक अहम अंतर

और देखें और पढ़ें

समस्या

प्रैक्टिस लैब

आपका काम तब पूरा होगा जब

कठिन सवाल

अक्सर पूछे जाने वाले सवाल