• 🍨 本文為🔗365天深度學習訓練營 中的學習記錄博客
• 🍖 原作者：K同學啊 | 接輔導、項目定制

---

前言

本文將采用pytorch框架創建CNN網絡，實現簡單彩色圖片分類。講述實現代碼與執行結果，并淺談涉及知識點。
關鍵字： torch.nn常用網絡層Conv2d、Linear和MaxPool2d詳解,torch.nn網絡訓練相關函數optimizer.zero_grad()、loss.backward()、optimizer.step()詳解, opencv、matplotlib、pillow和pytorch讀取數據的通道順序。

1 我的環境

• 電腦系統：Windows 11
• 語言環境：python 3.8.6
• 編譯器：pycharm2020.2.3
• 深度學習環境：
  torch == 1.9.1+cu111
  torchvision == 0.10.1+cu111
• 顯卡：NVIDIA GeForce RTX 4070

2 代碼實現與執行結果

2.1 前期準備

2.1.1 引入庫

import torch
import torch.nn as nn
import matplotlib.pyplot as plt
plt.rcParams['font.sans-serif'] = ['SimHei']  # 用來正常顯示中文標簽
plt.rcParams['axes.unicode_minus'] = False  # 用來正常顯示負號
plt.rcParams['figure.dpi'] = 100  # 分辨率
import torchvision
import numpy as np
from torchinfo import summary
import torch.nn.functional as F
import warningswarnings.filterwarnings('ignore')  # 忽略一些warning內容，無需打印

2.1.2 設置GPU（如果設備上支持GPU就使用GPU,否則使用CPU）

"""前期準備-設置GPU-"""
# 如果設備上支持GPU就使用GPU,否則使用CPU
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(device)

輸出

cuda

2.1.3 導入數據

'''前期工作-導入數據'''
train_ds = torchvision.datasets.CIFAR10('data',train=True,transform=torchvision.transforms.ToTensor(), # 將數據類型轉化為Tensordownload=True)test_ds  = torchvision.datasets.CIFAR10('data',train=False,transform=torchvision.transforms.ToTensor(), # 將數據類型轉化為Tensordownload=True)
batch_size = 32train_dl = torch.utils.data.DataLoader(train_ds, batch_size=batch_size, shuffle=True)test_dl  = torch.utils.data.DataLoader(test_ds, batch_size=batch_size)

2.1.4 查看數據

'''前期工作-查看數據'''                                       
# 取一個批次查看數據格式
# 數據的shape為：[batch_size, channel, height, weight]
# 其中batch_size為自己設定，channel，height和weight分別是圖片的通道數，高度和寬度。
imgs, labels = next(iter(train_dl))  # 通過 iter(train_dl) 創建一個數據迭代器，然后使用 next(train_dl) 從訓練數據加載一個批次的圖像和對應的標簽。
# images包含了一批圖像，labels 包含了這些圖像的類別標簽。
print(imgs.shape)

輸出

torch.Size([32, 1, 28, 28])

2.1.5.數據可視化

'''前期工作-數據可視化'''
# 指定圖片大小，圖像大小為20寬、5高的繪圖(單位為英寸inch)
plt.figure(figsize=(20, 5))
for i, img in enumerate(imgs[:20]):npimg = img.numpy().transpose((1, 2, 0))# 轉換圖像的數組格式 ： transpose (C, H, W) -> (H, W, C)# 將整個figure分成2行10列，繪制第i+1個子圖。plt.subplot(2, 10, i + 1)plt.imshow(npimg)plt.axis('off')plt.show()  #如果你使用的是Pycharm編譯器，請加上這行代碼

2.2 構建CNN網絡模型

"""構建CNN網絡"""num_classes = 10  # 圖片的類別數class Model(nn.Module):def __init__(self):super().__init__()# 特征提取網絡self.conv1 = nn.Conv2d(3, 64, kernel_size=3)  # 第一層卷積,卷積核大小為3*3self.pool1 = nn.MaxPool2d(kernel_size=2)  # 設置池化層，池化核大小為2*2self.conv2 = nn.Conv2d(64, 64, kernel_size=3)  # 第二層卷積,卷積核大小為3*3self.pool2 = nn.MaxPool2d(kernel_size=2)self.conv3 = nn.Conv2d(64, 128, kernel_size=3)  # 第二層卷積,卷積核大小為3*3self.pool3 = nn.MaxPool2d(kernel_size=2)# 分類網絡self.fc1 = nn.Linear(512, 256)self.fc2 = nn.Linear(256, num_classes)# 前向傳播def forward(self, x):x = self.pool1(F.relu(self.conv1(x)))x = self.pool2(F.relu(self.conv2(x)))x = self.pool3(F.relu(self.conv3(x)))x = torch.flatten(x, start_dim=1)x = F.relu(self.fc1(x))x = self.fc2(x)return x# 將模型轉移到GPU中（我們模型運行均在GPU中進行）
model = Model().to(device)
summary(model)

輸出

=================================================================
Layer (type:depth-idx)                   Param #
=================================================================
Model                                    --
├─Conv2d: 1-1                            1,792
├─MaxPool2d: 1-2                         --
├─Conv2d: 1-3                            36,928
├─MaxPool2d: 1-4                         --
├─Conv2d: 1-5                            73,856
├─MaxPool2d: 1-6                         --
├─Linear: 1-7                            131,328
├─Linear: 1-8                            2,570
=================================================================
Total params: 246,474
Trainable params: 246,474
Non-trainable params: 0
=================================================================

2.3 訓練模型

2.3.1 訓練模型

"""訓練模型--設置超參數"""
loss_fn = nn.CrossEntropyLoss()  # 創建損失函數，計算實際輸出和真實相差多少，交叉熵損失函數，事實上，它就是做圖片分類任務時常用的損失函數
learn_rate = 1e-2  # 學習率
opt = torch.optim.SGD(model.parameters(), lr=learn_rate)  # 作用是定義優化器，用來訓練時候優化模型參數；其中，SGD表示隨機梯度下降，用于控制實際輸出y與真實y之間的相差有多大

2.3.2 編寫訓練函數

"""訓練模型--編寫訓練函數"""
# 訓練循環
def train(dataloader, model, loss_fn, optimizer):size = len(dataloader.dataset)  # 訓練集的大小，一共60000張圖片num_batches = len(dataloader)  # 批次數目，1875（60000/32）train_loss, train_acc = 0, 0  # 初始化訓練損失和正確率for X, y in dataloader:  # 加載數據加載器，得到里面的 X（圖片數據）和 y（真實標簽）X, y = X.to(device), y.to(device) # 用于將數據存到顯卡# 計算預測誤差pred = model(X)  # 網絡輸出loss = loss_fn(pred, y)  # 計算網絡輸出和真實值之間的差距，targets為真實值，計算二者差值即為損失# 反向傳播optimizer.zero_grad()  # 清空過往梯度loss.backward()  # 反向傳播，計算當前梯度optimizer.step()  # 根據梯度更新網絡參數# 記錄acc與losstrain_acc += (pred.argmax(1) == y).type(torch.float).sum().item()train_loss += loss.item()train_acc /= sizetrain_loss /= num_batchesreturn train_acc, train_loss

2.3.3 編寫測試函數

"""訓練模型--編寫測試函數"""
# 測試函數和訓練函數大致相同，但是由于不進行梯度下降對網絡權重進行更新，所以不需要傳入優化器
def test(dataloader, model, loss_fn):size = len(dataloader.dataset)  # 測試集的大小，一共10000張圖片num_batches = len(dataloader)  # 批次數目，313（10000/32=312.5，向上取整）test_loss, test_acc = 0, 0# 當不進行訓練時，停止梯度更新，節省計算內存消耗with torch.no_grad(): # 測試時模型參數不用更新，所以 no_grad，整個模型參數正向推就ok，不反向更新參數for imgs, target in dataloader:imgs, target = imgs.to(device), target.to(device)# 計算losstarget_pred = model(imgs)loss = loss_fn(target_pred, target)test_loss += loss.item()test_acc += (target_pred.argmax(1) == target).type(torch.float).sum().item()#統計預測正確的個數test_acc /= sizetest_loss /= num_batchesreturn test_acc, test_loss

2.3.4 正式訓練

"""訓練模型--正式訓練"""
epochs = 10
train_loss = []
train_acc = []
test_loss = []
test_acc = []for epoch in range(epochs):model.train()epoch_train_acc, epoch_train_loss = train(train_dl, model, loss_fn, opt)model.eval()epoch_test_acc, epoch_test_loss = test(test_dl, model, loss_fn)train_acc.append(epoch_train_acc)train_loss.append(epoch_train_loss)test_acc.append(epoch_test_acc)test_loss.append(epoch_test_loss)template = ('Epoch:{:2d}, Train_acc:{:.1f}%, Train_loss:{:.3f}, Test_acc:{:.1f}%，Test_loss:{:.3f}')print(template.format(epoch + 1, epoch_train_acc * 100, epoch_train_loss, epoch_test_acc * 100, epoch_test_loss))
print('Done')

輸出

Epoch: 1, Train_acc:13.6%, Train_loss:2.263, Test_acc:22.1%，Test_loss:2.085
Epoch: 2, Train_acc:25.5%, Train_loss:2.003, Test_acc:29.4%，Test_loss:1.921
Epoch: 3, Train_acc:33.6%, Train_loss:1.808, Test_acc:32.6%，Test_loss:1.931
Epoch: 4, Train_acc:40.4%, Train_loss:1.630, Test_acc:41.6%，Test_loss:1.627
Epoch: 5, Train_acc:44.5%, Train_loss:1.527, Test_acc:45.4%，Test_loss:1.540
Epoch: 6, Train_acc:47.9%, Train_loss:1.441, Test_acc:49.7%，Test_loss:1.384
Epoch: 7, Train_acc:51.2%, Train_loss:1.355, Test_acc:51.3%，Test_loss:1.357
Epoch: 8, Train_acc:54.2%, Train_loss:1.283, Test_acc:53.7%，Test_loss:1.291
Epoch: 9, Train_acc:57.0%, Train_loss:1.212, Test_acc:57.4%，Test_loss:1.202
Epoch:10, Train_acc:59.0%, Train_loss:1.159, Test_acc:55.5%，Test_loss:1.251
Done

2.4 結果可視化

"""訓練模型--結果可視化"""
epochs_range = range(epochs)plt.figure(figsize=(12, 3))
plt.subplot(1, 2, 1)plt.plot(epochs_range, train_acc, label='Training Accuracy')
plt.plot(epochs_range, test_acc, label='Test Accuracy')
plt.legend(loc='lower right')
plt.title('Training and Validation Accuracy')plt.subplot(1, 2, 2)
plt.plot(epochs_range, train_loss, label='Training Loss')
plt.plot(epochs_range, test_loss, label='Test Loss')
plt.legend(loc='upper right')
plt.title('Training and Validation Loss')
plt.show()

3 知識點詳解

3.1 torch.nn常用網絡層Conv2d、Linear和MaxPool2d詳解

3.1.1 torch.nn.Conv2d()詳解

函數原型：
torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True, padding_mode=‘zeros’, device=None, dtype=None)
關鍵參數說明：
in_channels ( int ) – 輸入圖像中的通道數
out_channels ( int ) – 卷積產生的通道數
kernel_size ( int or tuple ) – 卷積核的大小
stride ( int or tuple , optional ) – 卷積的步幅。默認值：1
padding ( int , tuple或str , optional ) – 添加到輸入的所有四個邊的填充。默認值：0
dilation (int or tuple, optional) - 擴張操作：控制kernel點（卷積核點）的間距，默認值:1。
padding_mode (字符串,可選) – ‘zeros’, ‘reflect’, ‘replicate’或’circular’. 默認：‘zeros’
關于dilation參數圖解：

3.1.2 torch.nn.Linear()詳解

函數原型：
torch.nn.Linear(in_features, out_features, bias=True, device=None, dtype=None)
關鍵參數說明：
in_features：每個輸入樣本的大小
out_features：每個輸出樣本的大小

3.1.3 torch.nn.MaxPool2d()詳解

函數原型：
torch.nn.MaxPool2d(kernel_size, stride=None, padding=0, dilation=1, return_indices=False, ceil_mode=False)
關鍵參數說明：
kernel_size：最大的窗口大小
stride：窗口的步幅，默認值為kernel_size
padding：填充值，默認為0
dilation：控制窗口中元素步幅的參數

3.1.4. 關于卷積層、池化層的計算：

下面的網絡數據shape變化過程為：
3, 32, 32（輸入數據）
-> 64, 30, 30（經過卷積層1）-> 64, 15, 15（經過池化層1）
-> 64, 13, 13（經過卷積層2）-> 64, 6, 6（經過池化層2）
-> 128, 4, 4（經過卷積層3） -> 128, 2, 2（經過池化層3）
-> 512 -> 256 -> num_classes(10)
參看文章深度學習CNN網絡–卷積層、池化層、全連接層詳解與其參數量計算可手動推導這個過程。
網絡結構圖（可單擊放大查看）：

3.2. torch.nn網絡訓練相關函數optimizer.zero_grad()、loss.backward()、optimizer.step()詳解

3.2.1 optimizer.zero_grad()

函數會遍歷模型的所有參數，通過內置方法截斷反向傳播的梯度流，再將每個參數的梯度值設為0，即上一次的梯度記錄被清空。

3.2.2 loss.backward()

PyTorch的反向傳播(即tensor.backward())是通過autograd包來實現的，autograd包會根據tensor進行過的數學運算來自動計算其對應的梯度。

具體來說，torch.tensor是autograd包的基礎類，如果你設置tensor的requires_grads為True，就會開始跟蹤這個tensor上面的所有運算，如果你做完運算后使用tensor.backward()，所有的梯度就會自動運算，tensor的梯度將會累加到它的.grad屬性里面去。

更具體地說，損失函數loss是由模型的所有權重w經過一系列運算得到的，若某個w的requires_grads為True，則w的所有上層參數（后面層的權重w）的.grad_fn屬性中就保存了對應的運算，然后在使用loss.backward()后，會一層層的反向傳播計算每個w的梯度值，并保存到該w的.grad屬性中。

如果沒有進行tensor.backward()的話，梯度值將會是None，因此loss.backward()要寫在optimizer.step()之前。

3.2.3 optimizer.step()

step()函數的作用是執行一次優化步驟，通過梯度下降法來更新參數的值。因為梯度下降是基于梯度的，所以在執行optimizer.step()函數前應先執行loss.backward()函數來計算梯度。

注意：optimizer只負責通過梯度下降進行優化，而不負責產生梯度，梯度是tensor.backward()方法產生的。

3.3 opencv、matplotlib、pillow和pytorch讀取數據的通道順序

• opencv(imread,imshow)：uint8的ndarray數據，通道順序hwc，顏色通道BGR。
• matplotlib(imread,imshow)：uint8的ndarray數據，通道順序hwc，顏色通道RGB。
• pillow(open,show)：自己的數據結構。可以np.array(image)轉換成numpy數組：uint8的ndarray數據，通道順序hwc，顏色通道RGB。可以Image.fromarray(image)將numpy數組類型轉化為pillow類型。
• pythorch(torchvision.datasets、torch.utils.data.DataLoader及torchvision.io.read_image)：ToTensor()到[0, 1]的torch數據，通道順序nchw，顏色通道RGB，查看圖片方法及ToPILImage。

總結：除了pytorch得到的是nchw圖片，其余方法得到的都是hwc圖片；除了cv2得到的c是bgr圖片，其余方法得到的c都是rgb圖片；plt.imshow()既可以顯示（H,W）灰色圖片，也可以顯示(H,W,C=3)的numpy或torch類型的RGB圖片，但nhwc某批次里的圖片只能一張一張顯示.

總結

通過本文的學習，對torch.nn常用網絡層Conv2d、Linear和MaxPool2d有了更深的了解。