pytorch教程之自动求导机制(AUTOGRAD)-从梯度和Jacobian矩阵讲起

2024-04-02 01:38

本文主要是介绍pytorch教程之自动求导机制(AUTOGRAD)-从梯度和Jacobian矩阵讲起,希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!


文章目录

  • 1. 梯度和Jacobian矩阵
  • 2. pytorch求变量导数的过程

1. 梯度和Jacobian矩阵

f ( x ) ∈ R 1 f(x)\in R^1 f(x)R1是关于向量 x ∈ R n x\in R^n xRn的函数,则它关于 x x x的导数定义为:
d f ( x ) d x : = [ ∂ f ( x ) ∂ x i ] ∈ R n (1-1) \frac{df(x)}{dx}:=\left[\frac{\partial f(x)}{\partial x_i}\right]\in R^{n}\tag{1-1} dxdf(x):=[xif(x)]Rn(1-1)
函数 f ( x ) ∈ R 1 f(x)\in R^1 f(x)R1关于向量 x ∈ R n x\in R^n xRn的导数是一个列向量,称之为 f ( x ) f(x) f(x)关于 x x x的梯度。
d f ( x ) T d x : = ( d f ( x ) d x ) T = [ ∂ f ( x ) ∂ x i ] T ∈ R 1 × n (1-2) \frac{df(x)^T}{dx}:=\left(\frac{df(x)}{dx}\right)^T=\left[\frac{\partial f(x)}{\partial x_i}\right]^T\in R^{1\times n}\tag{1-2} dxdf(x)T:=(dxdf(x))T=[xif(x)]TR1×n(1-2)
如果 f ( x ) ∈ R M f(x)\in R^M f(x)RM是关于向量 x ∈ R n x\in R^n xRn的函数向量,则 f ( x ) f(x) f(x)关于 x x x的导数定义为:
d f ( x ) d x : = d f ( x ) d x T = [ ∂ f ( x ) ∂ x 1 , ∂ f ( x ) ∂ x 2 , ⋯ , ∂ f ( x ) ∂ x n ] ∈ R m × n (1-3) \frac{df(x)}{dx}:=\frac{df(x)}{dx^T}=\left[\frac{\partial f(x)}{\partial x_1},\frac{\partial f(x)}{\partial x_2},\cdots,\frac{\partial f(x)}{\partial x_n}\right]\in R^{m\times n}\tag{1-3} dxdf(x):=dxTdf(x)=[x1f(x),x2f(x),,xnf(x)]Rm×n(1-3)
称上述矩阵为Jacobian矩阵。
一些常用推论:

  1. 假设 v , x ∈ R n v,x\in R^n v,xRn:
    d d x ( v T x ) = d d x ( x T v ) = v (1-4) \frac{d}{dx}(v^Tx)=\frac{d}{dx}(x^Tv)=v\tag{1-4} dxd(vTx)=dxd(xTv)=v(1-4)
  2. 假设 y ∈ R 1 y\in R^1 yR1, z ∈ R m z\in R^m zRm, x ∈ R n x\in R^n xRn, z = g ( x ) z=g(x) z=g(x),y=f(z):
    d y d x = ( d z d x ) T d y d z (1-5) \frac{dy}{dx}=\left(\frac{dz}{dx}\right)^T\frac{dy}{dz}\tag{1-5} dxdy=(dxdz)Tdzdy(1-5)
    可以从向量矩阵的维度适配上去理解和记忆,因为 d y d x ∈ R n \frac{dy}{dx}\in R^n dxdyRn, d y d z ∈ R m \frac{dy}{dz}\in R^m dzdyRm, d z d x ∈ R m × n \frac{dz}{dx}\in R^{m\times n} dxdzRm×n,所以必须有上述的公式才能适配。
  3. 假设 y ∈ R k y\in R^k yRk, z ∈ R m z\in R^m zRm, x ∈ R 1 x\in R^1 xR1, z = g ( x ) z=g(x) z=g(x),y=f(z):
    d y d x = d y d z d z d x (1-6) \frac{dy}{dx}=\frac{dy}{dz}\frac{dz}{dx}\tag{1-6} dxdy=dzdydxdz(1-6)
  4. 假设 y ∈ R k y\in R^k yRk, z ∈ R m z\in R^m zRm, x ∈ R n x\in R^n xRn, z = g ( x ) z=g(x) z=g(x),y=f(z):
    d y d x = d y d z d z d x (1-7) \frac{dy}{dx}=\frac{dy}{dz}\frac{dz}{dx}\tag{1-7} dxdy=dzdydxdz(1-7)

2. pytorch求变量导数的过程

在pytorch和TensorFlow中,是不支持张量对张量的求导。这不是因为数学上没法求,而是因为工程实现上比较麻烦。因为向量对向量求导是个矩阵,二阶张量(矩阵)对二阶张量(矩阵)求导得到一个四阶张量,这样很容易会产生阶数爆炸。所以pytorch和TensorFlow(猜测其他深度学习框架也是这样)对外的接口干脆不支持张量对张量求导。如果遇到张量对张量求导的情况,例如向量对向量求导的情况,需要对因变量乘以一个维度一样的向量,转换为标量对向量的求导,这样可以大大减少计算量(具体见后文)。并且,因为pytorch和TensorFlow是为了机器学习/深度学习模型设计的,机器学习/深度模型的求导基本上都是损失函数(标量)对参数的求导,很少直接用到向量对向量求导,因此上述过程是有实际意义和需求的。

假设有一个三维tensor x = [ x 1 , x 2 , x 3 ] T = [ 1 , 2 , 3 ] T x=[x_1,x_2,x_3]^T=[1,2,3]^T x=[x1,x2,x3]T=[1,2,3]T,另一个三维tensor y:
y = f ( x ) = [ x 1 3 + 2 x 2 2 + 3 x 3 3 x 1 + 2 x 2 2 + x 3 3 2 x 1 + x 2 3 + 3 x 3 2 ] (2-1) y=f(x)= \begin{bmatrix} {x_1}^3+2{x_2}^2+3x_3 \\ 3x_1+2{x_2}^2+{x_3}^3\\ 2x_1+{x_2}^3+3{x_3}^2 \end{bmatrix} \tag{2-1} y=f(x)=x13+2x22+3x33x1+2x22+x332x1+x23+3x32(2-1)
那么在计算y相对于x的导数时,
d y d x = [ 3 x 1 2 , 4 x 2 , 3 3 , 4 x 2 , 3 x 3 2 2 , 3 x 2 2 , 6 x 3 ] (2-2) \frac{dy}{dx}= \begin{bmatrix} &3{x_1}^2,&4x_2,&3 \\ &3,&4{x_2},&3{x_3}^2\\ &2,&3{x_2}^2,&6{x_3} \end{bmatrix} \tag{2-2} dxdy=3x12,3,2,4x2,4x2,3x22,33x326x3(2-2)
在pytorch中实际计算时,不能直接用y对x求导,需要先用一个向量 w w w左乘y,再转置。例如, w T = [ 3 , 2 , 1 ] w^T=[3,2,1] wT=[3,2,1]。因此,pytorch算的其实是:
d y T d x w = ( w T d y d x ) T = [ 17 52 81 ] (2-3) \frac{dy^T}{dx}w= \left(w^T\frac{dy}{dx}\right)^T =\begin{bmatrix} 17\\ 52\\ 81\\ \end{bmatrix} \tag{2-3} dxdyTw=(wTdxdy)T=175281(2-3)
w w w可以理解为是对 [ ∂ y 1 ∂ x , ∂ y 2 ∂ x , ∂ y 3 ∂ x ] T [\frac{\partial y_1}{\partial x},\frac{\partial y_2}{\partial x},\frac{\partial y_3}{\partial x}]^T [xy1,xy2,xy3]T的权重参数。因此我们得到的是y的各个分量的导数的加权求和。

代码如下:

import torch
x1=torch.tensor(1, requires_grad=True, dtype = torch.float)
x2=torch.tensor(2, requires_grad=True, dtype = torch.float)
x3=torch.tensor(3, requires_grad=True, dtype = torch.float)
y=torch.randn(3)
y[0]=x1**3+2*x2**2+3*x3
y[1]=3*x1+2*x2**2+x3**3
y[2]=2*x1+x2**3+3*x3**2
v=torch.tensor([3,2,1],dtype=torch.float)
y.backward(v)
print(x1.grad)
print(x2.grad)
print(x3.grad)

利用链式求导的原理来理解,可以理解为 w w w是(远方)某个标量对 y y y的导数。pytorch之所以要这么设计,是因为在机器学习/深度学习模型中,求导的最终目的一般是为了让损失函数最小。损失函数一般都是一个标量,因此无论链式求导的过程多么复杂,中间过程也许有很多向量对向量求导的子过程,但是最开始一定会有一个标量(损失函数)对向量的求导过程,这个导数就是前面的 w w w

下面看一个带两个隐藏层的神经网络解决线性回归问题的例子,来进一步说明这点。
为了简单起见,考虑batch_size=1的情况。设输入数据为 x = [ x 1 , x 2 ] T x=[x_1,x_2]^T x=[x1,x2]T,输入层到第一个隐藏层的权重矩阵为
W = [ w 1 T w 2 T ] = [ w 11 , w 12 w 21 , w 22 ] (2-4) W=\begin{bmatrix} w_1^T\\ w_2^T \end{bmatrix} = \begin{bmatrix} w_{11},w_{12}\\ w_{21},w_{22}\\ \end{bmatrix} \tag{2-4} W=[w1Tw2T]=[w11,w12w21,w22](2-4)
第一个隐藏层的值为 z = [ z 1 , z 2 ] T z=[z_1,z_2]^T z=[z1,z2]T,
第一个隐藏层到第二个隐藏层的权重矩阵为
U = [ u 1 T u 2 T ] = [ u 11 , u 12 u 21 , u 22 ] (2-5) U=\begin{bmatrix} u_1^T\\ u_2^T \end{bmatrix} = \begin{bmatrix} u_{11},u_{12}\\ u_{21},u_{22}\\ \end{bmatrix} \tag{2-5} U=[u1Tu2T]=[u11,u12u21,u22](2-5)
第二个隐藏层的值为 s = [ s 1 , s 2 ] T s=[s_1,s_2]^T s=[s1,s2]T,
输出层的值为 y y y,隐藏层到输出层的权重参数为 v = [ v 1 , v 2 ] T v=[v_1,v_2]^T v=[v1,v2]T。则有:
z = [ z 1 z 2 ] = [ w 11 , w 12 w 21 , w 22 ] [ x 1 x 2 ] = [ w 11 x 1 + w 12 x 2 w 21 x 1 + w 22 x 2 ] (2-6) z=\begin{bmatrix} z_1\\ z_2\\ \end{bmatrix}= \begin{bmatrix} w_{11},w_{12}\\ w_{21},w_{22}\\ \end{bmatrix}\begin{bmatrix} x_1\\ x_2\\ \end{bmatrix}= \begin{bmatrix} w_{11}x_1+w_{12}x_2\\ w_{21}x_1+w_{22}x_2\\ \end{bmatrix}\tag{2-6} z=[z1z2]=[w11,w12w21,w22][x1x2]=[w11x1+w12x2w21x1+w22x2](2-6)

s = [ s 1 s 2 ] = [ u 11 , u 12 u 21 , u 22 ] [ z 1 z 2 ] = [ u 11 ( w 11 x 1 + w 12 x 2 ) + u 12 ( w 21 x 1 + w 22 x 2 ) u 21 ( w 11 x 1 + w 12 x 2 ) + u 22 ( w 21 x 1 + w 22 x 2 ) ] (2-7) \begin{aligned} s&=\begin{bmatrix} s_1\\ s_2\\ \end{bmatrix}= \begin{bmatrix} u_{11},u_{12}\\ u_{21},u_{22}\\ \end{bmatrix}\begin{bmatrix} z_1\\ z_2\\ \end{bmatrix}\\ &= \begin{bmatrix} u_{11}(w_{11}x_1+w_{12}x_2)+u_{12}(w_{21}x_1+w_{22}x_2)\\ u_{21}(w_{11}x_1+w_{12}x_2)+u_{22}(w_{21}x_1+w_{22}x_2)\\ \end{bmatrix}\tag{2-7} \end{aligned} s=[s1s2]=[u11,u12u21,u22][z1z2]=[u11(w11x1+w12x2)+u12(w21x1+w22x2)u21(w11x1+w12x2)+u22(w21x1+w22x2)](2-7)

y = [ v 1 , v 2 ] [ s 1 s 2 ] = ( v 1 u 11 x 1 + v 2 u 21 x 1 ) w 11 + ( v 1 u 11 x 2 + v 2 u 21 x 2 ) w 12 + ( v 1 u 12 x 1 + v 2 u 22 x 1 ) w 21 + ( v 1 u 12 x 2 + v 2 u 22 x 2 ) w 22 (2-8) \begin{aligned} y&= [v_1,v_2]\begin{bmatrix} s_1\\ s_2\\ \end{bmatrix}\\ &=(v_1u_{11}x_1+v_2u_{21}x_1)w_{11}\\ &+(v_1u_{11}x_2+v_2u_{21}x_2)w_{12}\\ &+(v_1u_{12}x_1+v_2u_{22}x_1)w_{21}\\ &+(v_1u_{12}x_2+v_2u_{22}x_2)w_{22} \end{aligned}\tag{2-8} y=[v1,v2][s1s2]=(v1u11x1+v2u21x1)w11+(v1u11x2+v2u21x2)w12+(v1u12x1+v2u22x1)w21+(v1u12x2+v2u22x2)w22(2-8)
损失函数为 L = ( y − y ^ ) 2 / 2 L=(y-\hat y)^2/2 L=(yy^)2/2
则损失函数关于权重参数 w 1 w_1 w1的导数为:
d L d w 1 = ( y − y ^ ) d y d x = ( y − y ^ ) d s T d x d y d s = ( y − y ^ ) d z T d x d s T d z d y d s = ( y − y ^ ) [ x 1 , 0 x 2 , 0 ] [ u 11 , u 21 u 12 , u 22 ] [ v 1 v 2 ] = ( y − y ^ ) [ v 1 x 1 u 11 + v 2 x 1 u 21 v 1 x 2 u 11 + v 2 x 2 u 21 ] (2-9) \begin{aligned} \frac{dL}{dw_1}&=(y-\hat y)\frac{dy}{dx}\\ &=(y-\hat y)\frac{ds^T}{dx}\frac{dy}{ds}\\ &=(y-\hat y)\frac{dz^T}{dx}\frac{ds^T}{dz}\frac{dy}{ds}\\ &=(y-\hat y)\begin{bmatrix} x_1,0\\ x_2,0\\ \end{bmatrix} \begin{bmatrix} u_{11},u_{21}\\ u_{12},u_{22}\\ \end{bmatrix} \begin{bmatrix} v_1\\ v_2 \end{bmatrix}\\ &=(y-\hat y)\begin{bmatrix} v_1x_1u_{11}+v_2x_1u_{21}\\ v_1x_2u_{11}+v_2x_2u_{21} \end{bmatrix}\\ \end{aligned}\tag{2-9} dw1dL=(yy^)dxdy=(yy^)dxdsTdsdy=(yy^)dxdzTdzdsTdsdy=(yy^)[x1,0x2,0][u11,u21u12,u22][v1v2]=(yy^)[v1x1u11+v2x1u21v1x2u11+v2x2u21](2-9)
可以验证 ( 2 − 9 ) (2-9) (29)和前面 ( 2 − 8 ) (2-8) (28)中直接求得的导数值是一样的。
这里发现了一个小彩蛋:
假设在pytorch的底层实现中,如果从左往右计算,则需要进行进行大量的矩阵乘法。如果有n个 2 × 2 2\times 2 2×2的方阵相乘,那么需要进行 4 × ( n − 1 ) 4\times (n-1) 4×(n1)次内积。如果从又往左计算,只需要进行 2 × n 2\times n 2×n次内积。

这篇关于pytorch教程之自动求导机制(AUTOGRAD)-从梯度和Jacobian矩阵讲起的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!



http://www.chinasem.cn/article/868652

相关文章

idea中创建新类时自动添加注释的实现

《idea中创建新类时自动添加注释的实现》在每次使用idea创建一个新类时,过了一段时间发现看不懂这个类是用来干嘛的,为了解决这个问题,我们可以设置在创建一个新类时自动添加注释,帮助我们理解这个类的用... 目录前言:详细操作:步骤一:点击上方的 文件(File),点击&nbmyHIgsp;设置(Setti

MySQL Workbench 安装教程(保姆级)

《MySQLWorkbench安装教程(保姆级)》MySQLWorkbench是一款强大的数据库设计和管理工具,本文主要介绍了MySQLWorkbench安装教程,文中通过图文介绍的非常详细,对大... 目录前言:详细步骤:一、检查安装的数据库版本二、在官网下载对应的mysql Workbench版本,要是

通过Docker Compose部署MySQL的详细教程

《通过DockerCompose部署MySQL的详细教程》DockerCompose作为Docker官方的容器编排工具,为MySQL数据库部署带来了显著优势,下面小编就来为大家详细介绍一... 目录一、docker Compose 部署 mysql 的优势二、环境准备与基础配置2.1 项目目录结构2.2 基

Linux安装MySQL的教程

《Linux安装MySQL的教程》:本文主要介绍Linux安装MySQL的教程,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录linux安装mysql1.Mysql官网2.我的存放路径3.解压mysql文件到当前目录4.重命名一下5.创建mysql用户组和用户并修

使用PyTorch实现手写数字识别功能

《使用PyTorch实现手写数字识别功能》在人工智能的世界里,计算机视觉是最具魅力的领域之一,通过PyTorch这一强大的深度学习框架,我们将在经典的MNIST数据集上,见证一个神经网络从零开始学会识... 目录当计算机学会“看”数字搭建开发环境MNIST数据集解析1. 认识手写数字数据库2. 数据预处理的

一文详解SQL Server如何跟踪自动统计信息更新

《一文详解SQLServer如何跟踪自动统计信息更新》SQLServer数据库中,我们都清楚统计信息对于优化器来说非常重要,所以本文就来和大家简单聊一聊SQLServer如何跟踪自动统计信息更新吧... SQL Server数据库中,我们都清楚统计信息对于优化器来说非常重要。一般情况下,我们会开启"自动更新

Pytorch微调BERT实现命名实体识别

《Pytorch微调BERT实现命名实体识别》命名实体识别(NER)是自然语言处理(NLP)中的一项关键任务,它涉及识别和分类文本中的关键实体,BERT是一种强大的语言表示模型,在各种NLP任务中显著... 目录环境准备加载预训练BERT模型准备数据集标记与对齐微调 BERT最后总结环境准备在继续之前,确

最新Spring Security实战教程之Spring Security安全框架指南

《最新SpringSecurity实战教程之SpringSecurity安全框架指南》SpringSecurity是Spring生态系统中的核心组件,提供认证、授权和防护机制,以保护应用免受各种安... 目录前言什么是Spring Security?同类框架对比Spring Security典型应用场景传统

最新Spring Security实战教程之表单登录定制到处理逻辑的深度改造(最新推荐)

《最新SpringSecurity实战教程之表单登录定制到处理逻辑的深度改造(最新推荐)》本章节介绍了如何通过SpringSecurity实现从配置自定义登录页面、表单登录处理逻辑的配置,并简单模拟... 目录前言改造准备开始登录页改造自定义用户名密码登陆成功失败跳转问题自定义登出前后端分离适配方案结语前言

Centos环境下Tomcat虚拟主机配置详细教程

《Centos环境下Tomcat虚拟主机配置详细教程》这篇文章主要讲的是在CentOS系统上,如何一步步配置Tomcat的虚拟主机,内容很简单,从目录准备到配置文件修改,再到重启和测试,手把手带你搞定... 目录1. 准备虚拟主机的目录和内容创建目录添加测试文件2. 修改 Tomcat 的 server.X