日萌社

人工智能AI：Keras PyTorch MXNet TensorFlow PaddlePaddle 深度學習實戰（不定時更新）

使用Pytorch實現手寫數字識別

目標

知道如何使用Pytorch完成神經網絡的構建
知道Pytorch中激活函數的使用方法
知道Pytorch中torchvision.transforms中常見圖形處理函數的使用
知道如何訓練模型和如何評估模型

1. 思路和流程分析

流程：

準備數據，這些需要準備DataLoader
構建模型，這裏可以使用torch構造一個深層的神經網絡
模型的訓練
模型的保存，保存模型，後續持續使用
模型的評估，使用測試集，觀察模型的好壞

2. 準備訓練集和測試集

準備數據集的方法前面已經講過，但是通過前面的內容可知，調用MNIST返回的結果中圖形數據是一個Image對象,需要對其進行處理

爲了進行數據的處理，接下來學習torchvision.transfroms的方法

2.1 `torchvision.transforms`的圖形數據處理方法

2.1.1 torchvision.transforms.ToTensor

把一個取值範圍是[0,255]的PIL.Image或者shape爲(H,W,C)的numpy.ndarray，轉換成形狀爲[C,H,W]

其中(H,W,C)意思爲(高，寬，通道數)，黑白圖片的通道數只有1，其中每個像素點的取值爲[0,255],彩色圖片的通道數爲(R,G,B),每個通道的每個像素點的取值爲[0,255]，三個通道的顏色相互疊加，形成了各種顏色

示例如下：

from torchvision import transforms
import numpy as np

data = np.random.randint(0, 255, size=12)
img = data.reshape(2,2,3)
print(img.shape)
img_tensor = transforms.ToTensor()(img) # 轉換成tensor
print(img_tensor)
print(img_tensor.shape)

輸出如下：

shape:(2, 2, 3)
img_tensor:tensor([[[215, 171],
                 [ 34,  12]],

                [[229,  87],
                 [ 15, 237]],

                [[ 10,  55],
                 [ 72, 204]]], dtype=torch.int32)
new shape:torch.Size([3, 2, 2])

注意：

transforms.ToTensor對象中有__call__方法，所以可以對其示例能夠傳入數據獲取結果

2.1.2 torchvision.transforms.Normalize(mean, std)

給定均值：mean，shape和圖片的通道數相同(指的是每個通道的均值)，方差：std，和圖片的通道數相同(指的是每個通道的方差)，將會把Tensor規範化處理。

即：Normalized_image=(image-mean)/std。

例如：

 
from torchvision import transforms
import numpy as np
import torchvision

data = np.random.randint(0, 255, size=12)
img = data.reshape(2,2,3)
img = transforms.ToTensor()(img) # 轉換成tensor
print(img)
print("*"*100)

norm_img = transforms.Normalize((10,10,10), (1,1,1))(img) #進行規範化處理

print(norm_img)

輸出如下：

tensor([[[177, 223],
         [ 71, 182]],

        [[153, 120],
         [173,  33]],

        [[162, 233],
         [194,  73]]], dtype=torch.int32)
***************************************************************************************
tensor([[[167, 213],
         [ 61, 172]],

        [[143, 110],
         [163,  23]],

        [[152, 223],
         [184,  63]]], dtype=torch.int32)

注意：在sklearn中，默認上式中的std和mean爲數據每列的std和mean，sklearn會在標準化之前算出每一列的std和mean。

但是在api：Normalize中並沒有幫我們計算，所以我們需要手動計算

當mean爲全部數據的均值，std爲全部數據的std的時候，纔是進行了標準化。
如果mean(x)不是全部數據的mean的時候，std(y)也不是的時候，Normalize後的數據分佈滿足下面的關係

2.1.3 torchvision.transforms.Compose(transforms)

將多個transform組合起來使用。

例如

transforms.Compose([
     torchvision.transforms.ToTensor(), #先轉化爲Tensor
     torchvision.transforms.Normalize(mean,std) #在進行正則化
 ])

2.2 準備MNIST數據集的Dataset和DataLoader

準備訓練集

import torchvision

#準備數據集，其中0.1307，0.3081爲MNIST數據的均值和標準差，這樣操作能夠對其進行標準化
#因爲MNIST只有一個通道（黑白圖片）,所以元組中只有一個值
dataset = torchvision.datasets.MNIST('/data', train=True, download=True,
                             transform=torchvision.transforms.Compose([
                               torchvision.transforms.ToTensor(),
                               torchvision.transforms.Normalize(
                                 (0.1307,), (0.3081,))
                             ]))
#準備數據迭代器                          
train_dataloader = torch.utils.data.DataLoader(dataset,batch_size=64,shuffle=True)

準備測試集

import torchvision

#準備數據集，其中0.1307，0.3081爲MNIST數據的均值和標準差，這樣操作能夠對其進行標準化
#因爲MNIST只有一個通道（黑白圖片）,所以元組中只有一個值
dataset = torchvision.datasets.MNIST('/data', train=False, download=True,
                             transform=torchvision.transforms.Compose([
                               torchvision.transforms.ToTensor(),
                               torchvision.transforms.Normalize(
                                 (0.1307,), (0.3081,))
                             ]))
#準備數據迭代器                          
train_dataloader = torch.utils.data.DataLoader(dataset,batch_size=64,shuffle=True)

3. 構建模型

補充：全連接層：當前一層的神經元和前一層的神經元相互鏈接，其核心操作就是y = wx，即矩陣的乘法，實現對前一層的數據的變換

模型的構建使用了一個三層的神經網絡，其中包括兩個全連接層和一個輸出層，第一個全連接層會經過激活函數的處理，將處理後的結果交給下一個全連接層，進行變換後輸出結果

那麼在這個模型中有兩個地方需要注意：

激活函數如何使用
每一層數據的形狀
模型的損失函數

3.1 激活函數的使用

前面介紹了激活函數的作用，常用的激活函數爲Relu激活函數，他的使用非常簡單

Relu激活函數由import torch.nn.functional as F提供，F.relu(x)即可對x進行處理

例如：

In [30]: b
Out[30]: tensor([-2, -1,  0,  1,  2])

In [31]: import torch.nn.functional as F

In [32]: F.relu(b)
Out[32]: tensor([0, 0, 0, 1, 2])

3.2 模型中數據的形狀（【添加形狀變化圖形】）

原始輸入數據爲的形狀:[batch_size,1,28,28]
進行形狀的修改：[batch_size,28*28] ,(全連接層是在進行矩陣的乘法操作)
第一個全連接層的輸出形狀：[batch_size,28]，這裏的28是個人設定的，你也可以設置爲別的
激活函數不會修改數據的形狀
第二個全連接層的輸出形狀：[batch_size,10],因爲手寫數字有10個類別

構建模型的代碼如下：

import torch
from torch import nn
import torch.nn.functional as F

class MnistNet(nn.Module):
    def __init__(self):
        super(MnistNet,self).__init__()
        self.fc1 = nn.Linear(28*28*1,28)  #定義Linear的輸入和輸出的形狀
        self.fc2 = nn.Linear(28,10)  #定義Linear的輸入和輸出的形狀

    def forward(self,x):
        x = x.view(-1,28*28*1)  #對數據形狀變形，-1表示該位置根據後面的形狀自動調整
        x = self.fc1(x) #[batch_size,28]
        x = F.relu(x)  #[batch_size,28]
        x = self.fc2(x) #[batch_size,10]

可以發現：pytorch在構建模型的時候形狀上並不會考慮batch_size

3.3 模型的損失函數

首先，我們需要明確，當前我們手寫字體識別的問題是一個多分類的問題，所謂多分類對比的是之前學習的2分類

回顧之前的課程，我們在邏輯迴歸中，我們使用sigmoid進行計算對數似然損失，來定義我們的2分類的損失。

對於這個softmax輸出的結果，是在[0,1]區間，我們可以把它當做概率

和前面2分類的損失一樣，多分類的損失只需要再把這個結果進行對數似然損失的計算即可

即：

最後，會計算每個樣本的損失，即上式的平均值

我們把softmax概率傳入對數似然損失得到的損失函數稱爲交叉熵損失

在pytorch中有兩種方法實現交叉熵損失

criterion = nn.CrossEntropyLoss()
loss = criterion(input,target)

#1. 對輸出值計算softmax和取對數
output = F.log_softmax(x,dim=-1)
#2. 使用torch中帶權損失
loss = F.nll_loss(output,target)

帶權損失定義爲：

4. 模型的訓練

訓練的流程：

實例化模型，設置模型爲訓練模式
實例化優化器類，實例化損失函數
獲取，遍歷dataloader
梯度置爲0
進行向前計算
計算損失
反向傳播
更新參數

mnist_net = MnistNet()
optimizer = optim.Adam(mnist_net.parameters(),lr= 0.001)
def train(epoch):
    mode = True
    mnist_net.train(mode=mode) #模型設置爲訓練模型

    train_dataloader = get_dataloader(train=mode) #獲取訓練數據集
    for idx,(data,target) in enumerate(train_dataloader):
        optimizer.zero_grad() #梯度置爲0
        output = mnist_net(data) #進行向前計算
        loss = F.nll_loss(output,target) #帶權損失
        loss.backward()  #進行反向傳播，計算梯度
        optimizer.step() #參數更新
        if idx % 10 == 0:
            print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
                epoch, idx * len(data), len(train_dataloader.dataset),
                       100. * idx / len(train_dataloader), loss.item()))

5. 模型的保存和加載

5.1 模型的保存

torch.save(mnist_net.state_dict(),"model/mnist_net.pt") #保存模型參數
torch.save(optimizer.state_dict(), 'results/mnist_optimizer.pt') #保存優化器參數

5.2 模型的加載

mnist_net.load_state_dict(torch.load("model/mnist_net.pt"))
optimizer.load_state_dict(torch.load("results/mnist_optimizer.pt"))

6. 模型的評估

評估的過程和訓練的過程相似，但是：

不需要計算梯度
需要收集損失和準確率，用來計算平均損失和平均準確率
損失的計算和訓練時候損失的計算方法相同
準確率的計算：
- 模型的輸出爲[batch_size,10]的形狀
- 其中最大值的位置就是其預測的目標值（預測值進行過sotfmax後爲概率，sotfmax中分母都是相同的，分子越大，概率越大）
- 最大值的位置獲取的方法可以使用torch.max,返回最大值和最大值的位置
- 返回最大值的位置後，和真實值（[batch_size]）進行對比，相同表示預測成功

def test():
    test_loss = 0
    correct = 0
    mnist_net.eval()  #設置模型爲評估模式
    test_dataloader = get_dataloader(train=False) #獲取評估數據集
    with torch.no_grad(): #不計算其梯度
        for data, target in test_dataloader:
            output = mnist_net(data)
            test_loss += F.nll_loss(output, target, reduction='sum').item()
            pred = output.data.max(1, keepdim=True)[1] #獲取最大值的位置,[batch_size,1]
            correct += pred.eq(target.data.view_as(pred)).sum()  #預測準備樣本數累加
    test_loss /= len(test_dataloader.dataset) #計算平均損失
    print('\nTest set: Avg. loss: {:.4f}, Accuracy: {}/{} ({:.2f}%)\n'.format(
        test_loss, correct, len(test_dataloader.dataset),
        100. * correct / len(test_dataloader.dataset)))

7. 完整的代碼如下：

import torch
from torch import nn
from torch import optim
import torch.nn.functional as F
import torchvision

train_batch_size = 64
test_batch_size = 1000
img_size = 28

def get_dataloader(train=True):
    assert isinstance(train,bool),"train 必須是bool類型"

    #準備數據集，其中0.1307，0.3081爲MNIST數據的均值和標準差，這樣操作能夠對其進行標準化
    #因爲MNIST只有一個通道（黑白圖片）,所以元組中只有一個值
    dataset = torchvision.datasets.MNIST('/data', train=train, download=True,
                                         transform=torchvision.transforms.Compose([
                                         torchvision.transforms.ToTensor(),
                                         torchvision.transforms.Normalize((0.1307,), (0.3081,)),]))
    #準備數據迭代器
    batch_size = train_batch_size if train else test_batch_size
    dataloader = torch.utils.data.DataLoader(dataset,batch_size=batch_size,shuffle=True)
    return dataloader

class MnistNet(nn.Module):
    def __init__(self):
        super(MnistNet,self).__init__()
        self.fc1 = nn.Linear(28*28*1,28)
        self.fc2 = nn.Linear(28,10)

    def forward(self,x):
        x = x.view(-1,28*28*1)
        x = self.fc1(x) #[batch_size,28]
        x = F.relu(x)  #[batch_size,28]
        x = self.fc2(x) #[batch_size,10]
        # return x
        return F.log_softmax(x,dim=-1)

mnist_net = MnistNet()
optimizer = optim.Adam(mnist_net.parameters(),lr= 0.001)
# criterion = nn.NLLLoss()
# criterion = nn.CrossEntropyLoss()
train_loss_list = []
train_count_list = []

def train(epoch):
    mode = True
    mnist_net.train(mode=mode)
    train_dataloader = get_dataloader(train=mode)
    print(len(train_dataloader.dataset))
    print(len(train_dataloader))
    for idx,(data,target) in enumerate(train_dataloader):
        optimizer.zero_grad()
        output = mnist_net(data)
        loss = F.nll_loss(output,target) #對數似然損失
        loss.backward()
        optimizer.step()
        if idx % 10 == 0:
            print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
                epoch, idx * len(data), len(train_dataloader.dataset),
                       100. * idx / len(train_dataloader), loss.item()))

            train_loss_list.append(loss.item())
            train_count_list.append(idx*train_batch_size+(epoch-1)*len(train_dataloader))
            torch.save(mnist_net.state_dict(),"model/mnist_net.pkl")
            torch.save(optimizer.state_dict(), 'results/mnist_optimizer.pkl')


def test():
    test_loss = 0
    correct = 0
    mnist_net.eval()
    test_dataloader = get_dataloader(train=False)
    with torch.no_grad():
        for data, target in test_dataloader:
            output = mnist_net(data)
            test_loss += F.nll_loss(output, target, reduction='sum').item()
            pred = output.data.max(1, keepdim=True)[1] #獲取最大值的位置,[batch_size,1]
            correct += pred.eq(target.data.view_as(pred)).sum()
    test_loss /= len(test_dataloader.dataset)
    print('\nTest set: Avg. loss: {:.4f}, Accuracy: {}/{} ({:.2f}%)\n'.format(
        test_loss, correct, len(test_dataloader.dataset),
        100. * correct / len(test_dataloader.dataset)))


if __name__ == '__main__':

    test()  
    for i in range(5): #模型訓練5輪
        train(i)
        test()

使用Pytorch實現手寫數字識別

import torch
import torch.nn as nn
import torch.nn.functional as F
from torchvision import datasets, transforms
from torch.utils.data import DataLoader

#定義一些參數
BATCH_SIZE = 64
EPOCHS = 10
# DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
DEVICE = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

#圖像預處理
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.1307,), (0.3081,))
    ])

#訓練集
train_set = datasets.MNIST('data', train=True, transform=transform, download=True)
train_loader = DataLoader(train_set,
                          batch_size=BATCH_SIZE,
                          shuffle=True)

#測試集
test_set = datasets.MNIST('data', train=False, transform=transform, download=True)
test_loader = DataLoader(test_set,
                        batch_size=BATCH_SIZE,
                        shuffle=True)


# 搭建模型
class ConvNet(nn.Module):
    # 圖像輸入是(batch,1,28,28)
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(1, 10, (3, 3))       # 輸入通道數爲1，輸出通道數爲10，卷積核(3,3)
        self.conv2 = nn.Conv2d(10, 32, (3, 3))      # 輸入通道數爲10，輸出通道數爲32，卷積核(3,3)
        self.fc1 = nn.Linear(12 * 12 * 32, 100)     #定義Linear全鏈接層 的輸入形狀(不包含batch_size) 12 * 12 * 32，輸出形狀 100
        self.fc2 = nn.Linear(100, 10)               #定義Linear全鏈接層 的輸入形狀(不包含batch_size) 100，輸出形狀 10
        self.dropout =nn.Dropout()                  #元素歸零的概率。默認值：0.5

    def forward(self, x):
        x = self.conv1(x)  # (batch,10,26,26)
        #BN：每個隱層神經元的激活值做BN，可以想象成每個隱層又加上了一層BN操作層，它位於A=X*W+B激活值獲得之後，非線性函數變換之前
        x = F.relu(x)

        x = self.conv2(x)  # (batch,32,24,24)
        x = F.relu(x)
        x = F.max_pool2d(x, (2, 2))  # (batch,32,12,12)

        x = x.view(x.size(0), -1)  # flatten 形狀變成 (batch,12*12*32)
        x = self.fc1(x)  # (batch,100)
        x = F.relu(x)

        x = self.fc2(x)  # (batch,10)
        out = F.log_softmax(x, dim=1)  # softmax激活並取對數，數值上更穩定
        return out


# 定義模型和優化器
model = ConvNet().to(DEVICE)  # 模型移至GPU
optimizer = torch.optim.Adam(model.parameters())


# 定義訓練函數
def train(model, device, train_loader, optimizer, epoch):  # 跑一個epoch
    # 開啓訓練模式，即啓用BatchNormalization和Dropout等。僅僅當模型中有Dropout和BatchNorm是纔會有影響。
    model.train()

    for batch_idx, (data, target) in enumerate(train_loader):   # 每次產生一個batch
        data, target = data.to(device), target.to(device)       # 產生的數據移至GPU
        output = model(data)
        """
        #1. 對輸出值計算softmax和取對數
        output = F.log_softmax(x,dim=-1)
        #2. 使用torch中帶權損失
        loss = F.nll_loss(output,target)
        """
        #交叉熵損失：nn.CrossEntropyLoss()，常用於分類問題
        loss = F.nll_loss(output, target)  # CrossEntropyLoss = log_softmax + NLLLoss
        optimizer.zero_grad()   # 設置當前該次循環時的參數梯度置爲0，即梯度清零
        loss.backward()         # 反向傳播求所有參數梯度
        optimizer.step()        # 沿負梯度方向 更新參數的值
        if (batch_idx + 1) % 10 == 0:
            # print("批量大小:",len(data))
            # print("batch批數:",len(train_loader))
            # print("樣本總數:",len(train_loader.dataset))

            # len(data) 批量大小，len(train_loader)爲batch批數，len(train_loader.dataset)爲樣本總數
            print('Train Epoch: {} [{}/{} ({:.1f}%)]\tLoss: {:.6f}'.format(
                epoch, (batch_idx + 1) * len(data), len(train_loader.dataset),
                       100. * (batch_idx + 1) / len(train_loader), loss.item()))


# 定義測試函數
def eval_test(model, device, test_loader):
    # 測試模式，不啓用BatchNormalization和Dropout。僅僅當模型中有Dropout和BatchNorm是纔會有影響。
    model.eval()
    test_loss = 0
    correct = 0
    with torch.no_grad():  # 避免梯度跟蹤，不計算其梯度
        for data, target in test_loader:
            data, target = data.to(device), target.to(device)
            output = model(data)
            test_loss += F.nll_loss(output, target, reduction='sum').item()  # 將一批損失相加
            # output.max 效果等同於 pred = torch.argmax(output, dim=1, keepdim=True)
            pred = output.max(1, keepdim=True)[1]  # 找到概率最大的下標，獲取最大值的位置
            # print("最大值結果:",output.max(1, keepdim=True)[0])
            # print("概率最大的下標:",pred)
            # print("真實標籤的下標:",target.view_as(pred))
            correct += pred.eq(target.view_as(pred)).sum().item() #預測準備樣本數累加

    # len(data) 批量大小，len(test_loader)爲batch批數，len(test_loader.dataset)爲樣本總數
    test_loss /= len(test_loader.dataset)
    print('\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.1f}%)\n'.format(
        test_loss, correct, len(test_loader.dataset),
        100. * correct / len(test_loader.dataset)))

"""
max()有兩種用法
    1.torch.max(input_tensor, dim, [keepdim]) 直接傳入一個input_tensor，返回一個tuple，
      前者爲最大值結果，後者爲indices（效果同argmax）
    2.output.max() 與 torch.max()類似，只不過output.max()無需傳入input_tensor
"""
# 開始訓練
for epoch in range(1, EPOCHS + 1):
    train(model, DEVICE, train_loader, optimizer, epoch)
    eval_test(model, DEVICE, test_loader)

Pytorch 實現手寫數字識別

日萌社

使用Pytorch實現手寫數字識別

目標

1. 思路和流程分析

2. 準備訓練集和測試集

2.1 `torchvision.transforms`的圖形數據處理方法

2.2 準備MNIST數據集的Dataset和DataLoader

3. 構建模型

3.1 激活函數的使用

3.2 模型中數據的形狀（【添加形狀變化圖形】）

3.3 模型的損失函數

4. 模型的訓練

5. 模型的保存和加載

5.1 模型的保存

5.2 模型的加載

6. 模型的評估

7. 完整的代碼如下：

使用Pytorch實現手寫數字識別

自學編程兩個月，現在我月入 4 萬元

Google Chrome驅動程序 124.0.6367.62（正式版本）去哪下載？

泛娛樂推薦系統

召回模塊：用戶推薦邏輯完善

召回模塊：召回金字塔

召回模塊：規則過濾器

排序模塊：泛娛樂特徵工程與模型代碼構建

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結

Pytorch 實現手寫數字識別

使用Pytorch實現手寫數字識別

目標

1. 思路和流程分析

2. 準備訓練集和測試集

2.1 torchvision.transforms的圖形數據處理方法

2.2 準備MNIST數據集的Dataset和DataLoader

3. 構建模型

3.1 激活函數的使用

3.2 模型中數據的形狀（【添加形狀變化圖形】）

3.3 模型的損失函數

4. 模型的訓練

5. 模型的保存和加載

5.1 模型的保存

5.2 模型的加載

6. 模型的評估

7. 完整的代碼如下：

使用Pytorch實現手寫數字識別

2.1 `torchvision.transforms`的圖形數據處理方法