一、Pytorch中tensor的类型与数据类型

torch.Tensor是一种包含元素的多维矩阵，但这些元素属于单一数据类型元素（与list不同，list可以在同一序列中存储不一样类型的元素）。

1.0 默认类型与数据类型

torch.Tensor是默认的tensor类型（torch.FlaotTensor）的简称，并且默认放置于CPU上，使用该类型声明的时候会生成类型为torch.FloatTensor，数据类型为torch.float32的数据。

torch.ensor是默认的tensor类型（torch.LongTensor）的简称，并且默认放置于CPU上，使用该类型声明的时候会生成类型为torch.LongTensor，数据类型为torch.int64的数据。

注意：不存在torch.cuda.Tensor或者torch.cuda.tensor

import torch
print("测试开始")

print("==默认Tensor数据类型==")
tensor= torch.Tensor([1,2])
print("type(tensor):",type(tensor))
print("tensor.type():",tensor.type())
print("tensor.dtype:",tensor.dtype)
print("tensor.is_cuda:",tensor.is_cuda)


print("==默认tensor数据类型==")
tensor= torch.tensor([1,2])
print("type(tensor):",type(tensor))
print("tensor.type():",tensor.type())
print("tensor.dtype:",tensor.dtype)
print("tensor.is_cuda:",tensor.is_cuda)

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17

1.1 tensor类型与数据类型总览

Pytorch中定义了8种CPU张量类型和对应的8种GPU张量类型，（相同的CPU张量，GPU张量类型分别对应的存储数据类型相同），具体对应关系见下表：

1.2 tensor类型与数据类型的显示

针对这16种tensor变量使用type()函数得出的结果都是

求解具体的张量类型需要使用，tensor_name.type()

求解对应的数据存储类型需要使用，tensor_name.dtype

举例：见1.0

1.3 tensor数据是否属于cuda显示

求解具体tensor是否属于cuda类型需要使用，tensor_name.iscuda

举例：见1.0

1.4 举例：16种类型的矩阵初始化和数据类型显示

import torch
print("测试开始")

print("===torch.FloatTensor===")
tensor = torch.FloatTensor([1,2])
print("type(FloatTensor):",type(tensor))
print("FloatTensor.type():",tensor.type())
print("FloatTensor.dtype:",tensor.dtype)
print("FloatTensor.is_cuda:",tensor.is_cuda)
print("===torch.cuda.FloatTensor===")
tensor = torch.cuda.FloatTensor([1,2])
print("type(cuda_FloatTensor):",type(tensor))
print("cuda_FloatTensor.type():",tensor.type())
print("cuda_FloatTensor.dtype:",tensor.dtype)
print("cuda_FloatTensor.is_cuda:",tensor.is_cuda)

print("===torch.DoubleTensor===")
tensor = torch.DoubleTensor([1,2])
print("type(DoubleTensor):",type(tensor))
print("DoubleTensor.type():",tensor.type())
print("DoubleTensor.dtype:",tensor.dtype)
print("DoubleTensor.is_cuda:",tensor.is_cuda)
print("===torch.cuda.DoubleTensor===")
tensor = torch.cuda.DoubleTensor([1,2])
print("type(cuda_DoubleTensor):",type(tensor))
print("cuda_DoubleTensor.type():",tensor.type())
print("cuda_DoubleTensor.dtype:",tensor.dtype)
print("cuda_DoubleTensor.is_cuda:",tensor.is_cuda)

print("===torch.HalfTensor===")
tensor = torch.HalfTensor([1,2])
print("type(cuda_DoubleTensor):",type(tensor))
print("HalfTensor.type():",tensor.type())
print("HalfTensor.dtype:",tensor.dtype)
print("HalfTensor.is_cuda:",tensor.is_cuda)
print("===torch.cuda.HalfTensor===")
tensor = torch.cuda.HalfTensor([1,2])
print("type(cuda_HalfTensor):",type(tensor))
print("cuda_HalfTensor.type():",tensor.type())
print("cuda_HalfTensor.dtype:",tensor.dtype)
print("cuda_HalfTensor.is_cuda:",tensor.is_cuda)

print("===torch.ByteTensor===")
tensor = torch.ByteTensor([1,2])
print("type(ByteTensor):",type(tensor))
print("ByteTensor.type():",tensor.type())
print("ByteTensor.dtype:",tensor.dtype)
print("ByteTensor.is_cuda:",tensor.is_cuda)
print("===torch.cuda.ByteTensor===")
tensor = torch.cuda.ByteTensor([1,2])
print("type(cuda_ByteTensor):",type(tensor))
print("cuda_ByteTensor.type():",tensor.type())
print("cuda_ByteTensor.dtype:",tensor.dtype)
print("cuda_ByteTensor.is_cuda:",tensor.is_cuda)

print("===torch.CharTensor===")
tensor = torch.CharTensor([1,2])
print("type(CharTensor):",type(tensor))
print("CharTensor.type():",tensor.type())
print("CharTensor.dtype:",tensor.dtype)
print("CharTensor.is_cuda:",tensor.is_cuda)
print("===torch.cuda.CharTensor===")
tensor = torch.cuda.CharTensor([1,2])
print("type(cuda_CharTensor):",type(tensor))
print("cuda_CharTensor.type():",tensor.type())
print("cuda_CharTensor.dtype:",tensor.dtype)
print("cuda_CharTensor.is_cuda:",tensor.is_cuda)

print("===torch.ShortTensor===")
tensor = torch.ShortTensor([1,2])
print("type(ShortTensor):",type(tensor))
print("ShortTensor.type():",tensor.type())
print("ShortTensor.dtype:",tensor.dtype)
print("ShortTensor.is_cuda:",tensor.is_cuda)
print("===torch.cuda.ShortTensor===")
tensor = torch.cuda.ShortTensor([1,2])
print("type(cuda_ShortTensor):",type(tensor))
print("cuda_ShortTensor.type():",tensor.type())
print("cuda_ShortTensor.dtype:",tensor.dtype)
print("cuda_ShortTensor.is_cuda:",tensor.is_cuda)

print("===torch.IntTensor===")
tensor = torch.IntTensor([1,2])
print("type(IntTensor):",type(tensor))
print("IntTensor.type():",tensor.type())
print("IntTensor.dtype:",tensor.dtype)
print("IntTensor.is_cuda:",tensor.is_cuda)
print("===torch.cuda.IntTensor===")
tensor = torch.cuda.IntTensor([1,2])
print("type(cuda_IntTensor):",type(tensor))
print("cuda_IntTensor.type():",tensor.type())
print("cuda_IntTensor.dtype:",tensor.dtype)
print("cuda_IntTensor.is_cuda:",tensor.is_cuda)

print("===torch.LongTensor===")
tensor = torch.LongTensor([1,2])
print("type(LongTensor):",type(tensor))
print("LongTensor.type():",tensor.type())
print("LongTensor.dtype:",tensor.dtype)
print("LongTensor.is_cuda:",tensor.is_cuda)
print("===torch.cuda.LongTensor===")
tensor = torch.cuda.LongTensor([1,2])
print("type(cuda_LongTensor):",type(tensor))
print("cuda_LongTensor.type():",tensor.type())
print("cuda_LongTensor.dtype:",tensor.dtype)
print("cuda_LongTensor.is_cuda:",tensor.is_cuda)

• 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
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• 51
• 52
• 53
• 54
• 55
• 56
• 57
• 58
• 59
• 60
• 61
• 62
• 63
• 64
• 65
• 66
• 67
• 68
• 69
• 70
• 71
• 72
• 73
• 74
• 75
• 76
• 77
• 78
• 79
• 80
• 81
• 82
• 83
• 84
• 85
• 86
• 87
• 88
• 89
• 90
• 91
• 92
• 93
• 94
• 95
• 96
• 97
• 98
• 99
• 100
• 101
• 102
• 103
• 104
• 105
• 106

二、tensor数据类型间的转换

2.0 数据转换的必要

相同类型的tensor才能做运算，是否在CPU和GPU同种，是否有相同的数据存储类型

2.1 CPU张量类型和GPU张量类型的转换

cpu_tensor.cuda()
gpu_tensor.cpu()

• 1
• 2

举例

import torch
print("测试开始")

print("==默认数据类型==")
tensor= torch.FloatTensor([1,2])
print("初始化CPU张量是否在GPU上:",tensor.is_cuda)
tensor.cuda()
print("CPU张量使用.cuda()后是否在GPU上:",tensor.is_cuda)
tensor = tensor.cuda()
print("CPU张量使用.cuda()并重新赋值后是否在GPU上:",tensor.is_cuda)

print("="*10)
tensor= torch.cuda.FloatTensor([1,2])
print("初始化GPU张量是否在GPU上:",tensor.is_cuda)
tensor.cpu()
print("GPU张量使用.cpu()并重新赋值后是否在GPU上:",tensor.is_cuda)
tensor = tensor.cpu()
print("GPU张量使用.cpu()并重新赋值后是否在GPU上:",tensor.is_cuda)

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18

2.2 不涉及到CPU与GPU的其它数据类型转换

2.2.1 tensor.int()将该tensor投射为int类型

八种CPU类型全部转换成torch.IntTensor，数据存储类型为torch.int32类型

八种GPU类型全部转换成torch.cuda.IntTensor，数据存储类型为torch.int32类型

2.2.2 tensor.long() 将tensor投射为long类型

八种CPU类型全部转换成torch.LongTensor，数据存储类型为torch.int64类型

八种GPU类型全部转换成torch.cuda.LongTensor，数据存储类型为torch.int64类型

2.2.3 tensor.half()将tensor投射为半精度浮点类型

八种CPU类型全部转换成torch.HalfTensor，数据存储类型为torch.float16类型

八种GPU类型全部转换成torch.cuda.HalfTensor，数据存储类型为torch.float16类型

2.2.4 tensor.double()将该tensor投射为double类型

八种CPU类型全部转换成torch.DoubleTensor，数据存储类型为torch.float64类型

八种GPU类型全部转换成torch.cuda.DoubleTensor，数据存储类型为torch.float64类型

2.2.5 tensor.float()将该tensor投射为float类型

八种CPU类型全部转换成torch.FloatTensor，数据存储类型为torch.float32类型

八种GPU类型全部转换成 torch.cuda.FloatTensor，数据存储类型为torch.float32类型

2.2.6 tensor.char()将该tensor投射为char类型

八种CPU类型全部转换成torch.CharTensor，数据存储类型为torch.int8类型

八种GPU类型全部转换成torch.cuda.CharTensor，数据存储类型为torch.int8类型

2.2.7 tensor.byte()将该tensor投射为byte类型

八种CPU类型全部转换成torch.ByteTensor，数据存储类型为torch.uint8类型

八种GPU类型全部转换成torch.cuda.ByteTensor，数据存储类型为torch.uint8类型

2.2.8 tensor.short()将tensor投射为short类型

八种CPU类型全部转换成torch.ShortTensor，数据存储类型为torch.int16类型

八种GPU类型全部转换成torch.cuda.ShortTensor，数据存储类型为torch.int16类型

2.3 使用tensor.type()函数

这个函数的作用是将该tensor转换为另一个tensor的type,可以同步完成转换CPU类型和GPU类型，如torch.IntTensor–>torch.cuda.floatTensor

语法如下：

tensor_new = tensor.type(new_type=None, async=False)

• 1

举例：

import torch
print("测试开始")
tensor = torch.FloatTensor([1,2])
print("before type function:",tensor.type())
tensor = tensor.type(torch.int32)
print("after type function:",tensor.type())

• 1
• 2
• 3
• 4
• 5
• 6

2.4 使用type_as(tesnor)将张量转换为给定类型的张量

这个函数的作用是将该tensor转换为另一个tensor的type,可以同步完成转换CPU类型和GPU类型，如torch.IntTensor–>torch.cuda.floatTensor

如果张量已经是指定类型，则不会进行转换

语法如下：

tensor_new = tensor1.type_as(tensor2)

• 1

举例：

import torch
print("测试开始")
tensor1 = torch.FloatTensor([1,2])
tensor2 = torch.IntTensor([1,2])
print("before type_as function:",tensor1.type())
tensor1 = tensor1.type_as(tensor2)
print("after type function:",tensor1.type())

• 1
• 2
• 3
• 4
• 5
• 6
• 7

运行结果：

LAST、参考文献

pytorch判断变量类型和是否是cuda_怡宝2号-CSDN博客
torch.Tensor - PyTorch中文文档
pytorch: tensor类型的构建与相互转换_JNing-CSDN博客
Pytorch中支持的tensor的数据类型及它们的相互转换 - 知乎
pytorch知识一tensor数据声明、类型转换。微调rensnet34的注意点。_yangdeshun888的博客-CSDN博客
Pytorch 基本的数据类型_洪流之源-CSDN博客_pytorch 数据类型