【偷偷卷死小伙伴Pytorch20天day06自动微分机制】

神经网络通常依赖反向传播求梯度来更新网络参数&＃xff0c;求梯度过程通常是一件非常复杂而容易出错的事情。而深度学习框架可以帮助我们自动地完成这种求梯度运算。 Pytorch一般通过反向传播 backward 方法 实现这种求梯度计算。该方法求得的梯度将存在对应自变量张量的grad属性下。 除此之外&＃xff0c;也能够调用torch.autograd.grad 函数来实现求梯度计算。这就是Pytorch的自动微分机制。

一、利用backward方法求导数

backward 方法通常在一个标量张量上调用&＃xff0c;该方法求得的梯度将存在对应自变量张量的grad属性下。

如果调用的张量非标量&＃xff0c;则要传入一个和它同形状 的gradient参数张量。

相当于用该gradient参数张量与调用张量作向量点乘&＃xff0c;得到的标量结果再反向传播。

1.标量的反向传播

import numpy as np
import torch # f(x) &＃61; a*x**2 &＃43; b*x &＃43; c的导数x &＃61; torch.tensor(0.0,requires_grad &＃61; True) # x需要被求导
a &＃61; torch.tensor(1.0)
b &＃61; torch.tensor(-2.0)
c &＃61; torch.tensor(1.0)
y &＃61; a*torch.pow(x,2) &＃43; b*x &＃43; c y.backward()
dy_dx &＃61; x.grad
print(dy_dx)


2. 非标量的反向传播

import numpy as np
import torch # f(x) &＃61; a*x**2 &＃43; b*x &＃43; cx &＃61; torch.tensor([[0.0,0.0],[1.0,2.0]],requires_grad &＃61; True) # x需要被求导
a &＃61; torch.tensor(1.0)
b &＃61; torch.tensor(-2.0)
c &＃61; torch.tensor(1.0)
y &＃61; a*torch.pow(x,2) &＃43; b*x &＃43; c gradient &＃61; torch.tensor([[1.0,1.0],[1.0,1.0]])print("x:\n",x)
print("y:\n",y)
y.backward(gradient &＃61; gradient)
x_grad &＃61; x.grad
print("x_grad:\n",x_grad)


3.非标量的反向传播可以用标量的反向传播实现

import numpy as np
import torch # f(x) &＃61; a*x**2 &＃43; b*x &＃43; cx &＃61; torch.tensor([[0.0,0.0],[1.0,2.0]],requires_grad &＃61; True) # x需要被求导
a &＃61; torch.tensor(1.0)
b &＃61; torch.tensor(-2.0)
c &＃61; torch.tensor(1.0)
y &＃61; a*torch.pow(x,2) &＃43; b*x &＃43; c gradient &＃61; torch.tensor([[1.0,1.0],[1.0,1.0]])
z &＃61; torch.sum(y*gradient)print("x:",x)
print("y:",y)
z.backward()
x_grad &＃61; x.grad
print("x_grad:\n",x_grad)


二、利用autograd.grad方法求导数

import numpy as np
import torch # f(x) &＃61; a*x**2 &＃43; b*x &＃43; c的导数x &＃61; torch.tensor(0.0,requires_grad &＃61; True) # x需要被求导
a &＃61; torch.tensor(1.0)
b &＃61; torch.tensor(-2.0)
c &＃61; torch.tensor(1.0)
y &＃61; a*torch.pow(x,2) &＃43; b*x &＃43; c# create_graph 设置为 True 将允许创建更高阶的导数
dy_dx &＃61; torch.autograd.grad(y,x,create_graph&＃61;True)[0]
print(dy_dx.data)# 求二阶导数
dy2_dx2 &＃61; torch.autograd.grad(dy_dx,x)[0] print(dy2_dx2.data)


import numpy as np
import torch x1 &＃61; torch.tensor(1.0,requires_grad &＃61; True) # x需要被求导
x2 &＃61; torch.tensor(2.0,requires_grad &＃61; True)y1 &＃61; x1*x2
y2 &＃61; x1&＃43;x2# 允许同时对多个自变量求导数
(dy1_dx1,dy1_dx2) &＃61; torch.autograd.grad(outputs&＃61;y1,inputs &＃61; [x1,x2],retain_graph &＃61; True)
print(dy1_dx1,dy1_dx2)# 如果有多个因变量&＃xff0c;相当于把多个因变量的梯度结果求和
(dy12_dx1,dy12_dx2) &＃61; torch.autograd.grad(outputs&＃61;[y1,y2],inputs &＃61; [x1,x2])
print(dy12_dx1,dy12_dx2)


三、利用自动微分和优化器求最小值

神经网络优化器&＃xff0c;主要是为了优化我们的神经网络&＃xff0c;使他在我们的训练过程中快起来&＃xff0c;节省社交网络训练的时间。在pytorch中提供了torch.optim方法优化我们的神经网络&＃xff0c;torch.optim是实现各种优化算法的包。

torch.optim.SGD

SGD是最基础的优化方法&＃xff0c;普通的训练方法, 需要重复不断的把整套数据放入神经网络NN中训练, 这样消耗的计算资源会很大.当我们使用SGD会把数据拆分后再分批不断放入 NN 中计算. 每次使用批数据, 虽然不能反映整体数据的情况, 不过却很大程度上加速了 NN 的训练过程, 而且也不会丢失太多准确率.

import numpy as np
import torch # f(x) &＃61; a*x**2 &＃43; b*x &＃43; c的最小值x &＃61; torch.tensor(0.0,requires_grad &＃61; True) # x需要被求导
a &＃61; torch.tensor(1.0)
b &＃61; torch.tensor(-2.0)
c &＃61; torch.tensor(1.0)optimizer &＃61; torch.optim.SGD(params&＃61;[x],lr &＃61; 0.01)def f(x):result &＃61; a*torch.pow(x,2) &＃43; b*x &＃43; c return(result)for i in range(500):optimizer.zero_grad()y &＃61; f(x)y.backward()optimizer.step()print("y&＃61;",f(x).data,";","x&＃61;",x.data)