स्वचालित भेदभाव

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

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

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

चित्र 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$) पर निर्धारित किया जाता है। इसके विपरीत, उत्क्रम संचयन के लिए आंशिक अवकलज के लिए मूल्यांकन किए गए आंशिक फलनो की आवश्यकता होती है। इसलिए उत्क्रम संचयन पहले फलन का मूल्यांकन करता है और एक अतिरिक्त पास में सभी स्वतंत्र चर के संबंध में अवकलज की गणना करता है।

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

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

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

अग्रगामी संचयन की शुरुआत 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 <<t, << पिछड़ा << ,�;
  }

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

  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$$