स्वचालित अवकलन

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

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

अन्य विभेदीकरण विधियों से अंतर

चित्र 1: स्वचालित भेदभाव प्रतीकात्मक भेदभाव से कैसे संबंधित है

स्वचालित अवकलन प्रतीकात्मक अवकलन और संख्यात्मक अवकलन से भिन्न है।

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

आगे और पीछे संचय

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

स्वचालित अवकलन के लिए मौलिक कार्य संरचना के आंशिक डेरिवेटिव के श्रृंखला नियम द्वारा प्रदान किए गए अंतर का अपघटन है। सरल रचना के लिए

$${\begin{aligned}y&=f(g(h(x)))=f(g(h(w_{0})))=f(g(w_{1}))=f(w_{2})=w_{3}\\w_{0}&=x\\w_{1}&=h(w_{0})\\w_{2}&=g(w_{1})\\w_{3}&=f(w_{2})=y\end{aligned}}$$

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

$${\frac {\partial y}{\partial x}}={\frac {\partial y}{\partial w_{2}}}{\frac {\partial w_{2}}{\partial w_{1}}}{\frac {\partial w_{1}}{\partial x}}={\frac {\partial f(w_{2})}{\partial w_{2}}}{\frac {\partial g(w_{1})}{\partial w_{1}}}{\frac {\partial h(w_{0})}{\partial x}}$$

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

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

• फॉरवर्ड संचयन (जिसे बॉटम-अप, फॉरवर्ड मोड या टैंगेंट मोड भी कहा जाता है)
• रिवर्स संचयन (जिसे टॉप-डाउन, रिवर्स मोड या एडजॉइंट मोड भी कहा जाता है)

फॉरवर्ड संचय निर्दिष्ट करता है कि कोई व्यक्ति श्रृंखला नियम को अंदर से बाहर तक पार करता है (अर्थात, पहले गणना करें $\partial w_{1}/\partial x$ और तब $\partial w_{2}/\partial w_{1}$ और अंत में $\partial y/\partial w_{2}$), जबकि रिवर्स संचय में बाहर से अंदर तक ट्रैवर्सल होता है (पहले गणना करें)। $\partial y/\partial w_{2}$ और तब $\partial w_{2}/\partial w_{1}$ और अंत में $\partial w_{1}/\partial x$). अधिक संक्षेप में,

• फॉरवर्ड संचय पुनरावर्ती संबंध की गणना करता है: ${\frac {\partial w_{i}}{\partial x}}={\frac {\partial w_{i}}{\partial w_{i-1}}}{\frac {\partial w_{i-1}}{\partial x}}$ साथ $w_{3}=y$, और,
• रिवर्स संचय पुनरावर्ती संबंध की गणना करता है: ${\frac {\partial y}{\partial w_{i}}}={\frac {\partial y}{\partial w_{i+1}}}{\frac {\partial w_{i+1}}{\partial w_{i}}}$ साथ $w_{0}=x$.

आंशिक अवकलज का मूल्य, जिसे बीज कहा जाता है, आगे या पीछे प्रचारित होता है और प्रारंभ में होता है ${\frac {\partial x}{\partial x}}=1$ या ${\frac {\partial y}{\partial y}}=1$. फॉरवर्ड संचय फलन का मूल्यांकन करता है और एक पास में एक स्वतंत्र चर के संबंध में व्युत्पन्न की गणना करता है। प्रत्येक स्वतंत्र चर के लिए $x_{1},x_{2},\dots ,x_{n}$ इसलिए एक अलग पास आवश्यक है जिसमें उस स्वतंत्र चर के संबंध में व्युत्पन्न को एक पर सेट किया गया है (${\frac {\partial x_{1}}{\partial x_{1}}}=1$) और अन्य सभी को शून्य (${\frac {\partial x_{2}}{\partial x_{1}}}=\dots ={\frac {\partial x_{n}}{\partial x_{1}}}=0$). इसके विपरीत, रिवर्स संचय के लिए आंशिक डेरिवेटिव के लिए मूल्यांकन किए गए आंशिक कार्यों की आवश्यकता होती है। इसलिए रिवर्स संचय पहले फलन का मूल्यांकन करता है और एक अतिरिक्त पास में सभी स्वतंत्र चर के संबंध में डेरिवेटिव की गणना करता है।

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

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

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

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

आगे संचय

आगे संचय

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

$${\begin{aligned}{\frac {\partial y}{\partial x}}&={\frac {\partial y}{\partial w_{n-1}}}{\frac {\partial w_{n-1}}{\partial x}}\\[6pt]&={\frac {\partial y}{\partial w_{n-1}}}\left({\frac {\partial w_{n-1}}{\partial w_{n-2}}}{\frac {\partial w_{n-2}}{\partial x}}\right)\\[6pt]&={\frac {\partial y}{\partial w_{n-1}}}\left({\frac {\partial w_{n-1}}{\partial w_{n-2}}}\left({\frac {\partial w_{n-2}}{\partial w_{n-3}}}{\frac {\partial w_{n-3}}{\partial x}}\right)\right)\\[6pt]&=\cdots \end{aligned}}$$

इसे जैकोबियन मैट्रिक्स और निर्धारकों के मैट्रिक्स उत्पाद के रूप में कई चर के लिए सामान्यीकृत किया जा सकता है।

रिवर्स संचय की तुलना में, आगे संचय स्वाभाविक और लागू करना आसान है क्योंकि व्युत्पन्न जानकारी का प्रवाह मूल्यांकन के क्रम के साथ मेल खाता है। प्रत्येक चर $w_{i}$ इसके व्युत्पन्न के साथ संवर्धित किया गया है ${\dot {w}}_{i}$ (संख्यात्मक मान के रूप में संग्रहीत, प्रतीकात्मक अभिव्यक्ति नहीं),

$${\dot {w}}_{i}={\frac {\partial w_{i}}{\partial x}}$$

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

श्रृंखला नियम का उपयोग करना, यदि $w_{i}$ अभिकलनीय ग्राफ़ में पूर्ववर्ती हैं:

${\dot {w}}_{i}=\sum _{j\in \{{\text{predecessors of i}}\}}{\frac {\partial w_{i}}{\partial w_{j}}}{\dot {w}}_{j}$

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

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

$${\begin{aligned}y&=f(x_{1},x_{2})\\&=x_{1}x_{2}+\sin x_{1}\\&=w_{1}w_{2}+\sin w_{1}\\&=w_{3}+w_{4}\\&=w_{5}\end{aligned}}$$

स्पष्टता के लिए, व्यक्तिगत उप-अभिव्यक्तियों को चर के साथ लेबल किया गया है $w_{i}$.

जिस स्वतंत्र चर का विभेदीकरण किया जाता है उसका चुनाव बीज मूल्यों को प्रभावित करता है ẇ₁ और ẇ₂. के संबंध में इस फलन के व्युत्पन्न में रुचि दी गई है x₁, बीज मान इस पर सेट किया जाना चाहिए:

$${\begin{aligned}{\dot {w}}_{1}={\frac {\partial w_{1}}{\partial x_{1}}}={\frac {\partial x_{1}}{\partial x_{1}}}=1\\{\dot {w}}_{2}={\frac {\partial w_{2}}{\partial x_{1}}}={\frac {\partial x_{2}}{\partial x_{1}}}=0\end{aligned}}$$

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

Operations to compute value	Operations to compute derivative
$w_{1}=x_{1}$	${\dot {w}}_{1}=1$ (seed)
$w_{2}=x_{2}$	${\dot {w}}_{2}=0$ (seed)
$w_{3}=w_{1}\cdot w_{2}$	${\dot {w}}_{3}=w_{2}\cdot {\dot {w}}_{1}+w_{1}\cdot {\dot {w}}_{2}$
$w_{4}=\sin w_{1}$	${\dot {w}}_{4}=\cos w_{1}\cdot {\dot {w}}_{1}$
$w_{5}=w_{3}+w_{4}$	${\dot {w}}_{5}=1\cdot {\dot {w}}_{3}+1\cdot {\dot {w}}_{4}$

इस उदाहरण फलन के ग्रेडियेंट की गणना करने के लिए, जिसकी न केवल आवश्यकता है ${\tfrac {\partial y}{\partial x_{1}}}$ लेकिन ${\tfrac {\partial y}{\partial x_{2}}}$, बीज मानों का उपयोग करके अभिकलनीय ग्राफ़ पर एक अतिरिक्त स्वीप किया जाता है ${\dot {w}}_{1}=0;{\dot {w}}_{2}=1$.

कार्यान्वयन

छद्म कोड

फॉरवर्ड संचयन एक पास में फलन और व्युत्पन्न (लेकिन केवल एक स्वतंत्र चर के लिए) की गणना करता है। संबंधित विधि कॉल एक चर V के संबंध में अभिव्यक्ति Z को प्राप्त करने की अपेक्षा करती है। विधि मूल्यांकन किए गए फलन और इसकी व्युत्पत्ति की एक जोड़ी लौटाती है। यह विधि एक चर तक पहुंचने तक अभिव्यक्ति वृक्ष को पुनरावर्ती रूप से पार करती है। यदि इस चर के संबंध में व्युत्पन्न का अनुरोध किया जाता है, तो इसका व्युत्पन्न 1, 0 है अन्यथा। फिर आंशिक फलन के साथ-साथ आंशिक अवकलज का मूल्यांकन किया जाता है। <सिंटैक्सहाइलाइट लैंग= सी++ > टपल<फ्लोट,फ्लोट> eval(अभिव्यक्ति Z, अभिव्यक्ति V) {

  यदि चर(Z) है
     यदि (Z=V) वापसी {valueOf(Z),1};
     अन्यथा वापसी {valueOf(Z),0};
  अन्यथा यदि (Z = X + Y)
     {x,x'} = eval(X,V);
     {y,y'} = eval(Y,V);
     वापसी {x+y, x'+y'};
  अन्यथा यदि (Z = X - Y)
     {x,x'} = eval(X,V);
     {y,y'} = eval(Y,V);
     वापसी {x-y, x'-y'};
  अन्यथा यदि (Z = X * Y)
     {x,x'} = eval(X,V);
     {y,y'} = eval(Y,V);
     वापसी {x*y, x'*y+x*y'};

} </सिंटैक्सहाइलाइट>

सी++

<सिंटैक्सहाइलाइट लैंग= सी++ >

1. शामिल करें <iostream>
2. शामिल <स्ट्रिंग>
3. शामिल <मानचित्र>

टाइपडिफ स्ट्रक्चर डुअल {फ्लोट वी,डी; } दोहरा; संरचना अभिव्यक्ति {

  वर्चुअल डुअल इवल(std::map<std::string,float> &vals, Expression *v) { return {0,0}; };

}; स्ट्रक्चर प्लस: सार्वजनिक अभिव्यक्ति {

  अभिव्यक्ति *ए, *बी;
  प्लस(अभिव्यक्ति *ए, अभिव्यक्ति *बी): ए{ए}, बी{बी} {}
  दोहरी 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.d};
  }

}; संरचना मूल: सार्वजनिक अभिव्यक्ति {

  अभिव्यक्ति *ए, *बी;
  मूल(अभिव्यक्ति *ए, अभिव्यक्ति *बी): ए{ए}, बी{बी} {}
  दोहरी 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};
  }

}; संरचना वार: सार्वजनिक अभिव्यक्ति {

  एसटीडी::स्ट्रिंग एस;
  Var(std::string s) : s{s} {}
  दोहरी eval(std::map<std::string,float> &vals, अभिव्यक्ति *v) {
     वापसी {vals[s], this==v?1.0f:0.0f};
  }

}; मुख्य प्रवेश बिंदु (){

  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));
  वर x( x ), y( y ), z( z );
  मूल m1(&x,&z); मूल m2(&y,&z); प्लस 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;
  वापसी 0;

} </सिंटैक्सहाइलाइट>

विपरीत संचय

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

$${\begin{aligned}{\frac {\partial y}{\partial x}}&={\frac {\partial y}{\partial w_{1}}}{\frac {\partial w_{1}}{\partial x}}\\&=\left({\frac {\partial y}{\partial w_{2}}}{\frac {\partial w_{2}}{\partial w_{1}}}\right){\frac {\partial w_{1}}{\partial x}}\\&=\left(\left({\frac {\partial y}{\partial w_{3}}}{\frac {\partial w_{3}}{\partial w_{2}}}\right){\frac {\partial w_{2}}{\partial w_{1}}}\right){\frac {\partial w_{1}}{\partial x}}\\&=\cdots \end{aligned}}$$

विपरीत संचय में, ब्याज की मात्रा सहायक होती है, जिसे एक बार से दर्शाया जाता है ${\bar {w}}_{i}$; यह उपअभिव्यक्ति के संबंध में चुने गए आश्रित चर का व्युत्पन्न है $w_{i}$:

$${\bar {w}}_{i}={\frac {\partial y}{\partial w_{i}}}$$

श्रृंखला नियम का उपयोग करना, यदि $w_{i}$ अभिकलनीय ग्राफ़ में उत्तराधिकारी हैं:

${\bar {w}}_{i}=\sum _{j\in \{{\text{successors of i}}\}}{\bar {w}}_{j}{\frac {\partial w_{j}}{\partial w_{i}}}$

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

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

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

Operations to compute derivative

${\bar {w}}_{5}=1{\text{ (seed)}}$

${\bar {w}}_{4}={\bar {w}}_{5}\cdot 1$

${\bar {w}}_{3}={\bar {w}}_{5}\cdot 1$

${\bar {w}}_{2}={\bar {w}}_{3}\cdot w_{1}$

${\bar {w}}_{1}={\bar {w}}_{3}\cdot w_{2}+{\bar {w}}_{4}\cdot \cos w_{1}$

किसी गणना के डेटा प्रवाह ग्राफ़ को उसकी मूल गणना के ग्रेडिएंट की गणना करने के लिए हेरफेर किया जा सकता है। यह प्रत्येक प्राइमल नोड के लिए एक एडजॉइंट नोड जोड़कर किया जाता है, जो एडजॉइंट किनारों से जुड़ा होता है जो कि प्राइमल किनारों के समानांतर होता है लेकिन विपरीत दिशा में बहता है। निकटवर्ती ग्राफ में नोड्स प्रारंभिक में नोड्स द्वारा गणना किए गए कार्यों के डेरिवेटिव द्वारा गुणा का प्रतिनिधित्व करते हैं। उदाहरण के लिए, मूल में जोड़ के कारण जोड़ में फैनआउट हो जाता है; मूल में फ़ैनआउट के कारण जोड़ में वृद्धि होती है; एक यूनरी ऑपरेशन फलन y = f(x) मौलिक कारणों में x̄ = ȳ f′(x) सन्निकट में; वगैरह।

कार्यान्वयन

छद्म कोड

रिवर्स संचय के लिए दो पास की आवश्यकता होती है: फॉरवर्ड पास में, फलन का पहले मूल्यांकन किया जाता है और आंशिक परिणाम कैश किए जाते हैं। रिवर्स पास में, आंशिक डेरिवेटिव की गणना की जाती है और पहले से प्राप्त मूल्य को बैकप्रोपेगेट किया जाता है। संबंधित विधि कॉल से अपेक्षा की जाती है कि अभिव्यक्ति Z को व्युत्पन्न किया जाए और मूल अभिव्यक्ति के व्युत्पन्न मूल्य के साथ बीजित किया जाए। शीर्ष अभिव्यक्ति के लिए, Z, Z के संबंध में व्युत्पन्न, यह 1 है। विधि अभिव्यक्ति वृक्ष को पुनरावर्ती रूप से पार करती है जब तक कि एक चर तक नहीं पहुंच जाता है और व्युत्पन्न अभिव्यक्ति में वर्तमान बीज मान जोड़ता है। <सिंटैक्सहाइलाइट लैंग= सी++ > शून्य व्युत्पन्न (अभिव्यक्ति Z, फ्लोट बीज) {

  यदि (Z = X + Y)
     व्युत्पन्न (एक्स, बीज);
     व्युत्पन्न (वाई, बीज);
  अन्यथा यदि (Z = X - Y)
     व्युत्पन्न (एक्स, बीज);
     व्युत्पन्न(Y,-बीज);
  अन्यथा यदि (Z = X * Y)
     व्युत्पन्न(X,valueOf(X)*seed);
     व्युत्पन्न(Y,seed*valueOf(Y));
  अन्यथा यदि वैरिएबल (जेड) है
     आंशिकDerivativeOf(Z) += बीज;

} </सिंटैक्सहाइलाइट>

पायथन

टेप के बिना पायथन (प्रोग्रामिंग भाषा) में कार्यान्वयन।

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)

सी++

<सिंटैक्सहाइलाइट लैंग= सी++ >

1. शामिल करें <iostream>
2. शामिल <स्ट्रिंग>
3. शामिल <मानचित्र>

संरचना अभिव्यक्ति {

  आगे तैरना = 0, पीछे = 0;
  वर्चुअल फ्लोट eval(std::map<std::string,float> &vals) = 0;
  आभासी शून्य वापस(फ्लोट बीज) {पिछड़ा+=बीज; };

}; स्ट्रक्चर प्लस: सार्वजनिक अभिव्यक्ति {

  अभिव्यक्ति *ए, *बी;
  प्लस(अभिव्यक्ति *ए, अभिव्यक्ति *बी): ए{ए}, बी{बी} {}
  फ्लोट 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);
     आगे लौटें;
  }
  शून्य वापस (फ्लोट बीज) {
     अभिव्यक्ति::वापस(बीज);
     a->पीछे(बीज * b->आगे);
     बी->पीछे(बीज * ए->आगे);
  }

}; संरचना वार: सार्वजनिक अभिव्यक्ति {

  एसटीडी::स्ट्रिंग एस;
  Var(std::string s) : s{s} {}
  फ्लोट eval(std::map<std::string,float> &vals) {
     फॉरवर्ड=वैल्स[एस];
     पिछड़ा=0;
     आगे लौटें;
  }
  शून्य वापस (फ्लोट बीज) {
     अभिव्यक्ति::वापस(बीज);
     std::cout << s << : << पिछड़ा << , ;
  }

}; मुख्य प्रवेश बिंदु (){

  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));
  वर x( x ), y( y ), z( z ); मूल m1(&x,&z); मूल m2(&y,&z); प्लस p(&m1,&m2); // x*z+y*z
  std::cout << p.eval(dict) << std::endl;
  पी.बैक(1); std::cout << std::endl;
  वापसी 0;

} </सिंटैक्सहाइलाइट>

आगे और पीछे संचय से परे

आगे और पीछे संचय श्रृंखला नियम को पार करने के केवल दो (चरम) तरीके हैं। संपूर्ण जैकोबियन की गणना करने की समस्या f : Rⁿ → R^m अंकगणितीय परिचालनों की न्यूनतम संख्या के साथ इष्टतम जैकोबियन संचय (ओजेए) समस्या के रूप में जाना जाता है, जो एनपी-पूर्ण है। इस प्रमाण के केंद्र में यह विचार है कि ग्राफ़ के किनारों को लेबल करने वाले स्थानीय आंशिक भागों के बीच बीजगणितीय निर्भरताएँ मौजूद हो सकती हैं। विशेष रूप से, दो या दो से अधिक एज लेबल को बराबर के रूप में पहचाना जा सकता है। समस्या की जटिलता अभी भी खुली है यदि यह मान लिया जाए कि सभी किनारे के लेबल अद्वितीय और बीजगणितीय रूप से स्वतंत्र हैं।

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

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

हर नंबर बदलें $\,x$ संख्या के साथ $x+x'\varepsilon$, कहाँ $x'$ एक वास्तविक संख्या है, लेकिन $\varepsilon$ संपत्ति के साथ एक अमूर्त संख्या है $\varepsilon ^{2}=0$ (एक अतिसूक्ष्म; सहज अतिसूक्ष्म विश्लेषण देखें)। इसके प्रयोग से ही नियमित अंकगणित मिलता है

$${\begin{aligned}(x+x'\varepsilon )+(y+y'\varepsilon )&=x+y+(x'+y')\varepsilon \\(x+x'\varepsilon )-(y+y'\varepsilon )&=x-y+(x'-y')\varepsilon \\(x+x'\varepsilon )\cdot (y+y'\varepsilon )&=xy+xy'\varepsilon +yx'\varepsilon +x'y'\varepsilon ^{2}=xy+(xy'+yx')\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{aligned}}$$

का उपयोग करते हुए $(1+y'\varepsilon /y)\cdot (1-y'\varepsilon /y)=1$.

अब, इस संवर्धित अंकगणित में बहुपदों की गणना की जा सकती है। अगर $P(x)=p_{0}+p_{1}x+p_{2}x^{2}+\cdots +p_{n}x^{n}$, तब

$${\begin{aligned}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_{1}x'\varepsilon +2p_{2}xx'\varepsilon +\cdots +np_{n}x^{n-1}x'\varepsilon \\&=P(x)+P^{(1)}(x)x'\varepsilon \end{aligned}}$$

कहाँ $P^{(1)}$ के व्युत्पन्न को दर्शाता है $P$ इसके पहले तर्क के संबंध में, और $x'$, जिसे बीज कहा जाता है, मनमाने ढंग से चुना जा सकता है।

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

$$g$$