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

然而，要構造張量，我們建議使用如 torch.empty() 這樣的工廠函式，並指定 dtype 引數。 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。如果你有一個 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')

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

可以使用 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

有關索引的更多資訊，請參閱 索引、切片、連線、變動操作 (Indexing, Slicing, Joining, Mutating Ops)

可以建立一個張量並設定 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 Views)。

注意

有關 torch.dtype, torch.device 和 torch.layout 這三個 torch.Tensor 屬性的更多資訊，請參閱 張量屬性 (Tensor Attributes)。

注意

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

注意

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

警告

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

Tensor 類參考

class torch.Tensor

根據您的用例，有幾種主要方法可以建立張量。

• 要使用現有資料建立張量，請使用 torch.tensor()。

• 要建立具有特定大小的張量，請使用 torch.* 張量建立操作（參閱 建立操作 (Creation Ops)）。

• 要建立與另一個張量具有相同大小（和相似型別）的張量，請使用 torch.*_like 張量建立操作（參閱 建立操作 (Creation Ops)）。

• 要建立與另一個張量型別相似但大小不同的張量，請使用 tensor.new_* 建立操作。

• 有一個不推薦使用的舊版建構函式 torch.Tensor。建議改用 torch.tensor()。

Tensor.__init__(self, data)

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

• 如果 data 是一個 Tensor，則返回原始 Tensor 的別名。與 torch.tensor() 不同，這會跟蹤 autograd 並將梯度傳播到原始 Tensor。device kwarg 不支援此 data 型別。

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

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

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

引數

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

關鍵字引數

device (torch.device, optional)：返回張量的期望裝置。

預設值：如果為 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

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

對於複數矩陣，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	返回一個新 Tensor，其張量資料為 data。
Tensor.new_full	返回一個大小為 size 並填充 fill_value 的 Tensor。
Tensor.new_empty	返回一個大小為 size 並填充未初始化資料的 Tensor。
Tensor.new_ones	返回一個大小為 size 並填充 1 的 Tensor。
Tensor.new_zeros	返回一個大小為 size 並填充 0 的 Tensor。
Tensor.is_cuda	如果 Tensor 儲存在 GPU 上，則為 True，否則為 False。
Tensor.is_quantized	如果 Tensor 已量化，則為 True，否則為 False。
Tensor.is_meta	如果 Tensor 是 meta 張量，則為 True，否則為 False。
Tensor.device	此 Tensor 所在的 torch.device。
Tensor.grad	此屬性預設為 None，並在第一次呼叫 backward() 計算 self 的梯度時變為一個 Tensor。
Tensor.ndim	dim() 的別名
Tensor.real	對於複數值輸入張量，返回一個包含 self 張量的實部值的新張量。
Tensor.imag	返回一個包含 self 張量的虛部值的新張量。
Tensor.nbytes	如果 Tensor 不使用稀疏儲存佈局，則返回 Tensor 元素的“檢視”消耗的位元組數。
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_	將 alpha 乘以 source 的元素按 index 中給定的順序累加到 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 引數指定的歸約方法，將 source 的元素按 index 中給定的順序累加到 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() 返回一個數據型別為 uint8_t 的 CPU 張量，它儲存給定張量的底層 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 例項。
Tensor.map_	對 self 張量和給定的 tensor 中的每個元素應用 callable，並將結果儲存到 self 張量中。
Tensor.masked_scatter_	將 source 中的元素複製到 self 張量中 mask 為 True 的位置。
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	給定透過線性(仿射)量化量化的張量，返回底層量化器的尺度。
Tensor.q_zero_point	給定透過線性(仿射)量化量化的張量，返回底層量化器的零點。
Tensor.q_per_channel_scales	給定透過線性(仿射)逐通道量化量化的張量，返回底層量化器的尺度張量。
Tensor.q_per_channel_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_	更改自動微分是否應該記錄此張量上的操作：原地設定此張量的 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	返回一個新的稀疏張量，其值來自一個跨步張量 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	執行張量 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。
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 張量的值張量。
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 張量。