Automatic differentiation

In mathematics and computer algebra, automatic differentiation (AD), also called algorithmic differentiation or computational differentiation, is a set of techniques to numerically evaluate the derivative of a function specified by a computer program. AD exploits the fact that every computer program, no matter how complicated, executes a sequence of elementary arithmetic operations (addition, subtraction, multiplication, division, etc.) and elementary functions (exp, log, sin, cos, etc.). By applying the chain rule repeatedly to these operations, derivatives of arbitrary order can be computed automatically, accurately to working precision, and using at most a small constant factor more arithmetic operations than the original program.

Automatic differentiation is not:

Figure 1: How automatic differentiation relates to symbolic differentiation

• Symbolic differentiation, nor
• Numerical differentiation (the method of finite differences).

These classical methods run into problems: symbolic differentiation leads to inefficient code (unless done carefully) and faces the difficulty of converting a computer program into a single expression, while numerical differentiation can introduce round-off errors in the discretization process and cancellation. Both classical methods have problems with calculating higher derivatives, where the complexity and errors increase. Finally, both classical methods are slow at computing the partial derivatives of a function with respect to many inputs, as is needed for gradient-based optimization algorithms. Automatic differentiation solves all of these problems, at the expense of introducing more software dependencies.

The chain rule, forward and reverse accumulation

Fundamental to AD is the decomposition of differentials provided by the chain rule. For the simple composition $y=f(g(h(x)))=f(g(h(w_{0})))=f(g(w_{1}))=f(w_{2})=w_{3}$ the chain rule gives

${\frac {dy}{dx}}={\frac {dy}{dw_{2}}}{\frac {dw_{2}}{dw_{1}}}{\frac {dw_{1}}{dx}}$

Usually, two distinct modes of AD are presented, forward accumulation (or forward mode) and reverse accumulation (or reverse mode). Forward accumulation specifies that one traverses the chain rule from inside to outside (that is, first compute $dw_{1}/dx$ and then $dw_{2}/dw_{1}$ and at last $dy/dw_{2}$), while reverse accumulation has the traversal from outside to inside (first compute $dy/dw_{2}$ and then $dw_{2}/dw_{1}$ and at last $dw_{1}/dx$). More succinctly,

1. forward accumulation computes the recursive relation: ${\frac {dw_{i}}{dx}}={\frac {dw_{i}}{dw_{i-1}}}{\frac {dw_{i-1}}{dx}}$ with $w_{3}=y$, and,
2. reverse accumulation computes the recursive relation: ${\frac {dy}{dw_{i}}}={\frac {dy}{dw_{i+1}}}{\frac {dw_{i+1}}{dw_{i}}}$ with $w_{0}=x$.

Generally, both forward and reverse accumulation are specific manifestations of applying the operator of program composition, with the appropriate one of the two mappings $(w,y)$ being fixed.

Forward accumulation

Figure 2: Example of forward accumulation with computational graph

In forward accumulation AD, one first fixes the independent variable with respect to which differentiation is performed and computes the derivative of each sub-expression recursively. In a pen-and-paper calculation, one can do so by repeatedly substituting the derivative of the inner functions in the chain rule:

${\frac {\partial y}{\partial x}}={\frac {\partial y}{\partial w_{n-1}}}{\frac {\partial w_{n-1}}{\partial x}}={\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)={\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)=\cdots$

This can be generalized to multiple variables as a matrix product of Jacobians.

Compared to reverse accumulation, forward accumulation is very natural and easy to implement as the flow of derivative information coincides with the order of evaluation. One simply augments each variable w with its derivative ẇ (stored as a numerical value, not a symbolic expression),

${\dot {w}}={\frac {\partial w}{\partial x}}$

as denoted by the dot. The derivatives are then computed in sync with the evaluation steps and combined with other derivatives via the chain rule.

As an example, consider the function:

${\begin{aligned}z&=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}}$

For clarity, the individual sub-expressions have been labeled with the variables w_i.

The choice of the independent variable to which differentiation is performed affects the seed values ẇ₁ and ẇ₂. Suppose one is interested in the derivative of this function with respect to x₁. In this case, the seed values should be set to:

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

With the seed values set, one may then propagate the values using the chain rule as shown in the table below. Figure 2 shows a pictorial depiction of this process as a computational graph.

${\begin{array}{l|l}{\text{Operations to compute value}}&{\text{Operations to compute derivative}}\\\hline w_{1}=x_{1}&{\dot {w}}_{1}=1{\text{ (seed)}}\\w_{2}=x_{2}&{\dot {w}}_{2}=0{\text{ (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}={\dot {w}}_{3}+{\dot {w}}_{4}\end{array}}$

To compute the gradient of this example function, which requires the derivatives of f with respect to not only x₁ but also x₂, one must perform an additional sweep over the computational graph using the seed values ${\dot {w}}_{1}=0;{\dot {w}}_{2}=1$.

The computational complexity of one sweep of forward accumulation is proportional to the complexity of the original code.

Forward accumulation is more efficient than reverse accumulation for functions f : ℝⁿ → ℝ^m with m ≫ n as only n sweeps are necessary, compared to m sweeps for reverse accumulation.

Reverse accumulation

Figure 3: Example of reverse accumulation with computational graph

In reverse accumulation AD, one first fixes the dependent variable to be differentiated and computes the derivative with respect to each sub-expression recursively. In a pen-and-paper calculation, one can perform the equivalent by repeatedly substituting the derivative of the outer functions in the chain rule:

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

In reverse accumulation, the quantity of interest is the adjoint, denoted with a bar (w̄); it is a derivative of a chosen dependent variable with respect to a subexpression w:

${\bar {w}}={\frac {\partial y}{\partial w}}$

Reverse accumulation traverses the chain rule from outside to inside, or in the case of the computational graph in Figure 3, from top to bottom. The example function is scalar-valued, and thus there is only one seed for the derivative computation, and only one sweep of the computational graph is needed in order to calculate the (two-component) gradient. This is only half the work when compared to forward accumulation, but reverse accumulation requires the storage of the intermediate variables w_i as well as the instructions that produced them in a data structure known as a Wengert list (or "tape"), which may represent a significant memory issue if the computational graph is large. This can be mitigated to some extent by storing only a subset of the intermediate variables and then reconstructing the necessary work variables by repeating the evaluations, a technique known as rematerialization. Checkpointing is also used to save intermediary states.

The operations to compute the derivative using reverse accumulation are shown in the table below (note the reversed order):

${\begin{array}{l}{\text{Operations to compute derivative}}\\\hline {\bar {w}}_{5}=1{\text{ (seed)}}\\{\bar {w}}_{4}={\bar {w}}_{5}\\{\bar {w}}_{3}={\bar {w}}_{5}\\{\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}\end{array}}$

The data flow graph of a computation can be manipulated to calculate the gradient of its original calculation. This is done by adding an adjoint node for each primal node, connected by adjoint edges which parallel the primal edges but flow in the opposite direction. The nodes in the adjoint graph represent multiplication by the derivatives of the functions calculated by the nodes in the primal. For instance, addition in the primal causes fanout in the adjoint; fanout in the primal causes addition in the adjoint; a unary function y = f(x) in the primal causes x̄ = ȳ f′(x) in the adjoint; etc.

Reverse accumulation is more efficient than forward accumulation for functions f : ℝⁿ → ℝ^m with m ≪ n as only m sweeps are necessary, compared to n sweeps for forward accumulation.

Reverse mode AD was first published in 1976 by Seppo Linnainmaa.

Backpropagation of errors in multilayer perceptrons, a technique used in machine learning, is a special case of reverse mode AD.

Beyond forward and reverse accumulation

Forward and reverse accumulation are just two (extreme) ways of traversing the chain rule. The problem of computing a full Jacobian of f : ℝⁿ → ℝ^m with a minimum number of arithmetic operations is known as the optimal Jacobian accumulation (OJA) problem, which is NP-complete. Central to this proof is the idea that there may exist algebraic dependencies between the local partials that label the edges of the graph. In particular, two or more edge labels may be recognized as equal. The complexity of the problem is still open if it is assumed that all edge labels are unique and algebraically independent.

Automatic differentiation using dual numbers

Forward mode automatic differentiation is accomplished by augmenting the algebra of real numbers and obtaining a new arithmetic. An additional component is added to every number which will represent the derivative of a function at the number, and all arithmetic operators are extended for the augmented algebra. The augmented algebra is the algebra of dual numbers. This approach was generalized by the theory of operational calculus on programming spaces (see Analytic programming space), through tensor algebra of the dual space.

Replace every number $\,x$ with the number $x+x'\varepsilon$, where $x'$ is a real number, but $\varepsilon$ is an abstract number with the property $\varepsilon ^{2}=0$ (an infinitesimal; see Smooth infinitesimal analysis). Using only this, we get for the regular arithmetic

${\begin{aligned}(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 \end{aligned}}$

and likewise for subtraction and division.

Now, we may calculate polynomials in this augmented arithmetic. If $P(x)=p_{0}+p_{1}x+p_{2}x^{2}+\cdots +p_{n}x^{n}$, then

${\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}}$

where $P^{(1)}$ denotes the derivative of $P$ with respect to its first argument, and $x'$, called a seed, can be chosen arbitrarily.

The new arithmetic consists of ordered pairs, elements written $\langle x,x'\rangle$, with ordinary arithmetics on the first component, and first order differentiation arithmetic on the second component, as described above. Extending the above results on polynomials to analytic functions we obtain a list of the basic arithmetic and some standard functions for the new arithmetic:

${\begin{aligned}\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 \\\left\langle u,u'\right\rangle *\left\langle v,v'\right\rangle &=\left\langle uv,u'v+uv'\right\rangle \\\left\langle u,u'\right\rangle /\left\langle v,v'\right\rangle &=\left\langle {\frac {u}{v}},{\frac {u'v-uv'}{v^{2}}}\right\rangle \quad (v\neq 0)\\\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 \\\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},ku^{k-1}u'\right\rangle \quad (u\neq 0)\\\left|\left\langle u,u'\right\rangle \right|&=\left\langle \left|u\right|,u'{\mbox{sign}}u\right\rangle \quad (u\neq 0)\end{aligned}}$

and in general for the primitive function $g$,

$g(\langle u,u'\rangle ,\langle v,v'\rangle )=\langle g(u,v),g_{u}(u,v)u'+g_{v}(u,v)v'\rangle$

where $g_{u}$ and $g_{v}$ are the derivatives of $g$ with respect to its first and second arguments, respectively.

When a binary basic arithmetic operation is applied to mixed arguments—the pair $\langle u,u'\rangle$ and the real number $c$—the real number is first lifted to $\langle c,0\rangle$. The derivative of a function $f:\mathbb {R} \rightarrow \mathbb {R}$ at the point $x_{0}$ is now found by calculating $f(\langle x_{0},1\rangle )$ using the above arithmetic, which gives $\langle f(x_{0}),f'(x_{0})\rangle$ as the result.

Vector arguments and functions

Multivariate functions can be handled with the same efficiency and mechanisms as univariate functions by adopting a directional derivative operator. That is, if it is sufficient to compute $y'=\nabla f(x)\cdot x'$, the directional derivative $y'\in \mathbb {R} ^{m}$ of $f:\mathbb {R} ^{n}\rightarrow \mathbb {R} ^{m}$ at $x\in \mathbb {R} ^{n}$ in the direction $x'\in \mathbb {R} ^{n}$, this may be calculated as $(\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 )$ using the same arithmetic as above. If all the elements of $\nabla f$ are desired, then $n$ function evaluations are required. Note that in many optimization applications, the directional derivative is indeed sufficient.

High order and many variables

The above arithmetic can be generalized to calculate second order and higher derivatives of multivariate functions. However, the arithmetic rules quickly grow very complicated: complexity will be quadratic in the highest derivative degree. Instead, truncated Taylor polynomial algebra can be used. The resulting arithmetic, defined on generalized dual numbers, allows to efficiently compute using functions as if they were a new data type. Once the Taylor polynomial of a function is known, the derivatives are easily extracted. A rigorous, general formulation is achieved through the tensor series expansion using operational calculus on programming spaces.

Operational calculus on programming spaces

Operational calculus on programming spaces provides differentiable programming with formal semantics through an algebra of higher-order constructs. It can thus be used to express the concepts underlying automatic differentiation.

Differentiable programming space

A differentiable programming space ${\mathcal {P}}_{0}$ is any subspace of ${\mathcal {F}}_{0}:{\mathcal {V}}\to {\mathcal {V}}$ such that

$\partial {\mathcal {P}}_{0}\subset {\mathcal {P}}_{0}\otimes T({\mathcal {V}}^{*}),$

where $T({\mathcal {V}}^{*})$ is the tensor algebra of the dual space ${\mathcal {V}}^{*}$. When all elements of ${\mathcal {P}}_{0}$ are analytic, we call ${\mathcal {P}}_{0}$ an analytic programming space.

Theorem. Any differentiable programming space ${\mathcal {P}}_{0}$ is an infinitely differentiable programming space, meaning that

$\partial ^{k}{\mathcal {P}}_{0}\subset {\mathcal {P}}_{0}\otimes T({\mathcal {V}}^{*})$

for any $k\in \mathbb {N} .$ If all elements of ${\mathcal {P}}_{0}$ are analytic, than so are the elements of ${\mathcal {P}}_{n}$.

Definition. Let ${\mathcal {P}}_{0}$ be a differentiable programming space. The space ${\mathcal {P}}_{n}<{\mathcal {F}}_{n}:{\mathcal {V}}\to {\mathcal {V}}\otimes T({\mathcal {V}}^{*})$ spanned by ${\mathcal {D}}^{n}{\mathcal {P}}_{0}$ over $K$, where ${\mathcal {D}}^{n}=\{\partial ^{k}|0\leq k\leq n\},$ is called a differentiable programming space of order $n$.

Corollary. A differentiable programming space of order $n,{\mathcal {P}}_{n}:{\mathcal {V}}\to {\mathcal {V}}\otimes T({\mathcal {V}}^{*}),$ can be embedded into the tensor product of the function space ${\mathcal {P}}_{0}:{\mathcal {V}}\to {\mathcal {V}}$ and the subspace $T_{n}({\mathcal {V}}^{*})$ of the tensor algebra of the dual of the virtual space ${\mathcal {P}}$. By taking the limit as $n\to \infty$, we consider

${\mathcal {P}}_{\infty }<{\mathcal {P}}_{0}\otimes {\mathcal {T}}({\mathcal {V}}^{*}),$

where

${\mathcal {T}}({\mathcal {V}}^{*})=\prod _{k=0}^{\infty }({\mathcal {V}}^{*})^{\otimes k}$

is the tensor series algebra, the algebra of the infinite formal tensor series, which is a completion of the tensor algebra $T({\mathcal {V}}^{*})$ in suitable topology.

Proofs can be found in.

This means that we can represent calculation of derivatives of the map $P:{\mathcal {V}}\to {\mathcal {V}}$, with only one mapping $\tau$. We define the operator $\tau _{n}$ as a direct sum of operators

$\tau _{n}=1+\partial +\partial ^{2}+\cdots +\partial ^{n}$

The image $\tau _{k}P(\mathbf {x} )$ is a multitensor of order $k$, which is a direct sum of the maps value and all derivatives of order $n\leq k$, all evaluated at the point $\mathbf {x}$

$\tau _{k}P(\mathbf {x} )=P(\mathbf {x} )+\partial _{\mathbf {x} }P(\mathbf {x} )+\partial _{\mathbf {x} }^{2}P(\mathbf {x} )+\cdots +\partial _{\mathbf {x} }^{k}P(\mathbf {x} ).$

The operator $\tau _{n}$ satisfies the recursive relation.

$\tau _{k+1}=1+\partial \tau _{k},$

that can be used to recursively construct programming spaces of arbitrary order. Only explicit knowledge of $\tau :{\mathcal {P}}_{0}\to {\mathcal {P}}_{1}$ is required for the construction of ${\mathcal {P}}_{n}$ from ${\mathcal {P}}_{1}$, which is evident from the above theorem.

Virtual tensor machine

The paper proposed an abstract virtual machine capable of constructing and implementing the theory. Such a machine provides a framework for analytic study of algorithmic procedures through algebraic means.

Claim. The tuple $({\mathcal {V}},{\mathcal {P}}_{0})$ and the belonging tensor series algebra are sufficient conditions for the existence and construction of infinitely differentiable programming spaces ${\mathcal {P}}_{\infty }$, through linear combinations of elements of ${\mathcal {P}}_{0}\otimes {\mathcal {T}}({\mathcal {V}}^{*})$.

This claim allows a simple definition of such a machine.

Definition (Virtual tensor machine). The tuple $M=\langle {\mathcal {V}},{\mathcal {P}}_{0}\rangle$ is a virtual tensor machine, where

• ${\mathcal {V}}$ is a finite dimensional vector space
• ${\mathcal {V}}\otimes {\mathcal {T}}({\mathcal {V}}^{*})$ is the virtual memory space
• ${\mathcal {P}}_{0}$ is an analytic programming space over ${\mathcal {V}}$

Tensor series expansion

Expansion into a series offers valuable insights into programs through methods of analysis.

There exists a space spanned by the set ${\mathcal {D}}^{n}=\{\partial ^{k}|0\leq k\leq n\}$ over a field $K$. Thus, the expression

$e^{h\partial }=\sum _{n=0}^{\infty }{\frac {(h\partial )^{n}}{n!}}$

is well defined. The operator $e^{h\partial }$ is a mapping between function spaces

$e^{h\partial }:{\mathcal {P}}\to {\mathcal {P}}_{\infty }.$

It also defines a map

$e^{h\partial }:{\mathcal {P}}\times {\mathcal {V}}\to {\mathcal {V}}\otimes {\mathcal {T}}({\mathcal {V}}^{*}),$

by taking the image of the map $e^{h\partial }(P)$ at a certain point $\mathbf {v} \in {\mathcal {V}}$.

We may construct a map from the space of programs, to the space of polynomials. Note that the space of multivariate polynomials ${\mathcal {V}}\to K$ is isomorphic to symmetric algebra $S({\mathcal {V}}^{*})$, which is in turn a quotient of tensor algebra $T({\mathcal {V}}^{*})$. To any element of ${\mathcal {V}}\otimes T({\mathcal {V}}^{*})$ one can attach corresponding element of ${\mathcal {V}}\otimes S({\mathcal {V}}^{i*})$ namely a polynomial map ${\mathcal {V}}\to {\mathcal {V}}$. Thus, we consider the completion of the symmetric algebra $S({\mathcal {V}}^{*})$ as the formal power series ${\mathcal {S}}({\mathcal {V}}^{*})$, which is in turn isomorphic to a quotient of tensor series algebra ${\mathcal {T}}({\mathcal {V}}^{*})$, arriving at

$e^{h\partial }:{\mathcal {P}}\times {\mathcal {V}}\to {\mathcal {V}}\otimes {\mathcal {S}}({\mathcal {V}}^{i*})$

For any element $\mathbf {v} _{0}\in {\mathcal {V}}$, the expression $e^{h\partial }(\cdot ,\mathbf {v} _{0})$ is a map ${\mathcal {P}}\to {\mathcal {V}}\otimes {\mathcal {S}}({\mathcal {V}}^{*})$, mapping a program to a formal power series. We can express the correspondence between multi-tensors in ${\mathcal {V}}\otimes T({\mathcal {V}}^{*})$ and polynomial maps ${\mathcal {V}}\to {\mathcal {V}}$ given by multiple contractions for all possible indices.

Theorem. For a program $P\in {\mathcal {P}}$ the expansion into an infinite tensor series at the point $\mathbf {v} _{0}\in {\mathcal {V}}$ is expressed by multiple contractions

$P(\mathbf {v} _{0}+h\mathbf {v} )=\left((e^{h\partial }P)(\mathbf {v} _{0})\right)\cdot \mathbf {v} =\sum _{n=0}^{\infty }{\frac {h^{n}}{n!}}\partial ^{n}P(\mathbf {v} _{0})\cdot (\mathbf {v} ^{\otimes n})$

Proof can be found in. Evaluated at $h=1$, the operator is a generalization of the shift operator widely used in physics. For a specific $v_{0}\in {\mathcal {V}}$ it is here on denoted by

$e^{\partial }\vert _{v_{0}}:{\mathcal {P}}\to {\mathcal {V}}\otimes {\mathcal {T}}({\mathcal {V}}^{*}).$

When the choice of $v_{0}\in {\mathcal {V}}$ is arbitrary, we omit it from expressions for brevity. Following this work, a similar approach was taken by others.

Operator of program composition

Theory offers a generalization of both forward and reverse mode of automatic differentiation to arbitrary order, under a single invariant operator in the theory. This condenses complex notions to simple expressions allowing meaningful manipulations before being applied to a particular programming space.

Theorem. Composition of maps ${\mathcal {P}}$ is expressed as

$e^{h\partial }(f\circ g)=\exp(\partial _{f}e^{h\partial _{g}})(g,f)$

where $\exp(\partial _{f}e^{h\partial _{g}}):{\mathcal {P}}\times {\mathcal {P}}\to {\mathcal {P}}_{\infty }$ is an operator on pairs of maps $(g,f)$, where $\partial _{g}$ is applied to $g$ and $\partial _{f}$ to $f$.

Proof can be found in.

Both forward and reverse mode (generalized to arbitrary order) are obtainable using this operator, by fixing the appropriate one of the two maps. This generalizes both concepts under a single operator in the theory. For example, by considering projections of the operator onto the space spanned by ${\mathcal {D}}=\{1,\partial \}$, and fixing the second map $g$, we retrieve the basic first order forward mode of automatic differentiation, or reverse mode, by fixing $f$.

Thus the operator alleviates the need for explicit implementation of the higher order chain rule (see Faà di Bruno's formula), as it is encoded in the structure of the operator itself, which can be efficiently implemented by manipulating its generating map (see ).

Order reduction for nested applications

It is useful to be able to use the $k$-th derivative of a program $P\in {\mathcal {P}}$ as part of a different differentiable program $P_{1}$. As such, we must be able to treat the derivative itself as a differentiable program $P^{\prime k}\in {\mathcal {P}}$, while only coding the original program $P$.

Theorem. There exists a reduction of order map $\phi :{\mathcal {P}}_{n}\to {\mathcal {P}}_{n-1}$ satisfying

$\forall P_{1}\in {\mathcal {P}}_{0}\quad \exists P_{2}\in {\mathcal {P}}_{0}\qquad \phi ^{k}\circ e_{n}^{\partial }(P_{1})=e_{n-k}^{\partial }(P_{2})$

for each $n\geq 1,$ where $e_{n}^{\partial }$ is the projection of the operator $e^{\partial }$ onto the set ${\mathcal {D}}^{n}=\{\partial ^{k}|0\leq k\leq n\}$.

By the above Theorem, $n$-differentiable $k$-th derivatives of a program $P\in {\mathcal {P}}_{0}$ can be extracted by

$^{n}P^{k\prime }=\phi ^{k}\circ e_{n+k}^{\partial }(P)\in {\mathcal {P}}_{n}.$

Thus, we gained the ability of writing a differentiable program acting on derivatives of another program, stressed as crucial by other authors.

Implementation

Forward-mode AD is implemented by a nonstandard interpretation of the program in which real numbers are replaced by dual numbers, constants are lifted to dual numbers with a zero epsilon coefficient, and the numeric primitives are lifted to operate on dual numbers. This nonstandard interpretation is generally implemented using one of two strategies: source code transformation or operator overloading.

Source code transformation (SCT)

Figure 4: Example of how source code transformation could work

The source code for a function is replaced by an automatically generated source code that includes statements for calculating the derivatives interleaved with the original instructions.

Source code transformation can be implemented for all programming languages, and it is also easier for the compiler to do compile time optimizations. However, the implementation of the AD tool itself is more difficult.

Operator overloading (OO)

Figure 5: Example of how operator overloading could work

Operator overloading is a possibility for source code written in a language supporting it. Objects for real numbers and elementary mathematical operations must be overloaded to cater for the augmented arithmetic depicted above. This requires no change in the form or sequence of operations in the original source code for the function to be differentiated, but often requires changes in basic data types for numbers and vectors to support overloading and often also involves the insertion of special flagging operations.

Operator overloading for forward accumulation is easy to implement, and also possible for reverse accumulation. However, current compilers lag behind in optimizing the code when compared to forward accumulation.

Operator overloading, for both forward and reverse accumulation, can be well-suited to applications where the objects are vectors of real numbers rather than scalars. This is because the tape then comprises vector operations; this can facilitate computationally efficient implementations where each vector operation performs many scalar operations. Vector adjoint algorithmic differentiation (vector AAD) techniques may be used, for example, to differentiate values calculated by Monte-Carlo simulation.

Examples of operator-overloading implementations of automatic differentiation in C++ are the Adept and Stan libraries.

Literature

• Rall, Louis B. (1981). Automatic Differentiation: Techniques and Applications. Lecture Notes in Computer Science. 120. Springer. ISBN 3-540-10861-0.
• Griewank, Andreas; Walther, Andrea (2008). Evaluating Derivatives: Principles and Techniques of Algorithmic Differentiation. Other Titles in Applied Mathematics. 105 (2nd ed.). SIAM. ISBN 978-0-89871-659-7. Archived from the original on 2010-03-23. Retrieved 2009-10-21.
• Neidinger, Richard (2010). "Introduction to Automatic Differentiation and MATLAB Object-Oriented Programming" (PDF). SIAM Review. 52 (3): 545–563. doi:10.1137/080743627. Retrieved 2013-03-15.
• Antoine Savine (2018). Modern Computational Finance: AAD and Parallel Simulations. Wiley. ISBN 978-1119539452.

External links

• www.autodiff.org, An "entry site to everything you want to know about automatic differentiation"
• Automatic Differentiation of Parallel OpenMP Programs
• Automatic Differentiation, C++ Templates and Photogrammetry
• Automatic Differentiation, Operator Overloading Approach
• Compute analytic derivatives of any Fortran77, Fortran95, or C program through a web-based interface Automatic Differentiation of Fortran programs
• Description and example code for forward Automatic Differentiation in Scala
• finmath-lib automatic differentiation extensions, Automatic differentiation for random variables (Java implementation of the stochastic automatic differentiation).
• Adjoint Algorithmic Differentiation: Calibration and Implicit Function Theorem
• C++ Template-based automatic differentiation article and implementation
• Tangent Source-to-Source Debuggable Derivatives
• [1], Exact First- and Second-Order Greeks by Algorithmic Differentiation
• [2], Adjoint Algorithmic Differentiation of a GPU Accelerated Application
• [3], Adjoint Methods in Computational Finance Software Tool Support for Algorithmic Differentiation