Python 计算Jacobian x Jacobian.T的有效方法

Python 计算Jacobian x Jacobian.T的有效方法,python,pytorch,backpropagation,autograd,jax,Python,Pytorch,Backpropagation,Autograd,Jax,假设J是某函数f关于某些参数的雅可比矩阵。有没有有效的方法(在PyTorch或Jax中)让函数接受两个输入(x1和x2)并计算J(x1)*J(x2).transpose()而不实例化内存中的整个J矩阵 我遇到过类似于jvp(f,input,v=vjp(f,input))的东西,但我不太理解它,也不确定我想要什么。在JAX中,可以使用JAX.jacfwd或JAX.jacrev计算完整的雅可比矩阵,或者可以使用jax.jvp和jax.vjp计算雅可比算子及其转置 例如,假设你有一个函数Rᴺ → Rᴹ

假设
J
是某函数
f
关于某些参数的雅可比矩阵。有没有有效的方法(在PyTorch或Jax中)让函数接受两个输入(
x1
x2
)并计算
J(x1)*J(x2).transpose()
而不实例化内存中的整个
J
矩阵


我遇到过类似于
jvp(f,input,v=vjp(f,input))
的东西,但我不太理解它,也不确定我想要什么。

在JAX中,可以使用
JAX.jacfwd
JAX.jacrev
计算完整的雅可比矩阵,或者可以使用
jax.jvp
jax.vjp
计算雅可比算子及其转置

例如,假设你有一个函数
Rᴺ → Rᴹ看起来像这样:

import jax.numpy as jnp
import numpy as np

np.random.seed(1701)
N, M = 10000, 5
f_mat = np.array(np.random.rand(M, N))
def f(x):
  return jnp.sqrt(f_mat @ x / N)
给定两个向量
x1
x2
,可以使用
jax.jacfwd

import jax
x1 = np.array(np.random.rand(N))
x2 = np.array(np.random.rand(N))
J1 = jax.jacfwd(f)(x1)
J2 = jax.jacfwd(f)(x2)
print(J1 @ J2.T)
# [[3.3123782e-05 2.5001222e-05 2.4946943e-05 2.5180108e-05 2.4940484e-05]
#  [2.5084497e-05 3.3233835e-05 2.4956826e-05 2.5108084e-05 2.5048916e-05]
#  [2.4969209e-05 2.4896170e-05 3.3232871e-05 2.5006309e-05 2.4947023e-05]
#  [2.5102483e-05 2.4947576e-05 2.4906987e-05 3.3327218e-05 2.4958186e-05]
#  [2.4981882e-05 2.5007204e-05 2.4966144e-05 2.5076926e-05 3.3595043e-05]]
但是,正如您所注意到的,在计算这个5x5结果的过程中,我们实例化了两个5x1000矩阵。我们该怎么解决这个问题呢

答案在
jax.jvp
jax.vjp
中。就您的问题而言,这些电话签名有些不直观,因为它们主要用于正向模式和反向模式自动区分。但是广义上,你可以把它们看作是一种计算向量
v
J@v
J.T@v
的方法,而不必显式地计算
J

例如,您可以使用
jax.jvp
计算
J1
对向量的操作效果,而不实际计算
J1

J1_op = lambda v: jax.jvp(f, (x1,), (v,))[1]

vN = np.random.rand(N)
np.allclose(J1 @ vN, J1_op(vN))
# True
类似地,您可以使用
jax.vjp
计算
J2.T
对向量的操作效果,而无需实际计算
J2

J2T_op = lambda v: jax.vjp(f, x2)[1](v)[0]

vM = np.random.rand(M)
np.allclose(J2.T @ vM, J2T_op(vM))
# True
将它们放在一起并在一个单位矩阵上操作,可以得到您想要的完整雅可比矩阵乘积:

def direct(f, x1, x2):
  J1 = jax.jacfwd(f)(x1)
  J2 = jax.jacfwd(f)(x2)
  return J1 @ J2.T

def indirect(f, x1, x2, M):
  J1J2T_op = lambda v: jax.jvp(f, (x1,), jax.vjp(f, x2)[1](v))[1]
  return jax.vmap(J1J2T_op)(jnp.eye(M)).T

np.allclose(direct(f, x1, x2), indirect(f, x1, x2, M))
# True
除了节省内存,这种间接方法也比直接方法快一点,这取决于所涉及的雅可比矩阵的大小:

%time direct(f, x1, x2)
# CPU times: user 1.43 s, sys: 14.9 ms, total: 1.44 s
# Wall time: 886 ms
%time indirect(f, x1, x2, M)
# CPU times: user 311 ms, sys: 0 ns, total: 311 ms
# Wall time: 158 ms