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

У каждого torch.Tensor есть torch.dtype, torch.device и torch.layout.

torch.dtype

class torch.dtype

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

1

Иногда называется binary16: использует 1 бит для знака, 5 битов для порядка и 10 битов для мантиссы. Полезно, когда важна точность.

2

Иногда называется Brain Floating Point: использует 1 бит для знака, 8 битов для порядка и 7 битов для мантиссы. Полезно, когда важен диапазон, так как имеет такое же количество битов порядка, что и float32

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

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

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

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

Скалярный операнд с плавающей точкой имеет тип torch.get_default_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)
# 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

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

• Целочисленный тензор-результат не может принимать тензор с плавающей точкой.
• Булевый тензор-результат не может принимать тензор, не являющийся булевым.
• Некомплексный тензор-результат не может принимать комплексный тензор.

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

# 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

A torch.device — это объект, представляющий устройство, на котором размещён или будет размещён torch.Tensor.

The torch.device содержит тип устройства ('cpu', 'cuda' или 'mps') и необязательный порядковый номер устройства для типа устройства. Если порядковый номер устройства отсутствует, этот объект всегда будет представлять текущее устройство для типа устройства, даже после вызова torch.cuda.set_device(); например, torch.Tensor, сконструированный с устройством 'cuda', эквивалентен 'cuda:X', где X — результат вызова torch.cuda.current_device().

Устройство torch.Tensor можно получить через свойство Tensor.device.

A 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')  # current cuda device
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)

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

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

Этот менеджер контекста не имеет эффекта, если фабричная функция получает явный, не равный 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.device(1)
device(type='cuda', index=1)

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

torch.layout

class torch.layout

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

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

A 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