目錄

張量操作

創建張量：

torch.tensor() ：直接從數據創建張量

torch.zeros() ：創建全零張量

torch.ones() ：創建全一張量

torch.randn() ：創建正態分布隨機張量

torch.arange() ：創建等差序列張量

torch.linspace() ：創建線性間隔張量

張量屬性：

tensor.shape ：獲取張量的形狀

tensor.dtype ：獲取張量的數據類型

tensor.device ：獲取張量所在的設備

張量轉換：

tensor.to() ：將張量轉換到指定設備或數據類型

tensor.numpy() ：將張量轉換為NumPy數組

torch.from_numpy() ：從NumPy數組創建張量

?張量操作：

數學運算

廣播機制

索引和切片

重塑和轉置

自動求導

自動求導機制

定義新自動求導函數

神經網絡構建

torch.nn 模塊：

層定義

激活函數

損失函數

優化器

模型定義：

數據處理

數據集

數據加載器

模型保存與加載

保存模型

torch.save(model.state_dict(), 'model.pth')

torch.save(model, 'model.pth')

加載模型

對于只保存參數的方式，需要先定義相同的模型結構，然后使用 model.load_state_dict(torch.load('model.pth')) 加載模型參數

對于保存整個模型的方式，可以直接使用 torch.load('model.pth') 加載模型，然后將其分配給一個變量即可使用

分布式訓練

多GPU訓練

分布式數據加載

其他功能

設備管理

隨機數種子設置

模型推理

---

PyTorch是一個功能強大的深度學習庫，以下是其常用方法功能的分類介紹：

張量操作

創建張量：

• torch.tensor() ：直接從數據創建張量

• torch.zeros() ：創建全零張量

• torch.ones() ：創建全一張量

• torch.randn() ：創建正態分布隨機張量

• torch.arange() ：創建等差序列張量

• torch.linspace() ：創建線性間隔張量

## 張量操作
# 創建張量
import torch# 創建張量
tensor_from_data = torch.tensor([1, 2, 3])
zeros_tensor = torch.zeros((3, 3))
ones_tensor = torch.ones((2, 2))
randn_tensor = torch.randn((3, 3))
arange_tensor = torch.arange(0, 10)
linspace_tensor = torch.linspace(0, 10, steps=5)print(tensor_from_data)  # tensor([1, 2, 3])
print(zeros_tensor)
# tensor([[0., 0., 0.],
#         [0., 0., 0.],
#         [0., 0., 0.]])print(ones_tensor)
# tensor([[1., 1.],
#         [1., 1.]])print(randn_tensor)
# tensor([[ 0.9779,  1.8636, -0.8193],
#         [-0.8590,  0.4308, -0.2886],
#         [-1.1653,  0.4701, -1.0421]])print(arange_tensor)  # tensor([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
print(linspace_tensor)  #  tensor([ 0.0000,  2.5000,  5.0000,  7.5000, 10.0000])

張量屬性：

• tensor.shape ：獲取張量的形狀

• tensor.dtype ：獲取張量的數據類型

• tensor.device ：獲取張量所在的設備

# 張量屬性
print(tensor_from_data.shape)  # 輸出：torch.Size([3])
print(zeros_tensor.dtype)      # 輸出：torch.float32
print(ones_tensor.device)      # 輸出：cpu

張量轉換：

• tensor.to() ：將張量轉換到指定設備或數據類型

• tensor.numpy() ：將張量轉換為NumPy數組

• torch.from_numpy() ：從NumPy數組創建張量

# 張量轉換
tensor_to_cpu = tensor_from_data.to('cpu')
print(tensor_to_cpu)  # tensor([1, 2, 3])tensor_to_float = tensor_from_data.to(torch.float32)
print(tensor_to_float)  # tensor([1., 2., 3.])numpy_array = tensor_from_data.numpy()
print(numpy_array)  # [1 2 3]tensor_from_numpy = torch.from_numpy(numpy_array)
print(tensor_from_numpy)  # tensor([1, 2, 3])

?張量操作：

• 數學運算

支持加法 tensor1 + tensor2 、減法 tensor1 - tensor2 、乘法 tensor1 * tensor2 、除法 tensor1 / tensor2 等逐元素運算，以及矩陣乘法 torch.matmul(tensor1, tensor2)?

• 廣播機制

在進行張量運算時，會自動擴展較小張量的維度以匹配較大張量的維度，從而實現更靈活的運算

• 索引和切片

與NumPy類似，可以通過索引和切片操作來訪問張量的特定元素或子張量

• 重塑和轉置

tensor.reshape() 可以改變張量的形狀， tensor.transpose() 可以對張量進行轉置操作

# 張量操作
tensor1 = torch.tensor([1, 2, 3])
tensor2 = torch.tensor([4, 5, 6])
add_tensor = tensor1 + tensor2  # 加法
print(add_tensor)  # tensor([5, 7, 9])mul_tensor = tensor1 * tensor2  # 乘法
print(mul_tensor)  # tensor([ 4, 10, 18])matmul_tensor = torch.matmul(tensor1.unsqueeze(0), tensor2.unsqueeze(1))  # 矩陣乘法
print(matmul_tensor)  # tensor([[32]])reshaped_tensor = tensor_from_data.reshape((1, 3))  # 重塑
print(reshaped_tensor)  # tensor([[1, 2, 3]])transposed_tensor = tensor_from_data.reshape((3, 1)).transpose(0, 1)  # 轉置
print(transposed_tensor)  # tensor([[1, 2, 3]])

自動求導

• 自動求導機制

PyTorch的 autograd 模塊能夠自動計算梯度，這對于神經網絡的反向傳播至關重要。當創建張量時，設置 requires_grad=True ，則該張量的所有操作都會被跟蹤，以便后續計算梯度

## 自動求導x = torch.tensor([1.0, 2.0, 3.0], requires_grad=True)
y = x * x
y.sum().backward()  # 反向傳播
print(x.grad)  # 輸出梯度 [2., 4., 6.]

• 定義新自動求導函數

可以通過繼承 torch.autograd.Function 類并實現 forward 和 backward 方法來定義新的自動求導函數，從而實現自定義的梯度計算邏輯

# 定義新自動求導函數
class CustomReLU(torch.autograd.Function):@staticmethod  # 表示這是一個靜態方法，不需要實例化類就可以調用def forward(ctx, input):ctx.save_for_backward(input)  # 保存輸入張量，以便在反向傳播時使用return torch.relu(input)  # 前向傳播：應用 ReLU 激活函數@staticmethoddef backward(ctx, grad_output):input, = ctx.saved_tensors  # 獲取保存的輸入張量grad_input = grad_output.clone()  # 創建一個與 grad_output 形狀相同的張量grad_input[input < 0] = 0  # 對于輸入小于0的部分，梯度為0return grad_input  # 返回梯度custom_relu = CustomReLU.apply
x = torch.tensor([-1.0, 2.0, 3.0], requires_grad=True)
y = custom_relu(x)
y.sum().backward()
print(x.grad)  # 輸出梯度 [0., 1., 1.]

神經網絡構建

torch.nn 模塊：

• 層定義

提供了各種神經網絡層的實現如 nn.Linear 定義全連接層， nn.Conv2d 定義二維卷積層， nn.BatchNorm2d 定義二維批量歸一化層等

• 激活函數

包括 torch.relu 、 torch.sigmoid 、 torch.tanh 等常用的激活函數

• 損失函數

提供了多種損失函數，如 nn.MSELoss 用于均方誤差損失， nn.CrossEntropyLoss 用于分類任務的交叉熵損失， nn.BCELoss 用于二分類任務的二元交叉熵損失等

• 優化器

實現了多種優化算法，如 torch.optim.SGD 是隨機梯度下降優化器， torch.optim.Adam 是Adam優化器等，用于更新網絡參數

模型定義：

通過繼承 torch.nn.Module 類來定義自己的神經網絡模型，在 __init__ 方法中定義網絡的層，在 forward 方法中定義數據在網絡中的前向傳播過程

## 神經網絡構建import torch.nn as nn
import torch.optim as optim# 定義模型
class MyModel(nn.Module):def __init__(self):super(MyModel, self).__init__()self.fc1 = nn.Linear(10, 5)self.relu = nn.ReLU()self.fc2 = nn.Linear(5, 2)def forward(self, x):x = self.fc1(x)x = self.relu(x)x = self.fc2(x)return xmodel = MyModel()# 定義損失函數和優化器
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01)# 模擬訓練
inputs = torch.randn(4, 10)
labels = torch.tensor([0, 1, 0, 1])optimizer.zero_grad()  # 清空梯度
outputs = model(inputs)
loss = criterion(outputs, labels)
loss.backward()  # 反向傳播
optimizer.step()  # 更新參數print(criterion(outputs, labels))  # tensor(0.6918, grad_fn=<NllLossBackward0>)

數據處理

• 數據集

?torch.utils.data.Dataset 是一個抽象類，用于表示數據集，用戶可以自定義數據集類，通過重寫 __getitem__ 和 __len__ 方法來實現對數據的訪問和獲取數據集的大小

• 數據加載器

torch.utils.data.DataLoader 是一個可迭代對象，它封裝了數據集，并提供了批量加載、打亂數據、多線程數據加載等功能，方便在訓練過程中高效地獲取數據

## 數據處理from torch.utils.data import Dataset, DataLoader# 自定義數據集
class MyDataset(Dataset):def __init__(self, data, labels):self.data = dataself.labels = labelsdef __getitem__(self, index):return self.data[index], self.labels[index]def __len__(self):return len(self.data)data = torch.randn(100, 10)
labels = torch.randint(0, 2, (100,))
dataset = MyDataset(data, labels)
dataloader = DataLoader(dataset, batch_size=10, shuffle=True)# 使用數據加載器
for inputs, labels in dataloader:print(inputs.shape, labels.shape)   # torch.Size([10, 10])  torch.Size([10])# torch.Size([10, 10])  torch.Size([10])# torch.Size([10, 10])  torch.Size([10])# torch.Size([10, 10])  torch.Size([10])# torch.Size([10, 10])  torch.Size([10])# torch.Size([10, 10])  torch.Size([10])# torch.Size([10, 10])  torch.Size([10])# torch.Size([10, 10])  torch.Size([10])# torch.Size([10, 10])  torch.Size([10])# torch.Size([10, 10])  torch.Size([10])

模型保存與加載

保存模型

• torch.save(model.state_dict(), 'model.pth')

只保存模型的參數，這種方式保存的文件較小，且在加載模型時需要先定義相同的模型結構

• torch.save(model, 'model.pth')

保存整個模型，包括模型的結構和參數，這種方式保存的文件較大，但加載時不需要定義模型結構

## 數據保存與加載# 保存模型
torch.save(model.state_dict(), 'model.pth')  # 保存參數
torch.save(model, 'model.pth')  # 保存整個模型

加載模型

• 對于只保存參數的方式，需要先定義相同的模型結構，然后使用 model.load_state_dict(torch.load('model.pth')) 加載模型參數

• 對于保存整個模型的方式，可以直接使用 torch.load('model.pth') 加載模型，然后將其分配給一個變量即可使用

# 加載模型
model = MyModel()
model.load_state_dict(torch.load('model.pth'))  # 加載參數
model = torch.load('model.pth')  # 加載整個模型

分布式訓練

• 多GPU訓練

PyTorch提供了 torch.nn.DataParallel 和 torch.nn.parallel.DistributedDataParallel 等模塊，用于在多GPU環境下進行模型訓練，可以顯著提高訓練速度

• 分布式數據加載

在分布式訓練中， torch.utils.data.distributed.DistributedSampler 可以根據進程數和進程編號對數據集進行分片，確保每個進程加載的數據是不同的，從而實現數據的分布式加載

## 分布式訓練import torch.distributed as dist
import torch.nn.parallel# 初始化分布式環境
dist.init_process_group(backend='nccl', init_method='env://')# 多GPU訓練
model = MyModel()
model = torch.nn.DataParallel(model)
# model = torch.nn.parallel.DistributedDataParallel(model)# 分布式數據加載
sampler = torch.utils.data.distributed.DistributedSampler(dataset)
dataloader = DataLoader(dataset, batch_size=10, sampler=sampler)

其他功能

• 設備管理

可以通過 torch.device 對象來指定張量和模型所在的設備，如 torch.device('cuda:0') 表示使用第一塊GPU， torch.device('cpu') 表示使用CPU

• 隨機數種子設置

使用 torch.manual_seed(seed) 可以設置隨機數種子，確保每次運行代碼時生成的隨機數是相同的，這對于實驗的可重復性非常重要

• 模型推理

在模型推理階段，可以使用 model.eval() 將模型切換到評估模式，這會關閉 Dropout 和 BatchNorm 等層的訓練特性，以確保模型在推理時的行為是正確的

## 其他功能# 設備管理
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
tensor = torch.tensor([1, 2, 3], device=device)# 隨機數種子設置
torch.manual_seed(42)
random_tensor = torch.randn((3, 3))# 模型推理
model.eval()  # 切換到評估模式
with torch.no_grad():  # 關閉梯度計算outputs = model(inputs)