張量的簡介
張量是多重線性映射在給定基下的坐標表示，可視為向量和矩陣的泛化。
- 0 維張量：標量（如?
5） - 1 維張量：向量（如?
[1, 2, 3]） - 2 維張量：矩陣（如?
[[1, 2], [3, 4]]） - 3 維及以上張量：多維數組（如圖像、視頻、時間序列數據）
創建張量的方法
直接從數據創建
x = torch.tensor([5.5, 3]) # 從列表創建
print(x) # tensor([5.5000, 3.0000])
創建了一個包含兩個浮點數的一維張量，創建一個形狀為?[2]?的張量，包含元素?[5.5, 3.0]，數據類型默認為?torch.float32
默認情況下，張量會創建在 CPU 上。若要在 GPU 上運行，需顯式指定（如?.to('cuda')）
全0或全1張量
zeros = torch.zeros(4, 3, dtype=torch.long) # 4x3全0矩陣，數據類型為long
ones = torch.ones(2, 2) # 2x2全1矩陣
print(zeros)
?
zeros 張量：使用 torch.zeros() 創建一個形狀為 [4, 3] 的全零矩陣，數據類型指定為 torch.long（即 64 位整數）。
ones 張量：使用 torch.ones() 創建一個形狀為 [2, 2] 的全一矩陣，數據類型默認為 torch.float32。
隨機初始化張量
rand = torch.rand(4, 3) # 4x3隨機矩陣（均勻分布[0,1)）
randn = torch.randn(4, 3) # 4x3隨機矩陣（標準正態分布）
print(rand)
print(randn)
rand 張量：使用 torch.rand(4, 3) 創建一個形狀為 [4, 3] 的隨機矩陣，元素服從 均勻分布 U(0, 1)（范圍從 0 到 1，包含 0 但不包含 1）。
randn 張量：使用 torch.randn(4, 3) 創建一個形狀為 [4, 3] 的隨機矩陣，元素服從 標準正態分布 N(0, 1)（均值為 0，標準差為 1）。
基于現有張量創建
x = torch.new_ones(4, 3, dtype=torch.double) # 全1矩陣，double類型
y = torch.randn_like(x, dtype=torch.float) # 與x形狀相同的隨機矩陣，float類型
print(x.size()) # torch.Size([4, 3])
print(y.shape) # 等價于.size()torch.new_ones()：創建一個與調用對象（此處為torch）相同類型的全 1 張量。dtype=torch.double指定數據類型為 64 位浮點數（等價于torch.float64）。
torch.randn_like()：基于已有張量的形狀創建新張量。dtype=torch.float覆蓋原始數據類型，生成 32 位浮點數（等價于torch.float32）的隨機張量（正態分布）。
報錯：
raise AttributeError(f"module '{__name__}' has no attribute '{name}'")
AttributeError: module 'torch' has no attribute 'new_ones'
錯誤的原因是 torch.new_ones() 并不是 PyTorch 的全局函數，而是 張量對象的方法（即需要通過已有的張量實例調用）。
# 正確寫法：通過現有張量調用 new_ones()
# 1. 先創建一個基礎張量（用于指定設備和數據類型）
base_tensor = torch.tensor([], dtype=torch.double) # 空張量，僅指定類型
# 2. 基于基礎張量創建全1張量
x = base_tensor.new_ones(4, 3) # 形狀為 (4, 3)，數據類型與 base_tensor 一致（double）
print(x)
print(x.dtype) # 輸出：torch.float64（即 double 類型）# 更簡潔的等價寫法：直接用 torch.ones() 指定形狀和類型
x = torch.ones(4, 3, dtype=torch.double) # 效果與上面完全相同
print(x)
常用函數
torch.Tensor()?? ?基礎構造函數
torch.zeros()?? ?全 0 張量
torch.ones()?? ?全 1 張量
torch.rand()?? ?均勻分布隨機張量
torch.randn()?? ?正態分布隨機張量
torch.arange()?? ?等差數列張量
torch.linspace()?? ?等分數列張量
運算
三種加法
方式一
x = torch.rand(4, 3)
y = torch.rand(4, 3)
print(x + y)方式二
torch.add(x, y)方式三
y.add_(x)
print(y)
減乘除
print(x-y)
print(x*y)
print(x/y)
索引
x[k, :]取第k+1行，因為索引從0開始
x[:,k]取第k+1列
import torch
x = torch.rand(4, 3)
print(x)
print(x[1,:])
print(x[:,1])
另外可以用
x[p,q] = 100來修改特定位置的元素
索引操作返回的是原張量的視圖（view），共享內存。如需獨立副本，使用 .clone()。
維度變換
y = x.view(16) # 將x展平為1維向量
z = x.view(-1, 8) # -1表示該維度由其他維度推斷（16/8=2）view()返回的是原張量的視圖（共享內存），不復制數據。-1是動態推斷維度的占位符，總元素數必須匹配（4×4=16）
print(x.size(), y.size(), z.size()) # 輸出: [4, 4] [16] [2, 8]所有張量共享相同的 16 個元素，只是組織方式不同
# 功能類似view，但可能返回副本
a = x.reshape(2, 8)reshape()是更靈活的操作：若原張量內存連續，返回視圖（等價于view()）；若不連續（如經過轉置），會強制復制數據
# 使用clone()創建獨立副本后再view
b = x.clone().view(16)?x.clone() 創建了一個與 x 具有相同數據但內存獨立的新張量。這意味著修改 b 不會影響原始張量 x。
.view(16) 將克隆后的張量調整為一維向量（長度為 16）。由于 clone() 返回的是連續內存的張量，view() 可以直接操作而無需額外復制。
import torch
x=torch.rand(4,3)
print(x)
y=x.view(12)
z=x.view(-1,2)
print(x.size(),y.size(),z.size())輸出：
import torch
x=torch.rand(4,3)
print(x)
a=x.reshape(2,6)
print(a)
b=x.clone().view(12)
print(b)輸出：?
取值操作
x = torch.randn(1)
print(x) # tensor([-0.3456])
print(x.item()) # -0.3456234779701233（轉為Python標量）廣播機制
當對兩個張量執行運算時，PyTorch 會按以下規則自動處理形狀差異：
維度對齊：將維度較少的張量左側補 1，使兩者維度數相同。
例：a.shape = (2, 3, 4)，b.shape = (3, 1) → 補全后 b.shape = (1, 3, 1)。
維度兼容性檢查：對每個維度，若大小不同，則其中必須有一個為 1，否則廣播失敗。
兼容示例：(3, 1) 和 (1, 4) → 可廣播為 (3, 4)。
不兼容示例：(2, 3) 和 (2, 4) → 最后一維 3≠4 且均不為 1，廣播失敗。
維度擴展：將維度為 1 的軸擴展到與另一張量對應維度相同的大小（實際計算中不復制數據，僅邏輯擴展）。
例：a.shape = (3, 4) 與補全后的 b.shape = (1, 4) → 廣播后均為 (3, 4)。
當兩個形狀不同的張量進行運算時，PyTorch 會自動觸發廣播機制
import torcha = torch.tensor([1, 2, 3]) # shape: (3,)
b = torch.tensor(5) # shape: ()result = a + b
print(result) # tensor([6, 7, 8])a = torch.randn(2, 3) # shape: (2, 3)
b = torch.randn(3) # shape: (3,)result = a + b
print(result.shape) # torch.Size([2, 3])a = torch.randn(2, 1, 3) # shape: (2, 1, 3)
b = torch.randn(1, 3) # shape: (1, 3)result = a + b
print(result.shape) # torch.Size([2, 1, 3])a = torch.randn(2, 3) # shape: (2, 3)
b = torch.randn(2, 4) # shape: (2, 4)# 會報錯
try:result = a + b
except RuntimeError as e:print(e)
# 輸出: The size of tensor a (3) must match the size of tensor b (4) at non-singleton dimension 1a = torch.randn(1, 2, 1) # shape: (1, 2, 1)
b = torch.randn(3, 1, 4) # shape: (3, 1, 4)result = a + b
print(result.shape) # torch.Size([3, 2, 4])所有維度都會嘗試廣播：
第 0 維：1 vs 3 → 擴展為 3
第 1 維：2 vs 1 → 擴展為 2
第 2 維：1 vs 4 → 擴展為 4
結果形狀為 (3, 2, 4)
a = torch.arange(1, 3).view(1, 2) # tensor([[1, 2]])
b = torch.arange(1, 4).view(3, 1) # tensor([[1], [2], [3]])
print(a + b)torch.arange()創建一個一維張量，包含從 start 到 end - 1（左閉右開）的等差數列。
torch.arange(start=0, end, step=1, dtype=None, device=None, requires_grad=False)start：起始值（默認為 0）
end：結束值（不包含）
step：步長（默認為 1）
dtype：數據類型（如 torch.int, torch.float 等）
b = torch.arange(1, 4) # start=1, end=4 → [1, 2, 3]
# tensor([1, 2, 3])a = torch.arange(1, 3).view(1, 2) # shape: (1, 2)
b = torch.arange(1, 4).view(3, 1) # shape: (3, 1)print(a + b)a = [[1, 2]] # shape (1, 2)
b = [[1],[2],[3]] # shape (3, 1)# 廣播后：
a = [[1, 2],[1, 2],[1, 2]] # shape (3, 2)b = [[1, 1],[2, 2],[3, 3]] # shape (3, 2)# 相加：
result = [[2, 3],[3, 4],[4, 5]]廣播機制 不會復制數據，而是通過“虛擬擴展”（broadcast）的方式，讓不同形狀的張量看起來像是相同形狀，從而進行逐元素操作。這在內存和性能上都非常高效。
?張量與 NumPy 的交互
import numpy as np# NumPy數組轉PyTorch張量
a = np.array([1, 2, 3])
b = torch.from_numpy(a) # 共享內存
print(b) # tensor([1, 2, 3], dtype=torch.int32)# PyTorch張量轉NumPy數組
c = torch.rand(3)
d = c.numpy() # 共享內存
print(d) # [0.1234 0.5678 0.9012]# 修改其中一個會影響另一個（因為共享內存）
a[0] = 100
print(b) # tensor([100, 2, 3], dtype=torch.int32)a = np.array([1, 2, 3])
b = torch.from_numpy(a) ?torch.from_numpy() 的作用：這是 將 NumPy 數組轉換為 PyTorch 張量 的函數。
關鍵點：共享內存！也就是說，b 和 a 指向的是同一塊內存區域。
如果修改 a，b 也會變；反之亦然。
print(b) # tensor([1, 2, 3], dtype=torch.int32)輸出張量 b，其數據類型是 torch.int32，對應于 NumPy 的 np.int32 或 np.int64（根據系統）。
PyTorch 會根據 NumPy 數組的 dtype 自動推斷張量的 dtype。
d = c.numpy().numpy() 的作用：.numpy() 是 PyTorch 張量的方法，用于將其轉換為 NumPy 數組。
同樣，共享內存！即 c 和 d 指向的是同一塊內存空間。
自動求梯度（Autograd）
x = torch.tensor([2.0], requires_grad=True) torch.tensor([2.0])：創建一個包含單個元素的張量 x = 2.0。
requires_grad=True：告訴 PyTorch 需要為這個張量記錄梯度。只有設置了這個參數的張量，才會在反向傳播時計算梯度。默認情況下，requires_grad=False，即不記錄梯度。
# 定義函數 y = x^2
y = x**2這里我們定義了一個函數 y = x^2。y 是一個張量，它是由 x 經過計算得到的。PyTorch 會自動記錄這個計算過程，構建一個 計算圖（computation graph），以便后續進行反向傳播。
# 反向傳播計算梯度
y.backward() # 等價于 y.backward(torch.tensor(1.0))y.backward()：觸發反向傳播，計算 y 對所有需要梯度的輸入張量（比如 x）的梯度。
因為 y 是一個標量（只有一個元素），所以不需要傳入參數。
如果 y 是一個向量或更高維的張量，則需要傳入一個與 y 同形狀的 梯度向量，作為鏈式法則中的“上游梯度”。
y.backward() 等價于 y.backward(torch.tensor(1.0))，因為 PyTorch 默認對標量調用 .backward() 時使用 1.0 作為梯度。
# 查看梯度 dy/dx = 2x = 2*2 = 4
print(x.grad) # tensor([4.])x.grad：這是 x 的梯度，也就是 dy/dx。因為 y = x^2，所以 dy/dx = 2x。當 x = 2 時，dy/dx = 4。所以輸出為：tensor([4.])。
# 1. 定義模型參數
w = torch.randn(1, requires_grad=True)
b = torch.randn(1, requires_grad=True)# 2. 輸入數據
x = torch.tensor([2.0])# 3. 前向傳播
y_pred = w * x + b# 4. 定義目標值和損失函數
y_true = torch.tensor([5.0])
loss = (y_pred - y_true)**2# 5. 反向傳播
loss.backward()# 6. 查看梯度
print("w.grad:", w.grad)
print("b.grad:", b.grad)參考文章
thorough-pytorch/source/第二章/2.1 張量.md at main · datawhalechina/thorough-pytorch
https://github.com/datawhalechina/thorough-pytorch/blob/main/source/%E7%AC%AC%E4%BA%8C%E7%AB%A0/2.1%20%E5%BC%A0%E9%87%8F.md
