Automatic differentiation

In mathematics and computer algebra, automatic differentiation (AD), also called algorithmic differentiation, computational differentiation, auto-differentiation, or simply autodiff, is a set of techniques to 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 distinct from symbolic differentiation and numerical differentiation.
Symbolic differentiation faces the difficulty of converting a computer program into a single mathematical expression and can lead to inefficient code. Numerical differentiation (the method of finite differences) can introduce round-off errors in the discretization process and cancellation. Both of these classical methods have problems with calculating higher derivatives, where complexity and errors increase. Finally, both of these classical methods are slow at computing 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.

The chain rule, forward and reverse accumulation

Fundamental to AD is the decomposition of differentials provided by the chain rule. For the simple composition
$\begin 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$
the chain rule gives
$\frac = \frac \frac \frac = \frac \frac \frac$

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,
# forward accumulation computes the recursive relation: $\frac = \frac \frac$ with $w_3 = y$, and,
# reverse accumulation computes the recursive relation: $\frac = \frac \frac$ with $w_0 = x$.

Forward accumulation

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, this involves repeatedly substituting the derivative of the ''inner'' functions in the chain rule:
\begin
\frac
&= \frac \frac \\ pt&= \frac \left(\frac \frac\right) \\ pt&= \frac \left(\frac \left(\frac \frac\right)\right) \\ pt&= \cdots
\end
This can be generalized to multiple variables as a matrix product of Jacobians.

Compared to reverse accumulation, forward accumulation is natural and easy to implement as the flow of derivative information coincides with the order of evaluation. Each variable is augmented with its derivative (stored as a numerical value, not a symbolic expression),
$\dot w = \frac$
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 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$
For clarity, the individual sub-expressions have been labeled with the variables .

The choice of the independent variable to which differentiation is performed affects the ''seed'' values and . Given interest in the derivative of this function with respect to , the seed values should be set to:
$\begin \dot w_1 = \frac = 1 \\ \dot w_2 = \frac = 0 \end$

With the seed values set, the values propagate using the chain rule as shown. Figure 2 shows a pictorial depiction of this process as a computational graph.
:

To compute the gradient of this example function, which requires the derivatives of with respect to not only but also , an ''additional'' sweep is performed 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 with as only sweeps are necessary, compared to sweeps for reverse accumulation.

Reverse accumulation

In reverse accumulation AD, the ''dependent variable'' to be differentiated is fixed and the derivative is computed ''with respect to'' each sub- expression recursively. In a pen-and-paper calculation, the derivative of the ''outer'' functions is repeatedly substituted in the chain rule:
$\frac = \frac \frac = \left(\frac \frac\right) \frac = \left(\left(\frac \frac\right) \frac\right) \frac = \cdots$

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

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 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 as well as the instructions that produced them in a data structure known as a Wengert list (or "tape"), which may consume significant memory 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):

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 in the primal causes in the adjoint; etc.

Reverse accumulation is more efficient than forward accumulation for functions with as only sweeps are necessary, compared to 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 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 algebraic dependencies may exist 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 to 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.

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, regular arithmetic gives
$\begin (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 + (x y' + 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$
using $(1 + y'\varepsilon/y) \cdot (1 - y'\varepsilon/y) = 1$.

Now, polynomials can be calculated in this augmented arithmetic. If $P(x) = p_0 + p_1 x + p_2x^2 + \cdots + p_n x^n$, then
$\begin 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^ x'\varepsilon \\ &= P(x) + P^(x)x'\varepsilon \end$
where $P^$ 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 gives a list of the basic arithmetic and some standard functions for the new arithmetic:
$\begin \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 u v, u'v + uv' \right\rangle \\ \left\langle u,u'\right\rangle / \left\langle v,v'\right\rangle &= \left\langle \frac, \frac \right\rangle \quad ( v\ne 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 , u' k u^ \right\rangle \quad (u \ne 0) \\ \left, \left\langle u,u'\right\rangle \ &= \left\langle \left, u \ , u' \operatorname u \right\rangle \quad (u \ne 0) \end$
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 : \R\to\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 \R^m$ of $f:\R^n\to\R^m$ at $x \in \R^n$ in the direction $x' \in \R^n$ 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 complicated: complexity is quadratic in the highest derivative degree. Instead, truncated Taylor polynomial algebra can be used. The resulting arithmetic, defined on generalized dual numbers, allows efficient computation using functions as if they were a data type. Once the Taylor polynomial of a function is known, the derivatives are easily extracted.

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)

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 and the build system is more complex.

Operator overloading (OO)

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.

Examples of operator-overloading implementations of automatic differentiation in C++ are the Adept, the NAG's dco library, and the Stan libraries.

See also

* Differentiable programming

Notes

References

Further reading

*
*
*
*
*

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 stochastic automatic differentiation
Automatic differentiation for random variables (Java implementation of the stochastic automatic differentiation).

Adjoint Algorithmic Differentiation: Calibration and Implicit Function Theorem


an
implementation

Tangent

Exact First- and Second-Order Greeks by Algorithmic Differentiation

Adjoint Algorithmic Differentiation of a GPU Accelerated Application

Adjoint Methods in Computational Finance Software Tool Support for Algorithmic Differentiationop

More than a Thousand Fold Speed Up for xVA Pricing Calculations with Intel Xeon Scalable Processors

{{DEFAULTSORT:Automatic Differentiation
Differential calculus
Computer algebra