引言

本篇介绍创建tensor的几种方式

Import from numpy

  • from_numpy()
  • float64 是 double 类型，也就是说从numpy导入的float其实是double类型。
  • 从numpy导入的 int 还是 int 类型
  1. 1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
 
  1. In[2]: import numpy as np
    In[3]: import torch
    In[4]: a = np.array([2,3.3])
    In[5]: torch.from_numpy(a)
    Out[5]: tensor([2.0000, 3.3000], dtype=torch.float64)
  2.  
  3. In[6]: a = np.ones([2,3])
    In[7]: torch.from_numpy(a)
    Out[7]: 
    tensor([[1., 1., 1.],
            [1., 1., 1.]], dtype=torch.float64)

Import from List

  • 数据量不是很大，不需要numpy作为载体
  • torch.tensor([ ]) 、 torch.FloatTensor([ ]) 、 torch.Tensor([ ])关系在后面介绍
  • tensor 与 Tensor易混淆
  • 多使用tensor。
  1. 1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
 
  1. # 一维
    In[17]: torch.tensor([2, 3.2])
    Out[17]: tensor([2.0000, 3.2000])
    # 二维 
    In[19]: torch.tensor([[2,3.2],[1,22.3]])
    Out[19]: 
    tensor([[ 2.0000,  3.2000],
            [ 1.0000, 22.3000]])
    # 查看数据类型
    In[20]: a = torch.tensor([[2,3.2],[1,22.3]])
    In[21]: a.type()
    Out[21]: 'torch.FloatTensor'
  2.  
  3. # tensor 与 Tensor 易混淆
    # tensor只能接收数据，来对向量进行创建
    # Tensor既可以通过维度来创建向量，也可以通过接收数据来创建向量.
    # 两者的区别在于：前者是以参数的形式(维度1，维度2，...)来组织形状，后者的数据必须放在列表中([数据1,数据2,...]).
    # 但建议使用tensor来接收向量，这样减少混淆。
    In[24]: a = torch.Tensor([2,3])
    In[25]: a
    Out[25]: tensor([2., 3.])
    In[32]: a = torch.Tensor(2,3)
    In[33]: a
    Out[33]: 
    tensor([[0., 0., 0.],
            [0., 0., 0.]])
  4.  
  5. a = torch.FloatTensor([1,2])
    b = torch.tensor([1,2])
    b.type()
    Out[42]: 'torch.LongTensor'
    # 结论：torch.FloatTensor([1,2]) 不等于 torch.tensor([1,2])
  • torch.tensor() 与 torch.Tensor() 默认 生成 torch.FloatTensor 类型，增强学习中多为 torch.DoubleTensor
  • 通过 torch.set_default_tensor_type(torch.DoubleTensor) 来更改
  • torch.tensor() 如果列表中都是int类型，则它会生成 torch.LongTensor
  1. 1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
 
  1. In[173]: a = torch.tensor([2.2,3])
    In[174]: a.type()
    Out[174]: 'torch.FloatTensor'
  2.  
  3. In[178]: torch.set_default_tensor_type(torch.DoubleTensor)
    In[179]: a = torch.tensor([2.2,3])
    In[180]: a.type()
    Out[180]: 'torch.DoubleTensor'
  4.  
  5. 但是对于 tensor([2,3]) 创建的是int64类型的
    In[181]: a = torch.tensor([2,3])
    In[182]: a.type()
    Out[182]: 'torch.LongTensor'
  6.  
  7. a = torch.Tensor([2,3])
    a.type()
    Out[188]: 'torch.FloatTensor'
    # torch.Tensor is an alias for the default tensor type (torch.FloatTensor).

data uninitialized

生成未初始化的数据

  • torch.empty(d1,d2,d3)
  • torch.FloatTensor(d1,d2,d3)
  • torch.IntTensor(d1,d2,d3)

未初始化的tensor将出现的问题

  1. 1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
 
  1. torch.empty(1)
    Out[50]: tensor([0.])
    torch.Tensor(2,3)
    Out[51]: 
    tensor([[0.0000e+00, 0.0000e+00, 1.4013e-45],
            [0.0000e+00, 1.4013e-45, 0.0000e+00]])
    torch.IntTensor(2,3)
    Out[52]: 
    Out[78]: 
    tensor([[1902983832,      32767,          6],
            [         0,          1,          0]], dtype=torch.int32)
    torch.FloatTensor(2,3)
    Out[53]: 
    tensor([[1.1747e+30, 4.5916e-41, 1.4013e-45],
            [0.0000e+00, 1.4013e-45, 0.0000e+00]])
  • 这些数据有的特别特别小，有的特别特别大
  • 这些数据如果没有后续的处理覆盖，将会产生bug，例如：可能在后面产生无穷大的数
  1. 1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
 
  1. torch.isnan(torch.Tensor(2,3))
    # 其布尔元素表示每个元素是否为 'nan'
    Out[55]: 
    tensor([[0, 0, 0],
            [0, 0, 0]], dtype=torch.uint8)
    a = torch.FloatTensor(2,3)
    torch.isnan(a)
    Out[57]: 
    tensor([[0, 0, 0],
            [0, 0, 0]], dtype=torch.uint8)
    torch.isfinite(a)
    # 其布尔元素表示每个元素是否为有限元素
    Out[58]: 
    tensor([[1, 1, 1],
            [1, 1, 1]], dtype=torch.uint8)
    # 虽然这里都是正常的，但存在后面出现问题的可能
  • tensor只是一个容器，后面会将自己的数据放入的。

rand/rand_like, randint

随机初始化

推荐使用随机初始化。

  • rand 会随机的在[0, 1] 之间取一个数。
  • rand_like( a ) 读取向量 a 的shape在送到rand函数
  • randint 先指定区间 [ min, max ) ,然后指定shape，shape要放在列表或元组中
  1. 1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
 
  1. In[189]: torch.rand(3,3)
    Out[189]: 
    tensor([[0.1364, 0.6610, 0.7115],
            [0.5758, 0.2318, 0.0798],
            [0.1356, 0.9596, 0.3406]])
    In[190]: a = torch.rand(3,3)
    In[191]: torch.rand_like(a)
    Out[191]: 
    tensor([[0.5966, 0.9067, 0.6670],
            [0.5968, 0.1216, 0.3202],
            [0.8507, 0.3520, 0.4741]])
  2.  
  3. In[193]: torch.randint(1,10,(3,3))
    Out[193]: 
    tensor([[7, 3, 8],
            [8, 2, 1],
            [8, 4, 8]])
    In[194]: torch.randint(1,10,[3,3])
    Out[194]: 
    tensor([[3, 8, 2],
            [3, 5, 2],
            [8, 8, 3]])

N(0, 1)

  • randn()
  • 均值为0，方差为1，数据集中在0附近
  • 权值w 或 偏置 b 的一个初始化

N(u, std)

  • normal()
  1. 1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
 
  1. In[201]: torch.randn(3,3)
    Out[201]: 
    tensor([[ 0.3099, -0.8410, -0.3561],
            [ 1.0023, -0.4343,  0.3544],
            [-0.7071, -0.3124, -0.3938]])
    In[202]: torch.normal(mean=torch.full([10], 0), std=torch.arange(1, 0, -0.1))
    Out[202]: 
    tensor([-3.5323e-01,  7.4789e-01,  5.8816e-01,  1.9938e+00,  3.8165e-01,
            -9.8357e-01,  5.2820e-01, -1.6654e-02, -4.8233e-02,  9.7792e-04])
    In[203]: torch.normal(mean=torch.full([10], 0), std=torch.arange(1, 0, -0.1))
    Out[203]: 
    tensor([-0.3920,  1.2376,  0.3669, -0.8245, -1.2928,  0.4541, -0.0843,  0.1847,
            -0.1818, -0.0868])
  2.  
  3. # full方法解释
    # 生成二维向量
    In[204]: torch.full([2,3],7)
    Out[204]: 
    tensor([[7., 7., 7.],
            [7., 7., 7.]])
  4.  
  5. # 生成一维向量
    In[206]: torch.full([1],7)
    Out[206]: tensor([7.])
  6.  
  7. # 生成标量
    In[205]: torch.full([],7)
    Out[205]: tensor(7.)

arange/range

  • 生成等差数列 arange() ,默认以1来递增
  • range现在已经不建议使用了
  1. 1
    2
    3
    4
    5
    6
    7
    8
 
  1. In[207]: torch.arange(0,10)
    Out[207]: tensor([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
    In[208]: torch.arange(0,10,2)
    Out[208]: tensor([0, 2, 4, 6, 8])
    In[209]: torch.range(0,10)
    G:\PyCharm 2019.1.3\helpers\pydev\pydevconsole.py:1: UserWarning: torch.range is deprecated in favor of torch.arange and will be removed in 0.5. Note that arange generates values in [start; end), not [start; end].
      '''
    Out[209]: tensor([ 0.,  1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

linspace/logspace

  • 等分 linspace() [0,10] , steps=4
  • logspace() 也是等分，不过是以10^x 来得到输出的。
  1. 1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
 
  1. In[210]: torch.linspace(0,10, steps=4)
    Out[210]: tensor([ 0.0000,  3.3333,  6.6667, 10.0000])
  2.  
  3. # 将11个数 切成10个
    In[211]: torch.linspace(0,10, steps=10)
    Out[211]: 
    tensor([ 0.0000,  1.1111,  2.2222,  3.3333,  4.4444,  5.5556,  6.6667,  7.7778,
             8.8889, 10.0000])
    In[212]: torch.linspace(0,10, steps=11)
    Out[212]: tensor([ 0.,  1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])
  4.  
  5. # 将 0->-1 切成10份，然后乘10
    In[213]: torch.logspace(0,-1,steps=10)
    Out[213]: 
    tensor([1.0000, 0.7743, 0.5995, 0.4642, 0.3594, 0.2783, 0.2154, 0.1668, 0.1292,
            0.1000])
    In[214]: torch.logspace(0,1,steps=10)
    Out[214]: 
    tensor([ 1.0000,  1.2915,  1.6681,  2.1544,  2.7826,  3.5938,  4.6416,  5.9948,
             7.7426, 10.0000])

ones/zeros/eye

  • ones() 生成全部为1的
  • zeros() 生成全部为0的
  • eye() 生成单位向量
  1. 1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
 
  1. In[215]: torch.ones(3,3)
    Out[215]: 
    tensor([[1., 1., 1.],
            [1., 1., 1.],
            [1., 1., 1.]])
    In[216]: torch.zeros(3,3)
    Out[216]: 
    tensor([[0., 0., 0.],
            [0., 0., 0.],
            [0., 0., 0.]])
    In[219]: torch.eye(3,4)
    Out[219]: 
    tensor([[1., 0., 0., 0.],
            [0., 1., 0., 0.],
            [0., 0., 1., 0.]])
  2.  
  3. In[220]: torch.eye(3)
    Out[220]: 
    tensor([[1., 0., 0.],
            [0., 1., 0.],
            [0., 0., 1.]])
    In[221]: a = torch.zeros(3,3)
    In[222]: torch.ones_like(a)
    Out[222]: 
    tensor([[1., 1., 1.],
            [1., 1., 1.],
            [1., 1., 1.]])

randperm

  • 随机打散 (numpy中是 random.shuffle)
  • randperm()
  1. 1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
 
  1. In[223]: torch.randperm(10)
    Out[223]: tensor([8, 1, 0, 4, 9, 3, 7, 6, 2, 5])
    In[224]: a = torch.rand(2,3)
    In[225]: b = torch.rand(2,2)
    In[226]: idx = torch.randperm(2)
    In[227]: idx
    Out[227]: tensor([1, 0])
        # [1,0] 相反；[0,1]维持不变
  2.  
  3. # 需要用同一个索引/维度来shuffle，协同shuffle，保持配对
    In[232]: a[idx]
    Out[232]: 
    tensor([[0.8259, 0.7368, 0.3033],
            [0.2103, 0.2943, 0.0866]])
    In[233]: b[idx]
    Out[233]: 
    tensor([[0.4822, 0.2033],
            [0.3809, 0.8047]])
    In[234]: a,b
    Out[234]: 
    (tensor([[0.2103, 0.2943, 0.0866],
             [0.8259, 0.7368, 0.3033]]), tensor([[0.3809, 0.8047],
             [0.4822, 0.2033]]))
 

Pytorch-创建tensor的更多相关文章

  1. pytorch 创建tensor的几种方法

    tensor默认是不求梯度的,对应的requires_grad是False. 1.指定数值初始化 import torch #创建一个tensor,其中shape为[2] tensor=torch.T ...

  2. pytorch——不用包模拟简单线性预测，数据类型，创建tensor，索引与切片

    常见的学习种类 线性回归,最简单的y=wx+b型的,就像是调节音量大小.逻辑回归,是否问题.分类问题,是猫是狗是猪 最简单的线性回归y=wx+b 目的:给定大量的(x,y)坐标点,通过机器学习来找出最 ...

  3. 对pytorch中Tensor的剖析

    不是python层面Tensor的剖析,是C层面的剖析. 看pytorch下lib库中的TH好一阵子了,TH也是torch7下面的一个重要的库. 可以在torch的github上看到相关文档.看了半天 ...

  4. pytorch中tensor张量数据基础入门

    pytorch张量数据类型入门1.对于pytorch的深度学习框架,其基本的数据类型属于张量数据类型,即Tensor数据类型,对于python里面的int,float,int array,flaot ...

  5. pytorch之Tensor

    #tensor和numpy import torch import numpy as np numpy_tensor = np.random.randn(3,4) print(numpy_tensor ...

  6. 创建Tensor

    目录 创建Tensor numpy, list numpy list zeros, ones, fill zeros ones fill random 打乱idx后,a和b的索引不变 constant ...

  7. pytorch中tensor数据和numpy数据转换中注意的一个问题

    转载自:(pytorch中tensor数据和numpy数据转换中注意的一个问题)[https://blog.csdn.net/nihate/article/details/82791277] 在pyt ...

  8. pytorch中tensor张量的创建

    import torch import numpy as np print(torch.tensor([1,2,3])) print(torch.tensor(np.arange(15).reshap ...

  9. [Pytorch]Pytorch中tensor常用语法

    原文地址:https://zhuanlan.zhihu.com/p/31494491 上次我总结了在PyTorch中建立随机数Tensor的多种方法的区别. 这次我把常用的Tensor的数学运算总结到 ...

  10. [Pytorch]Pytorch的tensor变量类型转换

    原文:https://blog.csdn.net/hustchenze/article/details/79154139 Pytorch的数据类型为各式各样的Tensor,Tensor可以理解为高维矩 ...

随机推荐

  1. css全部理解

    如何设置标签样式 给标签设置长宽 只有块儿级标签才可以设置长宽 行内标签设置了没有任何作用(仅仅只取决于内部文本值) 字体颜色 color后面可以跟多种颜色数据 颜色英文 red #06a0de 直接 ...

  2. 数据库中char和varchar的区别

    1. char类型的长度是固定的,varchar的长度是可变的. 这就表示,存储字符串'abc',使用char(10),表示存储的字符将占10个字节(包括7个空字符) 使用varchar2(10),, ...

  3. [BZOJ 1095] [ZJOI2007]Hide 捉迷藏——线段树+括号序列(强..)

    神做法-%dalao,写的超详细 konjac的博客. 如果觉得上面链接的代码不够优秀好看,欢迎回来看本蒟蒻代码- CODE WITH ANNOTATION 代码中−6-6−6表示左括号'[',用−9 ...

  4. robotframework 获取坐标

    Get Horizontal Position  获取X轴坐标 Get Vertical Position      获取Y轴坐标 Get Element Size          获取整个图表的高 ...

  5. java——ThreadLocal、ThreadLocalMap、Thread三者的关系

    https://www.jianshu.com/p/377bb840802f Thread类中维护了一个成员变量:ThreadLocalMap 每个Thread有一个自己的ThreadLocalMap ...

  6. JSP页面的Page指令指定编码和Meta标签编码

    JSP代码如下: <%@ page language="java" contentType="text/html; charset=UTF-8" page ...

  7. linux下ssh免秘钥登录

    1.检查防火墙是否关闭 (1)切换到root用户 (2)查看防火墙状态 service iptables status 这是没有关闭 (3)设置关闭 service iptables stop 2.检 ...

  8. HGOI 20190828 题解

    Problem A 数学题 设数论函数$f(x)$表示$x(x ∉ Prime)$的次大因数, 给出$l,r$求出$\sum\limits_{i=l,i ∉ Prime} ^r f(i)$ . 对于$ ...

  9. Node.js 安装与开发

    Node.js 简介 Node.js是一个Javascript运行环境(runtime),发布于2009年5月,由Ryan Dahl开发,实质是对Chrome V8引擎进行了封装.Node.js对一些 ...

  10. jQuery文档操作之插入操作

    append() 语法 父元素.append(子元素) 解释:追加某元素,在父元素中添加新的子元素.子元素可以为:string/element(js对象)/jQuery元素 代码如下: var oli ...