Атрибуты тензора

torch.dtype

class torch.dtype

torch.dtype — это объект, представляющий тип данных torch.Tensor. PyTorch поддерживает несколько различных типов данных:

Типы данных с плавающей точкой

Целочисленные типы данных

Примечание: устаревшие конструкторы, такие как torch.*.FloatTensor, torch.*.DoubleTensor, torch.*.HalfTensor, torch.*.BFloat16Tensor, torch.*.ByteTensor, torch.*.CharTensor, torch.*.ShortTensor, torch.*.IntTensor, torch.*.LongTensor, torch.*.BoolTensor, сохранены только для обратной совместимости, и их больше не следует использовать.

Чтобы определить, является ли torch.dtype типом данных с плавающей точкой, можно использовать свойство is_floating_point. Оно возвращает True, если тип данных является типом с плавающей точкой.

Чтобы определить, является ли torch.dtype комплексным типом данных, можно использовать свойство is_complex. Оно возвращает True, если тип данных является комплексным.

Каждый torch.dtype имеет свойство abbr, возвращающее краткую строку-аббревиатуру типа данных (например, torch.float32.abbr возвращает "f32").

Если типы данных входных значений арифметической операции (add, sub, div, mul) различаются, мы выполняем повышение типа, выбирая минимальный тип данных, удовлетворяющий следующим правилам:

• Если тип скалярного операнда относится к категории выше, чем категория тензорных операндов (комплексные > с плавающей точкой > целочисленные > логические), тип повышается до типа, размер которого достаточен для хранения всех скалярных операндов этой категории.
• Если категория операнда-тензора нулевой размерности выше, чем категория операндов с размерностью, тип повышается до типа, размер и категория которого достаточны для хранения всех тензорных операндов нулевой размерности этой категории.
• Если нет операндов нулевой размерности из категорий выше, тип повышается до типа, размер и категория которого достаточны для хранения всех операндов с размерностью.

Для скалярного операнда с плавающей точкой используется тип данных torch.get_default_dtype(), а для целочисленного скалярного операнда, не являющегося логическим значением, — тип данных torch.int64. В отличие от numpy, при определении минимальных типов данных операнда мы не проверяем значения. Комплексные типы пока не поддерживаются. Правила повышения типов для shell-типов данных не определены.

Примеры повышения типов:

>>> 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)
>>> bool_tensor = torch.ones(1, dtype=torch.bool)
# zero-dim tensors
>>> long_zerodim = torch.tensor(1, dtype=torch.long)
>>> int_zerodim = torch.tensor(1, dtype=torch.int)

>>> torch.add(5, 5).dtype
torch.int64
# 5 is an int64, but does not have higher category than int_tensor so is not considered.
>>> (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
# Since long is a different kind than float, result dtype only needs to be large enough
# to hold the float.
>>> torch.add(long_tensor, float_tensor).dtype
torch.float32

Если выходной тензор арифметической операции задан явно, мы допускаем приведение к его типу данных, за исключением следующих случаев:

• Выходной целочисленный тензор не может принимать тензор с плавающей точкой.
• Выходной логический тензор не может принимать тензор, не являющийся логическим.
• Выходной тензор некомплексного типа не может принимать комплексный тензор.

Примеры приведения типов:

# allowed:
>>> 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

# disallowed (RuntimeError: result type can't be cast to the desired output type):
>>> 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(); например, torch.Tensor, созданный с устройством 'cuda', эквивалентен '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')  # implicit index is the "current device index"
device(type='cuda')

С помощью типа устройства и его порядкового номера:

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

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

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

С помощью порядкового номера устройства:

>>> torch.device(0)  # the current accelerator is cuda
device(type='cuda', index=0)

>>> torch.device(1)  # the current accelerator is xpu
device(type='xpu', index=1)

>>> torch.device(0)  # no current accelerator detected
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
RuntimeError: Cannot access accelerator device when none is available.

Объект устройства также можно использовать как менеджер контекста для изменения устройства по умолчанию, на котором размещаются тензоры:

>>> with torch.device('cuda:1'):
...     r = torch.randn(2, 3)
>>> r.device
device(type='cuda', index=1)

Этот менеджер контекста не действует, если фабричной функции передан явный аргумент device, отличный от None. Чтобы изменить устройство по умолчанию глобально, см. также torch.set_default_device().

>>> # Example of a function that takes in a torch.device
>>> cuda1 = torch.device('cuda:1')
>>> torch.randn((2,3), device=cuda1)

>>> # You can substitute the torch.device with a string
>>> torch.randn((2,3), device='cuda:1')

>>> torch.randn((2,3), device=torch.device('cuda:1'))
>>> torch.randn((2,3), device='cuda:1')
>>> torch.randn((2,3), device=1)  # equivalent to 'cuda:1' if the current accelerator is cuda

>>> # two scalars
>>> torch.ones(()) + torch.ones(()).cuda()  # OK, scalar auto-transferred from CPU to GPU
>>> torch.ones(()).cuda() + torch.ones(())  # OK, scalar auto-transferred from CPU to GPU

>>> # one scalar (CPU), one vector (GPU)
>>> torch.ones(()) + torch.ones(1).cuda()  # OK, scalar auto-transferred from CPU to GPU
>>> torch.ones(1).cuda() + torch.ones(())  # OK, scalar auto-transferred from CPU to GPU

>>> # one scalar (GPU), one vector (CPU)
>>> torch.ones(()).cuda() + torch.ones(1)  # Fail, scalar not auto-transferred from GPU to CPU and non-scalar not auto-transferred from CPU to GPU
>>> torch.ones(1) + torch.ones(()).cuda()  # Fail, scalar not auto-transferred from GPU to CPU and non-scalar not auto-transferred from CPU to GPU

torch.layout

class torch.layout

torch.layout — это объект, представляющий расположение данных torch.Tensor в памяти. В настоящее время поддерживается torch.strided (плотные тензоры), а torch.sparse_coo (разреженные тензоры COO) поддерживается в бета-режиме.

torch.strided представляет плотные тензоры и является наиболее распространённым способом размещения данных в памяти. С каждым тензором со strides связан 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