मैं यूनिट कैसे एक हेयोरिस्टिक एल्गोरिदम का परीक्षण कर सकता हूं?

Question

कहें कि हमारे पास एल्गोरिथ्म खोजने का हमारा मार्ग है:

def myHeuristicTSP(graph):
    /*implementation*/
    return route

अब हम इकाई इस परीक्षण करना चाहते हैं:

class TestMyHeuristicTSP:
    def testNullGraphRaiseValueError(self):
        self.assertRaises(ValueError, myHueristicTSP(None))

    def testSimpleTwoNodeGraphReturnsRoute:
        self.assertEquals(expectedResult, myHeuristicTSP(input))

सवाल यह है कि एक गैर-हेयुरिस्टिक टीएसपी एल्गोरिथ्म के लिए, हम कई तरह के रेखांकन दे सकते हैं और जांच सकते हैं कि वे हमेशा सबसे छोटा रास्ता बनाते हैं।

लेकिन क्योंकि एक पार्थिव एल्गोरिथ्म, जबकि अभी भी नियतात्मक है, कम अनुमानित है, बस यह समझने के लिए है कि एल्गोरिदम कैसे काम करने के लिए है, और उन किनारे के मामलों को खोजने के लिए है?

Comments

संबंधित: programmers.stackexchange.com/questions/236925/… , programmers.stackexchange.com/questions/230355/…

— Doc Brown

Answer 1

एक अनुमानी एल्गोरिथ्म के लिए जिसे आदर्श नहीं बल्कि "अच्छा पर्याप्त" समाधान माना जाता है, आपके पास विभिन्न परीक्षण-मामले और जांच होगी

1. समाधान वास्तव में मान्य है? आप निश्चित रूप से यह सुनिश्चित करना चाहते हैं कि आपका मार्ग-खोजने वाला एल्गोरिथ्म उन रास्तों को वापस नहीं करता है जो असंभव हैं या जो वास्तव में शुरू से अंत तक नहीं जाते हैं। आप साबित होता है कि समाधान आदर्श है में सक्षम नहीं हो सकता है, लेकिन आप कम से कम की पुष्टि है कि वापसी मान वास्तव में सक्षम होना चाहिए है एक समाधान।
2. समाधान "काफी अच्छा" है? आपके पास कुछ आवश्यकताएं होनी चाहिए जो परिभाषित करती हैं कि आदर्श समाधान की तुलना में एल्गोरिदम कितना खराब हो सकता है। आपके पास परीक्षण के मामले होने चाहिए जहां आदर्श समाधान ज्ञात हो (या कम से कम एक समाधान जिसे तुलनात्मक मानक के रूप में उपयोग करने के लिए पर्याप्त अच्छा माना जाता है) और पुष्टि करें कि एल्गोरिथ्म द्वारा प्रदान किया गया समाधान x% से अधिक खराब नहीं है।
3. क्या एल्गोरिथ्म काफी तेज है? जब आप अनुमान लगाते हैं कि आप अधिक तेजी से अपनी सटीकता की कमी के लिए बनाते हैं तो आप अक्सर एक दृष्टिकोण का उपयोग करते हैं। इसे सत्यापित करने के लिए आपको उनके रनटाइम को मापना चाहिए और सुनिश्चित करना चाहिए कि वे वास्तव में एक एल्गोरिथ्म की तुलना में तेज़ हैं जो सटीक समाधान प्राप्त करता है। रनटाइम माप हमेशा थोड़े फ़र्ज़ी होते हैं, इसलिए अपेक्षित रनटाइम से अधिक एक चेतावनी होनी चाहिए, एक त्रुटि नहीं (जब आपकी इकाई परीक्षण रूपरेखा चेतावनी और त्रुटियों के बीच अंतर करने की अनुमति देती है)।

Comments

क्या आप शायद परीक्षण के लिए एक सुझाव दे सकते हैं कि आप कैसे निर्धारित करेंगे कि एक मार्ग वैध है?

— dwjohnston

@dwjohnston बस अपना ग्राफ़ लें, अपना रास्ता अपनाएँ, और अपने ग्राफ़ पर पथ को आगे बढ़ाने का प्रयास करें। सत्यापित करें कि पथ का प्रत्येक किनारा वर्तमान नोड से आगे बढ़ रहा है और यह कि पथ सही नोड्स पर शुरू और समाप्त होता है। आप यह भी सत्यापित कर सकते हैं कि अंत-नोड अंत से पहले नहीं पहुंचा है।

— फिलिप

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

— फिलिप

Answer 2

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

किसी भी अधिक जटिल एल्गोरिदम के लिए अच्छी इकाई परीक्षण बनाने के लिए, वास्तव में एल्गोरिथ्म को विस्तार से जानना होगा । "पहाड़ी चढ़ाई" जैसे सरल अनुमानों के लिए आप आमतौर पर छोटे इनपुट के परिणाम की भविष्यवाणी कर सकते हैं। उदाहरण के लिए, 3 से 5 बिंदुओं के प्रारंभिक मार्गों के लिए, जब एक निश्चित क्रम में दिया जाता है, तो आप अनुमान लगा सकते हैं कि क्या होगा। यह मेरे द्वारा ज्ञात अधिकांश नियतात्मक अनुमानी एल्गोरिदम के लिए सही रहेगा, इसलिए यह शायद शुरू करने के लिए एक अच्छी जगह है।

अधिक जटिल एल्गोरिदम के लिए, और इनपुट के बड़े आकार के लिए, जब आप इनपुट को एल्गोरिथ्म में फीड करते हैं और आउटपुट की जांच करने की कोशिश करते हैं, तो आप वास्तव में अब एक इकाई परीक्षण नहीं कर रहे हैं, आप स्वीकृति या एकीकरण परीक्षण कर रहे हैं। इस तरह के एक अहंकार "इकाई परीक्षण" के लिए आपको समस्या क्यों है, इसका कारण यह है कि इसमें आमतौर पर मुट्ठी भर छोटे हिस्से (व्यक्तिगत इकाइयां) होते हैं। तो इस तरह के एक एल्गोरिथ्म की वास्तव में इकाई परीक्षण के लिए, आपको उन हिस्सों की पहचान करनी होगी और उन्हें व्यक्तिगत रूप से परीक्षण करना होगा। इसके अतिरिक्त, आप यह सुनिश्चित करने के लिए कोड कवरेज या शाखा कवरेज तकनीकों का उपयोग कर सकते हैं कि आपके पास पर्याप्त परीक्षण मामले हैं।

यदि आप यूनिट-टेस्ट की तलाश में नहीं हैं, लेकिन स्वचालित स्वीकृति या एकीकरण परीक्षण हैं, तो आप कोशिश कर सकते हैं कि @Phillip ने (2) या (3) के तहत क्या सुझाव दिया है ।