精华内容
下载资源
问答
  • PyTotch之Tensor数据类型介绍 Tonsor数据类型基础介绍 在PyTorch中, torch.Tensor 是存储和变换数据的主要⼯工具,并且Tensor 和NumPy的多维数组⾮非常类似, Tensor 提供GPU计算和自动求梯度等功能。 "tensor"这个...

    PyTotch之Tensor数据类型介绍

    Tonsor数据类型基础介绍

    在PyTorch中, torch.Tensor 是存储和变换数据的主要⼯工具,并且Tensor 和NumPy的多维数组⾮非常类似, Tensor 提供GPU计算和自动求梯度等功能。

    "tensor"这个单词⼀一般可译作“张量量”,张量量可以看作是⼀一个多维数组。标量量可以看作是0维张量量,向
    量量可以看作1维张量量,矩阵可以看作是⼆二维张量量。

    创建Tensor

    在创建Tensor时,首先导入torch库

    1. 创建一个a x b的未初始化的Tensor
    x = torch.empty(a, b)
    
    1. 创建一个a x b的随机初始化的Tensor
    x = torch.rand(a, b)
    
    1. 创建一个a x b的全0型Tensor
    x = torch.zeros(a, b)
    
    1. 根据数据([a, b])创建
    x = torch.tensor([a, b])
    
    1. 创建一个a x b的全1的Tensor
    x = x.new_ones(a, b)
    
    1. 创建根据指定类型的随机初始化的Tensor
    x = torch.randn_like(x)
    

    输出Tensor的shape

    1. x.size()
    2. x.shape

    Tensor的算术操作

    1. 加法运算

    1. 加法一:
    x = torch.rand(5,3)
    y = torch.rand(5,3)
    z = x + y
    
    1. 加法二:
    z = torch.add(x, y)
    
    1. 加法三:
    y.add_(x)
    

    2.索引

    A).类似NumPy的索引操作。
    注意:索引出来的结果与原数据共享内存,也即修改一个,另一个会跟着修改

    import torch
    x = torch.empty(3, 5)
    y = torch.rand(3, 5)
    z = x[0, :]
    z1 += 1		# 源Tensor也被更改了
    

    输出:

    print(x)
    tensor([[1.9005e-19, 4.6246e+19, 1.7163e+25, 1.1866e+27, 4.8263e+19],
            [6.4072e+02, 2.8573e+32, 1.5793e-19, 2.1727e+35, 1.8971e+31],
            [1.0803e-32, 1.3563e-19, 1.3563e-19, 2.7256e+20, 1.8524e+28]])
    print(y)
    tensor([[0.6262, 0.4501, 0.3295, 0.5330, 0.7711],
            [0.9652, 0.9371, 0.3598, 0.4364, 0.5721],
            [0.9199, 0.3670, 0.6096, 0.5397, 0.9333]])
    print(z)
    tensor([1.0000e+00, 4.6246e+19, 1.7163e+25, 1.1866e+27, 4.8263e+19])
    print(z1)
    tensor([1.0000e+00, 4.6246e+19, 1.7163e+25, 1.1866e+27, 4.8263e+19])
    

    B).使用函数

    • index_select(input, dim, index)
      在指定维度dim上选取,比如选取某行、某列
    # input:
    z = torch.index_select(x, 1, torch.tensor([0, 2]))	
    # output
    print(z)
    tensor([[8.4490e-39, 1.0194e-38],
            [9.6429e-39, 9.6429e-39],
            [9.0919e-39, 9.2755e-39]])
    
    • masked_select(input, mask)
    # input
    mask = x.ge(0.5)
    z = torch.masked_select(x, mask)
    # output
    print(mask)
    tensor([[False,  True,  True,  True, False],
            [ True,  True, False, False,  True],
            [False,  True,  True,  True,  True]])
    print(z)
    tensor([1.7444e+28, 7.3909e+22, 1.8727e+31, 4.6168e+24, 4.2964e+24, 7.1345e+31,
            1.7444e+28, 7.3909e+22, 1.8727e+31, 1.3179e+25])
    
    • nonzero(input)
      非0的下标
    # input
    z = torch.nonzero(x)
    # output
    print(z)
    tensor([[0, 0],
            [0, 1],
            [0, 2],
            [0, 3],
            [0, 4],
            [1, 0],
            [1, 1],
            [1, 2],
            [1, 3],
            [1, 4],
            [2, 0],
            [2, 1],
            [2, 2],
            [2, 3],
            [2, 4]])
    
    • gather(input, dim ,index)
      根据index,在dim维度上选取数据,输出的size与index一样
    # input
    z = torch.gather(x,1,torch.LongTensor([[0,0],[1,0]]))
    # output
    print(z)
    tensor([[2.3869e-12, 2.3869e-12],
            [2.3869e-12, 5.7033e-43]])
    

    Tips:x值均于加法示例中一致。

    展开全文
  • 数据类型查看版本信息Tensor维度变换求导剥离无梯度变量Parameter 编程语言和自然语言一样,不理解的词越多,对全文的理解就越差。掌握必要的基础知识,让后期看代码更加流畅。 机器学习需要掌握数据处理工具Pandas...

    编程语言和自然语言一样,不理解的词越多,对全文的理解就越差。掌握必要的基础知识,让后期看代码更加流畅。

    机器学习需要掌握数据处理工具Pandas、Numpy,同理,深度学习也需要掌握相应的工具,在Pytorch中数据存储在Tensor之中,本篇将介绍它们的基本用法以及与之相关的常用函数。

    查看版本信息

    包含头文件

     import torch  
    

    1.查看torch版本

     print(torch.__version__)  
    

    2.查看CUDA版本

    print(torch.version.cuda)  
    

    GPU相关操作

    1查看当前是否支持GPU

    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')  
    

    2GPU相关的数据转换

    a = torch.Tensor([5])  
    b = a.to('cuda') # 转成在 GPU 上运行的类型  
    b = a.cuda() # 同上  
    c = b.to('cpu') # 转成在 CPU 上运行的类型  
    c = b.cpu() # 同上 
    

    3 查看GPU状态

    print(torch.cuda.device_count()) # 查看可用 GPU 个数  
    print(torch.cuda.current_device()) # 查看当前使用的 GPU ID  
    print(torch.cuda.get_device_capability(0)) # 查看 ID 为 0 的 CUDA 容量  
    print(torch.cuda.get_device_name(0)) # 查看设备名
    

    4清空GPU缓存

    print(torch.cuda.empty_cache()) # 清空缓存  
    

    Tensor

    Tensor用于表示矩阵(多维数据),类似Numpy的ndarray,它可以使用GPU加速。从Pytorch 0.4.0之后,Variable与Tensor合并(Variable仍存在,但很少使用)。

    创建**Tensor时参数requires_grad默认为False,若设为True,则可实现自动求导的功能,**梯度保存在其内部变量grad中,计算梯度的方法存储在grad_fn中。

    1.生成Tensor

    用Tensor方法将其它格式数据转换成张量,转换内容一般是list或数组格式:

    a = torch.Tensor([[1,2],[3,4],[5,6]]) # 生成 3,2 维Tensor    
    b = torch.zeros(3,5) # 生成内容为全0的 3,5 维Tensor    
    c = torch.rand(3,5) # 生成内容为 0-1 随机数的 3,5 维Tensor    
    d = c.clone() # 将c中内容复制到 d, 新旧内容指向不同的地址空间  
    

    2.修改Tensor

    用赋值的方法即可修改张量,比如将上面生成张量中位置1,1的元素赋值成50。

    a[1,1]=50  
    

    3.查看Tensor状态

    查看Tensor数据类型,大小及元素个数

    1.  a = torch.Tensor([5])    
    2.  print(a.type()) # torch.FloatTensor,默认类型为FloatTesor     
    3.  print(a.size()) # torch.Size([1])    
    4.  print(a.shape)  # torch.Size([1])    
    5.  print(a.numel()) # 1,查看元素个数  
    6.  print(a.dim()) # 1, 查看维度  
    

    4.类型转换

    Tensor与其它数据类型相互转换

    1.  a = torch.Tensor([5]) # tensor([5.])
    2.  b = a.numpy()  # 转换成numpy.array类型 [5.]  
    3.  c = a.item() # 转换成单个值 5.0  
    4.  d = torch.from_numpy(b)  # 转换成Tensor tensor([5.])  
    5.  e = d.int() # 转换成 IntTensor tensor([5], dtype=torch.int32)
    6.  f = d.tolist() # 转换成list [5.0]  
    

    维度变换

    1.增加维度

    在深度学习过程中,现有的数据格式和模型要求的格式往往不同,层与层之间的数据也需要转换后才能对接,维度转换是最常用的方法。

    squeeze意为压缩,即去掉维度,unsqueeze则相反,为添加维度。

    unsqueeze(input, dim, out=None)   
    

    用于增添第dim维度为1。具体用法见以下示例:

    1.  a = torch.Tensor([1,2,3])  
    2.  print(a, a.shape)  # tensor([1., 2., 3.]) torch.Size([3])  
    3.  b = torch.unsqueeze(a, 1)  
    4.  print(b, b.shape)  # tensor([[1.],[2.],[3.]]) torch.Size([3, 1])  
    5.  c = torch.unsqueeze(a, 0)  
    6.  print(c, c.shape)  # tensor([[1., 2., 3.]]) torch.Size([1, 3])  
    

    2.减小维度

    1.  squeeze(input, dim=None, out=None)   
    

    用于删除第dim个维度,如果当前不包括指定的维度,则不会删除。如果不指定dim,函数将删除值为1的维度。

    本例中延用上例中的数据:

    1.  print(torch.squeeze(c,0))  # tensor([1., 2., 3.])  
    2.  print(torch.squeeze(b,1))  # tensor([1., 2., 3.])  
    3.  print(torch.squeeze(b))  # tensor([1., 2., 3.])  
    

    3.转换维度

    比squeeze和unsqueeze更简单的方法是直接把张量转换成指定维度,使用view函数实现,它类似于numpy的reshape,Tensor也提供reshape方法。

    1.  view(*shape)   
    

    将张量转换成指定的形状,示例:

    1.  x = torch.Tensor([1,2,3,4])  
    2.  print(x.view(2,2))  # tensor([[1., 2.], [3., 4.]])  
    3.  print(x.view(1,4))  # tensor([[1., 2., 3., 4.]])  
    4.  print(x.view(1,-1)) # 设为-1时自动计算该维度大小 tensor([[1., 2., 3., 4.]])  
    5.  print(x.view(4))  # tensor([1., 2., 3., 4.])  
    

    4.cat拼接

    cat函数用于在指定维度上拼接多个张量。

    1.  cat(tensors, dim=0, out=None)   
    

    将tensors中的多个张量按dim指定的维度拼接成一个张量,拼接后总维数不变。

    1.  x = torch.Tensor([[1,2],[3,4]])  
    2.  y = torch.Tensor([[5,6],[7,8]])  
    3.  print(torch.cat((x,y),0))  
    4.  # tensor([[1., 2.],  
    5.  #        [3., 4.],  
    6.  #        [5., 6.],  
    7.  #        [7., 8.]])  
    8.  print(torch.cat((x,y),1))  
    9.  # tensor([[1., 2., 5., 6.],  
    10. #        [3., 4., 7., 8.]])  
    

    一般面对的数据最多三维,并以一两维居多,可将其理解为横向加或者纵向加。

    5.stack拼接

    与cat拼接不同的是,stack拼接后维度增加,其用法如下:

    1.  stack(tensors, dim=0, out=None)  
    

    示例:

    1.  x = torch.Tensor([1,2])  
    2.  y = torch.Tensor([3,4])  
    3.  print(torch.stack((x,y),dim=0))  
    4.  # tensor([[1., 2.],  
    5.  #         [3., 4.]])  
    6.  print(torch.stack((x,y),dim=1))  
    7.  # tensor([[1., 3.],  
    8.  #         [2., 4.]])  
    

    从输出内容可以看到,拼接后张量变成了两维,dim=0是最常用的方法,它直接把两个张量拼在一起,当dim=1时,拼接时转换了位置。

    6.transpose两维度互换

    1.  transpose(input, dim0, dim1)  
    

    互换dim0, dim1两个维度,具体用法如下:

    1.  x = torch.Tensor([[1,2],[3,4]])  
    2.  print(torch.transpose(x,0,1))  
    3.  # tensor([[1., 3.],  
    4.  #        [2., 4.]])  
    

    7.perumute多维度互换

    permute与transpose功能类似,但更加灵活,它可以指定多个维度互换。

    1.  x = torch.Tensor([[1,2],[3,4]])  
    2.  print(torch.transpose(x,0,1))  
    3.  # tensor([[1., 3.],  
    4.  #        [2., 4.]])  
    

    用于将张量转换成dim指定的维度。

    1.  x = torch.rand(2,3,4)  
    2.  print(x.shape, x.permute(2,1,0).shape)  
    3.  # torch.Size([2, 3, 4]) torch.Size([4, 3, 2])  
    

    本例先产生了一组3维的随机数,每个维度的元素个数分别是2,3,4,然后使用permute将其第2维转成第0维,第1维不变,第0维转成第2维,从打印信息可以看到各维元素个数的变化。permute常用于对转换图片格式。

    8.维度扩展

    增加Tensor中元素的个数,其内容与被扩展的内容一致。

    1.  a = torch.Tensor([5])  
    2.  print(a.expand(1, 2)) # tensor([[5., 5.]])  
    

    求导

    下例中使用了torch.tensor而非torch.Tensor,torch.Tensor是Pytorch中的类,确切地说是FloatTensor的别名;而torch.tensor()是函数,它更加灵活,使用方法如下:

    1.  torch.tensor(data, dtype=None, device=None, requires_grad=False)  
    

    它可以创建各种类型的Tensor数据。

    下面声明三个变量x,a,b,用它们计算变量y,之后用y.backward()求y对x,a,b三个变量的偏导数,这是深度学习中常说的“反向”过程。结果存储在变量的grad元素中,如x.grad。

    1.  x = torch.tensor([1.0], requires_grad=True)    
    2.  a = torch.tensor([2.0], requires_grad=True)    
    3.  b = torch.tensor([3.0], requires_grad=True)    
    4.  y = a * x + b  
    5.  y.backward()    
    6.  print(x.grad) # 输出结果: tensor([2.])    
    7.  print(a.grad) # 输出结果: tensor([1.])    
    8.  print(b.grad) # 输出结果: tensor([1.])    
    9.  print(b.data) # 输出结果: tensor([3.])    
    

    从输出结果可以看到,Tensor包含两个元素,data是它的Tensor值,grad保存的是求得的偏导数。

    剥离无梯度变量

    detach方法用于从普通Tensor中剥离出无梯度的变量。下面延用上例求导后有梯度的数据b。

    1.  print(b) # tensor([3.], requires_grad=True)  
    2.  print(b.detach()) # tensor([3.])  
    3.  print(b.detach_()) # tensor([3.])  
    

    detach和detach_的区别是detach获取b的data数据,**而detach_则是将b中的grad_fn设置为None,**requires_grad设置为False,从而改变了b的内容。

    Parameter

    一般模型参数都是torch.nn.parameter.Parameter类型的数据,它继承了Tensor,主要不同是requires_grad默认为True,以便于模型调参。

    常在两种场景中使用Parameter,一种是fine-tune精调时冻结模型中某些层的参数;另一种是自己实现一些特殊的结构,如构建Attention时,用Parameter创建需要调节的参数。

    1.创建Parameter数据

    1.  p = torch.nn.Parameter(torch.randn(2))   
    2.  print(p) # tensor([1.2087, 1.2607], requires_grad=True)  
    

    2.查看模型的Parameter参数,大小及冻结情况

    Pytorch模型的基类是Module,其中维护一个名为_parameters的字典,它包含每一个子元素的名字(key)和value参数(value)。如需要冻结某层,将其require_grad设为False即可。

    1.  model = torch.nn.Linear(1,1)  
    2.  for name, param in model.named_parameters():    
    3.      print(name, param.size(), param.requires_grad)    
    4.  # 输出结果:  
    5.  # weight torch.Size([1, 1]) True  
    6.  # bias torch.Size([1]) True  
    

    感谢原文-知乎谢彦
    Pytorch常用函数之一_数据类型

    展开全文
  • 1.torch.autograd和Variable torch.autograd包,可以使模型参数自动计算在优化过程中需要用到的梯度值,降低实现后向传播代码的...#使用 torch.autograd中的Variabe类,对tensor数据类型变量进行封装的操作 x=Varia...

    1.torch.autograd和Variable

    torch.autograd包,可以使模型参数自动计算在优化过程中需要用到的梯度值,降低实现后向传播代码的复杂度。
    主要功能:完成神经网络后向传播的链式求导。

    from torch.autograd import Variable
    

    #使用 torch.autograd中的Variabe类,对tensor数据类型变量进行封装的操作

    x=Variable(torch.randn(batch_n,input_data),requires_grad = False)
    #requires_grad参数其赋值类型为布尔型,False,表示该变量在进行自动梯度计算过程中不会保留梯度值
    

    另在迭代代码中使用

    loss.backward()
    

    代替了所有的后向传播计算部分。

    2.torch.nn

    torch.nn 提供了很多实现神经网络中具体功能的类,例如 卷积层torch.nn.Conv,池化层torch.nn.MaxPool,全连接层这类层次的构造方法,防止过拟合的参数归一化方法,Dropout 方法,以及线性或非线性激活函数等。
    例如:
    1.torch.nn.Sequential :该类是torch.nn 中的一种序列容器,通过在容器中嵌套实现神经网络相关的类,完成神经网络搭建。
    包含两种方式:1>直接嵌套。2>以orderdict有序字典方式进行传入。
    不同在于2 可以自定义名称
    2.torch.nn.Linear 用于定义模型的线性层,完成不同层之间的线性变换。
    3.totch.nn中的损失函数

    1. torch.nn.MSELoss 使用均方误差函数计算损失值
      2)torch.nn.L1Loss 使用平均绝对误差函数计算损失值
    2. torch.nn.CrossEntropyLoss 计算交叉熵

    3.torch.optim

    torch.optim:自动优化类
    包含:SGD.AdaGrad,RMSProp,Adam 等

    optmizer=torch.optim.Adam( models.parameters(),lr=learning_rata)
    
    展开全文
  • 深度学习其实就是一个最优化问题,找到最小的loss值,因为自变量过多,想要找到最小值非常困难。所以就出现了很多最优化...tensor还可以指定数据类型,以及数据存储的位置(可以存在显存里,硬件加速) torch.te...

     

    深度学习其实就是一个最优化问题,找到最小的loss值,因为自变量过多,想要找到最小值非常困难。所以就出现了很多最优化方法,梯度下降就是一个非常典型的例子。本文针对python的pytorch库中的自动求梯度进行了详细的解释

    Tensor

    pytorch里面的tensor可以用来存储向量或者标量。

    torch.tensor(1) # 标量
    torch.tensor([1]) # 1*1 的向量

    tensor还可以指定数据类型,以及数据存储的位置(可以存在显存里,硬件加速)

    torch.tensor([1,2], dtype=torch.float64)

    梯度

    在数学里,梯度的定义如下:

    设三元函数u=f(x,y,z)在空间区域G内具有一阶连续偏导数,点 P(x,y,z) \in G,称向量

     

    为函数 u=f(x,y,z)在点P的梯度。

    可以看出,自变量相对于因变量的每一个偏导乘以相应的单位向量,最后相加,即为最后的梯度向量。

    在pytorch里面,我们无法直接定义函数,也无法直接求得梯度向量的表达式。更多的时候,我们其实只是求得了函数的在某一个点处相对于自变量的偏导。

    我们先假设一个一元函数:y = x^2 + 3x +1,在pytorch里面,我们假设x = 2, 那么

    >>> x = torch.tensor(2, dtype=torch.float64, requires_grad=True)
    >>> y = x * x + 3 * x + 1
    >>> y.backward()
    >>> x.grad
    tensor(7., dtype=torch.float64)

    可以看出,最后y相对于x的导数在x=2的地方为7。在数学里进行验证,那么就是

    y' = 2*x + 3, 当x=2时,y' = 2 * 2 + 3 = 7, 完全符合torch自动求得的梯度值。

    接下来计算二元函数时的情况:

    >>> x1 = torch.tensor(1.0)
    >>> x2 = torch.tensor(2.0, requires_grad=True)
    >>> y = 3*x1*x1 + 9 * x2
    >>> y.backward()
    tensor(6.)
    >>> x2.grad
    tensor(9.)

    可以看出,我们可以求得y相对于x2的偏导数。


    以上讨论的都是标量的情况,接下来讨论自变量为向量的情况。

    mat1 = torch.tensor([[1,2,3]], dtype=torch.float64, requires_grad=True)
    >>> mat2
    tensor([[1.],
            [2.],
            [3.]], dtype=torch.float64, requires_grad=True)

    mat1是一个1x3的矩阵,mat2是一个3x1的矩阵,他们俩的叉乘为一个1x1的矩阵。在pytorch里面,可以直接对其进行backward,从而求得相对于mat1或者是mat2的梯度值。

    >>> y = torch.mm(mat1, mat2)
    >>> y.backward()
    >>> mat1.grad
    tensor([[1., 2., 3.]], dtype=torch.float64)
    >>> mat2.grad
    tensor([[1.],
            [2.],
            [3.]], dtype=torch.float64)

    其实可以把mat1中的每一个元素当成一个自变量,那么相对于mat1的梯度向量,就是分别对3个x进行求偏导。

    相当于是y = mat1[0] * mat2[0] + mat1[1] * mat2[1] + mat1[2] * mat2[2]

    然后分别求y对于mat1,mat2每个元素的偏导。

     

    另外,如果我们最后输出的是一个N x M 的一个向量,我们要计算这个向量相对于自变量向量的偏导,那么我们就需要在backward函数的参数里传入参数。

     

    如上图所述,其实pytorch的autograd核心就是计算一个 vector-jacobian 乘积, jacobian就是因变量向量相对于自变量向量的偏导组成的矩阵,vector相当于是因变量向量到一个标量的函数的偏导。最后就是标量相对于一个向量的梯度向量。

     

    总结

    最后,其实神经网络就是寻求一个拟合函数,但是因为参数过多,所以不得不借助每一点的梯度来一点一点的接近最佳的LOSS值,pytorch拥有动态的计算图,存储记忆对向量的每一个函数操作,最后通过反向传播来计算梯度,这可以说是pytorch的核心。所以深入了解如果利用pytorch进行自动梯度计算非常重要。

    展开全文
  • nn.Module包含各种类型的网络层(layers) 前向传播forward(input),返回output. 一、网络训练的基本步骤 定义一个具有科学系参数的神经网络(权值) 迭代数据集的所有输入 通过网络处理输入 计算loss 反向求网络参数的...
  • 使用storage()函数把Tensor数据转换为float类型的Storage数据,再使用tolist() 返回一个包含此存储中元素的列表。 2.detach 计算图截断 detach 的意思是,这个数据和生成它的计算图“脱钩”了,即detach就是截断...
  • 深度学习其实就是一个最优化问题,找到最小的loss值,因为自变量过多,想要找到最小值非常困难。...torchtensor还可以指定数据类型,以及数据存储的位置(可以存在显存里,硬件加速)torch.tens...
  • 上一篇笔记中搭建了一个简单的神经网络模型,前向学习和反向传播都是使用简单的计算,但是随着模型网络的...过程大致为:先通过输入的tensor数据类型的变量在神经网络的前向传播中生成一张计算图,然后再根据这个计...
  • 1.问题描述 再使用pytorch过程中,将torch.FloatTensor类型的变量转换成胃nparray类型时报错,内容...待转换类型torch.FloatTensor变量带有梯度,直接将其转换为numpy数据将破坏计算图,因此var.numpy()函数拒绝进
  • ENet的TensorFlow实施( )基于官方的Torch实施( )和PavlosMelissinos的Keras实施( ),在Cityscapes数据集( )上进行了培训。 YouTube视频结果( ): 视频中的结果显然可以得到改善,但是由于计算资源有限...
  • 在 Pytroch 中,Tensor 是一种包含单一数据类型元素的多维矩阵,译作张量。熟悉 numpy 的同学对这个定义应该感到很熟悉,就像ndarray一样,一维Tensor叫Vector,二维Tensor叫Matrix,三维及以上称为Tensor。而 numpy...
  • Pytorch训练网络的一般步骤

    千次阅读 2019-02-02 11:59:55
    print(torch.tensor([1,2,3],dtype=torch.float))#将一个列表强制转换为torch.Tensor类型 print(torch.randn(5,3))#生成torch.Tensor类型的5X3的随机数 1、构建模型 2、定义一个损失函数 3、定义一个优化器 4、将...
  • torch.autograd包的主要功能是完成神经网络后向传播中的链式求导,实现自动梯度功能的过程大致为:先通过输入的Tensor数据类型的变量在神经网络的前向传播过程中生成一张计算图,然后根据这个计算图和输出结果准确...
  • 1.(以前)Variable是torch.autograd中的数据类型,主要用于封装Tensor,进行自动求导: data:被包装的tensor grad:data的梯度 grad_fn:创建Tensor的Function,是自动求导的关键 requires_grad:指示是否需要梯度...
  • 2020-11-11

    2020-11-11 20:08:57
    torch.tensor属性: grad 张量梯度 grad_fn 梯度函数 data 张量数据 is_leaf 是否叶子节点 devices 张量所在的设备(CPU/GPU) shape 张量的形状(64,3,244,244) dtype data的数据类型 requires_grad 是否需要梯度
  • BiLSTM-Attention文本分类

    2020-12-21 07:13:03
    首先,我们导入需要的包,包括模型,优化器,梯度求导等,将数据类型全部转化成tensor类型 import numpy as np import torch import torch.nn as nn import torch.optim as optim from torch.autograd import ...
  • PyTorch基础学习总结

    千次阅读 2020-01-14 21:38:12
    2、Tensor数据类型 3、Tensor常用函数 二、基于PyTorch搭建简易神经网络模型 1、简易神经网络模型 2、Pytorch自动梯度 3、使用自动梯度和自定义函数搭建简易神经网络模型 三、torch.nn和torch.optim 1、使用...
  • dtype=None, # 数据类型 默认与data一致 device=None, # 所在设备 cuda / cpu requires_grad=False, # 是否需要梯度 pin_memory = False ,# 是否存于锁页内存) flag = True if flag: arr = np.ones((3,3)) print('...
  • PyTorch学习 Week1张量

    2021-01-26 22:46:31
    torch中的数据类型,用于封装Tensor,进行自动求导 data:被包装的Tensor grad:data的梯度 grad_fn:创建Tensor的Function,是自动求导的关键 requirs_grad:指示是否需要梯度 is_leaf:指示是否是叶子结点(张量...
  • 张量的概念   张量,即Tensor,是PyTorch的基本数据结构。在数学概念中,张量是一个多维数组,它是标量、向量、...dtype: 张量的数据类型,如 torch.FloatTensor, torch.cuda.FloatTensor shape: 张量的形状,如(64
  • Variable的数据类型主要有:data(被包装的Tensor)、grad(data的梯度)、grad_fn(创建Tensor的Function,是自动求导的关键)、requires_grad(指示是否需要梯度)、is_leaf(是否是叶子结点也就是张量)。 PyTorch0.4版本...
  • import torch import numpy as np torch.tensor(data, dtype=None, device...dtype:数据类型,默认与data一致 device:所在设备 gpu/cpu requores_grad:是否需要梯度 pin_memory:是否存于锁页内存 torch.from_numpy(n
  • 张量的创建

    2019-12-16 09:38:04
    Variable 是torch.autograd中的数据类型(0.4.0之前)主要用于封装Tensor,进行自动求导 data: 被包装的Tensor grad:data 的梯度 grad_fn 创建Tensor的Function,是自动求导的关键 requires_grad: 指示是否需要梯度 ...
  • pytorch学习笔记(1)

    2020-10-04 16:47:42
    pytorch学习笔记(1) 学习教程:《动手学深度学习 PYTORCH 版(DEMO)》 目录pytorch学习笔记(1)Tensor对张量进行操作线性代数tensor on gpu自动求梯度 Tensor 首先导入pytorch ... # dtype:数据类型,device:
  • 2021-01-06

    2021-01-06 23:21:53
    pytorch笔记 1.6 numpy_torch 与data转化 data = [-1,-2,1,2] tensor = torch.FloatTensor(data) numpy_data = tensor.numpy() ...注意:对于torch的相关属性里面必须传入tensor类型数据 更新梯度 tens
  • dtype:张量的数据类型 如:torch.FloatTensor shape:张量的形状 device:张量所在的设备 requires_grad:是否需要求导 grad:data的梯度 grad_fn:创建Tensor的function is_leaf:是否为叶子结点 1.直接创建 通过...
  • 一、直接创建 1.1 通过torch.tensor创建张量 torch.tensor( ...dtype:数据类型,默认与data一致 device:所在设备,cuda/cpu requires_grad:是否需要梯度 pin_memory:是否存于锁页内存 举例:
  • Pytorch学习进度记录

    2020-09-25 14:23:00
    dtype: 数据类型,默认与data一致 device: 所在设备,cuda/cpu requires_grad: 是否需要梯度 pin_memory: 是否存于锁页内存 torch.tensor( data, dtype = None, device = None, requires_grad = False; pin_...
  • 一、直接创建 1.1 通过torch.tensor创建张量 torch.tensor( ...dtype:数据类型,默认与data一致 device:所在设备,cuda/cpu requires_grad:是否需要梯度 pin_memory:是否存于锁页内存 举例:

空空如也

空空如也

1 2 3 4
收藏数 71
精华内容 28
关键字:

torch梯度数据类型