स्वचालित भेदभाव "उंगलियों पर"

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

सरल विचार

तो चलिए हमारे पास कुछ फंक्शन है । हमें कुछ बिंदु पर इसका अर्थ जानते हैं , और हम इसके व्युत्पन्न का अर्थ जानते हैं । हम केवल दो नंबर जानते हैं: और , हमें कुछ और जानने की आवश्यकता नहीं है - अभिव्यक्ति के लिए नहीं , अर्थ भी नहीं । फ़ंक्शन पर विचार करें और अपने आप से पूछें: एक बिंदु पर इसके मूल्य और इसके व्युत्पन्न का मूल्य क्या है ? यह स्पष्ट है: और । कृपया ध्यान दें कि दाईं ओर केवल वही संख्याएँ हैं जिन्हें हम जानते हैं।

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

अगला, कुछ अन्य फ़ंक्शन होने दें , और हम इसके बारे में केवल दो संख्याएँ जानते हैं: और । फिर फंक्शन के लिए हम आसानी से एक ही बिंदु पर मूल्य और व्युत्पन्न दोनों की आसानी से गणना कर सकते हैं; और इसी तरह किसी भी बाइनरी ऑपरेशन के लिए। उदाहरण के लिए, गुणन के लिए हमारे पास: यदि तो और ।

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

कोड

एक वर्ग जो ऐसे अंकगणित को लागू करता है, उसे लिखना आसान है:

class Derivable { double val, deriv; public: Derivable(double _val, double _deriv) : val(_val), deriv(_deriv) {} double getValue() {return val;} double getDerivative() {return deriv;} Derivable operator+(Derivable f) { return Derivable(val + f.val, deriv + f.deriv); } Derivable operator-(Derivable f) { return Derivable(val - f.val, deriv - f.deriv); } Derivable operator*(Derivable f) { return Derivable(val * f.val, deriv * f.val + val * f.deriv); } Derivable operator/(Derivable f) { return Derivable(val / f.val, (deriv * f.val - val * f.deriv) / f.val / f.val); } friend Derivable cos(Derivable f); }; Derivable cos(Derivable f) { return Derivable(cos(f.val), -sin(f.val)*f.deriv); } 

अब, यदि हमारे पास एक निश्चित फ़ंक्शन की गणना करने वाला कोड है, तो बस हर जगह Derivable साथ Derivable - और हमें कोड मिलता है जो समान व्युत्पत्ति के साथ समान फ़ंक्शन की गणना करता है। सच है, ज़ाहिर है, सवाल उठता है: कहां से शुरू करें? हम अब भी जानते हैं कि कैसे Derivable से नया Derivable प्राप्त किया जा Derivable , लेकिन बहुत पहले Derivable कहां से प्राप्त किया Derivable ? वास्तव में, सब कुछ स्पष्ट है। हमारे कार्य के लिए अभिव्यक्तियाँ शामिल हैं, सबसे पहले, विभिन्न स्थिरांक से स्वतंत्र , और, दूसरी बात, वास्तव में । कोई स्थिर से स्वतंत्र , निश्चित रूप से, Derivable(c, 0) द्वारा प्रतिस्थापित किया जाना चाहिए Derivable(c, 0) ; और वास्तविक चर की घटनाओं - Derivable(x0, 1) पर Derivable(x0, 1) । (यहाँ, स्पष्टता के लिए, x0 उस मान को दर्शाता है जिसके लिए हम एक फ़ंक्शन की गणना कर रहे हैं। एक वास्तविक कार्यक्रम में, सबसे अधिक संभावना है, संबंधित चर को x भी कहा जाएगा)।

यहाँ एक उदाहरण फ़ंक्शन गणना है एक साथ इसके व्युत्पन्न:

 Derivable f(double x, double a) { Derivable xd(x, 1); Derivable ad(a, 0); Derivable two(2, 0); return ad*xd*xd*xd - cos(xd/two); } 

स्वाभाविक रूप से, ऐसी गलती न करने के लिए, हमारी कक्षा में एक अंतर्निहित प्रकार रूपांतरण जोड़ना आसान है:

  Derivable(double c): val(c), deriv(0) {} 

और एक स्वतंत्र चर के लिए एक नामित निर्माता:

  static Derivable IndependendVariable(double x) { return Derivable(x,1); } 

जिसके बाद फ़ंक्शन कोड f और भी सरल हो जाता है:

 Derivable f(double x, double a) { Derivable xd = Derivable::IndependendVariable(x); return xd*xd*xd*a - cos(xd/2); } 

यहाँ एक उदाहरण कोड है जो समीकरण को हल करता है न्यूटन की विधि (यहाँ मैं भी, निश्चित रूप से, ऑपरेटरों को वैश्विक a*xd ताकि a*xd काम कर सके; ऊपर वे कक्षा के सदस्य हैं ताकि कोड को अव्यवस्थित न किया जाए)। यदि आप हल किए जा रहे समीकरण को बदलना चाहते हैं, तो आपको फ़ंक्शन कोड f और इसे बदलना होगा; व्युत्पन्न स्वचालित रूप से सही ढंग से गणना की जाएगी। (बेशक, इस उदाहरण में, हाथ से व्युत्पन्न की गणना करना आसान हो सकता है, क्योंकि फ़ंक्शन सरल है - लेकिन जैसे ही आपके समीकरण अधिक जटिल हो जाते हैं, व्युत्पन्न की गणना के लिए कोड के बारे में नहीं सोचने की क्षमता बहुत सुविधाजनक है)।

यह सब काम करेगा, भले ही हमारे कोड में बहुत जटिल शाखाएं, लूप, अन्य कार्यों के लिए कॉल आदि न हों। - मुख्य बात यह है कि सभी मध्यवर्ती चर (मध्यवर्ती कार्यों के परिणामों सहित) को Derivable , बाकी कोड को बदलने की भी आवश्यकता नहीं है!

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

सामान्यीकरण

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

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

तीसरा, एक और दिलचस्प दृष्टिकोण है जो मैंने अपनी आंख के कोने से स्वचालित भेदभाव के लिए एक ओपन-सोर्स कोड में देखा (विकिपीडिया पर लिंक देखें)। आप Derivable वर्ग बॉयलरप्लेट बना सकते हैं, फ़ंक्शन प्रकार और व्युत्पन्न मूल्यों के लिए डेटा प्रकार को टेम्पलेट पैरामीटर के रूप में स्वीकार करते हैं (यानी, लिखने के लिए। Derivable ..; Derivable ). Derivable<Derivable >, ? . , : , , , , , . , Derivable<Derivable >, , .


, ; «forward» «reverse» ( . ). , -, , , — .


http://habrahabr.ru/post/63055/
http://en.wikipedia.org/wiki/Automatic_differentiation,
http://www.coin-or.org/CppAD/Doc/mul_level.htm ( Derivable<Derivable >)

Derivable ..; Derivable ). Derivable<Derivable >, ? . , : , , , , , . , Derivable<Derivable >, , .


, ; «forward» «reverse» ( . ). , -, , , — .


http://habrahabr.ru/post/63055/
http://en.wikipedia.org/wiki/Automatic_differentiation,
http://www.coin-or.org/CppAD/Doc/mul_level.htm ( Derivable<Derivable >)

Derivable ..; Derivable ). Derivable<Derivable >, ? . , : , , , , , . , Derivable<Derivable >, , .


, ; «forward» «reverse» ( . ). , -, , , — .


http://habrahabr.ru/post/63055/
http://en.wikipedia.org/wiki/Automatic_differentiation,
http://www.coin-or.org/CppAD/Doc/mul_level.htm ( Derivable<Derivable >)

Derivable ..; Derivable ). Derivable<Derivable >, ? . , : , , , , , . , Derivable<Derivable >, , .


, ; «forward» «reverse» ( . ). , -, , , — .


http://habrahabr.ru/post/63055/
http://en.wikipedia.org/wiki/Automatic_differentiation,
http://www.coin-or.org/CppAD/Doc/mul_level.htm ( Derivable<Derivable >)

Derivable ..; Derivable ). Derivable<Derivable >, ? . , : , , , , , . , Derivable<Derivable >, , .


, ; «forward» «reverse» ( . ). , -, , , — .


http://habrahabr.ru/post/63055/
http://en.wikipedia.org/wiki/Automatic_differentiation,
http://www.coin-or.org/CppAD/Doc/mul_level.htm ( Derivable<Derivable >)