KaPilot: LLM-Assisted Generation of Kani Specifications for Unsafe Rust Verification
KaPilot एक मल्टी-एजेंट फ्रेमवर्क है जो अनसेफ रस्ट (unsafe Rust) कोड में मेमोरी सेफ्टी को सत्यापित करने के लिए कानी (Kani) स्पेसिफिकेशन को स्वचालित रूप से उत्पन्न करने और पुनरावृत्ति से परिष्कृत करने के लिए लार्ज लैंग्वेज मॉडल्स का लाभ उठाता है, जो AutoSpec जैसे मौजूदा टूल्स की तुलना में काफी उच्च सफलता दर और स्पेसिफिकेशन गुणवत्ता प्राप्त करता है।
मूल पेपर CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/) के तहत लाइसेंस किया गया है। नीचे दिए गए पेपर की यह व्याख्या AI से तैयार की गई है। इसे लेखकों ने न तो लिखा है, न इसका समर्थन किया है। तकनीकी सटीकता के लिए मूल पेपर देखें। पूरा डिस्क्लेमर पढ़ें
कल्पना कीजिए कि आप जादुई, स्वयं-सुधार करने वाली ईंटों के एक सेट के साथ एक घर बना रहे हैं। ये ईंटें, जिन्हें "Rust" कहा जाता है, इसलिए प्रसिद्ध हैं क्योंकि इनमें एक अंतर्निहित सुरक्षा निरीक्षक (safety inspector) है जो आपको कुछ भी अस्थिर बनाने से मना कर देता है। यदि आप दीवार की जगह खिड़की लगाने की कोशिश करते हैं, तो निरीक्षक चिल्लाकर "नहीं!" कहता है और आपको पहला पत्थर रखने से पहले ही रोक देता है। यह Rust को सॉफ्टवेयर बनाने के लिए अविश्वसनीय रूप से सुरक्षित बनाता है, जिससे क्रैश और सुरक्षा खामियों को होने से पहले ही रोका जा सके। हालाँकि, कभी-कभी एक मास्टर बिल्डर को कुछ ऐसा करने की आवश्यकता होती है जिसे निरीक्षक समझ नहीं पाता—जैसे कि एक भारी बीम को तेज़ी से हिलाने के लिए एक विशेष, खतरनाक उपकरण का उपयोग करना। Rust की दुनिया में, इसे "unsafe code" कहा जाता है। यह एक गुप्त पास की तरह है जो आपको निरीक्षक को बायपास करने की अनुमति देता है, लेकिन इसकी एक भारी कीमत है: यदि आप एक भी गलती करते हैं, तो पूरा घर ढह सकता है। घर को खड़ा रखने के लिए, आपको एक बहुत ही सख्त, गणितीय "नियम पुस्तिका" (जिसे specification कहा जाता है) लिखने की आवश्यकता है जो यह सिद्ध करे कि इन खतरनाक उपकरणों का उपयोग बिल्कुल कैसे किया जाए। लेकिन इन नियम पुस्तिकाओं को हाथ से लिखना अविश्वसनीय रूप से कठिन, धीमा और मानवीय त्रुटियों के प्रति संवेदनशील है।
यहीं से KaPilot की कहानी शुरू होती है। इस परियोजना के पीछे के शोधकर्ताओं ने एक सरल प्रश्न पूछा: क्या हम एक सुपर-स्मार्ट कंप्यूटर मस्तिष्क (एक AI) को हमारे लिए ये सुरक्षा नियम लिखने के लिए सिखा सकते हैं? चुनौती यह है कि ये AI कोड लिखने में माहिर हैं, लेकिन वे अक्सर उस कोड की गलतियों को ही कॉपी कर लेते हैं जो वे देखते हैं, बजाय इसके कि वे उसके पीछे के इरादे (intent) को समझें। वे एक ऐसी नियम पुस्तिका लिख सकते हैं जो दिखने में तो एकदम सही हो, लेकिन उसमें एक छोटी सी, घातक बारीकी छूट गई हो। यह शोध पत्र KaPilot को प्रस्तुत करता है, जो एजेंटों की एक टीम है जो इस पहेली को सुलझाने के लिए मिलकर काम करती है। केवल "एक नियम लिखें" कहने के बजाय, KaPilot एक जासूस, एक लेखक और एक सख्त संपादक की तरह कार्य करता है। यह बिल्डर के नोट्स (documentation) को पढ़ता है, वास्तविक सुरक्षा नियमों को निकालता है, एक ड्राफ्ट लिखता है, इसमें मौजूद कमियों की जांच करता है, और फिर यह सुनिश्चित करने के लिए इसे एक कठोर परीक्षण से गुजारता है कि यह वास्तव में काम करता है। परिणाम एक ऐसा सिस्टम है जो खतरनाक कोड के लिए उच्च गुणवत्ता वाले सुरक्षा नियम स्वचालित रूप से उत्पन्न कर सकता है, जिससे हर एक नियम को मानव विशेषज्ञों द्वारा हाथ से लिखे बिना भी सुरक्षित सॉफ्टवेयर बनाना बहुत आसान हो जाता है।
जासूस, लेखक और संपादक
Unsafe Rust कोड को सत्यापित करने की प्रक्रिया को एक उच्च गति वाली रेस कार के लिए एक आदर्श निर्देश मैनुअल लिखने की कोशिश करने के रूप में समझें जिसमें ब्रेक नहीं हैं। यदि मैनुअल गलत है, तो कार दुर्घटनाग्रस्त हो जाएगी। यदि मैनुअल बहुत अस्पष्ट है, तो ड्राइवर को पता नहीं चलेगा कि गाड़ी कैसे चलानी है। यदि मैनुअल बहुत सख्त है, तो ड्राइवर हिल भी नहीं पाएगा।
KaPilot एक मल्टी-एजेंट फ्रेमवर्क है, जिसका सीधा सा अर्थ है विशेषज्ञों की एक टीम जो मिलकर काम करती है। यहाँ बताया गया है कि वे अपनी भूमिकाएँ कैसे निभाते हैं:
- जासूस (SafetyReq): कुछ भी लिखने से पहले, टीम को यह जानने की आवश्यकता है कि नियम क्या होने चाहिए। आमतौर पर, ये नियम उन अव्यवस्थित, मानव-लिखित नोट्स (documentation) में छिपे होते हैं जो कोड के साथ आते हैं। "SafetyReq" एजेंट एक जासूस की तरह कार्य करता है। यह इन नोट्स को पढ़ता है, अनावश्यक बातों को हटा देता है, और नियमों की एक साफ, संक्षिप्त सूची निकालता है। यह एक लंबी कहानी को एक स्पष्ट, क्रमांकित सूची में बदलने जैसा है: "1. लाल बटन न दबाएं। 2. लाल बटन से 5 फीट के भीतर न खड़े हों।" यह चरण महत्वपूर्ण है क्योंकि यह AI को कोड की गलतियों को केवल कॉपी करने से रोकता है।
- लेखक (SpecGenerate): एक बार जब जासूस के पास सूची आ जाती है, तो "SpecGenerate" एजेंट कदम रखता है। यह वह लेखक है जो उस सूची को एक औपचारिक, गणितीय भाषा में बदल देता है जिसे कंप्यूटर समझ सके (विशेष रूप से, Kani नामक भाषा)। यह केवल अनुमान नहीं लगाता; यह जासूस की सूची का एक सख्त मार्गदर्शक के रूप में उपयोग करता है।
- संपादक (SpecPrecheck): लेखक के ड्राफ्ट को अंतिम बॉस के पास भेजने से पहले, "SpecPrecheck" एजेंट इसकी समीक्षा करता है। यह एक सख्त संपादक है जो पूछता है: "क्या आपने जासूस द्वारा खोजे गए प्रत्येक बिंदु को कवर किया है? क्या आपका वाक्य बहुत कमजोर है? क्या यह बहुत मजबूत है?" यदि ड्राफ्ट ढीला है, तो संपादक इसे सुधार के विशिष्ट नोट्स के साथ लेखक के पास वापस भेज देता है। यह एक लूप में तब तक चलता रहता है जब तक कि ड्राफ्ट ठोस न हो जाए।
- टेस्ट ड्राइवर (SpecVerify): अंत में, "SpecVerify" एजेंट ड्राफ्ट लेता है और इसे एक वास्तविक दुनिया के परीक्षण से गुजारता है। यह यह देखने के लिए कि क्या कार दुर्घटनाग्रस्त होती है, लाखों अलग-अलग ड्राइविंग परिदृश्यों को सिम्युलेट करने के लिए Kani नामक टूल का उपयोग करता है। यदि कार दुर्घटनाग्रस्त होती है (सत्यापन विफल होता है), तो टेस्ट ड्राइवर लेखक को ठीक से बताता है कि दुर्घटना क्यों हुई, और लूप फिर से शुरू हो जाता है।
"शफल और मिक्स" रणनीति
यहाँ टीम वास्तव में चतुर हो जाती है। कभी-कभी AI नियम पुस्तिका के कुछ अलग संस्करण उत्पन्न करता है। एक संस्करण में एक आदर्श "शुरुआती स्थिति" (precondition) हो सकती है लेकिन एक कमजोर "अंतिम स्थिति" (postcondition)। दूसरे में एक कमजोर शुरुआत लेकिन एक आदर्श अंत हो सकता है। यदि आप केवल एक को चुनते हैं, तो आप सबसे अच्छे संयोजन को मिस कर सकते हैं।
KaPilot "शफल-एंड-इम्प्लिकेशन" (shuffle-and-implication) नामक रणनीति का उपयोग करता है। कल्पना कीजिए कि आपके पास ताश की एक गड्डी है, जहाँ प्रत्येक कार्ड नियम पुस्तिका का एक अलग हिस्सा है। टीम इन कार्डों को इधर-उधर शफल करती है, एक संस्करण के सबसे अच्छे "शुरुआत" को दूसरे के सबसे अच्छे "अंत" के साथ मिलाती है। वे फिर इन नए संयोजनों का परीक्षण करते हैं ताकि वे देख सकें कि क्या वे मूल ड्राफ्ट से भी बेहतर काम करते हैं। यह एक कार के सबसे अच्छे इंजन को दूसरी कार के सबसे अच्छे टायरों के साथ मिलाकर एक परम रेस कार बनाने जैसा है। यह सुनिश्चित करता है कि वे केवल एक "ठीक-ठाक" नियम पुस्तिका के साथ समझौता न करें, बल्कि सबसे अच्छी संभव नियम पुस्तिका खोजें।
उन्होंने क्या पाया
शोधकर्ताओं ने KaPilot का परीक्षण 124 अलग-अलग unsafe Rust कोड पर किया। उन्होंने इन्हें दो समूहों में विभाजित किया:
- गोल्ड सेट (54 फंक्शन्स): इनके पास मानव विशेषज्ञों द्वारा लिखी गई "ग्राउंड ट्रुथ" नियम पुस्तिकाएं थीं, ताकि टीम यह जांच सके कि KaPilot का काम सही था या नहीं।
- अल्ट्रा सेट (70 फंक्शन्स): इनमें कोई मानव नियम पुस्तिका नहीं थी, इसलिए टीम ने केवल यह जांचा कि क्या KaPilot कोई भी काम करने वाली नियम पुस्तिका बना सकता है।
परिणाम प्रभावशाली थे। गोल्ड सेट के लिए, KaPilot ने 88.9% फंक्शन्स के लिए सफलतापूर्वक एक काम करने वाली नियम पुस्तिका तैयार की। इससे भी महत्वपूर्ण बात यह है कि 57.4% बार, जो नियम पुस्तिका उसने लिखी, वह मानव विशेषज्ञों द्वारा लिखी गई तुलना में उतनी ही अच्छी या उससे बेहतर थी। अल्ट्रा सेट के लिए, यह 71.4% फंक्शन्स के लिए काम करने वाली नियम पुस्तिकाएं बनाने में सफल रहा।
जब उन्होंने KaPilot की तुलना एक अन्य AI टूल AutoSpec (जिसे इस नई प्रणाली के साथ काम करने के लिए अनुकूलित किया गया था) से की, तो KaPilot ने स्पष्ट जीत हासिल की। इसने 14.8% अधिक नियम पुस्तिकाएं बनाईं जो वास्तव में परीक्षणों में पास हुईं, और 25.9% अधिक नियम पुस्तिकाएं बनाईं जो मानव-लिखित नियमों के समान या उनसे बेहतर थीं।
यह क्यों मायने रखता है
यह शोध पत्र तर्क देता है कि केवल AI से "इस कोड के आधार पर एक सुरक्षा नियम लिखें" कहना अच्छी तरह से काम नहीं करता है। AI कोड की खामियों को कॉपी करने लगता है या जटिलता से भ्रमित हो जाता है। कार्य को विशेषज्ञों की एक टीम में तोड़कर—एक नोट्स पढ़ने के लिए, एक लिखने के लिए, एक संपादित करने के लिए और एक परीक्षण करने के लिए—KaPilot इन समस्याओं से बच जाता है।
शोधकर्ताओं ने यह भी पाया कि मानव नोट्स (documentation) की गुणवत्ता बहुत मायने रखती है। यदि नोट्स अस्पष्ट हैं, तो AI संघर्ष करता है। लेकिन जब नोट्स स्पष्ट होते हैं, तो KaPilot चमकता है। उन्होंने यह भी खोजा कि उनकी "शफल" रणनीति एक प्रमुख घटक थी; इसके बिना, सिस्टम अक्सर एक पूर्ण समाधान खोजने के बजाय एक औसत दर्जे के समाधान पर ही रुक जाता।
संक्षेप में, KaPilot सुझाव देता है कि हमें मानव विशेषज्ञता और AI की गति के बीच चयन करने की आवश्यकता नहीं है। एक सख्त, तार्किक प्रक्रिया का पालन करने वाले विशेष सहायकों की एक टीम के रूप में AI का उपयोग करके, हम अपने सॉफ्टवेयर के सबसे खतरनाक हिस्सों के लिए सुरक्षा नियम स्वचालित रूप से बना सकते हैं, जिससे डिजिटल दुनिया रहने के लिए एक सुरक्षित स्थान बन सके। यह पेपर यह दावा नहीं करता है कि यह हर समस्या को हल कर देता है (कुछ जटिल लूप्स को अभी भी मानव सहायता की आवश्यकता होती है), लेकिन यह सिद्ध करता है कि यह मल्टी-एजेंट दृष्टिकोण सॉफ्टवेयर सत्यापन को स्वचालित और विश्वसनीय बनाने की दिशा में एक बड़ा कदम है।
अपने क्षेत्र के पेपरों की भीड़ में उलझे हुए हैं?
आपके रिसर्च कीवर्ड से मेल खाने वाले सबसे नए और अलग सोच वाले पेपरों का रोज़ाना Digest पाएँ—तकनीकी सारांश के साथ, आपकी भाषा में।