{ "cells": [ { "cell_type": "markdown", "metadata": { "id": "LqiaKasFjH82" }, "source": [ "# Custom derivative rules for JAX-transformable Python functions\n", "\n", "[![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/google/jax/blob/main/docs/notebooks/Custom_derivative_rules_for_Python_code.ipynb)\n", "\n", "*mattjj@ Mar 19 2020, last updated Oct 14 2020*\n", "\n", "There are two ways to define differentiation rules in JAX:\n", "\n", "1. using jax.custom_jvp and jax.custom_vjp to define custom differentiation rules for Python functions that are already JAX-transformable; and\n", "2. defining new core.Primitive instances along with all their transformation rules, for example to call into functions from other systems like solvers, simulators, or general numerical computing systems.\n", "\n", "This notebook is about #1. To read instead about #2, see the [notebook on adding primitives](https://jax.readthedocs.io/en/latest/notebooks/How_JAX_primitives_work.html).\n", "\n", "For an introduction to JAX's automatic differentiation API, see [The Autodiff Cookbook](https://jax.readthedocs.io/en/latest/notebooks/autodiff_cookbook.html). This notebook assumes some familiarity with [jax.jvp](https://jax.readthedocs.io/en/latest/jax.html#jax.jvp) and [jax.grad](https://jax.readthedocs.io/en/latest/jax.html#jax.grad), and the mathematical meaning of JVPs and VJPs." ] }, { "cell_type": "markdown", "metadata": { "id": "9Fg3NFNY-2RY" }, "source": [ "## TL;DR" ] }, { "cell_type": "markdown", "metadata": { "id": "ZgMNRtXyWIW8" }, "source": [ "### Custom JVPs with jax.custom_jvp" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "id": "zXic8tr--1PK" }, "outputs": [], "source": [ "import jax.numpy as jnp\n", "from jax import custom_jvp\n", "\n", "@custom_jvp\n", "def f(x, y):\n", " return jnp.sin(x) * y\n", "\n", "@f.defjvp\n", "def f_jvp(primals, tangents):\n", " x, y = primals\n", " x_dot, y_dot = tangents\n", " primal_out = f(x, y)\n", " tangent_out = jnp.cos(x) * x_dot * y + jnp.sin(x) * y_dot\n", " return primal_out, tangent_out" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "id": "RrNf588X_kJF", "outputId": "b962bafb-e8a3-4b0d-ddf4-202e088231c3" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "2.7278922\n", "2.7278922\n", "-1.2484405\n", "-1.2484405\n" ] } ], "source": [ "from jax import jvp, grad\n", "\n", "print(f(2., 3.))\n", "y, y_dot = jvp(f, (2., 3.), (1., 0.))\n", "print(y)\n", "print(y_dot)\n", "print(grad(f)(2., 3.))" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "id": "1kHd3cKOWQgB" }, "outputs": [], "source": [ "# Equivalent alternative using the defjvps convenience wrapper\n", "\n", "@custom_jvp\n", "def f(x, y):\n", " return jnp.sin(x) * y\n", "\n", "f.defjvps(lambda x_dot, primal_out, x, y: jnp.cos(x) * x_dot * y,\n", " lambda y_dot, primal_out, x, y: jnp.sin(x) * y_dot)" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "id": "Zn81cHeYWVOw", "outputId": "bf29b66c-897b-485e-c0a0-ee0fbd729a95" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "2.7278922\n", "2.7278922\n", "-1.2484405\n", "-1.2484405\n" ] } ], "source": [ "print(f(2., 3.))\n", "y, y_dot = jvp(f, (2., 3.), (1., 0.))\n", "print(y)\n", "print(y_dot)\n", "print(grad(f)(2., 3.))" ] }, { "cell_type": "markdown", "metadata": { "id": "N2DOGCREWXFj" }, "source": [ "### Custom VJPs with jax.custom_vjp" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "id": "35ScHqhrBwPh" }, "outputs": [], "source": [ "from jax import custom_vjp\n", "\n", "@custom_vjp\n", "def f(x, y):\n", " return jnp.sin(x) * y\n", "\n", "def f_fwd(x, y):\n", "# Returns primal output and residuals to be used in backward pass by f_bwd.\n", " return f(x, y), (jnp.cos(x), jnp.sin(x), y)\n", "\n", "def f_bwd(res, g):\n", " cos_x, sin_x, y = res # Gets residuals computed in f_fwd\n", " return (cos_x * g * y, sin_x * g)\n", "\n", "f.defvjp(f_fwd, f_bwd)" ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "id": "HpSozxKUCXgp", "outputId": "57277102-7bdb-41f0-c805-a27fcf9fb1ae" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "-1.2484405\n" ] } ], "source": [ "print(grad(f)(2., 3.))" ] }, { "cell_type": "markdown", "metadata": { "id": "p5ypWA7XlZpu" }, "source": [ "## Example problems\n", "\n", "To get an idea of what problems jax.custom_jvp and jax.custom_vjp are meant to solve, let's go over a few examples. A more thorough introduction to the jax.custom_jvp and jax.custom_vjp APIs is in the next section." ] }, { "cell_type": "markdown", "metadata": { "id": "AR02eyd1GQhC" }, "source": [ "### Numerical stability\n", "\n", "One application of jax.custom_jvp is to improve the numerical stability of differentiation." ] }, { "cell_type": "markdown", "metadata": { "id": "GksPXslaGPaW" }, "source": [ "Say we want to write a function called log1pexp, which computes $x \\mapsto \\log ( 1 + e^x )$. We can write that using jax.numpy:" ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "id": "6lWbTvs40ET-", "outputId": "8caff99e-add1-4c70-ace3-212c0c5c6f4e" }, "outputs": [ { "data": { "text/plain": [ "DeviceArray(3.0485873, dtype=float32)" ] }, "execution_count": 8, "metadata": { "tags": [] }, "output_type": "execute_result" } ], "source": [ "import jax.numpy as jnp\n", "\n", "def log1pexp(x):\n", " return jnp.log(1. + jnp.exp(x))\n", "\n", "log1pexp(3.)" ] }, { "cell_type": "markdown", "metadata": { "id": "PL36r_cD0oE8" }, "source": [ "Since it's written in terms of jax.numpy, it's JAX-transformable:" ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "id": "XgtGKFld02UD", "outputId": "809d399d-8eca-401e-b969-810e46648571" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "3.0485873\n", "0.95257413\n", "[0.5 0.7310586 0.88079715]\n" ] } ], "source": [ "from jax import jit, grad, vmap\n", "\n", "print(jit(log1pexp)(3.))\n", "print(jit(grad(log1pexp))(3.))\n", "print(vmap(jit(grad(log1pexp)))(jnp.arange(3.)))" ] }, { "cell_type": "markdown", "metadata": { "id": "o56Nr3V61PKS" }, "source": [ "But there's a numerical stability problem lurking here:" ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "id": "sVM6iwIO22sB", "outputId": "9c935ee8-f174-475a-ca01-fc80949199e5" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "nan\n" ] } ], "source": [ "print(grad(log1pexp)(100.))" ] }, { "cell_type": "markdown", "metadata": { "id": "Zu9sR2I73wuO" }, "source": [ "That doesn't seem right! After all, the derivative of $x \\mapsto \\log (1 + e^x)$ is $x \\mapsto \\frac{e^x}{1 + e^x}$, and so for large values of $x$ we'd expect the value to be about 1.\n", "\n", "We can get a bit more insight into what's going on by looking at the jaxpr for the gradient computation:" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "id": "dO6uZlYR4TVp", "outputId": "61e06b1e-14cd-4030-f330-a949be185df8" }, "outputs": [ { "data": { "text/plain": [ "{ lambda ; a.\n", " let b = exp a\n", " c = add b 1.0\n", " _ = log c\n", " d = div 1.0 c\n", " e = mul d b\n", " in (e,) }" ] }, "execution_count": 11, "metadata": { "tags": [] }, "output_type": "execute_result" } ], "source": [ "from jax import make_jaxpr\n", "\n", "make_jaxpr(grad(log1pexp))(100.)" ] }, { "cell_type": "markdown", "metadata": { "id": "52HR5EW26PEt" }, "source": [ "Stepping through how the jaxpr would be evaluated, we can see that the last line would involve multiplying values that floating point math will round to 0 and $\\infty$, respectively, which is never a good idea. That is, we're effectively evaluating lambda x: (1 / (1 + jnp.exp(x))) * jnp.exp(x) for large x, which effectively turns into 0. * jnp.inf.\n", "\n", "Instead of generating such large and small values, hoping for a cancellation that floats can't always provide, we'd rather just express the derivative function as a more numerically stable program. In particular, we can write a program that more closely evaluates the equal mathematical expression $1 - \\frac{1}{1 + e^x}$, with no cancellation in sight.\n", "\n", "This problem is interesting because even though our definition of log1pexp could already be JAX-differentiated (and transformed with jit, vmap, ...), we're not happy with the result of applying standard autodiff rules to the primitives comprising log1pexp and composing the result. Instead, we'd like to specify how the whole function log1pexp should be differentiated, as a unit, and thus arrange those exponentials better.\n", "\n", "This is one application of custom derivative rules for Python functions that are already JAX transformable: specifying how a composite function should be differentiated, while still using its original Python definition for other transformations (like jit, vmap, ...).\n", "\n", "Here's a solution using jax.custom_jvp:" ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "id": "XQt6MAuTJewG" }, "outputs": [], "source": [ "from jax import custom_jvp\n", "\n", "@custom_jvp\n", "def log1pexp(x):\n", " return jnp.log(1. + jnp.exp(x))\n", "\n", "@log1pexp.defjvp\n", "def log1pexp_jvp(primals, tangents):\n", " x, = primals\n", " x_dot, = tangents\n", " ans = log1pexp(x)\n", " ans_dot = (1 - 1/(1 + jnp.exp(x))) * x_dot\n", " return ans, ans_dot" ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "id": "rhiMHulfKBIF", "outputId": "883bc4d2-3a1b-48d3-b205-c500f77d229c" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1.0\n" ] } ], "source": [ "print(grad(log1pexp)(100.))" ] }, { "cell_type": "code", "execution_count": 14, "metadata": { "id": "9cLDuAo6KGUu", "outputId": "59984494-6124-4540-84fd-608ad4fc6bc6" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "3.0485873\n", "0.95257413\n", "[0.5 0.7310586 0.8807971]\n" ] } ], "source": [ "print(jit(log1pexp)(3.))\n", "print(jit(grad(log1pexp))(3.))\n", "print(vmap(jit(grad(log1pexp)))(jnp.arange(3.)))" ] }, { "cell_type": "markdown", "metadata": { "id": "9sVUGbGkUOqO" }, "source": [ "Here's a defjvps convenience wrapper to express the same thing:" ] }, { "cell_type": "code", "execution_count": 15, "metadata": { "id": "xfQTp8F7USEM" }, "outputs": [], "source": [ "@custom_jvp\n", "def log1pexp(x):\n", " return jnp.log(1. + jnp.exp(x))\n", "\n", "log1pexp.defjvps(lambda t, ans, x: (1 - 1/(1 + jnp.exp(x))) * t)" ] }, { "cell_type": "code", "execution_count": 16, "metadata": { "id": "dtdh-PLaUsvw", "outputId": "aa36aec6-15af-4397-fc55-8b9fb7e607d8" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1.0\n", "3.0485873\n", "0.95257413\n", "[0.5 0.7310586 0.8807971]\n" ] } ], "source": [ "print(grad(log1pexp)(100.))\n", "print(jit(log1pexp)(3.))\n", "print(jit(grad(log1pexp))(3.))\n", "print(vmap(jit(grad(log1pexp)))(jnp.arange(3.)))" ] }, { "cell_type": "markdown", "metadata": { "id": "V9tHAfrSF1N-" }, "source": [ "### Enforcing a differentiation convention\n", "\n", "A related application is to enforce a differentiation convention, perhaps at a boundary." ] }, { "cell_type": "markdown", "metadata": { "id": "l_6tdb-QGK-H" }, "source": [ "Consider the function $f : \\mathbb{R}_+ \\mapsto \\mathbb{R}_+$ with $f(x) = \\frac{x}{1 + \\sqrt{x}}$, where we take $\\mathbb{R}_+ = [0, \\infty)$. We might implement $f$ as a program like this:" ] }, { "cell_type": "code", "execution_count": 17, "metadata": { "id": "AfF5P7x_GaSe" }, "outputs": [], "source": [ "def f(x):\n", " return x / (1 + jnp.sqrt(x))" ] }, { "cell_type": "markdown", "metadata": { "id": "BVcEkF3ZGgv1" }, "source": [ "As a mathematical function on $\\mathbb{R}$ (the full real line), $f$ is not differentiable at zero (because the limit defining the derivative doesn't exist from the left). Correspondingly, autodiff produces a nan value:" ] }, { "cell_type": "code", "execution_count": 18, "metadata": { "id": "piI0u5MiHhQh", "outputId": "c045308f-2f3b-4c22-ebb2-b9ee582b4d25" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "nan\n" ] } ], "source": [ "print(grad(f)(0.))" ] }, { "cell_type": "markdown", "metadata": { "id": "IP0H2b7ZHkzD" }, "source": [ "But mathematically if we think of $f$ as a function on $\\mathbb{R}_+$ then it is differentiable at 0 [Rudin's Principles of Mathematical Analysis Definition 5.1, or Tao's Analysis I 3rd ed. Definition 10.1.1 and Example 10.1.6]. Alternatively, we might say as a convention we want to consider the directional derivative from the right. So there is a sensible value for the Python function grad(f) to return at 0.0, namely 1.0. By default, JAX's machinery for differentiation assumes all functions are defined over $\\mathbb{R}$ and thus doesn't produce 1.0 here.\n", "\n", "We can use a custom JVP rule! In particular, we can define the JVP rule in terms of the derivative function $x \\mapsto \\frac{\\sqrt{x} + 2}{2(\\sqrt{x} + 1)^2}$ on $\\mathbb{R}_+$," ] }, { "cell_type": "code", "execution_count": 19, "metadata": { "id": "ksHmCkcSKQJr" }, "outputs": [], "source": [ "@custom_jvp\n", "def f(x):\n", " return x / (1 + jnp.sqrt(x))\n", "\n", "@f.defjvp\n", "def f_jvp(primals, tangents):\n", " x, = primals\n", " x_dot, = tangents\n", " ans = f(x)\n", " ans_dot = ((jnp.sqrt(x) + 2) / (2 * (jnp.sqrt(x) + 1)**2)) * x_dot\n", " return ans, ans_dot" ] }, { "cell_type": "code", "execution_count": 20, "metadata": { "id": "Gsh9ZvMTKi1O", "outputId": "a3076175-6542-4210-ce4a-d0d82e0051c6" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1.0\n" ] } ], "source": [ "print(grad(f)(0.))" ] }, { "cell_type": "markdown", "metadata": { "id": "Usbp_gxaVVea" }, "source": [ "Here's the convenience wrapper version:" ] }, { "cell_type": "code", "execution_count": 21, "metadata": { "id": "qXnrxIfaVYCs" }, "outputs": [], "source": [ "@custom_jvp\n", "def f(x):\n", " return x / (1 + jnp.sqrt(x))\n", "\n", "f.defjvps(lambda t, ans, x: ((jnp.sqrt(x) + 2) / (2 * (jnp.sqrt(x) + 1)**2)) * t)" ] }, { "cell_type": "code", "execution_count": 22, "metadata": { "id": "uUU5qRmEViK1", "outputId": "ea7dc2c4-a100-48f4-a74a-859070daf994" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1.0\n" ] } ], "source": [ "print(grad(f)(0.))" ] }, { "cell_type": "markdown", "metadata": { "id": "7J2A85wbSAmF" }, "source": [ "### Gradient clipping\n", "\n", "While in some cases we want to express a mathematical differentiation computation, in other cases we may even want to take a step away from mathematics to adjust the computation autodiff performs. One canonical example is reverse-mode gradient clipping.\n", "\n", "For gradient clipping, we can use jnp.clip together with a jax.custom_vjp reverse-mode-only rule:" ] }, { "cell_type": "code", "execution_count": 23, "metadata": { "id": "8jfjSanIW_tJ" }, "outputs": [], "source": [ "from functools import partial\n", "from jax import custom_vjp\n", "\n", "@custom_vjp\n", "def clip_gradient(lo, hi, x):\n", " return x # identity function\n", "\n", "def clip_gradient_fwd(lo, hi, x):\n", " return x, (lo, hi) # save bounds as residuals\n", "\n", "def clip_gradient_bwd(res, g):\n", " lo, hi = res\n", " return (None, None, jnp.clip(g, lo, hi)) # use None to indicate zero cotangents for lo and hi\n", "\n", "clip_gradient.defvjp(clip_gradient_fwd, clip_gradient_bwd)" ] }, { "cell_type": "code", "execution_count": 24, "metadata": { "id": "4OLU_vf8Xw2J", "outputId": "5a51ff2c-79c2-41ba-eead-53679b4eddbc" }, "outputs": [ { "data": { "text/plain": [ "[]" ] }, "execution_count": 24, "metadata": { "tags": [] }, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "