PyTorch

PyTorch 是由 Meta（原 Facebook）開發的開源深度學習框架，于 2016 年發布，以靈活性、動態計算圖和易用性為核心特點，廣泛應用于學術研究和工業界。

其核心優勢包括：

• 動態計算圖：計算過程實時構建，支持在運行中修改網絡結構，便于調試和靈活實驗
• 自動求導機制：自動計算張量操作的梯度，簡化反向傳播實現
• GPU 加速：無縫支持 CUDA 加速，大幅提升大規模張量運算效率
• 豐富生態：配套 TorchVision（計算機視覺）、TorchText（自然語言處理）等工具庫
• 良好兼容性：支持模型導出為 ONNX 格式，便于跨框架部署

PyTorch 的核心數據結構是張量（Tensor），所有神經網絡操作都圍繞張量展開。

Tensor

• 核心數據結構： torch.Tensor 是 PyTorch 中最基本、最重要的數據結構，類似于 NumPy 的 ndarray，但擁有額外的特性使其適用于深度學習。
• 本質： 一個多維數組（張量）。標量是 0 維張量，向量是 1 維張量，矩陣是 2 維張量，依此類推。
• 關鍵特性：
  • GPU 加速： 可以輕松地將 Tensor 移動到 GPU 上進行高速并行計算。
  • 自動微分 (Autograd)： Tensor 可以跟蹤在其上執行的操作，以自動計算梯度（導數），這是訓練神經網絡的核心（反向傳播）。
  • 豐富的操作： 提供了大量用于數學運算、線性代數、隨機采樣等的函數。

---

1 Tensor 的創建

有多種方式創建 Tensor：

1.torch.tensor

從 Python 列表或序列創建：

import torch
# 創建標量 (0維)
scalar = torch.tensor(3.14)
# 創建向量 (1維)
vector = torch.tensor([1, 2, 3, 4])
# 創建矩陣 (2維)
matrix = torch.tensor([[1., 2.], [3., 4.]])
# 創建3維張量
tensor_3d = torch.tensor([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])

2.torch.Tensor

# 1. 根據形狀創建張量
tensor1 = torch.Tensor(2, 3)
print(tensor1)
# 2. 也可以是具體的值
tensor2 = torch.Tensor([[1, 2, 3], [4, 5, 6]])
print(tensor2, tensor2.shape, tensor2.dtype)tensor3 = torch.Tensor([10])
print(tensor3, tensor3.shape, tensor3.dtype)# 指定tensor數據類型
tensor1 = torch.Tensor([1,2,3]).short()
print(tensor1)tensor1 = torch.Tensor([1,2,3]).int()
print(tensor1)

3. 線性張量

使用 torch.arange() / torch.linspace()： 創建線性序列

• torch.arange(start=0, end, step=1)： 類似 Python range，創建從 start 到 end（不包括 end），步長為 step 的 1 維 Tensor。
• torch.linspace(start, end, steps)： 創建從 start 到 end（包括 end）的等間隔 steps 個點組成的 1 維 Tensor。

# 類似range，生成[start, end)的整數序列
t_arange = torch.arange(0, 10, step=2)  # 結果：[0, 2, 4, 6, 8]# 生成均勻分布的線性序列（包含end）
t_linspace = torch.linspace(0, 1, steps=5)  # 結果：[0.0, 0.25, 0.5, 0.75, 1.0]

4. 隨機張量

使用 torch.rand() / torch.randn() / torch.randint()： 創建隨機初始化的 Tensor。

• torch.rand(*size)： 從 [0, 1) 均勻分布中隨機采樣。
• torch.randn(*size)： 從 標準正態分布（均值為0，方差為1） 中隨機采樣。
• torch.randint(low, high, size)： 從 [low, high) 的整數均勻分布中隨機采樣。

# 均勻分布 [0,1)
t_rand = torch.rand(2, 3)  # 形狀為(2,3)的隨機張量# 標準正態分布（均值0，方差1）
t_randn = torch.randn(3, 3)# 隨機整數 [low, high)
t_randint = torch.randint(low=0, high=10, size=(2, 2))  # 2x2的0-9隨機整數# 固定隨機種子（保證結果可復現）
torch.manual_seed(42)

5. 特定數值的張量

t_zeros = torch.zeros((2, 3))  # 全零張量，形狀(2,3)
t_ones = torch.ones((3, 3))   # 全一張量
t_full = torch.full((2, 2), 5)  # 填充指定值（5）
t_eye = torch.eye(3)  # 單位矩陣（對角線為1，其余為0）

---

2 Tensor 常見屬性

1 屬性

.shape	張量的形狀（各維度大小）	t = torch.rand(2, 3); print(t.shape)	torch.Size([2, 3])
.size()	與 .shape 等價，返回形狀元組	print(t.size(0))	2（第 0 維大小）
.dtype	數據類型（如 float32、int64 等）	print(t.dtype)	torch.float32
.device	存儲設備（CPU 或 GPU）	print(t.device)	cpu 或 cuda:0
.requires_grad	是否需要計算梯度（用于反向傳播）	t = torch.tensor(2.0, requires_grad=True); print(t.requires_grad)	True
.grad	存儲梯度值（需先調用 .backward()）	t.backward(); print(t.grad)	tensor(1.)（示例梯度值）
.is_cuda	是否在 GPU 上（布爾值）	print(t.is_cuda)	False（CPU 上）
.numel()	總元素數量（各維度大小乘積）	print(t.numel())	6（2×3 的張量）

2 設備切換

PyTorch 支持張量在 CPU 和 GPU 之間遷移，以利用 GPU 的并行計算能力加速深度學習任務。

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

方法 1：使用 .to(device)

# 創建一個 CPU 上的張量
t_cpu = torch.tensor([1, 2, 3])
print("原始設備:", t_cpu.device)  # cpu# 遷移到 GPU（若可用）
t_gpu = t_cpu.to(device)
print("遷移后設備:", t_gpu.device)  # cuda:0（若有GPU）# 從 GPU 遷回 CPU
t_cpu2 = t_gpu.to("cpu")
print(t_cpu2.device)  # cpu

方法 2：使用 .cuda() 和 .cpu()

    t2 = torch.tensor([1,2,3])t2 = t2.cuda()print(t2)t3 = t2.cpu()print(t3)

3 類型轉換

torch.Tensor.to(dtype)

通用方法，通過 dtype 參數指定目標類型，適用于所有轉換場景：

import torch# 原始張量（int64類型）
t = torch.tensor([1, 2, 3], dtype=torch.int64)
print("原始類型:", t.dtype)  # torch.int64# 轉換為 float32（默認浮點類型）
t_float32 = t.to(torch.float32)
print("轉換為float32:", t_float32.dtype)  # torch.float32# 轉換為 int32
t_int32 = t.to(torch.int32)
print("轉換為int32:", t_int32.dtype)  # torch.int32# 轉換為 bool 類型（非0值為True）
t_bool = t.to(torch.bool)
print("轉換為bool:", t_bool.dtype, t_bool)  # torch.bool tensor([True, True, True])

類型專用方法

PyTorch 為常用類型提供了專用方法，更簡潔直觀：

t = torch.tensor([1, 2, 3], dtype=torch.int32)t_float = t.float()       # 等價于 to(torch.float32)
t_double = t.double()     # 等價于 to(torch.float64)
t_long = t.long()         # 等價于 to(torch.int64)
t_int = t.int()           # 等價于 to(torch.int32)
t_bool = t.bool()         # 等價于 to(torch.bool)

創建張量時直接指定類型

通過 dtype 參數在創建張量時就確定類型，避免后續轉換：

# 直接創建 float16 類型張量
t_half = torch.tensor([1.5, 2.5], dtype=torch.float16)
print(t_half.dtype)  # torch.float16# 直接創建 uint8 類型張量（圖像數據常用）
t_uint8 = torch.tensor([0, 128, 255], dtype=torch.uint8)
print(t_uint8.dtype)  # torch.uint8

與 NumPy 數組的類型互轉

PyTorch 張量與 NumPy 數組轉換時，類型會自動對應，也可顯式指定：

import numpy as np# NumPy 數組（float64類型）
np_arr = np.array([1.2, 3.4], dtype=np.float64)# 轉換為 PyTorch 張量（默認對應 float64）
t = torch.from_numpy(np_arr)
print(t.dtype)  # torch.float64# 轉換時顯式指定類型
t = torch.from_numpy(np_arr).to(torch.float32)
print(t.dtype)  # torch.float32# 張量轉 NumPy 數組（保留類型）
np_arr2 = t.numpy()
print(np_arr2.dtype)  # float32

---

4 數據轉換（淺拷貝與深拷貝）

在 PyTorch 中理解數據轉換（尤其是涉及內存共享）非常重要，因為它直接影響內存使用和計算結果。

• 淺拷貝 (Shallow Copy)： 創建一個新對象，但新對象的內容是對原對象內容的引用。修改新對象的內容可能會改變原對象的內容（因為它們共享底層數據）。內存效率高。
• 深拷貝 (Deep Copy)： 創建一個新對象，并且遞歸地復制原對象及其包含的所有對象。新對象與原對象完全獨立，修改其中一個不會影響另一個。內存開銷更大。

張量轉Numpy

numpy():張量轉numpy數組，淺拷貝，修改numpy的元素會修改張量元素

numpy().copy():深拷貝，復制一個副本，修改副本不會影響源張量元素

    t = torch.tensor([1,2,3])print(t)	#tensor([1, 2, 3])# numpy():張量轉numpy數組，淺拷貝，修改numpy的元素會修改張量元素a = t.numpy()a[0]=100print(a)	#[100   2   3]print(t)	#tensor([100,   2,   3])b = t.numpy().copy()# numpy().copy():深拷貝，復制一個副本，修改副本不會影響源張量元素b[0]=200print(b)	#[200   2   3]print(t)	#tensor([100,   2,   3])

Numpy轉張量

torch.from_numpy():numpy數組轉張量，淺拷貝，修改張量元素會修改numpy的元素

torch.tensor():numpy數組轉張量，深拷貝，會創建新的存儲空間，修改副本不會影響源numpy元素

    a = np.array([1,2,3])print(a)# torch.from_numpy():numpy數組轉張量，淺拷貝，修改張量元素會修改numpy的元素t = torch.from_numpy(a)print(t)t[0] = 100print(t,a)# torch.tensor():numpy數組轉張量，深拷貝，復制一個副本，修改副本不會影響源numpy元素t1 = torch.tensor(a)t1[0]=999print(a)

5. Tensor常見操作

5.1 獲取元素值

item()方法：單個元素的數組獲取元素值，維度不影響

• 和Tensor的維度沒有關系，都可以取出來
• 如果有多個元素則報錯；

    t = torch.tensor(10)print((t.item()))t1 = torch.tensor([[10]])print(t1.item())

5.2 元素值運算

常見的加減乘除次方取反開方等各種操作，帶有_的方法則會替換原始值。

import torchdef test001():# 生成范圍 [0, 10) 的 2x3 隨機整數張量data = torch.randint(0, 10, (2, 3))print(data)# 元素級別的加減乘除：不修改原始值print(data.add(1))print(data.sub(1))print(data.mul(2))print(data.div(3))print(data.pow(2))# 元素級別的加減乘除：修改原始值data = data.float()data.add_(1)data.sub_(1)data.mul_(2)data.div_(3.0)data.pow_(2)print(data)if __name__ == "__main__":test001()

5.3 形狀操作

調整 Tensor 的維度和形狀是適配神經網絡輸入輸出的關鍵操作。

5.3.1 改變形狀（reshape /view）

• view(new_shape)：修改數組形狀，不改變內存存儲順序，效率較高，
  • 前提是tensor在內存中是連續的，否則需先用contiguous()轉換；
  • 如果進行轉置等操作導致數據不連續，此時使用view()方法會報錯
  • 支持 -1 自動計算維度，總元素數必須與原張量一致
• reshape(new_shape)：功能類似 NumPy 的reshape，會自動處理非連續情況（內部可能調用view或復制數據）

x = torch.arange(12)  # 形狀：(12,)# reshape：靈活改變形狀（推薦，自動處理非連續內存）
x1 = x.reshape(3, 4)  # 3行4列 → (3,4)
x2 = x.reshape(2, 2, 3)  # 3維 → (2,2,3)# view：類似reshape，但要求Tensor內存連續（不連續時會報錯）
x3 = x.view(4, 3)  # 4行3列 → (4,3)

5.3.2 維度增減（unsqueeze /squeeze）

• unsqueeze：用于在指定位置插入一個大小為 1 的新維度。

• squeeze：用于移除所有大小為 1 的維度，或者移除指定維度的大小為 1 的維度;若刪除的維度數不為1，則不做任何操作，也不報錯

x = torch.tensor([1, 2, 3])  # 形狀：(3,)# unsqueeze：在指定位置增加一個維度（維度大小為1）
x_unsq0 = x.unsqueeze(0)  # 形狀：(1,3)（在第0維增加）
x_unsq1 = x.unsqueeze(1)  # 形狀：(3,1)（在第1維增加）# squeeze：刪除大小為1的維度（默認刪除所有）
x_sq0 = x_unsq0.squeeze()  # 形狀：(3,)（刪除第0維）
x_sq1 = x_unsq1.squeeze(1)  # 形狀：(3,)（指定刪除第1維）

5.3.3 維度交換（transpose /permute）

transpose: 用于交換張量的兩個維度,返回新張量，原張量不變

permute:重新排列張量的維度,不改變張量的數據，只改變維度的順序

x = torch.randn(2, 3, 4)  # 形狀：(2,3,4)（假設為[batch, height, width]）# transpose：交換兩個維度
x_trans = x.transpose(1, 2)  # 交換1和2維 → 形狀：(2,4,3)# permute：重排所有維度（更靈活）
x_perm = x.permute(2, 0, 1)  # 維度順序變為2→0→1 → 形狀：(4,2,3)

5.4 阿達瑪積

對兩個形狀相同的 Tensor，對應位置的元素相乘，結果形狀與輸入相同。

實現方式：

• 運算符：*
• 函數：torch.mul(a, b)
• 方法：a.mul(b)

'''# 阿達碼積:
前提：兩個矩陣形狀相同；
兩個矩陣相同位置元素相乘：Cij = Mij * Nij
運算：mul   *
'''t = torch.tensor([[1,2,3],[3,4,5]])t1 = torch.tensor([[5,6,6],[7,8,9]])print(t.mul(t1))print(t*t1)'''tensor([[ 5, 12, 18],[21, 32, 45]])tensor([[ 5, 12, 18],[21, 32, 45]])	'''

5.5 Tensor相乘

要求前一個矩陣的列數等于后一個矩陣的行數。

實現方式：

• 運算符：@
• 函數：torch.matmul(a, b)
• 方法：a.matmul(b)

'''
矩陣運算：(M X N) x (N X M)
第一個矩陣的第一行于第二個矩陣的第一列元素分別相乘之和...
運算符號：matmul  @
'''t = torch.tensor([[1,2,3],[3,4,5]])t1 = torch.tensor([[5,6],[7,8],[9,10]])print(t.matmul(t1))print(t@t1)'''tensor([[ 46,  52],[ 88, 100]])tensor([[ 46,  52],[ 88, 100]])'''

6 廣播機制（Broadcasting）

當兩個 Tensor 形狀不同時，PyTorch 會自動擴展它們的維度以匹配，便于元素級運算（類似 NumPy 的廣播）。

廣播規則：

1. 若維度數量不同，在形狀較短的 Tensor 前補 1，直到維度數量一致。
2. 對于每個維度，若兩個 Tensor 的大小相同，或其中一個為 1，則可廣播（擴展為較大的大小）。

a = torch.tensor([[1, 2, 3], [4, 5, 6]])  # 形狀：(2,3)
b = torch.tensor([10, 20, 30])           # 形狀：(3,)# 廣播后：
# a保持(2,3)，b擴展為(2,3) → [[10,20,30], [10,20,30]]
c = a + b  # 結果：[[11,22,33], [14,25,36]]# 另一個例子：(3,1) 與 (1,4) 廣播為 (3,4)
d = torch.tensor([[1], [2], [3]])  # (3,1)
e = torch.tensor([[10, 20, 30, 40]])  # (1,4)
f = d + e  
# 結果：3x4矩陣 → [[11,21,31,41], [12,22,32,42],[13,23,33,43]]