torch.Tensor#

建立日期：2016年12月23日 | 最後更新日期：2025年6月27日

一個 torch.Tensor 是一個包含單一資料型別元素的 N 維矩陣。有關 dtype 支援的更多詳細資訊，請參閱 torch.dtype。

初始化和基本操作#

可以使用 torch.tensor() 建構函式從 Python list 或序列構造張量

>>> torch.tensor([[1., -1.], [1., -1.]])
tensor([[ 1.0000, -1.0000],
        [ 1.0000, -1.0000]])
>>> torch.tensor(np.array([[1, 2, 3], [4, 5, 6]]))
tensor([[ 1,  2,  3],
        [ 4,  5,  6]])

警告

torch.tensor() 總是會複製 data。如果你有一個 Tensor data 並且只想改變它的 requires_grad 標誌，請使用 requires_grad_() 或 detach() 來避免複製。如果你有一個 numpy 陣列並希望避免複製，請使用 torch.as_tensor()。

可以透過將 torch.dtype 和/或 torch.device 傳遞給建構函式或張量建立操作來構造具有特定資料型別的張量

>>> torch.zeros([2, 4], dtype=torch.int32)
tensor([[ 0,  0,  0,  0],
        [ 0,  0,  0,  0]], dtype=torch.int32)
>>> cuda0 = torch.device('cuda:0')
>>> torch.ones([2, 4], dtype=torch.float64, device=cuda0)
tensor([[ 1.0000,  1.0000,  1.0000,  1.0000],
        [ 1.0000,  1.0000,  1.0000,  1.0000]], dtype=torch.float64, device='cuda:0')

有關構建張量的更多資訊，請參閱建立操作

可以使用 Python 的索引和切片表示法訪問和修改張量的內容

>>> x = torch.tensor([[1, 2, 3], [4, 5, 6]])
>>> print(x[1][2])
tensor(6)
>>> x[0][1] = 8
>>> print(x)
tensor([[ 1,  8,  3],
        [ 4,  5,  6]])

使用 torch.Tensor.item() 從包含單個值的張量中獲取 Python 數字

>>> x = torch.tensor([[1]])
>>> x
tensor([[ 1]])
>>> x.item()
1
>>> x = torch.tensor(2.5)
>>> x
tensor(2.5000)
>>> x.item()
2.5

有關索引的更多資訊，請參閱索引、切片、連線、修改操作

可以建立一個 requires_grad=True 的張量，以便 torch.autograd 記錄對其的操作以進行自動微分。

>>> x = torch.tensor([[1., -1.], [1., 1.]], requires_grad=True)
>>> out = x.pow(2).sum()
>>> out.backward()
>>> x.grad
tensor([[ 2.0000, -2.0000],
        [ 2.0000,  2.0000]])

每個張量都有一個關聯的 torch.Storage，它儲存其資料。Tensor 類還提供了一個儲存的多維、跨步檢視，並定義了在其上的數值運算。

注意

有關張量檢視的更多資訊，請參閱張量檢視。

注意

有關 torch.Tensor 的 torch.dtype、torch.device 和 torch.layout 屬性的更多資訊，請參閱張量屬性。

注意

帶有下劃線字尾的方法會修改張量。例如，torch.FloatTensor.abs_() 會就地計算絕對值並返回修改後的張量，而 torch.FloatTensor.abs() 會在一個新張量中計算結果。

注意

要更改現有張量的 torch.device 和/或 torch.dtype，請考慮使用張量上的 to() 方法。

警告

當前 torch.Tensor 的實現會引入記憶體開銷，因此在有許多小型張量的應用程式中，它可能導致意外的高記憶體使用。如果這種情況適用於你，請考慮使用一個大型結構。

張量類參考#

class torch.Tensor#

根據你的用例，有幾種主要的方法來建立張量。

要使用預先存在的資料建立張量，請使用 torch.tensor()。
要建立具有特定大小的張量，請使用 torch.* 張量建立操作（請參閱建立操作）。
要建立與另一個張量大小相同（型別也相似）的張量，請使用 torch.*_like 張量建立操作（請參閱建立操作）。
要建立型別相似但大小與另一個張量不同的張量，請使用 tensor.new_* 建立操作。
有一箇舊的建構函式 torch.Tensor，不推薦使用。請改用 torch.tensor()。

Tensor.__init__(self, data)#

此建構函式已棄用，我們建議改用 torch.tensor()。此建構函式的作用取決於 data 的型別。

如果 data 是一個 Tensor，則返回原始 Tensor 的別名。與 torch.tensor() 不同，這會跟蹤 autograd 並將梯度傳播到原始 Tensor。device 關鍵字引數不適用於此 data 型別。
如果 data 是一個序列或巢狀序列，則建立一個具有預設 dtype（通常為 torch.float32）的張量，其資料為序列中的值，並在必要時執行型別轉換。特別值得注意的是，這與 torch.tensor() 不同，因為即使輸入都是整數，此建構函式也總是會構造一個浮點張量。
如果 data 是一個 torch.Size，則返回一個大小為該 torch.Size 的空張量。

此建構函式不支援顯式指定返回張量的 dtype 或 device。我們建議使用 torch.tensor()，它提供了此功能。

引數 (Args)

data (array_like): 用於構造張量的資料。

關鍵字引數

device (torch.device, optional): 返回張量的目標裝置。: 預設值：如果為 None，則與此張量具有相同的 torch.device。

Tensor.T#

返回一個維度顛倒的張量檢視。

如果 x 的維度數為 n，則 x.T 等同於 x.permute(n-1, n-2, ..., 0)。

警告

在維度不為 2 的張量上使用 Tensor.T() 來顛倒其形狀已被棄用，並在將來的版本中會引發錯誤。請考慮使用 mT 來轉置矩陣批次，或者使用 x.permute(*torch.arange(x.ndim - 1, -1, -1)) 來顛倒張量的維度。

Tensor.H#

返回一個共軛轉置的矩陣（2-D 張量）檢視。

x.H 對於複數矩陣等同於 x.transpose(0, 1).conj()，對於實數矩陣等同於 x.transpose(0, 1)。

另請參閱

mH：一個也適用於矩陣批次的屬性。

Tensor.mT#

返回一個最後兩個維度被轉置的張量檢視。

x.mT 等同於 x.transpose(-2, -1)。

Tensor.mH#: 訪問此屬性等同於呼叫 adjoint()。

`Tensor.new_tensor`	返回一個以 `data` 作為張量資料的張量。
`Tensor.new_full`	返回一個大小為 `size`，並用 `fill_value` 填充的張量。
`Tensor.new_empty`	返回一個大小為 `size`，並用未初始化資料填充的張量。
`Tensor.new_ones`	返回一個大小為 `size`，並用 `1` 填充的張量。
`Tensor.new_zeros`	返回一個大小為 `size`，並用 `0` 填充的張量。
`Tensor.is_cuda`	如果張量儲存在 GPU 上，則為 `True`，否則為 `False`。
`Tensor.is_quantized`	如果張量是量化的，則為 `True`，否則為 `False`。
`Tensor.is_meta`	如果張量是元張量，則為 `True`，否則為 `False`。
`Tensor.device`	此張量所在的 `torch.device`。
`Tensor.grad`	此屬性預設值為 `None`，並在第一次呼叫 `backward()` 計算 `self` 的梯度時變為張量。
`Tensor.ndim`	是 `dim()` 的別名
`Tensor.real`	對於復值輸入張量，返回一個包含 `self` 張量實部值的新張量。
`Tensor.imag`	返回一個包含 `self` 張量虛部值的新張量。
`Tensor.nbytes`	如果張量不使用稀疏儲存佈局，則返回張量元素“檢視”所佔用的位元組數。
`Tensor.itemsize`	是 `element_size()` 的別名
`Tensor.abs`	請參閱 `torch.abs()`
`Tensor.abs_`	`abs()` 的就地版本
`Tensor.absolute`	是 `abs()` 的別名
`Tensor.absolute_`	是 `absolute()` 的就地版本，也是 `abs_()` 的別名。
`Tensor.acos`	請參閱 `torch.acos()`
`Tensor.acos_`	是 `acos()` 的就地版本
`Tensor.arccos`	請參閱 `torch.arccos()`
`Tensor.arccos_`	是 `arccos()` 的就地版本
`Tensor.add`	將標量或張量新增到 `self` 張量。
`Tensor.add_`	是 `add()` 的就地版本
`Tensor.addbmm`	請參閱 `torch.addbmm()`
`Tensor.addbmm_`	是 `addbmm()` 的就地版本
`Tensor.addcdiv`	請參閱 `torch.addcdiv()`
`Tensor.addcdiv_`	是 `addcdiv()` 的就地版本
`Tensor.addcmul`	請參閱 `torch.addcmul()`
`Tensor.addcmul_`	是 `addcmul()` 的就地版本
`Tensor.addmm`	請參閱 `torch.addmm()`
`Tensor.addmm_`	是 `addmm()` 的就地版本
`Tensor.sspaddmm`	請參閱 `torch.sspaddmm()`
`Tensor.addmv`	請參閱 `torch.addmv()`
`Tensor.addmv_`	是 `addmv()` 的就地版本
`Tensor.addr`	請參閱 `torch.addr()`
`Tensor.addr_`	是 `addr()` 的就地版本
`Tensor.adjoint`	是 `adjoint()` 的別名
`Tensor.allclose`	請參閱 `torch.allclose()`
`Tensor.amax`	請參閱 `torch.amax()`
`Tensor.amin`	請參閱 `torch.amin()`
`Tensor.aminmax`	請參閱 `torch.aminmax()`
`Tensor.angle`	請參閱 `torch.angle()`
`Tensor.apply_`	將 `callable` 函式應用於張量中的每個元素，並將每個元素替換為 `callable` 返回的值。
`Tensor.argmax`	請參閱 `torch.argmax()`
`Tensor.argmin`	請參閱 `torch.argmin()`
`Tensor.argsort`	請參閱 `torch.argsort()`
`Tensor.argwhere`	請參閱 `torch.argwhere()`
`Tensor.asin`	請參閱 `torch.asin()`
`Tensor.asin_`	是 `asin()` 的就地版本
`Tensor.arcsin`	請參閱 `torch.arcsin()`
`Tensor.arcsin_`	是 `arcsin()` 的就地版本
`Tensor.as_strided`	請參閱 `torch.as_strided()`
`Tensor.atan`	請參閱 `torch.atan()`
`Tensor.atan_`	是 `atan()` 的就地版本
`Tensor.arctan`	請參閱 `torch.arctan()`
`Tensor.arctan_`	是 `arctan()` 的就地版本
`Tensor.atan2`	請參閱 `torch.atan2()`
`Tensor.atan2_`	是 `atan2()` 的就地版本
`Tensor.arctan2`	請參閱 `torch.arctan2()`
`Tensor.arctan2_`	atan2_(other) -> Tensor
`Tensor.all`	請參閱 `torch.all()`
`Tensor.any`	請參閱 `torch.any()`
`Tensor.backward`	計算當前張量相對於圖葉的梯度。
`Tensor.baddbmm`	請參閱 `torch.baddbmm()`
`Tensor.baddbmm_`	是 `baddbmm()` 的就地版本
`Tensor.bernoulli`	返回一個結果張量，其中每個 $\texttt{result[i]}$ 是獨立地從 $\text{Bernoulli}(\texttt{self[i]})$ 中抽取的。
`Tensor.bernoulli_`	用獨立抽取的 $\text{Bernoulli}(\texttt{p})$ 的樣本填充 `self` 中的每個位置。
`Tensor.bfloat16`	`self.bfloat16()` 等同於 `self.to(torch.bfloat16)`。
`Tensor.bincount`	請參閱 `torch.bincount()`
`Tensor.bitwise_not`	請參閱 `torch.bitwise_not()`
`Tensor.bitwise_not_`	是 `bitwise_not()` 的就地版本
`Tensor.bitwise_and`	請參閱 `torch.bitwise_and()`
`Tensor.bitwise_and_`	是 `bitwise_and()` 的就地版本
`Tensor.bitwise_or`	請參閱 `torch.bitwise_or()`
`Tensor.bitwise_or_`	是 `bitwise_or()` 的就地版本
`Tensor.bitwise_xor`	請參閱 `torch.bitwise_xor()`
`Tensor.bitwise_xor_`	是 `bitwise_xor()` 的就地版本
`Tensor.bitwise_left_shift`	請參閱 `torch.bitwise_left_shift()`
`Tensor.bitwise_left_shift_`	是 `bitwise_left_shift()` 的就地版本
`Tensor.bitwise_right_shift`	請參閱 `torch.bitwise_right_shift()`
`Tensor.bitwise_right_shift_`	是 `bitwise_right_shift()` 的就地版本
`Tensor.bmm`	請參閱 `torch.bmm()`
`Tensor.bool`	`self.bool()` 等同於 `self.to(torch.bool)`。
`Tensor.byte`	`self.byte()` 等同於 `self.to(torch.uint8)`。
`Tensor.broadcast_to`	請參閱 `torch.broadcast_to()`。
`Tensor.cauchy_`	用從柯西分佈中抽取的數字填充張量
`Tensor.ceil`	請參閱 `torch.ceil()`
`Tensor.ceil_`	是 `ceil()` 的就地版本
`Tensor.char`	`self.char()` 等同於 `self.to(torch.int8)`。
`Tensor.cholesky`	請參閱 `torch.cholesky()`
`Tensor.cholesky_inverse`	請參閱 `torch.cholesky_inverse()`
`Tensor.cholesky_solve`	請參閱 `torch.cholesky_solve()`
`Tensor.chunk`	請參閱 `torch.chunk()`
`Tensor.clamp`	請參閱 `torch.clamp()`
`Tensor.clamp_`	是 `clamp()` 的就地版本
`Tensor.clip`	是 `clamp()` 的別名。
`Tensor.clip_`	是 `clamp_()` 的別名。
`Tensor.clone`	請參閱 `torch.clone()`
`Tensor.contiguous`	返回一個在記憶體中連續的張量，包含與 `self` 張量相同的資料。
`Tensor.copy_`	將 `src` 的元素複製到 `self` 張量中，並返回 `self`。
`Tensor.conj`	請參閱 `torch.conj()`
`Tensor.conj_physical`	請參閱 `torch.conj_physical()`
`Tensor.conj_physical_`	是 `conj_physical()` 的就地版本
`Tensor.resolve_conj`	請參閱 `torch.resolve_conj()`
`Tensor.resolve_neg`	請參閱 `torch.resolve_neg()`
`Tensor.copysign`	請參閱 `torch.copysign()`
`Tensor.copysign_`	是 `copysign()` 的就地版本
`Tensor.cos`	請參閱 `torch.cos()`
`Tensor.cos_`	是 `cos()` 的就地版本
`Tensor.cosh`	請參閱 `torch.cosh()`
`Tensor.cosh_`	是 `cosh()` 的就地版本
`Tensor.corrcoef`	請參閱 `torch.corrcoef()`
`Tensor.count_nonzero`	請參閱 `torch.count_nonzero()`
`Tensor.cov`	請參閱 `torch.cov()`
`Tensor.acosh`	請參閱 `torch.acosh()`
`Tensor.acosh_`	是 `acosh()` 的就地版本
`Tensor.arccosh`	acosh() -> Tensor
`Tensor.arccosh_`	acosh_() -> Tensor
`Tensor.cpu`	返回此物件的 CPU 記憶體副本。
`Tensor.cross`	請參閱 `torch.cross()`
`Tensor.cuda`	返回此物件在 CUDA 記憶體中的副本。
`Tensor.logcumsumexp`	請參閱 `torch.logcumsumexp()`
`Tensor.cummax`	請參閱 `torch.cummax()`
`Tensor.cummin`	請參閱 `torch.cummin()`
`Tensor.cumprod`	請參閱 `torch.cumprod()`
`Tensor.cumprod_`	是 `cumprod()` 的就地版本
`Tensor.cumsum`	請參閱 `torch.cumsum()`
`Tensor.cumsum_`	是 `cumsum()` 的就地版本
`Tensor.chalf`	`self.chalf()` 等同於 `self.to(torch.complex32)`。
`Tensor.cfloat`	`self.cfloat()` 等同於 `self.to(torch.complex64)`。
`Tensor.cdouble`	`self.cdouble()` 等同於 `self.to(torch.complex128)`。
`Tensor.data_ptr`	返回 `self` 張量第一個元素的地址。
`Tensor.deg2rad`	請參閱 `torch.deg2rad()`
`Tensor.dequantize`	給定一個量化張量，對其進行去量化並返回去量化的浮點張量。
`Tensor.det`	請參閱 `torch.det()`
`Tensor.dense_dim`	返回稀疏張量 `self` 的密集維度數量。
`Tensor.detach`	返回一個從當前圖分離的新張量。
`Tensor.detach_`	將張量與建立它的圖分離，使其成為葉子節點。
`Tensor.diag`	請參閱 `torch.diag()`
`Tensor.diag_embed`	請參閱 `torch.diag_embed()`
`Tensor.diagflat`	請參閱 `torch.diagflat()`
`Tensor.diagonal`	請參閱 `torch.diagonal()`
`Tensor.diagonal_scatter`	請參閱 `torch.diagonal_scatter()`
`Tensor.fill_diagonal_`	填充至少具有 2 個維度的張量的對角線。
`Tensor.fmax`	請參閱 `torch.fmax()`
`Tensor.fmin`	請參閱 `torch.fmin()`
`Tensor.diff`	請參閱 `torch.diff()`
`Tensor.digamma`	請參閱 `torch.digamma()`
`Tensor.digamma_`	是 `digamma()` 的就地版本
`Tensor.dim`	返回 `self` 張量的維度數量。
`Tensor.dim_order`	返回描述 `self` 的維度順序或物理佈局的唯一確定的整數元組。
`Tensor.dist`	請參閱 `torch.dist()`
`Tensor.div`	請參閱 `torch.div()`
`Tensor.div_`	是 `div()` 的就地版本
`Tensor.divide`	請參閱 `torch.divide()`
`Tensor.divide_`	是 `divide()` 的就地版本
`Tensor.dot`	請參閱 `torch.dot()`
`Tensor.double`	`self.double()` 等同於 `self.to(torch.float64)`。
`Tensor.dsplit`	請參閱 `torch.dsplit()`
`Tensor.element_size`	返回單個元素的位元組大小。
`Tensor.eq`	請參閱 `torch.eq()`
`Tensor.eq_`	是 `eq()` 的就地版本
`Tensor.equal`	請參閱 `torch.equal()`
`Tensor.erf`	請參閱 `torch.erf()`
`Tensor.erf_`	是 `erf()` 的就地版本
`Tensor.erfc`	請參閱 `torch.erfc()`
`Tensor.erfc_`	是 `erfc()` 的就地版本
`Tensor.erfinv`	請參閱 `torch.erfinv()`
`Tensor.erfinv_`	是 `erfinv()` 的就地版本
`Tensor.exp`	請參閱 `torch.exp()`
`Tensor.exp_`	是 `exp()` 的就地版本
`Tensor.expm1`	請參閱 `torch.expm1()`
`Tensor.expm1_`	是 `expm1()` 的就地版本
`Tensor.expand`	返回 `self` 張量的新檢視，其中單例維度已擴充套件到更大的大小。
`Tensor.expand_as`	將此張量擴充套件為與 `other` 相同的大小。
`Tensor.exponential_`	用從 PDF（機率密度函式）中抽取的元素填充 `self` 張量
`Tensor.fix`	請參閱 `torch.fix()`。
`Tensor.fix_`	是 `fix()` 的就地版本
`Tensor.fill_`	用指定的值填充 `self` 張量。
`Tensor.flatten`	請參閱 `torch.flatten()`
`Tensor.flip`	請參閱 `torch.flip()`
`Tensor.fliplr`	請參閱 `torch.fliplr()`
`Tensor.flipud`	請參閱 `torch.flipud()`
`Tensor.float`	`self.float()` 等同於 `self.to(torch.float32)`。
`Tensor.float_power`	請參閱 `torch.float_power()`
`Tensor.float_power_`	是 `float_power()` 的就地版本
`Tensor.floor`	請參閱 `torch.floor()`
`Tensor.floor_`	是 `floor()` 的就地版本
`Tensor.floor_divide`	請參閱 `torch.floor_divide()`
`Tensor.floor_divide_`	是 `floor_divide()` 的就地版本
`Tensor.fmod`	請參閱 `torch.fmod()`
`Tensor.fmod_`	是 `fmod()` 的就地版本
`Tensor.frac`	請參閱 `torch.frac()`
`Tensor.frac_`	是 `frac()` 的就地版本
`Tensor.frexp`	請參閱 `torch.frexp()`
`Tensor.gather`	請參閱 `torch.gather()`
`Tensor.gcd`	請參閱 `torch.gcd()`
`Tensor.gcd_`	是 `gcd()` 的就地版本
`Tensor.ge`	請參閱 `torch.ge()`。
`Tensor.ge_`	是 `ge()` 的就地版本。
`Tensor.greater_equal`	請參閱 `torch.greater_equal()`。
`Tensor.greater_equal_`	是 `greater_equal()` 的就地版本。
`Tensor.geometric_`	用從幾何分佈中抽取的元素填充 `self` 張量
`Tensor.geqrf`	請參閱 `torch.geqrf()`
`Tensor.ger`	請參閱 `torch.ger()`
`Tensor.get_device`	對於 CUDA 張量，此函式返回張量所在的 GPU 的裝置序號。
`Tensor.gt`	請參閱 `torch.gt()`。
`Tensor.gt_`	是 `gt()` 的就地版本。
`Tensor.greater`	請參閱 `torch.greater()`。
`Tensor.greater_`	是 `greater()` 的就地版本。
`Tensor.half`	`self.half()` 等同於 `self.to(torch.float16)`。
`Tensor.hardshrink`	請參閱 `torch.nn.functional.hardshrink()`
`Tensor.heaviside`	請參閱 `torch.heaviside()`
`Tensor.histc`	請參閱 `torch.histc()`
`Tensor.histogram`	請參閱 `torch.histogram()`
`Tensor.hsplit`	請參閱 `torch.hsplit()`
`Tensor.hypot`	請參閱 `torch.hypot()`
`Tensor.hypot_`	是 `hypot()` 的就地版本
`Tensor.i0`	請參閱 `torch.i0()`
`Tensor.i0_`	是 `i0()` 的就地版本
`Tensor.igamma`	請參閱 `torch.igamma()`
`Tensor.igamma_`	是 `igamma()` 的就地版本
`Tensor.igammac`	請參閱 `torch.igammac()`
`Tensor.igammac_`	是 `igammac()` 的就地版本
`Tensor.index_add_`	透過按 `index` 指定的順序將 `alpha` 乘以 `source` 的元素累加到 `self` 張量中。
`Tensor.index_add`	`torch.Tensor.index_add_()` 的非就地版本。
`Tensor.index_copy_`	透過按 `index` 指定的順序選擇索引，將 `tensor` 的元素複製到 `self` 張量中。
`Tensor.index_copy`	`torch.Tensor.index_copy_()` 的非就地版本。
`Tensor.index_fill_`	透過按 `index` 指定的順序選擇索引，用值 `value` 填充 `self` 張量的元素。
`Tensor.index_fill`	`torch.Tensor.index_fill_()` 的非就地版本。
`Tensor.index_put_`	使用 `indices`（這是一個張量元組）指定的索引，將張量 `values` 中的值放入張量 `self` 中。
`Tensor.index_put`	`index_put_()` 的非就地版本。
`Tensor.index_reduce_`	透過使用 `reduce` 引數指定的歸約，按 `index` 指定的順序將 `source` 的元素累加到 `self` 張量中。
`Tensor.index_reduce`
`Tensor.index_select`	請參閱 `torch.index_select()`
`Tensor.indices`	返回稀疏 COO 張量的索引張量。
`Tensor.inner`	請參閱 `torch.inner()`。
`Tensor.int`	`self.int()` 等同於 `self.to(torch.int32)`。
`Tensor.int_repr`	給定一個量化張量，`self.int_repr()` 返回一個 CPU 張量，其資料型別為 uint8_t，用於儲存給定張量的底層 uint8_t 值。
`Tensor.inverse`	請參閱 `torch.inverse()`
`Tensor.isclose`	請參閱 `torch.isclose()`
`Tensor.isfinite`	請參閱 `torch.isfinite()`
`Tensor.isinf`	請參閱 `torch.isinf()`
`Tensor.isposinf`	請參閱 `torch.isposinf()`
`Tensor.isneginf`	請參閱 `torch.isneginf()`
`Tensor.isnan`	請參閱 `torch.isnan()`
`Tensor.is_contiguous`	如果 `self` 張量在記憶體中按指定的記憶體格式是連續的，則返回 True。
`Tensor.is_complex`	如果 `self` 的資料型別是複數資料型別，則返回 True。
`Tensor.is_conj`	如果 `self` 的共軛位設定為 True，則返回 True。
`Tensor.is_floating_point`	如果 `self` 的資料型別是浮點資料型別，則返回 True。
`Tensor.is_inference`	請參閱 `torch.is_inference()`
`Tensor.is_leaf`	根據約定，所有 `requires_grad` 為 `False` 的張量都將是葉子張量。
`Tensor.is_pinned`	如果此張量位於固定記憶體中，則返回 true。
`Tensor.is_set_to`	如果兩個張量指向完全相同的記憶體（相同的儲存、偏移量、大小和步幅），則返回 True。
`Tensor.is_shared`	檢查張量是否在共享記憶體中。
`Tensor.is_signed`	如果 `self` 的資料型別是有符號資料型別，則返回 True。
`Tensor.is_sparse`	如果張量使用稀疏 COO 儲存佈局，則為 `True`，否則為 `False`。
`Tensor.istft`	請參閱 `torch.istft()`
`Tensor.isreal`	請參閱 `torch.isreal()`
`Tensor.item`	將此張量的值作為標準 Python 數字返回。
`Tensor.kthvalue`	請參閱 `torch.kthvalue()`
`Tensor.lcm`	請參閱 `torch.lcm()`
`Tensor.lcm_`	`lcm()` 的原地版本
`Tensor.ldexp`	請參閱 `torch.ldexp()`
`Tensor.ldexp_`	`ldexp()` 的原地版本
`Tensor.le`	請參閱 `torch.le()`。
`Tensor.le_`	`le()` 的原地版本。
`Tensor.less_equal`	請參閱 `torch.less_equal()`。
`Tensor.less_equal_`	`less_equal()` 的原地版本。
`Tensor.lerp`	請參閱 `torch.lerp()`
`Tensor.lerp_`	`lerp()` 的原地版本
`Tensor.lgamma`	請參閱 `torch.lgamma()`
`Tensor.lgamma_`	`lgamma()` 的原地版本
`Tensor.log`	請參閱 `torch.log()`
`Tensor.log_`	`log()` 的原地版本
`Tensor.logdet`	請參閱 `torch.logdet()`
`Tensor.log10`	請參閱 `torch.log10()`
`Tensor.log10_`	`log10()` 的原地版本
`Tensor.log1p`	請參閱 `torch.log1p()`
`Tensor.log1p_`	`log1p()` 的原地版本
`Tensor.log2`	請參閱 `torch.log2()`
`Tensor.log2_`	`log2()` 的原地版本
`Tensor.log_normal_`	使用給定的均值 $\mu$ 和標準差 $\sigma$ 引數化的對數正態分佈樣本填充 `self` 張量。
`Tensor.logaddexp`	請參閱 `torch.logaddexp()`
`Tensor.logaddexp2`	請參閱 `torch.logaddexp2()`
`Tensor.logsumexp`	請參閱 `torch.logsumexp()`
`Tensor.logical_and`	請參閱 `torch.logical_and()`
`Tensor.logical_and_`	`logical_and()` 的原地版本
`Tensor.logical_not`	請參閱 `torch.logical_not()`
`Tensor.logical_not_`	`logical_not()` 的原地版本
`Tensor.logical_or`	請參閱 `torch.logical_or()`
`Tensor.logical_or_`	`logical_or()` 的原地版本
`Tensor.logical_xor`	請參閱 `torch.logical_xor()`
`Tensor.logical_xor_`	`logical_xor()` 的原地版本
`Tensor.logit`	請參閱 `torch.logit()`
`Tensor.logit_`	`logit()` 的原地版本
`Tensor.long`	`self.long()` 等同於 `self.to(torch.int64)`。
`Tensor.lt`	請參閱 `torch.lt()`。
`Tensor.lt_`	`lt()` 的原地版本。
`Tensor.less`	lt(other) -> Tensor
`Tensor.less_`	`less()` 的原地版本。
`Tensor.lu`	請參閱 `torch.lu()`
`Tensor.lu_solve`	請參閱 `torch.lu_solve()`
`Tensor.as_subclass`	建立一個 `cls` 例項，其資料指標與 `self` 相同。
`Tensor.map_`	為 `self` 張量和給定的 `tensor` 的每個元素應用 `callable`，並將結果儲存在 `self` 張量中。
`Tensor.masked_scatter_`	將 `source` 中的元素複製到 `self` 張量中 `mask` 為 True 的位置。
`Tensor.masked_scatter`	`torch.Tensor.masked_scatter_()` 的非原地版本
`Tensor.masked_fill_`	在 `mask` 為 True 的位置，使用 `value` 填充 `self` 張量的元素。
`Tensor.masked_fill`	`torch.Tensor.masked_fill_()` 的非原地版本
`Tensor.masked_select`	請參閱 `torch.masked_select()`
`Tensor.matmul`	請參閱 `torch.matmul()`
`Tensor.matrix_power`	注意 `matrix_power()` 已棄用，請改用 `torch.linalg.matrix_power()`。
`Tensor.matrix_exp`	請參閱 `torch.matrix_exp()`
`Tensor.max`	請參閱 `torch.max()`
`Tensor.maximum`	請參閱 `torch.maximum()`
`Tensor.mean`	請參閱 `torch.mean()`
`Tensor.module_load`	定義了在 `load_state_dict()` 中載入 `other` 到 `self` 時如何轉換它。
`Tensor.nanmean`	請參閱 `torch.nanmean()`
`Tensor.median`	請參閱 `torch.median()`
`Tensor.nanmedian`	請參閱 `torch.nanmedian()`
`Tensor.min`	請參閱 `torch.min()`
`Tensor.minimum`	請參閱 `torch.minimum()`
`Tensor.mm`	請參閱 `torch.mm()`
`Tensor.smm`	請參閱 `torch.smm()`
`Tensor.mode`	請參閱 `torch.mode()`
`Tensor.movedim`	請參閱 `torch.movedim()`
`Tensor.moveaxis`	請參閱 `torch.moveaxis()`
`Tensor.msort`	請參閱 `torch.msort()`
`Tensor.mul`	請參閱 `torch.mul()`。
`Tensor.mul_`	`mul()` 的原地版本。
`Tensor.multiply`	請參閱 `torch.multiply()`。
`Tensor.multiply_`	`multiply()` 的原地版本。
`Tensor.multinomial`	請參閱 `torch.multinomial()`
`Tensor.mv`	請參閱 `torch.mv()`
`Tensor.mvlgamma`	請參閱 `torch.mvlgamma()`
`Tensor.mvlgamma_`	`mvlgamma()` 的原地版本
`Tensor.nansum`	請參閱 `torch.nansum()`
`Tensor.narrow`	請參閱 `torch.narrow()`。
`Tensor.narrow_copy`	請參閱 `torch.narrow_copy()`。
`Tensor.ndimension`	是 `dim()` 的別名
`Tensor.nan_to_num`	請參閱 `torch.nan_to_num()`。
`Tensor.nan_to_num_`	`nan_to_num()` 的原地版本。
`Tensor.ne`	請參閱 `torch.ne()`。
`Tensor.ne_`	`ne()` 的原地版本。
`Tensor.not_equal`	請參閱 `torch.not_equal()`。
`Tensor.not_equal_`	`not_equal()` 的原地版本。
`Tensor.neg`	請參閱 `torch.neg()`
`Tensor.neg_`	`neg()` 的原地版本
`Tensor.negative`	請參閱 `torch.negative()`
`Tensor.negative_`	`negative()` 的原地版本
`Tensor.nelement`	`numel()` 的別名
`Tensor.nextafter`	請參閱 `torch.nextafter()`
`Tensor.nextafter_`	`nextafter()` 的原地版本
`Tensor.nonzero`	請參閱 `torch.nonzero()`
`Tensor.norm`	請參閱 `torch.norm()`
`Tensor.normal_`	使用 `mean` 和 `std` 引數化的正態分佈樣本填充 `self` 張量。
`Tensor.numel`	請參閱 `torch.numel()`
`Tensor.numpy`	將張量作為 NumPy `ndarray` 返回。
`Tensor.orgqr`	請參閱 `torch.orgqr()`
`Tensor.ormqr`	請參閱 `torch.ormqr()`
`Tensor.outer`	請參閱 `torch.outer()`。
`Tensor.permute`	請參閱 `torch.permute()`
`Tensor.pin_memory`	如果張量未被固定，則將其複製到固定記憶體。
`Tensor.pinverse`	請參閱 `torch.pinverse()`
`Tensor.polygamma`	請參閱 `torch.polygamma()`
`Tensor.polygamma_`	`polygamma()` 的原地版本
`Tensor.positive`	請參閱 `torch.positive()`
`Tensor.pow`	請參閱 `torch.pow()`
`Tensor.pow_`	`pow()` 的原地版本
`Tensor.prod`	請參閱 `torch.prod()`
`Tensor.put_`	將 `source` 中的元素複製到 `index` 指定的位置。
`Tensor.qr`	請參閱 `torch.qr()`
`Tensor.qscheme`	返回給定 QTensor 的量化方案。
`Tensor.quantile`	請參閱 `torch.quantile()`
`Tensor.nanquantile`	請參閱 `torch.nanquantile()`
`Tensor.q_scale`	給定一個透過線性（仿射）量化量化的張量，返回底層量化器() 的尺度。
`Tensor.q_zero_point`	給定一個透過線性（仿射）量化量化的張量，返回底層量化器() 的零點。
`Tensor.q_per_channel_scales`	對於透過線性（仿射）每通道量化量化的張量，返回底層量化器的 scales 張量。
`Tensor.q_per_channel_zero_points`	對於透過線性（仿射）每通道量化量化的張量，返回底層量化器的 zero_points 張量。
`Tensor.q_per_channel_axis`	給定一個透過線性（仿射）逐通道量化量化的張量，返回應用逐通道量化的維度的索引。
`Tensor.rad2deg`	請參閱 `torch.rad2deg()`
`Tensor.random_`	使用離散均勻分佈（在 `[from, to - 1]` 上）取樣的數字填充 `self` 張量。
`Tensor.ravel`	參見 `torch.ravel()`
`Tensor.reciprocal`	請參閱 `torch.reciprocal()`
`Tensor.reciprocal_`	`reciprocal()` 的原地版本
`Tensor.record_stream`	將張量標記為已被此流使用。
`Tensor.register_hook`	註冊一個反向鉤子。
`Tensor.register_post_accumulate_grad_hook`	註冊一個在梯度累積後執行的反向鉤子。
`Tensor.remainder`	請參閱 `torch.remainder()`
`Tensor.remainder_`	`remainder()` 的原地版本
`Tensor.renorm`	請參閱 `torch.renorm()`
`Tensor.renorm_`	`renorm()` 的原地版本
`Tensor.repeat`	沿指定維度重複此張量。
`Tensor.repeat_interleave`	請參閱 `torch.repeat_interleave()`。
`Tensor.requires_grad`	如果需要為此張量計算梯度，則為 `True`，否則為 `False`。
`Tensor.requires_grad_`	更改 autograd 是否應記錄此張量上的操作：原地設定此張量的 `requires_grad` 屬性。
`Tensor.reshape`	返回一個與 `self` 具有相同資料和相同數量元素但具有指定形狀的新張量。
`Tensor.reshape_as`	將此張量視為與 `other` 具有相同形狀。
`Tensor.resize_`	將 `self` 張量的大小調整為指定的大小。
`Tensor.resize_as_`	將 `self` 張量的大小調整為與指定的 `tensor` 相同。
`Tensor.retain_grad`	允許此張量的 `grad` 在 `backward()` 期間被填充。
`Tensor.retains_grad`	如果此張量是非葉張量且其 `grad` 在 `backward()` 期間可以被填充，則為 `True`，否則為 `False`。
`Tensor.roll`	請參閱 `torch.roll()`
`Tensor.rot90`	請參閱 `torch.rot90()`
`Tensor.round`	請參閱 `torch.round()`
`Tensor.round_`	`round()` 的原地版本
`Tensor.rsqrt`	請參閱 `torch.rsqrt()`
`Tensor.rsqrt_`	`rsqrt()` 的原地版本
`Tensor.scatter`	`torch.Tensor.scatter_()` 的非原地版本
`Tensor.scatter_`	將 `src` 張量中的所有值按照 `index` 張量指定的索引寫入 `self`。
`Tensor.scatter_add_`	以類似於 `scatter_()` 的方式，將 `src` 張量中的所有值加到 `index` 張量指定的 `self` 張量中的索引處。
`Tensor.scatter_add`	`torch.Tensor.scatter_add_()` 的非原地版本
`Tensor.scatter_reduce_`	使用透過 `reduce` 引數（`"sum"`、`"prod"`、`"mean"`、`"amax"`、`"amin"`）定義的約簡操作，將 `src` 張量中的所有值約簡到 `self` 張量中 `index` 指定的索引。
`Tensor.scatter_reduce`	`torch.Tensor.scatter_reduce_()` 的非原地版本
`Tensor.select`	請參閱 `torch.select()`
`Tensor.select_scatter`	請參閱 `torch.select_scatter()`
`Tensor.set_`	設定底層儲存、大小和步幅。
`Tensor.share_memory_`	將底層儲存移動到共享記憶體。
`Tensor.short`	`self.short()` 等同於 `self.to(torch.int16)`。
`Tensor.sigmoid`	請參閱 `torch.sigmoid()`
`Tensor.sigmoid_`	`sigmoid()` 的原地版本
`Tensor.sign`	請參閱 `torch.sign()`
`Tensor.sign_`	`sign()` 的原地版本
`Tensor.signbit`	請參閱 `torch.signbit()`
`Tensor.sgn`	請參閱 `torch.sgn()`
`Tensor.sgn_`	`sgn()` 的原地版本
`Tensor.sin`	請參閱 `torch.sin()`
`Tensor.sin_`	`sin()` 的原地版本
`Tensor.sinc`	請參閱 `torch.sinc()`
`Tensor.sinc_`	`sinc()` 的原地版本
`Tensor.sinh`	請參閱 `torch.sinh()`
`Tensor.sinh_`	`sinh()` 的原地版本
`Tensor.asinh`	請參閱 `torch.asinh()`
`Tensor.asinh_`	`asinh()` 的原地版本
`Tensor.arcsinh`	請參閱 `torch.arcsinh()`
`Tensor.arcsinh_`	`arcsinh()` 的原地版本
`Tensor.shape`	返回 `self` 張量的大小。
`Tensor.size`	返回 `self` 張量的大小。
`Tensor.slogdet`	請參閱 `torch.slogdet()`
`Tensor.slice_scatter`	請參閱 `torch.slice_scatter()`
`Tensor.softmax`	`torch.nn.functional.softmax()` 的別名。
`Tensor.sort`	請參閱 `torch.sort()`
`Tensor.split`	請參閱 `torch.split()`
`Tensor.sparse_mask`	返回一個新稀疏張量，其中包含來自跨步張量 `self` 且由稀疏張量 `mask` 的索引過濾的值。
`Tensor.sparse_dim`	返回稀疏張量 `self` 的稀疏維度數量。
`Tensor.sqrt`	請參閱 `torch.sqrt()`
`Tensor.sqrt_`	`sqrt()` 的原地版本
`Tensor.square`	請參閱 `torch.square()`
`Tensor.square_`	`square()` 的原地版本
`Tensor.squeeze`	請參閱 `torch.squeeze()`
`Tensor.squeeze_`	`squeeze()` 的原地版本
`Tensor.std`	請參閱 `torch.std()`
`Tensor.stft`	請參閱 `torch.stft()`
`Tensor.storage`	返回底層 `TypedStorage`。
`Tensor.untyped_storage`	返回底層 `UntypedStorage`。
`Tensor.storage_offset`	以儲存元素（而非位元組）的數量返回 `self` 張量在底層儲存中的偏移量。
`Tensor.storage_type`	返回底層儲存的型別。
`Tensor.stride`	返回 `self` 張量的步幅。
`Tensor.sub`	請參閱 `torch.sub()`。
`Tensor.sub_`	`sub()` 的原地版本
`Tensor.subtract`	請參閱 `torch.subtract()`。
`Tensor.subtract_`	`subtract()` 的原地版本。
`Tensor.sum`	請參閱 `torch.sum()`
`Tensor.sum_to_size`	將 `this` 張量求和至 `size`。
`Tensor.svd`	請參閱 `torch.svd()`
`Tensor.swapaxes`	請參閱 `torch.swapaxes()`
`Tensor.swapdims`	請參閱 `torch.swapdims()`
`Tensor.t`	請參閱 `torch.t()`
`Tensor.t_`	`t()` 的原地版本
`Tensor.tensor_split`	請參閱 `torch.tensor_split()`
`Tensor.tile`	請參閱 `torch.tile()`
`Tensor.to`	執行張量資料型別和/或裝置轉換。
`Tensor.to_mkldnn`	返回 `torch.mkldnn` 佈局的張量副本。
`Tensor.take`	請參閱 `torch.take()`
`Tensor.take_along_dim`	請參閱 `torch.take_along_dim()`
`Tensor.tan`	請參閱 `torch.tan()`
`Tensor.tan_`	`tan()` 的原地版本
`Tensor.tanh`	請參閱 `torch.tanh()`
`Tensor.tanh_`	`tanh()` 的原地版本
`Tensor.atanh`	請參閱 `torch.atanh()`
`Tensor.atanh_`	`atanh()` 的原地版本
`Tensor.arctanh`	請參閱 `torch.arctanh()`
`Tensor.arctanh_`	`arctanh()` 的原地版本
`Tensor.tolist`	將張量作為（巢狀）列表返回。
`Tensor.topk`	請參閱 `torch.topk()`
`Tensor.to_dense`	如果 `self` 不是跨步張量，則建立一個 `self` 的跨步副本，否則返回 `self`。
`Tensor.to_sparse`	返回張量的稀疏副本。
`Tensor.to_sparse_csr`	將張量轉換為壓縮行儲存格式 (CSR)。
`Tensor.to_sparse_csc`	將張量轉換為壓縮列儲存 (CSC) 格式。
`Tensor.to_sparse_bsr`	將張量轉換為給定塊大小的塊稀疏行 (BSR) 儲存格式。
`Tensor.to_sparse_bsc`	將張量轉換為給定塊大小的塊稀疏列 (BSC) 儲存格式。
`Tensor.trace`	請參閱 `torch.trace()`
`Tensor.transpose`	請參閱 `torch.transpose()`
`Tensor.transpose_`	`transpose()` 的原地版本
`Tensor.triangular_solve`	請參閱 `torch.triangular_solve()`
`Tensor.tril`	請參閱 `torch.tril()`
`Tensor.tril_`	`tril()` 的原地版本
`Tensor.triu`	請參閱 `torch.triu()`
`Tensor.triu_`	`triu()` 的原地版本
`Tensor.true_divide`	請參閱 `torch.true_divide()`
`Tensor.true_divide_`	`true_divide_()` 的原地版本
`Tensor.trunc`	請參閱 `torch.trunc()`
`Tensor.trunc_`	`trunc()` 的原地版本
`Tensor.type`	如果未提供 dtype，則返回型別，否則將此物件轉換為指定型別。
`Tensor.type_as`	將此張量轉換為給定張量的型別。
`Tensor.unbind`	請參閱 `torch.unbind()`
`Tensor.unflatten`	請參閱 `torch.unflatten()`。
`Tensor.unfold`	返回原始張量的檢視，該檢視包含 `self` 張量在 `dimension` 維度上的大小為 `size` 的所有切片。
`Tensor.uniform_`	在 `self` 張量中填充連續均勻分佈中取樣的數字。
`Tensor.unique`	返回輸入張量的唯一元素。
`Tensor.unique_consecutive`	從每個連續的等效元素組中刪除除第一個元素之外的所有元素。
`Tensor.unsqueeze`	請參閱 `torch.unsqueeze()`
`Tensor.unsqueeze_`	`unsqueeze()` 的原地版本
`Tensor.values`	返回稀疏 COO 張量的 values 張量。
`Tensor.var`	請參閱 `torch.var()`
`Tensor.vdot`	請參閱 `torch.vdot()`
`Tensor.view`	返回一個與 `self` 張量具有相同資料但具有不同 `shape` 的新張量。
`Tensor.view_as`	將此張量視為與 `other` 具有相同大小。
`Tensor.vsplit`	請參閱 `torch.vsplit()`
`Tensor.where`	`self.where(condition, y)` 等同於 `torch.where(condition, self, y)`。
`Tensor.xlogy`	請參閱 `torch.xlogy()`
`Tensor.xlogy_`	`xlogy()` 的原地版本
`Tensor.xpu`	返回此物件在 XPU 記憶體中的副本。
`Tensor.zero_`	用零填充 `self` 張量。

torch.Tensor#

初始化和基本操作#

張量類參考#

文件

教程

資源