Deep Learning with Parametric Lenses

Abstract.

We propose a categorical semantics for machine learning algorithms in terms of lenses, parametric maps, and reverse derivative categories. This foundation provides a powerful explanatory and unifying framework: it encompasses a variety of gradient descent algorithms such as ADAM, AdaGrad, and Nesterov momentum, as well as a variety of loss functions such as MSE and Softmax cross-entropy, and different architectures, shedding new light on their similarities and differences. Furthermore, our approach to learning has examples generalising beyond the familiar continuous domains (modelled in categories of smooth maps) and can be realised in the discrete setting of Boolean and polynomial circuits. We demonstrate the practical significance of our framework with an implementation in Python.

1. Introduction

The last decade has witnessed a surge of interest in machine learning, fuelled by the numerous successes and applications that these methodologies have found in many fields of science and technology. As machine learning techniques become increasingly pervasive, algorithms and models become more sophisticated, posing a significant challenge both to the software developers and the users that need to interface, execute and maintain these systems. In spite of this rapidly evolving picture, the formal analysis of many learning algorithms mostly takes place at a heuristic level [48], or using definitions that fail to provide a general and scalable framework for describing machine learning. Indeed, it is commonly acknowledged through academia, industry, policy makers and funding agencies that there is a pressing need for a unifying perspective, which can make this growing body of work more systematic, rigorous, transparent and accessible both for users and developers [41, 52].

Consider, for example, one of the most common machine learning scenarios: supervised learning with a neural network. This technique trains the model towards a certain task, e.g. the recognition of patterns in a data set (cf. Figure 1). There are several different ways of implementing this scenario. Typically, at their core, there is a gradient update algorithm (often called the “optimiser”), depending on a given loss function, which updates in steps the parameters of the network, based on some learning rate controlling the “scaling” of the update. All of these components can vary independently in a supervised learning algorithm and a number of choices is available for loss maps (quadratic error, Softmax cross entropy, dot product, etc.) and optimisers (Adagrad [23], Momentum [44], and Adam [36], etc.).

Figure 1. An informal illustration of gradient-based learning. This neural network is trained to distinguish different kinds of animals in the input image. Given an input $X$, the network predicts an output $Y$, which is compared by a ‘loss map’ with what would be the correct answer (‘label’). The loss map returns a real value expressing the error of the prediction; this information, together with the learning rate (a weight controlling how much the model should be changed in response to error) is used by an optimiser, which computes by gradient-descent the update of the parameters of the network, with the aim of improving its accuracy. The neural network, the loss map, the optimiser and the learning rate are all components of a supervised learning system, and can vary independently of one another.

This scenario highlights several questions: is there a uniform mathematical language capturing the different components of the learning process? Can we develop a unifying picture of the various optimisation techniques, allowing for their comparative analysis? Moreover, it should be noted that supervised learning is not limited to neural networks. For example, supervised learning is surprisingly applicable to the discrete setting of boolean circuits [59] where continuous functions are replaced by boolean-valued functions. Can we identify an abstract perspective encompassing both the real-valued and the boolean case? In a nutshell, this paper seeks to answer the question:

what are the fundamental mathematical structures

underpinning gradient-based learning?

Our approach to this question stems from the identification of three fundamental aspects of the gradient-descent learning process:

1. computation is parametric, e.g. in the simplest case we are given a function $f:P\times X\to Y$ and learning consists of finding a parameter $p:P$ such that $f(p,-)$ is the best function according to some criteria. Specifically, the weights on the internal nodes of a neural network are a parameter which the learning is seeking to optimize. Parameters also arise elsewhere, e.g. in the loss function (see later).

2. information flows bidirectionally: in the forward direction, the computation turns inputs via a sequence of layers into predicted outputs, and then into a loss value; in the reverse direction, backpropagation is used to propagate the changes backwards through the layers, and then turn them into parameter updates.

3. the basis of parameter update via gradient descent is differentiation e.g. in the simple case we differentiate the function mapping a parameter to its associated loss to reduce that loss.

We model bidirectionality via lenses [13, 6, 33] and based upon the above three insights, we propose the notion of parametric lens as the fundamental semantic structure of learning. In a nutshell, a parametric lens is a process with three kinds of interfaces: inputs, outputs, and parameters. On each interface, information flows both ways, i.e. computations are bidirectional. These data are best explained with our graphical representation of parametric lenses, with inputs $A$, $A^{\prime}$, outputs $B$, $B^{\prime}$, parameters $P$, $P^{\prime}$, and arrows indicating information flow (below left). The graphical notation also makes evident that parametric lenses are open systems, which may be composed along their interfaces (below center and right).

$$\begin{gathered}\scalebox{0.7}{ { \begin{tikzpicture} }}\qquad\scalebox{0.7}{{ \begin{tikzpicture} }}\qquad\vbox{\hbox{\scalebox{0.7}{{ \begin{tikzpicture} }}}}\end{gathered}$$ (1)

This pictorial formalism is not just an intuitive sketch: as we will show, it can be understood as a completely formal (graphical) syntax using the formalism of string diagrams [43], in a way similar to how other computational phenomena have been recently analysed e.g. in quantum theory  [16], control theory  [4, 8], and digital circuit theory [29].

It is intuitively clear how parametric lenses express aspects (I) and (II) above, whereas (III) will be achieved by studying them in a space of ‘differentiable objects’ (in a sense that will be made precise). The main technical contribution of our paper is showing how the various ingredients involved in learning (the model, the optimiser, the error map and the learning rate) can be uniformly understood as being built from parametric lenses.

Figure 2. The parametric lens that captures the learning process informally sketched in Figure 1. Note each component is a lens itself, whose composition yields the interactions described in Figure 1. Defining this picture formally will be the subject of Sections 3-4.

We will use category theory as the formal language to develop our notion of parametric lenses, and make Figure  2 mathematically precise. The categorical perspective brings several advantages, which are well-known, established principles in programming language semantics [58, 1, 47]. Three of them are particularly important to our contribution, as they constitute distinctive advantages of our semantic foundations:

$\mathbf{Abstraction}$:

Our approach studies which categorical structures are sufficient to perform gradient-based learning. This analysis abstracts away from the standard case of neural networks in several different ways: as we will see, it encompasses other models (namely Boolean circuits), different kinds of optimisers (including Adagrad, Adam, Nesterov momentum), and error maps (including quadratic and softmax cross entropy loss). These can be all understood as parametric lenses, and different forms of learning result from their interaction.

$\mathbf{Uniformity}$:

As seen in Figure 1, learning involves ingredients that are seemingly quite different: a model, an optimiser, a loss map, etc. We will show how all these notions may be seen as instances of the categorical definition of a parametric lens, thus yielding a remarkably uniform description of the learning process, and supporting our claim of parametric lenses being a fundamental semantic structure of learning.

$\mathbf{Compositionality}$:

The use of categorical structures to describe computation naturally enables compositional reasoning whereby complex systems are analysed in terms of smaller, and hence easier to understand, components. Compositionality is a fundamental tenet of programming language semantics; in the last few years, it has found application in the study of diverse kinds of computational models, across different fields— see e.g. [53, 28, 16, 8]. As made evident by Figure 2, our approach models a neural network as a parametric lens, resulting from the composition of simpler parametric lenses, capturing the different ingredients involved in the learning process. Moreover, as all the simpler parametric lenses are themselves composable, one may engineer a different learning process by simply plugging a new lens on the left or right of existing ones. This means that one can glue together smaller and relatively simple networks to create larger and more sophisticated neural networks.

We now give a synopsis of our contributions:

• In Section 2, we introduce the tools necessary to define our notion of parametric lens. First, in Section 2.1, we introduce a notion of parametric categories, which amounts to a functor $\mathbf{Para}(-)$ turning a category $\operatorname{\mathcal{C}}$ into one $\mathbf{Para}(\operatorname{\mathcal{C}})$ of ‘parametric $\operatorname{\mathcal{C}}$-maps’. Second, we recall lenses (Section 2.2). In a nutshell, a lens is a categorical morphism equipped with operations to view and update values in a certain data structure. Lenses play a prominent role in functional programming [56], as well as in the foundations of database theory [35] and more recently game theory [28]. Considering lenses in $\operatorname{\mathcal{C}}$ simply amounts to the application of a functorial construction $\mathbf{Lens}(-)$, yielding $\mathbf{Lens}(\operatorname{\mathcal{C}})$. Finally, we recall the notion of a cartesian reverse differential category (CRDC): a categorical structure axiomatising the notion of differentiation [15] (Section 2.4). We wrap up in Section 2.3, by combining these ingredients into the notion of parametric lens, formally defined as a morphism in $\mathbf{Para}(\mathbf{Lens}(\operatorname{\mathcal{C}}))$ for a CRDC $\operatorname{\mathcal{C}}$. In terms of our desiderata (I)-(III) above, note that $\mathbf{Para}(-)$ accounts for (I), $\mathbf{Lens}(-)$ accounts for (II), and the CRDC structure accounts for (III).

• As seen in Figure 1, in the learning process there are many components at work: the model, the optimiser, the loss map, the learning rate, etc.. In Section 3, we show how the notion of parametric lens provides a uniform characterisation for such components. Moreover, for each of them, we show how different variations appearing in the literature become instances of our abstract characterisation. The plan is as follows:

  • In Section 3.1, we show how the combinatorial model subject of the training can be seen as a parametric lens. The conditions we provide are met by the ‘standard’ case of neural networks, but also enables the study of learning for other classes of models. In particular, another instance are Boolean circuits: learning of these structures is relevant to binarisation [18] and it has been explored recently using a categorical approach [59], which turns out to be a particular case of our framework. We continue by describing internals of a model, and translating several exampls of models in deep learning to their categorical form. This includes linear layers, biases, activations, convolutional layers, but also general techniques such as weight tying and batching.

  • In Section 3.2, we show how the loss maps associated with training are also parametric lenses. Our approach covers the cases of quadratic error, Boolean error, Softmax cross entropy, but also the ‘dot product loss’ associated with the phenomenon of deep dreaming [40, 38, 22, 51].

  • In Section 3.3, we model the learning rate as a parametric lens. This analysis also allows us to contrast how learning rate is handled in the ‘real-valued’ case of neural networks with respect to the ‘Boolean-valued’ case of Boolean circuits.

  • In Section 3.4, we show how optimisers can be modelled as ‘reparameterisations’ of models as parametric lenses. As case studies, in addition to basic gradient ascent and descent, we consider the stateful variants: Momentum [44], Nesterov Momentum [57], Adagrad [23], and Adam (Adaptive Moment Estimation) [36], as well as optimiser composition (Subsection 3.4.1). Also, on Boolean circuits, we show how the reverse derivative ascent of [59] can be also regarded in such way.

• In Section 4, we study how the composition of the lenses defined in Section 3 yields a description of different kinds of learning processes.

  • Section 4.1 is dedicated to modelling supervised learning of parameters, in the way described in Figure 1. This amounts essentially to study of the composite of lenses expressed in Figure 2, for different choices of the various components. In particular we look at (i) quadratic loss with basic gradient descent, (ii) softmax cross entropy loss with basic gradient descent, (iii) quadratic loss with Nesterov momentum, and (iv) learning in Boolean circuits with XOR loss and basic gradient ascent.

  • In Section 4.2 we describe how a system traditionally considered as unsupervised can be recast to its supervised form: Generative Adversarial Networks ([30, 3]). We define this model abstractly as a parametric lens, and describe how a particular instantiation thereof — Wasserstein GAN ([3]) — arises as a supervised learning system with the dot product loss and the gradient descent-ascent optimiser.

  • In order to showcase the flexibility of our approach, in Section 4.3 we depart from our ‘core’ case study of parameter learning, and turn attention to supervised learning of inputs, also called deep dreaming — the idea behind this technique is that, instead of the network parameters, one updates the inputs, in order to elicit a particular interpretation [40, 38, 22, 51]. Deep dreaming can be easily expressed within our approach, with a different rearrangement of the parametric lenses involved in the learning process, see (11) below. The abstract viewpoint of categorical semantics provides a mathematically precise and visually captivating description of the differences between the usual parameter learning process and deep dreaming.

• In Section 5 we describe a proof-of-concept Python implementation, available at [19], based on the theory developed in this paper. This code is intended to show more concretely the payoff of our approach. Model architectures, as well as the various components participating in the learning process, are now expressed in a uniform, principled mathematical language, in terms of lenses. As a result, computing network gradients is greatly simplified, as it amounts to lens composition. Moreover, the modularity of this approach allows one to more easily tune the various parameters of training. We show our library via a number of experiments, and prove correctness by achieving accuracy on par with an equivalent model in Keras, a mainstream deep learning framework [12]. In particular, we create a working non-trivial neural network model for the MNIST image-classification problem [37].

• Finally, in Sections 6 and 7, we discuss related and future work.

Note this paper extends a previous conference version [20]. Section 3.1 has been extended with examples of different architectures and techniques in deep learning, while Section 4.2, which considers unsupervised learning, and Remark 2, followed by a discussion on the axioms of CRDCs needed in our framework, are new. Also, we included missing proofs and complementary background material (see in particular Appendices A-B).

2. Categorical Toolkit

In this section we describe the three categorical components of our framework, each corresponding to an aspect of gradient-based learning: (I) the $\mathbf{Para}$ construction (Section 2.1), which builds a category of parametric maps, (II) the $\mathbf{Lens}$ construction, which builds a category of “bidirectional” maps (Section 2.2), and (III) the combination of these two constructions into the notion of “parametric lenses” (Section 2.3). Finally (IV) we recall Cartesian reverse differential categories — categories equipped with an abstract gradient operator.

Notation

We shall use $f;g$ for sequential composition of morphisms $f\colon A\to B$ and $g\colon B\to C$ in a category, $1_{A}$ for the identity morphism on $A$, and $I$ for the unit object of a symmetric monoidal category.

2.1. Parametric Maps

In supervised learning one is typically interested in approximating a function $g:\operatorname{\mathbb{R}}^{n}\to\operatorname{\mathbb{R}}^{m}$ for some $n$ and $m$. To do this, one begins by building a neural network, which is a smooth map $f:\operatorname{\mathbb{R}}^{p}\times\operatorname{\mathbb{R}}^{n}\to\operatorname{\mathbb{R}}^{m}$ where $\operatorname{\mathbb{R}}^{p}$ is the set of possible weights of that neural network. Then one looks for a value of $q\in\operatorname{\mathbb{R}}^{p}$ such that the function $f(q,-):\operatorname{\mathbb{R}}^{n}\to\operatorname{\mathbb{R}}^{m}$ closely approximates $g$. We formalise these maps categorically via the $\mathbf{Para}$ construction [26, 27, 10, 34].

[Parametric category] Let $(\operatorname{\mathcal{C}},\otimes,I)$ be a strict symmetric monoidal category. We define a category $\mathbf{Para}(\operatorname{\mathcal{C}})$ with

• objects those of $\operatorname{\mathcal{C}}$;

• a map from $A$ to $B$ is a pair $(P,f)$, with $P$ an object of $\operatorname{\mathcal{C}}$ and $f:P\otimes A\to B$;

• the identity on $A$ is the pair $(I,1_{A})$ (since $\otimes$ is strict monoidal, $I\otimes A=A$);

• the composite of maps $(P,f):A\to B$ and $(P^{\prime},f^{\prime}):B\to C$ is the pair $(P^{\prime}\otimes P,(1_{P^{\prime}}\otimes f);f^{\prime})$;

Take the category $\mathbf{Smooth}$ whose objects are natural numbers and whose morphisms $f:n\to m$ are smooth maps from $\operatorname{\mathbb{R}}^{n}$ to $\operatorname{\mathbb{R}}^{m}$. This is a strict symmetric monoidal category with product given by addition. As described above, the category $\mathbf{Para}(\mathbf{Smooth})$ can be thought of as a category of neural networks: a map in this category from $n$ to $m$ consists of a choice of $p$ and a map $f:\operatorname{\mathbb{R}}^{p}\times\operatorname{\mathbb{R}}^{n}\to\operatorname{\mathbb{R}}^{m}$ with $\operatorname{\mathbb{R}}^{p}$ representing the set of possible weights of the neural network.

As we will see in the next sections, the interplay of the various components at work in the learning process becomes much clearer once represented the morphisms of $\mathbf{Para}(\operatorname{\mathcal{C}})$ using the pictorial formalism of string diagrams, which we now recall. In fact, we will mildly massage the traditional notation for string diagrams (below left), by representing a morphism $f\colon A\to B$ in $\mathbf{Para}(\operatorname{\mathcal{C}})$ as below right.

This is to emphasise the special role played by $P$, reflecting the fact that in machine learning data and parameters have different semantics. String diagrammatic notations also allows to neatly represent composition of maps $(P,f):A\to B$ and $(P^{\prime},f^{\prime}):B\to C$ (below left), and “reparameterisation” of $(P,f):A\to B$ by a map $\alpha:Q\to P$ (below right), yielding a new map $(Q,(\alpha\otimes 1_{A});f):A\to B$.

(2)

Intuitively, reparameterisation changes the parameter space of $(P,f):A\to B$ to some other object $Q$, via some map $\alpha:Q\to P$. We shall see later that gradient descent and its many variants can naturally be viewed as reparameterisations.

Note coherence rules in combining the two operations in (2) just work as expected, as these diagrams can be ultimately ‘compiled’ down to string diagrams for monoidal categories.

2.2. Lenses

In machine learning (or even learning in general) it is fundamental that information flows both forwards and backwards: the ‘forward’ flow corresponds to a model’s predictions, and the ‘backwards’ flow to corrections to the model. The category of lenses is the ideal setting to capture this type of structure, as it is a category consisting of maps with both a “forward” and a “backward” part.

For any Cartesian category $\operatorname{\mathcal{C}}$, the category of (bimorphic) lenses in $\operatorname{\mathcal{C}}$, $\mathbf{Lens}(\operatorname{\mathcal{C}})$, is the category with the following data:

• Objects are pairs $(A,A^{\prime})$ of objects in $\operatorname{\mathcal{C}}$, written as $\left({{A}\atop{A^{\prime}}}\right)$;

• A map from $\left({{A}\atop{A^{\prime}}}\right)$ to $\left({{B}\atop{B^{\prime}}}\right)$ consists of a pair $(f,f^{*})$ (also written as $\left({{f}\atop{f^{*}}}\right)$) where $f:A\to B$ (called the get or forward part of the lens) and $f^{*}:A\times B^{\prime}\to A^{\prime}$ (called the put or backwards part of the lens);

• The identity on $\left({{A}\atop{A^{\prime}}}\right)$ is the pair $\left({{1_{A}}\atop{\pi_{1}}}\right)$;

• The composite of $\left({{f}\atop{f^{*}}}\right):\left({{A}\atop{A^{\prime}}}\right)\to\left({{B}\atop{B^{\prime}}}\right)$ and $\left({{g}\atop{g^{*}}}\right):\left({{B}\atop{B^{\prime}}}\right)\to\left({{C}\atop{C^{\prime}}}\right)$ is given by get $f;g$ and put $\langle\pi_{0},\langle\pi_{0};f,\pi_{1}\rangle;g^{*}\rangle;f^{*}$.

The embedding of $\mathbf{Lens}(\operatorname{\mathcal{C}})$ into the category of Tambara modules over $\operatorname{\mathcal{C}}$ (see [7, Thm. 23]) provides a rich string diagrammatic language, in which lenses may be represented with forward/backward wires indicating the information flow. In this language, a morphism $\left({{f}\atop{f^{*}}}\right):\left({{A}\atop{A^{\prime}}}\right)\to\left({{B}\atop{B^{\prime}}}\right)$ is written as below left, which can be ‘expanded’ as below right.

It is clear in this language how to describe the composite of $\left({{f}\atop{f^{*}}}\right):\left({{A}\atop{A^{\prime}}}\right)\to\left({{B}\atop{B^{\prime}}}\right)$ and $\left({{g}\atop{g^{*}}}\right):\left({{B}\atop{B^{\prime}}}\right)\to\left({{C}\atop{C^{\prime}}}\right)$:

Remark 1.

Note $\mathbf{Lens}(\operatorname{\mathcal{C}})$ is a monoidal category, with $\left({{A}\atop{A^{\prime}}}\right)\otimes\left({{B}\atop{B^{\prime}}}\right)$ defined as $\left({{A\times B}\atop{A^{\prime}\times B^{\prime}}}\right)$. However, in general $\mathbf{Lens}(\operatorname{\mathcal{C}})$ is not itself Cartesian. This is easy to see when looking at even a terminal object: if $T$ is a terminal object in $\operatorname{\mathcal{C}}$, then in general $\left({{T}\atop{T}}\right)$ will not be a terminal object in $\mathbf{Lens}(\operatorname{\mathcal{C}})$ — it if was, there would be a unique lens $\left({{!_{A}}\atop{!_{A}^{*}}}\right):\left({{A}\atop{A^{\prime}}}\right)\to\left({{T}\atop{T}}\right)$ whose put part would need to be a (unique) map $A\times T\to A^{\prime}$, but in general there are many such maps.

2.3. Parametric Lenses

The fundamental category where supervised learning takes place is the composite $\mathbf{Para}(\mathbf{Lens}(\operatorname{\mathcal{C}}))$ of the two constructions in the previous sections: The category $\mathbf{Para}(\mathbf{Lens}(\operatorname{\mathcal{C}}))$ of parametric lenses on $\operatorname{\mathcal{C}}$ is defined as follows.

• Its objects are pairs of objects $\left({{A}\atop{A^{\prime}}}\right)$ of objects from $\operatorname{\mathcal{C}}$;

• A morphism from $\left({{A}\atop{A^{\prime}}}\right)$ to $\left({{B}\atop{B^{\prime}}}\right)$, called a parametric lens, is a choice of parameter pair $\left({{P}\atop{P^{\prime}}}\right)$ and a lens $\left({{f}\atop{f^{*}}}\right):\left({{P}\atop{P^{\prime}}}\right)\times\left({{A}\atop{A^{\prime}}}\right)\to\left({{B}\atop{B^{\prime}}}\right)$ where $f:P\times A\to B$ and $f^{*}:P\times A\times B^{\prime}\to P^{\prime}\times A^{\prime}$

String diagrams for parametric lenses are built by simply composing the graphical languages of the previous two sections — see (1), where respectively a morphism, a composition of morphisms, and a reparameterisation are depicted.

Given a generic morphism in $\mathbf{Para}(\mathbf{Lens}(\operatorname{\mathcal{C}}))$ as depicted in (1) on the left, one can see how it is possible to “learn” new values from $f$: it takes as input an input $A$, a parameter $P$, and a change $B^{\prime}$, and outputs a change in $A$, a value of $B$, and a change $P^{\prime}$. This last element is the key component for supervised learning: intuitively, it says how to change the parameter values to get the neural network closer to the true value of the desired function.

The question, then, is how one is to define such a parametric lens given nothing more than a neural network, ie., a parametric map $(P,f):A\to B$. This is precisely what the gradient operation provides, and its generalization to categories is explored in the next subsection.

2.4. Cartesian Reverse Differential Categories

Fundamental to all types of gradient-based learning is, of course, the gradient operation. In most cases this gradient operation is performed in the category of smooth maps between Euclidean spaces. However, recent work [59] has shown that gradient-based learning can also work well in other categories; for example, in a category of boolean circuits. Thus, to encompass these examples in a single framework, we will work in a category with an abstract gradient operation.

A Cartesian left additive category [15, Defn. 1] consists of a category $\operatorname{\mathcal{C}}$ with chosen finite products (including a terminal object), and an addition operation and zero morphism in each homset, satisfying various axioms. A Cartesian reverse differential category (CRDC) [15, Defn. 13] consists of a Cartesian left additive category $\operatorname{\mathcal{C}}$, together with an operation which provides, for each map $f:A\to B\mbox{ in }\operatorname{\mathcal{C}}$, a map $R[f]:A\times B\to A$ satisfying various axioms (see (Def. B)).

For $f:A\to B$, the pair $\left({{f}\atop{R[f]}}\right)$ forms a lens from $\left({{A}\atop{A}}\right)$ to $\left({{B}\atop{B}}\right)$. We will pursue the idea that $R[f]$ acts as backwards map, thus giving a means to “learn”$f$.

Note that assigning type $A\times B\to A$ to $R[f]$ hides some relevant information: $B$-values in the domain and $A$-values in the codomain of $R[f]$ do not play the same role as values of the same types in $f\colon A\to B$: in $R[f]$, they really take in a tangent vector at $B$ and output a tangent vector at $A$ (cf. the definition of $R[f]$ in $\mathbf{Smooth}$, Example 2.4 below). To emphasise this, we will type $R[f]$ as a map $A\times B^{\prime}\to A^{\prime}$ (even though in reality $A=A^{\prime}$ and $B=B^{\prime}$), thus meaning that $\left({{f}\atop{R[f]}}\right)$ is actually a lens from $\left({{A}\atop{A^{\prime}}}\right)$ to $\left({{B}\atop{B^{\prime}}}\right)$. This typing distinction will be helpful later on, when we want to add additional components to our learning algorithms.

The following two examples of CRDCs will serve as the basis for the learning scenarios of the upcoming sections.

The category $\mathbf{Smooth}$ (Example 2.1) is Cartesian with product given by addition, and it is also a Cartesian reverse differential category: given a smooth map $f:\mathbb{R}^{n}\to\mathbb{R}^{m}$, the map $R[f]\colon\mathbb{R}^{n}\times\mathbb{R}^{m}\to\mathbb{R}^{n}$ sends a pair $(x,v)$ to $J[f]^{T}(x)\cdot v$: the transpose of the Jacobian of $f$ at $x$ in the direction $v$. For example, if $f:\mathbb{R}^{2}\to\mathbb{R}^{3}$ is defined as $f(x_{1},x_{2}):=(x_{1}^{3}+2x_{1}x_{2},x_{2},\sin(x_{1}))$, then $R[f]:\mathbb{R}^{2}\times\mathbb{R}^{3}\to\mathbb{R}^{2}$ is given by

$$(x,v)\mapsto\begin{bmatrix}3x_{1}^{2}+2x_{2}&0&\cos(x_{1})\\ 2x_{1}&1&0\end{bmatrix}\cdot\begin{bmatrix}v_{1}\\ v_{2}\\ v_{3}\end{bmatrix}.$$

Using the reverse derivative (as opposed to the forward derivative) is well-known to be much more computationally efficient for functions $f:\mathbb{R}^{n}\to\mathbb{R}^{m}$ when $m\ll n$ (for example, see [31]), as is the case in most supervised learning situations (where often $m=1$).

Another CRDC is the symmetric monoidal category $\mathrm{POLY}_{\mathbb{Z}_{2}}$ [15, Example 14] with objects the natural numbers and morphisms $f\colon A\to B$ the $B$-tuples of polynomials $\mathbb{Z}_{2}[x_{1}\ldots x_{A}]$. When presented by generators and relations these morphisms can be viewed as a syntax for boolean circuits, with parametric lenses for such circuits (and their reverse derivative) described in [59].

Remark 2.

The definition of a CRDC (see Def. B) satisfies 7 axioms describing the interaction of the reverse differential operator with the rest of the cartesian left-additive structure. As pointed out in [14, Sec. 2.3], the last two axioms are independent of the others. In this paper we will additionally see that these two axioms are also not needed to compositionally model the update step of supervised learning.

The remark above can be stated abstractly in two steps. Firstly, we note that a CRDC $\operatorname{\mathcal{C}}$ for each morphism $f$ defines a lens $\left({{f}\atop{R[f]}}\right)$ whose backwards map is additive in the second component (see Def. B for the definition of additivity in the second component). This defines a subcategory $\mathbf{Lens}_{A}(\operatorname{\mathcal{C}})$ of $\mathbf{Lens}(\operatorname{\mathcal{C}})$, and the following functor. theoremLensFunctorCLAC Lenses with backward passes additive in the second component form a functor

$$\mathbf{Lens}_{A}:\mathbf{CLACat}\to\mathbf{CLACat}$$

Proof 2.1.

See Appendix. Definition B contains the definition of the category $\mathbf{CLACat}$, Definition 5 the definition of $\mathbf{Lens}_{A}(\operatorname{\mathcal{C}})$, Prop. 6 the proof that $\mathbf{Lens}_{A}(\operatorname{\mathcal{C}})$ is a cartesian left-additive category and Prop. 7 the action of $\mathbf{Lens}_{A}$ on morphisms.

The second step is the observation that a coalgebra of this functor gives us a choice of a cartesian left-additive category $\operatorname{\mathcal{C}}$ and a cartesian left-additive functor $\mathbf{R}_{\operatorname{\mathcal{C}}}:\operatorname{\mathcal{C}}\to\mathbf{Lens}_{A}(\operatorname{\mathcal{C}})$ such that a number of axioms are satisfied: precisely the first five axioms of a CRDC.

[(compare [15, Prop. 31])]propFiveOutOfSeven A coalgebra of the copointed $\mathbf{Lens}_{A}$ endofunctor gives rise to a cartesian left-additive category $\operatorname{\mathcal{C}}$ equipped with a reverse differential combinator $R$ which satisfies the first five axioms of a cartesian reverse derivative category.

Proof 2.2.

A coalgebra of $\mathbf{Lens}_{A}$ consists of a category $\operatorname{\mathcal{C}}$ and a cartesian left-additive functor $\mathbf{R}_{\operatorname{\mathcal{C}}}:\operatorname{\mathcal{C}}\to\mathbf{Lens}_{A}(\operatorname{\mathcal{C}})$ such that the following diagram commutes.

$$\begin{tikzcd}$$ (4)

The data of the functor $\mathbf{R}_{\operatorname{\mathcal{C}}}$ is equivalent to the data of a reverse differential combinator $R$: every map $f:A\to B$ in $\operatorname{\mathcal{C}}$ is mapped it to a lens whose forward part is by the Eq. 4 above restricted to be $f$ itself, leaving the only choice involved in this functor the one of the backward part. What remains to prove is that this backward part satisfies the first five axioms of a CRDC. We do this in Appendix B.

We will see in the next section how only the data of the functor $\mathbf{R}_{\operatorname{\mathcal{C}}}:\operatorname{\mathcal{C}}\to\mathbf{Lens}_{A}(\operatorname{\mathcal{C}})$ is used to model supervised learning, justifying our claim that only the first five axioms of a CRDC are used.

3. Components of learning as Parametric Lenses

As seen in the introduction, in the learning process there are many components at work: a model, an optimiser, a loss map, a learning rate, etc. In this section we show how each such component can be understood as a parametric lens. Moreover, for each component, we show how our framework encompasses several variations of the gradient-descent algorithms, thus offering a unifying perspective on many different approaches that appear in the literature.

3.1. Models as Parametric Lenses

We begin by characterising the models used for training as parametric lenses. In essence, our approach identifies a set of abstract requirements necessary to perform training by gradient descent, which covers the case studies that we will consider in the next sections.

The leading intuition is that a suitable model is a parametric map, equipped with a reverse derivative operator. Using the formal developments of Section 2, this amounts to assuming that a model is a morphism in $\mathbf{Para}(\operatorname{\mathcal{C}})$, for a CRDC $\operatorname{\mathcal{C}}$. In order to visualise such morphism as a parametric lens, it then suffices to apply under $\mathbf{Para}(-)$ the canonical morphism $\mathbf{R}_{\operatorname{\mathcal{C}}}\colon\operatorname{\mathcal{C}}\to\mathbf{Lens}(\operatorname{\mathcal{C}})$ (which exists for any CRDC $\operatorname{\mathcal{C}}$, see Prop. 2.1), mapping $f$ to $\left({{f}\atop{R[f]}}\right)$. This yields a functor $\mathbf{Para}(\mathbf{R}_{\operatorname{\mathcal{C}}}):\mathbf{Para}(\operatorname{\mathcal{C}})\to\mathbf{Para}(\mathbf{Lens}(\operatorname{\mathcal{C}}))$, pictorially defined as

$$\scalebox{0.7}{{ \begin{tikzpicture} }}\qquad\mapsto\qquad\scalebox{0.6}{{ \begin{tikzpicture} }}$$ (5)

[Neural networks] As noted previously, to learn a function of type $\operatorname{\mathbb{R}}^{n}\to\operatorname{\mathbb{R}}^{m}$, one constructs a neural network, which can be seen as a function of type $\operatorname{\mathbb{R}}^{p}\times\operatorname{\mathbb{R}}^{n}\to\operatorname{\mathbb{R}}^{m}$ where $\operatorname{\mathbb{R}}^{p}$ is the space of parameters of the neural network. As seen in Example 2.1, this is a map in the category $\mathbf{Para}(\mathbf{Smooth})$ of type $\operatorname{\mathbb{R}}^{n}\to\operatorname{\mathbb{R}}^{m}$ with parameter space $\operatorname{\mathbb{R}}^{p}$. Then one can apply the functor in (5) to present a neural network together with its reverse derivative operator as a parametric lens, i.e. a morphism in $\mathbf{Para}(\mathbf{Lens}(\mathbf{Smooth}))$.

[Boolean and Polynomial circuits] For learning of Boolean circuits as described in [59], the recipe is the same as in Example 3.1, except that the base category is $\mathrm{POLY}_{\mathbb{Z}_{2}}$ (see Example 2.4). The important observation here is that $\mathrm{POLY}_{\mathbb{Z}_{2}}$ is a CRDC, see [15, 59], and thus we can apply the functor in (5). Note this setting can be generalised to circuits over any polynomial ring, see [61].

Note a model/parametric lens $f$ takes as inputs an element of $A$, a parameter $P$, an element of $B^{\prime}$ (a change in $B$) and outputs an element of $B$, a change in $A$, and a change in $P$. This is not yet sufficient to do machine learning! When we perform learning, we want to input a parameter $P$ and a pair $A\times B$ and receive a new parameter $P$. Instead, $f$ expects a change in $B$ (not an element of $B$) and outputs a change in $P$ (not an element of $P$). Deep dreaming, on the other hand, wants to return an element of $A$ (not a change in $A$). Thus, to do machine learning (or deep dreaming) we need to add additional components to $f$; we will consider these additional components in the next sections.

We now proceed to describe the internals of a model, and translate several examples of models in deep learning to their categorical form. But before doing so, we clarify some terminology. While ‘layers’ and ‘models’ are both parametric maps, the former typically refers to components of larger models, while the latter refers to the final model to be learned in the manner described in Section 4.1).

Remark 3.

An unfortunate ambiguity in deep learning terminology is the second meaning of ‘layer’. For example, the ‘hidden layer’ of a model refers to internal values of a neural network, corresponding to the ‘wires’ of a string diagram. We will avoid using the term ‘layer’ in this sense unless explicitly noted.

In deep learning, one often speaks of ‘model architectures’. This can mean either a specific model (e.g., ResNet50 [32]) or a family of models employing a particular technique. For example, one says a model has a ‘convolutional architecture’ when it contains a convolutional layer (Example 3.1.1). Examples of layers, models, and architectures are given in the following sections.

3.1.1. Layers

The dense or fully-connected layer is a component of many neural network architectures. In the categorical viewpoint, a dense layer is the composition of linear, bias, and activation layers, which we describe first. Unless explicitly noted, we will assume for simplicity that most layers are maps in $\mathbf{Para}(\mathbf{Smooth})$. However, many of the maps defined here only require a multiplication map as additional structure, and so can be defined in any cartesian distributive category [60] such as $\mathrm{POLY}_{S}$.

[Linear layer] A linear or matrix-multiply layer is the parametric map $(\operatorname{\mathbb{R}}^{nm},\mathsf{linear}:\operatorname{\mathbb{R}}^{nm}\times\operatorname{\mathbb{R}}^{n}\to\operatorname{\mathbb{R}}^{m})$, where $\mathsf{linear}(M,x)=M\cdot x$ is the matrix-vector product of $M$ interpreted as matrix coefficients and the vector $x$.

Note that layers are best thought of as families of maps. For example, there is a linear layer morphism for all choices of dimension $m$ and $n$.

[Bias layer] A bias layer is a parametric map $(\operatorname{\mathbb{R}}^{n},+)$, where $+:\operatorname{\mathbb{R}}^{n}\times\operatorname{\mathbb{R}}^{n}\to\operatorname{\mathbb{R}}^{n}$ is the cartesian left-additive addition map. The reverse derivative of $+$ is the copy map, so we may depict the bias layer as a parametric lens as below.

$${\begin{tikzpicture}}$$

An activation layer $(I,\alpha:A^{n}\to A^{n})$ is a typically nonlinear, trivially parametric map often applied to the output of another layer. Many are simply the $n$-fold tensor product of a univariate function $A\to A$.

[Sigmoid Activation] The sigmoid activation layer $(I,\mathsf{sigmoid}:\operatorname{\mathbb{R}}^{n}\to\operatorname{\mathbb{R}}^{n})$ is the $n$-fold tensor product $\sigma\times\overset{n}{\ldots}\times\sigma$ of the sigmoid function $\sigma(x)=\frac{\exp(x)}{\exp(x)+1}$.

Note that unlike other layers considered so far, while sigmoid is a map in $\mathbf{Smooth}$, it is not a map in $\mathrm{POLY}_{S}$. An example of an activation layer which is not in $\mathbf{Smooth}$ is the ReLU map.

[ReLU Activation] The ‘Rectified Linear Unit’ activation function is the map $\mathsf{ReLU}(x)=\delta_{>0}(x)\cdot x$ where $\delta_{>0}$ is the positive indicator function. The $\mathsf{ReLU}$ activation layer $\mathsf{ReLU}:A^{n}\to A^{n}$ is again the $n$-fold tensor product of this function. Although ReLU is not a smooth map, some presentations of RDCs can be extended via Theorem 3.1 of [60] to include the positive indicator function $\delta_{>0}:A\to A$. The $\mathsf{ReLU}$ function can then be expressed in terms of this function, and its reverse derivative can be derived as $\mathsf{R}[\mathsf{ReLU}](x,\delta_{y})=\delta_{>0}(x)\cdot\delta_{y}$.

The combination of linear, bias, and choice of activation layer gives a dense or fully-connected layer.

[Dense Layer] A dense or fully-connected layer is the following composition.

Where some choice of input dimension $m\in\operatorname{\mathbb{N}}$, output dimension $m\in\operatorname{\mathbb{N}}$, and activation layer $\alpha:\operatorname{\mathbb{R}}^{m}\to\operatorname{\mathbb{R}}^{n}$ is assumed. Note that the activation layer has no parameters.

The final two examples of layers we cover here are convolutional and max-pooling layers, which are common in models for image-processing tasks.

[Convolutional Layer] A convolutional layer is a map $(\operatorname{\mathbb{R}}^{k^{2}},\mathsf{convolve2D}:\operatorname{\mathbb{R}}^{k^{2}}\times\operatorname{\mathbb{R}}^{m^{2}}\to\operatorname{\mathbb{R}}^{n^{2}})$ where $\mathsf{convolve2D}$ denotes the discrete 2D convolution of a $k\times k$ kernel and an $m\times m$ image. The output of a convolutional layer is an $n\times n$ image with $n=\max(m,k)-\min(m,k)+1$.

A number of further variations of the convolutional layer exist in the literature, but the basic idea is to use 2D convolution to map a kernel (the parameters) over the input. Convolutional layers are frequently composed with max-pooling layers.

[Max-Pooling Layer] A max-pooling layer $(I,\mathsf{maxpool}:S^{(kn)^{2}}\to S^{n})$ computes the maximum of each of the $n^{2}$ size-$k\times k$ subregions of the input image.

However, as with the $\mathsf{ReLU}$ layer, max-pooling layers cannot be thought of as maps in $\mathbf{Smooth}$. Nevertheless, by again appealing to [60, Theorem 3.1], one can extend a presentation of RDCs to include a function $\max:2\to 1$ from which the max-pooling layer and its reverse derivative can be derived.

3.1.2. Architectures

We now consider some examples of neural network architectures defined in terms of the layers above. Since both layers and architectures are just parametric maps, we can consider the layers by themselves as architectures already, and in fact the linear and dense layers are sufficient to solve some simple machine learning problems. The first non-trivial architecture we consider is the ‘single hidden layer’ network.

[Hidden Layer Network] A neural network with a single ‘hidden layer’ (in the sense of Remark 3) is the composition of two $\mathsf{dense}$ maps.

We emphasize that the term ‘hidden layer’ here ambiguously refers to the central wires labeled $\operatorname{\mathbb{R}}^{b}$ rather than the dense morphisms.

This architecture is demonstrated in detail in the experiments [19] accompanying this paper. Also included in our experiments is a convolutional model for classifying images of handwritten digits (the MNIST [37] dataset). A simplified version is below.

[Convolutional Architecture] First, define a $\mathsf{CPR}$ layer as the composition of a convolution, max-pooling, and $\mathsf{ReLU}$ layer.

$$CPR\>=\>\scalebox{0.8}{{ \begin{tikzpicture} }}$$

where $n=\max(m,k)-\min(m,k)+1$. One can then define a convolutional architecture for classifying $28\times 28$-pixel images of the MNIST dataset into digits $0-9$ as follows.

Lastly, we mention the architecture of Generative Adversarial Networks which e define and thoroughly discuss in Section 4.2.

3.1.3. Weight Tying and Batching

A number of general techniques are employed in designing deep learning models. We now describe two examples of these techniques in terms of their categorical interpretations. The first is weight-tying, which is required in Subsection 4.2 to define a more complex architecture for unsupervised learning: the GAN.

[Weight Tying] Weight tying is the sharing of parameters between two different components. Categorically speaking, this means using the copy map on parameters as below.

Note that $f$ and $g$ have the same parameters, but might be applied to different parts of the input. In this sense, one can think of convolutional layers (Example 3.1.1) as using weight-tying.

A related technique is batching. So far, we have considered learning as updating a model with a single data example $(x,y)$ at each timestep. However, it is common for efficiency purposes to update the model using a batch of examples: a finite number $n$ of examples $(x_{i},y_{i})$ for $i\in\{0\ldots n\}$.

[Batching] Suppose we have a model $(P,f:P\times A\to B)$. The batched model with batch size $n$ is a parametric map $(P,f^{\prime}:P\times A^{n}:B^{n})$ where $f^{\prime}$ consists of $n$ copies of $f$ applied to each input, but with the same parameters. For example, when $n=2$, the batch update is as follows.

The above diagrams highlight the relationship between weight-tying and batching. However, note that these techniques serve different purposes: while weight-tying can be used to reduce the number of weights in a model, batching is used for efficiency reasons to update a model with multiple examples in parallel.

3.2. Loss Maps as Parametric Lenses

Another key component of any learning algorithm is the choice of loss map. This gives a measurement of how far the current output of the model is from the desired output. In standard learning in $\mathbf{Smooth}$, this loss map is viewed as a map of type $B\times B\to\operatorname{\mathbb{R}}$. However, in our setup, this is naturally viewed as a parametric map from $B$ to $\operatorname{\mathbb{R}}$ with parameter space $B$. We also generalize the codomain to an arbitrary object $L$.

A loss map on $B$ consists of a parametric map $(B,\mbox{loss}):\mathbf{Para}(\operatorname{\mathcal{C}})(B,L)$ for some object $L$.

Note that we can precompose a loss map $(B,\mbox{loss})\colon B\to L$ with a neural network $(P,f):A\to B$ (below left), and apply the functor in (5) (with $\operatorname{\mathcal{C}}=\mathbf{Smooth}$) to obtain the parametric lens below right.

$$\begin{gathered}\scalebox{0.8}{{ \begin{tikzpicture} }}\quad\mapsto\quad\scalebox{0.8}{{ \begin{tikzpicture} }}\end{gathered}$$ (7)

This is getting closer to the parametric lens we want: it can now receive inputs of type $B$. However, this is at the cost of now needing an input to $L^{\prime}$; we consider how to handle this in the next section.

[Quadratic error] In $\mathbf{Smooth}$, the standard loss function on $\operatorname{\mathbb{R}}^{b}$ is quadratic error: it uses $L=\operatorname{\mathbb{R}}$ and has parametric map $e:\operatorname{\mathbb{R}}^{b}\times\operatorname{\mathbb{R}}^{b}\to\operatorname{\mathbb{R}}$ given by

$$e(b_{t},b_{p})=\frac{1}{2}\sum_{i=1}^{b}((b_{p})_{i}-(b_{t})_{i})^{2}$$

where we think of $b_{t}$ as the “true” value and $b_{p}$ the predicted value. This has reverse derivative $R[e]:\operatorname{\mathbb{R}}^{b}\times\operatorname{\mathbb{R}}^{b}\times\operatorname{\mathbb{R}}\to\operatorname{\mathbb{R}}^{b}\times\operatorname{\mathbb{R}}^{b}$ given by $R[e](b_{t},b_{p},\alpha)=\alpha\cdot(b_{p}-b_{t},b_{t}-b_{p})$ — note $\alpha$ suggests the idea of learning rate, which we will explore in Section 3.3.

[Boolean error] In $\mathrm{POLY}_{\mathbb{Z}_{2}}$, the loss function on $\mathbb{Z}^{b}$ which is implicitly used in [59] is a bit different: it uses $L=\mathbb{Z}^{b}$ and has parametric map $e:\mathbb{Z}^{b}\times\mathbb{Z}^{b}\to\mathbb{Z}^{b}$ given by

$$e(b_{t},b_{p})=b_{t}+b_{p}.$$

(Note that this is $+$ in $Z_{2}$; equivalently this is given by XOR.) Its reverse derivative is of type $R[e]:\mathbb{Z}^{b}\times\mathbb{Z}^{b}\times\mathbb{Z}^{b}\to\mathbb{Z}^{b}\times\mathbb{Z}^{b}$ given by $R[e](b_{t},b_{p},\alpha)=(\alpha,\alpha)$.

[Softmax cross entropy] The Softmax cross entropy loss is a $\operatorname{\mathbb{R}}^{b}$-parametric map $\operatorname{\mathbb{R}}^{b}\to\operatorname{\mathbb{R}}$ defined by

$$e(b_{t},b_{p})=\sum_{i=1}^{b}(b_{t})_{i}((b_{p})_{i}-\log(\mathrm{Softmax}(b_{p})_{i}))$$

where $\mathrm{Softmax}(b_{p})=\frac{\exp((b_{p})_{i})}{\sum_{j=1}^{b}\exp((b_{p})_{j})}$ is defined componentwise for each class $i$.

We note that, although $b_{t}$ needs to be a probability distribution, at the moment there is no need to ponder the question of interaction of probability distributions with the reverse derivative framework: one can simply consider $b_{t}$ as the image of some logits under the $\mathrm{Softmax}$ function.

[Dot product] In Deep Dreaming (Section 4.3) we often want to focus only on a particular element of the network output $\operatorname{\mathbb{R}}^{b}$. This is done by supplying a one-hot vector $b_{t}$ as the ground truth to the loss function $e(b_{t},b_{p})=b_{t}\cdot b_{p}$ which computes the dot product of two vectors. If the ground truth vector $y$ is a one-hot vector (active at the $i$-th element), then the dot product performs masking of all inputs except the $i$-th one. Note the reverse derivative $R[e]\colon\operatorname{\mathbb{R}}^{b}\times\operatorname{\mathbb{R}}^{b}\times\operatorname{\mathbb{R}}\to\operatorname{\mathbb{R}}^{b}\times\operatorname{\mathbb{R}}^{b}$ of the dot product is defined as $R[e](b_{t},b_{p},\alpha)=(\alpha\cdot b_{p},\alpha\cdot b_{t})$.

3.3. Learning Rates as Parametric Lenses

After models and loss maps, another ingredient of the learning process are learning rates, which we formalise as follows.

A learning rate $\alpha$ on $L$ consists of a lens from $\left({{L}\atop{L^{\prime}}}\right)$ to $\left({{1}\atop{1}}\right)$ where $1$ is a terminal object in $\operatorname{\mathcal{C}}$. Note that the get component of the learning rate lens must be the unique map to $1$, while the put component is a map $L\times 1\to L^{\prime}$; that is, simply a map $\alpha^{*}:L\to L^{\prime}$. Thus we can view $\alpha$ as a parametric lens from $\left({{L}\atop{L^{\prime}}}\right)\to\left({{1}\atop{1}}\right)$ (with trivial parameter space) and compose it in $\mathbf{Para}(\mathbf{Lens}(\operatorname{\mathcal{C}}))$ with a model and a loss map (cf. (7)) to get

In standard supervised learning in $\mathbf{Smooth}$, one fixes some $\epsilon>0$ as a learning rate, and this is used to define $\alpha$: $\alpha$ is simply constantly $-\epsilon$, ie., $\alpha(l)=-\epsilon$ for any $l\in L$.

In supervised learning in $\mathrm{POLY}_{\mathbb{Z}_{2}}$, the standard learning rate is quite different: for a given $L$ it is defined as the identity function, $\alpha(l)=l$.

Other learning rate morphisms are possible as well: for example, one could fix some $\epsilon>0$ and define a learning rate in $\mathbf{Smooth}$ by $\alpha(l)=-\epsilon\cdot l$. Such a choice would take into account how far away the network is from its desired goal and adjust the learning rate accordingly.

3.4. Optimisers as Reparameterisations

In this section we consider how to implement gradient descent, ascent, and other gradient updates into our framework. To this aim, note that the parametric lens $\left({{f}\atop{R[f]}}\right)$ representing our model (see (5)) outputs a $P^{\prime}$, which represents a change in the parameter space. Now, we would like to receive not just the requested change in the parameter, but the new parameter itself. This is precisely what gradient update accomplishes, when formalised as a lens. We start by describing gradient ascent and gradient descent.

[Gradient ascent] Let $\operatorname{\mathcal{C}}$ be a CRDC. Gradient ascent on $P:\operatorname{\mathcal{C}}$ is a lens

$$\left({{\text{id}_{P}}\atop{+_{P}}}\right):\left({{P}\atop{P}}\right)\to\left({{P}\atop{P^{\prime}}}\right)$$

where $+_{P}:P\times P^{\prime}\to P$ is the monoid structure of $P$.

Figure 3. Gradient Ascent

Intuitively, such a lens allows one to receive the requested change in parameter and implement that change by adding that value to the current parameter. By its type, we can now “plug” the gradient descent lens $G\colon\left({{P}\atop{P}}\right)\to\left({{P}\atop{P^{\prime}}}\right)$ above the model $\left({{f}\atop{R[f]}}\right)$ in (5) — formally, this is accomplished as a reparameterisation of the parametric morphism $\left({{f}\atop{R[f]}}\right)$, cf. Section 2.1. This gives us Figure 4 (left).

Figure 4. Model reparameterised by basic gradient descent (left) and a generic stateful optimiser (right).

[Gradient ascent in Smooth] In $\mathbf{Smooth}$, the gradient ascent reparameterisation will take the output from $P^{\prime}$ and add it to the current value of $P$ to get a new value of $P$.

[Gradient ascent in Boolean circuits] In the CRDC $\mathrm{POLY}_{\mathbb{Z}_{2}}$, the gradient ascent reparameterisation will again take the output from $P^{\prime}$ and add it to the current value of $P$ to get a new value of $P$; however, since $+$ in $\mathbb{Z}_{2}$ is the same as XOR, this can be also be seen as taking the XOR of the current parameter and the requested change; this is exactly how this algorithm is implemented in [59].

[Gradient descent] Let $\operatorname{\mathcal{C}}$ be a CRDC where every monoid is additionally a commutative group. Gradient descent on $P$ is a lens

$$\left({{\text{id}_{P}}\atop{-_{P}}}\right):\left({{P}\atop{P}}\right)\to\left({{P}\atop{P^{\prime}}}\right)$$

where $-_{P}:(p,p^{\prime})=p-p^{\prime}$.

Figure 5. Gradient Descent

In $\mathbf{Smooth}$ this instantiates to usual gradient descent. Gradient ascent in $\mathrm{POLY}_{\mathbb{Z}_{2}}$ is equal to gradient descent because $\mathsf{XOR}$ is its own inverse. Intuitively in $\mathrm{POLY}_{\mathbb{Z}_{2}}$ there is always only one direction we can move (other than staying still): it’s flipping the bit. Gradient descent and ascent are not usually seen as a lens — but they fit precisely into this picture that we are creating.

Other variants of gradient descent also fit naturally into this framework by allowing for additional input/output data with $P$. In particular, many of them keep track of the history of previous updates and use that to inform the next one. This is easy to model in our setup: instead of asking for a lens $\left({{P}\atop{P}}\right)\to\left({{P}\atop{P^{\prime}}}\right)$, we ask instead for a lens $\left({{S\times P}\atop{S\times P}}\right)\to\left({{P}\atop{P^{\prime}}}\right)$ where $S$ is some “state” object.

A stateful parameter update consists of a choice of object $S$ (the state object) and a lens $U:\left({{S\times P}\atop{S\times P}}\right)\to\left({{P}\atop{P^{\prime}}}\right)$.

Again, we view this optimiser as a reparameterisation which may be “plugged in” a model as in Figure  4 (right). Let us now consider how several well-known optimisers can be implemented in this way.

[Momentum] In the momentum variant of gradient descent, one keeps track of the previous change and uses this to inform how the current parameter should be changed. Thus, in this case, we set $S=P$, fix some $\gamma>0$, and define the momentum lens $\left({{U}\atop{U^{*}}}\right):\left({{P\times P}\atop{P\times P}}\right)\to\left({{P}\atop{P^{\prime}}}\right)$. by $U(s,p)=p$ and $U^{*}(s,p,p^{\prime})=(s^{\prime},p+s^{\prime})$, where $s^{\prime}=-\gamma s+p^{\prime}$. Note momentum recovers gradient descent when $\gamma=0$.

In both standard gradient descent and momentum, our lens representation has trivial get part. However, as soon as we move to more complicated variants, this is not anymore the case, as for instance in Nesterov momentum below.

[Nesterov momentum] In Nesterov momentum, one uses the momentum from previous updates to tweak the input parameter supplied to the network. We can precisely capture this by using a small variation of the lens in the previous example. Again, we set $S=P$, fix some $\gamma>0$, and define the Nesterov momentum lens $\left({{U}\atop{U^{*}}}\right):\left({{P\times P}\atop{P\times P}}\right)\to\left({{P}\atop{P^{\prime}}}\right)$ by $U(s,p)=p+\gamma s$ and $U^{*}$ as in the previous example.

[Adagrad] Given any fixed $\epsilon>0$ and $\delta\sim 10^{-7}$, Adagrad [23] is given by $S=P$, with the lens whose $\mathsf{get}$ part is $(g,p)\mapsto p$. The $\mathsf{put}$ is $(g,p,p^{\prime})\mapsto(g^{\prime},p+\frac{\epsilon}{\delta+\sqrt{g^{\prime}}}\odot p^{\prime})$ where $g^{\prime}=g+p^{\prime}\odot p^{\prime}$ and $\odot$ is the elementwise (Hadamard) product. Unlike with other optimization algorithms where the learning rate is the same for all parameters, Adagrad divides the learning rate of each individual parameter with the square root of the past accumulated gradients.

[Adam] Adaptive Moment Estimation (Adam) [36] is another method that computes adaptive learning rates for each parameter by storing exponentially decaying average of past gradients ($m$) and past squared gradients ($v$). For fixed $\beta_{1},\beta_{2}\in[0,1)$, $\epsilon>0$, and $\delta\sim 10^{-8}$, Adam is given by $S=P\times P$, with the lens whose $\mathsf{get}$ part is $(m,v,p)\mapsto p$ and whose $\mathsf{put}$ part is $\mathsf{put}{}(m,v,p,p^{\prime})=(\widehat{m}^{\prime},\widehat{v}^{\prime},p+\frac{\epsilon}{\delta+\sqrt{\widehat{v}^{\prime}}}\odot\widehat{m}^{\prime})$ where $m^{\prime}=\beta_{1}m+(1-\beta_{1})p^{\prime}$, $v^{\prime}=\beta_{2}v+(1-\beta_{2})p^{\prime 2}$, and $\widehat{m}^{\prime}=\frac{m^{\prime}}{1-\beta_{1}^{t}},\widehat{v}^{\prime}=\frac{v^{\prime}}{1-\beta_{2}^{t}}$.

Note that, so far, optimsers/reparameterisations have been added to the $P/P^{\prime}$ wires. In order to change the model’s parameters (Fig. 4). In Section 4.3 we will study them on the $A/A^{\prime}$ wires instead, giving deep dreaming.

3.4.1. Can we compose optimisers?

Even though not explicitly acknowledged in the literature, optimisers can be composed, and this composition plays an important role in settings where deep learning intersects with multivariable optimisation. In such settings we’re interested in their parallel composition, therefore giving a positive answer to the above question. Parallel composition of optimisers arises out of the fact that optimisers are lenses, and lenses are a monoidal category (Remark 1). In such settings we might have an optimiser of two variables which descends in one direction, and ascends in the other one, for instance.

[Gradient descent-ascent (GDA)] Given objects $P$ and $Q$, gradient descent-ascent on $P\times Q$ is a lens

$$\left({{P\times Q}\atop{\mathsf{gda}}}\right):\left({{P\times Q}\atop{P\times Q}}\right)\to\left({{P\times Q}\atop{P^{\prime}\times Q^{\prime}}}\right)$$

where $\mathsf{gda}(p,q,p^{\prime},q^{\prime})=(p-p^{\prime},q+q^{\prime})$.

In $\mathbf{Smooth}$ this gives an optimiser which descends on $P$ and ascents on $Q$. In $\mathrm{POLY}_{\mathbb{Z}_{2}}$ this map ends up computing the same update function on both parameter spaces: the one that just flips the underlying bit. This is something that ends up preventing us from modelling GANs in this setting (compare with Ex. 7 where both positive and negative polarity of the optimiser map is needed).

When it comes to optimisers of two parameters, gradient descent-ascent is a particular type of an optimiser that is a product of two optimisers. But not all optimisers can be factored in such a way, much like a general monoidal product doesn’t necessarily have to be cartesian. A good example of this is an optimiser on two parameters called competitive gradient descent ([46]). We don’t explicitly define or use it in this paper, instead inviting the reader to the aforementioned reference for more information.

4. Learning with Parametric Lenses

In the previous section we have seen how all the components of learning can be modeled as parametric lenses. We now study how all these components can be put together to form learning systems. We cover the most common examples of supervised learning, also discussing different kinds of layers, architectures, and techniques such as weight tying and batching. We also consider unsupervised learning, in the form of Generative Adversarial Networks. Finally, in addition to systems that learn parameters, we study systems that learn their inputs. This is a technique commonly known as deep dreaming, and we present it as a natural counterpart of supervised learning of parameters.

Before we describe these systems, it will be convenient to represent all the inputs and outputs of our parametric lenses as parameters. In (8), we see the $P/P^{\prime}$ and $B/B^{\prime}$ inputs and outputs as parameters; however, the $A/A^{\prime}$ wires are not. To view the $A/A^{\prime}$ inputs as parameters, we compose that system with the parametric lens $\eta$ we now define. The parametric lens $\eta$ has the type $\left({{1}\atop{1}}\right)\to\left({{A}\atop{A^{\prime}}}\right)$ with parameter space $\left({{A}\atop{A^{\prime}}}\right)$ defined by $(\mathsf{get}{}_{\eta}=1_{A},\mathsf{put}{}_{\eta}=\pi_{1})$ and can be depicted graphically as . Composing $\eta$ with the rest of the learning system in  (8) gives us the closed parametric lens

This composite is now a map in $\mathbf{Para}(\mathbf{Lens}(\operatorname{\mathcal{C}}))$ from $\left({{1}\atop{1}}\right)$ to $\left({{1}\atop{1}}\right)$; all its inputs and outputs are now vertical wires, ie., parameters. Unpacking it further, this is a lens of type $\left({{A\times P\times B}\atop{A^{\prime}\times P^{\prime}\times B^{\prime}}}\right)\to\left({{1}\atop{1}}\right)$ whose $\mathsf{get}{}$ map is the terminal map, and whose $\mathsf{put}{}$ map is of the type $A\times P\times B\to A^{\prime}\times P^{\prime}\times B^{\prime}$. It can be unpacked as the composite

$$\mathsf{put}{}(a,p,b_{t})=(a^{\prime},p^{\prime},b_{t}^{\prime})\qquad\texttt{ where }\quad\qquad b_{p} =f(p,a)$$

$$(b^{\prime}_{t},b^{\prime}_{p}) =R[\mathsf{loss}](b_{t},b_{p},\alpha(\mathsf{loss}(b_{t},b_{p})))$$

$$(p^{\prime},a^{\prime}) =R[f](p,a,b^{\prime}_{p})$$

In the next two sections we consider further additions to the image above which correspond to different types of supervised learning.

4.1. Supervised Learning of Parameters

The most common type of learning performed on (9) is supervised learning of parameters. This is done by reparameterising (cf. Section 2.1) the image in the following manner. The parameter ports are reparameterised by one of the (possibly stateful) optimisers described in the previous section, while the backward wires $A^{\prime}$ of inputs and $B^{\prime}$ of outputs are discarded. This finally yields the complete picture of a system which learns the parameters in a supervised manner:

$${{\begin{tikzpicture}}}$$

Fixing a particular optimiser $\left({{U}\atop{U^{*}}}\right):\left({{S\times P}\atop{S\times P}}\right)\to\left({{P}\atop{P^{\prime}}}\right)$ we again unpack the entire construction. This is a map in $\mathbf{Para}(\mathbf{Lens}(\operatorname{\mathcal{C}}))$ from $\left({{1}\atop{1}}\right)$ to $\left({{1}\atop{1}}\right)$ whose parameter space is $\left({{A\times S\times P\times B}\atop{S\times P}}\right)$. In other words, this is a lens of type $\left({{A\times S\times P\times B}\atop{S\times P}}\right)\to\left({{1}\atop{1}}\right)$ whose $\mathsf{get}{}$ component is the terminal map. Its $\mathsf{put}{}$ map has the type $A\times S\times P\times B\to S\times P$ and unpacks to $\mathsf{put}{}(a,s,p,b_{t})=U^{*}(s,p,p^{\prime})$, where

$$\mathsf{put}{}(a,s,p,b_{t})=U^{*}(s,p,p^{\prime})\qquad\texttt{ where }\quad\qquad\overline{p} =U(s,p)$$

$$b_{p} =f(\overline{p},a)$$

$$(b^{\prime}_{t},b^{\prime}_{p}) =R[\mathsf{loss}](b_{t},b_{p},\alpha(\mathsf{loss}(b_{t},b_{p})))$$

$$(p^{\prime},a^{\prime}) =R[f](\overline{p},a,b^{\prime}_{p})$$

While this formulation might seem daunting, we note that it just explicitly specifies the computation performed by a supervised learning system. The variable $\overline{p}$ represents the parameter supplied to the network by the stateful gradient update rule (in many cases this is equal to $p$); $b_{p}$ represents the prediction of the network (contrast this with $b_{t}$ which represents the ground truth from the dataset). Variables with a tick ${}^{\prime}$ represent changes: $b^{\prime}_{p}$ and $b^{\prime}_{t}$ are the changes on predictions and true values respectively, while $p^{\prime}$ and $a^{\prime}$ are changes on the parameters and inputs. Furthermore, this arises automatically out of the rule for lens composition (3); what we needed to specify is just the lenses themselves.

We justify and illustrate our approach on a series of case studies drawn from the literature. This presentation has the advantage of treating all these instances uniformly in terms of basic constructs, highlighting their similarities and differences. First, we fix some parametric map $(\operatorname{\mathbb{R}}^{p},f):\mathbf{Para}(\mathbf{Smooth})(\operatorname{\mathbb{R}}^{a},\operatorname{\mathbb{R}}^{b})$ in $\mathbf{Smooth}$ and the constant negative learning rate $\alpha:\operatorname{\mathbb{R}}$ (Example  3.3). We then vary the loss function and the gradient update, seeing how the $\mathsf{put}{}$ map above reduces to many of the known cases in the literature.

[Quadratic error, basic gradient descent] Fix the quadratic error (Example 3.2) as the loss map and basic gradient update (Example 4). Then the aforementioned $\mathsf{put}{}$ map simplifies. Since there is no state, its type reduces to $A\times P\times B\to P$, and we have $\mathsf{put}{}(a,p,b_{t})=p+p^{\prime}$, where $(p^{\prime},a^{\prime})=R[f](p,a,\alpha\cdot(f(p,a)-b_{t}))$.

Note that $\alpha$ here is simply a constant, and due to the linearity of the reverse derivative (Def  2.4), we can slide the $\alpha$ from the costate into the basic gradient update lens. Rewriting this update, and performing this sliding we obtain a closed form update step

$$\mathsf{put}{}(a,p,b_{t})=p+\alpha\cdot(R[f](p,a,f(p,a)-b_{t});\pi_{0})$$

where the negative descent component of gradient descent is here contained in the choice of the negative constant $\alpha$.

This example gives us a variety of regression algorithms solved iteratively by gradient descent: it embeds some parametric map $(\mathbb{R}^{p},f)\colon\mathbb{R}^{a}\to\mathbb{R}^{b}$ into the system which performs regression on input data - where $a$ denotes the input to the model and $b_{t}$ denotes the ground truth. If the corresponding $f$ is linear and $b=1$, we recover simple linear regression with gradient descent. If the codomain is multi-dimensional, i.e. we are predicting multiple scalars, then we recover multivariate linear regression. Likewise, we can model a multi-layer perceptron or even more complex neural network architectures performing supervised learning of parameters simply by changing the underlying parametric map.

[Softmax cross entropy, basic gradient descent] Fix Softmax cross entropy (Example 3.2) as the loss map and basic gradient update (Example 4). Again the $\mathsf{put}{}$ map simplifies. The type reduces to $A\times P\times B\to P$ and we have

$$\mathsf{put}{}(a,p,b_{t})=p+p^{\prime}$$

where $(p^{\prime},a^{\prime})=R[f](\overline{p},a,\alpha\cdot(\mathrm{Softmax}(f(p,a))-b_{t}))$. The same rewriting performed on the previous example can be done here.

This example recovers logistic regression, e.g. classification.

[Mean squared error, Nesterov Momentum] Fix the quadratic error (Example 3.2) as the loss map and Nesterov momentum (Example 5) as the gradient update. This time the $\mathsf{put}{}$ map $A\times S\times P\times B\to S\times P$ does not have a simplified type. The implementation of $\mathsf{put}{}$ reduces to

$$\mathsf{put}{}(a,s,p,b_{t})=(s^{\prime},p+s^{\prime})\qquad\texttt{ where }\quad\qquad\overline{p} =p+\gamma s$$

$$(p^{\prime},a^{\prime}) =R[f](\overline{p},a,\alpha\cdot(f(\overline{p},a)-b_{t}))$$

$$s^{\prime} =-\gamma s+p^{\prime}$$

This example with Nesterov momentum differs in two key points from all the other ones: i) the optimiser is stateful, and ii) its $\mathsf{get}{}$ map is not trivial. While many other optimisers are stateful, the non-triviality of the $\mathsf{get}{}$ map here showcases the importance of lenses. They allow us to make precise the notion of computing a “lookahead” value for Nesterov momentum, something that is in practice usually handled in ad-hoc ways. Here, the algebra of lens composition handles this case naturally by using the $\mathsf{get}{}$ map, a seemingly trivial, unused piece of data for previous optimisers.

Our last example, using a different base category $\mathrm{POLY}_{\mathbb{Z}_{2}}$, shows that our framework captures learning in not just continuous, but discrete settings too. Again, we fix a parametric map $(\operatorname{\mathbb{Z}}^{p},f):\mathrm{POLY}_{\mathbb{Z}_{2}}(\operatorname{\mathbb{Z}}^{a},\operatorname{\mathbb{Z}}^{b})$ but this time we fix the identity learning rate (Example 3.3), instead of a constant one.

[Basic learning in Boolean circuits] Fix XOR as the loss map (Example 3.2) and the basic gradient update (Example 4). The put map again simplifies. The type reduces to $A\times P\times B\to P$ and the implementation to $\mathsf{put}{}(a,p,b_{t})=p+p^{\prime}$ where $(p^{\prime},a^{\prime})=R[f](p,a,f(p,a)+b_{t})$.

A sketch of learning iteration. Having described a number of examples in supervised learning, we outline how to model learning iteration in our framework. Recall the aforementioned $\mathsf{put}$ map whose type is $A\times P\times B\to P$ (for simplicity here modelled without state $S$). This map takes an input-output pair $(a_{0},b_{0})$, the current parameter $p_{i}$ and produces an updated parameter $p_{i+1}$. At the next time step, it takes a potentially different input-output pair $(a_{1},b_{1})$, the updated parameter $p_{i+1}$ and produces $p_{i+2}$. This process is then repeated. We can model this iteration as a composition of the $\mathsf{put}{}$ map with itself, as a composite $(A\times\mathsf{put}{}\times B);\mathsf{put}{}$ whose type is $A\times A\times P\times B\times B\to P$. This map takes two input-output pairs $A\times B$, a parameter and produces a new parameter by processing these datapoints in sequence. One can see how this process can be iterated any number of times, and even represented as a string diagram.

But we note that with a slight reformulation of the $\mathsf{put}$ map, it is possible to obtain a conceptually much simpler definition. The key insight lies in seeing that the map $\mathsf{put}{}:A\times P\times B\to P$ is essentially an endo-map $P\to P$ with some extra inputs $A\times B$; it’s a parametric map!

In other words, we can recast the $\mathsf{put}{}$ map as a parametric map $(A\times B,\mathsf{put}{}):\mathbf{Para}(\operatorname{\mathcal{C}})(P,P)$. Being an endo-map, it can be composed with itself. The resulting composite is an endo-map taking two “parameters”: input-output pair at the time step $0$ and time step $1$. This process can then be repeated, with $\mathbf{Para}$ composition automatically taking care of the algebra of iteration.

This reformulation captures the essence of parameter iteration: one can think of it as a trajectory $p_{i},p_{i+1},p_{i+2},...$ through the parameter space; but it is a trajectory parameterised by the dataset. With different datasets the algorithm will take a different path through this space and learn different things.

4.2. Unsupervised Learning

Many kinds of systems that are traditionally considered unsupervised can be recast to their supervised form. One example is a Generative Adversarial Network ([30, 3]). This is a neural network architecture that lies in the centre of the intersection of deep learning and game theory. It is a system of two neural networks trained with “competing” optimisers. One neural network is called the generator whose optimiser is, as usual, tasked with moving in the direction of the negative gradient of the loss. However, the other network — called the discriminator — has an optimiser which is tasked with moving in the positive, i.e. ascending direction of the gradient of the total loss — maximising the loss. The actual networks are wired in such a way (Fig. 6) where the discriminator effectively serves as a loss function to the generator, i.e. being the generator’s only source of information on how to update. Dually, taking the vantage point of the discriminator, the generator serves as an ever changing source of training data.

[GAN] Fix three objects $Z,X$ and $L$ in $\operatorname{\mathcal{C}}$ (respectively called “the latent space”, “the data space” and “the payoff space”). Then given two parametric morphisms

$$(P,g):\mathbf{Para}(\operatorname{\mathcal{C}})(Z,X)\quad\text{and}\quad(Q,d):\mathbf{Para}(\operatorname{\mathcal{C}})(X,L)$$

a generative adversarial network is a morphism $(P\times Q,\mathsf{GAN}_{g,d}):\mathbf{Para}(\operatorname{\mathcal{C}})(Z\times X,L\times L)$ where $\mathsf{GAN}_{g,d}$ is defined as the composite

$$Z\times X\times P\times Q\cong Z\times P\times X\times Q\xrightarrow{g\times X\times\Delta_{Q}}X\times X\times Q\times Q\cong X\times Q\times X\times Q\xrightarrow{d\times d}L\times L$$

Figure 6. A generative adversarial network as a parametric morphism.

Its string diagram representation is shown in Fig. 6 where we see that a GAN consists of two parallel tracks. We will see in Ex. 7 how the first one will be used to process latent vectors, and the second one to process samples from a chosen dataset. Despite the fact that there are two boxes labeled $d$, they are weight tied, making them behave like a singular unit.

We can easily state what the reverse derivative of $\mathsf{GAN}_{g,d}$ is in terms of its components:

$$\begin{split}R[\mathsf{GAN}_{g,d}](z,x_{r},p,q,\alpha_{g},\alpha_{r})=(z^{\prime},x_{r}^{\prime},p^{\prime},q_{g}^{\prime}+q_{r}^{\prime})\quad\text{where}\quad(x_{g}^{\prime},q_{g}^{\prime})&=R[d](g(z,p),q,\alpha_{g})\\ (x_{r}^{\prime},q_{r}^{\prime})&=R[d](x_{r},q,\alpha_{r})\\ (z^{\prime},p^{\prime})&=R[g](z,p,x_{g}^{\prime})\end{split}$$ (10)

The pair $(\mathsf{GAN}_{g,d},R[\mathsf{GAN}_{g,d}])$ yields a parametric lens of type $(Z\times X)(Z^{\prime}\times X^{\prime})\to(L\times L)(L^{\prime}\times L^{\prime})$ (Fig. 7), which we interpret as follows.

It consumes two pieces of data, “a latent vector” $z:Z$, a “real” sample from the dataset $x_{r}:X$, in addition to the parameter $p:P$ for the generator and a parameter $q:Q$ for the discriminator. What happens then are two independent evaluations done by the discriminator. The first one uses the generator’s attempt of producing a sample from the dataset (the latent vector which was fed into it, producing $g(z,p):X$) as input to the discriminator, producing a payoff $d((g,z,p),q):L$ for this particular sample. The second one uses the actual sample from the dataset $x_{r}$, producing the payoff $d(x_{r},q):L$.

By choosing $\mathsf{GAN}_{g,d}$ as the parametric map representing our supervised learning model, we can differentiate it as in (Fig. 7), and, with the appropriate choice of a loss function, produce the learning system in the literature called Wasserstein GAN ([3]).

Figure 7. A generative adversarial network under the image of $\mathbf{Para}(\mathbf{R}_{\operatorname{\mathcal{C}}})$.

[GANs, Dot product, GDA] Fix $\mathsf{GAN}_{g,d}$ as the parametric map (Def. 4.2), gradient descent-ascent (Ex. 3.4.1) as the optimiser and dot product (Ex. 3.2) as the loss function. Then $\mathsf{put}{}$ becomes a map of type $Z\times X\times P\times Q\times L\times L\to P\times Q$ and its implementation reduces to

$$\mathsf{put}{}(z,x,p,q,b_{t})=(p-p^{\prime},q+q^{\prime})\qquad\text{where}\quad\qquad(z^{\prime},x^{\prime},p^{\prime},q^{\prime}) =R[\mathsf{GAN}_{g,d}](z,x,p,q,\alpha\cdot b_{t})$$

We can further unpack the label

$$\mathsf{put}{}(z,x_{r},p,q,{b_{t}}_{g},{b_{t}}_{r})=(p-p^{\prime},q+q_{g}^{\prime}+q_{r}^{\prime})\qquad\text{where}\quad\qquad(x_{g}^{\prime},q_{g}^{\prime}) =R[d](g(z,p),q,\alpha\cdot{b_{t}}_{g})$$

$$(z^{\prime},p^{\prime}) =R[g](z,p,x_{g}^{\prime})$$

$$(x_{r}^{\prime},q_{r}^{\prime}) =R[d](x_{r},q,\alpha\cdot{b_{t}}_{r})$$

This brings us to the last step, where by linearity of the backward pass we can extract $\alpha$ and components of $b_{t}$ out:

$$\mathsf{put}{}(z,x_{r},p,q,{b_{t}}_{g},{b_{t}}_{r})=(p-\alpha{b_{t}}_{g}p^{\prime},q+\alpha({b_{t}}_{g}q_{g}^{\prime}+{b_{t}}_{r}q_{r}^{\prime}))\qquad\text{where}\quad(x_{g}^{\prime},q_{g}^{\prime}) =R[d](g(z,p),q,1)$$

$$(z^{\prime},p^{\prime}) =R[g](z,p,x_{g}^{\prime})$$

$$(x_{r}^{\prime},q_{r}^{\prime}) =R[d](x_{r},q,1)$$

The ultimate representation is a form in which it makes it possible to see how the update recovers that of Wasserstein GANs. The last missing piece is to note that the supervision labels $y_{t}$ here are effectively “masks”. Just like in standard supervised learning an input-output pair $(x_{i},y_{i})$ consisted of an input value and a corresponding label which guided the direction in which the output $f(x_{i},p)$ should’ve been improved, here the situation is the same. Given any latent vector $z$ its corresponding “label” is the learning signal ${b_{t}}_{g}=1$ which does not change anything in the update, effectively signaling to the generator’s and discriminator’s optimisers that they should descend (minimizing the assigned loss, making the image more realistic next time), and respectively ascend (maximizing the loss, becoming better at detecting when its input is a sample generated by the generator). On the other hand, given any real sample $x_{r}$ its corresponding “label” is the learning signal ${b_{t}}_{r}=-1$ which signals to the discriminator’s optimiser that it should do the opposite of what it usually does; it should descend, causing it to assign a lower loss value actual samples from the dataset. In other words, the input-output pairs here are always of the form $((z,x)_{i},(1,-1)_{i})$, making this GAN in many ways a constantly supervised model. Nonetheless, these different “forces” that pull the discriminator in different directions depending on the source of the input, coupled with the ever-changing generated inputs make GANs have intrinsically complex dynamics that are still being studied.

The fact that we were able to encode Wasserstein GAN in this form in our framework is a consequence of its simple formulation of its loss function, which is effectively given by subtraction [3, Theorem 3].

4.3. Deep Dreaming: Supervised Learning of Inputs

We have seen that reparameterising the parameter port with gradient descent allows us to capture supervised parameter learning. In this section we describe how reparameterising the input port provides us with a way to enhance an input image to elicit a particular interpretation. This is the idea behind the technique called Deep Dreaming, appearing in the literature in many forms [40, 38, 22, 51].

$${{\begin{tikzpicture}}}$$ (11)

Deep dreaming is a technique which uses the parameters $p$ of some trained classifier network to iteratively dream up, or amplify some features of a class $b$ on a chosen input $a$. For example, if we start with an image of a landscape $a_{0}$, a label $b$ of a “cat” and a parameter $p$ of a sufficiently well-trained classifier, we can start performing “learning” as usual: computing the predicted class for the landscape $a_{0}$ for the network with parameters $p$, and then computing the distance between the prediction and our label of a cat $b$. When performing backpropagation, the respective changes computed for each layer tell us how the activations of that layer should have been changed to be more “cat” like. This includes the first (input) layer of the landscape $a_{0}$. Usually, we discard this changes and apply gradient update to the parameters. In deep dreaming we discard the parameters and apply gradient update to the input (see (11)). Gradient update here takes these changes and computes a new image $a_{1}$ which is the same image of the landscape, but changed slightly so to look more like whatever the network thinks a cat looks like. This is the essence of deep dreaming, where iteration of this process allows networks to dream up features and shapes on a particular chosen image [39].

Just like in the previous subsection, we can write this deep dreaming system as a map in $\mathbf{Para}(\mathbf{Lens}(\operatorname{\mathcal{C}}))$ from $\left({{1}\atop{1}}\right)$ to $\left({{1}\atop{1}}\right)$ whose parameter space is $\left({{S\times A\times P\times B}\atop{S\times A}}\right)$. In other words, this is a lens of type $\left({{S\times A\times P\times B}\atop{S\times A}}\right)\to\left({{1}\atop{1}}\right)$ whose $\mathsf{get}{}$ map is trivial. Its $\mathsf{put}{}$ map has the type $S\times A\times P\times B\to S\times A$ and unpacks to

$$\mathsf{put}{}(s,a,p,b_{t})=U^{*}(s,a,a^{\prime})\qquad\texttt{ where}\quad\qquad\overline{a} =U(s,a)$$

$$b_{p} =f(p,\overline{a})$$

$$(b^{\prime}_{t},b^{\prime}_{p}) =R[\mathsf{loss}](b_{t},b_{p},\alpha(\mathsf{loss}(b_{t},b_{p})))$$

$$(p^{\prime},a^{\prime}) =R[f](p,\overline{a},b^{\prime}_{p})$$

We note that deep dreaming is usually presented without any loss function as a maximisation of a particular activation in the last layer of the network output [51, Section 2.]. This maximisation is done with gradient ascent, as opposed to gradient descent. However, this is just a special case of our framework where the loss function is the dot product (Example 3.2). The choice of the particular activation is encoded as a one-hot vector, and the loss function in that case essentially masks the network output, leaving active only the particular chosen activation. The final component is the gradient ascent: this is simply recovered by choosing a positive, instead of a negative learning rate [51]. We explicitly unpack this in the following example.

[Deep dreaming, dot product loss, basic gradient update] Fix $\mathbf{Smooth}$ as base category, a parametric map $(\operatorname{\mathbb{R}}^{p},f):\mathbf{Para}(\mathbf{Smooth})(\operatorname{\mathbb{R}}^{a},\operatorname{\mathbb{R}}^{b})$, the dot product loss (Example 3.2), basic gradient update (Example 4), and a positive learning rate $\alpha:\operatorname{\mathbb{R}}$. Then the above put map simplifies. Since there is no state, its type reduces to $A\times P\times B\to A$ and its implementation to

$$\mathsf{put}{}(a,p,b_{t})=a+a^{\prime} \qquad\qquad\qquad\qquad\texttt{ where }(p^{\prime},a^{\prime})=R[f](p,a,\alpha\cdot b_{t}).$$

Like in Example 4.1, this update can be rewritten as

$$\mathsf{put}{}(a,p,b_{t})=a+\alpha\cdot(R[f](p,a,b_{t});\pi_{1})$$

making a few things apparent. This update does not depend on the prediction $f(p,a)$: no matter what the network has predicted, the goal is always to maximise particular activations. Which activations? The ones chosen by $b_{t}$. When $b_{t}$ is a one-hot vector, this picks out the activation of just one class to maximise, which is often done in practice.

While we present only the most basic image, there is plenty of room left for exploration. The work of [51, Section 2.] adds an extra regularisation term to the image. In general, the neural network $f$ is sometimes changed to copy a number of internal activations which are then exposed on the output layer. Maximising all these activations often produces more visually appealing results. In the literature we did not find an example which uses the Softmax-cross entropy (Example 3.2) as a loss function in deep dreaming, which seems like the more natural choice in this setting. Furthermore, while deep dreaming commonly uses basic gradient descent, there is nothing preventing the use of any of the optimiser lenses discussed in the previous section, or even doing deep dreaming in the context of Boolean circuits. Lastly, learning iteration which was described in at the end of previous subsection can be modelled here in an analogous way.

5. Implementation

We provide a proof-of-concept implementation as a Python library — full usage examples, source code, and experiments can be found at [19]. We demonstrate the correctness of our library empirically using a number of experiments implemented both in our library and in Keras [12], a popular framework for deep learning. For example, one experiment is a model for the MNIST image classification problem [37]: we implement the same model in both frameworks and achieve comparable accuracy. Note that despite similarities between the user interfaces of our library and of Keras, a model in our framework is constructed as a composition of parametric lenses. This is fundamentally different to the approach taken by Keras and other existing libraries, and highlights how our proposed algebraic structures naturally guide programming practice

In summary, our implementation demonstrates the advantages of our approach. Firstly, computing the gradients of the network is greatly simplified through the use of lens composition. Secondly, model architectures can be expressed in a principled, mathematical language; as morphisms of a monoidal category. Finally, the modularity of our approach makes it easy to see how various aspects of training can be modified: for example, one can define a new optimization algorithm simply by defining an appropriate lens. We now give a brief sketch of our implementation.

5.1. Constructing a Model with Lens and Para

We model a lens $\left({{f}\atop{f^{*}}}\right)$ in our library with the Lens class, which consists of a pair of maps fwd and rev corresponding to $f$ and $f^{*}$, respectively. For example, we write the identity lens $\left({{1_{A}}\atop{\pi_{2}}}\right)$ as follows:

⬇

identity = Lens(lambda x: x, lambda x_dy: x_dy[1])

The composition (in diagrammatic order) of Lens values f and g is written f >> g, and monoidal composition as f @ g. Similarly, the type of $\mathbf{Para}$ maps is modeled by the Para class, with composition and monoidal product written the same way. Our library provides several primitive Lens and Para values.

Let us now see how to construct a single layer neural network from the composition of such primitives. Diagrammatically, we will construct a model consisting of a single dense layer, as in Example 3.1.1 and below.

Recall that the parameters of linear are the coefficients of a $b\times a$ matrix, and the underlying lens has as its forward map the function $(M,x)\to M\cdot x$, where $M$ is the $b\times a$ matrix whose coefficients are the $\operatorname{\mathbb{R}}^{b\times a}$ parameters, and $x\in\operatorname{\mathbb{R}}^{a}$ is the input vector. The bias map is even simpler: the forward map of the underlying lens is simply pointwise addition of inputs and parameters: $(b,x)\to b+x$. Finally, the activation map simply applies a nonlinear function (e.g., sigmoid) to the input, and thus has the trivial (unit) parameter space. The representation of this composition in code is straightforward: we can simply compose the three primitive Para maps as in (6):

⬇

def dense(a, b, activation):

  return linear(a, b) >> bias(b) >> activation

Note that by constructing model architectures in this way, the computation of reverse derivatives is greatly simplified: we obtain the reverse derivative ‘for free’ as the $\mathsf{put}$ map of the model. Furthermore, adding new primitives is also simplified: the user need simply provide a function and its reverse derivative in the form of a Para map. Finally, notice also that our approach is truly compositional: we can define a hidden layer neural network with $n$ hidden units simply by composing two dense layers, as follows:

⬇

dense(a, n, activation) >> dense(n, b, activation)

5.2. Learning

Now that we have constructed a model, we also need to use it to learn from data. Concretely, we will construct a full parametric lens as in Figure  2 then extract its $\mathsf{put}$ map to iterate over the dataset.

By way of example, let us see how to construct the following parametric lens, representing basic gradient descent over a single layer neural network with a fixed learning rate:

This morphism is constructed essentially as below, where apply_update($\alpha$, $f$) represents the ‘vertical stacking’ of $\alpha$ atop $f$:

⬇

apply_update(basic_update, dense) >> loss >> learning_rate($\epsilon$)

Now, given the parametric lens of (12), one can construct a morphism $\textsf{step}:B\times P\times A\to P$ which is simply the put map of the lens. Training the model then consists of iterating the step function over dataset examples $(x,y)\in A\times B$ to optimise some initial choice of parameters $\theta_{0}\in P$, by letting $\theta_{i+1}=\mathsf{step}(y_{i},\theta_{i},x_{i})$.

Note that our library also provides a utility function to construct $\mathsf{step}$ from its various pieces:

⬇

step = supervised_step(model, update, loss, learning_rate)

For an end-to-end example of model training and iteration, we refer the interested reader to the experiments accompanying the code [19].

6. Related Work

The work [26] is closely related to ours, in that it provides an abstract categorical model of backpropagation. However, it differs in a number of key aspects. We give a complete lens-theoretic explanation of what is back-propagated via (i) the use of CRDCs to model gradients; and (ii) the $\mathbf{Para}$ construction to model parametric functions and parameter update. We thus can go well beyond [26] in terms of examples - their example of smooth functions and basic gradient descent is covered in our subsection 4.1.

We also explain some of the constructions of [26] in a more structured way. For example, rather than considering the category $\mathbf{Learn}$ of [26] as primitive, here we construct it as a composite of two more basic constructions (the $\mathbf{Para}$ and $\mathbf{Lens}$ constructions). The flexibility could be used, for example, to compositionally replace $\mathbf{Para}$ with a variant allowing parameters to come from a different category, or lenses with the category of optics [45] enabling us to model things such as control flow using prisms.

One more relevant aspect is functoriality. We use a functor to augment a parametric map with its backward pass, just like [26]. However, they additionally augmented this map with a loss map and gradient descent using a functor as well. This added extra conditions on the partial derivatives of the loss function: it needed to be invertible in the 2nd variable. This constraint was not justified in [26], nor is it a constraint that appears in machine learning practice. This led us to reexamine their constructions, coming up with our reformulation that does not require it. While loss maps and optimisers are mentioned in [26] as parts of the aforementioned functor, here they are extracted out and play a key role: loss maps are parametric lenses and optimisers are reparameterisations. Thus, in this paper we instead use $\mathbf{Para}$-composition to add the loss map to the model, and $\mathbf{Para}$ 2-cells to add optimisers. The mentioned inverse of the partial derivative of the loss map in the 2${}^{nd}$ variable was also hypothesised to be relevant to deep dreaming. We have investigated this possibility thoroughly in our paper, showing it is gradient update which is used to dream up pictures. We also correct a small issue in Theorem III.2 of [26]. There, the morphisms of $\mathbf{Learn}$ were defined up to an equivalence (pg. 4 of [26]) but, unfortunately, the functor defined in Theorem III.2 does not respect this equivalence relation. Our approach instead uses 2-cells which comes from the universal property of $\mathbf{Para}$ — a 2-cell from $(P,f):A\to B$ to $(Q,g):A\to B$ is a lens, and hence has two components: a map $\alpha:Q\to P$ and $\alpha^{*}:Q\times P\to Q$. By comparison, we can see the equivalence relation of [26] as being induced by map $\alpha:Q\to P$, and not a lens. Our approach highlights the importance of the 2-categorical structure of learners. In addition, it does not treat the functor $\mathbf{Para}(\operatorname{\mathcal{C}})\to\mathbf{Learn}$ as a primitive. In our case, this functor has the type $\mathbf{Para}(\operatorname{\mathcal{C}})\to\mathbf{Para}(\mathbf{Lens}(\operatorname{\mathcal{C}}))$ and arises from applying $\mathbf{Para}$ to a canonical functor $\operatorname{\mathcal{C}}\to\mathbf{Lens}(\operatorname{\mathcal{C}})$ existing for any reverse derivative category, not just $\mathbf{Smooth}$. Lastly, in our paper we took advantage of the graphical calculus for $\mathbf{Para}$, redrawing many diagrams appearing in [26] in a structured way.

Other than [26], there are a few more relevant papers. The work of [21] contains a sketch of some of the ideas this paper evolved from. They are based on the interplay of optics with parameterisation, albeit framed in the setting of diffeological spaces, and requiring cartesian and local cartesian closed structure on the base category. Lenses and Learners are studied in the eponymous work of [25] which observes that learners are parametric lenses. They do not explore any of the relevant $\mathbf{Para}$ or CRDC structure, but make the distinction between symmetric and asymmetric lenses, studying how they are related to learners defined in [26]. A lens-like implementation of automatic differentiation is the focus of [24], but learning algorithms aren’t studied. A relationship between category-theoretic perspective on probabilistic modeling and gradient-based optimisation is studied in [49] which also studies a variant of the $\mathbf{Para}$ construction. Usage of Cartesian differential categories to study learning is found in [55]. They extend the differential operator to work on stateful maps, but do not study lenses, parameterisation nor update maps. The work of [27] studies deep learning in the context of Cycle-consistent Generative Adversarial Networks [62] and formalises it via free and quotient categories, making parallels to the categorical formulations of database theory [53]. They do use the $\mathbf{Para}$ construction, but do not relate it to lenses nor reverse derivative categories. A general survey of category theoretic approaches to machine learning, covering many of the above papers, can be found in [50]. Lastly, the concept of parametric lenses has started appearing in recent formulations of categorical game theory and cybernetics [10, 11]. The work of [10] generalises the study of parametric lenses into parametric optics and connects it to game thereotic concepts such as Nash equilibria.

7. Conclusions and Future Directions

We have given a categorical foundation of gradient-based learning algorithms which achieves a number of important goals. The foundation is principled and mathematically clean, based on the fundamental idea of a parametric lens. The foundation covers a wide variety of examples: different optimisers and loss maps in gradient-based learning, different architectures and layer structures, different settings where gradient-based learning happens (smooth functions vs. boolean circuits), adversarial unsupervised learning, and both learning of parameters and learning of inputs (deep dreaming). Finally, the foundation is more than a mere abstraction: we have also shown how it can be used to give a practical implementation of learning, as discussed in Section 5.

There are a number of important directions which are possible to explore because of this work. One of the most exciting ones is a more comprehensive study of neural network architectures through the category-theoretic perspective. Neural network architectures have begun to be studied using category theory adjacent machinery in the context of Geometric Deep Learning ([9]) and Topological Deep Learning ([42]). Recurrent neural networks, in particular, have been been studied in [55], in the context of differential categories and the concept of delayed trace introduced in the same paper. Despite this, a comprehensive categorical study of architectures is still missing in the literature. As first noticed in [41], many architectures such as recurrent and recursive neural network have close parallels to concepts in functional programming such as folds, unfolds and accumulating maps, for instance. As these functional concepts have clear categorical semantics, it is natural to ask whether these categorical semantics can be used to study neural network architectures. We believe the categorical framework presented in this paper can serve as a natural starting point for such a study. Future work includes modelling some classical systems as well, such as the Support Vector Machines [17], which should be possible with the usage of loss maps such as Hinge loss.

In all our settings we have fixed an optimiser beforehand. The work of [2] describes a meta-learning approach which sees the optimiser as a neural network whose parameters and gradient update rule can be learned. This is an exciting prospect since one can model optimisers as parametric lenses; and our framework covers learning with parametric lenses.

Future work also includes using the full power of CRDC axioms. In particular, axioms RD.6 or RD.7, which deal with the behaviour of higher-order derivatives, were not exploited in our work, but they should play a role in modelling some supervised learning algorithms using higher-order derivatives (for example, the Hessian) for additional optimisations. Taking this idea in a different direction, one can see that much of our work can be applied to any functor of the form $F:\operatorname{\mathcal{C}}\to\mathbf{Lens}(\operatorname{\mathcal{C}})$ - $F$ does not necessarily have to be of the form $f\mapsto\left({{f}\atop{R[f]}}\right)$ for a CRDC $R$. Moreover, by working with more generalised forms of the lens category (such as dependent lenses), we may be able to capture ideas related to supervised learning on manifolds. And, of course, we can vary the parameter space to endow it with different structure from the functions we wish to learn. In this vein, we wish to use fibrations/dependent types to model the use of tangent bundles: this would foster the extension of the correct by construction paradigm to machine learning, and thereby addressing the widely acknowledged problem of trusted machine learning. The possibilities are made much easier by the compositional nature of our framework. Another key topic for future work is to link gradient-based learning with game theory. At a high level, the former takes little incremental steps to achieve an equilibrium while the later aims to do so in one fell swoop. Formalising this intuition is possible with our lens-based framework and the lens-based framework for game theory [28]. Finally, because our framework is quite general, in future work we plan to consider further modifications and additions to encompass probabilistic, non-gradient based, and other forms of non-supervised learning. This includes genetic algorithms and reinforcement learning.

Acknowledgements Fabio Zanasi acknowledges support from epsrc EP/V002376/1. Geoff Cruttwell acknowledges support from NSERC.

Appendix A More details on Parametric Categories

As mentioned in the main text, coherence rules in combining the two operations in (2) just work as expected, in the sense that these diagrams can be ultimately ‘compiled’ down to string diagrams for monoidal categories. For example, given maps $(P,f):A\to B$, $(Q,g):B\to C$ with reparametrisations $\alpha:P^{\prime}\to P$, $\beta:Q^{\prime}\to Q$, one could either first reparametrise $f$ and $g$ separately and then compose the results (below left), or compose first then reparametrise jointly (below right):

                  

As expected, translating these two operations into string diagrams for monoidal categories yield equivalent representations of the same morphism.

$$\scalebox{0.8}{ { \begin{tikzpicture} }}\qquad=\qquad\scalebox{0.8}{{ \begin{tikzpicture} }}$$ (14)

Remark 4.

There is a 2-categorical perspective on $\mathbf{Para}(\operatorname{\mathcal{C}})$, which we glossed over in this paper for the sake of simplicity. In particular, the reparametrisations described above can also be seen as equipping $\mathbf{Para}(\operatorname{\mathcal{C}})$ with 2-cells, giving a 2-categorical structure on $\mathbf{Para}(\operatorname{\mathcal{C}})$. This is also coherent with respect to base change: if $\operatorname{\mathcal{C}}$ and $\operatorname{\mathcal{D}}$ are strict symmetric monoidal categories, and $F\colon\operatorname{\mathcal{C}}\to\operatorname{\mathcal{D}}$ a lax symmetric monoidal functor, then there is an induced 2-functor $\mathbf{Para}(F)\colon\mathbf{Para}(\operatorname{\mathcal{C}})\to\mathbf{Para}(\operatorname{\mathcal{D}})$ which agrees with $F$ on objects. This 2-functor is straightforward: for a 1-cell $(P,f):A\to B$, it applies $F$ to $P$ and $f$ and uses the (lax) comparison to get a map of the correct type. We will see how this base change becomes important when performing backpropagation on parametric maps (Eq. 5)

Lastly, we mention that $\mathbf{Para}(\operatorname{\mathcal{C}})$ inherits the symmetric monoidal structure from $\operatorname{\mathcal{C}}$ and that the induced 2-functor $\mathbf{Para}(F)$ respects that structure. This will allow us to compose neural networks not only in series, but also in parallel. For more detail on alternative viewpoints on the $\mathbf{Para}$ construction, including how it can be viewed as the Grothendieck construction of a certain indexed category, see [10].

Appendix B Background on Cartesian Reverse Differential Categories

Here we briefly review the definitions of Cartesian left additive category (CLAC), Cartesian reverse differential category (CRDC) and additive and linear maps in these categories. Note that in this appendix we follow the convention of [15] and write composition in diagrammatic order by juxtaposition of terms (rather than a semicolon) to shorten the form of many of the expressions.

A category $\operatorname{\mathcal{C}}$ is said to be Cartesian when there are chosen binary products $\times$, with projection maps $\pi_{i}$ and pairing operation $\langle-,-\rangle$, and a chosen terminal object $T$, with unique maps $!$ to the terminal object.

A left additive category [5, Definition 1.1.1] (CLAC) is a category $\operatorname{\mathcal{C}}$ such that each hom-set has commutative monoid structure, with addition operation $+$ and zero maps 0, such that composition on the left preserves the additive structure: for any appropriate $f,g,h$, $f(g+h)=fg+fh$ and $f0=0$.

A map $h:X\to Y$ in a CLAC is additive if it has the property that it preserves additive structure by composition on the right: for any maps $x,y:Z\to X$, $(x+y);h=x;h+y;h$, and $0;h=0$.

[Additive in second component, (compare [5, Lemma 1.2.3])] A morphism $f:X\times A\to B$ is additive in the variable $A$ if it is an additive morphism of type $A\to B$ in the cartesian left-additive category $\mathbf{CoKl}(X\times-)$, where $\mathbf{CoKl}(X\times-)$ is the coKleisli category of the coreader comonad.

A Cartesian left additive category [5, Definition 1.2.1] is a left additive category $\operatorname{\mathcal{C}}$ which is Cartesian and such that all projection maps $\pi_{i}$ are additive.

We call $\mathbf{CLACat}$ the category whose objects are cartesian left-additive categories and whose morphisms are cartesian left-additive functors (functors which preserve products and commutative monoid structure on objects ([5, Definition 1.3.1])).

Lemma 5.

Let $\operatorname{\mathcal{C}}$ and $\operatorname{\mathcal{D}}$ be cartesian left-additive categories, and $F:\operatorname{\mathcal{C}}\to\operatorname{\mathcal{D}}$ a a cartesian left-additive functor. Let $f:A\to B$ be an additive morphism in $\operatorname{\mathcal{C}}$. Then $F(f):F(A)\to F(B)$ is also additive.

The central definition of [15] is the following:

A Cartesian reverse differential category (CRDC) is a Cartesian left additive category $\operatorname{\mathcal{C}}$ which has, for each map $f:A\to B$ in $\operatorname{\mathcal{C}}$, a map

$$R[f]:A\times B\to A$$

satisfying seven axioms:
[RD.1] $R[f+g]=R[f]+R[g]$ and $R[0]=0$.
[RD.2] $\langle a,b+c\rangle R[f]=\langle a,b\rangle R[f]+\langle a,c\rangle R[f]$ and $\langle a,0\rangle R[f]=0$.
[RD.3] $R[1]=\pi_{1}$, $R[\pi_{0}]=\pi_{1}\iota_{0}$, and $R[\pi_{1}]=\pi_{1}\iota_{1}$. [RD.4] For a tupling of maps $f$ and $g$, the following equality holds:

$$R[\langle f,g\rangle]=(1\times\pi_{0});R[f]+(1\times\pi_{1});R[g]$$

And if $!_{A}:A\to T$ is the unique map to the terminal object, $R[!_{A}]=0$.

[RD.5] For composable maps $f$ and $g$,

$$R[fg]=\langle\pi_{0},\pi_{0}f,\pi_{1}\rangle\rangle(1\times R[g])R[f]$$

[RD.6]

$$\langle 1\times\pi_{0},0\times\pi_{1}\rangle(\iota_{0}\times 1)R[R[R[f]]]\pi_{1}=(1\times\pi_{1})R[f].$$

[RD.7]

$$(\iota_{0}\times 1);R[R[(\iota_{0}\times 1)R[R[f]]\pi_{1}]];\pi_{1}=\mathsf{ex};(\iota_{0}\times 1)R[R[(\iota_{0}\times 1)R[R[f]]\pi_{1}]]\pi_{1}$$

(where $\mathsf{ex}$ is the map that exchanges the middle two variables).

As discussed in [15], these axioms correspond to familiar properties of the reverse derivative:

• [RD.1] says that differentiation preserves addition of maps, while [RD.2] says that differentiation is additive in its vector variable.

• [RD.3] and [RD.4] handle the derivatives of identities, projections, and tuples.

• [RD.5] is the (reverse) chain rule.

• [RD.6] says that the reverse derivative is linear in its vector variable.

• [RD.7] expresses the independence of order of mixed partial derivatives.

We proceed to prove the following theorem in three steps. *

The first step is formally defining the category $\mathbf{Lens}_{A}(\operatorname{\mathcal{C}})$. Let $\operatorname{\mathcal{C}}$ be a cartesian left-additive category. Then $\mathbf{Lens}_{A}(\operatorname{\mathcal{C}})$ is a wide subcategory of $\mathbf{Lens}(\operatorname{\mathcal{C}})$ where

$$\mathbf{Lens}_{A}(\operatorname{\mathcal{C}})\Bigg{(}\begin{matrix}{A}\\ {A^{\prime}}\end{matrix}\,,\begin{matrix}{B}\\ {B^{\prime}}\end{matrix}\Bigg{)}\coloneqq\operatorname{\mathcal{C}}(A,B)\times\mathbf{CoKl}(A\times-)_{A}(B^{\prime},A^{\prime})$$

Compare this with the defintion of $\mathbf{Lens}(\operatorname{\mathcal{C}})$ via the Grothendieck construction ([54, Prop. 3.10]) where

$$\mathbf{Lens}(\operatorname{\mathcal{C}})\Bigg{(}\begin{matrix}{A}\\ {A^{\prime}}\end{matrix}\,,\begin{matrix}{B}\\ {B^{\prime}}\end{matrix}\Bigg{)}\coloneqq\operatorname{\mathcal{C}}(A,B)\times\mathbf{CoKl}(A\times-)(B^{\prime},A^{\prime})$$

The second step is showing this category is cartesian left-additive.

Proposition 6.

The category $\mathbf{Lens}_{A}(\operatorname{\mathcal{C}})$ is cartesian left-additive.

Proof B.1.

We need to equip $\mathbf{Lens}_{A}(\operatorname{\mathcal{C}})$ with a commutative monoid on every object in a way that’s compatible with the cartesian structure. That is, for every object $\left({{A}\atop{A^{\prime}}}\right)$ we need to provide two morphisms:

• Unit $0_{\left({{A}\atop{A^{\prime}}}\right)}:\left({{1}\atop{1}}\right)\to\left({{A}\atop{A^{\prime}}}\right)$. This is a lens whose forward map we set as the zero map $0_{A}$ and the backward map as the delete $!_{1\times A^{\prime}}$.

• Multiplication $+_{\left({{A}\atop{A^{\prime}}}\right)}:\left({{A\times A}\atop{A^{\prime}\times A^{\prime}}}\right)\to\left({{A}\atop{A^{\prime}}}\right)$. This is a lens whose forward map we set as sum $+_{A}$ and the backward map as copy, i.e. $(A\times A)\times A^{\prime}\xrightarrow{\pi_{2}}A^{\prime}\xrightarrow{\Delta_{A^{\prime}}}A^{\prime}\times A^{\prime}$.

Additionally, these morphisms need to obey the monoid laws. This can be verified by routine.

This defines the action of $\mathbf{Lens}_{A}$ on objects of $\mathbf{CLACat}$. Action on morphisms is defined below.

Proposition 7.

Let $F:\operatorname{\mathcal{C}}\to\operatorname{\mathcal{D}}$ be a cartesian left-additive functor. This induces a cartesian left-additive functor $\mathbf{Lens}_{A}(F)$ between the corresponding categories of lenses:

$$\begin{tikzcd}$$ (15)

where $\overline{f^{*}}\coloneqq F(A^{\prime})\times F(B^{\prime})\cong F(A^{\prime}\times B^{\prime})\xrightarrow{F(f^{\prime})}F(A^{\prime})$.

Proof B.2.

We need to prove that $\mathbf{Lens}_{A}(F)$ is a cartesian left-additive functor. To prove it is a functor, we need to:

• Define its action on objects and morphisms. We have done this in Prop. 7 itself;

• Prove additivity of $\overline{f^{*}}$. This follows from Lemma. 5;

• Prove identities are preserved. The identity $\left({{\text{id}_{A}}\atop{\pi_{2}}}\right):\left({{A}\atop{A^{\prime}}}\right)\to\left({{A}\atop{A^{\prime}}}\right)$ in the domain gets mapped to $\left({{F(\text{id}_{A})}\atop{F(\pi_{2})}}\right)$. By preservation of identities and products of $F$ this is equal to the identity map on $\left({{F(A)}\atop{F(A^{\prime})}}\right)$.

• Prove composition is preserved. This can be be by routine, albeit tedious calculation.

To prove that it is additionally cartesian, we need to show that the image of every comonoid $(\left({{A}\atop{A^{\prime}}}\right),!_{\left({{A}\atop{A^{\prime}}}\right)},\Delta_{\left({{A}\atop{A^{\prime}}}\right)})$ is also a comonoid, and that all maps preserve comonoids. We can understand the first part in terms of actions on the counit and comultiplication of the comonoid.

• Counit. The action on the counit unpacks to the pair $\left({{F(!_{\left({{A}\atop{A^{\prime}}}\right)})}\atop{F(!_{A\times 1};0_{A})}}\right)$. By preservation of terminal and additive maps of $F$ this morphism is equal to the counit of $\left({{F(A)}\atop{F(A^{\prime})}}\right)$.

• Comultiplication. The action on the comultiplication unpacks to $\left({{(F(\Delta_{A})}\atop{F(\pi_{2,3};+_{A})}}\right)$. By $F$’s preservation of products and additive morphisms this morphism is equal to the comultiplication of $\left({{F(A)}\atop{F(A^{\prime})}}\right)$.

It is routine to show it obey the corresponding laws and form a comonoid.

For the second part we need to show that the image of every lens $\left({{f}\atop{f^{\sharp}}}\right):\left({{A}\atop{A^{\prime}}}\right)\to\left({{B}\atop{B^{\prime}}}\right)$ preserves these comonoids. For the forward part this is true because $F$ preserves products. For the backwards part this is true because $F$ is left-additive.

Lastly, we need to prove that this functor is additionally left-additive. This means that it preserves the monoid $(\left({{A}\atop{A^{\prime}}}\right),0_{\left({{A}\atop{A^{\prime}}}\right)},+_{\left({{A}\atop{A^{\prime}}}\right)})$ of every object. We unpack the action of $\mathbf{Lens}_{A}(F)$ on the unit $0_{\left({{A}\atop{A^{\prime}}}\right)}$ and multiplication $+_{\left({{A}\atop{A^{\prime}}}\right)}$ below.

• Unit. The action on the unit unpacks to the pair $\left({{F(0_{A})}\atop{F(!_{1\times A})}}\right)$. By preservation of additive and terminal maps of $F$ this morphism is equal to the unit of $\left({{F(A)}\atop{F(A)}}\right)$;

• Multiplication. The action on the multiplication unpacks to the pair $\left({{F(+_{A})}\atop{F(\pi_{3};\Delta_{A})}}\right)$. By preservation of coadditive maps and products of $F$ this morphism is equal to the multiplication of $\left({{F(A)}\atop{F(A^{\prime})}}\right)$.

Seeing as these monoids in the codomain are of the same form as those in the domain, it is routine to show that they obey the monoid laws. This concludes the proof that $\mathbf{Lens}_{A}(F)$ is a cartesian left-additive functor.

What remains to show is that $\mathbf{Lens}_{A}$ preserves identities and composition, which follows routinely, concluding the proof of (Thm. 2).

This functor has additional structure — it is copointed.

Proposition 8 (Copointed structure of $\mathbf{Lens}_{A}$).

There is a natural transformation $\epsilon:\mathbf{Lens}_{A}\Rightarrow\text{id}_{\mathbf{CLACat}}$ which on components assigns to cartesian left-additive category $\operatorname{\mathcal{C}}$ a cartesian left-additive functor $\epsilon_{\operatorname{\mathcal{C}}}:\mathbf{Lens}_{A}(\operatorname{\mathcal{C}})\to\operatorname{\mathcal{C}}$ which forgets the backward part of the lens.

*

Proof B.3.

We have shown how a putative reverse derivative combinator arises out of the functor $\mathbf{R}_{\operatorname{\mathcal{C}}}:\operatorname{\mathcal{C}}\to\mathbf{Lens}_{A}(\operatorname{\mathcal{C}})$. What remains to prove is that this combinator satisfies the first five axioms of a CRDC.

1. Additivity of reverse differentiation. This is recovered by $\mathbf{R}_{\operatorname{\mathcal{C}}}$ preserving left-additive structure.

2. Additivity of reverse derivative in the second variable. This is recovered by definition of $\mathbf{Lens}_{A}$ — the backward maps are additive in the 2nd component.

3. Coherence with identities and projections. Coherence with identities is recovered by preservation of identities of the functor $\mathbf{R}_{\operatorname{\mathcal{C}}}$, where for every $X:\operatorname{\mathcal{C}}$, $\mathbf{R}_{\operatorname{\mathcal{C}}}(\text{id}_{X})=\text{id}_{\mathbf{R}_{\operatorname{\mathcal{C}}}(X)}=(\text{id}_{X},\pi_{2}:X\times X\to X)$. Coherence with projections is recovered by $\mathbf{R}_{\operatorname{\mathcal{C}}}$ preserving cartesian structure.

4. Coherence with pairings. Recovered by $\mathbf{R}_{\operatorname{\mathcal{C}}}$ preserving cartesian structure.

5. Reverse chain rule. Recovered by functoriality of $\mathbf{R}_{\operatorname{\mathcal{C}}}$.