---

torch

torch 包提供了多維張量的數據結構，并定義了針對這些張量的數學運算。此外，它還包含許多實用工具，可實現張量及任意類型的高效序列化，以及其他實用功能。

該包還配有 CUDA 版本，支持在計算能力 >= 3.0 的 NVIDIA GPU 上運行張量計算。

---

張量

is_tensor	如果 obj 是 PyTorch 張量則返回 True。
is_storage	如果 obj 是 PyTorch 存儲對象則返回 True。
is_complex	如果 input 的數據類型是復數類型（即 torch.complex64 或 torch.complex128）則返回 True。
is_conj	如果 input 是共軛張量（即其共軛位被設為 True）則返回 True。
is_floating_point	如果 input 的數據類型是浮點類型（即 torch.float64、torch.float32、torch.float16 或 torch.bfloat16）則返回 True。
is_nonzero	如果 input 是單元素張量且在類型轉換后不等于零則返回 True。
set_default_dtype	將默認浮點數據類型設置為 d。
get_default_dtype	獲取當前默認浮點 torch.dtype。
set_default_device	設置默認 torch.Tensor 分配到的設備為 device。
get_default_device	獲取默認 torch.Tensor 分配到的設備 device。
set_default_tensor_type
numel	返回 input 張量中的元素總數。
set_printoptions	設置打印選項。
set_flush_denormal	在 CPU 上禁用非正規浮點數。

---

創建操作

---

隨機采樣創建操作列在隨機采樣下，包括：torch.rand()、torch.rand_like()、torch.randn()、torch.randn_like()、torch.randint()、torch.randint_like()、torch.randperm()。你也可以使用torch.empty()結合原地隨機采樣方法來創建torch.Tensor，其值從更廣泛的分布中采樣。

tensor	通過復制data構造一個沒有自動求導歷史的張量（也稱為“葉子張量”，參見自動求導機制）。
sparse_coo_tensor	在給定的indices處構造一個COO（坐標）格式的稀疏張量。
sparse_csr_tensor	在給定的crow_indices和col_indices處構造一個CSR（壓縮稀疏行）格式的稀疏張量。
sparse_csc_tensor	在給定的ccol_indices和row_indices處構造一個CSC（壓縮稀疏列）格式的稀疏張量。
sparse_bsr_tensor	在給定的crow_indices和col_indices處構造一個BSR（塊壓縮稀疏行）格式的稀疏張量，包含指定的二維塊。
sparse_bsc_tensor	在給定的ccol_indices和row_indices處構造一個BSC（塊壓縮稀疏列）格式的稀疏張量，包含指定的二維塊。
asarray	將obj轉換為張量。
as_tensor	將data轉換為張量，盡可能共享數據并保留自動求導歷史。
as_strided	創建一個現有torch.Tensor的視圖，指定size、stride和storage_offset。
from_file	創建一個由內存映射文件支持的CPU張量。
from_numpy	從numpy.ndarray創建Tensor。
from_dlpack	將外部庫中的張量轉換為torch.Tensor。
frombuffer	從實現Python緩沖區協議的對象創建一維Tensor。
zeros	返回一個填充標量值0的張量，形狀由可變參數size定義。
zeros_like	返回一個填充標量值0的張量，大小與input相同。
ones	返回一個填充標量值1的張量，形狀由可變參數size定義。
ones_like	返回一個填充標量值1的張量，大小與input相同。
arange	返回一個大小為?end?startstep?的一維張量，值取自區間[start, end)，步長為step。
range	返回一個大小為?end?startstep?+1的一維張量，值從start到end，步長為step。
linspace	創建一個大小為steps的一維張量，值從start到end均勻分布（包含端點）。
logspace	創建一個大小為steps的一維張量，值在base^start到base^end之間均勻分布（包含端點），對數刻度。
eye	返回一個二維張量，對角線為1，其余為0。
empty	返回一個填充未初始化數據的張量。
empty_like	返回一個未初始化的張量，大小與input相同。
empty_strided	創建一個指定size和stride的張量，填充未定義數據。
full	創建一個大小為size的張量，填充fill_value。
full_like	返回一個大小與input相同的張量，填充fill_value。
quantize_per_tensor	將浮點張量轉換為具有給定比例和零點的量化張量。
quantize_per_channel	將浮點張量轉換為具有給定比例和零點的逐通道量化張量。
dequantize	通過反量化量化張量返回一個fp32張量。
complex	構造一個復數張量，實部為real，虛部為imag。
polar	構造一個復數張量，其元素為極坐標對應的笛卡爾坐標，絕對值為abs，角度為angle。
heaviside	計算input中每個元素的Heaviside階躍函數。

---

索引、切片、連接與變異操作

adjoint	返回張量的共軛視圖，并轉置最后兩個維度。
argwhere	返回包含輸入張量input所有非零元素索引的張量。
cat	在給定維度上連接張量序列tensors。
concat	torch.cat()的別名。
concatenate	torch.cat()的別名。
conj	返回翻轉共軛位后的輸入張量input視圖。
chunk	嘗試將張量分割為指定數量的塊。
dsplit	按indices_or_sections深度方向分割三維及以上張量input。
column_stack	通過水平堆疊tensors中的張量創建新張量。
dstack	沿第三軸深度堆疊張量序列。
gather	沿指定維度dim聚集值。
hsplit	按indices_or_sections水平分割一維及以上張量input。
hstack	水平（按列）堆疊張量序列。
index_add	功能描述見index_add_()。
index_copy	功能描述見index_add_()。
index_reduce	功能描述見index_reduce_()。
index_select	使用長整型張量index沿維度dim索引輸入張量input，返回新張量。
masked_select	根據布爾掩碼mask（BoolTensor類型）索引輸入張量input，返回新的一維張量。
movedim	將輸入張量input的維度從source位置移動到destination位置。
moveaxis	torch.movedim()的別名。
narrow	返回輸入張量input的縮小版本。
narrow_copy	功能同Tensor.narrow()，但返回副本而非共享存儲。
nonzero
permute	返回原始張量input的維度重排視圖。
reshape	返回與input數據相同但形狀改變的新張量。
row_stack	torch.vstack()的別名。
select	在選定維度的給定索引處切片輸入張量input。
scatter	torch.Tensor.scatter_()的非原位版本。
diagonal_scatter	將源張量src的值沿dim1和dim2嵌入到輸入張量input的對角元素中。
select_scatter	將源張量src的值嵌入到輸入張量input的指定索引處。
slice_scatter	將源張量src的值沿指定維度嵌入到輸入張量input中。
scatter_add	torch.Tensor.scatter_add_()的非原位版本。
scatter_reduce	torch.Tensor.scatter_reduce_()的非原位版本。
split	將張量分割成塊。
squeeze	移除輸入張量input中所有大小為1的指定維度。
stack	沿新維度連接張量序列。
swapaxes	torch.transpose()的別名。
swapdims	torch.transpose()的別名。
t	要求輸入input為≤2維張量，并轉置維度0和1。
take	返回輸入張量input在給定索引處元素組成的新張量。
take_along_dim	沿指定維度dim從一維索引indices處選擇輸入張量input的值。
tensor_split	根據indices_or_sections將張量沿維度dim分割為多個子張量（均為input的視圖）。
tile	通過重復輸入張量input的元素構造新張量。
transpose	返回輸入張量input的轉置版本。
unbind	移除張量維度。
unravel_index	將平面索引張量轉換為坐標張量元組，用于索引指定形狀的任意張量。
unsqueeze	在指定位置插入大小為1的維度，返回新張量。
vsplit	按indices_or_sections垂直分割二維及以上張量input。
vstack	垂直（按行）堆疊張量序列。
where	根據條件condition從input或other中選擇元素組成新張量。

---

加速器

在 PyTorch 代碼庫中，我們將"加速器"定義為與 CPU 協同工作以加速計算的 torch.device。這些設備采用異步執行方案，使用 torch.Stream 和 torch.Event 作為主要的同步機制。我們假設在給定主機上一次只能使用一個這樣的加速器，這使得我們可以將當前加速器作為默認設備，用于固定內存、流設備類型、FSDP 等相關概念。

目前支持的加速器設備包括（無特定順序）：“CUDA”、“MTIA”、“XPU”、“MPS”、“HPU”以及 PrivateUse1（許多設備不在 PyTorch 代碼庫本身中）。

PyTorch 生態系統中的許多工具使用 fork 創建子進程（例如數據加載或操作內并行），因此應盡可能延遲任何會阻止后續 fork 的操作。這一點尤為重要，因為大多數加速器的初始化都會產生這種影響。實際應用中需注意，默認情況下檢查 torch.accelerator.current_accelerator() 是編譯時檢查，因此始終是 fork 安全的。相反，向此函數傳遞 check_available=True 標志或調用 torch.accelerator.is_available() 通常會阻止后續 fork。

某些后端提供實驗性的可選選項，使運行時可用性檢查成為 fork 安全的。例如，使用 CUDA 設備時可以使用 PYTORCH_NVML_BASED_CUDA_CHECK=1。

Stream	按先進先出（FIFO）順序異步執行相應任務的有序隊列。
Event	查詢和記錄流狀態，以識別或控制跨流的依賴關系并測量時間。

---

生成器

Generator	創建并返回一個生成器對象，該對象用于管理產生偽隨機數的算法狀態。

---

隨機采樣

seed	將所有設備的隨機數生成種子設置為非確定性隨機數
manual_seed	設置所有設備的隨機數生成種子
initial_seed	返回生成隨機數的初始種子（Python長整型）
get_rng_state	返回隨機數生成器狀態（torch.ByteTensor類型）
set_rng_state	設置隨機數生成器狀態

torch.default_generator 返回默認的CPU torch.Generator

---

bernoulli	從伯努利分布中抽取二元隨機數（0或1）。
multinomial	返回一個張量，其中每一行包含從對應行的張量input中的多項式（更嚴格的定義是多元的，更多細節請參考torch.distributions.multinomial.Multinomial）概率分布中抽取的num_samples個索引。
normal	返回一個張量，其中的隨機數是從具有給定均值和標準差的獨立正態分布中抽取的。
poisson	返回一個與input大小相同的張量，其中每個元素都是從具有由input中對應元素給出的速率參數的泊松分布中抽取的。
rand	返回一個張量，其中填充了來自區間[0,1)上的均勻分布的隨機數。
rand_like	返回一個與input大小相同的張量，其中填充了來自區間[0,1)上的均勻分布的隨機數。
randint	返回一個張量，其中填充了在low（包含）和high（不包含）之間均勻生成的隨機整數。
randint_like	返回一個與張量input形狀相同的張量，其中填充了在low（包含）和high（不包含）之間均勻生成的隨機整數。
randn	返回一個張量，其中填充了來自均值為0、方差為1的正態分布的隨機數（也稱為標準正態分布）。
randn_like	返回一個與input大小相同的張量，其中填充了來自均值為0、方差為1的正態分布的隨機數。
randperm	返回一個從0到n - 1的整數的隨機排列。

---

原地隨機采樣

張量上還定義了一些原地隨機采樣函數。點擊以下鏈接查看它們的文檔：

• torch.Tensor.bernoulli_() - torch.bernoulli() 的原地版本
• torch.Tensor.cauchy_() - 從柯西分布中抽取的數字
• torch.Tensor.exponential_() - 從指數分布中抽取的數字
• torch.Tensor.geometric_() - 從幾何分布中抽取的元素
• torch.Tensor.log_normal_() - 從對數正態分布中抽取的樣本
• torch.Tensor.normal_() - torch.normal() 的原地版本
• torch.Tensor.random_() - 從離散均勻分布中抽取的數字
• torch.Tensor.uniform_() - 從連續均勻分布中抽取的數字

---

準隨機采樣

quasirandom.SobolEngine	torch.quasirandom.SobolEngine 是一個用于生成（加擾）Sobol序列的引擎。

---

序列化

save	將對象保存到磁盤文件。
load	從文件中加載由 torch.save() 保存的對象。

---

并行計算

get_num_threads	返回用于CPU操作并行化的線程數
set_num_threads	設置CPU上用于內部操作并行化的線程數
get_num_interop_threads	返回CPU上用于操作間并行化的線程數（例如
set_num_interop_threads	設置用于操作間并行化的線程數（例如

---

局部禁用梯度計算

上下文管理器 torch.no_grad()、torch.enable_grad() 和 torch.set_grad_enabled() 可用于在局部范圍內禁用或啟用梯度計算。具體用法詳見局部禁用梯度計算文檔。這些上下文管理器是線程局部的，因此如果通過threading模塊等將工作發送到其他線程，它們將不會生效。

---

示例：

>>> x = torch.zeros(1, requires_grad=True)>>> with torch.no_grad():
...     y = x * 2
>>> y.requires_grad
False>>> is_train = False
>>> with torch.set_grad_enabled(is_train):
...     y = x * 2
>>> y.requires_grad
False>>> torch.set_grad_enabled(True)  # 也可以作為函數使用
>>> y = x * 2
>>> y.requires_grad
True>>> torch.set_grad_enabled(False)
>>> y = x * 2
>>> y.requires_grad
False

---

| no_grad | 禁用梯度計算的上下文管理器。 |

| — | — |

| enable_grad | 啟用梯度計算的上下文管理器。 |

| autograd.grad_mode.set_grad_enabled | 設置梯度計算開啟或關閉的上下文管理器。 |

| is_grad_enabled | 如果當前梯度模式已啟用則返回True。 |

| autograd.grad_mode.inference_mode | 啟用或禁用推理模式的上下文管理器。 |

| is_inference_mode_enabled | 如果當前推理模式已啟用則返回True。 |

---

數學運算

---

常量

inf	浮點正無窮大。math.inf 的別名。
nan	浮點“非數字”值。該值不是一個合法的數字。math.nan 的別名。

---

逐點運算

abs	計算 input 中每個元素的絕對值。
absolute	torch.abs() 的別名
acos	計算 input 中每個元素的反余弦值。
arccos	torch.acos() 的別名。
acosh	返回一個新張量，包含 input 中元素的反雙曲余弦值。
arccosh	torch.acosh() 的別名。
add	將 other 乘以 alpha 后加到 input 上。
addcdiv	對 tensor1 和 tensor2 進行逐元素除法，將結果乘以標量 value 后加到 input 上。
addcmul	對 tensor1 和 tensor2 進行逐元素乘法，將結果乘以標量 value 后加到 input 上。
angle	計算給定 input 張量中每個元素的角度（弧度）。
asin	返回一個新張量，包含 input 中元素的反正弦值。
arcsin	torch.asin() 的別名。
asinh	返回一個新張量，包含 input 中元素的反雙曲正弦值。
arcsinh	torch.asinh() 的別名。
atan	返回一個新張量，包含 input 中元素的反正切值。
arctan	torch.atan() 的別名。
atanh	返回一個新張量，包含 input 中元素的反雙曲正切值。
arctanh	torch.atanh() 的別名。
atan2	逐元素計算 inputi/otheri\text{input}{i} / \text{other}{i}inputi?/otheri? 的反正切值，并考慮象限。
arctan2	torch.atan2() 的別名。
bitwise_not	計算給定輸入張量的按位取反。
bitwise_and	計算 input 和 other 的按位與。
bitwise_or	計算 input 和 other 的按位或。
bitwise_xor	計算 input 和 other 的按位異或。
bitwise_left_shift	計算 input 左移 other 位的算術結果。
bitwise_right_shift	計算 input 右移 other 位的算術結果。
ceil	返回一個新張量，包含 input 中每個元素的向上取整值（不小于該元素的最小整數）。
clamp	將 input 中的所有元素限制在 min 和 max 范圍內。
clip	torch.clamp() 的別名。
conj_physical	計算給定 input 張量的逐元素共軛。
copysign	創建一個新浮點張量，其數值為 input 的絕對值，符號為 other 的符號（逐元素）。
cos	返回一個新張量，包含 input 中元素的余弦值。
cosh	返回一個新張量，包含 input 中元素的雙曲余弦值。
deg2rad	返回一個新張量，將 input 中的角度從度轉換為弧度。
div	將 input 中的每個元素除以 other 中對應的元素。
divide	torch.div() 的別名。
digamma	torch.special.digamma() 的別名。
erf	torch.special.erf() 的別名。
erfc	torch.special.erfc() 的別名。
erfinv	torch.special.erfinv() 的別名。
exp	返回一個新張量，包含輸入張量 input 中元素的指數值。
exp2	torch.special.exp2() 的別名。
expm1	torch.special.expm1() 的別名。
fake_quantize_per_channel_affine	返回一個新張量，其中 input 的數據按通道使用 scale、zero_point、quant_min 和 quant_max 進行偽量化，通道由 axis 指定。
fake_quantize_per_tensor_affine	返回一個新張量，其中 input 的數據使用 scale、zero_point、quant_min 和 quant_max 進行偽量化。
fix	torch.trunc() 的別名
float_power	以雙精度逐元素計算 input 的 exponent 次冪。
floor	返回一個新張量，包含 input 中每個元素的向下取整值（不大于該元素的最大整數）。
floor_divide
fmod	逐元素應用 C++ 的 std::fmod。
frac	計算 input 中每個元素的小數部分。
frexp	將 input 分解為尾數和指數張量，滿足 input=mantissa×2exponent\text{input} = \text{mantissa} \times 2^{\text{exponent}}input=mantissa×2exponent。
gradient	使用二階精確中心差分法估計函數 g:Rn→Rg : \mathbb{R}^n \rightarrow \mathbb{R}g:Rn→R 在一維或多維上的梯度，邊界處使用一階或二階估計。
imag	返回一個新張量，包含 self 張量的虛部值。
ldexp	將 input 乘以 2 的 other 次方。
lerp	根據標量或張量 weight 對兩個張量 start（由 input 給出）和 end 進行線性插值，返回結果張量 out。
lgamma	計算 input 上伽馬函數絕對值的自然對數。
log	返回一個新張量，包含 input 中元素的自然對數。
log10	返回一個新張量，包含 input 中元素的以 10 為底的對數。
log1p	返回一個新張量，包含 (1 + input) 的自然對數。
[log2](https://docs.pytorch.org/docs/stable/generated/torch.log2.html#torch.log2 "

---

歸約操作

argmax	返回 input 張量中所有元素最大值的索引
argmin	返回展平張量或沿指定維度中最小值的索引
amax	返回 input 張量在給定維度 dim 上各切片的最大值
amin	返回 input 張量在給定維度 dim 上各切片的最小值
aminmax	計算 input 張量的最小值和最大值
all	測試 input 中所有元素是否均為 True
any	測試 input 中是否存在任意元素為 True
max	返回 input 張量中所有元素的最大值
min	返回 input 張量中所有元素的最小值
dist	返回 (input - other) 的 p-范數
logsumexp	返回 input 張量在給定維度 dim 上各行指數求和對數
mean
nanmean	計算指定維度中所有非 NaN 元素的均值
median	返回 input 中所有值的中位數
nanmedian	返回 input 中所有值的中位數（忽略 NaN 值）
mode	返回命名元組 (values, indices)，其中 values 是 input 張量在給定維度 dim 上各行的眾數值（即該行最常出現的值），indices 是各眾數值的索引位置
norm	返回給定張量的矩陣范數或向量范數
nansum	返回所有元素的和（將 NaN 視為零）
prod	返回 input 張量中所有元素的乘積
quantile	計算 input 張量在維度 dim 上各行的 q 分位數
nanquantile	torch.quantile() 的變體，忽略 NaN 值計算分位數 q（如同 input 中的 NaN 不存在）
std	計算指定維度 dim 上的標準差
std_mean	計算指定維度 dim 上的標準差和均值
sum	返回 input 張量中所有元素的和
unique	返回輸入張量的唯一元素
unique_consecutive	去除連續等效元素組中除首個元素外的所有元素
var	計算指定維度 dim 上的方差
var_mean	計算指定維度 dim 上的方差和均值
count_nonzero	統計張量 input 在給定維度 dim 上的非零值數量

---

比較運算

allclose	檢查 input 和 other 是否滿足條件：
argsort	返回按值升序排列張量沿指定維度的索引。
eq	逐元素計算相等性
equal	如果兩個張量大小和元素相同返回 True，否則返回 False。
ge	逐元素計算 input≥other\text{input} \geq \text{other}input≥other。
greater_equal	torch.ge() 的別名。
gt	逐元素計算 input>other\text{input} \text{other}input>other。
greater	torch.gt() 的別名。
isclose	返回一個新張量，其布爾元素表示 input 的每個元素是否與 other 的對應元素"接近"。
isfinite	返回一個新張量，其布爾元素表示每個元素是否為有限值。
isin	測試 elements 的每個元素是否在 test_elements 中。
isinf	測試 input 的每個元素是否為無窮大（正無窮或負無窮）。
isposinf	測試 input 的每個元素是否為正無窮。
isneginf	測試 input 的每個元素是否為負無窮。
isnan	返回一個新張量，其布爾元素表示 input 的每個元素是否為 NaN。
isreal	返回一個新張量，其布爾元素表示 input 的每個元素是否為實數值。
kthvalue	返回一個命名元組 (values, indices)，其中 values 是 input 張量在給定維度 dim 上每行的第 k 個最小元素。
le	逐元素計算 input≤other\text{input} \leq \text{other}input≤other。
less_equal	torch.le() 的別名。
lt	逐元素計算 input<other\text{input} < \text{other}input<other。
less	torch.lt() 的別名。
maximum	計算 input 和 other 的逐元素最大值。
minimum	計算 input 和 other 的逐元素最小值。
fmax	計算 input 和 other 的逐元素最大值。
fmin	計算 input 和 other 的逐元素最小值。
ne	逐元素計算 input≠other\text{input} \neq \text{other}input=other。
not_equal	torch.ne() 的別名。
sort	按值升序排列 input 張量沿指定維度的元素。
topk	返回 input 張量沿給定維度的前 k 個最大元素。
msort	按值升序排列 input 張量沿其第一維度的元素。

---

頻譜操作

stft	短時傅里葉變換 (STFT)。
istft	短時傅里葉逆變換。
bartlett_window	巴特利特窗函數。
blackman_window	布萊克曼窗函數。
hamming_window	漢明窗函數。
hann_window	漢恩窗函數。
kaiser_window	計算具有窗口長度 window_length 和形狀參數 beta 的凱撒窗。

---

其他操作

atleast_1d	返回每個零維輸入張量的一維視圖。
atleast_2d	返回每個零維輸入張量的二維視圖。
atleast_3d	返回每個零維輸入張量的三維視圖。
bincount	統計非負整數數組中每個值的出現頻率。
block_diag	根據提供的張量創建塊對角矩陣。
broadcast_tensors	按照廣播語義廣播給定張量。
broadcast_to	將input廣播至指定形狀shape。
broadcast_shapes	功能類似broadcast_tensors()，但針對形狀操作。
bucketize	返回input中每個值所屬的桶索引，桶邊界由boundaries定義。
cartesian_prod	計算給定張量序列的笛卡爾積。
cdist	計算兩組行向量之間批次化的p范數距離。
clone	返回input的副本。
combinations	計算給定張量中長度為rrr的組合。
corrcoef	估計input矩陣的皮爾遜積矩相關系數矩陣，其中行代表變量，列代表觀測值。
cov	估計input矩陣的協方差矩陣，其中行代表變量，列代表觀測值。
cross	返回input和other在維度dim上的向量叉積。
cummax	返回命名元組(values, indices)，其中values是input在維度dim上的累積最大值。
cummin	返回命名元組(values, indices)，其中values是input在維度dim上的累積最小值。
cumprod	返回input在維度dim上的累積乘積。
cumsum	返回input在維度dim上的累積和。
diag	* 若input為向量（1維張量），則返回2維方陣
diag_embed	創建張量，其特定2D平面（由dim1和dim2指定）的對角線由input填充。
diagflat	* 若input為向量（1維張量），則返回2維方陣
diagonal	返回input的部分視圖，其中相對于dim1和dim2的對角線元素被附加到形狀末尾。
diff	沿給定維度計算第n階前向差分。
einsum	根據愛因斯坦求和約定，沿指定維度對輸入operands的元素乘積求和。
flatten	將input展平為一維張量。
flip	沿指定維度反轉n維張量的順序。
fliplr	左右翻轉張量，返回新張量。
flipud	上下翻轉張量，返回新張量。
kron	計算input和other的克羅內克積（?）。
rot90	在指定平面內將n維張量旋轉90度。
gcd	計算input和other的逐元素最大公約數(GCD)。
histc	計算張量的直方圖。
histogram	計算張量值的直方圖。
histogramdd	計算張量值的多維直方圖。
meshgrid	根據1D輸入張量創建坐標網格。
lcm	計算input和other的逐元素最小公倍數(LCM)。
logcumsumexp	返回input在維度dim上元素指數累積求和的對數值。
ravel	返回連續的展平張量。
renorm	返回歸一化后的張量，其中input沿維度dim的每個子張量的p范數小于maxnorm。
repeat_interleave	重復張量元素。
roll	沿指定維度滾動張量input。
searchsorted	在sorted_sequence最內層維度查找索引，使得插入values對應值后仍保持排序順序。
tensordot	返回a和b在多個維度上的縮并結果。
trace	返回輸入2維矩陣對角線元素之和。
tril	返回矩陣（2維張量）或矩陣批次input的下三角部分，結果張量out的其他元素設為0。
tril_indices	返回row×col矩陣下三角部分的索引（2×N張量），首行為所有索引的行坐標，次行為列坐標。
triu	返回矩陣（2維張量）或矩陣批次input的上三角部分，結果張量out的其他元素設為0。
triu_indices	返回row×col矩陣上三角部分的索引（2×N張量），首行為所有索引的行坐標，次行為列坐標。
unflatten	將輸入張量的一個維度擴展為多個維度。
vander	生成范德蒙矩陣。
view_as_real	返回input作為實數張量的視圖。
view_as_complex	返回input作為復數張量的視圖。
resolve_conj	若input的共軛位為True，則返回具體化共軛的新張量，否則返回原張量。
resolve_neg	若input的負位為True，則返回具體化取反的新張量，否則返回原張量。

---

BLAS 和 LAPACK 運算

addbmm	對存儲在 batch1 和 batch2 中的矩陣執行批量矩陣乘法，并帶有縮減加法步驟（所有矩陣乘法沿第一維度累積）。
addmm	對矩陣 mat1 和 mat2 執行矩陣乘法。
addmv	對矩陣 mat 和向量 vec 執行矩陣-向量乘法。
addr	對向量 vec1 和 vec2 執行外積，并將其加到矩陣 input 上。
baddbmm	對 batch1 和 batch2 中的矩陣執行批量矩陣乘法。
bmm	對存儲在 input 和 mat2 中的矩陣執行批量矩陣乘法。
chain_matmul	返回 NNN 個二維張量的矩陣乘積。
cholesky	計算對稱正定矩陣 AAA 或其批次的 Cholesky 分解。
cholesky_inverse	給定其 Cholesky 分解，計算復 Hermitian 或實對稱正定矩陣的逆。
cholesky_solve	給定其 Cholesky 分解，計算具有復 Hermitian 或實對稱正定 lhs 的線性方程組的解。
dot	計算兩個一維張量的點積。
geqrf	這是一個直接調用 LAPACK 的 geqrf 的低級函數。
ger	torch.outer() 的別名。
inner	計算一維張量的點積。
inverse	torch.linalg.inv() 的別名。
det	torch.linalg.det() 的別名。
logdet	計算方陣或其批次的 log 行列式。
slogdet	torch.linalg.slogdet() 的別名。
lu	計算矩陣或其批次 A 的 LU 分解。
lu_solve	使用來自 lu_factor() 的部分主元 LU 分解，返回線性方程組 Ax=bAx = bAx=b 的 LU 解。
lu_unpack	將 lu_factor() 返回的 LU 分解解包為 P、L、U 矩陣。
matmul	兩個張量的矩陣乘積。
matrix_power	torch.linalg.matrix_power() 的別名。
matrix_exp	torch.linalg.matrix_exp() 的別名。
mm	對矩陣 input 和 mat2 執行矩陣乘法。
mv	對矩陣 input 和向量 vec 執行矩陣-向量乘法。
orgqr	torch.linalg.householder_product() 的別名。
ormqr	計算 Householder 矩陣與一般矩陣的矩陣-矩陣乘法。
outer	input 和 vec2 的外積。
pinverse	torch.linalg.pinv() 的別名。
qr	計算矩陣或其批次 input 的 QR 分解，并返回一個命名元組 (Q, R)，使得 input=QR\text{input} = Q Rinput=QR，其中 QQQ 是正交矩陣或其批次，RRR 是上三角矩陣或其批次。
svd	計算矩陣或其批次 input 的奇異值分解。
svd_lowrank	返回矩陣、矩陣批次或稀疏矩陣 AAA 的奇異值分解 (U, S, V)，使得 A≈Udiag?(S)VHA \approx U \operatorname{diag}(S) V^{\text{H}}A≈Udiag(S)VH。
pca_lowrank	對低秩矩陣、其批次或稀疏矩陣執行線性主成分分析 (PCA)。
lobpcg	使用無矩陣 LOBPCG 方法找到對稱正定廣義特征值問題的 k 個最大（或最小）特征值及其對應的特征向量。
trapz	torch.trapezoid() 的別名。
trapezoid	沿 dim 計算梯形法則。
cumulative_trapezoid	沿 dim 累積計算梯形法則。
triangular_solve	解具有方上或下三角可逆矩陣 AAA 和多個右側 bbb 的方程組。
vdot	沿某一維度計算兩個一維向量的點積。

---

遍歷操作

---

警告：此API處于測試階段，未來可能會有變更。
不支持前向模式自動微分。

_foreach_abs	對輸入列表中的每個張量應用 torch.abs()。
_foreach_abs_	對輸入列表中的每個張量應用 torch.abs()。
_foreach_acos	對輸入列表中的每個張量應用 torch.acos()。
_foreach_acos_	對輸入列表中的每個張量應用 torch.acos()。
_foreach_asin	對輸入列表中的每個張量應用 [torch.asin()](https://docs.pytorch.org/docs/極簡翻譯結果：

遍歷操作

---

警告：此API處于測試階段，未來可能會有變更。
不支持前向模式自動微分。

_foreach_abs	對輸入列表中的每個張量應用 torch.abs()。
_foreach_abs_	對輸入列表中的每個張量應用 torch.abs()。
_foreach_acos	對輸入列表中的每個張量應用 torch.acos()。
_foreach_acos_	對輸入列表中的每個張量應用 torch.acos()。
_foreach_asin	對輸入列表中的每個張量應用 torch.asin()。
_foreach_asin_	對輸入列表中的每個張量應用 torch.asin()。
_foreach_atan	對輸入列表中的每個張量應用 [torch.atan()](https://docs.pytorch.org/docs/stable/generated/torch.atan.html#極簡翻譯結果：

遍歷操作

---

警告：此API處于測試階段，未來可能會有變更。
不支持前向模式自動微分。

| [_foreach_abs](https://docs.pytorch.org/docs/stable/generated/torch._foreach_abs.html#極簡翻譯結果：

遍歷操作

---

警告：此API處于測試階段，未來可能會有變更。
不支持前向模式自動微分。

_foreach_abs	對輸入列表中的每個張量應用 torch.abs()。
[_foreach_abs_](https://docs.pytorch.org/docs/stable/generated/torch.foreach_abs.html#torch._foreach極簡翻譯結果：

遍歷操作

---

警告：此API處于測試階段，未來可能會有變更。
不支持前向模式自動微分。

_foreach_abs	對輸入列表中的每個張量應用 torch.abs()。
_foreach_abs_	對輸入列表中的每個張量應用 torch.abs()。
_foreach_acos	對輸入列表中的每個張量應用 torch.acos()。
_foreach_acos_	對輸入列表中的每個張量應用 torch.acos()。
[_foreach_asin](https://docs.pytorch.org/docs/stable/generated極簡翻譯結果：

遍歷操作

---

警告：此API處于測試階段，未來可能會有變更。
不支持前向模式自動微分。

| [_foreach_abs](https://docs.pytorch.org/docs/stable/generated/torch._foreach_abs.html#torch._foreach_abs "torch._foreach極簡翻譯結果：

遍歷操作

---

警告：此API處于測試階段，未來可能會有變更。
不支持前向模式自動微分。

_foreach_abs	對輸入列表中的每個張量應用 torch.abs()。
_foreach_abs_	對輸入列表中的每個張量應用 torch.abs()。
_foreach_acos	對輸入列表中的每個張量應用 [`tor極簡翻譯結果：

遍歷操作

---

警告：此API處于測試階段，未來可能會有變更。
不支持前向模式自動微分。

_foreach_abs	對輸入列表中的每個張量應用 torch.abs()。
_foreach_abs_	對輸入列表中的每個張量應用 torch.abs()。
_foreach_acos	對輸入列表中的每個張量應用 torch.acos()。
_foreach_acos_	對輸入列表中的每個張量應用 torch.acos()。
_foreach_asin	對輸入列表中的每個張量應用 torch.asin()。
_foreach_asin_	對輸入列表中的每個張量應用 torch.asin()。
_foreach_atan	對輸入列表中的每個張量應用 torch.atan()。
[`極簡翻譯結果：

遍歷操作

---

警告：此API處于測試階段，未來可能會有變更。
不支持前向模式自動微分。

| _foreach_abs | 對輸入列表中的每個張量應用 [torch.abs()](https://docs.pytorch.org/docs/stable極簡翻譯結果：

遍歷操作

---

警告：此API處于測試階段，未來可能會有變更。
不支持前向模式自動微分。

_foreach_abs	對輸入列表中的每個張量應用 torch.abs()。
_foreach_abs_	對輸入列表中的每個張量應用 torch.abs()。
_foreach_acos	對輸入列表中的每個張量應用 torch.acos()。
_foreach_acos_	對輸入列表中的每個張量應用 torch.acos()。
_foreach_asin	對輸入列表中的每個張量應用 torch.asin()。
_foreach_asin_	對輸入列表中的每個張量應用 torch.asin()。
_foreach_atan	對輸入列表中的每個張量應用 torch.atan()。
_foreach_atan_	對輸入列表中的每個張量應用 torch.atan()。
_foreach_ceil	對輸入列表中的每個張量應用 [torch.ceil()](https://docs.pytorch.org/docs/stable/generated/torch.ceil.html#torch.ceil "極簡翻譯結果：

遍歷操作

---

警告：此API處于測試階段，未來可能會有變更。
不支持前向模式自動微分。

_foreach_abs	對輸入列表中的每個張量應用 torch.abs()。
_foreach_abs_	對輸入列表中的每個張量應用 torch.abs()。
[_foreach_acos](https://docs.pytorch.org/docs/stable/generated/torch._foreach極簡翻譯結果：

遍歷操作

---

警告：此API處于測試階段，未來可能會有變更。
不支持前向模式自動微分。

_foreach_abs	對輸入列表中的每個張量應用 torch.abs()。
_foreach_abs_	對輸入列表中的每個張量應用 [torch.abs()](https://docs.pytorch.org/docs/stable/g

---

實用工具

compiled_with_cxx11_abi	返回PyTorch是否使用_GLIBCXX_USE_CXX11_ABI=1編譯
result_type	返回對輸入張量執行算術運算后得到的torch.dtype類型
can_cast	根據類型提升文檔描述的PyTorch類型轉換規則，判斷是否允許類型轉換
promote_types	返回不小于type1或type2的最小尺寸和標量類型的torch.dtype
use_deterministic_algorithms	設置PyTorch操作是否必須使用"確定性"算法
are_deterministic_algorithms_enabled	如果全局確定性標志已開啟則返回True
is_deterministic_algorithms_warn_only_enabled	如果全局確定性標志設置為僅警告則返回True
set_deterministic_debug_mode	設置確定性操作的調試模式
get_deterministic_debug_mode	返回當前確定性操作的調試模式值
set_float32_matmul_precision	設置float32矩陣乘法的內部精度
get_float32_matmul_precision	返回當前float32矩陣乘法精度值
set_warn_always	當此標志為False(默認)時，某些PyTorch警告可能每個進程只出現一次
get_device_module	返回與給定設備關聯的模塊(如torch.device(‘cuda’), “mtia:0”, "xpu"等)
is_warn_always_enabled	如果全局warn_always標志已開啟則返回True
vmap	vmap是向量化映射；vmap(func)返回一個新函數，該函數在輸入的某些維度上映射func
_assert	Python assert的可符號追蹤包裝器

---

符號數字

---

class torch.SymInt(node)[source]

---

類似于整型（包括魔術方法），但會重定向所有對封裝節點的操作。這尤其用于在符號化形狀工作流中記錄符號化操作。

---

as_integer_ratio() 

---

將該整數表示為精確的整數比例

返回類型 tuple[SymInt', int]

---

class torch.SymFloat(node)

---

像一個浮點數（包括魔術方法），但會重定向所有對包裝節點的操作。這尤其用于在符號化形狀工作流中象征性地記錄操作。

---

as_integer_ratio()

---

將這個浮點數表示為精確的整數比例

返回類型：tuple[int, int]

---

conjugate()

---

返回該浮點數的復共軛值。

返回類型：SymFloat

---

hex()

---

返回浮點數的十六進制表示形式。

返回類型 str

---

is_integer()

---

如果浮點數是整數，則返回 True。

---

class torch.SymBool(node)

---

類似于布爾類型（包括魔術方法），但會重定向所有對包裝節點的操作。這尤其用于在符號化形狀工作流中符號化記錄操作。

與常規布爾類型不同，常規布爾運算符會強制生成額外的保護條件，而不是進行符號化求值。應改用位運算符來處理這種情況。

sym_float	支持SymInt的浮點數轉換工具
sym_fresh_size
sym_int	支持SymInt的整數轉換工具
sym_max	支持SymInt的最大值工具，避免在a < b時進行分支判斷
sym_min	支持SymInt的最小值工具
sym_not	支持SymInt的邏輯取反工具
sym_ite
sym_sum	多元加法工具，對于長列表的計算速度比迭代二元加法更快

---

導出路徑

警告：此功能為原型階段，未來可能包含不兼容的變更。

export generated/exportdb/index

---

控制流

警告：此功能為原型階段，未來可能存在破壞性變更。

cond	根據條件選擇執行 true_fn 或 false_fn

---

優化方法

compile	使用TorchDynamo和指定后端優化給定模型/函數

torch.compile文檔

---

操作符標簽

---

class torch.Tag 

---

成員：

core

data_dependent_output

dynamic_output_shape

flexible_layout

generated

inplace_view

maybe_aliasing_or_mutating

needs_fixed_stride_order

nondeterministic_bitwise

nondeterministic_seeded

pointwise

pt2_compliant_tag

view_copy

---

torch.nn

以下是構建圖模型的基本組件：

torch.nn

Buffer	一種不應被視為模型參數的張量類型
Parameter	一種需要被視為模塊參數的張量類型
UninitializedParameter	未初始化的參數
UninitializedBuffer	未初始化的緩沖區

---

容器模塊

Module	所有神經網絡模塊的基類
Sequential	順序容器
ModuleList	以列表形式存儲子模塊
ModuleDict	以字典形式存儲子模塊
ParameterList	以列表形式存儲參數
ParameterDict	以字典形式存儲參數

---

模塊全局鉤子

register_module_forward_pre_hook	為所有模塊注冊前向預處理鉤子
register_module_forward_hook	為所有模塊注冊全局前向鉤子
register_module_backward_hook	為所有模塊注冊反向傳播鉤子
register_module_full_backward_pre_hook	為所有模塊注冊反向預處理鉤子
register_module_full_backward_hook	為所有模塊注冊完整反向傳播鉤子
register_module_buffer_registration_hook	為所有模塊注冊緩沖區注冊鉤子
register_module_module_registration_hook	為所有模塊注冊子模塊注冊鉤子
register_module_parameter_registration_hook	為所有模塊注冊參數注冊鉤子

---

卷積層

nn.Conv1d	對由多個輸入平面組成的輸入信號進行一維卷積運算
nn.Conv2d	對由多個輸入平面組成的輸入信號進行二維卷積運算
nn.Conv3d	對由多個輸入平面組成的輸入信號進行三維卷積運算
nn.ConvTranspose1d	對由多個輸入平面組成的輸入圖像進行一維轉置卷積運算
nn.ConvTranspose2d	對由多個輸入平面組成的輸入圖像進行二維轉置卷積運算
nn.ConvTranspose3d	對由多個輸入平面組成的輸入圖像進行三維轉置卷積運算
nn.LazyConv1d	具有in_channels參數延遲初始化特性的torch.nn.Conv1d模塊
nn.LazyConv2d	具有in_channels參數延遲初始化特性的torch.nn.Conv2d模塊
nn.LazyConv3d	具有in_channels參數延遲初始化特性的torch.nn.Conv3d模塊
nn.LazyConvTranspose1d	具有in_channels參數延遲初始化特性的torch.nn.ConvTranspose1d模塊
nn.LazyConvTranspose2d	具有in_channels參數延遲初始化特性的torch.nn.ConvTranspose2d模塊
nn.LazyConvTranspose3d	具有in_channels參數延遲初始化特性的torch.nn.ConvTranspose3d模塊
nn.Unfold	從批處理輸入張量中提取滑動局部塊
nn.Fold	將滑動局部塊數組合并為一個包含張量

---

池化層

nn.MaxPool1d	對由多個輸入平面組成的輸入信號應用一維最大池化。
nn.MaxPool2d	對由多個輸入平面組成的輸入信號應用二維最大池化。
nn.MaxPool3d	對由多個輸入平面組成的輸入信號應用三維最大池化。
nn.MaxUnpool1d	計算 MaxPool1d 的部分逆運算。
nn.MaxUnpool2d	計算 MaxPool2d 的部分逆運算。
nn.MaxUnpool3d	計算 MaxPool3d 的部分逆運算。
nn.AvgPool1d	對由多個輸入平面組成的輸入信號應用一維平均池化。
nn.AvgPool2d	對由多個輸入平面組成的輸入信號應用二維平均池化。
nn.AvgPool3d	對由多個輸入平面組成的輸入信號應用三維平均池化。
nn.FractionalMaxPool2d	對由多個輸入平面組成的輸入信號應用二維分數最大池化。
nn.FractionalMaxPool3d	對由多個輸入平面組成的輸入信號應用三維分數最大池化。
nn.LPPool1d	對由多個輸入平面組成的輸入信號應用一維冪平均池化。
nn.LPPool2d	對由多個輸入平面組成的輸入信號應用二維冪平均池化。
nn.LPPool3d	對由多個輸入平面組成的輸入信號應用三維冪平均池化。
nn.AdaptiveMaxPool1d	對由多個輸入平面組成的輸入信號應用一維自適應最大池化。
nn.AdaptiveMaxPool2d	對由多個輸入平面組成的輸入信號應用二維自適應最大池化。
nn.AdaptiveMaxPool3d	對由多個輸入平面組成的輸入信號應用三維自適應最大池化。
nn.AdaptiveAvgPool1d	對由多個輸入平面組成的輸入信號應用一維自適應平均池化。
nn.AdaptiveAvgPool2d	對由多個輸入平面組成的輸入信號應用二維自適應平均池化。
nn.AdaptiveAvgPool3d	對由多個輸入平面組成的輸入信號應用三維自適應平均池化。

---

填充層

nn.ReflectionPad1d	使用輸入邊界的反射來填充輸入張量
nn.ReflectionPad2d	使用輸入邊界的反射來填充輸入張量
nn.ReflectionPad3d	使用輸入邊界的反射來填充輸入張量
nn.ReplicationPad1d	使用輸入邊界的復制來填充輸入張量
nn.ReplicationPad2d	使用輸入邊界的復制來填充輸入張量
nn.ReplicationPad3d	使用輸入邊界的復制來填充輸入張量
nn.ZeroPad1d	用零值填充輸入張量邊界
nn.ZeroPad2d	用零值填充輸入張量邊界
nn.ZeroPad3d	用零值填充輸入張量邊界
nn.ConstantPad1d	用常數值填充輸入張量邊界
nn.ConstantPad2d	用常數值填充輸入張量邊界
nn.ConstantPad3d	用常數值填充輸入張量邊界
nn.CircularPad1d	使用輸入邊界的循環填充來填充輸入張量
nn.CircularPad2d	使用輸入邊界的循環填充來填充輸入張量
nn.CircularPad3d	使用輸入邊界的循環填充來填充輸入張量

---

非線性激活函數（加權求和與非線性變換）

nn.ELU	逐元素應用指數線性單元（ELU）函數
nn.Hardshrink	逐元素應用硬收縮（Hardshrink）函數
nn.Hardsigmoid	逐元素應用硬Sigmoid函數
nn.Hardtanh	逐元素應用HardTanh函數
nn.Hardswish	逐元素應用Hardswish函數
nn.LeakyReLU	逐元素應用LeakyReLU函數
nn.LogSigmoid	逐元素應用Logsigmoid函數
nn.MultiheadAttention	使模型能夠共同關注來自不同表示子空間的信息
nn.PReLU	逐元素應用PReLU函數
nn.ReLU	逐元素應用修正線性單元函數
nn.ReLU6	逐元素應用ReLU6函數
nn.RReLU	逐元素應用隨機泄漏修正線性單元函數
nn.SELU	逐元素應用SELU函數
nn.CELU	逐元素應用CELU函數
nn.GELU	應用高斯誤差線性單元函數
nn.Sigmoid	逐元素應用Sigmoid函數
nn.SiLU	逐元素應用Sigmoid線性單元（SiLU）函數
nn.Mish	逐元素應用Mish函數
nn.Softplus	逐元素應用Softplus函數
nn.Softshrink	逐元素應用軟收縮函數
nn.Softsign	逐元素應用Softsign函數
nn.Tanh	逐元素應用雙曲正切（Tanh）函數
nn.Tanhshrink	逐元素應用Tanhshrink函數
nn.Threshold	對輸入張量的每個元素進行閾值處理
nn.GLU	應用門控線性單元函數

---

非線性激活函數（其他）

nn.Softmin	對n維輸入張量應用Softmin函數
nn.Softmax	對n維輸入張量應用Softmax函數
nn.Softmax2d	在每個空間位置上對特征應用SoftMax
nn.LogSoftmax	對n維輸入張量應用log?(Softmax(x))\log(\text{Softmax}(x))log(Softmax(x))函數
nn.AdaptiveLogSoftmaxWithLoss	高效的softmax近似方法

---

歸一化層

nn.BatchNorm1d	對2D或3D輸入應用批量歸一化
nn.BatchNorm2d	對4D輸入應用批量歸一化
nn.BatchNorm3d	對5D輸入應用批量歸一化
nn.LazyBatchNorm1d	具有延遲初始化功能的torch.nn.BatchNorm1d模塊
nn.LazyBatchNorm2d	具有延遲初始化功能的torch.nn.BatchNorm2d模塊
nn.LazyBatchNorm3d	具有延遲初始化功能的torch.nn.BatchNorm3d模塊
nn.GroupNorm	對小批量輸入應用組歸一化
nn.SyncBatchNorm	對N維輸入應用批量歸一化
nn.InstanceNorm1d	應用實例歸一化
nn.InstanceNorm2d	應用實例歸一化
nn.InstanceNorm3d	應用實例歸一化
nn.LazyInstanceNorm1d	具有num_features參數延遲初始化功能的torch.nn.InstanceNorm1d模塊
nn.LazyInstanceNorm2d	具有num_features參數延遲初始化功能的torch.nn.InstanceNorm2d模塊
nn.LazyInstanceNorm3d	具有num_features參數延遲初始化功能的torch.nn.InstanceNorm3d模塊
nn.LayerNorm	對小批量輸入應用層歸一化
nn.LocalResponseNorm	對輸入信號應用局部響應歸一化
nn.RMSNorm	對小批量輸入應用均方根層歸一化

---

循環神經網絡層

nn.RNNBase	RNN模塊的基類（包括RNN、LSTM、GRU）
nn.RNN	對輸入序列應用多層Elman RNN，使用tanh或ReLU非線性激活函數
nn.LSTM	對輸入序列應用多層長短期記憶(LSTM)循環神經網絡
nn.GRU	對輸入序列應用多層門控循環單元(GRU)網絡
nn.RNNCell	具有tanh或ReLU非線性激活的Elman RNN單元
nn.LSTMCell	長短期記憶(LSTM)單元
nn.GRUCell	門控循環單元(GRU)

---

Transformer 層

nn.Transformer	Transformer 模型
nn.TransformerEncoder	TransformerEncoder 由 N 個編碼器層堆疊而成
nn.TransformerDecoder	TransformerDecoder 由 N 個解碼器層堆疊而成
nn.TransformerEncoderLayer	TransformerEncoderLayer 由自注意力機制和前饋網絡組成
nn.TransformerDecoderLayer	TransformerDecoderLayer 由自注意力機制、多頭注意力機制和前饋網絡組成

---

線性層

nn.Identity	一個參數無關的占位恒等運算符
nn.Linear	對輸入數據進行仿射線性變換：y=xAT+by = xA^T + by=xAT+b
nn.Bilinear	對輸入數據進行雙線性變換：y=x1TAx2+by = x_1^T A x_2 + by=x1T?Ax2?+b
nn.LazyLinear	一個自動推斷輸入特征數(in_features)的torch.nn.Linear模塊

---

Dropout 層

nn.Dropout	在訓練過程中，以概率 p 隨機將輸入張量的部分元素置零。
nn.Dropout1d	隨機將整個通道置零。
nn.Dropout2d	隨機將整個通道置零。
nn.Dropout3d	隨機將整個通道置零。
nn.AlphaDropout	對輸入應用 Alpha Dropout。
nn.FeatureAlphaDropout	隨機屏蔽整個通道。

---

稀疏層

nn.Embedding	一個簡單的查找表，用于存儲固定字典和大小的嵌入向量。
nn.EmbeddingBag	計算嵌入向量"包"的和或均值，而無需實例化中間嵌入向量。

---

距離函數

nn.CosineSimilarity	返回x1和x2沿指定維度的余弦相似度
nn.PairwiseDistance	計算輸入向量之間的成對距離，或輸入矩陣列之間的成對距離

---

損失函數

nn.L1Loss	創建一個衡量輸入x和目標y之間平均絕對誤差(MAE)的損失函數。
nn.MSELoss	創建一個衡量輸入x和目標y之間均方誤差(平方L2范數)的損失函數。
nn.CrossEntropyLoss	計算輸入logits和目標之間的交叉熵損失。
nn.CTCLoss	連接時序分類損失(Connectionist Temporal Classification loss)。
nn.NLLLoss	負對數似然損失。
nn.PoissonNLLLoss	目標服從泊松分布的負對數似然損失。
nn.GaussianNLLLoss	高斯負對數似然損失。
nn.KLDivLoss	KL散度損失(Kullback-Leibler divergence loss)。
nn.BCELoss	創建一個衡量目標與輸入概率之間二元交叉熵的損失函數。
nn.BCEWithLogitsLoss	將Sigmoid層和BCELoss結合在一個類中的損失函數。
nn.MarginRankingLoss	創建一個衡量給定輸入x1、x2(兩個1D mini-batch或0D張量)和標簽y(包含1或-1的1D mini-batch或0D張量)的損失函數。
nn.HingeEmbeddingLoss	衡量給定輸入張量x和標簽張量y(包含1或-1)的損失。
nn.MultiLabelMarginLoss	創建一個優化輸入x(2D mini-batch張量)和輸出y(目標類別索引的2D張量)之間多類多分類鉸鏈損失(基于邊距的損失)的損失函數。
nn.HuberLoss	創建一個在元素級絕對誤差低于delta時使用平方項，否則使用delta縮放L1項的損失函數。
nn.SmoothL1Loss	創建一個在元素級絕對誤差低于beta時使用平方項，否則使用L1項的損失函數。
nn.SoftMarginLoss	創建一個優化輸入張量x和目標張量y(包含1或-1)之間二分類邏輯損失的損失函數。
nn.MultiLabelSoftMarginLoss	創建一個基于最大熵優化輸入x和大小(N,C)的目標y之間多標簽一對多損失的損失函數。
nn.CosineEmbeddingLoss	創建一個衡量給定輸入張量x1、x2和值為1或-1的標簽張量y的損失函數。
nn.MultiMarginLoss	創建一個優化輸入x(2D mini-batch張量)和輸出y(目標類別索引的1D張量，0≤y≤x.size(1)?1)之間多類分類鉸鏈損失(基于邊距的損失)的損失函數。
nn.TripletMarginLoss	創建一個衡量給定輸入張量x1、x2、x3和大于0的邊距值的三元組損失的損失函數。
nn.TripletMarginWithDistanceLoss	創建一個衡量給定輸入張量a、p、n(分別表示錨點、正例和負例)以及用于計算錨點與正例(“正距離”)和錨點與負例(“負距離”)之間關系的非負實值函數(“距離函數”)的三元組損失的損失函數。

---

視覺層

nn.PixelShuffle	根據上采樣因子重新排列張量中的元素
nn.PixelUnshuffle	反轉PixelShuffle操作
nn.Upsample	對給定的多通道1D（時序）、2D（空間）或3D（體積）數據進行上采樣
nn.UpsamplingNearest2d	對由多個輸入通道組成的輸入信號應用2D最近鄰上采樣
nn.UpsamplingBilinear2d	對由多個輸入通道組成的輸入信號應用2D雙線性上采樣

---

通道混洗層

nn.ChannelShuffle	對張量中的通道進行分組并重新排列

---

數據并行層（多GPU，分布式）

nn.DataParallel	在模塊級別實現數據并行。
nn.parallel.DistributedDataParallel	基于torch.distributed在模塊級別實現分布式數據并行。

---

實用工具

來自 torch.nn.utils 模塊的實用函數：

參數梯度裁剪工具

clip_grad_norm_	對一組可迭代參數的梯度范數進行裁剪
clip_grad_norm	對一組可迭代參數的梯度范數進行裁剪
clip_grad_value_	按指定值裁剪一組可迭代參數的梯度
get_total_norm	計算一組張量的范數
clip_grads_with_norm_	根據預計算的總范數和期望的最大范數縮放一組參數的梯度

---

模塊參數扁平化與反扁平化工具

parameters_to_vector	將一組參數展平為單個向量
vector_to_parameters	將向量切片復制到一組參數中

---

模塊與批歸一化融合工具

fuse_conv_bn_eval	將卷積模塊和批歸一化模塊融合為新的卷積模塊
fuse_conv_bn_weights	將卷積模塊參數和批歸一化模塊參數融合為新的卷積模塊參數
fuse_linear_bn_eval	將線性模塊和批歸一化模塊融合為新的線性模塊
fuse_linear_bn_weights	將線性模塊參數和批歸一化模塊參數融合為新的線性模塊參數

---

模塊參數內存格式轉換工具

convert_conv2d_weight_memory_format	轉換 nn.Conv2d.weight 的 memory_format
convert_conv3d_weight_memory_format	轉換 nn.Conv3d.weight 的 memory_format，該轉換會遞歸應用到嵌套的 nn.Module 包括 module

---

權重歸一化應用與移除工具

weight_norm	對給定模塊中的參數應用權重歸一化
remove_weight_norm	從模塊中移除權重歸一化重參數化
spectral_norm	對給定模塊中的參數應用譜歸一化
remove_spectral_norm	從模塊中移除譜歸一化重參數化

---

模塊參數初始化工具

| skip_init | 給定模塊類對象和參數，實例化模塊但不初始化參數/緩沖區 |

---

模塊參數剪枝工具類與函數

prune.BasePruningMethod	創建新剪枝技術的抽象基類
prune.PruningContainer	包含一系列剪枝方法的容器，用于迭代剪枝
prune.Identity	不剪枝任何單元但生成帶有全1掩碼的剪枝參數化的實用方法
prune.RandomUnstructured	隨機剪枝張量中當前未剪枝的單元
prune.L1Unstructured	通過置零L1范數最小的單元來剪枝張量
prune.RandomStructured	隨機剪枝張量中當前未剪枝的整個通道
prune.LnStructured	基于Ln范數剪枝張量中當前未剪枝的整個通道
prune.CustomFromMask
prune.identity	應用剪枝重參數化但不剪枝任何單元
prune.random_unstructured	通過移除隨機未剪枝單元來剪枝張量
prune.l1_unstructured	通過移除L1范數最小的單元來剪枝張量
prune.random_structured	通過沿指定維度移除隨機通道來剪枝張量
prune.ln_structured	通過沿指定維度移除Ln范數最小的通道來剪枝張量
prune.global_unstructured	通過應用指定的pruning_method全局剪枝parameters中所有參數對應的張量
prune.custom_from_mask	通過應用預計算掩碼mask來剪枝module中名為name的參數對應的張量
prune.remove	從模塊中移除剪枝重參數化并從前向鉤子中移除剪枝方法
prune.is_pruned	通過查找剪枝前鉤子檢查模塊是否被剪枝

---

使用torch.nn.utils.parameterize.register_parametrization()新參數化功能實現的參數化

parametrizations.orthogonal	對矩陣或矩陣批次應用正交或酉參數化
parametrizations.weight_norm	對給定模塊中的參數應用權重歸一化
parametrizations.spectral_norm	對給定模塊中的參數應用譜歸一化

---

為現有模塊上的張量參數化的實用函數

注意：這些函數可用于通過特定函數將給定參數或緩沖區從輸入空間映射到參數化空間。它們不是將對象轉換為參數的參數化。有關如何實現自定義參數化的更多信息，請參閱參數化教程。

parametrize.register_parametrization	為模塊中的張量注冊參數化
parametrize.remove_parametrizations	移除模塊中張量的參數化
parametrize.cached	啟用通過register_parametrization()注冊的參數化內部緩存系統的上下文管理器
parametrize.is_parametrized	判斷模塊是否具有參數化
parametrize.ParametrizationList	順序容器，用于保存和管理參數化torch.nn.Module的原始參數或緩沖區

---

以無狀態方式調用給定模塊的實用函數

| stateless.functional_call | 通過用提供的參數和緩沖區替換模塊參數和緩沖區來執行功能調用 |

---

其他模塊中的實用函數

nn.utils.rnn.PackedSequence	保存打包序列的數據和batch_sizes列表
nn.utils.rnn.pack_padded_sequence	打包包含可變長度填充序列的張量
nn.utils.rnn.pad_packed_sequence	對打包的可變長度序列批次進行填充
nn.utils.rnn.pad_sequence	用padding_value填充可變長度張量列表
nn.utils.rnn.pack_sequence	打包可變長度張量列表
nn.utils.rnn.unpack_sequence	將PackedSequence解包為可變長度張量列表
nn.utils.rnn.unpad_sequence	將填充張量解包為可變長度張量列表
nn.Flatten	將連續范圍的維度展平為張量
—	—
nn.Unflatten	將張量維度展開為期望形狀

---

量化函數

量化是指以低于浮點精度的位寬執行計算和存儲張量的技術。PyTorch 同時支持逐張量和逐通道的非對稱線性量化。要了解更多關于如何在 PyTorch 中使用量化函數的信息，請參閱量化文檔。

---

惰性模塊初始化

nn.modules.lazy.LazyModuleMixin	用于實現參數惰性初始化的模塊混合類（也稱為"惰性模塊"）

---

別名

以下是 torch.nn 中對應模塊的別名：

nn.modules.normalization.RMSNorm	對輸入的小批量數據應用均方根層歸一化。

---

torch.nn.functional

---

卷積函數

conv1d	對由多個輸入平面組成的輸入信號應用一維卷積運算
conv2d	對由多個輸入平面組成的輸入圖像應用二維卷積運算
conv3d	對由多個輸入平面組成的輸入圖像應用三維卷積運算
conv_transpose1d	對由多個輸入平面組成的輸入信號應用一維轉置卷積算子（有時也稱為"反卷積"）
conv_transpose2d	對由多個輸入平面組成的輸入圖像應用二維轉置卷積算子（有時也稱為"反卷積"）
conv_transpose3d	對由多個輸入平面組成的輸入圖像應用三維轉置卷積算子（有時也稱為"反卷積"）
unfold	從批處理輸入張量中提取滑動局部塊
fold	將滑動局部塊數組合并為一個包含張量

---

池化函數

avg_pool1d	對由多個輸入平面組成的輸入信號應用一維平均池化。
avg_pool2d	在kH×kW區域以步長sH×sW進行二維平均池化操作。
avg_pool3d	在kT×kH×kW區域以步長sT×sH×sW進行三維平均池化操作。
max_pool1d	對由多個輸入平面組成的輸入信號應用一維最大池化。
max_pool2d	對由多個輸入平面組成的輸入信號應用二維最大池化。
max_pool3d	對由多個輸入平面組成的輸入信號應用三維最大池化。
max_unpool1d	計算MaxPool1d的部分逆運算。
max_unpool2d	計算MaxPool2d的部分逆運算。
max_unpool3d	計算MaxPool3d的部分逆運算。
lp_pool1d	對由多個輸入平面組成的輸入信號應用一維冪平均池化。
lp_pool2d	對由多個輸入平面組成的輸入信號應用二維冪平均池化。
lp_pool3d	對由多個輸入平面組成的輸入信號應用三維冪平均池化。
adaptive_max_pool1d	對由多個輸入平面組成的輸入信號應用一維自適應最大池化。
adaptive_max_pool2d	對由多個輸入平面組成的輸入信號應用二維自適應最大池化。
adaptive_max_pool3d	對由多個輸入平面組成的輸入信號應用三維自適應最大池化。
adaptive_avg_pool1d	對由多個輸入平面組成的輸入信號應用一維自適應平均池化。
adaptive_avg_pool2d	對由多個輸入平面組成的輸入信號應用二維自適應平均池化。
adaptive_avg_pool3d	對由多個輸入平面組成的輸入信號應用三維自適應平均池化。
fractional_max_pool2d	對由多個輸入平面組成的輸入信號應用二維分數最大池化。
fractional_max_pool3d	對由多個輸入平面組成的輸入信號應用三維分數最大池化。

---

注意力機制

torch.nn.attention.bias 模塊包含專為 scaled_dot_product_attention 設計的注意力偏置項。

scaled_dot_product_attention	scaled_dot_product_attention(query, key, value, attn_mask=None, dropout_p=0.0,

---

非線性激活函數

threshold	對輸入張量的每個元素應用閾值處理
threshold_	threshold() 的原位操作版本
relu	逐元素應用修正線性單元函數
relu_	relu() 的原位操作版本
hardtanh	逐元素應用 HardTanh 函數
hardtanh_	hardtanh() 的原位操作版本
hardswish	逐元素應用 hardswish 函數
relu6	逐元素應用 ReLU6(x)=min?(max?(0,x),6)\text{ReLU6}(x) = \min(\max(0,x), 6)ReLU6(x)=min(max(0,x),6) 函數
elu	逐元素應用指數線性單元(ELU)函數
elu_	elu() 的原位操作版本
selu	逐元素應用 SELU(x)=scale?(max?(0,x)+min?(0,α?(exp?(x)?1)))\text{SELU}(x) = scale * (\max(0,x) + \min(0, \alpha * (\exp(x) - 1)))SELU(x)=scale?(max(0,x)+min(0,α?(exp(x)?1))) 函數，其中 α=1.6732632423543772848170429916717\alpha=1.6732632423543772848170429916717α=1.6732632423543772848170429916717，scale=1.0507009873554804934193349852946scale=1.0507009873554804934193349852946scale=1.0507009873554804934193349852946
celu	逐元素應用 CELU(x)=max?(0,x)+min?(0,α?(exp?(x/α)?1))\text{CELU}(x) = \max(0,x) + \min(0, \alpha * (\exp(x/\alpha) - 1))CELU(x)=max(0,x)+min(0,α?(exp(x/α)?1)) 函數
leaky_relu	逐元素應用 LeakyReLU(x)=max?(0,x)+negative_slope?min?(0,x)\text{LeakyReLU}(x) = \max(0, x) + \text{negative_slope} * \min(0, x)LeakyReLU(x)=max(0,x)+negative_slope?min(0,x) 函數
leaky_relu_	leaky_relu() 的原位操作版本
prelu	逐元素應用 PReLU(x)=max?(0,x)+weight?min?(0,x)\text{PReLU}(x) = \max(0,x) + \text{weight} * \min(0,x)PReLU(x)=max(0,x)+weight?min(0,x) 函數，其中 weight 是可學習參數
rrelu	隨機泄漏 ReLU
rrelu_	rrelu() 的原位操作版本
glu	門控線性單元
gelu	當 approximate 參數為 ‘none’ 時，逐元素應用 GELU(x)=x?Φ(x)\text{GELU}(x) = x * \Phi(x)GELU(x)=x?Φ(x) 函數
logsigmoid	逐元素應用 LogSigmoid(xi)=log?(11+exp?(?xi))\text{LogSigmoid}(x_i) = \log \left(\frac{1}{1 + \exp(-x_i)}\right)LogSigmoid(xi?)=log(1+exp(?xi?)1?) 函數
hardshrink	逐元素應用硬收縮函數
tanhshrink	逐元素應用 Tanhshrink(x)=x?Tanh(x)\text{Tanhshrink}(x) = x - \text{Tanh}(x)Tanhshrink(x)=x?Tanh(x) 函數
softsign	逐元素應用 SoftSign(x)=x1+∣x∣\text{SoftSign}(x) = \frac{x}{1 +
softplus	逐元素應用 Softplus(x)=1β?log?(1+exp?(β?x))\text{Softplus}(x) = \frac{1}{\beta} * \log(1 + \exp(\beta * x))Softplus(x)=β1??log(1+exp(β?x)) 函數
softmin	應用 softmin 函數
softmax	應用 softmax 函數
softshrink	逐元素應用軟收縮函數
gumbel_softmax	從 Gumbel-Softmax 分布(鏈接1 鏈接2)采樣并可選離散化
log_softmax	應用 softmax 后接對數運算
tanh	逐元素應用 Tanh(x)=tanh?(x)=exp?(x)?exp?(?x)exp?(x)+exp?(?x)\text{Tanh}(極x) = \tanh(x) = \frac{\exp(x) - \exp(-x)}{\exp(x) + \exp(-x)}Tanh(x)=tanh(x)=exp(x)+exp(?x)exp(x)?exp(?x)? 函數
sigmoid	逐元素應用 Sigmoid(x)=11+exp?(?x)\text{Sigmoid}(x) = \frac{1}{1 + \exp(-x)}Sigmoid(x)=1+exp(?x)1? 函數
hardsigmoid	逐元素應用 Hardsigmoid 函數
silu	逐元素應用 Sigmoid 線性單元(SiLU)函數
mish	逐元素應用 Mish 函數
batch_norm	對批量數據中的每個通道應用批量歸一化
group_norm	對最后若干維度應用組歸一化
instance_norm	對批量中每個數據樣本的每個通道獨立應用實例歸一化
layer_norm	對最后若干維度應用層歸一化
local_response_norm	對輸入信號應用局部響應歸一化
rms_norm	應用均方根層歸一化
normalize	對指定維度執行 LpL_pLp? 歸一化

---

線性函數

linear	對輸入數據應用線性變換：y=xAT+by = xA^T + by=xAT+b
bilinear	對輸入數據應用雙線性變換：y=x1TAx2+by = x_1^T A x_2 + by=x1T?Ax2?+b

---

Dropout 函數

dropout	在訓練過程中，以概率 p 隨機將輸入張量的部分元素置零。
alpha_dropout	對輸入應用 alpha dropout。
feature_alpha_dropout	隨機屏蔽整個通道（通道即特征圖）。
dropout1d	隨機將整個通道置零（通道為 1D 特征圖）。
dropout2d	隨機將整個通道置零（通道為 2D 特征圖）。
dropout3d	隨機將整個通道置零（通道為 3D 特征圖）。

---

稀疏函數

embedding	生成一個簡單的查找表，用于在固定字典和尺寸中查找嵌入向量。
embedding_bag	計算嵌入向量包的和、平均值或最大值。
one_hot	接收形狀為()的LongTensor索引值，返回形狀為(, num_classes)的張量，該張量除最后一維索引與輸入張量對應值匹配的位置為1外，其余位置均為0。

---

距離函數

pairwise_distance	詳情參見 torch.nn.PairwiseDistance
cosine_similarity	返回 x1 和 x2 沿指定維度的余弦相似度
pdist	計算輸入中每對行向量之間的 p-范數距離

---

損失函數

binary_cross_entropy	計算目標值與輸入概率之間的二元交叉熵
binary_cross_entropy_with_logits	計算目標值與輸入logits之間的二元交叉熵
poisson_nll_loss	泊松負對數似然損失
cosine_embedding_loss	詳見CosineEmbeddingLoss
cross_entropy	計算輸入logits與目標值之間的交叉熵損失
ctc_loss	應用連接時序分類損失
gaussian_nll_loss	高斯負對數似然損失
hinge_embedding_loss	詳見HingeEmbeddingLoss
[kl_div](https://docs.pytorch.org/docs/stable/generated/t torch.nn.functional.kl_div.html#torch.nn.functional.kl_div “torch.nn.functional.kl_div”)	計算KL散度損失
l1_loss	計算元素級絕對差值的均值
mse_loss	計算元素級均方誤差（支持加權）
margin_ranking_loss	詳見MarginRankingLoss
multilabel_margin_loss	詳見MultiLabelMarginLoss
multilabel_soft_margin_loss	詳見MultiLabelSoftMarginLoss
multi_margin_loss	詳見MultiMarginLoss
nll_loss	計算負對數似然損失
huber_loss	計算Huber損失（支持加權）
smooth_l1_loss	計算平滑L1損失
soft_margin_loss	詳見SoftMarginLoss
triplet_margin_loss	計算輸入張量與大于0的邊界值之間的三元組損失
triplet_margin_with_distance_loss	使用自定義距離函數計算輸入張量的三元組邊界損失

---

視覺函數

pixel_shuffle	將形狀為$(?,C\times r^2,H,W)$的張量元素重新排列為形狀$(?,C,H\times r,W\times r)$的張量，其中r為upscale_factor。
pixel_unshuffle	通過將形狀為$(?,C,H\times r,W\times r)$的張量元素重新排列為形狀$(?,C\times r^2,H,W)$的張量，來逆轉PixelShuffle操作，其中r為downscale_factor。
pad	對張量進行填充。
interpolate	對輸入進行下采樣/上采樣。
upsample	對輸入進行上采樣。
upsample_nearest	使用最近鄰像素值對輸入進行上采樣。
upsample_bilinear	使用雙線性上采樣對輸入進行上采樣。
grid_sample	計算網格采樣。
affine_grid	給定一批仿射矩陣theta，生成2D或3D流場（采樣網格）。

---

DataParallel 功能（多GPU，分布式）

---

data_parallel

torch.nn.parallel.data_parallel	在指定設備ID列表(device_ids)中的多個GPU上并行評估模塊(input)。

---

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）的別名。

---

初始化與基礎操作

可以通過 Python 的 list 或序列使用 torch.tensor() 構造函數來構建張量：

>>> 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，用于存儲其數據。

張量類還提供了存儲的多維跨步視圖，并定義了基于它的數值運算。

注意：有關張量視圖的更多信息，請參閱張量視圖。

注意：關于 torch.Tensor 的 torch.dtype、torch.device 和 torch.layout 屬性的更多信息，請參閱張量屬性。

注意：會改變張量的方法以下劃線后綴標記。例如，torch.FloatTensor.abs_() 會就地計算絕對值并返回修改后的張量，而 torch.FloatTensor.abs() 則會在新張量中計算結果。

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

警告：當前 torch.Tensor 的實現引入了內存開銷，因此在處理大量小張量的應用中可能導致意外的高內存使用。如果遇到這種情況，建議使用單個大型結構。

---

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() 不同，此操作會跟蹤自動微分并將梯度傳播到原始 Tensor。對于這種 data 類型不支持 device 關鍵字參數。
• 如果 data 是序列或嵌套序列，則創建一個默認數據類型（通常是 torch.float32）的張量，其數據為序列中的值，必要時執行類型轉換。值得注意的是，此構造函數與 torch.tensor() 的區別在于，即使輸入全是整數，此構造函數也會始終構造浮點張量。
• 如果 data 是 torch.Size，則返回一個該大小的空張量。

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

參數：

data (array_like): 用于構造張量的數據。

關鍵字參數：

device (torch.device, 可選): 返回張量的目標設備。默認值：如果為 None，則與此張量相同的 torch.device。

Tensor.T

返回此張量的維度反轉視圖。

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

警告： 在非二維張量上使用 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。
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 是元張量則為 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.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()](https://docs.pytorch.org/docs/stable/generated

---

張量屬性

每個 torch.Tensor 都擁有 torch.dtype、torch.device 和 torch.layout 屬性。

---

torch.dtype

---

class torch.dtype 

---

torch.dtype 是一個表示 torch.Tensor 數據類型的對象。PyTorch 提供了十二種不同的數據類型：

數據類型	dtype	舊版構造函數
32位浮點數	torch.float32 或 torch.float	torch.*.FloatTensor
64位浮點數	torch.float64 或 torch.double	torch.*.DoubleTensor
64位復數	torch.complex64 或 torch.cfloat
128位復數	torch.complex128 或 torch.cdouble
16位浮點數 [1]	torch.float16 或 torch.half	torch.*.HalfTensor
16位浮點數 [2]	torch.bfloat16	torch.*.BFloat16Tensor
8位無符號整數	torch.uint8	torch.*.ByteTensor
8位有符號整數	torch.int8	torch.*.CharTensor
16位有符號整數	torch.int16 或 torch.short	torch.*.ShortTensor
32位有符號整數	torch.int32 或 torch.int	torch.*.IntTensor
64位有符號整數	torch.int64 或 torch.long	torch.*.LongTensor
布爾型	torch.bool	torch.*.BoolTensor

[1] 有時稱為 binary16：使用 1 位符號、5 位指數和 10 位尾數。適用于需要高精度的場景。

[2] 有時稱為 Brain 浮點數：使用 1 位符號、8 位指數和 7 位尾數。由于與 float32 具有相同的指數位數，適用于需要大范圍的場景。

要判斷 torch.dtype 是否為浮點數據類型，可以使用屬性 is_floating_point，如果數據類型是浮點類型，則返回 True。

要判斷 torch.dtype 是否為復數數據類型，可以使用屬性 is_complex，如果數據類型是復數類型，則返回 True。

當算術運算（加、減、除、乘）的輸入數據類型不同時，我們會按照以下規則找到滿足條件的最小數據類型進行提升：

• 如果標量操作數的類型屬于比張量操作數更高的類別（復數 > 浮點 > 整數 > 布爾值），則提升到足以容納該類別所有標量操作數的類型。
• 如果零維張量操作數的類別高于有維度的操作數，則提升到足以容納該類別所有零維張量操作數的類型。
• 如果沒有更高類別的零維操作數，則提升到足以容納所有有維度操作數的類型。

浮點標量操作數的默認數據類型為 torch.get_default_dtype()，而整數非布爾標量操作數的默認數據類型為 torch.int64。與 NumPy 不同，我們在確定操作數的最小數據類型時不會檢查具體值。目前不支持量化和復數類型的提升。

提升示例：

>>> float_tensor = torch.ones(1, dtype=torch.float)
>>> double_tensor = torch.ones(1, dtype=torch.double)
>>> complex_float_tensor = torch.ones(1, dtype=torch.complex64)
>>> complex_double_tensor = torch.ones(1, dtype=torch.complex128)
>>> int_tensor = torch.ones(1, dtype=torch.int)
>>> long_tensor = torch.ones(1, dtype=torch.long)
>>> uint_tensor = torch.ones(1, dtype=torch.uint8)
>>> bool_tensor = torch.ones(1, dtype=torch.bool)
# zero-dim tensors
>>> long_zerodim = torch.tensor(1, dtype=torch.long)
>>> int_zerodim = torch.tensor(1, dtype=torch.int)>>> torch.add(5, 5).dtype
torch.int64
# 5 is an int64, but does not have higher category than int_tensor so is not considered.
>>> (int_tensor + 5).dtype
torch.int32
>>> (int_tensor + long_zerodim).dtype
torch.int32
>>> (long_tensor + int_tensor).dtype
torch.int64
>>> (bool_tensor + long_tensor).dtype
torch.int64
>>> (bool_tensor + uint_tensor).dtype
torch.uint8
>>> (float_tensor + double_tensor).dtype
torch.float64
>>> (complex_float_tensor + complex_double_tensor).dtype
torch.complex128
>>> (bool_tensor + int_tensor).dtype
torch.int32
# Since long is a different kind than float, result dtype only needs to be large enough
# to hold the float.
>>> torch.add(long_tensor, float_tensor).dtype
torch.float32

---

當指定算術運算的輸出張量時，我們允許將其類型轉換為輸出張量的數據類型，但存在以下例外情況：

• 整型輸出張量不能接受浮點型張量
• 布爾型輸出張量不能接受非布爾型張量
• 非復數型輸出張量不能接受復數型張量

類型轉換示例：

# allowed:
>>> float_tensor *= float_tensor
>>> float_tensor *= int_tensor
>>> float_tensor *= uint_tensor
>>> float_tensor *= bool_tensor
>>> float_tensor *= double_tensor
>>> int_tensor *= long_tensor
>>> int_tensor *= uint_tensor
>>> uint_tensor *= int_tensor# disallowed (RuntimeError: result type can't be cast to the desired output type):
>>> int_tensor *= float_tensor
>>> bool_tensor *= int_tensor
>>> bool_tensor *= uint_tensor
>>> float_tensor *= complex_float_tensor

---

torch.device

---

class torch.device 

---

torch.device 是一個表示設備類型的對象，torch.Tensor 會被分配或已經分配在該設備上。

torch.device 包含一個設備類型（最常見的是 “cpu” 或 “cuda”，但也可能是 “mps”、“xpu”、“xla” 或 “meta”）以及可選的設備序號。如果未指定設備序號，該對象將始終代表該設備類型的當前設備，即使在調用 torch.cuda.set_device() 之后也是如此；例如，使用設備 'cuda' 構造的 torch.Tensor 等同于 'cuda:X'，其中 X 是 torch.cuda.current_device() 的結果。

可以通過 Tensor.device 屬性訪問 torch.Tensor 的設備。

torch.device 可以通過字符串或字符串加設備序號來構造：

通過字符串：

>>> torch.device('cuda:0')
device(type='cuda', index=0)>>> torch.device('cpu')
device(type='cpu')>>> torch.device('mps')
device(type='mps')>>> torch.device('cuda')  # current cuda device
device(type='cuda')

---

通過字符串和設備序號：

>>> torch.device('cuda', 0)
device(type='cuda', index=0)>>> torch.device('mps', 0)
device(type='mps', index=0)>>> torch.device('cpu', 0)
device(type='cpu', index=0)

---

設備對象也可用作上下文管理器，用于更改張量分配的默認設備：

>>> with torch.device('cuda:1'):
...     r = torch.randn(2, 3)
>>> r.device
device(type='cuda', index=1)

---

如果向工廠函數傳遞了顯式且非 None 的設備參數，此上下文管理器將不起作用。要全局更改默認設備，請參閱 torch.set_default_device()。

警告：此函數會對每次調用 torch API 的 Python 操作（不僅限于工廠函數）產生輕微性能開銷。如果這給您帶來問題，請在 https://github.com/pytorch/pytorch/issues/92701 發表評論。

注意：函數中的 torch.device 參數通常可以用字符串替代，這有助于快速原型開發代碼。

---

>>> # Example of a function that takes in a torch.device
>>> cuda1 = torch.device('cuda:1')
>>> torch.randn((2,3), device=cuda1)

---

>>> # You can substitute the torch.device with a string
>>> torch.randn((2,3), device='cuda:1')

---

注意：由于歷史遺留原因，可以通過單個設備序號來構造設備，該序號會被視為當前加速器類型。

這與 Tensor.get_device() 的行為一致——該方法會返回設備張量的序號，但不支持CPU張量。

---

>>> torch.device(1)
device(type='cuda', index=1)

---

注意：接收設備參數的方法通常支持（格式正確的）字符串或（舊版）整數設備序號，以下寫法都是等效的：

>>> torch.randn((2,3), device=torch.device('cuda:1'))
>>> torch.randn((2,3), device='cuda:1')
>>> torch.randn((2,3), device=1)  # legacy

---

注意：張量不會自動在設備間移動，需要用戶顯式調用。標量張量（tensor.dim()==0的情況）是此規則唯一的例外——當需要時它們會自動從CPU轉移到GPU，因為該操作可以"零成本"完成。

---

示例：

>>> # two scalars
>>> torch.ones(()) + torch.ones(()).cuda()  # OK, scalar auto-transferred from CPU to GPU
>>> torch.ones(()).cuda() + torch.ones(())  # OK, scalar auto-transferred from CPU to GPU

---

>>> # one scalar (CPU), one vector (GPU)
>>> torch.ones(()) + torch.ones(1).cuda()  # OK, scalar auto-transferred from CPU to GPU
>>> torch.ones(1).cuda() + torch.ones(())  # OK, scalar auto-transferred from CPU to GPU

---

>>> # one scalar (GPU), one vector (CPU)
>>> torch.ones(()).cuda() + torch.ones(1)  # Fail, scalar not auto-transferred from GPU to CPU and non-scalar not auto-transferred from CPU to GPU
>>> torch.ones(1) + torch.ones(()).cuda()  # Fail, scalar not auto-transferred from GPU to CPU and non-scalar not auto-transferred from CPU to GPU

---

torch.layout

---

class torch.layout 

---

警告：torch.layout 類目前處于測試階段，后續可能會發生變化。

torch.layout 是一個表示 torch.Tensor 內存布局的對象。目前我們支持 torch.strided（密集張量），并對 torch.sparse_coo（稀疏 COO 張量）提供測試版支持。

torch.strided 表示密集張量，這是最常用的內存布局方式。每個跨步張量都有一個關聯的 torch.Storage 對象用于存儲數據。這些張量提供了存儲的多維跨步視圖。跨步是一個整數列表：第 k 個跨步表示在張量的第 k 維中，從一個元素移動到下一個元素所需的內存跳躍量。這個概念使得許多張量操作能夠高效執行。

---

示例：

>>> x = torch.tensor([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]])
>>> x.stride()
(5, 1)>>> x.t().stride()
(1, 5)

---

有關 torch.sparse_coo 張量的更多信息，請參閱 torch.sparse。

---

torch.memory_format

---

class torch.memory_format 

---

torch.memory_format 是一個表示內存格式的對象，用于描述 torch.Tensor 當前或將要分配的內存布局。

可能的取值包括：

• torch.contiguous_format：

張量當前或將要分配在密集且無重疊的內存中。其步長（strides）以遞減順序表示。

• torch.channels_last：

張量當前或將要分配在密集且無重疊的內存中。其步長遵循 strides[0] strides[2] strides[3] strides[1] == 1 的順序，即 NHWC 格式。

• torch.channels_last_3d：

張量當前或將要分配在密集且無重疊的內存中。其步長遵循 strides[0] strides[2] strides[3] strides[4] strides[1] == 1 的順序，即 NDHWC 格式。

• torch.preserve_format：

用于 clone 等函數中，以保留輸入張量的內存格式。如果輸入張量分配在密集且無重疊的內存中，輸出張量的步長將從輸入張量復制。否則，輸出張量的步長將遵循 torch.contiguous_format。

---

張量視圖

PyTorch 允許一個張量作為現有張量的視圖(View)。視圖張量與其基礎張量共享相同底層數據。支持視圖可以避免顯式數據拷貝，從而實現快速且內存高效的形狀變換、切片和逐元素操作。

例如，要獲取現有張量t的視圖，可以調用t.view(...)方法。

---

>>> t = torch.rand(4, 4)
>>> b = t.view(2, 8)
>>> t.storage().data_ptr() == b.storage().data_ptr()  # `t` and `b` share the same underlying data.
True
# Modifying view tensor changes base tensor as well.
>>> b[0][0] = 3.14
>>> t[0][0]
tensor(3.14)

---

由于視圖與基礎張量共享底層數據，當修改視圖中的數據時，基礎張量也會同步更新。

PyTorch操作通常返回一個新張量作為輸出，例如add()。但對于視圖操作，輸出會作為輸入張量的視圖以避免不必要的數據拷貝。

創建視圖時不會發生數據移動，視圖張量僅改變了對同一數據的解釋方式。對連續張量取視圖可能會產生非連續張量。

用戶需特別注意，因為連續性可能隱式影響性能。transpose()就是典型示例。

---

>>> base = torch.tensor([[0, 1],[2, 3]])
>>> base.is_contiguous()
True
>>> t = base.transpose(0, 1)  # `t` is a view of `base`. No data movement happened here.
# View tensors might be non-contiguous.
>>> t.is_contiguous()
False
# To get a contiguous tensor, call `.contiguous()` to enforce
# copying data when `t` is not contiguous.
>>> c = t.contiguous()

---

以下是PyTorch中視圖操作(view ops)的完整參考列表：

• 基礎切片和索引操作，例如tensor[0, 2:, 1:7:2]會返回基礎tensor的視圖（注意事項見下文）
• adjoint()
• as_strided()
• detach()
• diagonal()
• expand()
• expand_as()
• movedim()
• narrow()
• permute()
• select()
• squeeze()
• transpose()
• t()
• T
• H
• mT
• mH
• real
• imag
• view_as_real()
• unflatten()
• unfold()
• unsqueeze()
• view()
• view_as()
• unbind()
• split()
• hsplit()
• vsplit()
• tensor_split()
• split_with_sizes()
• swapaxes()
• swapdims()
• chunk()
• indices()（僅稀疏張量）
• values()（僅稀疏張量）

---

注意事項：
當通過索引訪問張量內容時，PyTorch遵循NumPy的行為規范：基礎索引返回視圖，而高級索引返回副本。無論是基礎索引還是高級索引進行的賦值操作都是就地(in-place)執行的。更多示例可參考NumPy索引文檔。

需要特別說明的幾個操作：

• reshape()、reshape_as()和flatten()可能返回視圖或新張量，用戶代碼不應依賴其返回類型
• contiguous()在輸入張量已連續時返回其自身，否則會通過復制數據返回新的連續張量

如需深入了解PyTorch內部實現機制，請參閱ezyang的PyTorch內部原理博客文章。

---

2025-05-10（六）