torch.Tensor

torch.Tensor 是一個多維矩陣，其中包含單一資料類型的元素。

資料類型

Torch 使用以下資料類型定義張量類型

資料類型	dtype
32 位元浮點數	torch.float32 或 torch.float
64 位元浮點數	torch.float64 或 torch.double
16 位元浮點數 1	torch.float16 或 torch.half
16 位元浮點數 2	torch.bfloat16
32 位元複數	torch.complex32 或 torch.chalf
64 位元複數	torch.complex64 或 torch.cfloat
128 位元複數	torch.complex128 或 torch.cdouble
8 位元整數（無符號）	torch.uint8
16 位元整數（無符號）	torch.uint16（支援有限） 4
32 位元整數（無符號）	torch.uint32（支援有限） 4
64 位元整數（無符號）	torch.uint64（支援有限） 4
8 位元整數（有符號）	torch.int8
16 位元整數（有符號）	torch.int16 或 torch.short
32 位元整數（有符號）	torch.int32 或 torch.int
64 位元整數（有符號）	torch.int64 或 torch.long
布林值	torch.bool
量化的 8 位元整數（無符號）	torch.quint8
量化的 8 位元整數（有符號）	torch.qint8
量化的 32 位元整數（有符號）	torch.qint32
量化的 4 位元整數（無符號） 3	torch.quint4x2
8 位元浮點數，e4m3 5	torch.float8_e4m3fn（支援有限）
8 位元浮點數，e5m2 5	torch.float8_e5m2（支援有限）

1

有時稱為 binary16：使用 1 個符號位元、5 個指數位元和 10 個有效位元數。在需要犧牲範圍以提高精度時很有用。

2

有時稱為 Brain Floating Point：使用 1 個符號位元、8 個指數位元和 7 個有效位元數。在需要範圍時很有用，因為它具有與 float32 相同數量的指數位元。

3

量化的 4 位元整數儲存為 8 位元有符號整數。目前僅在 EmbeddingBag 運算子中支援。

4(1,2,3)

除了 uint8 之外的無符號類型，目前計畫僅在 Eager 模式下提供有限支援（它們主要用於協助使用 torch.compile）；如果您需要 Eager 支援且不需要額外的範圍，我們建議您改用它們的有符號變體。如需更多詳細資訊，請參閱 https://github.com/pytorch/pytorch/issues/58734。

5(1,2)

torch.float8_e4m3fn 和 torch.float8_e5m2 根據 https://arxiv.org/abs/2209.05433 中的規範實作 8 位元浮點數類型。運算子支援非常有限。

為了向後相容性，我們支援以下這些資料類型的替代類別名稱

資料類型	CPU 張量	GPU 張量
32 位元浮點數	torch.FloatTensor	torch.cuda.FloatTensor
64 位元浮點數	torch.DoubleTensor	torch.cuda.DoubleTensor
16 位元浮點數	torch.HalfTensor	torch.cuda.HalfTensor
16 位元浮點數	torch.BFloat16Tensor	torch.cuda.BFloat16Tensor
8 位元整數（無符號）	torch.ByteTensor	torch.cuda.ByteTensor
8 位元整數（有符號）	torch.CharTensor	torch.cuda.CharTensor
16 位元整數（有符號）	torch.ShortTensor	torch.cuda.ShortTensor
32 位元整數（有符號）	torch.IntTensor	torch.cuda.IntTensor
64 位元整數（有符號）	torch.LongTensor	torch.cuda.LongTensor
布林值	torch.BoolTensor	torch.cuda.BoolTensor

然而，若要建構張量，我們建議使用帶有 dtype 參數的工廠函數，例如 torch.empty()。torch.Tensor 建構函數是預設張量類型 (torch.FloatTensor) 的別名。

初始化和基本操作

可以使用 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。如果您有一個張量 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，用於儲存其資料。張量類別還提供儲存空間的多維、跨步 視圖，並在其上定義數值運算。

備註

如需張量視圖的詳細資訊，請參閱 張量視圖。

備註

如需 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 是張量，則傳回原始張量的別名。與 torch.tensor() 不同，這會追蹤自動梯度，並將梯度傳播到原始張量。此 data 類型不支援 device 關鍵字參數。

• 如果 data 是序列或巢狀序列，則建立預設資料類型（通常為 torch.float32）的張量，其資料為序列中的值，必要時會進行強制轉換。值得注意的是，這與 torch.tensor() 不同，因為此建構函數將始終建構浮點張量，即使輸入都是整數也是如此。

• 如果 data 是 torch.Size，則傳回該大小的空張量。

此建構函數不支援明確指定傳回張量的 dtype 或 device。我們建議使用提供此功能的 torch.tensor()。

參數

data (類似陣列)：要從中建構的張量。

關鍵字參數

device (torch.device，可選）：傳回張量的所需裝置。

預設值：如果為 None，則與此張量使用相同的 torch.device。

Tensor.T

傳回此張量的視圖，其維度已反轉。

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

警告

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

Tensor.H

傳回矩陣（二維張量）的共軛轉置視圖。

對於複數矩陣，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_	填充至少具有二維張量的主要對角線。
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	傳回一個 int 元組，描述 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	使用與 self 相同的資料指標建立 cls instance。
Tensor.map_	將 callable 應用於 self 張量和給定的 tensor 中的每個元素，並將結果儲存在 self 張量中。
Tensor.masked_scatter_	將 source 中的元素複製到 mask 為 True 的位置的 self 張量中。
Tensor.masked_scatter	torch.Tensor.masked_scatter_() 的非原地版本
Tensor.masked_fill_	使用 value 填充 self 張量中 mask 為 True 的元素。
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 時如何轉換 other。
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	給定一個通過線性（仿射）量化量化的張量，返回底層 quantizer() 的比例。
Tensor.q_zero_point	給定一個通過線性（仿射）量化量化的張量，返回底層 quantizer() 的零點。
Tensor.q_per_channel_scales	給定一個通過線性（仿射）逐通道量化量化的張量，返回底層 quantizer 的比例張量。
Tensor.q_per_channel_zero_points	給定一個通過線性（仿射）逐通道量化量化的張量，返回底層 quantizer 的零點張量。
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	讓此張量能夠在 backward() 期間填入其 grad。
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 中的所有值寫入 self 中由 index 張量指定的索引處。
Tensor.scatter_add_	以類似於 scatter_() 的方式，將張量 src 中的所有值加到 self 中由 index 張量指定的索引處。
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	返回一個新的 稀疏張量，其值來自由稀疏張量 mask 的索引過濾的跨步張量 self。
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	執行張量 dtype 和/或裝置轉換。
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	傳回原始張量的一個視圖，其中包含維度 dimension 中 self 張量中所有大小為 size 的切片。
Tensor.uniform_	以從連續均勻分佈中取樣的數字填充 self 張量
Tensor.unique	傳回輸入張量的唯一元素。
Tensor.unique_consecutive	從每個相等元素的連續群組中消除第一個元素以外的所有元素。
Tensor.unsqueeze	請參閱 torch.unsqueeze()
Tensor.unsqueeze_	unsqueeze() 的就地版本
Tensor.values	傳回 稀疏 COO 張量 的值張量。
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 張量。