精华内容
下载资源
问答
  • detach()、.data、with no_grad()、requires_grad之间关系 [@TOC](detach ()、.data、with no_grad()、requires_grad之间关系)

    最近在学习pytorch的时候,遇到了几个新知识点,弄得我头大(本身头大,但更大 ==!)

    • requires_grad属性
    • detach()
    • with no_grad()方法
    • data属性

    一直搞不明白这些东西到底有什么神奇的用法还有它们之间的关系;作为为什么大王我必须需总结一下,不然难受啊。

    一. requires_grad属性

    requires_grad

    官网说:If autograd should record operations on the returned tensor. Default: False.

    是否追踪在张量上计算的所有操作,默认值为False
    什么意思?直接上代码测试一下吧!

    1. requires_grad 的作用探讨

    # 测试一些什么都不做,查看计算的梯度
    import torch
    
    x = torch.tensor([1.0, 2.0])
    y1 = x ** 2
    y2 = y1 * 2
    y3 = y1 + y2
    
    print(y1, y1.requires_grad)
    print(y2, y2.requires_grad)
    print(y3, y3.requires_grad)
    
    # 为什么backward里面需要加一个torch.ones(y3.shape)?
    # 这是另外一个需要讨论的问题了可以在留言区一起讨论
    y3.backward(torch.ones(y3.shape))  # y1.backward() y2.backward()
    print(x.grad)
    
    
    # 结果:
    tensor([1., 4.]) False
    tensor([2., 8.]) False
    tensor([ 3., 12.]) False
    RuntimeError: element 0 of tensors does not require grad and does not have a grad_fn
    

    X的requires_grad设置为True之后则如下:

    # 设置好requires_grad的值为True
    import torch
    
    x = torch.tensor([1.0, 2.0], requires_grad=True)
    y1 = x ** 2
    y2 = y1 * 2
    y3 = y1 + y2
    
    print(y1, y1.requires_grad)
    print(y2, y2.requires_grad)
    print(y3, y3.requires_grad)
    
    y3.backward(torch.ones(y3.shape))  # y1.backward() y2.backward()
    print(x.grad)
    
    """
    结果:
    tensor([1., 4.], grad_fn=<PowBackward0>) True
    tensor([2., 8.], grad_fn=<MulBackward0>) True
    tensor([ 3., 12.], grad_fn=<AddBackward0>) True
    tensor([ 6., 12.])
    """
    

    此时的y1、y2、y3输出都多了一个属性参数值:
    例如:y1的grad_fn = <PowBackward0>,就表示y1的上一次计算操作为pow,即指数运算
    再回到我们的y1 = x ** 2 ,果然,正是如此。

    2. 结论:

    """
    1. 当grad_fn设置为Fasle或者默认时:计算梯度会出现如下错误
    RuntimeError: element 0 of tensors does not require grad and does not have a grad_fn
    因为并没有追踪到任何计算历史,所以就不存在梯度的计算了
    
    2. 因此在最开始定义x张量的时候,就应当设置好是否计算追踪历史计算记录
    """
    

    二. detach()方法

    detach():

    官网又说:Returns a new Tensor, detached from the current graph.The result will never require gradient.

    就是返回了一个新的张量,该张量与当前计算图完全分离。且该张量的计算将不会记录到梯度当中。
    上代码看看那啥意思吧!

    # 设置好requires_grad的值为True
    import torch
    
    x = torch.tensor([1.0, 2.0], requires_grad=True)
    y1 = x ** 2
    y2 = y1.detach() * 2     # 注意这里在计算y2的时候对y1进行了detach()
    y3 = y1 + y2
    
    print(y1, y1.requires_grad)
    print(y2, y2.requires_grad)
    print(y3, y3.requires_grad)
    
    
    y3.backward(torch.ones(y3.shape))  # y1.backward() y2.backward()
    print(x.grad)
    

    结果:

    tensor([1., 4.], grad_fn=<PowBackward0>) True
    tensor([2., 8.]) False
    tensor([ 3., 12.], grad_fn=<AddBackward0>) True
    tensor([2., 4.])
    
    
    """
    	根据结果可知y2所计算出来的张量,grad_fn属性没有被输出(其实为None),即不具有追踪能力了
    	而y1和y3都仍然显示出各自上一次的计算操作,但是最终计算出的x的梯度发生了变化
    """
    

    对比一下使用detach()前后的梯度值tensor([ 6., 12.])tensor([2., 4.])
    (1)tensor([ 6., 12.])

    y3 = y2 + y1,根据 y2 = y1*2, 而y1 = x ** 2
    所以y3 = 3x**2,    y3对xi的偏导则为6xi
    针对x = [1, 2]
    所以,对应的梯度(偏导)则为:[6, 12]
    

    (2)tensor([ 2., 4.])

    y3 = y2 + y1,因为y2是根据y1.detach()得到的;
    根据定义,所以计算梯度的时候不考虑y2,但是实际计算y3的值还是按原公式
    因此计算梯度时。y3 = y1 + (y2不考虑),所以y3 = x ** 2
    y3对xi的偏导则为2xi
    针对x = [1, 2]
    所以,对应的梯度(偏导)则为:[2, 4]
    

    总结一下detach()吧:
    当我们在计算到某一步时,不需要在记录某一个张量的时,就可以使用detach()将其从追踪记录当中分离出来,这样一来该张量对应计算产生的梯度就不会被考虑了。

    三. with torch.no_grad()

    torch.no_grad():

    官方还说:Disabling gradient calculation is useful for inference, when you are sure that you will not call :meth:Tensor.backward(). It will reduce memory consumption for computations that would otherwise have requires_grad=True.

    先理解为也是类似取消梯度计算的一种方式,可以减少内存消耗,还是看代码结果吧!

    # 设置好requires_grad的值为True
    import torch
    
    x = torch.tensor([1.0, 2.0], requires_grad=True)
    y1 = x ** 2
    
    with torch.no_grad():  # 这里使用了no_grad()包裹不需要被追踪的计算过程
        y2 = y1 * 2
        
    y3 = y1 + y2
    
    print(y1, y1.requires_grad)
    print(y2, y2.requires_grad)
    print(y3, y3.requires_grad)
    
    y3.backward(torch.ones(y3.shape))  # y1.backward() y2.backward()
    print(x.grad)
    

    计算结果:

    tensor([1., 4.], grad_fn=<PowBackward0>) True
    tensor([2., 8.]) False
    tensor([ 3., 12.], grad_fn=<AddBackward0>) True
    tensor([2., 4.])
    
    """
    	结果和detach()方法一致,就不在分析了
    """
    

    可想而知,实际上torch.no_grad()功能和detach()方法作用是一致的。
    有差区别?
    detach()是考虑将单个张量从追踪记录当中脱离出来;
    torch.no_grad()是一个warper,可以将多个计算步骤的张量计算脱离出去,本质上没啥区别。

    四. data属性

    写到这了,突然忘了一个重要的事情,detach()和data属性都是由tensor调用;
    那么它们返回值存在什么关系呢?

    # 设置好requires_grad的值为True
    import torch
    
    x = torch.tensor([1.0, 2.0], requires_grad=True)
    y1 = x ** 2
    
    print(y1)
    print(y1.data)
    print(y1.detach())
    print(id(y1), id(y1.data), id(y1.detach()))
    print(id(y1.storage()), id(y1.data.storage()), id(y1.detach().storage()))
    
    """
    	tensor([1., 4.], grad_fn=<PowBackward0>)
    	tensor([1., 4.])
    	tensor([1., 4.])
    	3092644292392 3092631327272 3092631327272
    	3092650494536 3092650494536 3092650494536
    """
    

    可以很清楚的看到:

    • y1.detach()y1.datay1指向的内存单元是一样的
    • y1.detach()y1.data返回的对象都是一样的

    表示我又乱了!

    另外,终于找到一个比较好的解释了:来自stackoverflow的解释1

    在这里插入图片描述
    简单翻译一下:data方法是Variable的一个属性,而Variable在0.4版本以前,好像是封装Tensor所有操作,并提供额外属性的一个类(具体我也没了解)。
    在Pytorch 0.4版本以后,VariableTensor进行了彻底的合并,因此.data也随着Variable一同消失了(尽管Variable仍然存在,并且向后兼容,但是已经被弃用了)。

    .data 是从 Variable 中获取底层 Tensor 的主要方式。 合并后,y = x.data得到的y是一个与x共享内存的Tensor,(前面也证实了内存地址不相同)并且 requires_grad = False,它与 x 的计算历史无关。

    当然,在某些情况下 .data 可能不安全。 对 x.data 的任何更改都不会被 autograd 跟踪,如果在反向过程中需要 x,那么计算出的梯度将不正确。另一种更安全的方法是使用 x.detach(),它将返回一个共享内存地址的 Tensor(requires_grad = False),但如果在反向过程中需要 x,那么 autograd 将会提示你已经修改了该张量。

    测试代码2如下:

    # tensor.data
    >>> a = torch.tensor([1, 2, 3.], requires_grad =True)
    >>> out = a.sigmoid()
    >>> c = out.data
    >>> c.zero_()
    tensor([ 0., 0., 0.])
    
    >>> out       #  因为内存共享,所以out的数值被c.zero_()修改
    tensor([ 0., 0., 0.])
    
    >>> out.sum().backward()  #  反向传播
    >>> a.grad                
    tensor([ 0., 0., 0.])
    
    
    >>> a = torch.tensor([1,2,3.], requires_grad =True)
    >>> out = a.sigmoid()
    >>> c = out.detach()
    >>> c.zero_()
    tensor([ 0., 0., 0.])
    
    >>> out                   #  out的值被c.zero_()修改 !!
    tensor([ 0., 0., 0.])
    
    >>> out.sum().backward()  #  需要原来out得值,但是已经被c.zero_()覆盖了,结果报错
    one of the variables needed for gradient computation has been modified by an inplace operation:
     [torch.FloatTensor [3]], which is output 0 of SigmoidBackward, is at version 1;
     expected version 0 instead. Hint: enable anomaly detection to find the operation that 
     failed to compute its gradient, with torch.autograd.set_detect_anomaly(True).
    

    五. 总结

    最后还是要总结一下:

    • requires_grad:在最开始创建Tensor时候可以设置的属性,用于表明是否追踪当前Tensor的计算操作。后面也可以通过requires_grad_()方法设置该参数,但是只有叶子节点才可以设置该参数。
    • detach()方法:则是用于将某一个Tensor从计算图中分离出来。返回的是一个内存共享的Tensor,一变都变。
    • torch.no_grad():对所有包裹的计算操作进行分离。
      但是torch.no_grad()将会使用更少的内存,因为从包裹的开始,就表明不需要计算梯度了,因此就不需要保存中间结果。3
    • .data则是以前Pytorch中Variable的一个属性,返回的是一个共享内存的Tensor,一变都变,只是现在很少使用了。

    可能有些地方理解不到位,希望各位指出相互探讨。
    最后留一个问题:
    为什么y.backward()的时候,有时候需要传递一个同等维度的Tensor呢?
    欢迎大家一起来总结啊!!!


    1. Is .data still useful in pytorch? ↩︎

    2. PyTorch中 tensor.detach() 和 tensor.data 的区别 ↩︎

    3. Difference between “detach()” and “with torch.nograd()” in PyTorch? ↩︎

    展开全文
  • 1. 基本概念 Tensor是一个多维矩阵,其中包含所有的元素为同一数据类型。默认数据类型为torch.float32。... a.requires_grad False >>> a.dtype torch.float32 >>> a.item() 1.0 &g

    1. 基本概念

    Tensor是一个多维矩阵,其中包含所有的元素为同一数据类型。默认数据类型为torch.float32

    • 示例一
    >>> a = torch.tensor([1.0])
    >>> a.data
    tensor([1.])
    >>> a.grad
    >>> a.requires_grad
    False
    >>> a.dtype
    torch.float32
    >>> a.item()
    1.0
    >>> type(a.item())
    <class 'float'>
    

    Tensor中只有一个数字时,使用torch.Tensor.item()可以得到一个Python数字。requires_gradTrue时,表示需要计算Tensor的梯度。requires_grad=False可以用来冻结部分网络,只更新另一部分网络的参数。

    • 示例二
    >>> a = torch.tensor([1.0, 2.0])
    >>> b = a.data
    >>> id(b)
    139808984381768
    >>> id(a)
    139811772112328
    >>> b.grad
    >>> a.grad
    >>> b[0] = 5.0
    >>> b
    tensor([5., 2.])
    >>> a
    tensor([5., 2.])
    

    a.data返回的是一个新的Tensor对象ba, bid不同,说明二者不是同一个Tensor,但ba共享数据的存储空间,即二者的数据部分指向同一块内存,因此修改b的元素时,a的元素也对应修改。

    2. requires_grad_()与detach()

    >>> a = torch.tensor([1.0, 2.0])
    >>> a.data
    tensor([1., 2.])
    >>> a.grad
    >>> a.requires_grad
    False
    >>> a.requires_grad_()
    tensor([1., 2.], requires_grad=True)
    >>> c = a.pow(2).sum()
    >>> c.backward()
    >>> a.grad
    tensor([2., 4.])
    >>> b = a.detach()
    >>> b.grad
    >>> b.requires_grad
    False
    >>> b
    tensor([1., 2.])
    >>> b[0] = 6
    >>> b
    tensor([6., 2.])
    >>> a
    tensor([6., 2.], requires_grad=True)
    
    • requires_grad_()

    requires_grad_()函数会改变Tensorrequires_grad属性并返回Tensor,修改requires_grad的操作是原位操作(in place)。其默认参数为requires_grad=Truerequires_grad=True时,自动求导会记录对Tensor的操作,requires_grad_()的主要用途是告诉自动求导开始记录对Tensor的操作。

    • detach()

    detach()就是截断反向传播的梯度流。detach()函数会返回一个新的Tensor对象b,并且新Tensor是与当前的计算图分离的,其requires_grad属性为False,反向传播时不会计算其梯度。ba共享数据的存储空间,二者指向同一块内存。

    :共享内存空间只是共享的数据部分,a.gradb.grad是不同的。

    3. torch.no_grad()

    torch.no_grad()是一个上下文管理器,用来禁止梯度的计算,通常用来网络推断中,它可以减少计算内存的使用量。

    >>> a = torch.tensor([1.0, 2.0], requires_grad=True)
    >>> with torch.no_grad():
    ...     b = n.pow(2).sum()
    ...
    >>> b
    tensor(5.)
    >>> b.requires_grad
    False
    >>> c = a.pow(2).sum()
    >>> c.requires_grad
    True
    

    上面的例子中,当arequires_grad=True时,不使用torch.no_grad()c.requires_gradTrue,使用torch.no_grad()时,b.requires_gradFalse,当不需要进行反向传播时(推断)或不需要计算梯度(网络输入)时,requires_grad=True会占用更多的计算资源及存储资源。

    4. 总结

    requires_grad_()会修改Tensorrequires_grad属性。

    detach()会返回一个与计算图分离的新Tensor,新Tensor不会在反向传播中计算梯度,会在特定场合使用。

    torch.no_grad()更节省计算资源和存储资源,其作用域范围内的操作不会构建计算图,常用在网络推断中。

    展开全文
  • The context managers torch.no_grad(), torch.enable_grad(), and torch.set_grad_enabled() are helpful for locally disabling and enabling gradient computation. See Locally disabling gradient computation...

    参考链接: Locally disabling gradient computation-1
    参考链接: Locally disabling gradient computation-2
    参考链接: class torch.autograd.no_grad的使用举例
    参考链接: class torch.autograd.enable_grad的使用举例
    参考链接: class torch.autograd.set_grad_enabled(mode: bool)的使用举例

    在这里插入图片描述
    在这里插入图片描述

    原文及翻译:

    Locally disabling gradient computation
    在局部区域内关闭(禁用)梯度的计算.
    
    The context managers torch.no_grad(), torch.enable_grad(), 
    and torch.set_grad_enabled() are helpful for locally disabling 
    and enabling gradient computation. See Locally disabling gradient 
    computation for more details on their usage. These context 
    managers are thread local, so they won’t work if you send 
    work to another thread using the threading module, etc.
    上下文管理器torch.no_grad()、torch.enable_grad()和
    torch.set_grad_enabled()可以用来在局部范围内启用或禁用梯度计算.
    在Locally disabling gradient computation章节中详细介绍了
    局部禁用梯度计算的使用方式.这些上下文管理器具有线程局部性,
    因此,如果你使用threading模块来将工作负载发送到另一个线程,
    这些上下文管理器将不会起作用.
    
    
    
    no_grad   Context-manager that disabled gradient calculation.
    no_grad   用于禁用梯度计算的上下文管理器.
    
    enable_grad  Context-manager that enables gradient calculation.
    enable_grad  用于启用梯度计算的上下文管理器.
    
    set_grad_enabled  Context-manager that sets gradient calculation to on or off.
    set_grad_enabled  用于设置梯度计算打开或关闭状态的上下文管理器.
    

    例子1:

    Microsoft Windows [版本 10.0.18363.1440]
    (c) 2019 Microsoft Corporation。保留所有权利。
    
    C:\Users\chenxuqi>conda activate pytorch_1.7.1_cu102
    
    (pytorch_1.7.1_cu102) C:\Users\chenxuqi>python
    Python 3.7.9 (default, Aug 31 2020, 17:10:11) [MSC v.1916 64 bit (AMD64)] :: Anaconda, Inc. on win32
    Type "help", "copyright", "credits" or "license" for more information.
    >>> import torch
    >>> torch.manual_seed(seed=20200910)
    <torch._C.Generator object at 0x000001A2E55A8870>
    >>> a = torch.randn(3,4,requires_grad=True)
    >>> a
    tensor([[ 0.2824, -0.3715,  0.9088, -1.7601],
            [-0.1806,  2.0937,  1.0406, -1.7651],
            [ 1.1216,  0.8440,  0.1783,  0.6859]], requires_grad=True)
    >>> b = a * 2
    >>> b
    tensor([[ 0.5648, -0.7430,  1.8176, -3.5202],
            [-0.3612,  4.1874,  2.0812, -3.5303],
            [ 2.2433,  1.6879,  0.3567,  1.3718]], grad_fn=<MulBackward0>)
    >>> b.requires_grad
    True
    >>> b.grad
    __main__:1: UserWarning: The .grad attribute of a Tensor that is not a leaf Tensor is being accessed. Its .grad attribute won't be populated during autograd.backward(). If you indeed want the gradient for a non-leaf Tensor, use .retain_grad() on the non-leaf Tensor. If you access the non-leaf Tensor by mistake, make sure you access the leaf Tensor instead. See github.com/pytorch/pytorch/pull/30531 for more informations.
    >>> print(b.grad)
    None
    >>> a.requires_grad
    True
    >>> a.grad
    >>> print(a.grad)
    None
    >>>
    >>> with torch.no_grad():
    ...     c = a * 2
    ...
    >>> c
    tensor([[ 0.5648, -0.7430,  1.8176, -3.5202],
            [-0.3612,  4.1874,  2.0812, -3.5303],
            [ 2.2433,  1.6879,  0.3567,  1.3718]])
    >>> c.requires_grad
    False
    >>> print(c.grad)
    None
    >>> a.grad
    >>>
    >>> print(a.grad)
    None
    >>> c.sum()
    tensor(6.1559)
    >>>
    >>> c.sum().backward()
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
      File "D:\Anaconda3\envs\pytorch_1.7.1_cu102\lib\site-packages\torch\tensor.py", line 221, in backward
        torch.autograd.backward(self, gradient, retain_graph, create_graph)
      File "D:\Anaconda3\envs\pytorch_1.7.1_cu102\lib\site-packages\torch\autograd\__init__.py", line 132, in backward
        allow_unreachable=True)  # allow_unreachable flag
    RuntimeError: element 0 of tensors does not require grad and does not have a grad_fn
    >>>
    >>>
    >>> b.sum()
    tensor(6.1559, grad_fn=<SumBackward0>)
    >>> b.sum().backward()
    >>>
    >>>
    >>> a.grad
    tensor([[2., 2., 2., 2.],
            [2., 2., 2., 2.],
            [2., 2., 2., 2.]])
    >>> a.requires_grad
    True
    >>>
    >>>
    

    例子2:

    Microsoft Windows [版本 10.0.18363.1440]
    (c) 2019 Microsoft Corporation。保留所有权利。
    
    C:\Users\chenxuqi>conda activate pytorch_1.7.1_cu102
    
    (pytorch_1.7.1_cu102) C:\Users\chenxuqi>python
    Python 3.7.9 (default, Aug 31 2020, 17:10:11) [MSC v.1916 64 bit (AMD64)] :: Anaconda, Inc. on win32
    Type "help", "copyright", "credits" or "license" for more information.
    >>> import torch
    >>> torch.manual_seed(seed=20200910)
    <torch._C.Generator object at 0x000002109ABC8870>
    >>>
    >>> a = torch.randn(3,4,requires_grad=True)
    >>> a
    tensor([[ 0.2824, -0.3715,  0.9088, -1.7601],
            [-0.1806,  2.0937,  1.0406, -1.7651],
            [ 1.1216,  0.8440,  0.1783,  0.6859]], requires_grad=True)
    >>> a.requires_grad
    True
    >>>
    >>> with torch.set_grad_enabled(False):
    ...     b = a * 2
    ...
    >>> b
    tensor([[ 0.5648, -0.7430,  1.8176, -3.5202],
            [-0.3612,  4.1874,  2.0812, -3.5303],
            [ 2.2433,  1.6879,  0.3567,  1.3718]])
    >>> b.requires_grad
    False
    >>>
    >>> with torch.set_grad_enabled(True):
    ...     c = a * 3
    ...
    >>> c
    tensor([[ 0.8472, -1.1145,  2.7263, -5.2804],
            [-0.5418,  6.2810,  3.1219, -5.2954],
            [ 3.3649,  2.5319,  0.5350,  2.0576]], grad_fn=<MulBackward0>)
    >>> c.requires_grad
    True
    >>>
    >>> d = a * 4
    >>> d.requires_grad
    True
    >>>
    >>> torch.set_grad_enabled(True)  # this can also be used as a function
    <torch.autograd.grad_mode.set_grad_enabled object at 0x00000210983982C8>
    >>>
    >>> # 以函数调用的方式来使用
    >>>
    >>> e = a * 5
    >>> e
    tensor([[ 1.4119, -1.8574,  4.5439, -8.8006],
            [-0.9030, 10.4684,  5.2031, -8.8257],
            [ 5.6082,  4.2198,  0.8917,  3.4294]], grad_fn=<MulBackward0>)
    >>> e.requires_grad
    True
    >>>
    >>> d
    tensor([[ 1.1296, -1.4859,  3.6351, -7.0405],
            [-0.7224,  8.3747,  4.1625, -7.0606],
            [ 4.4866,  3.3759,  0.7133,  2.7435]], grad_fn=<MulBackward0>)
    >>>
    >>> torch.set_grad_enabled(False) # 以函数调用的方式来使用
    <torch.autograd.grad_mode.set_grad_enabled object at 0x0000021098394C48>
    >>>
    >>> f = a * 6
    >>> f
    tensor([[  1.6943,  -2.2289,   5.4527, -10.5607],
            [ -1.0836,  12.5621,   6.2437, -10.5908],
            [  6.7298,   5.0638,   1.0700,   4.1153]])
    >>> f.requires_grad
    False
    >>>
    >>>
    >>>
    
    展开全文
  • with torch.no_grad()或者@torch.no_grad()中的数据不需要计算梯度,也不会进行反向传播 model.eval() # 测试模式 with torch.no_grad(): pass @torch.no_grad() def eval(): ... ...
    • requires_grad=True 要求计算梯度

    • requires_grad=False 不要求计算梯度

    • with torch.no_grad()或者@torch.no_grad()中的数据不需要计算梯度,也不会进行反向传播

      model.eval()                                # 测试模式
      with torch.no_grad():
         pass
      @torch.no_grad()
      def eval():
      	...

       

    展开全文
  • [pytorch with torch.no_grad和torch.set_grad_enabled用法区别(作用是一样的)]
  • a = torch.tensor([1,2,3.], requires_grad = True) out = a.sigmoid() c = out.data # 通过.data “分离”得到的的变量会和原来的变量共用数据(指向同一地址),而且新分离得到的张量是不可求导的 c.zero_() # ...
  • requires_grad=True 要求计算梯度 requires_grad=False 不要求计算梯度 with torch.no_grad()或者@torch.no_grad()中的数据不需要计算梯度,也不会进行反向传播 model.eval() ...
  • 在编程中遇到了with torch.no_grad()用法,想整明白,过程中有一些意料之外的东西,故此记录一下。 首先说明一下环境,以下的测试均在:python3.6, pytorch1.2.0 环境下给出: 官网的截图如下: 主要有几个重要的点...
  • 在这个下面进行运算得到的tensor没有grad_fn,也就是它不带梯度(因为没有上一级的函数),因此loss无法从这些tensor向上传递,产生这些tensor的网络的参数将不会更新。下面这种情况一般使用with torch.no_grad(): ...
  • pytorch 中的with torch.no_grad(): 在pytorch写的网络中,with torch.no_torch():非常常见。 首先,关于python中的with: with语句适用于对资源进行访问的场合,确保不管使用过程中是否发生异常都会执行必要的”...
  • PyTorch torch.no_grad()

    2021-01-15 15:07:39
    torch.no_grad() 一般用于神经网络的推理阶段, 表示张量的计算过程中无需计算梯度 torch.no_grad 是一个类, 实现了 __enter__ 和 __exit__ 方法, 在进入环境管理器时记录梯度使能状态以及禁止梯度计算, 退出环境...
  • requires_grad require_grad意为是否需要计算梯度 使用backward()函数反向传播计算梯度时,并不是计算所有tensor的梯度,只有满足下面条件的tensor的梯度才会被计算:1. 当前tensor的 require_grad=True(代码示例一...
  • 既然涉及梯度,不得不先谈谈requires_grad。 import torch 下面先来做做题: a=torch.tensor([1.1]) print(a.requires_grad) #答案是? a=torch.tensor([1.1],requires_grad=True...with torch.no_grad(): b=a*2 pri
  • torch.set_grad_enabled(mode) 与with troch.no_grad 相似,会将在这个with包裹下的所有的计算出的 新的变量 的required_grad 置为false。但原有的变量required_grad 不会改变。这实际上也就是影响了网络的自动...
  • 【pytorch系列】 with torch.no_grad():用法详解

    千次阅读 多人点赞 2021-05-11 20:26:15
    在pytorch写的网络中,with torch.no_grad():非常常见。 首先,关于python中的with: with 语句适用于对资源进行访问的场合,确保不管使用过程中是否发生异常都会执行必要的“清理”操作,释放资源,比如文件使用后...
  • with torch.no_grad()

    2020-12-22 17:21:03
    合理的利用torch.no_grad()可以节省显存,在推断的时候,可以少占用 模型训练的时候,爆显存了,可以调整batch,对数据进行crop等等操作 今天发现一个模型,训练ok,每次测试的时候爆显存。开始以为是因为用了全图...
  • torch.no_grad()则是告知自动求导引擎不要进行求导操作。这个操作的意义在于加速计算、节约内存。但是由于没有gradient,也就没有办法进行backward。所以只能在测试的时候开启。 所以在evaluate的时候,需要同时使用...
  • leaf variable & with torch.no_grad & -=

    千次阅读 多人点赞 2019-04-26 16:09:54
    作用与volatile相似,即使一个tensor(命名为x)的requires_grad = True,由x得到的新tensor(命名为w-标量)requires_grad也为False,且grad_fn也为None,即不会对w求导。例子如下所示: x = torch.randn(10, 5,...
  • detach() 和 torch.no_grad() 都可以实现相同的效果,只是前者会麻烦一点,对每一个变量都要加上,而后者就不用管了。 x = torch.tensor(2., requires_grad=True) y = torch.tensor(3., requires_grad=True) z = 2 *...
  • pytorch中with torch.no_grad():

    千次阅读 2021-01-25 11:22:49
    0.5297, -0.3215, -2.0045, 1.0426, -3.2699, -0.5084], [-0.5357, -1.9851, -0.2835, -0.3110, 2.6453, 0.7452, -1.4148, 5.6919, -6.3235, -1.6220]], grad_fn=) 可以看到,此时有grad_fn=属性,表示,计算的结果...
  • with torch.no_grad() 详解

    万次阅读 多人点赞 2020-04-21 15:14:39
    torch.no_grad() 是一个上下文管理器,被该语句 wrap 起来的部分将不会track 梯度。 例如: a = torch.tensor([1.1], ...Out[63]: tensor([2.2000], grad_fn=<MulBackward0>) b.add_(2) Out[64]: tensor([4....
  • torch.no_grad

    千次阅读 2020-06-09 15:32:03
    class torch.no_grad[source] class torch.no_grad[source] 不能进行梯度计算的上下文管理器。当你确定你不调用Tensor.backward()时,不能计算梯度对测试来讲非常有用。对计算它将减少内存消耗,否则requires_grad...
  • 问题原因 no_grad后面少打了括号
  • 代码: a = torch.randn((),dtype=dtype, device=device, requires_grad=True) ...with torch.no_grad(): a -= learning_rate * a.grad z = a+b print(f"a with no gradient:{a.requires_grad}") print(f
  • torch.no_grad和验证模式

    千次阅读 2020-03-26 17:06:16
    requires_gradVariable变量的requires_grad的属性默认为False,若一个节点requires_grad被设置为True,那么所有依赖它的节点的requires_grad都为True。 volatile=True是Variable的另一个重要的标识,它能够将所有...
  • with torch.no_grad 代替volatile; 前置知识 requires_grad 在pytorch中,tensor有一个requires_grad参数(默认为False),如果设置为True,则反向传播时,该tensor就会自动求导。tensor的requires_grad的属性默认...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 18,953
精华内容 7,581
关键字:

no_grad