Autodiff engine

KeOps provides a simple Automatic Differentiation (AD) engine for generic formulas. This feature can be used seamlessly through the Grad instruction or the PyTorch backend: users don’t have to understand backpropagation to enjoy our “free” gradients. Nevertheless, for the sake of completeness, here is a short introduction to the inner workings of KeOps.

Backprop 101

Gradient of a vector valued function

Let $F:{\mathbb{R}}^n\to {\mathbb{R}}^d$ be a smooth function. Around any given point $x\in {\mathbb{R}}^n$, its variations are encoded in a linear application $\text{d}F(x):{\mathbb{R}}^n\to {\mathbb{R}}^d$ called the differential of $F$: for all variation $\delta x\in {\mathbb{R}}^n$ of $x$,

$$F(x+\delta x)=F(x)+[\text{d}F(x)](\delta x)+o(\delta x).$$

Going further, we can define the gradient of $F$ at $x$ as the adjoint of $\text{d}F(x)$: it is the unique application $\partial F(x)=\text{d}F(x{)}^{\ast }:{\mathbb{R}}^d\to {\mathbb{R}}^n$ such that for all vector $e\in {\mathbb{R}}^d$ and variation $\delta x\in {\mathbb{R}}^n$ of $x$, we have:

$$⟨[\partial F(x)](e),\delta x{⟩}_{{\mathbb{R}}^n}=⟨e,[\text{d}F(x)](\delta x){⟩}_{{\mathbb{R}}^d},$$

where $⟨\cdot ,\cdot ⟩$ denotes the standard scalar product.

When $F$ is scalar-valued (i.e. when $d=1$), the gradient is a linear application from $\mathbb{R}$ to ${\mathbb{R}}^n$: it is best understood as the vector of partial derivatives of $F$. In the general case, the matrix of the gradient in the canonical basis is given by the transpose of the Jacobian of $F$.

Reverse mode AD = backpropagation = chain rule

Now, let’s assume that the function $F:{\mathbb{R}}^n\to {\mathbb{R}}^d$ can be written as a composition $F=F_p\circ \cdots \circ F_2\circ F_1$ of $p$ functions $F_i:E_{i-1}\to E_i$, where $E_i={\mathbb{R}}^{d_i}$. With these notations $d_0=n$ and $d_p=d$.

Evaluating the gradient of $F$ with the backpropagation algorithm requires:

1. A Forward pass to evaluate the functions

   $$\begin{array}{r}\begin{array}{ccccl}{F}_i& :& E_{i-1}& \to & E_i\\ & & x& \mapsto & F_i(x)\end{array}\end{array}$$

   and thus compute the value $F(x)$ :

   

2. A Backward pass to evaluate the (adjoints of the) differentials

   $$\begin{array}{r}\begin{array}{ccccl}\partial F_i& :& E_{i-1}\times E_i& \to & E_{i-1}\\ & & (x_{i-1},x_i^{\ast })& \mapsto & [\text{d}{F}_i^{\ast }(x_{i-1})](x_i^{\ast })=x_{i-1}^{\ast }\end{array}\end{array}$$

   and compute the gradient of $F$ at location $x$, applied to an arbitrary vector $e$ is the space of outputs:

   

This method relies on the chain-rule, as

$$\begin{array}{r}\begin{array}{rlrl}& & \text{d}(F_p\circ \cdots \circ F_1)(x_0)& =\text{d}{F}_p(x_{p-1})\circ \cdots \circ \text{d}{F}_1(x_0),\\ & \text{i.e.}& \text{d}(F_p\circ \cdots \circ F_1{)}^{\ast }(x_0)& =\text{d}{F}_1^{\ast }(x_0)\circ \cdots \circ \text{d}{F}_p^{\ast }(x_{p-1}),\\ & \text{i.e.}& [\partial F(x_0)](e)& =[\partial F_1(x_0)](\cdots [\partial F_p(x_{p-1})](e)).\end{array}\end{array}$$

When $F$ is scalar-valued (i.e. $d=1$), this algorithm allows us to compute the vector of partial derivatives

$$\mathrm{\nabla }F(x_0)=[\partial F(x_0)](1)$$

with a mere forward-backward pass through the computational graph of $F$… which is much cheaper than the naive evaluation of $n$ finite differences of $F$.

The KeOps generic engine

Backpropagation has become the standard way of computing the gradients of arbitrary “Loss” functions in imaging and machine learning. Crucially, any backprop engine should be able to:

• Link together the forward operations $F_i$ with their backward counterparts $\partial F_i$.

• Store in memory the intermediate results $x_0,\dots ,x_p$ before using them in the backward pass.

The Grad operator

At a low level, KeOps allows us to perform these tasks with the Grad instruction: given a formula $F$, the symbolic expression Grad(F, V, E) denotes the gradient $[{\partial }_{V}F(x)](E)$ with respect to the variable $V$ evaluated on the input variable $E$.

If V is a variable place-holder that appears in the expression of F and if E has the same dimension and category as F, Grad(F,V,E) can be fed to KeOps just like any other symbolic expression. The resulting output will have the same dimension and category as the variable V, and can be used directly for gradient descent or higher-order differentiation: operations such as Grad(Grad(..,..,..),..,..) are fully supported.

User interfaces

As evidenced by this example, the simple Grad syntax can relieve us from the burden of differentiating symbolic formulas by hand.

Going further, our Python interface is fully compatible with the PyTorch library: feel free to use the output of a pykeops.torch routine just like any other differentiable tensor! Thanks to the flexibility of the torch.autograd engine, end-to-end automatic differentiation is at hand: see this example or this example for an introduction.

An example

Coming back to our previous example where the formula

$$F(p,x,y,a{)}_i={(\sum _{j=1}^N(p-a_j{)}^2\exp (x_i^u+y_j^u))}_{i=1,\cdots ,M,u=1,2,3}\in {\mathbb{R}}^{M\times 3}$$

F = "Sum_Reduction(Square(Pm(0,1) - Vj(3,1)) * Exp(Vi(1,3) + Vj(2,3)), 1)"

was discussed, the symbolic expression

[grad_a F] = "Grad( Sum_Reduction(Square(Pm(0,1) - Vj(3,1)) * Exp(Vi(1,3) + Vj(2,3)), 1),
                 Vj(3,1), Vi(4,3) )"

allows us to compute the gradient of $F$ with respect to $(a_j)\in {\mathbb{R}}^N$ (= Vj(3,1)), applied to an arbitrary test vector $e\in {\mathbb{R}}^{M\times 3}$ given as a fifth input Vi(4,3) :

$${[[{\partial }_{a}F(p,x,y,a)](e)]}_j=-\sum _{i=1}^M\sum _{u=1}^{3}2(p-a_j)\exp (x_i^u+y_j^u)e_i^u\in \mathbb{R}.$$

With aliases, this computation simply reads:

p=Pm(0,1), x=Vi(1,3), y=Vj(2,3), a=Vj(3,1), e=Vi(4,3)
[grad_a F](e) = "Grad( Sum_Reduction(Square(p-a)*Exp(x+y), 1), a, e)"