张量属性

每个 torch.Tensor 都有 torch.dtype、torch.device 和 torch.layout。

torch.dtype

class torch.dtype

一个 torch.dtype 是一个表示 torch.Tensor 数据类型的对象。PyTorch 有十二种不同的数据类型：

数据类型	数据类型	传统构造函数
32位浮点数	torch.float32 或 torch.float	torch.*.FloatTensor
64位浮点数	torch.float64 或 torch.double	torch.*.DoubleTensor
64位复数	torch.complex64 或 torch.cfloat
128位复数	torch.complex128 或 torch.cdouble
16位浮点数 1	torch.float16 或 torch.half	torch.*.HalfTensor
16位浮点数 2	torch.bfloat16	torch.*.BFloat16Tensor
8位无符号整数	torch.uint8	torch.*.ByteTensor
8位整数（有符号）	torch.int8	torch.*.CharTensor
16位整数（有符号）	torch.int16 或 torch.short	torch.*.ShortTensor
32位整数（有符号）	torch.int32 或 torch.int	torch.*.IntTensor
64位整数（有符号）	torch.int64 或 torch.long	torch.*.LongTensor
布尔值	torch.bool	torch.*.BoolTensor

1

有时被称为binary16：使用1个符号位、5个指数位和10个有效位。在精度重要时非常有用。

2

有时被称为Brain浮点数：使用1个符号位、8个指数位和7个有效位。当范围重要时很有用，因为它具有与float32相同的指数位数。

要确定一个torch.dtype是否为浮点数据类型，可以使用属性is_floating_point，如果数据类型是浮点数据类型，则返回True。

要确定一个torch.dtype是否为复数数据类型，可以使用属性is_complex，如果数据类型是复数数据类型，则返回True。

当算术运算（加、减、除、乘）的输入数据类型不同时，我们会通过找到满足以下规则的最小数据类型来进行类型提升：

• 如果标量操作数的类型比张量操作数的类型更高（其中复数 > 浮点数 > 整数 > 布尔值），我们将提升为具有足够大小以容纳该类别所有标量操作数的类型。

• 如果一个零维张量操作数的类别高于有维操作数，我们将提升到一个具有足够大小和类别的类型，以容纳该类别中的所有零维张量操作数。

• 如果没有更高类别的零维操作数，我们将提升为具有足够大小和类别的类型，以容纳所有有维度的操作数。

浮点标量操作数的dtype为torch.get_default_dtype()，而整数非布尔标量操作数的dtype为torch.int64。与numpy不同，我们在确定操作数的最小dtypes时不会检查值。量化和复数类型尚未得到支持。

促销示例：

>>> float_tensor = torch.ones(1, dtype=torch.float)
>>> double_tensor = torch.ones(1, dtype=torch.double)
>>> complex_float_tensor = torch.ones(1, dtype=torch.complex64)
>>> complex_double_tensor = torch.ones(1, dtype=torch.complex128)
>>> int_tensor = torch.ones(1, dtype=torch.int)
>>> long_tensor = torch.ones(1, dtype=torch.long)
>>> uint_tensor = torch.ones(1, dtype=torch.uint8)
>>> double_tensor = torch.ones(1, dtype=torch.double)
>>> bool_tensor = torch.ones(1, dtype=torch.bool)
# 零维张量
>>> long_zerodim = torch.tensor(1, dtype=torch.long)
>>> int_zerodim = torch.tensor(1, dtype=torch.int)

>>> torch.add(5, 5).dtype
torch.int64
# 5 是 int64，但没有比 int_tensor 更高的类别，因此不被考虑。
>>> (int_tensor + 5).dtype
torch.int32
>>> (int_tensor + long_zerodim).dtype
torch.int32
>>> (long_tensor + int_tensor).dtype
torch.int64
>>> (bool_tensor + long_tensor).dtype
torch.int64
>>> (bool_tensor + uint_tensor).dtype
torch.uint8
>>> (float_tensor + double_tensor).dtype
torch.float64
>>> (complex_float_tensor + complex_double_tensor).dtype
torch.complex128
>>> (bool_tensor + int_tensor).dtype
torch.int32
# 由于 long 与 float 是不同的类别，结果 dtype 只需要足够大以容纳 float。
>>> torch.add(long_tensor, float_tensor).dtype
torch.float32

When the output tensor of an arithmetic operation is specified, we allow casting to its dtype except that:

• 积分输出张量不能接受浮点张量。

• 布尔输出张量不能接受非布尔张量。

• 非复数输出张量不能接受复数张量

转换示例：

# 允许：
>>> float_tensor *= float_tensor
>>> float_tensor *= int_tensor
>>> float_tensor *= uint_tensor
>>> float_tensor *= bool_tensor
>>> float_tensor *= double_tensor
>>> int_tensor *= long_tensor
>>> int_tensor *= uint_tensor
>>> uint_tensor *= int_tensor

# 不允许（RuntimeError: 结果类型无法转换为所需的输出类型）：
>>> int_tensor *= float_tensor
>>> bool_tensor *= int_tensor
>>> bool_tensor *= uint_tensor
>>> float_tensor *= complex_float_tensor

torch.device

class torch.device

一个 torch.device 是一个表示 torch.Tensor 所分配或将被分配的设备的对象。

torch.device 包含一个设备类型（最常见的是“cpu”或“cuda”，但也可能是 “mps”、“xpu”、 “xla” 或 “meta”）以及设备类型的可选设备序号。如果设备序号不存在，此对象将始终表示设备类型的当前设备，即使在调用 torch.cuda.set_device() 之后也是如此；例如， 使用设备 'cuda' 构造的 torch.Tensor 等同于 'cuda:X'，其中 X 是 torch.cuda.current_device() 的结果。

一个 torch.Tensor 的设备可以通过 Tensor.device 属性来访问。

一个 torch.device 可以通过字符串或字符串和设备序号来构造

通过字符串：

>>> torch.device('cuda:0')
device(type='cuda', index=0)

>>> torch.device('cpu')
device(type='cpu')

>>> torch.device('mps')
device(type='mps')

>>> torch.device('cuda')  # 当前的cuda设备
device(type='cuda')

通过字符串和设备序号：

>>> torch.device('cuda', 0)
设备(类型='cuda', 索引=0)

>>> torch.device('mps', 0)
设备(类型='mps', 索引=0)

>>> torch.device('cpu', 0)
设备(类型='cpu', 索引=0)

设备对象也可以用作上下文管理器来更改默认的设备张量分配位置：

>>> with torch.device('cuda:1'):
...     r = torch.randn(2, 3)
>>> r.device
设备(类型='cuda', 索引=1)

如果工厂函数传递了一个显式的、非None的设备参数，则此上下文管理器无效。要全局更改默认设备，请参阅 torch.set_default_device()。

警告

此函数在每次调用 torch API 时（不仅仅是工厂函数）都会对 Python 造成轻微的性能开销。如果这对您造成了问题，请在 https://github.com/pytorch/pytorch/issues/92701 上发表评论。

注意

函数中的 torch.device 参数通常可以用字符串替代。 这使得代码的原型设计更加快速。

>>> # 一个接受torch.device作为参数的函数的示例
>>> cuda1 = torch.device('cuda:1')
>>> torch.randn((2,3), device=cuda1)

>>> # 你可以用字符串替换 torch.device
>>> torch.randn((2,3), device='cuda:1')

注意

由于历史原因，可以通过单个设备序号来构造设备，该序号被视为cuda设备。这与Tensor.get_device()匹配，后者返回cuda张量的序号，并且不支持cpu张量。

>>> torch.device(1)
设备(类型='cuda', 索引=1)

注意

接受设备的方法通常会接受一个（格式正确的）字符串或（遗留的）整数设备序号，即以下所有内容都是等效的：

>>> torch.randn((2,3), device=torch.device('cuda:1'))
>>> torch.randn((2,3), device='cuda:1')
>>> torch.randn((2,3), device=1)  # 旧版

注意

张量不会自动在设备之间移动，需要用户显式调用。标量张量（tensor.dim()==0）是此规则的唯一例外，当需要时它们会自动从CPU转移到GPU，因为此操作可以“免费”完成。 示例：

>>> # 两个标量
>>> torch.ones(()) + torch.ones(()).cuda()  # 可以，标量从CPU自动转移到GPU
>>> torch.ones(()).cuda() + torch.ones(())  # 可以，标量从CPU自动转移到GPU

>>> # 一个标量（CPU），一个向量（GPU）
>>> torch.ones(()) + torch.ones(1).cuda()  # 可以，标量自动从CPU转移到GPU
>>> torch.ones(1).cuda() + torch.ones(())  # 可以，标量自动从CPU转移到GPU

>>> # 一个标量（GPU），一个向量（CPU）
>>> torch.ones(()).cuda() + torch.ones(1)  # 失败，标量不会自动从GPU转移到CPU，非标量不会自动从CPU转移到GPU
>>> torch.ones(1) + torch.ones(()).cuda()  # 失败，标量不会自动从GPU转移到CPU，非标量不会自动从CPU转移到GPU

torch.布局

class torch.layout

警告

The torch.layout 类处于测试阶段，可能会发生变化。

一个 torch.layout 是一个表示 torch.Tensor 内存布局的对象。目前，我们支持 torch.strided（密集张量）并且对 torch.sparse_coo（稀疏 COO 张量）提供 beta 支持。

torch.strided 表示密集张量，并且是最常用的内存布局。每个跨步张量都有一个关联的 torch.Storage，用于保存其数据。这些张量提供了多维的、跨步 存储视图。跨步是一个整数列表：第 k 个跨步表示从张量的第 k 维中的一个元素到下一个元素所需的内存跳跃。这个概念使得许多张量操作能够高效执行。

示例：

>>> x = torch.tensor([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]])
>>> x.stride()
(5, 1)

>>> x.t().stride()
(1, 5)

有关 torch.sparse_coo 张量的更多信息，请参阅 torch.sparse。

torch.memory_format

class torch.memory_format

一个 torch.memory_format 是一个表示 torch.Tensor 所分配或将被分配的内存格式的对象。

可能的值包括：

• torch.contiguous_format: 张量在密集且不重叠的内存中分配或将被分配。步长由递减顺序的值表示。

• torch.channels_last: 张量在密集非重叠内存中分配或将被分配。步幅由strides[0] > strides[2] > strides[3] > strides[1] == 1表示，即NHWC顺序。

• torch.channels_last_3d: 张量在密集非重叠内存中分配或将被分配。步幅由strides[0] > strides[2] > strides[3] > strides[4] > strides[1] == 1表示，即NDHWC顺序。

• torch.preserve_format: 用于在函数如clone中保留输入张量的内存格式。如果输入张量在密集非重叠内存中分配，输出张量的步幅将从输入张量复制。 否则，输出步幅将遵循torch.contiguous_format