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 緩衝區協定的物件

5. 一個純量

6. 一個純量序列

當 obj 是一個 tensor、NumPy 陣列或 DLPack 膠囊時，預設情況下，返回的 tensor 將不會需要梯度，並且會擁有與 obj 相同的資料類型，位於相同的裝置上，並與之共享記憶體。這些屬性可以使用 dtype、device、copy 和 requires_grad 關鍵字參數來控制。 如果返回的 tensor 具有不同的資料類型、位於不同的裝置上，或要求複製，則它將不會與 obj 共享其記憶體。如果 requires_grad 為 True，則返回的 tensor 將需要梯度，並且如果 obj 也是具有 autograd 歷史記錄的 tensor，則返回的 tensor 將具有相同的歷史記錄。

當 obj 不是 tensor、NumPy 陣列或 DLPack 膠囊，而是實作 Python 緩衝區協定時，緩衝區會被解釋為一個位元組陣列，這些位元組根據傳遞給 dtype 關鍵字參數的資料類型的大小進行分組。（如果沒有傳遞資料類型，則會改為使用預設的浮點數資料類型。）返回的 tensor 將具有指定的資料類型（如果沒有指定，則為預設的浮點數資料類型），並且預設情況下，它將位於 CPU 裝置上，並與緩衝區共享記憶體。

當 obj 是一個 NumPy 純量時，返回的 tensor 將會是在 CPU 上的 0 維 tensor，且不共享其記憶體（即 copy=True）。預設資料類型將會是與 NumPy 純量的資料類型相對應的 PyTorch 資料類型。

當 obj 不是上述任何一種，而是純量或純量序列時，返回的 tensor 預設會從純量值推斷其資料類型，位於當前的預設裝置上，且不共享其記憶體。

參見

torch.tensor() 建立一個總是從輸入物件複製資料的 tensor。 torch.from_numpy() 建立一個總是與 NumPy 陣列共享記憶體的 tensor。 torch.frombuffer() 建立一個總是與實作緩衝區協定的物件共享記憶體的 tensor。 torch.from_dlpack() 建立一個總是與 DLPack 膠囊共享記憶體的 tensor。

參數

obj (object) – 一個 tensor、NumPy 陣列、DLPack 膠囊、實作 Python 緩衝區協定的物件、純量或純量序列。

關鍵字參數

• dtype (torch.dtype, optional) – 返回的 tensor 的資料類型。預設值：None，這會導致從 obj 推斷返回的 tensor 的資料類型。

• copy (bool, optional) – 控制返回的 tensor 是否與 obj 共享記憶體。預設值：None，這會導致返回的 tensor 盡可能與 obj 共享記憶體。如果 True，則返回的 tensor 不共享其記憶體。如果 False，則返回的 tensor 與 obj 共享其記憶體，如果無法共享則會引發錯誤。

• device (torch.device, optional) – 傳回張量的裝置。預設值：None，這會導致使用 obj 的裝置。或者，如果 obj 是 Python 序列，則將使用目前的預設裝置。

• requires_grad (bool, optional) – 傳回的張量是否需要梯度。預設值：False，這會導致傳回的張量不需要梯度。 如果 True，則傳回的張量將需要梯度，並且如果 obj 也是具有 autograd 歷史記錄的張量，則傳回的張量將具有相同的歷史記錄。

範例

>>> 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)