一、前言

在上一篇筆記《【Pytorch】整體工作流程代碼詳解（新手入門）》中介紹了Pytorch的整體工作流程，本文繼續(xù)說明如何使用Pytorch搭建卷積神經(jīng)網(wǎng)絡(luò)（CNN模型）來給圖像分類。

其他相關(guān)文章：
深度學(xué)習(xí)入門筆記：總結(jié)了一些神經(jīng)網(wǎng)絡(luò)的基礎(chǔ)概念。
TensorFlow專欄：《計算機(jī)視覺入門系列》介紹如何用TensorFlow框架實(shí)現(xiàn)卷積分類器。

二、CNN可視化解釋器

卷積分類器，是通過將導(dǎo)入的圖片，一層層篩選、過濾、學(xué)習(xí)圖形的特征，最后實(shí)現(xiàn)對輸入數(shù)據(jù)的分類、識別或預(yù)測。

下面是github上一個CNN可交互的可視化解釋器（ 鏈接在此）。

從上面的全局圖可見，CNN模型由多個卷積層和池化層交替堆疊而成，圖片被進(jìn)行了不同的處理，每一層都被提取出了不同的特征，最終將每個單元的輸出匯總，輸出分類。

1. 卷積層工作原理

相當(dāng)于是有一個濾鏡格子（叫做卷積核或者濾波器），從左到右、從上至下地掃描整個輸入圖層，并生成新的圖層。

整個過程中會壓縮數(shù)據(jù)，如下圖所示，將一個3*3 的圖形，壓縮成一個格子。

參數(shù)說明
Input輸入數(shù)據(jù)，中間是一個44的格子
Padding, 外面加的一圈格子，加一個單元。
Kernel Size卷積核大?。哼@里是33 ，左手邊的紅格子
Stride 步長：卷積核每次走多少格子

三、詳細(xì)步驟說明

1. 數(shù)據(jù)集準(zhǔn)備

import torch
from torch import nn
import torchvision
from torchvision import datasets
from torchvision.transforms import ToTensor
import matplotlib.pyplot as plt
print(f"Pytorch version:{torch.__version__}\n torchvision version:{torchvision.__version__}")

數(shù)據(jù)集介紹：
FashionMNIST是torchvision自帶的一個圖像數(shù)據(jù)集，用于機(jī)器學(xué)習(xí)和計算機(jī)視覺的訓(xùn)練和測試。它包含了10個不同類別的服裝物品的灰度圖像，包括T恤、褲子、套衫、裙子、外套、涼鞋、襯衫、運(yùn)動鞋、包和短靴。每張圖片的分辨率是28x28像素。

train_data=datasets.FashionMNIST(
    root="data",
    train=True,
    download=True,
    transform=ToTensor(),
    target_transform=None
)

test_data=datasets.FashionMNIST(
    root="data",
    train=False,
    download=True,
    transform=ToTensor(),
    target_transform=None
)

#數(shù)據(jù)集查看
image, label = train_data[0]
# image, label #查看第一條訓(xùn)練數(shù)據(jù)
image.shape  #查看數(shù)據(jù)的形狀

圖像張量的形狀是[1, 28, 28]，或者說：[顏色=1，高度=28，寬度=28]

# 查看類別
class_names = train_data.classes
class_names

#圖形可視化
import matplotlib.pyplot as plt
image, label = train_data[0]
print(f"Image shape: {image.shape}")
plt.imshow(image.squeeze()) 
plt.title(label);

2.DataLoader

from torch.utils.data import DataLoader

# 設(shè)置批處理大小超參數(shù)
BATCH_SIZE = 32

# 將數(shù)據(jù)集轉(zhuǎn)換為可迭代的（批處理）
train_dataloader = DataLoader(train_data,
    batch_size=BATCH_SIZE,  # 每個批次有多少樣本？
    shuffle=True  # 是否隨機(jī)打亂？
)

test_dataloader = DataLoader(test_data,
    batch_size=BATCH_SIZE,
    shuffle=False  # 測試數(shù)據(jù)集不一定需要洗牌
)

#打印結(jié)果
print(f"Dataloaders: {train_dataloader, test_dataloader}")
print(f"Length of train dataloader: {len(train_dataloader)} batches of {BATCH_SIZE}")
print(f"Length of test dataloader: {len(test_dataloader)} batches of {BATCH_SIZE}")

參數(shù)介紹：
shuffle：指對數(shù)據(jù)集進(jìn)行隨機(jī)打亂，以便在訓(xùn)練模型時以隨機(jī)順序呈現(xiàn)數(shù)據(jù)。這樣做有助于提高模型的泛化能力并減少模型對輸入數(shù)據(jù)順序的依賴性。相反，對于測試數(shù)據(jù)集通常被設(shè)置為False，因?yàn)樵谠u估模型性能時，我們希望保持?jǐn)?shù)據(jù)的原始順序，以便能夠正確評估模型在真實(shí)數(shù)據(jù)上的表現(xiàn)。

train_features_batch, train_labels_batch = next(iter(train_dataloader))
train_features_batch.shape, train_labels_batch.shape

3. 搭建模型CNN

3.1 設(shè)置設(shè)備

import torch
device = "cuda" if torch.cuda.is_available() else "cpu"
device

在GPU上跑。

3.2 搭建CNN模型

回顧一下CNN的參數(shù)設(shè)置：

1. in_channels：輸入數(shù)據(jù)的通道數(shù)，對于二維卷積，表示輸入圖像或特征圖的深度或通道數(shù)。
2. out_channels：輸出的通道數(shù)，即卷積核的數(shù)量。每個卷積核生成一個輸出通道。
3. kernel_size：卷積核的大小或?yàn)V波器的大小，用整數(shù)或元組表示，指定了卷積核的高度和寬度。kernel_size=3意味著卷積核的高度和寬度均為3。
4. stride：卷積核滑動的步長，決定卷積核在輸入數(shù)據(jù)上滑動的距離。stride=1表示卷積核在輸入上每次滑動1個步長。
5. padding：在輸入數(shù)據(jù)周圍填充0的層數(shù)。填充有助于保持輸入和輸出尺寸相同，特別是在卷積層之間傳遞信息時。這里的padding=1表示在輸入數(shù)據(jù)周圍填充一層0，以保持卷積操作后尺寸不變。

# Create a convolutional neural network
class FashionMNISTModelV2(nn.Module):
    def __init__(self, input_shape: int, hidden_units: int, output_shape: int):
        super().__init__()
        self.block_1 = nn.Sequential(
            nn.Conv2d(in_channels=input_shape,
                      out_channels=hidden_units,
                      kernel_size=3, 
                      stride=1,
                      padding=1),
            nn.ReLU(),
            nn.Conv2d(in_channels=hidden_units,
                      out_channels=hidden_units,
                      kernel_size=3,
                      stride=1,
                      padding=1),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2,
                         stride=2) 
        )
        self.block_2 = nn.Sequential(
            nn.Conv2d(hidden_units, hidden_units, 3, padding=1),
            nn.ReLU(),
            nn.Conv2d(hidden_units, hidden_units, 3, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(2)
        )
        self.classifier = nn.Sequential(
            nn.Flatten(),
            nn.Linear(in_features=hidden_units*7*7,
                      out_features=output_shape)
        )

    def forward(self, x: torch.Tensor):
        x = self.block_1(x)
        # print(x.shape)
        x = self.block_2(x)
        # print(x.shape)
        x = self.classifier(x)
        # print(x.shape)
        return x

# 加入?yún)?shù)
torch.manual_seed(42)
model_2 = FashionMNISTModelV2(input_shape=1,
    hidden_units=10,
    output_shape=len(class_names)).to(device)
model_2

3.3 設(shè)置loss 和 optimizer

導(dǎo)入accurcay_fn輔助函數(shù)文件

import requests
from pathlib import Path

# 從Learn PyTorch存儲庫中下載輔助函數(shù)（如果尚未下載）
if Path("helper_functions.py").is_file():
  print("helper_functions.py已存在，跳過下載")
else:
  print("正在下載helper_functions.py")
  # 注意：你需要使用"raw" GitHub URL才能使其工作
  request = requests.get("https://raw.githubusercontent.com/mrdbourke/pytorch-deep-learning/main/helper_functions.py")
  with open("helper_functions.py", "wb") as f:
    f.write(request.content)

創(chuàng)建loss、accuracy和optimizer

from helper_functions import accuracy_fn

# 設(shè)置loss和optimizer
loss_fn = nn.CrossEntropyLoss() # this is also called "criterion"/"cost function" in some places
optimizer = torch.optim.SGD(params=model_0.parameters(), lr=0.1)

創(chuàng)建一個計時器

from timeit import default_timer as timer
def print_train_time(start:float,end:float,device:torch.device=None):
  total_time=end-start
  print(f"Train time on {device}: {total_time:.3f} seconds")
  return total_time

3.4 訓(xùn)練和測試循環(huán)

def train_step(model: torch.nn.Module,
               data_loader: torch.utils.data.DataLoader,
               loss_fn: torch.nn.Module,
               optimizer: torch.optim.Optimizer,
               accuracy_fn,
               device: torch.device = device):
    train_loss, train_acc = 0, 0
    model.to(device)
    for batch, (X, y) in enumerate(data_loader):
        X, y = X.to(device), y.to(device)
        y_pred = model(X)
        loss = loss_fn(y_pred, y)
        train_loss += loss
        train_acc += accuracy_fn(y_true=y,
                                 y_pred=y_pred.argmax(dim=1))
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

    train_loss /= len(data_loader)
    train_acc /= len(data_loader)
    print(f"Train loss: {train_loss:.5f} | Train accuracy: {train_acc:.2f}%")

def test_step(data_loader: torch.utils.data.DataLoader,
              model: torch.nn.Module,
              loss_fn: torch.nn.Module,
              accuracy_fn,
              device: torch.device = device):
    test_loss, test_acc = 0, 0
    model.to(device)
    model.eval() # put model in eval mode
    # Turn on inference context manager
    with torch.inference_mode():
        for X, y in data_loader:
            X, y = X.to(device), y.to(device)
            test_pred = model(X)

            test_loss += loss_fn(test_pred, y)
            test_acc += accuracy_fn(y_true=y,
                y_pred=test_pred.argmax(dim=1) # Go from logits -> pred labels
            )
        test_loss /= len(data_loader)
        test_acc /= len(data_loader)
        print(f"Test loss: {test_loss:.5f} | Test accuracy: {test_acc:.2f}%\n")

torch.manual_seed(42)

from timeit import default_timer as timer
train_time_start_model_2 = timer()

epochs = 3
for epoch in tqdm(range(epochs)):
    print(f"Epoch: {epoch}\n---------")
    train_step(data_loader=train_dataloader,
        model=model_2,
        loss_fn=loss_fn,
        optimizer=optimizer,
        accuracy_fn=accuracy_fn,
        device=device
    )
    test_step(data_loader=test_dataloader,
        model=model_2,
        loss_fn=loss_fn,
        accuracy_fn=accuracy_fn,
        device=device
    )

train_time_end_model_2 = timer()
total_train_time_model_2 = print_train_time(start=train_time_start_model_2,
                                           end=train_time_end_model_2,
                                           device=device)

4. 模型評估和結(jié)果輸出

torch.manual_seed(42)
def eval_model(model: torch.nn.Module,
               data_loader: torch.utils.data.DataLoader,
               loss_fn: torch.nn.Module,
               accuracy_fn,
               device: torch.device = device):  #注意
    loss, acc = 0, 0
    model.eval()
    with torch.inference_mode():
        for X, y in data_loader:
            #注意設(shè)備轉(zhuǎn)移
            X, y = X.to(device), y.to(device)
            y_pred = model(X)
            loss += loss_fn(y_pred, y)
            acc += accuracy_fn(y_true=y, y_pred=y_pred.argmax(dim=1))

        
        loss /= len(data_loader)
        acc /= len(data_loader)
    return {"model_name": model.__class__.__name__, 
            "model_loss": loss.item(),
            "model_acc": acc}


model_2_results = eval_model(
    model=model_2,
    data_loader=test_dataloader,
    loss_fn=loss_fn,
    accuracy_fn=accuracy_fn
)
model_2_results

模型輸出結(jié)果：
文章來源地址http://www.zghlxwxcb.cn/news/detail-745486.html

到了這里，關(guān)于【Pytorch】計算機(jī)視覺項(xiàng)目——卷積神經(jīng)網(wǎng)絡(luò)CNN模型識別圖像分類的文章就介紹完了。如果您還想了解更多內(nèi)容，請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！