अभिसरण क्या है, सामान्य तौर पर
अभिसरण की अवधारणा एक अच्छी तरह से परिभाषित गणितीय शब्द है। इसका अनिवार्य रूप से अर्थ है कि "अंततः" तत्वों का एक क्रम एक मूल्य के करीब और करीब हो जाता है। हम इस एकल मूल्य को "सीमा" कहते हैं।
औपचारिक परिभाषा कुछ इस प्रकार है:
वास्तविक संख्याओं को देखते हुए (अनंत) अनुक्रम X0, X1, X2, ... Xn ...हम कहते हैं कि Xn converges to a given number Lयदि आप सोचते हैं कि प्रत्येक सकारात्मक त्रुटि के लिए , एक Xmऐसा है जो प्रत्येक तत्व Xnजो उस त्रुटि से कम से Xmभिन्न होने के बाद आता है L।
उदाहरण:
एक अनुक्रम की कल्पना करो जैसे:
- X0 = 1
- एक्स 1 = 0.1
- X2 = 0.01
- X3 = 0.001
- X4 = 0.0001
- ...
- Xn = 1 / (10 ^ n)
क्या Xn शून्य में परिवर्तित होता है? हाँ! क्यों?
एक त्रुटि ई के बारे में सोचो (उदाहरण के लिए E = 0.0025)। इस क्रम में एक तत्व है कि उसके बाद हर तत्व नीचे है 0.025? हाँ! वह तत्व है X3 = 0.001। X2 के बाद, हर XNनीचे है 0.0025। क्या यह हर E> 0 के लिए किया जा सकता है ? हाँ। हमारे द्वारा चुनी गई प्रत्येक सकारात्मक त्रुटि के लिए, हम यह देख सकते हैं कि इसके पहले दशमलव बिंदु से पहले कितने शून्य हैं और अनुक्रम कम होगा कि यह उस तत्व से शुरू होता है जिसमें समान संख्या में शून्य होते हैं।
इसका मतलब है कि Xn = 1/(10^5) converges to 0। जैसा कि "जितना हम चाहते हैं उतना करीब और शून्य के करीब हो सकता है"।
एक एल्गोरिथ्म के अभिसरण के लिए इसका क्या अर्थ है?
"तकनीकी रूप से" क्या अभिसरण एल्गोरिथ्म नहीं है, लेकिन एक मान एल्गोरिथ्म में हेरफेर या पुनरावृत्ति है। उदाहरण के लिए, हम कहते हैं कि हम एक एल्गोरिथ्म लिख रहे हैं जो PI के सभी अंकों को प्रिंट करता है।
एल्गोरिथ्म मुद्रण संख्याएँ शुरू करता है जैसे:
- X0 = 3.14
- X1 = 3.141
- X2 = 3.1415
- X3 = 3.14159
- ...
हम खुद से पूछ सकते हैं: क्या एल्गोरिथ्म पीआई के करीब हर तेजी से प्रिंट करता है? दूसरे शब्दों में, क्या अनुक्रम X0, X1, ... XN ...हमारे एल्गोरिथ्म को पीआई में परिवर्तित करता है?
यदि ऐसा है, तो हम कहते हैं कि हमारा एल्गोरिथ्म पीआई में परिवर्तित हो गया है।
हम आम तौर पर एक एल्गोरिथ्म की शुद्धता साबित करने में रुचि रखते हैं।
आमतौर पर, जब हम एक एल्गोरिथ्म लिखते हैं, तो हम यह जानने में रुचि रखते हैं कि एल्गोरिथ्म जो समाधान प्रदान करता है वह उस समस्या के लिए सही है जो इसे हल करता है। यह कभी-कभी एक अभिसरण के रूप में आ सकता है।
सामान्य तौर पर, एल्गोरिदम में वे होते हैं जिन्हें हम मैट्रिक्स कहते हैं । एक मीट्रिक एक संख्या है जो हम दिए गए परिणाम को देते हैं जो एल्गोरिथ्म का उत्पादन करता है। उदाहरण के लिए, AI / मशीन लर्निंग पुनरावृत्त एल्गोरिदम में हमारे लिए "त्रुटि" पर नज़र रखना बहुत सामान्य है जो कि एल्गोरिथ्म इनपुट के आधार पर उत्पन्न कर रहा है। यह त्रुटि मीट्रिक है।
उन पुनरावृत्त एल्गोरिदम में, प्रत्येक चरण एक अलग त्रुटि उत्पन्न करता है। और एल्गोरिथ्म जो करने की कोशिश करता है, वह उस त्रुटि को कम करने के लिए होता है ताकि वह कभी छोटा और छोटा हो जाए। हम कहते हैं कि एल्गोरिथ्म परिवर्तित हो जाता है अगर यह त्रुटियों का अनुक्रम परिवर्तित करता है।
उन मामलों में, global optimumआमतौर पर सेटअप के रूप में परिभाषित किया जाता है जिसमें सबसे कम त्रुटि संभव है। उस स्थिति में, "एल्गोरिथ्म वैश्विक इष्टतम में कनवर्ट करता है" इसका मतलब है कि "एल्गोरिथ्म एक अनुक्रम में त्रुटियों को उत्पन्न करता है जो संभवतया सबसे कम त्रुटि में परिवर्तित होता है"।
यदि "वैश्विक इष्टतम" हमारा "सही समाधान" है, तो यह कहना कि हमारा एल्गोरिथ्म यही बताता है कि हमारा एल्गोरिथ्म सही है।
इसके अलावा, यह ध्यान रखें कि एक एल्गोरिथ्म अभिसरण के लिए एक प्रमाण की आवश्यकता होती है (जैसा कि हमने अपने 0.001, 0.0001, ..., उदाहरण के लिए) किया है।
उदाहरण के लिए, एक क्लासिफायरियर
इसका एक उदाहरण एक क्लासिफायरियर के मामले में हो सकता है। मान लीजिए कि हम संख्याओं को विषम करना चाहते हैं या मशीन लर्निंग एल्गोरिदम का उपयोग करना चाहते हैं, और हमारे पास निम्नलिखित डेटासेट हैं:
- (1, विषम)
- (२, सम)
- (3, विषम)
- (77, विषम)
- (4, सम)
संख्याओं के प्रत्येक सेट के लिए हमारा एल्गोरिथ्म उनमें से प्रत्येक के लिए स्पिट करता है यदि वे सम या विषम हों। उसके लिए, हम एक मीट्रिक त्रुटि को परिभाषित कर सकते हैं, क्योंकि यह दिए गए तत्वों की कुल संख्या से कई बार गलत तरीके से विभाजित हो गया है।
तो, अगर हमारे एल्गोरिथ्म निम्नलिखित spits:
- (1, भी) // गलत
- (२, सम)
- (३, सम) // गलत
- (77, सम) // गलत
- (4, सम)
हमारी त्रुटि मीट्रिक होगी 3/5 = 0.6। अब हम कहते हैं कि हम एल्गोरिथ्म को फिर से चलाते हैं और यह अब थूकता है:
- (1, भी) // गलत
- (२, सम)
- (3, विषम)
- (77, विषम)
- (4, सम)
हमारी त्रुटि मीट्रिक होगी 1/5 = 0.2।
कहते हैं कि यह अधिक से अधिक बार चलता है, और त्रुटियों का हमारा क्रम कुछ इस तरह दिखता है:
0.6, 0.2, 0.1, 0.01, 0.000456, 0.00000543, 0.000000000444 ....
तो बड़ा सवाल यह है कि क्या हमारा एल्गोरिथ्म कभी शून्य होगा? क्या यह कभी शून्य में परिवर्तित होगा? क्या हमारा एल्गोरिथ्म हर जुटेगा? क्या हम यह साबित कर सकते हैं कि अंततः इसे सही (या जितना संभव हो उतना करीब) मिलेगा?
उम्मीद है कि :)