反向传播与参数更新的理解

首先，反向传播或许被称为“反向求导”更加合适，因为它只是个求导的过程，即计算中间参数的梯度。在PyTorch中，通过 loss.backward() 进行反向求导，关于 loss.backward() 有两点需要注意：【1】loss是标量（零维张量），只有标量才能直接使用 backward() ；【2】 loss.backward() 的完整写法是 loss.backward(retain_graph=False) ，其中的形参 retain_graph 的意义在于是否保留计算图，默认为False，即在反向传播后，自动释放当前计算图，节省资源的同时，为下一次反向传播做好准备。
一般情况下是每次迭代，只需一次 forward() 和一次 backward() 。但是不排除， 由于自定义 loss 等有多个，网络需要计算多个不同 loss 的 backward() 产生的梯度，来更新参数 。于是，如果在当前 loss.backward() 后，还需要执行其他 loss 的 backward() ，那么就需要在当前的 loss.backward() 时，指定保留计算图，即 loss.backward(retain_graph=True) 。
需要特别注意的是， 反向传播求导与网络参数更新是两个不同的过程 。必须要先反向求导，再进行参数更新，其代码逻辑大致如下：

loss.backward() # 先在构建好的计算图进行反向传播，计算中间变量的梯度，计算完后，立即释放计算图
optimizer.step() # 根据计算好的梯度，进行网络的参数更新
计算图的概念
 
  计算图可以说是输入变量一直到输出变量的逻辑运算关系，是模型前向forward() 和后向求梯度backward() 的流程参照。这里需要注意的是，能获取回传梯度(grad)的只有计算图的叶节点（即输入节点，在loss.backward()后）。中间节点的梯度在计算求取并回传之后就会被释放掉，没办法获取。想要获取中间节点梯度，可以使用 register_hook （钩子）函数工具。当然， register_hook 不仅仅只有这个作用。 
网络中间变量的梯度
 
  如上所述，，能获取回传梯度(grad)的只有计算图的叶节点（即输入节点，在loss.backward()后）。中间节点的梯度在计算求取并回传之后就会被释放掉，没办法获取。想要获取中间节点梯度，可以使用 register_hook （钩子）函数工具。 
为什么需要optimizer.zero_grad()
 
  在编写Pytorch的训练代码时，下面一段代码是非常常见的： 
	for i in range(batch): # 在每个Batch都执行如下操作
		# zero the parameter gradients
        optimizer.zero_grad()
        # forward + backward + optimize
        outputs = net(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
  在这里明确一下zero_grad()函数的作用以及为什么需要在每个batch都执行该操作：根据pytorch中backward()函数的计算，当进行求导时，梯度是累积计算而不是被替换，但在处理每一个batch时并不需要与其他batch的梯度混合起来累积计算，因此需要对每个batch调用一遍zero_grad()将当前可变参数的梯度置0。
   当然，我们也可以不选择每个batch都清除一次梯度，比如两次或多次再清除一次，这样相当于提高了batch_size，对GPU的内存需要更高。 
detach()的理解
 
  detach() ，如果 x 为中间输出，x_1 = x.detach 表示创建一个与 x 相同，但requires_grad==False 的新Tensor (相当于是把x_1以前的计算图 grad_fn 都消除了)，x_1也就成了叶节点（输入节点）。原先反向传播时，回传到x时还会继续，而现在回到x_1处后，就结束了，不继续回传求导了，在x之前的网络参数也就不再进行更新了。另外值得注意的是detach_() 表示不创建新张量，而是直接修改 x 本身。 
requires_grad和volatile的理解
 
  如果对于张量 x ，如果 x.requires_grad == True , 则表示它可以参与求导，也可以从它向后求导。默认情况下，一个新的Tensor的 requires_grad 为False。
   可以向后求导的意思是说，requires_grad == True 具有传递性，如果： 
x.requires_grad == True 
y.requires_grad == False  
z = f(x,y)
则z.requires_grad == True，注意requires_grad == False 则不具有传递性，在PyTorch中，凡是参与运算的变量（包括输入、输出、中间输出、网络权重参数等），都可以设置requires_grad。但是一般来说，输入是否含requires_grad=True是无所谓的，因为需要更新的是网络权重的参数，如果通过nn方法调用卷积层等，会默认其中的参数的requires_grad=True。当然，设置输入的requires_grad=True会更保险，但是可能会带来一些计算和内存上的代价。
   volatile在PyTorch1.0版本后已经被移除了。实际上，volatile==True 就等价于 requires_grad==False 。 volatile==True 同样具有传递性。一般只用在推理过程中。若是从某个中间输出x张量 开始都只需做推理，而不需反传梯度的话，那么只需设置x.volatile=True ，那么 x 以后的运算过程得到的输出张量均为 volatile==True ，即它们的 requires_grad==False 。
   虽然推理过程不必backward(),所以requires_grad 的值为False 或 True，对结果是没有影响的，但是对程序的运算效率有直接影响；所以使用volatile=True，就不必把运算过程中所有参数都手动设一遍requires_grad=False了，它所诞生的目的就相当于使requires_grad==False也具有传递性，方便快捷。
   在PyTorch1.0版本后，用with no_grad来代替volatile。 
当有多个Loss时，如何计算梯度与更新网络参数
 
  神经网络通常有多个损失函数组成，那么如何计算多个Loss的梯度呢？若计算不同Loss的中间张量相同，那么就可以累加再计算梯度，或者分别计算但要保留计算图，但不同网络更新参数要求不同，若计算不同Loss的中间张量不同，那么就不可以累加计算梯度。
   我们以VAE-GAN为例，从理论上来说，VAE-GAN的损失函数 
当模型由多个网络组成时，如何计算梯度与更新网络参数
 
tensor[1.]和tensor[1]的区别
 
  从数值大小来说，二者完全相同，都代表1。只是数据类型不一样，即前者为浮点型，后者为整型。 
nn.Module的理解
 
  Module作为torch.nn的核心数据结构，它是一个抽象的概念，既可以表示神经网络中的某个层，也可以表示一个包含很多层的神经网络。在实际中，我们最常用的做法就是继承nn.Module，来撰写自己的网络层。 
它与nn.Parameter数据类型紧密相关
 
  Parameter可以被视作加强版的Tensor，它有如下加强属性：
   【1】Parameters 与 nn.Module 一起使用时会有一些特殊的属性：Parameters会被自动加到 Module 的parameters() 迭代器中；
   【2】Parameters 不能被 volatile, 而且默认设置 requires_grad=True，即默认可学习。
   它的使用很简单：torch.nn.Parameter(data, requires_grad)，其中的data为tensor，requires_grad默认为True，在BP过程中会自动微分。 
>> custom_para=torch.nn.Parameter(data=torch.Tensor([1]),requires_grad=True) # 建立一个Parameter数据
>> custom_para
Parameter containing:
[torch.FloatTensor of size 1]
是所有网络层的基类
 

   torch.nn.Module的所有功能如上图所示，所有功能都可以函数的形式被调用，用法形如model.cuda()、model.modules()等，图片出处来自pytorch 入坑三：nn module。nn.Module运行时以树结构作为嵌入，允许包含其他Module，下面的代码中，基于torch.nn.Module的self.conv1 , self.conv2是整个基于torch.nn.Module的Model模型的子模型。 
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module): def __init__(self):
        super(Model, self).__init__()
        self.conv1 = nn.Conv2d(1, 20, 5) # submodule: Conv2d，子模块1
        self.conv2 = nn.Conv2d(20, 20, 5) # 子模块2
    def forward(self, x):
       x = F.relu(self.conv1(x))
       return F.relu(self.conv2(x))
nn.Module的核心功能
 
  【1】add_module(name,module) ：将子模块加入当前的模块中，被添加的模块可以通过访问name名称获取，示例程序如下，与直接写子模块等价： 
import torch.nn as nn
class Model(nn.Module): def __init__(self):
        super(Model, self).__init__()
        self.add_module("conv", nn.Conv2d(10, 20, 4))
        #self.conv = nn.Conv2d(10, 20, 4) 等同于上面这个增加module的方式！！！
>> model = Model()
>> print(model.conv)
Conv2d(10, 20, kernel_size=(4, 4), stride=(1, 1))
  【2】forward(*input) ：每次运行时都会执行的步骤，所有自定义的module都要重写这个函数
   【3】state_dict(destination=None)： 返回一个字典，保存module的所有状态
   【4】load_state_dict(state_dict)：用于加载保存好的模型的参数 
nn.Module的查看模块
 
  【1】parameters()：返回一个 包含模型所有参数 的迭代器，一般用作optimizer中的形参，如g_optimizer = optim.Adam(G.parameters(), lr=0.0001)中的G.parameters()。 
  【2】children()： 返回一个包含当前模型下一层子模块的迭代器。
   【3】name_children(): 返回一个包含当前模型子模块的迭代器，并列出模块名字和模块本身。 
  【4】modules(): 返回一个包含当前模型 所有模块的迭代器。
   【5】named_modules(): 返回包含网络中所有模块的迭代器, 并列出模块名和模块本身。 
注：modules()返回的iterator不止包含子模块，还会包含子模块中的子模块，而children()只包含下一层子模块，这是区别
import torch.nn as nn
class Model(nn.Module): def __init__(self):
        super(Model, self).__init__()
        self.add_module("conv", nn.Conv2d(10, 20, 4))
        self.add_module("conv1", nn.Conv2d(20 ,10, 4))
>> model = Model()
>> for module in model.modules():
>>    print(module)
Model (
  (conv): Conv2d(10, 20, kernel_size=(4, 4), stride=(1, 1))
  (conv1): Conv2d(20, 10, kernel_size=(4, 4), stride=(1, 1))
Conv2d(10, 20, kernel_size=(4, 4), stride=(1, 1))
Conv2d(20, 10, kernel_size=(4, 4), stride=(1, 1))
>> for children in model.children():
>>    print(module)
Conv2d(10, 20, kernel_size=(4, 4), stride=(1, 1))
Conv2d(20, 10, kernel_size=(4, 4), stride=(1, 1))
nn.Modules的设置功能
 
  【1】train(mode=True)：将module设置为training模式，只影响Dropout和BatchNorm
   【2】eval()： 将模型设置成evaluation模式，只影响Dropout和BatchNorm
   【3】zero_grad()： 将module中的所有模型的梯度设置为0 
nn.Modules的注册功能
 
  这些功能比较偏向实现逻辑，在平常的程序中很难用到，但是对于Pytorch的实现原理至关重要。
   【1】register_parameter(name, param)：向module添加 parameter,可以通过name获取
   【2】register_forward_hook(hook)：在module上注册一个forward hook。 每次调用forward()计算输出的时候，这个hook就会被调用。　　　　
   【3】register_backward_hook(hook)：在module上注册一个bachward hook。每次计算module的inputs的梯度的时候，这个hook会被调用
   【4】register_buffer(name, tensor)：给module添加一个persistent buffer，通常用来保存一个不需要看成模型参数的状态 
nn.Sequential（）的使用
 
  当你使用nn.Sequential时，会按照以nn.Module为基类的网络层传入的顺序添加到你构建的模型中，也可以传入一个OrderedDict, 下面是个简单的例子：
   使用使用nn.Sequential的意义在于能方便、快捷地构建网络模型，不需要一个一个定义模型层。 
# Example of using Sequential
model = nn.Sequential(
          nn.Conv2d(1,20,5),
          nn.ReLU(),
          nn.Conv2d(20,64,5),
          nn.ReLU()
# Example of using Sequential with OrderedDict
model = nn.Sequential(OrderedDict([
          ('conv1', nn.Conv2d(1,20,5)),
          ('relu1', nn.ReLU()),
          ('conv2', nn.Conv2d(20,64,5)),
          ('relu2', nn.ReLU())
        ]))
nn.ModuleList（）的使用
 
nn.ParameterList（）的使用

                                    PyTorch 的构建者表明，Pytorch 的哲学是解决当务之急，也就是说即时构建和运行我们的计算图。这恰好适合 Python 的编程理念，一边定义就可以在 Jupyter Notebook 一边运行，因此，PyTorch 的工作流程非常接近于 Python 的科学计算库 NumPy。
TENSORS
PRODUCTION
ooooooooooooooo
WHO AM I
Christian S Perone
14 years working with machine
Learning, Data Science and Software
                                    点击上方“AI公园”，关注公众号，选择加“星标“或“置顶”作者：Vaibhav Kumar编译：ronghuaiyang导读这篇文章详细解析了PyTorch的自动求导机制...
                                    此文为学习"莫烦Python"的Pytorch笔记
2.2 Variable变量
神经网络中的参数都是变量的形式,参数的更新是以Variable为基础的;Variable 需要从torch.autograd导入.;误差传播是根据Variable搭建的图来进行计算的,require_grad=True才计算变量节点的梯度.tensor无法反向传播,Variable才可以反向传播.
import to...
                                    自动求导机制从后向中排除子图每个变量都有两个标志：requires_grad和volatile。它们都允许从梯度计算中精细地排除子图，并可以提高效率。requires_grad如果有一个单一的输入操作需要梯度，它的输出也需要梯度。相反，只有所有输入都不需要梯度，输出才不需要。如果其中所有的变量都不需要梯度进行，后向计算不会在子图中执行。>>> x = Variable(torch.randn(5,
                                    1.nn.Module类理解pytorch里面一切自定义操作基本上都是继承nn.Module类来实现的方法预览：classModule(object):def __init__(self):def forward(self, *input):defadd_module(self, name, module):def cuda(self, device=None):defcpu(self):def ...
                                    (如转载请注明出处)花了imagesoft一个上午时间，终于改好了，问题不在libtiff，而是opencv的问题，发现问题后在网上搜了一下，找不到原因，而同样的图象在freeimage和cximage都是能打开的。都是使用libtiff，没道理呀，下载最新的libtiff，覆盖进去重新生成dll，还是不行；这也难不倒我，从freeimage提取libtiff，覆盖，编译，运行，仍然不行。我晕
源代码来自官方实例库：
链接：https://github.com/open-mmlab/mmclassification
官方说明文档：https://mmclassification.readthedocs.io/en/latest/index.html
样例应用及修改方式：
1. 准备数据集
首先保证mmclassification文件夹下有以下文件夹
mmclassification
                                    前言：Pytorch是目前学术界使用较为广泛的一种深度学习框架，要想能够熟练使用这个工具，就需要对它有一个全面系统的了解，本专栏就是为了带领大家系统地梳理Pytorch工具中的一些重要知识点，欢迎各位读者批评指正。目录1、Pytorch的动态图机制 2、Pytorch结构分析2.1 torch2.2 torchvision      .........
                                    点击上方，选择星标或置顶，每天给你送干货！阅读大概需要27分钟跟随小博主，每天进步一丢丢编辑：机器学习与推荐系统原文出处:
https://archwalker.github.io译者序...
                                    首先 ：retain_variables=True 与 retain_graph=True   没有任何区别 
        只是 retain_variables 会在pytorch 新版本中被取消掉，将使用 retain_graph 。
        所以 在使用 retain_variables=True 时报错：
        TypeError: backward() got...
                                    今天来学习pytorch中有关自动求导模块中的**torch.autograd.backward()**函数的用法和其涉及到的数学原理
函数的作用
首先来看看官方文档中是如何描述这个函数的作用的
原话：Computes the sum of gradients of given tensors w.r.t. graph leaves.
个人翻译：计算那些有关图中叶子节点的tensors的...