Theano2.1.6-基础知识之在thenao中的求导

来自：http://deeplearning.net/software/theano/tutorial/gradients.html

Derivatives in Theano

一、计算梯度

现在，让我们使用theano来做稍微更复杂的任务：创建一个函数，用来计算表达式y 关于它的参数x的导数。我们将会用到宏 T.grad 。例如，我们可以计算  关于 的梯度。注意： .

下面就是用来计算这个梯度的代码：

>>> from theano import pp
>>> x = T.dscalar('x')
>>> y = x ** 2
>>> gy = T.grad(y, x)
>>> pp(gy)  # print out the gradient prior to optimization
'((fill((x ** 2), 1.0) * 2) * (x ** (2 - 1)))'
>>> f = function([x], gy)
>>> f(4)
array(8.0)
>>> f(94.2)
array(188.40000000000001)

在这个例子中，我们可以从pp(gy) 中看到我们在计算的符号梯度是正确的。 fill((x ** 2), 1.0) 意思是说创建一个和 x ** 2一样shape的矩阵，然后用1.0来填充。

note：该优化器简化了符号梯度的表达式，你可以深挖编译后的函数的内部属性来了解细节。

pp(f.maker.fgraph.outputs[0])
'(2.0 * x)'

在优化之后，在graph中只有一个 Apply节点，其输入是乘以2的。

我们同样可以计算复杂表达式的梯度，例如由上面定义的逻辑函数。结果显示逻辑函数的梯度为： .

该图是逻辑函数的梯度，x轴表示x的变化，y轴表示梯度  。

>>> x = T.dmatrix('x')
>>> s = T.sum(1 / (1 + T.exp(-x)))
>>> gs = T.grad(s, x)
>>> dlogistic = function([x], gs)
>>> dlogistic([[0, 1], [-1, -2]])
array([[ 0.25      ,  0.19661193],
       [ 0.19661193,  0.10499359]])

通常来说，对于任何标量表达式， T.grad(s, w) 提供theano表达式来计算 。这种方式下，甚至对于有着许多输入的函数来说，theano可以用来高效的计算符号微分 (正如 T.grad 返回的表达式可以在编译期间进行优化)
( automatic
differentiation 有详细的描述关于符号微分的)。

note： T.grad 的第二个参数可以是一个列表，这种情况下，输出也同样是一个列表。在这两个列表中的顺序都是很重要的：输出列表的第
i 个元素是T.grad 的第一个参数关于第二个参数的列表的第
i 个元素的梯度。 T.grad 第一个参数必须是一个标量(其tensor
size 为1）。更多有关T.grad的参数的语义的信息和实现的细节，可以参考库的 this 部分。

在内部微分的工作的信息可以在更高级的教程 Extending Theano中找到。

二、计算Jacobian

在theano中，术语 Jacobian 指定为张量包含函数的输出关于输入的第一个偏导数。 （在数学中这就是所谓的Jacobian矩阵） Theano 实现宏theano.gradient.jacobian() 所需要的就是计算Jacobian。下面部分就是解释如何手动去完成它：

为了手动计算一些函数 y 关于一些参数 x 的Jacobian，我们需要使用 scan。即在y
中使用循环来遍历所有元素，然后计算 y[i] 关于x 的梯度。

note：scan 是theano中一个通用的操作，可以以符号方式写出各种递归等式。然而生成一个符号循环是很难的（而且还需要为了性能而去优化它们）
，所以需要努力提升scan.的效果。在后面会接着说 scan 的。

>>> x = T.dvector('x')
>>> y = x ** 2
>>> J, updates = theano.scan(lambda i, y,x : T.grad(y[i], x), sequences=T.arange(y.shape[0]), non_sequences=[y,x])
>>> f = function([x], J, updates=updates)
>>> f([4, 4])
array([[ 8.,  0.],
       [ 0.,  8.]])

在该代码中所做的就是生成一个int类型的序列，通过使用T.arange来使得其中从0到 y.shape[0] 。然后我们对这个序列进行循环，然后在每一步，灭我们计算元素 y[i]关于x
的梯度。scan 可以自动的连接所有的这些列，生成一个对应于jacobian的矩阵。

note：在使用T.grad的时候记得也有一些陷阱的。 其中一个就是你没法和这样theano.scan(lambda y_i,x: T.grad(y_i,x), sequences=y, non_sequences=x)重写jacobin的上述表达式，，尽管从文档上看scan是可以的。原因在于 y_i 不再试x的函数了，而 y[i]仍然是。

三、计算Hessian

在theano中，术语Hessian 与数学上的概念没差：是一个矩阵，其中包含着标量输出和向量输入的函数的二阶偏导数。Theano 实现宏theano.gradient.hessian() 所要做的就是计算Hessian。下面的部分就是介绍如何手动完成。

你可以可jacobian一样相似的计算Hessian。唯一的差别在于，我们通过计算T.grad(cost,x)的jacobian来代替计算一些表达式y
的jacobian，所以计算的cost是标量的。

>>> x = T.dvector('x')
>>> y = x ** 2
>>> cost = y.sum()
>>> gy = T.grad(cost, x)
>>> H, updates = theano.scan(lambda i, gy,x : T.grad(gy[i], x), sequences=T.arange(gy.shape[0]), non_sequences=[gy, x])
>>> f = function([x], H, updates=updates)
>>> f([4, 4])
array([[ 2.,  0.],
       [ 0.,  2.]])

四、Jacobian乘以一个向量

有时候我们需要将算法表示成jacobinas乘以向量，或者向量乘以jacobinans。相比较于评估jacobian，然后做乘法，可以直接计算合适的结果从而避免对jacobian的实际计算。这可以带来明显的性能的提升。一个这样的算法可以在下面的文献中找到：

• Barak A. Pearlmutter, “Fast Exact Multiplication by the Hessian”, Neural Computation, 1994

然而在实际中，我们想要theano能够自动的识别这些模式，不过以通常的方式来实现这样的优化是非常难的。所以，我们提供了特别的函数来应对这些问题：

R-operator

R
操作符是用来评估介于一个jacobian和一个向量之间的乘积的，即 .
该式子可以扩展成当x是一个矩阵，或者一个张量的形式，这种情况下，jacobian就变成了一个张量，然后乘积就变成了某种张量的积。因为在实际中，我们最后是需要计算权重矩阵这样的表达式的，theano支持这种操作的更通用形式。为了评估表达式y的R
操作，（关于x的），使用v乘以jacobian，你需要做类似下面的事情：

>>> W = T.dmatrix('W')
>>> V = T.dmatrix('V')
>>> x = T.dvector('x')
>>> y = T.dot(x, W)
>>> JV = T.Rop(y, W, V)
>>> f = theano.function([W, V, x], JV)
>>> f([[1, 1], [1, 1]], [[2, 2], [2, 2]], [0,1])
array([ 2.,  2.])

实现Rop的操作列表List 。

L-operator

相似于R-操作，L-操作 会计算一个行向量乘积，其数学上的形式为 。该L-操纵 同样支持通用的张量
(不只是向量)。相思的，它可以按照下面形式实现：

>>> W = T.dmatrix('W')
>>> v = T.dvector('v')
>>> x = T.dvector('x')
>>> y = T.dot(x, W)
>>> VJ = T.Lop(y, W, v)
>>> f = theano.function([v,x], VJ)
>>> f([2, 2], [0, 1])
array([[ 0.,  0.],
       [ 2.,  2.]])

note：v,
在L操作和R操作中是不同的。对于L操作来说，该 v 需要有着和输出一样的shape，然而，R操作需要和输入参数一样的shape。更进一步说，这两个操作的结果是不同的。L操作的结果有着和输入参数一样的shape，而R操作有着和输出一样的shape。

五、Hessian乘以一个向量

如果你需要计算Hessian
乘以一个向量，你就需要用到上面定义的操作，它们通常比实际计算准确的Hessian，然后计算乘积更高效。因为Hessian矩阵的对称性，你可以用两种方式得到相同的结果，虽然这些选择也许会有不同的性能。因此，我们建议在使用它们之前先,
先对它们进行分析：

>>> x = T.dvector('x')
>>> v = T.dvector('v')
>>> y = T.sum(x ** 2)
>>> gy = T.grad(y, x)
>>> vH = T.grad(T.sum(gy * v), x)
>>> f = theano.function([x, v], vH)
>>> f([4, 4], [2, 2])
array([ 4.,  4.])

或者使用R操作：

>>> x = T.dvector('x')
>>> v = T.dvector('v')
>>> y = T.sum(x ** 2)
>>> gy = T.grad(y, x)
>>> Hv = T.Rop(gy, x, v)
>>> f = theano.function([x, v], Hv)
>>> f([4, 4], [2, 2])
array([ 4.,  4.])

备注：

• grad 函数是符号化的工作的：它接受和返回theano变量。
• grad 可以和宏相比较，因为它可以重复使用
• 标量损失只能被直接通过grad进行处理。数组可以通过重复应用的形式来解决
• 内建的函数可以高效的计算向量乘以jacobian和向量乘以Hessian
• 优化需要高效的计算全jacobian和Hessian矩阵，以及jacobian乘以向量。

参考资料：

[1]官网：http://deeplearning.net/software/theano/tutorial/gradients.html