一、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.1 tensor类型与数据类型总览

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

Data type	CPU tensor	GPU tensor
32-bit floating point -> `torch.float32`	`torch.FloatTensor`	`torch.cuda.FloatTensor`
64-bit floating point -> `torch.float64`	`torch.DoubleTensor`	`torch.cuda.DoubleTensor`
16-bit floating point -> `torch.float16`	`torch.HalfTensor`	`torch.cuda.HalfTensor`
8-bit integer (unsigned) -> `torch.uint8`	`torch.ByteTensor`	`torch.cuda.ByteTensor`
8-bit integer (signed) -> `torch.int8`	`torch.CharTensor`	`torch.cuda.CharTensor`
16-bit integer (signed) -> `torch.int16`	`torch.ShortTensor`	`torch.cuda.ShortTensor`
32-bit integer (signed) -> `torch.int32`	`torch.IntTensor`	`torch.cuda.IntTensor`
64-bit integer (signed) -> `torch.int64`	`torch.LongTensor`	`torch.cuda.LongTensor`

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

针对这16种tensor变量使用type()函数得出的结果都是<class 'torch.Tensor'>

求解具体的张量类型需要使用，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)

二、tensor数据类型间的转换

2.0 数据转换的必要

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

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

cpu_tensor.cuda()
gpu_tensor.cpu()

举例

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)

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)

举例：

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

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