引言

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

Import from numpy

  • from_numpy()
  • float64 是 double 类型，也就是说从numpy导入的float其实是double类型。
  • 从numpy导入的 int 还是 int 类型
1
2
3
4
5
6
7
8
9
10
11
 
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)

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
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
 
# 一维
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'

# 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.]])

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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
In[173]: a = torch.tensor([2.2,3])
In[174]: a.type()
Out[174]: 'torch.FloatTensor'

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'

但是对于 tensor([2,3]) 创建的是int64类型的
In[181]: a = torch.tensor([2,3])
In[182]: a.type()
Out[182]: 'torch.LongTensor'

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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
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]])

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
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
 
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])

# full方法解释
# 生成二维向量
In[204]: torch.full([2,3],7)
Out[204]: 
tensor([[7., 7., 7.],
        [7., 7., 7.]])

# 生成一维向量
In[206]: torch.full([1],7)
Out[206]: tensor([7.])

# 生成标量
In[205]: torch.full([],7)
Out[205]: tensor(7.)

arange/range

  • 生成等差数列 arange() ,默认以1来递增
  • range现在已经不建议使用了
1
2
3
4
5
6
7
8
 
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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
In[210]: torch.linspace(0,10, steps=4)
Out[210]: tensor([ 0.0000,  3.3333,  6.6667, 10.0000])

# 将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.])

# 将 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
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
 
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.]])

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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
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]维持不变

# 需要用同一个索引/维度来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. openGL中的gl,glu,glut

    OpenGL函数库相关的API有核心库(gl).实用库(glu).辅助库(aux).实用工具库(glut).窗口库(glx.agl.wgl)和扩展函数库等.gl是核心,glu是对gl的部分封装.glx ...

  2. Java常用类(二) Scanner类和大数类

    二.Scanner类 有C系语言基础的可能都比较熟悉scanf("%d",&a);和cin>>a;这种代码,也打开了程序交互的第一道门.因此,这些程序员开始学J ...

  3. BZOJ 3594: [Scoi2014]方伯伯的玉米田 (二维树状数组优化DP)

    分析 首先每次增加的区间一定是[i,n][i,n][i,n]的形式.因为如果选择[i,j](j<n)[i,j](j<n)[i,j](j<n)肯定不如把后面的全部一起加111更优. 那 ...

  4. Acwing-204-表达整数的奇怪方式(扩展中国剩余定理)

    链接: https://www.acwing.com/problem/content/206/ 题意: 给定2n个整数a1,a2,-,an和m1,m2,-,mn,求一个最小的非负整数x,满足∀i∈[1 ...

  5. Spring下的@Order和@Primary与javax.annotation-api下@Priority【Spring4.1后】等方法控制多实现的依赖注入(转)

    @Order 可以作用在类.方法.属性. 影响加载顺序. 若不加,spring的加载顺序是随机的. @Primary 当注入bean冲突时,以@Primary定义的为准. @Order是控制配置类的加 ...

  6. 【Python之路】特别篇--Bottle

    Bottle Bottle是一个快速.简洁.轻量级的基于WSIG的微型Web框架,此框架只由一个 .py 文件,除了Python的标准库外,其不依赖任何其他模块. Bottle框架大致可以分为以下部分 ...

  7. bootstrap列表组的使用

    <ul class="list-group"> <li class="list-group-item"> <div class=& ...

  8. 7.9模拟赛T1图的遍历（dfs）

    图的遍历(dfs) [题目描述] 对于一个有向图G来说,我们存在一个经典的遍历算法,就是DFS (深度优先搜索遍历).将G以1号点为起点进行DFS后,我们可以 得到G的一棵DFS遍历树T.就此,我们可 ...

  9. C#如何生成setup安装文件

    当前项目状况如图: ,如何把test1打包成setup文件,用户安装后即可完成相应功能. 第一,右击“解决方案test1”->添加“新建项目”->“其他项目类型”->“安装和部署”- ...

  10. 化学结构SDF文件

    参考博客 第一行:一般作为分子名字,如 Levetiracetam 第二行:注释,ChemDraw06111413562D 第三行:一般是空行 第四行:是原子个数 键的个数等的起始行. M END所在 ...