1 自动微分

我们在《数值分析》课程中已经学过许多经典的数值微分方法。许多经典的数值微分算法非常快，因为它们只需要计算差商。然而，他们的主要缺点在于他们是数值的，这意味着有限的算术精度和不精确的函数求值，而这些都从根本上限制了求解结果的质量。因此。充满噪声的、复杂多变的函数很难得到精准的数值微分。

自动微分技术（称为“automatic differentiation, autodiff”）是介于符号微分和数值微分的一种技术，它是在计算效率和计算精度之间的一种折衷。自动微分不受任何离散化算法误差的约束，它充分利用了微分的链式法则和其他关于导数的性质来准确地计算它们。

2 前向自动微分

我们先来计算简单的前向自动微分。假设我们有两个变量u和v，使用浮点数存储。我们将变量u′=du/dt和v′=dv/dt和这些变量一起存储，这里t是独立的变量。在一些程序设计语言(如Python)中，我们可以选择定义一种新的数据类型来存储[u,u′]和[v,v′]这类数对。我们可以在这些数对上定义一种代数运算，这些代数运算编码了一些经典的操作：

[u,u′]+[v,v′]≡[u+v′,u′+v′]c[u,u′]≡[cu,cu′][u,u′]⋅[v,v′]≡[uv,uv′+u′v][u,u′]/[v,v′]≡[u/v,(vu′−uv′)/v2]exp([u,u′])≡[eu,u′eu]ln([u,u′])≡[lnu,u′/u]cos([u,u′])≡[cosu,−u′sinu′]⋮⋮

在进行前向自动微分之前，我们需要先将计算f(t)所产生的操作序列表示为计算图。接着，采用自底向上的递推算法的思想，从做为递推起点的数对t≡[t0,1](因为dt/dt=1)开始，我们能够按照我们上述编码规则同时对函数f(t)和它的导数f′(t)进行求值。我们在编程语言中可以选择令数对重载运算符，这样额外的求导数运算就可以对用户透明地执行了。

例1 比如，对于函数f(x)=exp(x2−x)/x，想要依次计算dyi/dx（这里yi为所有计算中间项）。则我们先从x开始将表达式分解为计算图：

xy1=x2y2=y1−xy3=exp(y2)y4=y3/x

然后前向递推地按照我们之前所述的编码规则来进行求导

dy1dx=2xdy2dx=dy1dx−dxdx=2x−1dy3dx=exp(y2)⋅dy2dxdy4dx=dy3dxx−y3x2

注意链式法则（chain rule）告诉我们：

(f(g(x)))′=f′(g(x))⋅g′(x)

所以我们对

yk=g(yi)

y′k=g′(yi)⋅y′i

事实上，我们也能够处理有多个输入的函数g：

yk=g(yi,⋯,yj)

多元微分链式法则如下：

ddxyk(x)=ddxg(yi(x),⋯,yj(x))=j∑h=i∂g∂yhdyhdx

比如，对于

y1=xy2=xy3=y2y4=y1⋅y2⋅y3

dy1dx=1dy2dx=1dy3dx=1⋅dy2dx=1dy4dx=y2y3⋅dy1dx+y1y3dy2dx+y1y2dy3dx=y2y3+y1y3+y1y2=3x2

下面展示了一个对二元函数模拟前向自动微分的过程。

例2 设f(x1,x2)=x1⋅exp(x2)−x1，模拟前向微分过程。

y1=exp(x2)y2=x1⋅y1y3=y2−x1

dy1dx2=exp(x2)dy2dx1=y1=exp(x2)dy2dx2=x1⋅dy1dx2=x1⋅exp(x2)dy3dx1=dy2dx1−dx1dx1=exp(x2)−1dy3dx2=dy2dx2=x1⋅exp(x2)

接下来我们看如何用Python代码来实现单变量函数的前向自动微分过程。为了简便起见，我们下面只编码了几个常用的求导规则。

import math

class Var:
    def __init__(self, val, deriv=1.0):
        self.val = val
        self.deriv = deriv
    
    def __add__(self, other):
        if isinstance(other, Var):
            val = self.val + other.val
            deriv = self.deriv + other.deriv
        else:
            val = self.val + other
            deriv = self.deriv
        return Var(val, deriv)
    
    def __radd__(self, other):
        return self + other

    def __sub__(self, other):
        if isinstance(other, Var):
            val = self.val - other.val
            deriv = self.deriv - other.deriv
        else:
            val = self.val - other
            deriv = self.deriv
        return Var(val, deriv)
    
    def __rsub__(self, other):
        val = other - self.val
        deriv = - self.deriv
        return Var(val, deriv)

    def __mul__(self, other):
        if isinstance(other, Var):
            val = self.val * other.val
            deriv = self.val * other.deriv + self.deriv * other.val
        else:
            val = self.val * other
            deriv = self.deriv * other
        return Var(val, deriv)
    
    def __rmul__(self, other):
        return self * other

    def __truediv__(self, other):
        if isinstance(other, Var):
            val = self.val / other.val
            deriv = (self.deriv * other.val - self.val * other.deriv)/other.val**2
        else:
            val = self.val / other
            deriv = self.deriv / other
        return Var(val, deriv)

    def __rtruediv__(self, other):
        val = other / self.val
        deriv = other * 1/self.val**2
        return Var(val, deriv)
    
    def __repr__(self):
        return "value: {}\t gradient: {}".format(self.val, self.deriv)
        

def exp(f: Var):
    return Var(math.exp(f.val), math.exp(f.val) * f.deriv)

例如，我们若尝试计算函数f(x)=exp(x2−x)/x在x=2.0处的导数f′(2.0)如下：

fx = lambda x: exp(x*x - x)/x
df = fx(Var(2.0))
print(df)

打印输出：

value: 3.694528049465325         deriv: 9.236320123663312

可见，前向过程完成计算得到f(2.0)≈3.69, f′(2.0)≈9.24。

3 反向自动微分

我们前面介绍的前向自动微分方法在计算y=f(t)的时候并行地计算f′(t)。接下来我们介绍一种“反向”自动微分方法，相比上一种的方法它仅需要更少的函数求值，不过需要以更多的内存消耗和更复杂的实现做为代价。

同样，这个技术需要先将计算f(t)所产生的操作序列表示为计算图。不过，与之前的从dt/dt=1开始，然后往dy/dt方向计算不同，反向自动求导算法从dy/dy=1开始并且按与之前同样的规则往反方向计算，一步步地将分母替换为dt。反向自动微分可以避免不必要的计算，特别是当y是一个多元函数的时候。例如，对f(t1,t2)=f1(t1)+f2(t2)，反向自动微分并不需要计算f1关于t2的微分或f2关于t1的微分。

例3 设f(x1,x2)=x1⋅exp(x2)−x1，模拟反向自动微分过程。

y1=exp(x2)y2=x1⋅y1y3=y2−x1

∂f∂y3=1∂f∂y2=∂f∂y3∂y3∂y2=1⋅1=1∂f∂y1=∂f∂y2∂y2∂y1=1⋅x1=x1∂f∂x2=∂f∂y1∂y1∂x2=x1⋅exp(x2)∂f∂x1=∂f∂y2∂y2x1+∂f∂y3∂y3∂x1=1⋅y1+1⋅(−1)=exp(x2)−1

可见若采用反向自动微分，我们需要存储计算过程中的所有东西，故内存的使用量会和时间成正比。不过，在现有的深度学习框架中，对反向自动微分的实现进行了进一步优化，我们会在深度学习专题文章中再进行详述。

自动微分被广泛认为是一种未被充分重视的数值技术，它可以以尽量小的执行代价来产生函数的精确导数。它在软件需要计算导数或Hessian来运行优化算法时显得格外有价值，从而避免每次目标函数改变时都去重新手动计算导数。当然，做为其便捷性的代价，自动微分也会带来计算的效率问题，因为在实际工作中自动微分方法并不会去化简表达式，而是直接应用最显式的编码规则。

[1] Solomon J. Numerical algorithms: methods for computer vision, machine learning, and graphics[M]. CRC press, 2015.
[2] S&DS 631: Computation and Optimization Automatic Differentiation

__EOF__

数值计算：前向和反向自动微分(Python实现) - orion-orion

1 自动微分

2 前向自动微分

3 反向自动微分

Recommend

200行写一个自动微分工具

MIT开源高性能自动微分框架Enzyme：速度提升4.5倍

深度学习框架中的自动微分及高阶导数

5.3. 自动微分

【自动微分原理】自动微分的具体实现 - ZOMI酱酱

数值计算(1) --求解连续微分系统和混沌系统

OneFlow源码解析：自动微分机制

图解自动微分的正向模式和逆向模式

自动微分（Automatic Differentiation）：算法篇

自动微分（Automatic Differentiation）：实现篇

About Joyk