深度學習框架Pytorch學習筆記

由於工作原因，需要使用到深度學習pytorch框架，所以，跟隨影片學習了深度學習框架的使用方法，影片連結如下：

PyTorch深度學習快速入門教程（絕對通俗易懂！）【小土堆】_嗶哩嗶哩_bilibili

1、安裝pytorch

在windows下使用pytorch，首先找到anaconda官網，安裝64位windows版本，然後使用清華的源替換掉anaconda預設源，詳細教程如下(2條訊息) 【2022】保姆級Anaconda安裝與換國內源教程_anaconda換源_NoBug2022的部落格-CSDN部落格

開啟anaconda prompt

conda create -n your_env_name python=x.x

命令建立環境，可以使用

conda env list 

檢視當前已有的環境，來判斷環境是否建立成功

開啟Start Locally | PyTorch，選擇自己需要的pytorch版本，將Run this Command命令複製到自己控制檯，然後就可以等待pytorch自己安裝成功啦

 

 安裝完成後，在控制檯輸入

python
import torch
print(torch.__version__)

 

 輸出版本後，就表明安裝成功啦，當然，如果是GPU版本，還可以輸入

print (torch.cuda.is_available())

顯示TRUE就表示顯示卡加速也開啟了，就可以開啟我們的深度學習之路了。

ps：python中的兩個方便的函式 

　　dir()      顯示包中的方法

　　help()   顯示方法的具體幫助資訊

2、資料載入

 

 如圖所示，資料在變成Dataset的過程就是將雜亂的資料刨除和整理資料的過程，並且統計了資料的大小，而Dataset到Dataloader則是將整理過的資料按照設定大小進行打包的過程，最終Dataloader為深度學習直接提供需要的資料。

使用的示例程式碼如下：

from torch.utils.data import Dataset
from PIL import Image
import os

class myData(Dataset):
    def __init__(self, strRootDir, strLabelDir):
        self.mstrRootDir = strRootDir
        self.mstrLabelDir = strLabelDir
        self.mstrPath = os.path.join(strRootDir, strLabelDir)
        self.mstrImagePath = os.listdir(self.mstrPath)

    def __getitem__(self, item):
        strImageName = self.mstrImagePath[item]
        strImageItemPath = os.path.join(self.mstrPath, strImageName)
        zImage = Image.open(strImageItemPath)
        strLabel = self.mstrLabelDir
        return zImage, strLabel

    def __len__(self):
        return len(self.mstrImagePath)

strRootDir = "dateset/train"
strLabelAnts = "ants"
strLabelBees = "bees"
zAntsData = myData(strRootDir, strLabelAnts)
zBeesData = myData(strRootDir, strLabelBees)
zTrainData = zAntsData + zBeesData
print(len(zAntsData), len(zBeesData), len(zTrainData))

3、深度學習訓練工具

由於深學習過程太過抽象，無法直觀的檢視模型學習的程度，所以使用Tensorbard工具來檢視，在控制檯輸入

pip3 -install tensorbard

下載該工具，使用其中的SummaryWriter類的add_scalar和add_image方法就可以將資料進行圖表展示以及圖片的展示

示例程式如下：

from torch.utils.tensorboard import SummaryWriter
import numpy
from PIL import Image

wirter = SummaryWriter("logs")
PILImagePath = "dateset/train/ants/0013035.jpg"
PILImage = Image.open(PILImagePath)
ImageArray = numpy.array(PILImage)
wirter.add_image("ants", ImageArray, 1, dataformats='HWC')

for i in range(100):
    wirter.add_scalar("y = 2x", 2 * i, i)

wirter.close()

在控制檯輸入

tensorboard --logdir=你的日誌檔案位置

就可以檢視到如下的圖表

 

 4、圖形變換

圖形變換主要使用torchvision包中的Transforms包內的方法，有Resize、ToTensor等方法，可以使用Compose方法將所以操作合併為一個命令，要求方法間輸入與下一個方法的輸出一一對應。

5、資料集

在torchvision包中的dataset包提供了一些內建的資料集可以使用，將download設定為True將在程式執行時自動下載。

6、神經網路的結構

1、模型本體，需要建立一個nn.Module的子類作為深度學習模型的本體，需要自己根據模型結構實現自己的__init__方法和forward方法

class MyModel(nn.Module):

    def __init__(self):
        super(MyModel, self).__init__()
        self.model = nn.Sequential(
            # 卷積層1
            nn.Conv2d(3, 32, 5, 1, 2, ),
            # 池化層1
            nn.MaxPool2d(2),
            # 卷積層2
            nn.Conv2d(32, 32, 5, 1, 2),
            # 池化層2
            nn.MaxPool2d(2),
            # 卷積層3
            nn.Conv2d(32, 64, 5, 1, 2),
            # 池化層3
            nn.MaxPool2d(2),
            # 展平層
            nn.Flatten(),
            # 全連線層1
            nn.Linear(64 * 4 * 4, 64),
            # 全連線層2
            nn.Linear(64, 10)
        )

    def forward(self, x):
        """
        神經元向前傳播函式
        :param x: 輸入的引數
        :return: 輸出的引數
        """
        x = self.model(x)
        return x

一般將這個類寫入單獨的py檔案方便之後操作，並且一般在檔案末尾提供模型的自檢方法

# 神經網路模型測試
if __name__ == '__main__':
    funModel = MyModel()
    myInPut = torch.ones(64, 3, 32, 32)
    myOutPut = funModel(myInPut)
    print(myOutPut.shape)

2、卷積層

卷積層負責卷積操作，一般呼叫nn.conv2d方法

3、池化層

池化層的作用是在儘量保證特徵的同時減少資料量，一般卷積層後就會跟隨一個池化層，呼叫nn.MaxPool2d方法

4、非線性啟用層

非線性啟用主要是為了引入非線性特徵，一般使用的有nn.ReLU方法和Sigmoid方法

5、正則化層

正則化層主要目的是加快訓練速度，一般使用nn.BatchNorm2d方法

6、線性層

線性層也叫全連線層，主要是對資料進行線性組合，一般使用Linear方法，線上性層之前可以呼叫nn.Flatten方法對資料進行展平

7、可以使用nn.Sequential方法將網路各層方法合併為一個命令，需要保證輸出與下一個輸入的資料對應

8、損失函式和反向傳播

損失函式可以產生一個loss數，用來判斷模型特徵與實際資料之間的差異，並且對神經網路的反向傳播提供依據，一般使用nn.L1Loss方法或nn.MSELoss方法，計算出的loss值越小，越接近真實。

9、最佳化器

最佳化器內建了許多成熟的神經網路最佳化演算法，一般使用SGD方法，需要提供一個學習速率，最佳化前需要將之前最佳化器的偏移進行清空，使用zero_grad方法，然後將網路進行反向傳播填充偏移，隨後呼叫step方法進行神經網路最佳化

10、學習速率調整函式

為了得到更好的模型，往往隨著訓練次數增大，需要調整學習的速率，lr_scheduler包提供了調整學習速率的函式方法，使用step方法就可以進行速率調整，注意，這個step需要在最佳化器至少在之前執行了一次step

11、GPU訓練模型

可以使用GPU進行訓練加速的地方有資料，損失函式和模型。具體方法有兩種：

11.1、使用cuda方法將需要加速的地方放入gpu

11.2、使用to(device)方法將需要加速的地方放入gpu，如果需要寫cpu和gpu平臺通用的函式，可以把device裝置這樣寫：

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

7、訓練模型常用套路

訓練模型基本套路為：

1、設定裝置

2、載入資料集

3、新增日誌記錄者

4、計算資料集長度

5、利用dataloader載入資料集

6、建立網路模型

7、建立損失函式

8、設定最佳化器

9、設定學習衰減函式

10、設定訓練網路的一些引數

11、迴圈開始訓練和測試

12、儲存每一次訓練的模型

13、記錄者關閉

#!/usr/bin/env pytorch
# -*- coding: UTF-8 -*-
"""
@Project     :llearn_pytorch
@File        :model.py
@IDE         :PyCharm
@Author      :張世航
@Date        :2023/2/24 11:30
@Description :一個深度學習演示樣例
"""
import torchvision.datasets
from torch.optim import lr_scheduler, SGD
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter
from model import *
import time

# 設定裝置
zDevice = torch.device("cuda" if torch.cuda.is_available() else "cpu")

# 載入資料集
zTrainData = torchvision.datasets.CIFAR10("TrainData", train=True, transform=torchvision.transforms.ToTensor(),
                                          download=True)
zTestData = torchvision.datasets.CIFAR10("TestData", train=False, transform=torchvision.transforms.ToTensor(),
                                         download=True)

# 新增記錄者
writer = SummaryWriter("logs")

# 計算資料集長度
iTrainDataLength = len(zTrainData)
iTestDataLength = len(zTestData)
print("the length of train data :{}".format(iTrainDataLength))
print("the length of test data:{}".format(iTestDataLength))

# 利用dataloader載入資料集
zTraindataLoader = DataLoader(zTrainData, batch_size=64)
zTestDataLoader = DataLoader(zTestData, batch_size=64)

# 建立網路模型
myModel = MyModel()
myModel = myModel.to(zDevice)
# 建立損失函式
myLossFunction = nn.CrossEntropyLoss()
myLossFunction = myLossFunction.to(zDevice)
# 最佳化器
dLearnRate = 1e-2
myOptimizer = SGD(myModel.parameters(), lr=dLearnRate)
# 設定學習率衰減函式
MyScheduler = lr_scheduler.StepLR(myOptimizer, 50, gamma=0.5)

# 設定訓練網路的一些引數
# 訓練的總次數
iTotalTrainStep = 0
# 測試的總次數
iTotalTestStep = 0
# 訓練的輪數
iEpoch = 300

# 記錄開始時間
fStartTime = time.time()

for i in range(iEpoch):
    print("----第{}訓練開始！！!----".format(i))
    myModel.train()
    for data in zTraindataLoader:
        images, targets = data
        images = images.to(zDevice)
        targets = targets.to(zDevice)
        outputs = myModel(images)
        loss = myLossFunction(outputs, targets)
        # 最佳化器最佳化模型
        myOptimizer.zero_grad()
        loss.backward()
        myOptimizer.step()
        iTotalTrainStep = iTotalTrainStep + 1
        if iTotalTrainStep % 100 == 0:
            fEndTime = time.time()
            print("第{}次模型訓練loss是{}".format(iTotalTrainStep, loss.item()))
            writer.add_scalar("train_loss", loss.item(), iTotalTrainStep)
            print("訓練耗時{}".format(fEndTime - fStartTime))
    MyScheduler.step()
    print("----調整學習率為{}----".format(myOptimizer.state_dict()['param_groups'][0]['lr']))
    writer.add_scalar("train_lr", myOptimizer.state_dict()['param_groups'][0]['lr'], i)

    myModel.eval()
    iTotalLoss = 0
    iTotalAccuracy = 0
    print("----第{}測試開始！！!----".format(i))
    with torch.no_grad():
        for data in zTestDataLoader:
            images, targets = data
            images = images.to(zDevice)
            targets = targets.to(zDevice)
            outputs = myModel(images)
            loss = myLossFunction(outputs, targets)
            iTotalLoss = iTotalLoss + loss.item()
            accuracy = (outputs.argmax(1) == targets).sum()
            iTotalAccuracy = accuracy + iTotalAccuracy

    print("第{}次模型測試loss是{}".format(i, iTotalLoss))
    print("第{}次模型測試正確率是{}".format(i, iTotalAccuracy / iTestDataLength))
    writer.add_scalar("test_loss", iTotalLoss, iTotalTestStep)
    writer.add_scalar("test_accuracy", iTotalAccuracy / iTestDataLength, iTotalTestStep)
    iTotalTestStep = iTotalTestStep + 1

    # 儲存每一次訓練的模型
    torch.save(myModel.state_dict(), "model/model_{}.path".format(i))
    print("----模型已經儲存！！！----")

writer.close()

8、模型儲存和讀取方法

有兩種方法儲存和讀取訓練好的模型

1、使用torch.save和torch.load儲存和讀取整個模型

2、使用torch.save(model.state_dict(),”xxx“)和model.load_state_dict(torch.load("xxx"))來儲存和載入模型中的資料（官方推薦）

9、使用模型的套路

1、載入模型

2、載入資料

3、獲取模型輸出結果

#!/usr/bin/env pytorch
# -*- coding: UTF-8 -*-
"""
@Project     :llearn_pytorch 
@File        :testmodel.py
@IDE         :PyCharm 
@Author      :張世航
@Date        :2023/2/27 8:48 
@Description :一個簡易的驗證訓練好的模型的程式
"""
import os

import torch
from PIL import Image
from torchvision import transforms
from model import MyModel


class myImage:
    def __init__(self, strRootDir):
        self.mstrRootDir = strRootDir
        self.mstrImagePath = os.listdir(self.mstrRootDir)

    def __getitem__(self, item):
        strImageName = self.mstrImagePath[item]
        strImageItemPath = os.path.join(self.mstrRootDir, strImageName)
        zImage = Image.open(strImageItemPath)
        strLabel = strImageName
        return zImage, strLabel

    def __len__(self):
        return len(self.mstrImagePath)


funTransform = transforms.Compose([
    transforms.Resize((32, 32)),
    transforms.ToTensor()
])

model = MyModel()
model.load_state_dict(torch.load("model/model_37.path"))
model.eval()
strTestDir = "testimage"
zData = myImage(strTestDir)
image_type = ("airplane", "automobile", "bird", "cat", "deer", "dog", "frog", "horse", "ship", "truck", "nolen")
with torch.no_grad():
    for data in zData:
        image, label = data
        image = image.convert('RGB')
        image = funTransform(image)
        image = torch.reshape(image, (1, 3, 32, 32))
        output = model(image)
        iResult = output.argmax(1)
        print("圖片型別|模型識別出型別:{}|{}".format(label, image_type[iResult]))

完整的程式碼地址 深度學習練習: 在學習深度學習時候的一些程式碼 編譯環境為python10+pytorch1.13.1+ancoda (gitee.com)

希望可以對大家學習有一定的幫助，互勉。