Tensor数据类型

数据类型 dtype CPU tensor GPU tensor
32位浮点 torch.float32\torch.float torch.FloatTensor torch.cuda.FloatTensor
64位浮点 torch.float64\torch.double torch.DoubleTensor torch.cuda.DoubleTensor
16位浮点(1) torch.float16\torch.half torch.HalfTensor torch.cuda.HalfTensor
16位浮点(2) torch.bfloat16 torch.BFloat16Tensor torch.cuda.BFloat16Tensor
32位复数 torch.complex32
64位复数 torch.complex64
128位复数 torch.complex128\torch.cdouble
8位无符号整型 torch.uint8 torch.ByteTensor torch.cuda.ByteTensor
8位有符号整型 torch.int8 torch.CharTensor torch.cuda.CharTensor
16位有符号整型 torch.int16\torch.short torch.ShortTensor torch.cuda.ShortTensor
32位有符号整型 torch.int32\torch.int torch.IntTensor torch.cuda.IntTensor
64位有符号整型 torch.int64\torch.long torch.LongTensor torch.cuda.LongTensor
布尔 torch.bool torch.BoolTensor torch.cuda.BoolTensor
  • 16位半精度浮点是专为GPU上运行的模型设计的，以尽可能地节省GPU显存占用，但这种节省显存空间的方式也缩小了所能表达数据的大小。PyTorch中默认的数据类型是torch.FloatTensor，即torch.Tensor等同于torch.FloatTensor。
  • PyTorch可以通过set_default_tensor_type函数设置默认使用的Tensor类型，在局部使用完后如果需要其他类型，则还需要重新设置回所需的类型。
    例：torch.set_default_tensor_type('torch.DoubleTensor')

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
33
34
35
36
37
38
39
40
41
import torch
#创建一个新的tensor，默认类型位32位浮点(torch.FloatTensor)
a = torch.Tensor(3,3)
print(a)
#转int类型
b = a.int()
print(b)
#转float类型
c = a.float()
print(c)
#转double类型
d = a.double()
print(d)
#转16位浮点类型
e = a.type(torch.HalfTensor)
print(e)
#转变量e的相同类型
f = a.type_as(e)
print(f)
'''
result:

a = tensor([[6.3058e-44, 6.7262e-44, 7.8473e-44],
            [6.3058e-44, 6.8664e-44, 7.2868e-44],
            [1.1771e-43, 6.7262e-44, 7.7071e-44]])
b = tensor([[0, 0, 0],
            [0, 0, 0],
            [0, 0, 0]], dtype=torch.int32)
c = tensor([[6.3058e-44, 6.7262e-44, 7.8473e-44],
            [6.3058e-44, 6.8664e-44, 7.2868e-44],
            [1.1771e-43, 6.7262e-44, 7.7071e-44]])
d = tensor([[6.3058e-44, 6.7262e-44, 7.8473e-44],
            [6.3058e-44, 6.8664e-44, 7.2868e-44],
            [1.1771e-43, 6.7262e-44, 7.7071e-44]], dtype=torch.float64)
e = tensor([[0., 0., 0.],
            [0., 0., 0.],
            [0., 0., 0.]], dtype=torch.float16)
f = tensor([[0., 0., 0.],
            [0., 0., 0.],
            [0., 0., 0.]], dtype=torch.float16)
'''

Tensor的创建与维度查看

  1. 常规创建
    例：a = torch.Tensor(2,2)
  2. 指定类型创建
    例：a = torch.HalfTensor(2,2)
  3. 直接使用Python的list创建
    例：a = torch.Tensor([[2,2],[3,3]])
  4. 创建一个元素全为0的tensor
    例：a = torch.zeros(2, 2)
  5. 创建一个元素全为1的tensor
    例：a = torch.ones(2, 2)
  6. 创建一个对角线元素全为1的2维矩阵，行列可以不相同，可用于构造单位矩阵
    例：a = torch.eye(2, 2)
  7. 创建一个随机tensor
    例：a = torch.randon(2, 2)
  8. 创建一个随机排列的1维向量
    例：a = torch.randperm(n)#长度为n
  9. torch.arange(start, end, step)
    创建一个从start到end，间距为step，1维向量
  10. torch.linspace(start, end, step)
    创建一个从start到end，一共steps份，1维向量
  11. 查看tensor的维度
    例：a.shape 或 a.size()
  12. 查看tensor的元素总个数
    例：a.numel() 或 a.nelement()

    Tensor的组合与分块

  13. torch.cat()
    沿着已有的数据的某一维度进行拼接，操作后数据的总维数不变，在进行拼接时，除了拼接的维度之外，其他维度必须相同
    例：
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    import torch
    a = torch.Tensor([[2,2],[3,3]])
    b = torch.Tensor([[4,4],[5,5]])
    print(a)
    print(b)
    c = torch.cat([a,b], 0) #沿着第1维拼接
    print(c)
    print(c.size())
    '''
    result:

    a = tensor([[2., 2.],
                [3., 3.]])
    b = tensor([[4., 4.],
                [5., 5.]])
    c = tensor([[2., 2.],
                [3., 3.],
                [4., 4.],
                [5., 5.]])
    c.size = torch.Size([4, 2])
    '''
  14. torch.stack()
    新增维度，并按照指定的维度进行叠加
    例：
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    import torch
    a = torch.Tensor([[2,2],[3,3]])
    b = torch.Tensor([[4,4],[5,5]])
    print(a)
    print(b)
    d = torch.stack([a,b],1) #沿着第1维拼接
    print(d)
    print(d.size())
    '''
    result:

    a = tensor([[2., 2.],
                [3., 3.]])
    b = tensor([[4., 4.],
                [5., 5.]])
    d = tensor([[[2., 2.],
                [4., 4.]],

                [[3., 3.],
                 [5., 5.]]])
    torch.Size([2, 2, 2])
  15. torch.chunk()
    将Tensor分割成不同的子Tensor，需要指定分块的数量
    例：
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    import torch
    a = torch.Tensor([[2,3,4],[2,3,4]])
    print(a)
    # 沿着第1维进行分块，因此分割成两个Tensor，当不能整除时，最后一个的维数会小于前面的
    # 因此第一个Tensor为2×2，第二个为2×1
    d = torch.chunk(a,2,1)
    print(d)
    '''
    result：

    a = tensor([[2., 3., 4.],
                [2., 3., 4.]])
    d = (tensor([[2., 3.],
                 [2., 3.]]), tensor([[4.],
                                    [4.]]))
    '''
  16. torch.split()
    将Tensor分割成不同的子Tensor，需要指定每一块的大小，以整型或者list来表示
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    import torch
    a = torch.Tensor([[2,3,4],[2,3,4]])
    print(a)
    # 沿着第1维分块，每一块维度为2，因此第一个Tensor为2×2，第二个为2×1
    b = torch.split(a,2,1)
    print(b)
    # split也可以根据输入的list进行自动分块，list中的元素代表了每一个块占的维度
    c = torch.split(a,[1,2],1)
    print(c)
    '''
    result:

    a = tensor([[2., 3., 4.],
                [2., 3., 4.]])
    b = (tensor([[2., 3.],
                 [2., 3.]]), tensor([[4.],
                                    [4.]]))
    c = (tensor([[2.],
                 [2.]]), tensor([[3., 4.],
                                 [3., 4.]]))
    '''