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)