torch.nn和torch.autograd

扩展torch.autograd

如果想要添加一个新的Operation 到autograd的话，我们的operation需要继承class Function. autograd使用Function计算结果和梯度，同时编码operation的历史。

Function一般只定义一个操作，并且它无法保存参数，一般适用于激活函数，pooling等，它需要定义三个方法，init(),forward(),backward()（需要自己定义求导规则）

torch.nn.Module和torch.autograd.Function是为pytorch提供自定义拓展的两种途径。

（1）途径一：通过继承torch.nn.Module类来实现拓展。这也是最常见的，在自定义模块中只需要定义构造函数和前向传播即可，即可自动求导。它最大的特点是以下几点：

        包装torch普通函数和torch.nn.functional专用于神经网络的函数；（torch.nn.functional是专门为神经网络所定义的函数集合）
        只需要重新实现__init__和forward函数，求导的函数是不需要设置的，会自动按照求导规则求导(Module类里面是没有定义backward这个函数的）
        可以保存参数和状态信息；

（2）方式二：通过继承torch.nn.Function类来实现拓展。它最大的特点是：

        在有些操作通过组合pytorch中已有的层或者是已有的方法实现不了的时候，比如你要实现一个新的方法，这个新的方法需要forward和backward一起写，然后自己写对中间变量的操作。
        需要重新实现__init__和forward函数，以及backward函数，需要自己定义求导规则；
        不可以保存参数和状态信息

总结： 当不使用自动求导机制，需要自定义求导规则的时候，就应该拓展torch.autograd.Function类。 否则就是用torch.nn.Module类，后者更简单更常用。

所以说nn.function 更加底层，来看一个例子，使用autograd.Function 定义新的自动求导函数

 

在底层，每一个原始的自动求导运算实际上是两个在Tensor上运行的函数。其中，forward函数计算从输入Tensors获得的输出Tensors。而backward函数接收输出Tensors对于某个标量值的梯度，并且计算输入Tensors相对于该相同标量值的梯度。

在PyTorch中，我们可以很容易地通过定义torch.autograd.Function的子类并实现forward和backward函数，来定义自己的自动求导运算。之后我们就可以使用这个新的自动梯度运算符了。然后，我们可以通过构造一个实例并像调用函数一样，传入包含输入数据的tensor调用它，这样来使用新的自动求导运算。

这个例子中，我们自定义一个自动求导函数来展示ReLU的非线性。并用它实现我们的两层网络：
————————————————

 
import torch
 
class MyReLU(torch.autograd.Function):
"""
我们可以通过建立torch.autograd的子类来实现我们自定义的autograd函数，
并完成张量的正向和反向传播。
"""
@staticmethod      ##静态方法：https://www.runoob.com/python/python-func-staticmethod.html
def forward(ctx, x):
"""
在正向传播中，我们接收到一个上下文对象和一个包含输入的张量；
我们必须返回一个包含输出的张量，
并且我们可以使用上下文对象来缓存对象，以便在反向传播中使用。
"""
#ctx.save_for_backward类似于ctx.input = input     ctx 相当于 class 中的 self
#参考：https://www.zhihu.com/question/366882609
ctx.save_for_backward(x)  
return x.clamp(min=0)     #截断  限制梯度最小值为非负
 
@staticmethod
def backward(ctx, grad_output):      #ctx 相当于 class 中的 self
"""
在反向传播中，我们接收到上下文对象和一个张量，
其包含了相对于正向传播过程中产生的输出的损失的梯度。
我们可以从上下文对象中检索缓存的数据，
并且必须计算并返回与正向传播的输入相关的损失的梯度。
"""
x, = ctx.saved_tensors          #data 
grad_x = grad_output.clone()    #grad
grad_x[x < 0] = 0               #截断
return grad_x                   #返回梯度
 
 
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
 
# N是批大小；D_in 是输入维度；
# H 是隐藏层维度；D_out 是输出维度
N, D_in, H, D_out = 64, 1000, 100, 10
 
# 产生输入和输出的随机张量
x = torch.randn(N, D_in, device=device)
y = torch.randn(N, D_out, device=device)
 
# 产生随机权重的张量
w1 = torch.randn(D_in, H, device=device, requires_grad=True)
w2 = torch.randn(H, D_out, device=device, requires_grad=True)
 
learning_rate = 1e-6
for t in range(500):
# 正向传播：使用张量上的操作来计算输出值y；
# 我们通过调用 MyReLU.apply 函数来使用自定义的ReLU
y_pred = MyReLU.apply(x.mm(w1)).mm(w2)
 
# 计算并输出loss
loss = (y_pred - y).pow(2).sum()
print(t, loss.item())
 
# 使用autograd计算反向传播过程。
loss.backward()
 
with torch.no_grad():   #这里在自己实现更新w1和w2，因此放到no_grad()里不跟踪计算梯度。
                        #由于这个阶段的optimizer是你自己写的SGD，只需要进行数值计算，不需要创建计算图 
                        #目的：在autograd里不跟踪这次 weight - grad的运算。 https://www.zhihu.com/question/326044178?sort=created
# 用梯度下降更新权重
w1 -= learning_rate * w1.grad
w2 -= learning_rate * w2.grad
 
# 在反向传播之后手动清零梯度
w1.grad.zero_()
w2.grad.zero_()

 

 

原文链接：https://blog.csdn.net/qq_27825451/article/details/102517406

                  https://blog.csdn.net/qq_27825451/article/details/95189376
                  https://www.jianshu.com/p/e39de662b30f