स्वचालित भेदभाव: Difference between revisions

From Vigyanwiki
No edit summary
 
(14 intermediate revisions by 4 users not shown)
Line 25: Line 25:
* उत्क्रम संचयन पुनरावर्ती संबंध की गणना करता है, <math>\frac{\partial y}{\partial w_i} = \frac{\partial y}{\partial w_{i+1}} \frac{\partial w_{i+1}}{\partial w_{i}}</math> के साथ <math>w_0 = x</math>।
* उत्क्रम संचयन पुनरावर्ती संबंध की गणना करता है, <math>\frac{\partial y}{\partial w_i} = \frac{\partial y}{\partial w_{i+1}} \frac{\partial w_{i+1}}{\partial w_{i}}</math> के साथ <math>w_0 = x</math>।


आंशिक अवकलज का मूल्य, जिसे सीड कहा जाता है, अग्रगामी या पश्चगामी प्रसारित होता है और प्रारंभ में <math>\frac{\partial x}{\partial x}=1</math> या <math>\frac{\partial y}{\partial y}=1</math> होता है। अग्रगामी संचयन फलन का मूल्यांकन करता है और एक पास में एक स्वतंत्र चर के संबंध में अवकलज की गणना करता है। प्रत्येक स्वतंत्र चर <math>x_1,x_2,\dots,x_n</math>के लिए एक अलग पास आवश्यक है जिसमें उस स्वतंत्र चर के संबंध में अवकलज को एक (<math>\frac{\partial x_1}{\partial x_1}=1</math>) और अन्य सभी को शून्य (<math>\frac{\partial x_2}{\partial x_1}= \dots = \frac{\partial x_n}{\partial x_1} = 0</math>) पर निर्धारित किया जाता है। इसके विपरीत, उत्क्रम संचयन के लिए आंशिक अवकलज के लिए मूल्यांकन किए गए आंशिक फलनो की आवश्यकता होती है। इसलिए उत्क्रम संचयन पहले फलन का मूल्यांकन करता है और एक अतिरिक्त पास में सभी स्वतंत्र चर के संबंध में अवकलज की गणना करता है।
आंशिक अवकलज का मूल्य, जिसे सीड कहा जाता है, अग्रगामी या पश्चगामी प्रसारित होता है और प्रारंभ में <math>\frac{\partial x}{\partial x}=1</math> या <math>\frac{\partial y}{\partial y}=1</math> होता है। अग्रगामी संचयन फलन का मूल्यांकन करता है और एक पास में एक स्वतंत्र चर के संबंध में अवकलज की गणना करता है। प्रत्येक स्वतंत्र चर <math>x_1,x_2,\dots,x_n</math>के लिए एक अलग पास आवश्यक है जिसमें उस स्वतंत्र चर के संबंध में अवकलज को एक (<math>\frac{\partial x_1}{\partial x_1}=1</math>) और अन्य सभी को शून्य (<math>\frac{\partial x_2}{\partial x_1}= \dots = \frac{\partial x_n}{\partial x_1} = 0</math>) पर निर्धारित किया जाता है। इसके उत्क्रम, उत्क्रम संचयन के लिए आंशिक अवकलज के लिए मूल्यांकन किए गए आंशिक फलनो की आवश्यकता होती है। इसलिए उत्क्रम संचयन पहले फलन का मूल्यांकन करता है और एक अतिरिक्त पास में सभी स्वतंत्र चर के संबंध में अवकलज की गणना करता है।


इन दोनों प्रकारों में से किसका उपयोग किया जाना चाहिए यह स्वीप गणना पर निर्भर करता है। एक स्वीप का [[कम्प्यूटेशनल जटिलता सिद्धांत|अभिकलनीय जटिलता]] मूल कोड की जटिलता के समानुपाती होती है।
इन दोनों प्रकारों में से किसका उपयोग किया जाना चाहिए यह स्वीप गणना पर निर्भर करता है। एक स्वीप का [[कम्प्यूटेशनल जटिलता सिद्धांत|अभिकलनीय जटिलता]] मूल कोड की जटिलता के समानुपाती होती है।
Line 47: Line 47:
उत्क्रम संचयन की तुलना में, अग्रगामी संचयन स्वाभाविक रूप से लागू करना आसान है क्योंकि अवकलज सूचना का प्रवाह मूल्यांकन के क्रम के साथ मेल खाता है। प्रत्येक चर <math>w_i</math> को इसके अवकलज <math>\dot w_i</math> (संख्यात्मक मान के रूप में संग्रहीत, प्रतीकात्मक व्यंजक नहीं),
उत्क्रम संचयन की तुलना में, अग्रगामी संचयन स्वाभाविक रूप से लागू करना आसान है क्योंकि अवकलज सूचना का प्रवाह मूल्यांकन के क्रम के साथ मेल खाता है। प्रत्येक चर <math>w_i</math> को इसके अवकलज <math>\dot w_i</math> (संख्यात्मक मान के रूप में संग्रहीत, प्रतीकात्मक व्यंजक नहीं),
<math display="block">\dot w_i = \frac{\partial w_i}{\partial x}</math>के साथ संवर्धित किया गया है ,जैसा कि बिंदु द्वारा दर्शाया गया है। फिर मूल्यांकन चरणों के साथ अवकलज की गणना की जाती है और श्रृंखला नियम के माध्यम से अन्य अवकलज के साथ जोड़ा जाता है।
<math display="block">\dot w_i = \frac{\partial w_i}{\partial x}</math>के साथ संवर्धित किया गया है ,जैसा कि बिंदु द्वारा दर्शाया गया है। फिर मूल्यांकन चरणों के साथ अवकलज की गणना की जाती है और श्रृंखला नियम के माध्यम से अन्य अवकलज के साथ जोड़ा जाता है।
श्रृंखला नियम का उपयोग करते हुए, यदि <math>w_i</math> के पास अभिकलनीय ग्राफ़ में पूर्ववर्ती हैं, तो  
श्रृंखला नियम का उपयोग करते हुए, if <math>w_i</math> के पास अभिकलनीय ग्राफ़ में पूर्ववर्ती हैं, तो  
:<math>\dot w_i = \sum_{j \in \{\text{predecessors of i}\}} \frac{\partial w_i}{\partial w_j} \dot w_j</math>
:<math>\dot w_i = \sum_{j \in \{\text{predecessors of i}\}} \frac{\partial w_i}{\partial w_j} \dot w_j</math>


Line 85: Line 85:


===== छद्म कोड =====
===== छद्म कोड =====
अग्रगामी संचयन एक पास में, फलन और अवकलज (लेकिन केवल एक स्वतंत्र चर के लिए) की गणना करता है। संबंधित विधि कॉल एक चर V के संबंध में व्यंजक Z को प्राप्त करने की अपेक्षा करती है। विधि मूल्यांकन किए गए फलन और इसके अवकलन की एक जोड़ी की पुनरावृत्ति है। यह विधि एक चर तक पहुंचने तक व्यंजक वृक्ष को पुनरावर्ती रूप से चंक्रमण करती है। यदि इस चर के संबंध में अवकलज का अनुरोध किया जाता है, तो इसका अवकलज 1, 0 होगा अन्यथा। फिर आंशिक फलन के साथ-साथ आंशिक अवकलज का मूल्यांकन किया जाता है।<ref name="demm22">{{cite journal|author = Maximilian E. Schüle, Maximilian Springer, [[Alfons Kemper]], [[Thomas Neumann]] |title=स्वचालित विभेदन के लिए एलएलवीएम कोड अनुकूलन|journal=DEEM '22: Proceedings of the Sixth Workshop on Data Management for End-To-End Machine Learning|date=2022|doi = 10.1145/3533028.3533302|language=English}}</ref>
अग्रगामी संचयन एक पास में, फलन और अवकलज (लेकिन केवल एक स्वतंत्र चर के लिए) की गणना करता है। संबंधित विधि कॉल एक चर V के संबंध में व्यंजक Z को प्राप्त करने की अपेक्षा करती है। विधि मूल्यांकन किए गए फलन और इसके अवकलन की एक जोड़ी की return है। यह विधि एक चर तक पहुंचने तक व्यंजक वृक्ष को पुनरावर्ती रूप से चंक्रमण करती है। if इस चर के संबंध में अवकलज का अनुरोध किया जाता है, तो इसका अवकलज 1, 0 होगा else। फिर आंशिक फलन के साथ-साथ आंशिक अवकलज का मूल्यांकन किया जाता है।<ref name="demm22">{{cite journal|author = Maximilian E. Schüle, Maximilian Springer, [[Alfons Kemper]], [[Thomas Neumann]] |title=स्वचालित विभेदन के लिए एलएलवीएम कोड अनुकूलन|journal=DEEM '22: Proceedings of the Sixth Workshop on Data Management for End-To-End Machine Learning|date=2022|doi = 10.1145/3533028.3533302|language=English}}</ref>
  tuple<[[float,float]]>eval(Expression Z, Expression V) { [[यदि]] चर(Z) है
  tuple<[[float,float]]>eval(Expression Z, Expression V) { [[यदि|if]] isVariable (Z)
       यदि (Z=V) [[पुनरावृत्ति]] {valueOf(Z),1};
       if (Z=V) [[पुनरावृत्ति|return]] {valueOf(Z),1};
       [[अन्यथा पुनरावृत्ति]] {valueOf(Z),0};
       [[अन्यथा पुनरावृत्ति|else return]] {valueOf(Z),0};
   [[अन्यथा यदि]] (Z = X + Y)
   [[अन्यथा यदि|else if]] (Z = X + Y)
       {x,x'} = eval(X,V);
       {x,x'} = eval(X,V);
       {y,y'} = eval(Y,V);
       {y,y'} = eval(Y,V);
       पुनरावृत्ति {x+y, x'+y'};
       return {x+y, x'+y'};
   अन्यथा यदि (Z = X - Y)
   else if (Z = X - Y)
       {x,x'} = eval(X,V);
       {x,x'} = eval(X,V);
       {y,y'} = eval(Y,V);
       {y,y'} = eval(Y,V);
       पुनरावृत्ति {x-y, x'-y'};
       return {x-y, x'-y'};
   अन्यथा यदि (Z = X * Y)
   else if (Z = X * Y)
       {x,x'} = eval(X,V);
       {x,x'} = eval(X,V);
       {y,y'} = eval(Y,V);
       {y,y'} = eval(Y,V);
       पुनरावृत्ति {x*y, x'*y+x*y'};                                               
       return {x*y, x'*y+x*y'};                                               
===== सी++ =====
===== सी++ =====
  #[[include]] <iostream>
  #[[include]] <iostream>
Line 106: Line 106:
   #include <map>
   #include <map>
       typedef struct dual { float v,d; } dual;
       typedef struct dual { float v,d; } dual;
     struct Expression {                                virtual dual eval(std::map<std::string,float>        &vals, Expression *v) { return {0,0}; };              };                                                  struct Plus: public Expression {                Expression *a, *b;                        Plus(Expression *a, Expression *b): a{a}, b{b} {}      dual eval(std::map<std::string,float> &vals, Expression *v) {                                                dual x=a->eval(vals,v);                              dual y=b->eval(vals,v);                            return {x.v+y.v, x.d+y.d};                               }                                                    };                                                struct Mul: public Expression {                        Expression *a, *b;                                      Plus(Expression *a, Expression *b): a{a}, b{b} {}      dual eval(std::map<std::string,float> &vals, Expression *v) {
     struct Expression {                                virtual dual eval(std::map<std::string,float>        &vals, Expression *v) { return {0,0}; };              };                                                  struct Plus: public Expression {                Expression *a, *b;                        Plus(Expression *a, Expression *b): a{a}, b{b} {}      dual eval(std::map<std::string,float> &vals, Expression *v) {                                                dual x=a->eval(vals,v);                              dual y=b->eval(vals,v);                            return {x.v+y.v, x.d+y.d};                                                                     }                                                    };                                                struct Var: public Expression {                      std::string s;                                            Var(std::string s) : s{s} {}                            dual eval(std::map<std::string,float> &vals, Expression *v) {                                                    return {vals[s], this==v?1.0f:0.0f};                    }                                                      };                                                  int main (){                            std,,map<std,,string,float> dict;
 
                   
 
       
};
संरचना मूल, सार्वजनिक व्यंजक {
  व्यंजक *ए, *बी;
  मूल(व्यंजक *ए, व्यंजक *बी), ए{ए}, बी{बी} {}
  दोहरी eval(std,,map<std,,string,float> &vals, व्यंजक *v) {
      दोहरी x=a->eval(vals,v);
      दोहरी y=b->eval(vals,v);
      पुनरावृत्ति {x.v*y.v, x.d*y.v+x.v*y.d};
  }                                                    };                                                struct Var: public Expression {                      std::string s;                                            Var(std::string s) : s{s} {}                            dual eval(std::map<std::string,float> &vals, Expression *v) {                                                    return {vals[s], this==v?1.0f:0.0f};                    }                                                      };                                                  int main (){                            std,,map<std,,string,float> dict;
   dict.insert(std,,pair<std,,string,int>( x ,1));
   dict.insert(std,,pair<std,,string,int>( x ,1));
   dict.insert(std,,pair<std,,string,int>( y ,-3));
   dict.insert(std,,pair<std,,string,int>( y ,-3));
Line 126: Line 113:
   Mul m1(&x,&z); Mul m2(&y,&z); Plus p(&m1,&m2); // x*z+y*z
   Mul m1(&x,&z); Mul m2(&y,&z); Plus p(&m1,&m2); // x*z+y*z
   std,,cout << x, << p.eval(dict,&x).d << , << y, << p.eval(dict,&y).d << , << z, << p. eval(dict,&z).d << std,,endl;
   std,,cout << x, << p.eval(dict,&x).d << , << y, << p.eval(dict,&y).d << , << z, << p. eval(dict,&z).d << std,,endl;
   पुनरावृत्ति 0;
   return 0;
=== विपरीत संचय ===
=== उत्क्रम संचयन ===
फ़ाइल,AutoDiff.webp|अंगूठा
उत्क्रम संचयन एडी में, अवकलित किए जाने वाले आश्रित चर को तय किया जाता है और अवकलज की गणना प्रत्येक उप-[[व्यंजक]] के संबंध में पुनरावर्ती रूप से की जाती है। कलम और कागज की गणना में, बाहरी फलनो के अवकलज को श्रृंखला नियम में बार-बार प्रतिस्थापित किया जाता है,
उत्क्रम संचयन एडी में, विभेदित किए जाने वाले आश्रित चर को तय किया जाता है और अवकलज की गणना प्रत्येक उप-व्यंजक (गणित) के संबंध में पुनरावर्ती रूप से की जाती है। कलम और कागज की गणना में, बाहरी कार्यों के अवकलज को श्रृंखला नियम में बार-बार प्रतिस्थापित किया जाता है,
<math display="block">\begin{align}
<math display="block">\begin{align}
\frac{\partial y}{\partial x}
\frac{\partial y}{\partial x}
Line 137: Line 123:
&= \cdots
&= \cdots
\end{align}</math>
\end{align}</math>
विपरीत संचयन में, ब्याज की मात्रा सहायक होती है, जिसे एक बार से दर्शाया जाता है <math>\bar w_i</math>; यह उपव्यंजक के संबंध में चुने गए आश्रित चर का अवकलज है <math>w_i</math>,
उत्क्रम संचयन में, ब्याज की मात्रा सहायक होती है, जिसे एक बार <math>\bar w_i</math>से दर्शाया जाता है, यह उपव्यंजक <math>w_i</math> के संबंध में चुने गए आश्रित चर का अवकलज है,
<math display="block">\bar w_i = \frac{\partial y}{\partial w_i}</math>
<math display="block">\bar w_i = \frac{\partial y}{\partial w_i}</math>
श्रृंखला नियम का उपयोग करना, यदि <math>w_i</math> अभिकलनीय ग्राफ़ में उत्तराधिकारी हैं,
श्रृंखला नियम का उपयोग करते हुए, if <math>w_i</math> के पासअभिकलनीय ग्राफ़ में परवर्ती हैं, तो
:<math>\bar w_i = \sum_{j \in \{\text{successors of i}\}} \bar w_j \frac{\partial w_j}{\partial w_i}</math>
:<math>\bar w_i = \sum_{j \in \{\text{successors of i}\}} \bar w_j \frac{\partial w_j}{\partial w_i}</math>
उत्क्रम संचयन श्रृंखला नियम को बाहर से अंदर तक, या चित्र 3 में अभिकलनीय ग्राफ के मामले में, ऊपर से नीचे तक पार करता है। उदाहरण फलन स्केलर-मूल्यवान है, और इस प्रकार अवकलज गणना के लिए केवल एक बीज है, और (दो-घटक) ग्रेडिएंट की गणना करने के लिए अभिकलनीय ग्राफ के केवल एक स्वीप की आवश्यकता होती है। अग्रगामी संचयन की तुलना में यह केवल स्पेस-टाइम ट्रेडऑफ़ है, लेकिन उत्क्रम संचयन के लिए मध्यवर्ती चर के भंडारण की आवश्यकता होती है {{math|''w''<sub>''i''</sub>}} साथ ही वे निर्देश जो उन्हें डेटा संरचना में उत्पादित करते हैं जिन्हें टेप या वेंगर्ट सूची के रूप में जाना जाता है<ref>{{cite journal|last1=Bartholomew-Biggs|first1=Michael| last2=Brown|first2=Steven|last3=Christianson|first3=Bruce|last4=Dixon|first4=Laurence|date=2000|title=एल्गोरिदम का स्वचालित विभेदन|journal=Journal of Computational and Applied Mathematics| volume=124|issue=1–2|pages=171–190| doi=10.1016/S0377-0427(00)00422-2|bibcode=2000JCoAM.124..171B|hdl=2299/3010|hdl-access=free}}</ref> (हालाँकि, वेंगर्ट ने अग्रगामी संचयन प्रकाशित किया, न कि उत्क्रम संचय<ref name="Wengert1964">{{cite journal|author=R.E. Wengert|title=एक सरल स्वचालित व्युत्पन्न मूल्यांकन कार्यक्रम|journal=Comm. ACM|volume=7
उत्क्रम संचयन श्रृंखला नियम को बाहर से अंदर तक, या चित्र 3 में अभिकलनीय ग्राफ की स्थिति में, ऊपर से नीचे तक चंक्रमण करता है। उदाहरण फलन अदिश-मूल्यवान है, और इस प्रकार अवकलज गणना के लिए केवल एक सीड है, और (दो-घटक) प्रवणता की गणना करने के लिए अभिकलनीय ग्राफ के केवल एक स्वीप की आवश्यकता होती है। अग्रगामी संचयन की तुलना में यह केवल [[आधा काम]] है, लेकिन उत्क्रम संचयन के लिए मध्यवर्ती चर {{math|''w''<sub>''i''</sub>}} के भंडारण की आवश्यकता होती है जो उन्हें टेप या वेंगर्ट सूची<ref>{{cite journal|last1=Bartholomew-Biggs|first1=Michael| last2=Brown|first2=Steven|last3=Christianson|first3=Bruce|last4=Dixon|first4=Laurence|date=2000|title=एल्गोरिदम का स्वचालित विभेदन|journal=Journal of Computational and Applied Mathematics| volume=124|issue=1–2|pages=171–190| doi=10.1016/S0377-0427(00)00422-2|bibcode=2000JCoAM.124..171B|hdl=2299/3010|hdl-access=free}}</ref> (हालाँकि, वेंगर्ट ने अग्रगामी संचयन प्रकाशित किया, न कि उत्क्रम संचय<ref name="Wengert1964">{{cite journal|author=R.E. Wengert|title=एक सरल स्वचालित व्युत्पन्न मूल्यांकन कार्यक्रम|journal=Comm. ACM|volume=7
|issue=8|year=1964|pages=463–464|doi=10.1145/355586.364791|s2cid=24039274|doi-access=free}}</ref>), जो अभिकलनीय ग्राफ़ बड़ा होने पर महत्वपूर्ण मेमोरी का उपभोग कर सकता है। मध्यवर्ती चरों के केवल एक उपसमूह को संग्रहीत करके और फिर मूल्यांकन को दोहराकर आवश्यक कार्य चरों का पुनर्निर्माण करके इसे कुछ हद तक कम किया जा सकता है, एक तकनीक जिसे [[पुनर्भौतिकीकरण]] के रूप में जाना जाता है। [[चेकपॉइंटिंग योजना]] का उपयोग मध्यस्थ राज्यों को बचाने के लिए भी किया जाता है।
|issue=8|year=1964|pages=463–464|doi=10.1145/355586.364791|s2cid=24039274|doi-access=free}}</ref>) के रूप में ज्ञात डेटा संरचना में उत्पन्न करते हैं, जो अभिकलनीय ग्राफ़ बड़ा होने पर महत्वपूर्ण मेमोरी का उपभोग कर सकता है। मध्यवर्ती चरों के केवल एक उपसमूह को संग्रहीत करके और फिर मूल्यांकन को दोहराकर आवश्यक कार्य चरों का पुनर्निर्माण करके इसे कुछ हद तक कम किया जा सकता है, एक तकनीक जिसे [[पुनर्भौतिकीकरण]] के रूप में जाना जाता है। [[चेकपॉइंटिंग योजना|जाँच बिन्दु]] का उपयोग मध्यस्थ अवस्थाओ को बचाने के लिए भी किया जाता है।


[[Image:ReverseaccumulationAD.png|right|thumb|300px|चित्र 3, अभिकलनीय ग्राफ़ के साथ उत्क्रम संचयन का उदाहरण]]रिवर्स संचय का उपयोग करके व्युत्पन्न की गणना करने के संचालन को नीचे दी गई तालिका में दिखाया गया है (उल्टे क्रम पर ध्यान दें):
[[Image:ReverseaccumulationAD.png|right|thumb|300px|चित्र 3, अभिकलनीय ग्राफ़ के साथ उत्क्रम संचयन का उदाहरण]]उत्क्रम संचयन का उपयोग करके अवकलज की गणना करने के संचालन को नीचे दी गई तालिका में दिखाया गया है (उत्क्रमित क्रम पर ध्यान दें),
{{block indent|
{{block indent|
; Operations to compute derivative
; अवकलज की गणना करने के लिए संचालन
:<math>\bar w_5 = 1 \text{ (seed)}</math>
:<math>\bar w_5 = 1 \text{ (seed)}</math>
:<math>\bar w_4 = \bar w_5 \cdot 1</math>
:<math>\bar w_4 = \bar w_5 \cdot 1</math>
Line 153: Line 139:
:<math>\bar w_1 = \bar w_3 \cdot w_2 + \bar w_4 \cdot \cos w_1</math>
:<math>\bar w_1 = \bar w_3 \cdot w_2 + \bar w_4 \cdot \cos w_1</math>
}}
}}
किसी गणना के डेटा प्रवाह ग्राफ़ को उसकी मूल गणना के ग्रेडिएंट की गणना करने के लिए हेरफेर किया जा सकता है। यह प्रत्येक प्राइमल नोड के लिए एक एडजॉइंट नोड जोड़कर किया जाता है, जो एडजॉइंट किनारों से जुड़ा होता है जो कि प्राइमल किनारों के समानांतर होता है लेकिन विपरीत दिशा में बहता है। निकटवर्ती ग्राफ में नोड्स प्रारंभिक में नोड्स द्वारा गणना किए गए कार्यों के अवकलज द्वारा गुणा का प्रतिनिधित्व करते हैं। उदाहरण के लिए, मूल में जोड़ के कारण जोड़ में फैनआउट हो जाता है; मूल में फ़ैनआउट के कारण जोड़ में वृद्धि होती है;{{efn|In terms of weight matrices, the adjoint is the [[transpose]]. Addition is the [[covector]] <math>[1 \cdots 1]</math>, since <math>[1 \cdots 1]\left[\begin{smallmatrix}x_1 \\ \vdots \\ x_n \end{smallmatrix}\right] = x_1 + \cdots + x_n,</math> and fanout is the vector <math>\left[\begin{smallmatrix}1 \\ \vdots \\ 1 \end{smallmatrix}\right],</math> since <math>\left[\begin{smallmatrix}1 \\ \vdots \\ 1 \end{smallmatrix}\right][x] = \left[\begin{smallmatrix}x \\ \vdots \\ x \end{smallmatrix}\right].</math>}} एक [[यूनरी ऑपरेशन]] फलन {{math|1=''y'' = ''f''(''x'')}} मौलिक कारणों में {{math|1=''x̄'' = ''ȳ'' ''f''′(''x'')}} सन्निकट में; वगैरह।
किसी गणना के डेटा प्रवाह ग्राफ़ को उसकी मूल गणना की प्रवणता की गणना करने के लिए प्रकलित किया जा सकता है। यह प्रत्येक प्रारंभिक नोड के लिए एक सहखंडज नोड जोड़कर किया जाता है, जो सहखंडज किनारों से जुड़ा होता है जो कि प्रारंभिक किनारों के समानांतर होता है लेकिन उत्क्रम दिशा में बहता है। निकटवर्ती ग्राफ में नोड्स प्रारंभिक में नोड्स द्वारा गणना किए गए फलनो के अवकलज द्वारा गुणन का प्रतिनिधित्व करते हैं। उदाहरण के लिए, मूल में जोड़ के कारण जोड़ में बहिर्गमांक हो जाता है, सहखंडज में बहिर्गमांक के कारण जोड़ में वृद्धि होती है,{{efn|In terms of weight matrices, the adjoint is the [[transpose]]. Addition is the [[covector]] <math>[1 \cdots 1]</math>, since <math>[1 \cdots 1]\left[\begin{smallmatrix}x_1 \\ \vdots \\ x_n \end{smallmatrix}\right] = x_1 + \cdots + x_n,</math> and fanout is the vector <math>\left[\begin{smallmatrix}1 \\ \vdots \\ 1 \end{smallmatrix}\right],</math> since <math>\left[\begin{smallmatrix}1 \\ \vdots \\ 1 \end{smallmatrix}\right][x] = \left[\begin{smallmatrix}x \\ \vdots \\ x \end{smallmatrix}\right].</math>}} प्रारंभिक कारणों में एक [[यूनरी ऑपरेशन|एकल फलन]] {{math|1=''y'' = ''f''(''x'')}}, सहखंडज में {{math|1=''x̄'' = ''ȳ'' ''f''′(''x'')}} आदि होते है।


==== कार्यान्वयन ====
==== कार्यान्वयन ====


===== छद्म कोड =====
===== छद्म कोड =====
उत्क्रम संचयन के लिए दो पास की आवश्यकता होती है, फॉरवर्ड पास में, फलन का पहले मूल्यांकन किया जाता है और आंशिक परिणाम कैश किए जाते हैं। उत्क्रम पास में, आंशिक अवकलज की गणना की जाती है और पहले से प्राप्त मूल्य को बैकप्रोपेगेट किया जाता है। संबंधित विधि कॉल से अपेक्षा की जाती है कि व्यंजक Z को अवकलज किया जाए और मूल व्यंजक के अवकलज मूल्य के साथ बीजित किया जाए। शीर्ष व्यंजक के लिए, Z, Z के संबंध में अवकलज, यह 1 है। विधि व्यंजक वृक्ष को पुनरावर्ती रूप से पार करती है जब तक कि एक चर तक नहीं पहुंच जाता है और अवकलज व्यंजक में वर्तमान बीज मान जोड़ता है।<ref name=ssdbm21>{{cite journal|author= Maximilian E. Schüle, Harald Lang, Maximilian Springer, [[Alfons Kemper]], [[Thomas Neumann]], Stephan Günnemann|title=जीपीयू पर एसक्यूएल के साथ इन-डेटाबेस मशीन लर्निंग|journal=33rd International Conference on Scientific and Statistical Database Management|date=2021|doi = 10.1145/3468791.3468840|language=English}}</ref><ref name=dpd>{{cite journal|author= Maximilian E. Schüle, Harald Lang, Maximilian Springer, [[Alfons Kemper]], [[Thomas Neumann]], Stephan Günnemann|title=इन-डेटाबेस मशीन लर्निंग के लिए पुनरावर्ती एसक्यूएल और जीपीयू-समर्थन|journal=Distributed and Parallel Databases|date=2022|doi = 10.1007/s10619-022-07417-7|language=English}}</ref>
उत्क्रम संचयन के लिए दो पास की आवश्यकता होती है, अग्रगामी पास में, फलन का पहले मूल्यांकन किया जाता है और आंशिक परिणाम कैश किए जाते हैं। उत्क्रम पास में, आंशिक अवकलज की गणना की जाती है और पहले से प्राप्त मूल्य को पृष्‍ठ संचरण  किया जाता है। संबंधित विधि कॉल से अपेक्षा की जाती है कि व्यंजक Z को व्युत्पन्न किया जाए और मूल व्यंजक के व्युत्पन्न मूल्य के साथ सीड किया जाए। शीर्ष व्यंजक के लिए, Z, Z के संबंध में व्युत्पन्न, यह 1 है। यह विधि एक चर तक पहुंचने तक व्यंजक वृक्ष को पुनरावर्ती रूप से चंक्रमण करती है और अवकलज व्यंजक में वर्तमान सीड मान जोड़ती  है।<ref name=ssdbm21>{{cite journal|author= Maximilian E. Schüle, Harald Lang, Maximilian Springer, [[Alfons Kemper]], [[Thomas Neumann]], Stephan Günnemann|title=जीपीयू पर एसक्यूएल के साथ इन-डेटाबेस मशीन लर्निंग|journal=33rd International Conference on Scientific and Statistical Database Management|date=2021|doi = 10.1145/3468791.3468840|language=English}}</ref><ref name=dpd>{{cite journal|author= Maximilian E. Schüle, Harald Lang, Maximilian Springer, [[Alfons Kemper]], [[Thomas Neumann]], Stephan Günnemann|title=इन-डेटाबेस मशीन लर्निंग के लिए पुनरावर्ती एसक्यूएल और जीपीयू-समर्थन|journal=Distributed and Parallel Databases|date=2022|doi = 10.1007/s10619-022-07417-7|language=English}}</ref>
<सिंटैक्सहाइलाइट लैंग= सी++ >
  void derive(Expression Z, float seed) {             if (Z = X + Y)
शून्य अवकलज (व्यंजक Z, फ्लोट बीज) {
       derive(X, seed);
  यदि (Z = X + Y)
       derive(Y, seed);
       अवकलज (एक्स, बीज);
   else if (Z = X - Y)
       अवकलज (वाई, बीज);
       derive(X, seed);
   अन्यथा यदि (Z = X - Y)
       derive(Y,-seed);
       अवकलज (एक्स, बीज);
   else if (Z = X * Y)
       अवकलज(Y,-बीज);
       derive(X,valueOf(X)*seed);
   अन्यथा यदि (Z = X * Y)
       derive(Y,seed*valueOf(Y));
       अवकलज(X,valueOf(X)*seed);
   else if वैरिएबल (जेड) है
       अवकलज(Y,seed*valueOf(Y));
       partialDerivativeOf(Z) += seed;                       }
   अन्यथा यदि वैरिएबल (जेड) है
       आंशिकDerivativeOf(Z) += बीज;
}
</सिंटैक्सहाइलाइट>


===== पायथन =====
===== पायथन =====
टेप के बिना [[पायथन (प्रोग्रामिंग भाषा)]] में कार्यान्वयन।
बिना टेप के [[पायथन]] में कार्यान्वयन।
<syntaxhighlight lang="Python">
<syntaxhighlight lang="Python">
import math
import math
Line 215: Line 197:


===== सी++ =====
===== सी++ =====
<सिंटैक्सहाइलाइट लैंग= सी++ >
 
#सम्मिलित करें <iostream>
  #include <iostream>                                           #include <string>                                     #include <map>                                   struct Expression {                               float forward=0, backward=0;
#सम्मिलित <स्ट्रिंग>
   virtual float eval(std::map<std::string,float> &vals) = 0;
#सम्मिलित <मानचित्र>
   virtual void back(float seed) { backward+=seed; }; };                                                 struct Plus: public Expression {                   Expression *a, *b;
संरचना व्यंजक {
      Plus(Expression *a, Expression *b): a{a}, b{b} {}
  आगे तैरना = 0, पीछे = 0;
      float eval(std::map<std::string,float> &vals) {
   वर्चुअल फ्लोट eval(std,,map<std,,string,float> &vals) = 0;
       backward=0;
   आभासी शून्य वापस(फ्लोट बीज) {पिछड़ा+=बीज; };
       forward=a->eval(vals); forward+=b->eval(vals);
};
       return forward;
स्ट्रक्चर प्लस, सार्वजनिक व्यंजक {
  व्यंजक *ए, *बी;
  प्लस(व्यंजक *ए, व्यंजक *बी), ए{ए}, बी{बी} {}
  फ्लोट eval(std,,map<std,,string,float> &vals) {
       पिछड़ा=0;
       फॉरवर्ड=a->eval(vals); फॉरवर्ड+=बी->ईवल(वैल);
      आगे लौटें;
  }
  शून्य वापस (फ्लोट बीज) {
      व्यंजक,,वापस(बीज);
      ए->वापस(बीज);
      बी->वापस(बीज);
  }
};
संरचना मूल, सार्वजनिक व्यंजक {
  व्यंजक *ए, *बी;
  मूल(व्यंजक *ए, व्यंजक *बी), ए{ए}, बी{बी} {}
  फ्लोट eval(std,,map<std,,string,float> &vals) {
      पिछड़ा=0;
      फॉरवर्ड=a->eval(vals); आगे*=b->eval(vals);
       आगे लौटें;
   }
   }
  शून्य वापस (फ्लोट बीज) {
    void back(float seed) {
      व्यंजक,,वापस(बीज);
    Expression::back(seed);
      a->पीछे(बीज * b->आगे);
    a->back(seed);
       बी->पीछे(बीज * ए->आगे);
    b->back(seed);
  }                                                      };                                                struct Mul: public Expression {                      Expression *a, *b;
      Mul(Expression *a, Expression *b): a{a}, b{b} {}    float eval(std::map<std::string,float> &vals) {
      backward=0;
       forward=a->eval(vals); forward*=b->eval(vals);
            return forward;
   }
   }
};
    void back(float seed) {
संरचना वार, सार्वजनिक व्यंजक {
      Expression::back(seed);
   एसटीडी,,स्ट्रिंग एस;
    a->back(seed * b->forward);
      b->back(seed * a->forward);
   }                                                        };                                                    struct Var: public Expression {                    std::string s;
   Var(std,,string s)), s{s} {}
   Var(std,,string s)), s{s} {}
  फ्लोट eval(std,,map<std,,string,float> &vals) {
    float eval(std::map<std::string,float> &vals) {
      फॉरवर्ड=वैल्स[एस];
      forward=vals[s];
      पिछड़ा=0;
          backward=0;
      आगे लौटें;
      return forward;
  }
  शून्य वापस (फ्लोट बीज) {
      व्यंजक,,वापस(बीज);
      std,,cout << s <<t, << पिछड़ा << ,�;
   }
   }
};
  void back(float seed) {
मुख्य प्रवेश बिंदु (){
      Expression::back(seed);
  std,,map<std,,string,float> dict;
      std::cout << s << ": " << backward << ", ";
  }                                                  };                                                     int main (){                     std,,map<std,,string,float> dict;
   dict.insert(std,,pair<std,,string,int>( x ,1));
   dict.insert(std,,pair<std,,string,int>( x ,1));
   dict.insert(std,,pair<std,,string,int>( y ,-3));
   dict.insert(std,,pair<std,,string,int>( y ,-3));
   dict.insert(std,,pair<std,,string,int>( z ,4));
   dict.insert(std,,pair<std,,string,int>( z ,4));
   वर x( x ), y( y ), z( z ); मूल m1(&x,&z); मूल m2(&y,&z); प्लस p(&m1,&m2); // x*z+y*z
   Var x( x ), y( y ), z( z ); Mul m1(&x,&z); Mul m2(&y,&z); Plus p(&m1,&m2); // x*z+y*z
   std,,cout << p.eval(dict) << std,,endl;
   std,,cout << p.eval(dict) << std,,endl;
   पी.बैक(1); std,,cout << std,,endl;
   p.back(1); std,,cout << std,,endl;
   पुनरावृत्ति 0;
   return 0;                                                 }
}
=== अग्रगामी और उत्क्रम संचयन के अतिरिक्त ===
</सिंटैक्सहाइलाइट>
 
=== आगे और पीछे संचयन से परे ===


आगे और पीछे संचयन श्रृंखला नियम को पार करने के केवल दो (चरम) तरीके हैं। संपूर्ण जैकोबियन की गणना करने की समस्या {{math|''f'' : '''R'''<sup>''n''</sup> → '''R'''<sup>''m''</sup>}} अंकगणितीय परिचालनों की न्यूनतम संख्या के साथ इष्टतम जैकोबियन संचयन (ओजेए) समस्या के रूप में जाना जाता है, जो एनपी-पूर्ण है।<ref>{{Cite journal|first=Uwe|last=Naumann|journal=Mathematical Programming|volume=112|issue=2|pages=427–441|date=April 2008|doi=10.1007/s10107-006-0042-z|title=इष्टतम जैकोबियन संचय एनपी-पूर्ण है|citeseerx=10.1.1.320.5665|s2cid=30219572}}</ref> इस प्रमाण के केंद्र में यह विचार है कि ग्राफ़ के किनारों को लेबल करने वाले स्थानीय आंशिक भागों के बीच बीजगणितीय निर्भरताएँ मौजूद हो सकती हैं। विशेष रूप से, दो या दो से अधिक एज लेबल को बराबर के रूप में पहचाना जा सकता है। समस्या की जटिलता अभी भी खुली है यदि यह मान लिया जाए कि सभी किनारे के लेबल अद्वितीय और बीजगणितीय रूप से स्वतंत्र हैं।
अग्रगामी और उत्क्रम संचयन श्रृंखला नियम को चंक्रमण करने के केवल दो (चरम) तरीके हैं। अंकगणितीय संक्रियाओं की न्यूनतम संख्या के साथ {{math|''f'' : '''R'''<sup>''n''</sup> → '''R'''<sup>''m''</sup>}} के पूर्ण जैकोबियन की गणना करने की समस्या को इष्टतम जैकोबियन संचयन (ओजेए) समस्या के रूप में जाना जाता है, जो [[एनपी-पूर्ण]] है।।<ref>{{Cite journal|first=Uwe|last=Naumann|journal=Mathematical Programming|volume=112|issue=2|pages=427–441|date=April 2008|doi=10.1007/s10107-006-0042-z|title=इष्टतम जैकोबियन संचय एनपी-पूर्ण है|citeseerx=10.1.1.320.5665|s2cid=30219572}}</ref> इस प्रमाण के केंद्र में यह विचार है कि ग्राफ़ के किनारों को लेबल करने वाले स्थानीय आंशिक भागों के बीच बीजगणितीय निर्भरताएँ उपस्थित हो सकती हैं। विशेष रूप से, दो या दो से अधिक एज लेबल को बराबर के रूप में पहचाना जा सकता है। समस्या की जटिलता अभी भी विवृत है if यह मान लिया जाए कि सभी किनारे के लेबल अद्वितीय और बीजगणितीय रूप से स्वतंत्र हैं।


== [[दोहरी संख्या]]ओं का उपयोग करके स्वचालित अवकलन ==
== दोहरी संख्याओं का उपयोग करके स्वचालित अवकलन ==


[[वास्तविक संख्या]]ओं के क्षेत्र में बीजगणित को बढ़ाकर और एक नया [[अंकगणित]] प्राप्त करके फॉरवर्ड मोड स्वचालित अवकलन पूरा किया जाता है। संख्या पर किसी फलन के अवकलज का प्रतिनिधित्व करने के लिए प्रत्येक संख्या में एक अतिरिक्त घटक जोड़ा जाता है, और सभी अंकगणितीय ऑपरेटरों को संवर्धित बीजगणित के लिए विस्तारित किया जाता है। संवर्धित बीजगणित दोहरी संख्याओं का बीजगणित है।
[[वास्तविक संख्या|वास्तविक संख्याओं]] के वास्तविक संख्याओं के [[बीजगणित]] को बढ़ाकर और एक नया [[अंकगणित]] प्राप्त करके अग्रगामी मोड स्वचालित अवकलन पूरा किया जाता है। संख्या पर किसी फलन के अवकलज का प्रतिनिधित्व करने के लिए प्रत्येक संख्या में एक अतिरिक्त घटक जोड़ा जाता है, और सभी अंकगणितीय संचालको को संवर्धित बीजगणित के लिए विस्तारित किया जाता है। संवर्धित बीजगणित [[दोहरी संख्याओं]] का बीजगणित है।


हर नंबर बदलें <math>\,x</math> संख्या के साथ <math>x + x'\varepsilon</math>, कहाँ <math>x'</math> एक वास्तविक संख्या है, लेकिन <math>\varepsilon</math> संपत्ति के साथ एक अमूर्त संख्या है <math>\varepsilon^2=0</math> (एक अतिसूक्ष्म; [[सहज अतिसूक्ष्म विश्लेषण]] देखें)। इसके प्रयोग से ही नियमित अंकगणित मिलता है
प्रत्येक संख्या <math>\,x</math> को संख्या <math>x + x'\varepsilon</math> से बदलें, जहाँ <math>x'</math> एक वास्तविक संख्या है, लेकिन <math>\varepsilon</math> गुण <math>\varepsilon^2=0</math> के साथ एक अमूर्त संख्या है (एक अतिसूक्ष्म, [[सहज अतिसूक्ष्म विश्लेषण]] देखें)। इसके प्रयोग से ही नियमित अंकगणित मिलता है
<math display="block">\begin{align}
<math display="block">\begin{align}
       (x + x'\varepsilon) + (y + y'\varepsilon) &= x + y + (x' + y')\varepsilon \\
       (x + x'\varepsilon) + (y + y'\varepsilon) &= x + y + (x' + y')\varepsilon \\
Line 292: Line 254:
   (x + x'\varepsilon) / (y + y'\varepsilon) &= (x/y + x'\varepsilon/y) / (1 + y'\varepsilon/y) = (x/y + x'\varepsilon/y) \cdot (1 - y'\varepsilon/y) = x/y + (x'/y - xy'/y^2)\varepsilon
   (x + x'\varepsilon) / (y + y'\varepsilon) &= (x/y + x'\varepsilon/y) / (1 + y'\varepsilon/y) = (x/y + x'\varepsilon/y) \cdot (1 - y'\varepsilon/y) = x/y + (x'/y - xy'/y^2)\varepsilon
\end{align}</math>
\end{align}</math>
का उपयोग करते हुए <math>(1 + y'\varepsilon/y) \cdot (1 - y'\varepsilon/y) = 1</math>.
<math>(1 + y'\varepsilon/y) \cdot (1 - y'\varepsilon/y) = 1</math> का उपयोग करते हुए।


अब, इस संवर्धित अंकगणित में बहुपदों की गणना की जा सकती है। अगर <math>P(x) = p_0 + p_1 x + p_2x^2 + \cdots + p_n x^n</math>, तब
अब, इस संवर्धित अंकगणित में बहुपदों की गणना की जा सकती है। if<math>P(x) = p_0 + p_1 x + p_2x^2 + \cdots + p_n x^n</math>, तब<math display="block">\begin{align}
<math display="block">\begin{align}
   P(x + x'\varepsilon) &= p_0 + p_1(x + x'\varepsilon) + \cdots + p_n (x + x'\varepsilon)^n \\
   P(x + x'\varepsilon) &= p_0 + p_1(x + x'\varepsilon) + \cdots + p_n (x + x'\varepsilon)^n \\
                       &= p_0 + p_1 x + \cdots + p_n x^n + p_1x'\varepsilon + 2p_2xx'\varepsilon + \cdots + np_n x^{n-1} x'\varepsilon \\
                       &= p_0 + p_1 x + \cdots + p_n x^n + p_1x'\varepsilon + 2p_2xx'\varepsilon + \cdots + np_n x^{n-1} x'\varepsilon \\
                       &= P(x) + P^{(1)}(x)x'\varepsilon
                       &= P(x) + P^{(1)}(x)x'\varepsilon
\end{align}</math>
\end{align}</math>
कहाँ <math>P^{(1)}</math> के अवकलज को दर्शाता है <math>P</math> इसके पहले तर्क के संबंध में, और <math>x'</math>, जिसे बीज कहा जाता है, मनमाने ढंग से चुना जा सकता है।


नए अंकगणित में क्रमित जोड़े, लिखे गए तत्व सम्मिलित हैं <math>\langle x, x' \rangle</math>, जैसा कि ऊपर वर्णित है, पहले घटक पर सामान्य अंकगणित और दूसरे घटक पर प्रथम क्रम अवकलन अंकगणित के साथ। बहुपदों पर उपरोक्त परिणामों को [[विश्लेषणात्मक कार्य]]ों तक विस्तारित करने से बुनियादी अंकगणित और नए अंकगणित के लिए कुछ मानक कार्यों की एक सूची मिलती है,
 
 
जहां <math>P^{(1)}</math> अपने पहले तर्क के संबंध में <math>P</math> के अवकलज को दर्शाता है, और <math>x'</math>, जिसे  सीड कहा जाता है, उसको स्वेच्छ रूप से चुना जा सकता है।
 
नए अंकगणित में क्रमित जोड़े, <math>\langle x, x' \rangle</math> लिखे तत्व, पहले घटक पर सामान्य अंकगणित और दूसरे घटक पर प्रथम क्रम अवकलन अंकगणित के साथ सम्मिलित हैं, जैसा कि ऊपर वर्णित है। बहुपदों पर उपरोक्त परिणामों को [[विश्लेषणात्मक कार्य|विश्लेषणात्मक फलनो]] तक विस्तारित करने से बुनियादी अंकगणित और नए अंकगणित के लिए कुछ मानक फलनो की एक सूची मिलती है,
<math display="block">\begin{align}
<math display="block">\begin{align}
   \left\langle u,u'\right\rangle + \left\langle v,v'\right\rangle &= \left\langle u + v, u' + v' \right\rangle \\
   \left\langle u,u'\right\rangle + \left\langle v,v'\right\rangle &= \left\langle u + v, u' + v' \right\rangle \\
Line 310: Line 274:
                               \sin\left\langle u,u'\right\rangle &= \left\langle \sin(u) , u' \cos(u) \right\rangle \\
                               \sin\left\langle u,u'\right\rangle &= \left\langle \sin(u) , u' \cos(u) \right\rangle \\
                               \cos\left\langle u,u'\right\rangle &= \left\langle \cos(u) , -u' \sin(u) \right\rangle \\
                               \cos\left\langle u,u'\right\rangle &= \left\langle \cos(u) , -u' \sin(u) \right\rangle \\
                              \exp\left\langle u,u'\right\rangle &= \left\langle \exp u , u' \exp u \right\rangle \\
           
                              \log\left\langle u,u'\right\rangle &= \left\langle \log(u) , u'/u \right\rangle \quad (u>0) \\
                                \left\langle u,u'\right\rangle^k &= \left\langle u^k , u' k u^{k - 1} \right\rangle \quad (u \ne 0) \\
                     \left| \left\langle u,u'\right\rangle \right| &= \left\langle \left| u \right| , u' \operatorname{sign} u \right\rangle \quad (u \ne 0)
                     \left| \left\langle u,u'\right\rangle \right| &= \left\langle \left| u \right| , u' \operatorname{sign} u \right\rangle \quad (u \ne 0)
\end{align}</math>
\end{align}</math>
और सामान्य तौर पर आदिम कार्य के लिए <math>g</math>,
और सामान्य तौर पर आदिम फलन के लिए <math>g</math>,
<math display="block">g(\langle u,u' \rangle , \langle v,v' \rangle ) = \langle g(u,v) , g_u(u,v) u' + g_v(u,v) v' \rangle</math>
<math display="block">g(\langle u,u' \rangle , \langle v,v' \rangle ) = \langle g(u,v) , g_u(u,v) u' + g_v(u,v) v' \rangle</math>
कहाँ <math>g_u</math> और <math>g_v</math> के अवकलज हैं <math>g</math> क्रमशः इसके पहले और दूसरे तर्क के संबंध में।
जहां <math>g_u</math> और <math>g_v</math> क्रमशः के इसके पहले और दूसरे तर्क के संबंध में <math>g</math> के अवकलज हैं।


जब एक द्विआधारी बुनियादी अंकगणितीय ऑपरेशन को मिश्रित तर्कों पर लागू किया जाता है - जोड़ी <math>\langle u, u' \rangle</math> और वास्तविक संख्या <math>c</math>-वास्तविक संख्या को पहले उठाया जाता है <math>\langle c, 0 \rangle</math>. किसी फलन का अवकलज <math>f : \R\to\R</math> बिंदु पर <math>x_0</math> अब गणना करके पाया जाता है <math>f(\langle x_0, 1 \rangle)</math> उपरोक्त अंकगणित का उपयोग करते हुए, जो देता है <math>\langle f ( x_0 ) , f' ( x_0 ) \rangle </math> परिणाम के रूप में।
जब एक द्विआधारी बुनियादी अंकगणितीय संचालन को मिश्रित तर्कों पर अनुप्रयुक्त किया जाता है - जोड़ी <math>\langle u, u' \rangle</math> और वास्तविक संख्या <math>c</math>- तो वास्तविक संख्या को पहले <math>\langle c, 0 \rangle</math> तक उत्थापित कर दिया जाता है। बिंदु <math>x_0</math>पर फलन <math>f : \R\to\R</math> का अवकलज अब उपरोक्त अंकगणित का उपयोग करके <math>f(\langle x_0, 1 \rangle)</math> की गणना करके पाया जाता है, जो परिणाम के रूप में <math>\langle f ( x_0 ) , f' ( x_0 ) \rangle </math> देता है।


===वेक्टर तर्क और कार्य===
===सदिश तर्क और फलन  ===


दिशात्मक अवकलज ऑपरेटर को अपनाकर बहुभिन्नरूपी कार्यों को अविभाज्य कार्यों के समान दक्षता और तंत्र के साथ संभाला जा सकता है। अर्थात्, यदि यह गणना करने के लिए पर्याप्त है <math>y' = \nabla f(x)\cdot x'</math>, दिशात्मक अवकलज <math>y' \in \R^m</math> का <math>f:\R^n\to\R^m</math> पर <math>x \in \R^n</math> दिशा में <math>x' \in \R^n</math> के रूप में गणना की जा सकती है <math>(\langle y_1,y'_1\rangle, \ldots, \langle y_m,y'_m\rangle) = f(\langle x_1,x'_1\rangle, \ldots, \langle x_n,x'_n\rangle)</math> उपरोक्त के समान अंकगणित का उपयोग करना। यदि के सभी तत्व <math>\nabla f</math> तो वांछित हैं <math>n</math> फलन मूल्यांकन की आवश्यकता है. ध्यान दें कि कई अनुकूलन अनुप्रयोगों में, दिशात्मक अवकलज वास्तव में पर्याप्त है।
दिशात्मक अवकलज संचालक को अपनाकर बहुभिन्नरूपी फलनो को अविभाज्य फलनो  के समान दक्षता और तंत्र के साथ संभाला जा सकता है। अर्थात्, if यह <math>y' = \nabla f(x)\cdot x'</math> गणना करने के लिए पर्याप्त है, तो <math>x' \in \R^n</math> की दिशा में  <math>x \in \R^n</math> पर <math>f:\R^n\to\R^m</math> का दिशात्मक अवकलज <math>y' \in \R^m</math> ऊपर के समान अंकगणित का उपयोग करके<math>(\langle y_1,y'_1\rangle, \ldots, \langle y_m,y'_m\rangle) = f(\langle x_1,x'_1\rangle, \ldots, \langle x_n,x'_n\rangle)</math> के रूप में गणना की जा सकती है। if के <math>\nabla f</math> सभी अवयव वांछित हों, तो <math>n</math> फलन मूल्यांकन की आवश्यकता होगी। ध्यान दें कि कई अनुकूलन अनुप्रयोगों में, दिशात्मक अवकलज वास्तव में पर्याप्त है।


===उच्च क्रम और कई चर===
===उच्च क्रम और कई चर===


उपरोक्त अंकगणित को दूसरे क्रम और बहुभिन्नरूपी कार्यों के उच्च अवकलज की गणना करने के लिए सामान्यीकृत किया जा सकता है। हालाँकि, अंकगणित के नियम तेजी से जटिल हो जाते हैं, जटिलता उच्चतम अवकलज डिग्री में द्विघात है। इसके बजाय, काटे गए [[टेलर श्रृंखला]] बीजगणित का उपयोग किया जा सकता है। परिणामी अंकगणित, सामान्यीकृत दोहरी संख्याओं पर परिभाषित, कार्यों का उपयोग करके कुशल गणना की अनुमति देता है जैसे कि वे एक डेटा प्रकार थे। एक बार किसी फलन का टेलर बहुपद ज्ञात हो जाने पर, अवकलज आसानी से निकाले जा सकते हैं।
उपरोक्त अंकगणित को दूसरे क्रम और बहुभिन्नरूपी फलनो के उच्च अवकलज की गणना करने के लिए सामान्यीकृत किया जा सकता है। हालाँकि, अंकगणित के नियम तेजी से जटिल हो जाते हैं, जटिलता उच्चतम अवकलज डिग्री में द्विघात है। इसके बजाय, संक्षिप्त [[टेलर श्रृंखला]] बीजगणित का उपयोग किया जा सकता है। परिणामी अंकगणित, सामान्यीकृत दोहरी संख्याओं पर परिभाषित, फलनो का उपयोग करके कुशल गणना की अनुमति देता है जैसे कि वे एक डेटा प्रकार थे। एक बार किसी फलन का टेलर बहुपद ज्ञात हो जाने पर, अवकलज आसानी से निकाले जा सकते हैं।


== कार्यान्वयन ==
== कार्यान्वयन ==


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


=== स्रोत कोड परिवर्तन (एससीटी) ===
=== स्रोत कोड परिवर्तन (एससीटी) ===
[[Image:SourceTransformationAutomaticDifferentiation.png|thumb|right|300px|चित्र 4, स्रोत कोड परिवर्तन कैसे काम कर सकता है इसका उदाहरण]]किसी फलन के स्रोत कोड को स्वचालित रूप से उत्पन्न स्रोत कोड द्वारा प्रतिस्थापित किया जाता है जिसमें मूल निर्देशों के साथ जुड़े अवकलज की गणना के लिए विवरण सम्मिलित होते हैं।
[[Image:SourceTransformationAutomaticDifferentiation.png|thumb|right|300px|चित्र 4, स्रोत कोड परिवर्तन कैसे काम कर सकता है इसका उदाहरण]]किसी फलन के स्रोत कोड को स्वचालित रूप से उत्पन्न स्रोत कोड द्वारा प्रतिस्थापित किया जाता है जिसमें मूल निर्देशों के साथ जुड़े अवकलज की गणना के लिए विवरण सम्मिलित होते हैं।


[[स्रोत कोड परिवर्तन]] को सभी प्रोग्रामिंग भाषाओं के लिए लागू किया जा सकता है, और कंपाइलर के लिए संकलन समय अनुकूलन करना भी आसान है। हालाँकि, एआई टूल का कार्यान्वयन स्वयं अधिक कठिन है और निर्माण प्रणाली अधिक जटिल है। स्रोत कोड परिवर्तन टूल के उदाहरणों में [https://github.com/EnzymeAD/Enzyme Enzyme] टूल सम्मिलित है<ref>{{cite journal |last1=Moses |first1=William |last2=Churavy |first2=Valentin |title=मशीन लर्निंग के लिए विदेशी कोड को फिर से लिखने के बजाय, स्वचालित रूप से तेज़ ग्रेडिएंट्स को संश्लेषित करें|journal=Proceedings of the 34th International Conference on Neural Information Processing Systems |date=December 2020 |url=https://dl.acm.org/doi/abs/10.5555/3495724.3496770}}</ref> एलएलवीएम/एमएलआईआर के लिए (और इस प्रकार सी/सी++, जूलिया, रस्ट, फोरट्रान, पायथन, आदि को अलग करता है) और
[[स्रोत कोड परिवर्तन]] को सभी प्रोग्रामिंग भाषाओं के लिए लागू किया जा सकता है, और इसमें संकलक के लिए संकलन समय इष्टतमीकरण करना भी आसान होता है। हालाँकि, एडी उपकरण का कार्यान्वयन स्वयं अधिक कठिन है और निर्माण प्रणाली अधिक सम्मिश्र है। स्रोत कोड परिवर्तन उपकरण के उदाहरणों में एलएलवीएम/एमएलआईआर (और इस प्रकार सी/सी++, जूलिया, रस्ट, फोरट्रान, पायथन, आदि को अलग करता है) के लिए [https://github.com/EnzymeAD/Enzyme Enzyme] उपकरण और फोरट्रान/सी के लिए [http://www-tapenade.inria.fr:8080/tapenade/index.jsp टेपेनेड]उपकरण सम्मिलित है<ref>{{cite journal |last1=Moses |first1=William |last2=Churavy |first2=Valentin |title=मशीन लर्निंग के लिए विदेशी कोड को फिर से लिखने के बजाय, स्वचालित रूप से तेज़ ग्रेडिएंट्स को संश्लेषित करें|journal=Proceedings of the 34th International Conference on Neural Information Processing Systems |date=December 2020 |url=https://dl.acm.org/doi/abs/10.5555/3495724.3496770}}</ref>) <ref>{{cite journal |last1=Hascoet |first1=Laurent |last2=Pascual |first2=Valérie |title=The Tapenade automatic differentiation tool: Principles, model, and specification |journal=ACM Transactions on Mathematical Software |date=April 2013 |volume=39 |issue=3 |pages=1–43 |doi=10.1145/2450153.2450158}}</ref>
[http://www-tapenade.inria.fr:8080/tapenade/index.jsp टेपेनेड] टूल<ref>{{cite journal |last1=Hascoet |first1=Laurent |last2=Pascual |first2=Valérie |title=The Tapenade automatic differentiation tool: Principles, model, and specification |journal=ACM Transactions on Mathematical Software |date=April 2013 |volume=39 |issue=3 |pages=1–43 |doi=10.1145/2450153.2450158}}</ref> फोरट्रान/सी के लिए.


=== ऑपरेटर ओवरलोडिंग (ओओ) ===
=== संचालक अतिभारक (ओओ) ===


[[Image:OperatorOverloadingAutomaticDifferentiation.png|thumb|right|300px|चित्र 5, ऑपरेटर ओवरलोडिंग कैसे काम कर सकती है इसका उदाहरण]][[ ऑपरेटर ओवरलोडिंग कर रहा है ]] के कारण स्रोत कोड का समर्थन करने वाली भाषा में लिखे जाने की संभावना है। ऊपर दर्शाए गए संवर्धित अंकगणित को पूरा करने के लिए वास्तविक संख्याओं और प्राथमिक गणितीय परिचालनों के लिए वस्तुओं को अतिभारित किया जाना चाहिए। फलन को विभेदित करने के लिए मूल स्रोत कोड में संचालन के रूप या अनुक्रम में कोई बदलाव की आवश्यकता नहीं होती है, लेकिन अक्सर ओवरलोडिंग का समर्थन करने के लिए संख्याओं और वैक्टरों के लिए बुनियादी डेटा प्रकारों में बदलाव की आवश्यकता होती है और अक्सर विशेष फ़्लैगिंग संचालन को सम्मिलित करना भी सम्मिलित होता है। प्रत्येक लूप पर अंतर्निहित ऑपरेटर ओवरहेड ओवरलोडिंग के कारण, यह दृष्टिकोण आमतौर पर कमजोर गति प्रदर्शन को प्रदर्शित करता है।
[[Image:OperatorOverloadingAutomaticDifferentiation.png|thumb|right|300px|चित्र 5, संचालक अतिभारक कैसे काम कर सकती है इसका उदाहरण]][[ ऑपरेटर ओवरलोडिंग कर रहा है | संचालक अतिभारक]] के कारण स्रोत कोड का समर्थन करने वाली भाषा में लिखे जाने की संभावना है। ऊपर दर्शाए गए संवर्धित अंकगणित को पूरा करने के लिए वास्तविक संख्याओं और प्राथमिक गणितीय परिचालनों के लिए वस्तुओं को अतिभारित किया जाना चाहिए। फलन को अवकलित करने के लिए मूल स्रोत कोड में संचालन के रूप या अनुक्रम में कोई बदलाव की आवश्यकता नहीं होती है, लेकिन प्रायः अतिभारक का समर्थन करने के लिए संख्याओं और सदिशो के लिए बुनियादी डेटा प्रकारों में बदलाव की आवश्यकता होती है और प्रायः विशेष फ़्लैगिंग संचालन को संबद्ध करना भी सम्मिलित होता है। प्रत्येक लूप पर अंतर्निहित संचालक शीर्ष अतिभारक के कारण, यह दृष्टिकोण आमतौर पर कमजोर गति प्रदर्शन को प्रदर्शित करता है।


C++ में स्वचालित अवकलन के ऑपरेटर-ओवरलोडिंग कार्यान्वयन के उदाहरण हैं,
सी++ में स्वचालित अवकलन के संचालक-अतिभारक कार्यान्वयन के उदाहरण हैं,
* निपुण (सी++ लाइब्रेरी)
* निपुण  
* एनएजी की डीसीओ लाइब्रेरी
* एनएजी का डीसीओ पुस्तकालय
* [[स्टेन (सॉफ्टवेयर)]] पुस्तकालय
* [[स्टेन (सॉफ्टवेयर)|स्टेन]] पुस्तकालय
* [https://auto-dependentiation.github.io/ Xएआई] ओपन-सोर्स टूल
* [https://auto-dependentiation.github.io/ एक्सएडी] विवृत स्रोत उपकरण


== ऑपरेटर ओवरलोडिंग और स्रोत कोड परिवर्तन ==
== संचालक अतिभारक और स्रोत कोड परिवर्तन ==
 
ओवरलोडेड ऑपरेटर्स का उपयोग वैल्यूएशन ग्राफ़ निकालने के लिए किया जा सकता है, जिसके बाद रन-टाइम पर प्राइमल फलन के एडी-संस्करण की स्वचालित पीढ़ी होती है। क्लासिक OO Aएआई के विपरीत, ऐसा एआई-फलन एक पुनरावृत्ति से अगले में नहीं बदलता है। इसलिए प्रति Xi नमूने में कोई OO या टेप व्याख्या रन-टाइम ओवरहेड है।
 
रनटाइम पर एडी-फलन उत्पन्न होने के साथ, इसे प्रोग्राम की वर्तमान स्थिति को ध्यान में रखने और कुछ मानों की पूर्व-गणना करने के लिए अनुकूलित किया जा सकता है। इसके अलावा, इसे उपयोगकर्ता डेटा के 4(8)-दोगुने टुकड़ों (AVX2\AVX512 गति x4-x8) को संसाधित करने के लिए देशी सीपीयू वेक्टराइजेशन का लगातार उपयोग करने के तरीके से उत्पन्न किया जा सकता है। मल्टीथ्रेडिंग को ध्यान में रखते हुए, इस तरह के दृष्टिकोण से पारंपरिक Aएआई टूल की तुलना में ऑर्डर 8 × #Cores का अंतिम त्वरण हो सकता है। GitHub पर एक संदर्भ कार्यान्वयन उपलब्ध है।<ref>{{Cite web|url=https://github.com/matlogica/aadc-prototype|title=एएडीसी प्रोटोटाइप लाइब्रेरी|date=June 22, 2022|via=GitHub}}</ref>


अतिभारित संचालको का उपयोग मूल्याकंन ग्राफ़ निकालने के लिए किया जा सकता है, जिसके बाद कार्य अवधि पर प्रारंभिक फलन के एडी-संस्करण की स्वचालित पीढ़ी होती है। प्रतिष्ठित ओओ एएडी के विपरीत, ऐसा एडी-फलन एक return से अगले में नहीं परिवर्तित होता है। इसलिए प्रति एक्सi प्रतिदर्श में कोई ओओ या टेप व्याख्या कार्य अवधि शिरोपरि है।


कार्य अवधि पर एडी-फलन उत्पन्न होने के साथ, इसे प्रोग्राम की वर्तमान स्थिति को ध्यान में रखने और कुछ मानों की पूर्व-गणना करने के लिए अनुकूलित किया जा सकता है। इसके अलावा, इसे उपयोगकर्ता डेटा के 4(8)-दोगुने टुकड़ों (एवीएक्स2\एवीएक्स512 गति x4-x8) को संसाधित करने के लिए मूल सीपीयू वैश्वीकरण का लगातार उपयोग करने के तरीके से उत्पन्न किया जा सकता है। बहु सूत्रण को ध्यान में रखते हुए, इस तरह के दृष्टिकोण से पारंपरिक एएडी उपकरण की तुलना में ऑर्डर 8 × #कोर्स का अंतिम त्वरण हो सकता है। एक संदर्भ कार्यान्वयन गिटहब पर उपलब्ध है।<ref>{{Cite web|url=https://github.com/matlogica/aadc-prototype|title=एएडीसी प्रोटोटाइप लाइब्रेरी|date=June 22, 2022|via=GitHub}}</ref>
==यह भी देखें==
==यह भी देखें==
*विभिन्न प्रोग्रामिंग
*[[अवलकनीय प्रोग्रामिंग]]


==टिप्पणियाँ==
==टिप्पणियाँ==
Line 438: Line 397:
* [http://www.autodiff.org/?module=Applications&application=HC1 Automatic Differentiation of Parallel OpenMP Programs]
* [http://www.autodiff.org/?module=Applications&application=HC1 Automatic Differentiation of Parallel OpenMP Programs]
* [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.89.7749&rep=rep1&type=pdf Automatic Differentiation, C++ Templates and Photogrammetry]
* [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.89.7749&rep=rep1&type=pdf Automatic Differentiation, C++ Templates and Photogrammetry]
* [https://web.archive.org/web/20070927120356/http://www.vivlabs.com/subpage_ad.php Automatic Differentiation, Operator Overloएआईing Approach]
* [https://web.archive.org/web/20070927120356/http://www.vivlabs.com/subpage_ad.php Automatic Differentiation, Operator Overloएडीing Approach]
* [http://tapenade.inria.fr:8080/tapenade/index.jsp Compute analytic derivatives of any Fortran77, Fortran95, or C program through a web-based interface] Automatic Differentiation of Fortran programs
* [http://tapenade.inria.fr:8080/tapenade/index.jsp Compute analytic derivatives of any Fortran77, Fortran95, or C program through a web-based interface] Automatic Differentiation of Fortran programs
* [http://www.win-vector.com/dfiles/AutomaticDifferentiationWithScala.pdf Description and example code for forward Automatic Differentiation in Scala]
* [http://www.win-vector.com/dfiles/AutomaticDifferentiationWithScala.pdf Description and example code for forward Automatic Differentiation in Scala]
* [https://www.finmath.net/finmath-lib/concepts/stochasticautomaticdifferentiation/ finmath-lib stochastic automatic differentiation], Automatic differentiation for random variables (Java implementation of the stochastic automatic differentiation).
* [https://www.finmath.net/finmath-lib/concepts/stochasticautomaticdifferentiation/ finmath-lib stochastic automatic differentiation], Automatic differentiation for random variables (Java implementation of the stochastic automatic differentiation).
* [https://web.archive.org/web/20140423121504/http://developers.opengamma.com/quantitative-research/Adjoint-Algorithmic-Differentiation-OpenGamma.pdf एआईjoint Algorithmic Differentiation, Calibration and Implicit Function Theorem]
* [https://web.archive.org/web/20140423121504/http://developers.opengamma.com/quantitative-research/Adjoint-Algorithmic-Differentiation-OpenGamma.pdf एडीjoint Algorithmic Differentiation, Calibration and Implicit Function Theorem]
* [http://www.quantandfinancial.com/2017/02/automatic-differentiation-templated.html C++ Template-based automatic differentiation article] and [https://github.com/omartinsky/QuantAndFinancial/tree/master/autodiff_templated implementation]
* [http://www.quantandfinancial.com/2017/02/automatic-differentiation-templated.html C++ Template-based automatic differentiation article] and [https://github.com/omartinsky/QuantAndFinancial/tree/master/autodiff_templated implementation]
* [https://github.com/google/tangent Tangent] [https://research.googleblog.com/2017/11/tangent-source-to-source-debuggable.html Source-to-Source Debuggable Derivatives]
* [https://github.com/google/tangent Tangent] [https://research.googleblog.com/2017/11/tangent-source-to-source-debuggable.html Source-to-Source Debuggable Derivatives]
* [http://www.nag.co.uk/doc/techrep/pdf/tr5_10.pdf Exact First- and Second-Order Greeks by Algorithmic Differentiation]
* [http://www.nag.co.uk/doc/techrep/pdf/tr5_10.pdf Exact First- and Second-Order Greeks by Algorithmic Differentiation]
* [http://www.nag.co.uk/Market/articles/adjoint-algorithmic-differentiation-of-gpu-accelerated-app.pdf एआईjoint Algorithmic Differentiation of a GPU Accelerated Application]
* [http://www.nag.co.uk/Market/articles/adjoint-algorithmic-differentiation-of-gpu-accelerated-app.pdf एडीjoint Algorithmic Differentiation of a GPU Accelerated Application]
* [http://www.nag.co.uk/Market/seminars/Uwe_AD_Slides_July13.pdf एआईjoint Methods in Computational Finance Software Tool Support for Algorithmic Differentiationop]
* [http://www.nag.co.uk/Market/seminars/Uwe_AD_Slides_July13.pdf एडीjoint Methods in Computational Finance Software Tओओl Support for Algorithmic Differentiationop]
* [https://www.intel.com/content/dam/www/public/us/en/documents/white-papers/xva-pricing-application-financial-services-white-papers.pdf More than a Thousand Fold Speed Up for xVA Pricing Calculations with Intel Xeon Scalable Processors]
* [https://www.intel.com/content/dam/www/public/us/en/documents/white-papers/xva-pricing-application-financial-services-white-papers.pdf More than a Thousand Fold Speed Up for xVA Pricing Calculations with Intel Xeon Scalable Processors]


Line 453: Line 412:
{{Authority control}}
{{Authority control}}


{{DEFAULTSORT:Automatic Differentiation}}[[Category: अंतर कलन]] [[Category: कंप्यूटर बीजगणित]]
{{DEFAULTSORT:Automatic Differentiation}}
 
 


[[Category: Machine Translated Page]]
[[Category:CS1]]
[[Category:Created On 21/07/2023]]
[[Category:CS1 English-language sources (en)]]
[[Category:CS1 maint]]
[[Category:Collapse templates|Automatic Differentiation]]
[[Category:Created On 21/07/2023|Automatic Differentiation]]
[[Category:Lua-based templates|Automatic Differentiation]]
[[Category:Machine Translated Page|Automatic Differentiation]]
[[Category:Navigational boxes| ]]
[[Category:Navigational boxes without horizontal lists|Automatic Differentiation]]
[[Category:Pages with script errors|Automatic Differentiation]]
[[Category:Sidebars with styles needing conversion|Automatic Differentiation]]
[[Category:Template documentation pages|Documentation/doc]]
[[Category:Templates Vigyan Ready|Automatic Differentiation]]
[[Category:Templates generating microformats|Automatic Differentiation]]
[[Category:Templates that add a tracking category|Automatic Differentiation]]
[[Category:Templates that are not mobile friendly|Automatic Differentiation]]
[[Category:Templates that generate short descriptions|Automatic Differentiation]]
[[Category:Templates using TemplateData|Automatic Differentiation]]
[[Category:Wikipedia metatemplates|Automatic Differentiation]]
[[Category:अंतर कलन|Automatic Differentiation]]
[[Category:कंप्यूटर बीजगणित|Automatic Differentiation]]

Latest revision as of 11:39, 20 October 2023

गणित और कंप्यूटर बीजगणित में, स्वचालित अवकलन (स्व-अवकलन, ऑटोडिफ़, या एआडी), जिसे कलनविधीय अवकलन तथा अभिकलनीय अवकलन भी कहा जाता है,[1][2] और यह कंप्यूटर प्रोग्राम द्वारा निर्दिष्ट फलन के आंशिक अवकलज का मूल्यांकन करने के लिए तकनीकों का एक समुच्चय है।

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

अन्य अवकलन विधियों से अंतर

चित्र 1, स्वचालित अवकलन प्रतीकात्मक अवकलन से कैसे संबंधित है

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

अग्रगामी और उत्क्रम संचयन

समग्र फलनों के आंशिक अवकलजों का श्रृंखला नियम

स्वचालित अवकलन के लिए मूल, संयुक्त फलनो के आंशिक अवकलज के श्रृंखला नियम द्वारा प्रदान किए गए अंतर का अपघटन है। सरल संयोजन

के लिए श्रृंखला नियम
देता है

दो प्रकार के स्वचालित अवकलन

आमतौर पर, स्वचालित अवकलन के दो अलग-अलग तरीके प्रस्तुत किए जाते हैं।

  • अग्रगामी संचयन (जिसे समानयन, अग्रगामी मोड या स्पर्शी मोड भी कहा जाता है)
  • उत्क्रम संचयन (जिसे अधोशीर्ष, उत्क्रम मोड या सहखंडज मोड भी कहा जाता है)

अग्रगामी संचयन निर्दिष्ट करता है कि कोई व्यक्ति श्रृंखला नियम को अंदर से (अर्थात, पहले की गणना करें और फिर की तथा अंत में की गणना करें) बाहर तक चंक्रमण करता है, जबकि उत्क्रम संचयन में बाहर से अंदर (पहले की गणना करें और फिर की और अंत में की गणना करें) तक चंक्रमण करता है।

  • अग्रगामी संचयन पुनरावर्ती संबंध की गणना करता है, के साथ , और,
  • उत्क्रम संचयन पुनरावर्ती संबंध की गणना करता है, के साथ ।

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

इन दोनों प्रकारों में से किसका उपयोग किया जाना चाहिए यह स्वीप गणना पर निर्भर करता है। एक स्वीप का अभिकलनीय जटिलता मूल कोड की जटिलता के समानुपाती होती है।

  • n ≫ m के साथ फलन f : Rn → Rm के लिए उत्क्रम संचयन की तुलना में अग्रगामी संचयन अधिक कुशल है क्योंकि उत्क्रम संचयन के लिए m स्वीप की तुलना में केवल n स्वीप आवश्यक हैं।
  • फलन f : Rn → Rm के लिए n ≪ m के साथ अग्रगामी संचयन की तुलना में उत्क्रम संचयन अधिक कुशल है क्योंकि अग्रगामी संचयन के लिए n स्वीप की तुलना में केवल m स्वीप आवश्यक है।

बहुपरतीय परसेप्ट्रॉन में त्रुटियों की पश्चसंचरण, यंत्र अधिगम में उपयोग की जाने वाली तकनीक, उत्क्रम संचयन की एक विशेष स्थिति है।[2]

अग्रगामी संचयन की शुरुआत 1964 में आर.ई. वेंगर्ट द्वारा की गई थी।।[3] एंड्रियास ग्रिवैंक के अनुसार, 1960 के दशक के उत्तरार्ध से उत्क्रम संचयन का सुझाव दिया गया है, लेकिन आविष्कारक अज्ञात है।[4] सेप्पो लिन्नैनमा ने 1976 में उत्क्रम संचयन प्रकाशित किया।[5]

अग्रगामी संचयन

अग्रगामी संचयन

अग्रगामी संचयन एडी में, व्यक्ति पहले स्वतंत्र चर को निर्धारित करता है जिसके संबंध में अवकलन किया जाता है और प्रत्येक उप-व्यंजक के अवकलज की पुनरावर्ती गणना करता है। कलम और कागज की गणना में, इसमें श्रृंखला नियम में आंतरिक फलनो के अवकलज को बार-बार प्रतिस्थापित करना सम्मिलित है,

इसे जैकोबियन के आव्यूह गुणन के रूप में कई चर के लिए सामान्यीकृत किया जा सकता है।

उत्क्रम संचयन की तुलना में, अग्रगामी संचयन स्वाभाविक रूप से लागू करना आसान है क्योंकि अवकलज सूचना का प्रवाह मूल्यांकन के क्रम के साथ मेल खाता है। प्रत्येक चर को इसके अवकलज (संख्यात्मक मान के रूप में संग्रहीत, प्रतीकात्मक व्यंजक नहीं),

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

चित्र 2, अभिकलनीय ग्राफ़ के साथ अग्रगामी संचयन का उदाहरण

उदाहरण के तौर पर, फलन पर विचार करें,

स्पष्टता के लिए, व्यक्तिगत उप-व्यंजको को चर के साथ वर्गीकृत किया गया है .

जिस स्वतंत्र चर का विभेदीकरण किया जाता है उसका चयन सीड मूल्यों ẇ1 और ẇ2 को प्रभावित करता है। x1 के संबंध में इस फलन के अवकलज में रुचि को देखते हुए, सीड मान को इस पर निर्धारित किया जाना चाहिए,

सीड मान निर्धारित होने के साथ, मान दिखाए गए अनुसार श्रृंखला नियम का उपयोग करके प्रसारित होते हैं। चित्र 2 एक अभिकलनीय ग्राफ़ के रूप में इस प्रक्रिया का सचित्र चित्रण दिखाता है।

मूल्य की गणना करने के लिए संचालन अवकलज की गणना करने के लिए संचालन
(seed)
(seed)

इस उदाहरण फलन की प्रवणता की गणना करने के लिए, जिसके लिए न केवल बल्कि की भी आवश्यकता होती है, सीड मान का उपयोग करके अभिकलनीय ग्राफ़ पर एक अतिरिक्त स्वीप किया जाता है।

कार्यान्वयन

छद्म कोड

अग्रगामी संचयन एक पास में, फलन और अवकलज (लेकिन केवल एक स्वतंत्र चर के लिए) की गणना करता है। संबंधित विधि कॉल एक चर V के संबंध में व्यंजक Z को प्राप्त करने की अपेक्षा करती है। विधि मूल्यांकन किए गए फलन और इसके अवकलन की एक जोड़ी की return है। यह विधि एक चर तक पहुंचने तक व्यंजक वृक्ष को पुनरावर्ती रूप से चंक्रमण करती है। if इस चर के संबंध में अवकलज का अनुरोध किया जाता है, तो इसका अवकलज 1, 0 होगा else। फिर आंशिक फलन के साथ-साथ आंशिक अवकलज का मूल्यांकन किया जाता है।[6] 

tuple<float,float>eval(Expression Z, Expression V) {  if isVariable (Z)
     if (Z=V) return {valueOf(Z),1};
     else return {valueOf(Z),0};
  else if (Z = X + Y)
     {x,x'} = eval(X,V);
     {y,y'} = eval(Y,V);
     return {x+y, x'+y'};
  else if (Z = X - Y)
     {x,x'} = eval(X,V);
     {y,y'} = eval(Y,V);
     return {x-y, x'-y'};
  else if (Z = X * Y)
     {x,x'} = eval(X,V);
     {y,y'} = eval(Y,V);
     return {x*y, x'*y+x*y'};
सी++
#include <iostream>
#include <string>
  #include <map>
     typedef struct dual { float v,d; } dual;
    struct Expression {                                 virtual dual eval(std::map<std::string,float>         &vals, Expression *v) { return {0,0}; };               };                                                   struct Plus: public Expression {                 Expression *a, *b;                         Plus(Expression *a, Expression *b): a{a}, b{b} {}      dual eval(std::map<std::string,float> &vals, Expression *v) {                                                dual x=a->eval(vals,v);                              dual y=b->eval(vals,v);                            return {x.v+y.v, x.d+y.d};                                                                     }                                                     };                                                struct Var: public Expression {                       std::string s;                                            Var(std::string s) : s{s} {}                            dual eval(std::map<std::string,float> &vals,  Expression *v) {                                                     return {vals[s], this==v?1.0f:0.0f};                     }                                                      };                                                   int main (){                             std,,map<std,,string,float> dict;
  dict.insert(std,,pair<std,,string,int>( x ,1));
  dict.insert(std,,pair<std,,string,int>( y ,-3));
  dict.insert(std,,pair<std,,string,int>( z ,4));
  Var x( x ), y( y ), z( z );
  Mul m1(&x,&z); Mul m2(&y,&z); Plus p(&m1,&m2); // x*z+y*z
  std,,cout << x, << p.eval(dict,&x).d << , << y, << p.eval(dict,&y).d << , << z, << p. eval(dict,&z).d << std,,endl;
  return 0;

उत्क्रम संचयन

उत्क्रम संचयन एडी में, अवकलित किए जाने वाले आश्रित चर को तय किया जाता है और अवकलज की गणना प्रत्येक उप-व्यंजक के संबंध में पुनरावर्ती रूप से की जाती है। कलम और कागज की गणना में, बाहरी फलनो के अवकलज को श्रृंखला नियम में बार-बार प्रतिस्थापित किया जाता है,

उत्क्रम संचयन में, ब्याज की मात्रा सहायक होती है, जिसे एक बार से दर्शाया जाता है, यह उपव्यंजक के संबंध में चुने गए आश्रित चर का अवकलज है,
श्रृंखला नियम का उपयोग करते हुए, if के पासअभिकलनीय ग्राफ़ में परवर्ती हैं, तो

उत्क्रम संचयन श्रृंखला नियम को बाहर से अंदर तक, या चित्र 3 में अभिकलनीय ग्राफ की स्थिति में, ऊपर से नीचे तक चंक्रमण करता है। उदाहरण फलन अदिश-मूल्यवान है, और इस प्रकार अवकलज गणना के लिए केवल एक सीड है, और (दो-घटक) प्रवणता की गणना करने के लिए अभिकलनीय ग्राफ के केवल एक स्वीप की आवश्यकता होती है। अग्रगामी संचयन की तुलना में यह केवल आधा काम है, लेकिन उत्क्रम संचयन के लिए मध्यवर्ती चर wi के भंडारण की आवश्यकता होती है जो उन्हें टेप या वेंगर्ट सूची[7] (हालाँकि, वेंगर्ट ने अग्रगामी संचयन प्रकाशित किया, न कि उत्क्रम संचय[3]) के रूप में ज्ञात डेटा संरचना में उत्पन्न करते हैं, जो अभिकलनीय ग्राफ़ बड़ा होने पर महत्वपूर्ण मेमोरी का उपभोग कर सकता है। मध्यवर्ती चरों के केवल एक उपसमूह को संग्रहीत करके और फिर मूल्यांकन को दोहराकर आवश्यक कार्य चरों का पुनर्निर्माण करके इसे कुछ हद तक कम किया जा सकता है, एक तकनीक जिसे पुनर्भौतिकीकरण के रूप में जाना जाता है। जाँच बिन्दु का उपयोग मध्यस्थ अवस्थाओ को बचाने के लिए भी किया जाता है।

चित्र 3, अभिकलनीय ग्राफ़ के साथ उत्क्रम संचयन का उदाहरण

उत्क्रम संचयन का उपयोग करके अवकलज की गणना करने के संचालन को नीचे दी गई तालिका में दिखाया गया है (उत्क्रमित क्रम पर ध्यान दें),

अवकलज की गणना करने के लिए संचालन

किसी गणना के डेटा प्रवाह ग्राफ़ को उसकी मूल गणना की प्रवणता की गणना करने के लिए प्रकलित किया जा सकता है। यह प्रत्येक प्रारंभिक नोड के लिए एक सहखंडज नोड जोड़कर किया जाता है, जो सहखंडज किनारों से जुड़ा होता है जो कि प्रारंभिक किनारों के समानांतर होता है लेकिन उत्क्रम दिशा में बहता है। निकटवर्ती ग्राफ में नोड्स प्रारंभिक में नोड्स द्वारा गणना किए गए फलनो के अवकलज द्वारा गुणन का प्रतिनिधित्व करते हैं। उदाहरण के लिए, मूल में जोड़ के कारण जोड़ में बहिर्गमांक हो जाता है, सहखंडज में बहिर्गमांक के कारण जोड़ में वृद्धि होती है,[lower-alpha 1] प्रारंभिक कारणों में एक एकल फलन y = f(x), सहखंडज में x̄ = ȳ f′(x) आदि होते है।

कार्यान्वयन

छद्म कोड

उत्क्रम संचयन के लिए दो पास की आवश्यकता होती है, अग्रगामी पास में, फलन का पहले मूल्यांकन किया जाता है और आंशिक परिणाम कैश किए जाते हैं। उत्क्रम पास में, आंशिक अवकलज की गणना की जाती है और पहले से प्राप्त मूल्य को पृष्‍ठ संचरण किया जाता है। संबंधित विधि कॉल से अपेक्षा की जाती है कि व्यंजक Z को व्युत्पन्न किया जाए और मूल व्यंजक के व्युत्पन्न मूल्य के साथ सीड किया जाए। शीर्ष व्यंजक के लिए, Z, Z के संबंध में व्युत्पन्न, यह 1 है। यह विधि एक चर तक पहुंचने तक व्यंजक वृक्ष को पुनरावर्ती रूप से चंक्रमण करती है और अवकलज व्यंजक में वर्तमान सीड मान जोड़ती है।[8][9] 

 void derive(Expression Z, float seed) {              if (Z = X + Y)
     derive(X, seed);
     derive(Y, seed);
  else if (Z = X - Y)
     derive(X, seed);
     derive(Y,-seed);
  else if (Z = X * Y)
     derive(X,valueOf(X)*seed);
     derive(Y,seed*valueOf(Y));
  else if वैरिएबल (जेड) है
     partialDerivativeOf(Z) += seed;                       }
पायथन

बिना टेप के पायथन में कार्यान्वयन। 

import math

class Var:
    def __init__(self, value, children=None):
        self.value = value
        self.children = children or []
        self.grad = 0

    def __add__(self, other):
        return Var(self.value + other.value, [(1, self), (1, other)])

    def __mul__(self, other):
        return Var(self.value * other.value, [(other.value, self), (self.value, other)])

    def sin(self):
        return Var(math.sin(self.value), [(math.cos(self.value), self)])

    def calc_grad(self, grad=1):
        self.grad += grad
        for coef, child in self.children:
            child.calc_grad(grad * coef)

# Example: f(x, y) = x * y + sin(x)
x = Var(2)
y = Var(3)
f = x * y + x.sin()

# Calculation of partial derivatives
f.calc_grad()

print("f =", f.value)
print("∂f/∂x =", x.grad)
print("∂f/∂y =", y.grad)


सी++
  #include <iostream>                                           #include <string>                                     #include <map>                                    struct Expression {                                float forward=0, backward=0;
  virtual float eval(std::map<std::string,float> &vals) = 0;
  virtual void back(float seed) { backward+=seed; };  };                                                 struct Plus: public Expression {                    Expression *a, *b;
     Plus(Expression *a, Expression *b): a{a}, b{b} {}
     float eval(std::map<std::string,float> &vals) {
     backward=0;
     forward=a->eval(vals); forward+=b->eval(vals);
     return forward;
  }
    void back(float seed) {
    Expression::back(seed);
    a->back(seed);
    b->back(seed);
  }                                                      };                                                 struct Mul: public Expression {                      Expression *a, *b;
     Mul(Expression *a, Expression *b): a{a}, b{b} {}     float eval(std::map<std::string,float> &vals) {
     backward=0;
     forward=a->eval(vals); forward*=b->eval(vals);
           return forward;
  }
   void back(float seed) {
     Expression::back(seed);
    a->back(seed * b->forward);
     b->back(seed * a->forward);
  }                                                        };                                                     struct Var: public Expression {                     std::string s;
  Var(std,,string s)), s{s} {}
    float eval(std::map<std::string,float> &vals) {
      forward=vals[s];
         backward=0;
      return forward;
  }
  void back(float seed) {
      Expression::back(seed);
     std::cout << s << ": " << backward << ", ";
  }                                                   };                                                     int main (){                     std,,map<std,,string,float> dict;
  dict.insert(std,,pair<std,,string,int>( x ,1));
  dict.insert(std,,pair<std,,string,int>( y ,-3));
  dict.insert(std,,pair<std,,string,int>( z ,4));
  Var x( x ), y( y ), z( z ); Mul m1(&x,&z); Mul m2(&y,&z); Plus p(&m1,&m2); // x*z+y*z
  std,,cout << p.eval(dict) << std,,endl;
  p.back(1); std,,cout << std,,endl;
  return 0;                                                 }

अग्रगामी और उत्क्रम संचयन के अतिरिक्त

अग्रगामी और उत्क्रम संचयन श्रृंखला नियम को चंक्रमण करने के केवल दो (चरम) तरीके हैं। अंकगणितीय संक्रियाओं की न्यूनतम संख्या के साथ f : Rn → Rm के पूर्ण जैकोबियन की गणना करने की समस्या को इष्टतम जैकोबियन संचयन (ओजेए) समस्या के रूप में जाना जाता है, जो एनपी-पूर्ण है।।[10] इस प्रमाण के केंद्र में यह विचार है कि ग्राफ़ के किनारों को लेबल करने वाले स्थानीय आंशिक भागों के बीच बीजगणितीय निर्भरताएँ उपस्थित हो सकती हैं। विशेष रूप से, दो या दो से अधिक एज लेबल को बराबर के रूप में पहचाना जा सकता है। समस्या की जटिलता अभी भी विवृत है if यह मान लिया जाए कि सभी किनारे के लेबल अद्वितीय और बीजगणितीय रूप से स्वतंत्र हैं।

दोहरी संख्याओं का उपयोग करके स्वचालित अवकलन

वास्तविक संख्याओं के वास्तविक संख्याओं के बीजगणित को बढ़ाकर और एक नया अंकगणित प्राप्त करके अग्रगामी मोड स्वचालित अवकलन पूरा किया जाता है। संख्या पर किसी फलन के अवकलज का प्रतिनिधित्व करने के लिए प्रत्येक संख्या में एक अतिरिक्त घटक जोड़ा जाता है, और सभी अंकगणितीय संचालको को संवर्धित बीजगणित के लिए विस्तारित किया जाता है। संवर्धित बीजगणित दोहरी संख्याओं का बीजगणित है।

प्रत्येक संख्या को संख्या से बदलें, जहाँ एक वास्तविक संख्या है, लेकिन गुण के साथ एक अमूर्त संख्या है (एक अतिसूक्ष्म, सहज अतिसूक्ष्म विश्लेषण देखें)। इसके प्रयोग से ही नियमित अंकगणित मिलता है

का उपयोग करते हुए।

अब, इस संवर्धित अंकगणित में बहुपदों की गणना की जा सकती है। if, तब


जहां अपने पहले तर्क के संबंध में के अवकलज को दर्शाता है, और , जिसे सीड कहा जाता है, उसको स्वेच्छ रूप से चुना जा सकता है।

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

और सामान्य तौर पर आदिम फलन के लिए ,
जहां और क्रमशः के इसके पहले और दूसरे तर्क के संबंध में के अवकलज हैं।

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

सदिश तर्क और फलन

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

उच्च क्रम और कई चर

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

कार्यान्वयन

अग्रगामी-मोड एडी को प्रोग्राम की एक गैर-मानक व्याख्या द्वारा कार्यान्वित किया जाता है जिसमें वास्तविक संख्याओं को दोहरी संख्याओं द्वारा प्रतिस्थापित किया जाता है, स्थिरांक को शून्य एप्सिलॉन गुणांक के साथ दोहरी संख्याओं में उत्थापित किया जाता है, और दोहरी संख्याओं पर काम करने के लिए संख्यात्मक आदिम को उत्थापित कर दिया गया है। यह गैरमानक व्याख्या आम तौर पर दो रणनीतियों स्रोत कोड परिवर्तन या संचालक अतिभारक में से एक का उपयोग करके कार्यान्वित की जाती है।

स्रोत कोड परिवर्तन (एससीटी)

चित्र 4, स्रोत कोड परिवर्तन कैसे काम कर सकता है इसका उदाहरण

किसी फलन के स्रोत कोड को स्वचालित रूप से उत्पन्न स्रोत कोड द्वारा प्रतिस्थापित किया जाता है जिसमें मूल निर्देशों के साथ जुड़े अवकलज की गणना के लिए विवरण सम्मिलित होते हैं।

स्रोत कोड परिवर्तन को सभी प्रोग्रामिंग भाषाओं के लिए लागू किया जा सकता है, और इसमें संकलक के लिए संकलन समय इष्टतमीकरण करना भी आसान होता है। हालाँकि, एडी उपकरण का कार्यान्वयन स्वयं अधिक कठिन है और निर्माण प्रणाली अधिक सम्मिश्र है। स्रोत कोड परिवर्तन उपकरण के उदाहरणों में एलएलवीएम/एमएलआईआर (और इस प्रकार सी/सी++, जूलिया, रस्ट, फोरट्रान, पायथन, आदि को अलग करता है) के लिए Enzyme उपकरण और फोरट्रान/सी के लिए टेपेनेडउपकरण सम्मिलित है[11]) [12]

संचालक अतिभारक (ओओ)

चित्र 5, संचालक अतिभारक कैसे काम कर सकती है इसका उदाहरण

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

सी++ में स्वचालित अवकलन के संचालक-अतिभारक कार्यान्वयन के उदाहरण हैं,

  • निपुण
  • एनएजी का डीसीओ पुस्तकालय
  • स्टेन पुस्तकालय
  • एक्सएडी विवृत स्रोत उपकरण

संचालक अतिभारक और स्रोत कोड परिवर्तन

अतिभारित संचालको का उपयोग मूल्याकंन ग्राफ़ निकालने के लिए किया जा सकता है, जिसके बाद कार्य अवधि पर प्रारंभिक फलन के एडी-संस्करण की स्वचालित पीढ़ी होती है। प्रतिष्ठित ओओ एएडी के विपरीत, ऐसा एडी-फलन एक return से अगले में नहीं परिवर्तित होता है। इसलिए प्रति एक्सi प्रतिदर्श में कोई ओओ या टेप व्याख्या कार्य अवधि शिरोपरि है।

कार्य अवधि पर एडी-फलन उत्पन्न होने के साथ, इसे प्रोग्राम की वर्तमान स्थिति को ध्यान में रखने और कुछ मानों की पूर्व-गणना करने के लिए अनुकूलित किया जा सकता है। इसके अलावा, इसे उपयोगकर्ता डेटा के 4(8)-दोगुने टुकड़ों (एवीएक्स2\एवीएक्स512 गति x4-x8) को संसाधित करने के लिए मूल सीपीयू वैश्वीकरण का लगातार उपयोग करने के तरीके से उत्पन्न किया जा सकता है। बहु सूत्रण को ध्यान में रखते हुए, इस तरह के दृष्टिकोण से पारंपरिक एएडी उपकरण की तुलना में ऑर्डर 8 × #कोर्स का अंतिम त्वरण हो सकता है। एक संदर्भ कार्यान्वयन गिटहब पर उपलब्ध है।[13]

यह भी देखें

टिप्पणियाँ

  1. ↑ In terms of weight matrices, the adjoint is the transpose. Addition is the covector , since and fanout is the vector since


संदर्भ

  1. ↑ Neidinger, Richard D. (2010). "स्वचालित विभेदन और MATLAB ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग का परिचय" (PDF). SIAM Review. 52 (3): 545–563. CiteSeerX 10.1.1.362.6580. doi:10.1137/080743627. S2CID 17134969.
  2. ↑ 2.0 2.1 Baydin, Atilim Gunes; Pearlmutter, Barak; Radul, Alexey Andreyevich; Siskind, Jeffrey (2018). "Automatic differentiation in machine learning: a survey". Journal of Machine Learning Research. 18: 1–43.
  3. ↑ 3.0 3.1 R.E. Wengert (1964). "एक सरल स्वचालित व्युत्पन्न मूल्यांकन कार्यक्रम". Comm. ACM. 7 (8): 463–464. doi:10.1145/355586.364791. S2CID 24039274.
  4. ↑ Griewank, Andreas (2012). "Who Invented the Reverse Mode of Differentiation?" (PDF). Optimization Stories, Documenta Matematica. Extra Volume ISMP: 389–400.
  5. ↑ Linnainmaa, Seppo (1976). "संचित गोलाई त्रुटि का टेलर विस्तार". BIT Numerical Mathematics. 16 (2): 146–160. doi:10.1007/BF01931367. S2CID 122357351.
  6. ↑ Maximilian E. Schüle, Maximilian Springer, Alfons Kemper, Thomas Neumann (2022). "स्वचालित विभेदन के लिए एलएलवीएम कोड अनुकूलन". DEEM '22: Proceedings of the Sixth Workshop on Data Management for End-To-End Machine Learning (in English). doi:10.1145/3533028.3533302.{{cite journal}}: CS1 maint: multiple names: authors list (link)
  7. ↑ Bartholomew-Biggs, Michael; Brown, Steven; Christianson, Bruce; Dixon, Laurence (2000). "एल्गोरिदम का स्वचालित विभेदन". Journal of Computational and Applied Mathematics. 124 (1–2): 171–190. Bibcode:2000JCoAM.124..171B. doi:10.1016/S0377-0427(00)00422-2. hdl:2299/3010.
  8. ↑ Maximilian E. Schüle, Harald Lang, Maximilian Springer, Alfons Kemper, Thomas Neumann, Stephan Günnemann (2021). "जीपीयू पर एसक्यूएल के साथ इन-डेटाबेस मशीन लर्निंग". 33rd International Conference on Scientific and Statistical Database Management (in English). doi:10.1145/3468791.3468840.{{cite journal}}: CS1 maint: multiple names: authors list (link)
  9. ↑ Maximilian E. Schüle, Harald Lang, Maximilian Springer, Alfons Kemper, Thomas Neumann, Stephan Günnemann (2022). "इन-डेटाबेस मशीन लर्निंग के लिए पुनरावर्ती एसक्यूएल और जीपीयू-समर्थन". Distributed and Parallel Databases (in English). doi:10.1007/s10619-022-07417-7.{{cite journal}}: CS1 maint: multiple names: authors list (link)
  10. ↑ Naumann, Uwe (April 2008). "इष्टतम जैकोबियन संचय एनपी-पूर्ण है". Mathematical Programming. 112 (2): 427–441. CiteSeerX 10.1.1.320.5665. doi:10.1007/s10107-006-0042-z. S2CID 30219572.
  11. ↑ Moses, William; Churavy, Valentin (December 2020). "मशीन लर्निंग के लिए विदेशी कोड को फिर से लिखने के बजाय, स्वचालित रूप से तेज़ ग्रेडिएंट्स को संश्लेषित करें". Proceedings of the 34th International Conference on Neural Information Processing Systems.
  12. ↑ Hascoet, Laurent; Pascual, Valérie (April 2013). "The Tapenade automatic differentiation tool: Principles, model, and specification". ACM Transactions on Mathematical Software. 39 (3): 1–43. doi:10.1145/2450153.2450158.
  13. ↑ "एएडीसी प्रोटोटाइप लाइब्रेरी". June 22, 2022 – via GitHub.


अग्रिम पठन


बाहरी संबंध

Retrieved from ‘https://www.vigyanwiki.in/index.php?title=स्वचालित_भेदभाव&oldid=270564’