目錄
簡單的神經網絡
一、PyTorch的安裝
二、準備工作
三、數據的準備
四、模型架構定義
五、模型訓練(CPU版本)
1. 定義損失函數和優化器
2. 開始循環訓練
3. 可視化結果
六、通俗解釋
1. 環境安裝(相當于買鍋碗瓢盆)??
2. 數據準備(洗菜切菜)??
3. 模型定義(設計菜譜)??
??4. 訓練過程(炒菜實操)??
??5. 評估與可視化(考試和總結)??
6. ??通俗總結??
7. 類比問答??
簡單的神經網絡
默認大家已經有一定的神經網絡基礎,該部分已經在復試班的深度學習部分介紹完畢,如果沒有,你需要自行了解下MLP的概念。
你需要知道
- 梯度下降的思想
- 激活函數的作用
- 損失函數的作用
- 優化器
- 神經網絡的概念
神經網絡由于內部比較靈活,所以封裝的比較淺,可以對模型做非常多的改進,而不像機器學習三行代碼固定。
一、PyTorch的安裝
我們后續完成深度學習項目中,主要使用的包為pytorch,所以需要安裝,你需要去配置一個新的環境。
未來在復現具體項目時候,新環境命名最好是python版本_pytorch版本_cuda版本,例如 py3.10_pytorch2.0_cuda12.2 ,因為復雜項目對運行環境有要求,所以需要安裝對應版本的包。
我們目前主要不用這么嚴格,先創建一個命名為DL的新環境即可,也可以沿用之前的環境
conda create -n DL python=3.8
conda env list
conda activate DL
conda install jupyter (如果conda無法安裝jupyter就參考環境配置文檔的pip安裝方法)
pip insatll scikit-learn
然后對著下列教程安裝pytorch
深度學習主要是簡單的并行計算,所以gpu優勢更大,簡單的計算cpu發揮不出來他的價值,我們之前說過顯卡和cpu的區別:
- cpu是1個博士生,能夠完成復雜的計算,串行能力強。
- gpu是100個小學生,能夠完成簡單的計算,人多計算的快。
這里的gpu指的是英偉達的顯卡,它支持cuda可以提高并行計算的能力。
如果你是amd的顯卡、蘋果的電腦,那樣就不需要安裝cuda了,直接安裝pytorch-gpu版本即可。cuda只支持nvidia的顯卡。
安裝教程
或者去b站隨便搜個pytorch安裝視頻。
- 怕麻煩直接安裝cpu版本的pytorch,跑通了用云服務器版本的pytorch-gpu
- gpu的pytorch還需要額外安裝cuda cudnn組件
二、準備工作
可以在你電腦的cmd中輸入nvidia-smi來查看下顯卡信息
其中最重要的2個信息,分別是:
- 顯卡目前驅動下最高支持的cuda版本,12.7
- 顯存大小,12288 MiB ÷ 1024 = 12
PS:之所以輸入這個命令,可以彈出這些信息,是因為為系統正確安裝了 NVIDIA 顯卡驅動程序,并且相關路徑被添加到了環境變量中。如果你不是英偉達的顯卡,自然無法使用這個命令。
import torch
torch.cuda
<module 'torch.cuda' from 'd:\\Anaconda\\envs\\yolov5\\lib\\site-packages\\torch\\cuda\\__init__.py'>
import torch# 檢查CUDA是否可用
if torch.cuda.is_available():print("CUDA可用!")# 獲取可用的CUDA設備數量device_count = torch.cuda.device_count()print(f"可用的CUDA設備數量: {device_count}")# 獲取當前使用的CUDA設備索引current_device = torch.cuda.current_device()print(f"當前使用的CUDA設備索引: {current_device}")# 獲取當前CUDA設備的名稱device_name = torch.cuda.get_device_name(current_device)print(f"當前CUDA設備的名稱: {device_name}")# 獲取CUDA版本cuda_version = torch.version.cudaprint(f"CUDA版本: {cuda_version}")
else:print("CUDA不可用。")
CUDA可用! 可用的CUDA設備數量: 1 當前使用的CUDA設備索引: 0 當前CUDA設備的名稱: NVIDIA GeForce RTX 3080 Ti CUDA版本: 11.1
這里的cuda版本是實際安裝的cuda驅動的版本,需要小于顯卡所支持的最高版本
上述這段代碼,可以以后不斷復用,檢查是否有pytorch及cuda相關信息,我們今天先用cpu訓練,不必在意,有沒有cuda不影響。
三、數據的準備
預處理補充:
注意事項:
(1)分類任務中,若標簽是整數(如 0/1/2 類別),需轉為long類型(對應 PyTorch 的torch.long),否則交叉熵損失函數會報錯。
(2)回歸任務中,標簽需轉為float類型(如torch.float32)。
# 仍然用4特征,3分類的鳶尾花數據集作為我們今天的數據集
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
import numpy as np# 加載鳶尾花數據集
iris = load_iris()
X = iris.data # 特征數據
y = iris.target # 標簽數據
# 劃分訓練集和測試集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)# 打印下尺寸
print(X_train.shape)
print(y_train.shape)
print(X_test.shape)
print(y_test.shape)
(120, 4) (120,) (30, 4) (30,)
# 歸一化數據,神經網絡對于輸入數據的尺寸敏感,歸一化是最常見的處理方式
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test) #確保訓練集和測試集是相同的縮放
# 將數據轉換為 PyTorch 張量,因為 PyTorch 使用張量進行訓練
# y_train和y_test是整數,所以需要轉化為long類型,如果是float32,會輸出1.0 0.0
X_train = torch.FloatTensor(X_train)
y_train = torch.LongTensor(y_train)
X_test = torch.FloatTensor(X_test)
y_test = torch.LongTensor(y_test)
四、模型架構定義
定義一個簡單的全連接神經網絡模型,包含一個輸入層、一個隱藏層和一個輸出層。
定義層數+定義前向傳播順序
import torch
import torch.nn as nn
import torch.optim as optim
class MLP(nn.Module): # 定義一個多層感知機(MLP)模型,繼承父類nn.Moduledef __init__(self): # 初始化函數super(MLP, self).__init__() # 調用父類的初始化函數# 前三行是八股文,后面的是自定義的self.fc1 = nn.Linear(4, 10) # 輸入層到隱藏層self.relu = nn.ReLU()self.fc2 = nn.Linear(10, 3) # 隱藏層到輸出層
# 輸出層不需要激活函數,因為后面會用到交叉熵函數cross_entropy,交叉熵函數內部有softmax函數,會把輸出轉化為概率def forward(self, x):out = self.fc1(x)out = self.relu(out)out = self.fc2(out)return out# 實例化模型
model = MLP()
其實模型層的寫法有很多,relu也可以不寫,在后面前向傳播的時候計算下即可,因為relu其實不算一個層,只是個計算而已。
# def forward(self,x): #前向傳播# x=torch.relu(self.fc1(x)) #激活函數# x=self.fc2(x) #輸出層不需要激活函數,因為后面會用到交叉熵函數cross_entropy# return x
五、模型訓練(CPU版本)
1. 定義損失函數和優化器
# 分類問題使用交叉熵損失函數
criterion = nn.CrossEntropyLoss()# 使用隨機梯度下降優化器
optimizer = optim.SGD(model.parameters(), lr=0.01)# # 使用自適應學習率的化器
# optimizer = optim.Adam(model.parameters(), lr=0.001)
2. 開始循環訓練
實際上在訓練的時候,可以同時觀察每個epoch訓練完后測試集的表現:測試集的loss和準確度
# 訓練模型
num_epochs = 20000 # 訓練的輪數# 用于存儲每個 epoch 的損失值
losses = []for epoch in range(num_epochs): # range是從0開始,所以epoch是從0開始# 前向傳播outputs = model.forward(X_train) # 顯式調用forward函數# outputs = model(X_train) # 常見寫法隱式調用forward函數,其實是用了model類的__call__方法loss = criterion(outputs, y_train) # output是模型預測值,y_train是真實標簽# 反向傳播和優化optimizer.zero_grad() #梯度清零,因為PyTorch會累積梯度,所以每次迭代需要清零,梯度累計是那種小的bitchsize模擬大的bitchsizeloss.backward() # 反向傳播計算梯度optimizer.step() # 更新參數# 記錄損失值losses.append(loss.item())# 打印訓練信息if (epoch + 1) % 100 == 0: # range是從0開始,所以epoch+1是從當前epoch開始,每100個epoch打印一次print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}')
輸出結果:
Epoch [100/20000], Loss: 1.0730
Epoch [200/20000], Loss: 1.0258
Epoch [300/20000], Loss: 0.9757
Epoch [400/20000], Loss: 0.9200
Epoch [500/20000], Loss: 0.8577
Epoch [600/20000], Loss: 0.7908
Epoch [700/20000], Loss: 0.7247
Epoch [800/20000], Loss: 0.6639
Epoch [900/20000], Loss: 0.6109
Epoch [1000/20000], Loss: 0.5661
Epoch [1100/20000], Loss: 0.5285
Epoch [1200/20000], Loss: 0.4967
Epoch [1300/20000], Loss: 0.4695
Epoch [1400/20000], Loss: 0.4456
Epoch [1500/20000], Loss: 0.4244
Epoch [1600/20000], Loss: 0.4052
Epoch [1700/20000], Loss: 0.3877
Epoch [1800/20000], Loss: 0.3715
Epoch [1900/20000], Loss: 0.3564
Epoch [2000/20000], Loss: 0.3423
Epoch [2100/20000], Loss: 0.3290
Epoch [2200/20000], Loss: 0.3165
Epoch [2300/20000], Loss: 0.3046
Epoch [2400/20000], Loss: 0.2935
Epoch [2500/20000], Loss: 0.2829
Epoch [2600/20000], Loss: 0.2729
Epoch [2700/20000], Loss: 0.2635
Epoch [2800/20000], Loss: 0.2545
Epoch [2900/20000], Loss: 0.2461
Epoch [3000/20000], Loss: 0.2381
Epoch [3100/20000], Loss: 0.2306
Epoch [3200/20000], Loss: 0.2235
Epoch [3300/20000], Loss: 0.2168
Epoch [3400/20000], Loss: 0.2104
Epoch [3500/20000], Loss: 0.2044
Epoch [3600/20000], Loss: 0.1987
Epoch [3700/20000], Loss: 0.1933
Epoch [3800/20000], Loss: 0.1882
Epoch [3900/20000], Loss: 0.1833
Epoch [4000/20000], Loss: 0.1787
Epoch [4100/20000], Loss: 0.1744
Epoch [4200/20000], Loss: 0.1702
Epoch [4300/20000], Loss: 0.1663
Epoch [4400/20000], Loss: 0.1625
Epoch [4500/20000], Loss: 0.1590
Epoch [4600/20000], Loss: 0.1556
Epoch [4700/20000], Loss: 0.1523
Epoch [4800/20000], Loss: 0.1492
Epoch [4900/20000], Loss: 0.1463
Epoch [5000/20000], Loss: 0.1435
Epoch [5100/20000], Loss: 0.1408
Epoch [5200/20000], Loss: 0.1382
Epoch [5300/20000], Loss: 0.1358
Epoch [5400/20000], Loss: 0.1334
Epoch [5500/20000], Loss: 0.1312
Epoch [5600/20000], Loss: 0.1290
Epoch [5700/20000], Loss: 0.1269
Epoch [5800/20000], Loss: 0.1249
Epoch [5900/20000], Loss: 0.1230
Epoch [6000/20000], Loss: 0.1212
Epoch [6100/20000], Loss: 0.1194
Epoch [6200/20000], Loss: 0.1177
Epoch [6300/20000], Loss: 0.1161
Epoch [6400/20000], Loss: 0.1145
Epoch [6500/20000], Loss: 0.1130
Epoch [6600/20000], Loss: 0.1116
Epoch [6700/20000], Loss: 0.1102
Epoch [6800/20000], Loss: 0.1088
Epoch [6900/20000], Loss: 0.1075
Epoch [7000/20000], Loss: 0.1062
Epoch [7100/20000], Loss: 0.1050
Epoch [7200/20000], Loss: 0.1038
Epoch [7300/20000], Loss: 0.1027
Epoch [7400/20000], Loss: 0.1016
Epoch [7500/20000], Loss: 0.1005
Epoch [7600/20000], Loss: 0.0995
Epoch [7700/20000], Loss: 0.0985
Epoch [7800/20000], Loss: 0.0975
Epoch [7900/20000], Loss: 0.0966
Epoch [8000/20000], Loss: 0.0957
Epoch [8100/20000], Loss: 0.0948
Epoch [8200/20000], Loss: 0.0940
Epoch [8300/20000], Loss: 0.0932
Epoch [8400/20000], Loss: 0.0924
Epoch [8500/20000], Loss: 0.0916
Epoch [8600/20000], Loss: 0.0908
Epoch [8700/20000], Loss: 0.0901
Epoch [8800/20000], Loss: 0.0894
Epoch [8900/20000], Loss: 0.0887
Epoch [9000/20000], Loss: 0.0880
Epoch [9100/20000], Loss: 0.0874
Epoch [9200/20000], Loss: 0.0867
Epoch [9300/20000], Loss: 0.0861
Epoch [9400/20000], Loss: 0.0855
Epoch [9500/20000], Loss: 0.0849
Epoch [9600/20000], Loss: 0.0844
Epoch [9700/20000], Loss: 0.0838
Epoch [9800/20000], Loss: 0.0833
Epoch [9900/20000], Loss: 0.0827
Epoch [10000/20000], Loss: 0.0822
Epoch [10100/20000], Loss: 0.0817
Epoch [10200/20000], Loss: 0.0812
Epoch [10300/20000], Loss: 0.0808
Epoch [10400/20000], Loss: 0.0803
Epoch [10500/20000], Loss: 0.0798
Epoch [10600/20000], Loss: 0.0794
Epoch [10700/20000], Loss: 0.0790
Epoch [10800/20000], Loss: 0.0785
Epoch [10900/20000], Loss: 0.0781
Epoch [11000/20000], Loss: 0.0777
Epoch [11100/20000], Loss: 0.0773
Epoch [11200/20000], Loss: 0.0769
Epoch [11300/20000], Loss: 0.0766
Epoch [11400/20000], Loss: 0.0762
Epoch [11500/20000], Loss: 0.0758
Epoch [11600/20000], Loss: 0.0755
Epoch [11700/20000], Loss: 0.0751
Epoch [11800/20000], Loss: 0.0748
Epoch [11900/20000], Loss: 0.0745
Epoch [12000/20000], Loss: 0.0741
Epoch [12100/20000], Loss: 0.0738
Epoch [12200/20000], Loss: 0.0735
Epoch [12300/20000], Loss: 0.0732
Epoch [12400/20000], Loss: 0.0729
Epoch [12500/20000], Loss: 0.0726
Epoch [12600/20000], Loss: 0.0723
Epoch [12700/20000], Loss: 0.0721
Epoch [12800/20000], Loss: 0.0718
Epoch [12900/20000], Loss: 0.0715
Epoch [13000/20000], Loss: 0.0712
Epoch [13100/20000], Loss: 0.0710
Epoch [13200/20000], Loss: 0.0707
Epoch [13300/20000], Loss: 0.0705
Epoch [13400/20000], Loss: 0.0702
Epoch [13500/20000], Loss: 0.0700
Epoch [13600/20000], Loss: 0.0698
Epoch [13700/20000], Loss: 0.0695
Epoch [13800/20000], Loss: 0.0693
Epoch [13900/20000], Loss: 0.0691
Epoch [14000/20000], Loss: 0.0688
Epoch [14100/20000], Loss: 0.0686
Epoch [14200/20000], Loss: 0.0684
Epoch [14300/20000], Loss: 0.0682
Epoch [14400/20000], Loss: 0.0680
Epoch [14500/20000], Loss: 0.0678
Epoch [14600/20000], Loss: 0.0676
Epoch [14700/20000], Loss: 0.0674
Epoch [14800/20000], Loss: 0.0672
Epoch [14900/20000], Loss: 0.0670
Epoch [15000/20000], Loss: 0.0668
Epoch [15100/20000], Loss: 0.0667
Epoch [15200/20000], Loss: 0.0665
Epoch [15300/20000], Loss: 0.0663
Epoch [15400/20000], Loss: 0.0661
Epoch [15500/20000], Loss: 0.0659
Epoch [15600/20000], Loss: 0.0658
Epoch [15700/20000], Loss: 0.0656
Epoch [15800/20000], Loss: 0.0654
Epoch [15900/20000], Loss: 0.0653
Epoch [16000/20000], Loss: 0.0651
Epoch [16100/20000], Loss: 0.0650
Epoch [16200/20000], Loss: 0.0648
Epoch [16300/20000], Loss: 0.0647
Epoch [16400/20000], Loss: 0.0645
Epoch [16500/20000], Loss: 0.0644
Epoch [16600/20000], Loss: 0.0642
Epoch [16700/20000], Loss: 0.0641
Epoch [16800/20000], Loss: 0.0639
Epoch [16900/20000], Loss: 0.0638
Epoch [17000/20000], Loss: 0.0637
Epoch [17100/20000], Loss: 0.0635
Epoch [17200/20000], Loss: 0.0634
Epoch [17300/20000], Loss: 0.0633
Epoch [17400/20000], Loss: 0.0631
Epoch [17500/20000], Loss: 0.0630
Epoch [17600/20000], Loss: 0.0629
Epoch [17700/20000], Loss: 0.0627
Epoch [17800/20000], Loss: 0.0626
Epoch [17900/20000], Loss: 0.0625
Epoch [18000/20000], Loss: 0.0624
Epoch [18100/20000], Loss: 0.0623
Epoch [18200/20000], Loss: 0.0621
Epoch [18300/20000], Loss: 0.0620
Epoch [18400/20000], Loss: 0.0619
Epoch [18500/20000], Loss: 0.0618
Epoch [18600/20000], Loss: 0.0617
Epoch [18700/20000], Loss: 0.0616
Epoch [18800/20000], Loss: 0.0615
Epoch [18900/20000], Loss: 0.0614
Epoch [19000/20000], Loss: 0.0613
Epoch [19100/20000], Loss: 0.0612
Epoch [19200/20000], Loss: 0.0610
Epoch [19300/20000], Loss: 0.0609
Epoch [19400/20000], Loss: 0.0608
Epoch [19500/20000], Loss: 0.0607
Epoch [19600/20000], Loss: 0.0606
Epoch [19700/20000], Loss: 0.0605
Epoch [19800/20000], Loss: 0.0605
Epoch [19900/20000], Loss: 0.0604
Epoch [20000/20000], Loss: 0.0603
如果你重新運行上面這段訓練循環,模型參數、優化器狀態和梯度會繼續保留,導致訓練結果疊加,模型參數和優化器狀態(如動量、學習率等)不會被重置。這會導致訓練從之前的狀態繼續,而不是從頭開始
3. 可視化結果
import matplotlib.pyplot as plt
# 可視化損失曲線
plt.plot(range(num_epochs), losses)
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.title('Training Loss over Epochs')
plt.show()
六、通俗解釋
1. 環境安裝(相當于買鍋碗瓢盆)??
- ??PyTorch??:就像買了一套廚房工具,用來“炒菜”(訓練模型)。
- ??CUDA??:如果電腦有NVIDIA顯卡(比如游戲本),可以加速“炒菜”速度,相當于用高壓鍋。
- ??檢查顯卡??:打開電腦的“工具箱”(命令行),輸入
nvidia-smi
,看看有沒有“高壓鍋”能用。
2. 數據準備(洗菜切菜)??
- ??鳶尾花數據集??:就像你有三種不同顏色的花(Setosa、Versicolor、Virginica),每朵花有四個特征(花瓣長度、寬度等)。
- ??數據分割??:把花分成兩堆,一堆用來“學做菜”(訓練集),另一堆用來“考試”(測試集)。
- ??歸一化??:把花的特征數據“調音量”,比如把花瓣長度從0-3cm變成0-1的比例,避免某些特征太大影響模型。
3. 模型定義(設計菜譜)??
- ??MLP模型??:就是一個“做菜流程”,比如:
- ??第一層(洗菜+切菜)??:輸入4個特征(花瓣、萼片數據),經過10個“小幫手”(神經元)處理。
- ??激活函數(ReLU)??:像“過濾器”,只保留重要的信息(比如過濾掉不新鮮的花)。
- ??第二層(炒菜)??:把處理后的信息交給3個“大廚”(神經元),輸出三個概率(預測是哪種花)。
# 代碼比喻:定義菜譜
class MLP(nn.Module):def __init__(self):super().__init__()self.layer1 = nn.Linear(4, 10) # 輸入4個特征,輸出10個中間結果self.layer2 = nn.Linear(10, 3) # 輸入10個中間結果,輸出3種花的概率
??4. 訓練過程(炒菜實操)??
(1)損失函數(老師的評分)??
- ??交叉熵損失??:老師會根據你的預測打分,比如你猜是Setosa(概率0.8),但實際是Versicolor,老師會扣分。
(2)優化器(調整火候)??
- ??SGD(手動翻炒)??:每次根據老師評分調整火候(學習率),比如火候太大會燒焦(參數更新太大),太小炒不熟(收斂慢)。
- ??Adam(自動翻炒)??:更智能的火候調整,適合新手。
(3)訓練循環(重復炒菜)??
- ??前向傳播??:把菜放進鍋里炒(輸入數據經過模型)。
- ??反向傳播??:根據老師評分,分析哪里炒糊了(計算梯度)。
- ??參數更新??:調整鹽、油量(模型參數),讓下次炒菜更好吃。
# 代碼比喻:炒菜過程
for epoch in range(20000):outputs = model(X_train) # 把菜放進鍋里炒loss = criterion(outputs, y_train) # 老師打分optimizer.zero_grad() # 清空鍋里的油(梯度清零)loss.backward() # 分析為什么難吃(反向傳播)optimizer.step() # 調整火候(更新參數)
??5. 評估與可視化(考試和總結)??
- ??測試集??:用沒炒過的菜(測試集)考驗模型,看能對幾道題(準確率)。
- ??損失曲線??:畫一張“扣分趨勢圖”,如果扣分越來越少,說明越炒越好。
6. ??通俗總結??
- ??神經網絡??:就是一個“自動炒菜機器人”,通過不斷試錯(訓練),學會根據食材特征(花瓣長度)判斷菜品類型(花的種類)。
- ??關鍵點??:
- ??數據要干凈??(歸一化):就像洗菜要洗干凈。
- ??模型要設計合理??:就像菜譜步驟不能亂。
- ??訓練要有耐心??:炒菜要反復調整火候。
7. 類比問答??
-
??Q:為什么需要激活函數???
A:防止模型變成“只會背答案的笨學生”,比如不管輸入什么,都輸出同樣的結果。激活函數讓模型學會“思考”(引入非線性)。 -
??Q:為什么用GPU???
A:GPU就像有100個廚師同時炒菜,速度飛快。CPU只有一個廚師,適合慢慢做精致菜品(簡單計算)。 -
??Q:為什么標簽要是Long類型???
A:因為模型需要明確知道“正確答案是數字0、1、2”,而不是浮點數(比如0.0、1.0)。