torch.asarray

torch.asarray(obj: Any, *, dtype: Optional[dtype], device: Optional[DeviceLikeType], copy: Optional[bool] = None, requires_grad: bool = False) → Tensor

将 obj 转换为 tensor。

obj 可以是以下之一：

1. 一个 tensor

2. 一个 NumPy 数组或 NumPy 标量

3. 一个 DLPack capsule

4. 一个实现了 Python buffer protocol 的对象

5. 一个标量

6. 一个标量序列

当 obj 是一个 tensor、NumPy 数组或 DLPack capsule 时，默认情况下，返回的 tensor 不会要求梯度，具有与 obj 相同的 datattype，位于同一设备上，并与其共享内存。这些属性可以通过 dtype、device、copy 和 requires_grad 关键字参数进行控制。如果返回的 tensor 的 datattype 不同、位于不同设备上，或者请求了复制，那么它将不会与 obj 共享内存。如果 requires_grad 为 True，则返回的 tensor 将要求梯度，并且如果 obj 也是一个具有 autograd 历史记录的 tensor，则返回的 tensor 将具有相同的历史记录。

当 obj 不是 tensor、NumPy 数组或 DLPack capsule，而是实现了 Python buffer protocol 的对象时，该 buffer 将被解释为根据传递给 dtype 关键字参数的数据类型大小分组的字节数组。（如果未传递数据类型，则使用默认的浮点数据类型。）返回的 tensor 将具有指定的数据类型（如果未指定，则为默认浮点数据类型），并且默认情况下位于 CPU 设备上，并与 buffer 共享内存。

当 obj 是 NumPy 标量时，返回的 tensor 将是一个 0 维 tensor，位于 CPU 上，并且不共享内存（即 copy=True）。默认情况下，数据类型将是与 NumPy 标量的数据类型相对应的 PyTorch 数据类型。

当 obj 不是以上任何一种，而是标量或标量序列时，默认情况下，返回的 tensor 将从标量值推断其数据类型，位于当前默认设备上，并且不共享内存。

另请参阅

torch.tensor() 创建一个总是从输入对象复制数据的 tensor。torch.from_numpy() 创建一个总是从 NumPy 数组共享内存的 tensor。torch.frombuffer() 创建一个总是从实现了 buffer protocol 的对象共享内存的 tensor。torch.from_dlpack() 创建一个总是从 DLPack capsule 共享内存的 tensor。

参数

obj (object) – 一个 tensor、NumPy 数组、DLPack Capsule、实现了 Python buffer protocol 的对象、标量或标量序列。

关键字参数

• dtype (torch.dtype, optional) – 返回 tensor 的数据类型。默认值：None，这将导致返回 tensor 的数据类型从 obj 推断。

• copy (bool, optional) – 控制返回的 tensor 是否与 obj 共享内存。默认值：None，这会导致返回的 tensor 在可能的情况下与 obj 共享内存。如果为 True，则返回的 tensor 不共享其内存。如果为 False，则返回的 tensor 与 obj 共享内存，并且如果无法共享则抛出错误。

• device (torch.device, optional) – 返回 tensor 的设备。默认值：None，这将使用 obj 的设备。或者，如果 obj 是 Python 序列，则将使用当前默认设备。

• requires_grad (bool, optional) – 返回的 tensor 是否需要 grad。默认值：False，这将导致返回的 tensor 不要求梯度。如果为 True，则返回的 tensor 将要求梯度，并且如果 obj 也是一个具有 autograd 历史记录的 tensor，则返回的 tensor 将具有相同的历史记录。

示例

>>> a = torch.tensor([1, 2, 3])
>>> # Shares memory with tensor 'a'
>>> b = torch.asarray(a)
>>> a.data_ptr() == b.data_ptr()
True
>>> # Forces memory copy
>>> c = torch.asarray(a, copy=True)
>>> a.data_ptr() == c.data_ptr()
False

>>> a = torch.tensor([1., 2., 3.], requires_grad=True)
>>> b = a + 2
>>> b
tensor([3., 4., 5.], grad_fn=<AddBackward0>)
>>> # Shares memory with tensor 'b', with no grad
>>> c = torch.asarray(b)
>>> c
tensor([3., 4., 5.])
>>> # Shares memory with tensor 'b', retaining autograd history
>>> d = torch.asarray(b, requires_grad=True)
>>> d
tensor([3., 4., 5.], grad_fn=<AddBackward0>)

>>> array = numpy.array([1, 2, 3])
>>> # Shares memory with array 'array'
>>> t1 = torch.asarray(array)
>>> array.__array_interface__['data'][0] == t1.data_ptr()
True
>>> # Copies memory due to dtype mismatch
>>> t2 = torch.asarray(array, dtype=torch.float32)
>>> array.__array_interface__['data'][0] == t2.data_ptr()
False

>>> scalar = numpy.float64(0.5)
>>> torch.asarray(scalar)
tensor(0.5000, dtype=torch.float64)