PyTorch 笔记（02）— 常用创建 Tensor 方法（torch.Tensor、ones、zeros、eye、arange、linspace、rand、randn、new）_torch.tensor.eye

1. Tensor 概念分类

PyTorch 中的张量（Tensor）类似 NumPy 中的 ndarrays，之所以称之为 Tensor 的另一个原因是它可以运行在 GPU 中，以加速运算。

1.1 从接口的角度分类

对 Tensor 的操作可分为以下两类：

1. torch.function，如 torch.save 等；
2. tensor.function，如 tensor.view 等；

为方便使用，对 Tensor 的大部分操作同时支持这两种接口，比如 torch.sum(a, b) 和 a.sum(b) 功能是等价的。

1.2 从存储的角度分类

对 Tensor 的操作又可分为以下两类：

1. 不会修改自身的数据，如 a.add(b)，加法结果会返回一个新的 tensor；
2. 会修改自身的数据，如 a.add_(b)，加法结果仍储存在 a 中，但是 a 已经被修改了；

注意：函数名以 _ 结尾的都是 inplace 方式，即会修改调用者自己的数据。

2. Tensor 创建方法

PyTorch 中的 Tensor 也有自己的数据类型定义方式，常用的如下。

2.1 torch.Tensor

需要注意的是，使用 torch.Tensor(*sizes) 创建 Tensor 时，系统不会立即分配空间，只会计算当前内容空间是否够用，使用到 Tensor 时才会分配，而其它操作都会在创建完成后立即进行空间分配。

用于创建一个 Tensor ，即可接受 list 作为参数，也可以接受指定形状作为参数，还能传入其它的 tensor 。

• Tensor 接受形状参数，创建一个 2*3 的 Tensor

In [1]: import torch as t                                                                                                                                            

In [2]: a = t.Tensor(2,3)                                                                                                                                            

In [3]: a                                                                                                                                                            
Out[3]: 
tensor([[2.6380e+23, 1.3070e-14, 4.4721e+21],
        [6.8233e+22, 3.0217e+32, 4.6161e+24]])

In [4]: a.type()                                                                                                                                                     
Out[4]: 'torch.FloatTensor'
1
2
3
4
5
6
7
8
9
10
11

• 将列表转换为 Tensor

In [5]: b = t.Tensor([[1,2], [3,4]])                                                                                                                                 

In [6]: b                                                                                                                                                            
Out[6]: 
tensor([[1., 2.],
        [3., 4.]])

In [7]: b.type()                                                                                                                                                     
Out[7]: 'torch.FloatTensor'
1
2
3
4
5
6
7
8
9

• Tensor 转换为 list

In [5]: b = t.Tensor([[1,2], [3,4]])                                                                                                                                 

In [6]: b                                                                                                                                                            
Out[6]: 
tensor([[1., 2.],
        [3., 4.]])

In [7]: b.type()                                                                                                                                                     
Out[7]: 'torch.FloatTensor'

In [8]: b.tolist()                                                                                                                                                   
Out[8]: [[1.0, 2.0], [3.0, 4.0]]

In [9]: type(b.tolist())                                                                                                                                             
Out[9]: list
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

• 创建一个元素为 2 和 3 的 Tensor

In [10]: c = t.Tensor((2,3))                                                                                                                                         

In [11]: c                                                                       
Out[11]: tensor([2., 3.])

In [12]: c.type()                                                                     
Out[12]: 'torch.FloatTensor'
1
2
3
4
5
6
7

2.2 torch.ones

用于生成数据类型为浮点型且维度指定的 Tensor，不过这个浮点型的 Tensor中的元素值全部为 1，dtype 参数可以指定其数据类型。

In [1]: import torch as  t                                                                                                                                            

In [2]: t.ones(2,3)                                                                                                                                                  
Out[2]: 
tensor([[1., 1., 1.],
        [1., 1., 1.]])
        
In [3]: t.ones(2,3, dtype=t.int)                                                                                                                                     
Out[3]: 
tensor([[1, 1, 1],
        [1, 1, 1]], dtype=torch.int32)

In [4]:   
1
2
3
4
5
6
7
8
9
10
11
12
13

2.3 torch.zeros

用于生成数据类型为浮点型且维度指定的 Tensor，不过这个浮点型的 Tensor中的元素值全部为 0，dtype 参数可以指定其数据类型。

import torch

a = torch.zeros(2, 3, dtype=torch.int8)
print a

1
2
3
4
5

输出结果：

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

2.4 torch.eye

用于生成数据类型为浮点型且维度指定的 Tensor，不过这个浮点型的 Tensor中对角线元素均为 1 ，dtype 参数可以指定其数据类型。

In [5]: t.eye(3,3)                                                                                                                                                   
Out[5]: 
tensor([[1., 0., 0.],
        [0., 1., 0.],
        [0., 0., 1.]])

In [6]:  
1
2
3
4
5
6
7

2.5 torch.arange

用于生成数据类型为浮点型且自定义起始范围和结束范围的 Tensor，所以传递给 torch.linspace 的参数有三个，分别是范围的起始值、范围的结束值和步长，其中，步长用于指定从起始值到结束值的每步的数据间隔。

import torch

a = torch.arange(1, 10, 2)

1
2
3
4

输出结果：

tensor([1, 3, 5, 7, 9])
1

2.6 torch.linspace

用于生成数据类型为长整型且自定义起始范围和结束范围的 Tensor，所以传递给 torch.arange 的参数有三个，分别是范围的起始值、范围的结束值和均匀分成的份数，其中，份数用于将起始值和结束值划分为几份。

In [7]: t.linspace(1, 10, 5)                                                                                                                                         
Out[7]: tensor([ 1.0000,  3.2500,  5.5000,  7.7500, 10.0000])

In [8]: t.linspace(1, 11, 5)                                                                                                                                         
Out[8]: tensor([ 1.0000,  3.5000,  6.0000,  8.5000, 11.0000])

In [9]:  
1
2
3
4
5
6
7

2.7 torch.rand

用于生成数据类型为浮点型且维度指定的随机 Tensor，和在 NumPy 中使用 numpy.rand 生成随机数的方法类似，随机生成的浮点数据在 0~1 区间均匀分布。

import torch

a = torch.rand(2, 3)

1
2
3
4

输出结果：

tensor([[0.6882, 0.4118, 0.2646],
        [0.0583, 0.2187, 0.8093]])
1
2

2.8 torch.randn

用于生成数据类型为浮点型且维度指定的随机 Tensor，和在 NumPy 中使用 numpy.randn 生成随机数的方法类似，随机生成的浮点数的取值满足均值为 0、方差为 1 的正态分布。

import torch

a = torch.randn(2, 3)

1
2
3
4

输出结果：

tensor([[ 0.2214, -0.0139, -0.0720],
        [ 0.2548, -1.3364,  0.3924]])
1
2

2.9 torch.new

Tensor 还有一个 new 方法，用法与 t.Tensor 一样， 会调用该 Tensor 对应类型的构造函数，生成与当前 tensor 类型一致的 tensor。

In [126]: a = t.Tensor(2,3)                                                                                                                                          

In [127]: a                                                                                                                                                          
Out[127]: 
tensor([[ 1.8829e+26,  4.5702e-41, -2.4199e-18],
        [-1.1804e+24,  2.3408e+26,  4.5702e-41]])

In [128]: a.new(2,3)                                                                                                                                                 
Out[128]: 
tensor([[-7.1914e+16,  4.5702e-41,  3.3177e+05],
        [ 0.0000e+00,  2.3408e+26,  4.5702e-41]])

In [129]: a.new(3,4)                                                                                                                                                 
Out[129]: 
tensor([[-7.1914e+16,  4.5702e-41,  3.4704e+05,  0.0000e+00],
        [-7.1913e+16,  4.5702e-41, -7.1913e+16,  4.5702e-41],
        [-7.6770e+16,  4.5702e-41, -7.6770e+16,  4.5702e-41]])

In [130]: a.new(3,4).type()                                                                                                                                          
Out[130]: 'torch.FloatTensor'

In [131]:   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22