一、概念

1. MLP

多層感知機(jī)（Multilayer Perceptron）縮寫(xiě)為MLP，也稱作前饋神經(jīng)網(wǎng)絡(luò)（Feedforward Neural Network）。 它是一種基于神經(jīng)網(wǎng)絡(luò)的機(jī)器學(xué)習(xí)模型，通過(guò)多層非線性變換對(duì)輸入數(shù)據(jù)進(jìn)行高級(jí)別的抽象和分類。

與單層感知機(jī)相比，MLP有多個(gè)隱藏層，每個(gè)隱藏層由多個(gè)神經(jīng)元組成，每個(gè)神經(jīng)元通過(guò)對(duì)上一層的輸入進(jìn)行加權(quán)和處理，再通過(guò)激活函數(shù)進(jìn)行非線性映射。

MLP的輸出層通常是一個(gè) softmax 層，用于多分類任務(wù)，或者是一個(gè) sigmoid 層，用于二分類任務(wù)。

由于它的強(qiáng)大表達(dá)能力和靈活性，MLP被廣泛應(yīng)用于各種機(jī)器學(xué)習(xí)任務(wù)中。

2. 前向傳播

由于有多個(gè)層，參數(shù)需要在這些層之間傳遞。 首先需要實(shí)現(xiàn)的就是參數(shù)的前向傳播，計(jì)算過(guò)程如下：

1. 將輸入數(shù)據(jù)傳遞給第一個(gè)隱藏層的神經(jīng)元；
2. 對(duì)于每個(gè)神經(jīng)元，計(jì)算其加權(quán)和，即將輸入與對(duì)應(yīng)的權(quán)重相乘并求和，再加上偏置項(xiàng)；
3. 將加權(quán)和輸入到激活函數(shù)中，得到激活值，作為該神經(jīng)元的輸出；
4. 將每個(gè)神經(jīng)元的輸出傳遞到下一層的神經(jīng)元，直至輸出層。

在這個(gè)過(guò)程中，數(shù)據(jù)和權(quán)重是前向傳播的主要傳播內(nèi)容。

3. 反向傳播

利用鏈?zhǔn)椒▌t對(duì)網(wǎng)絡(luò)中的參數(shù)進(jìn)行梯度更新。 在訓(xùn)練神經(jīng)網(wǎng)絡(luò)時(shí)，通常需要定義一個(gè)損失函數(shù)（loss function），用于評(píng)估模型預(yù)測(cè)結(jié)果與真實(shí)標(biāo)簽之間的差距。 反向傳播算法的目標(biāo)就是最小化這個(gè)損失函數(shù)。

在反向傳播過(guò)程中，算法首先計(jì)算損失函數(shù)對(duì)最后一層的輸出的梯度，然后根據(jù)鏈?zhǔn)椒▌t逐層向前計(jì)算各層的梯度，并利用梯度下降法更新網(wǎng)絡(luò)中的參數(shù)。 具體地，算法會(huì)先將損失函數(shù)對(duì)輸出的梯度傳回網(wǎng)絡(luò)最后一層，然后依次向前計(jì)算各層的梯度。 在計(jì)算梯度的過(guò)程中，算法會(huì)利用反向傳播公式來(lái)計(jì)算當(dāng)前層的梯度，然后將這個(gè)梯度傳遞到前一層。 在更新網(wǎng)絡(luò)參數(shù)時(shí)，算法會(huì)根據(jù)計(jì)算出的梯度和學(xué)習(xí)率來(lái)更新網(wǎng)絡(luò)中的權(quán)重和偏置。

通過(guò)不斷地反復(fù)迭代前向傳播和反向傳播兩個(gè)階段，可以不斷地更新網(wǎng)絡(luò)中的參數(shù)，從而逐漸提高模型的性能。

下面是一個(gè)Python計(jì)算反向傳播的示例：

for epoch in range(num_epochs):
            for x, y_true in zip(x_train, y_train):
                # 前向傳播
                hidden_layer = np.maximum(0, np.dot(x, self.weights1) + self.bias1)  # ReLU激活函數(shù)
                y_pred = np.dot(hidden_layer, self.weights2) + self.bias2

                # 計(jì)算損失和梯度，使用均方誤差作為損失函數(shù)(Mean Squared Error,MSE)
                # 對(duì)于每一個(gè)樣本，模型預(yù)測(cè)出來(lái)的輸出與實(shí)際輸出之間的差異會(huì)被平方，
                # 然后對(duì)所有樣本的平方差進(jìn)行求和并除以樣本數(shù)，即可得到MSE作為模型的損失函數(shù)。
                loss = np.square(y_true - y_pred).sum()

                # 下面復(fù)雜的方法用來(lái)實(shí)現(xiàn)反向傳播
                # 計(jì)算損失函數(shù)關(guān)于預(yù)測(cè)輸出的導(dǎo)數(shù)
                d_loss_pred = -2.0 * (y_true - y_pred)
                # 計(jì)算輸出層的梯度，
                d_weights2 = np.dot(hidden_layer.reshape(-1, 1), d_loss_pred.reshape(1, -1))
                # 計(jì)算輸出層偏置的梯度，其值等于輸出誤差
                d_bias2 = d_loss_pred
                # 計(jì)算隱藏層誤差，其中 self.weights2.T 代表輸出層權(quán)重的轉(zhuǎn)置，
                # 計(jì)算得到的結(jié)果是一個(gè)行向量，代表每個(gè)隱藏層節(jié)點(diǎn)的誤差。
                d_hidden = np.dot(d_loss_pred, self.weights2.T)
                # 將隱藏層誤差中小于等于 0 的部分置為 0，相當(dāng)于計(jì)算 ReLU 激活函數(shù)的導(dǎo)數(shù)，
                # 這是因?yàn)?ReLU 函數(shù)在小于等于 0 的部分導(dǎo)數(shù)為 0
                d_hidden[hidden_layer <= 0] = 0  # ReLU激活函數(shù)的導(dǎo)數(shù)
                # 計(jì)算隱藏層權(quán)重的梯度，
                # 其中 x.reshape(-1, 1) 代表將輸入變?yōu)榱邢蛄浚?/span>
                # d_hidden.reshape(1, -1) 代表將隱藏層誤差變?yōu)樾邢蛄浚?/span>
                # 兩者的點(diǎn)積得到的是一個(gè)矩陣，
                # 這個(gè)矩陣的行表示輸入的維度（也就是輸入節(jié)點(diǎn)的個(gè)數(shù)），
                # 列表示輸出的維度（也就是隱藏層節(jié)點(diǎn)的個(gè)數(shù)），表示每個(gè)輸入和每個(gè)隱藏層節(jié)點(diǎn)的權(quán)重梯度。
                d_weights1 = np.dot(x.reshape(-1, 1), d_hidden.reshape(1, -1))
                # 計(jì)算隱藏層偏置的梯度，其值等于隱藏層誤差。
                d_bias1 = d_hidden

                # 更新權(quán)重和偏置
                self.weights2 -= learning_rate * d_weights2
                self.bias2 -= learning_rate * d_bias2
                self.weights1 -= learning_rate * d_weights1
                self.bias1 -= learning_rate * d_bias1

4. 評(píng)估模式與訓(xùn)練模式

• 在訓(xùn)練階段，需要調(diào)用 model.train() 來(lái)指定模型為訓(xùn)練模式，以便啟用訓(xùn)練中需要的特性，如 dropout 和 batch normalization 等。
• 如果在訓(xùn)練過(guò)程中需要評(píng)估模型的性能，可以在評(píng)估前調(diào)用 model.eval()，以確保模型處于評(píng)估模式，而不是訓(xùn)練模式。
• 在測(cè)試階段，需要調(diào)用 model.eval() 來(lái)指定模型為評(píng)估模式，以便禁用 dropout 和 batch normalization 等特性，以及啟用測(cè)試中需要的特性，如在計(jì)算中間層的輸出等。
• 在預(yù)測(cè)階段，需要調(diào)用 model.eval() 來(lái)指定模型為預(yù)測(cè)模式，以便禁用 dropout 和 batch normalization 等特性，并且只計(jì)算模型的前向傳播，以生成模型的輸出，而不更新模型的權(quán)重。

二、模型定義

1. 加載數(shù)據(jù)集

本示例使用 MNIST 數(shù)據(jù)集。

import torch
from torchvision import datasets, transforms
from torch.autograd import Variable
import time
import matplotlib.pyplot as plt

# 定義ToTensor和Normalize的transform
to_tensor = transforms.ToTensor()
normalize = transforms.Normalize((0.5,), (0.5,))

# 定義Compose的transform
transform = transforms.Compose([
    to_tensor,  # 轉(zhuǎn)換為張量
    normalize  # 標(biāo)準(zhǔn)化
])

# 下載數(shù)據(jù)集
data_train = datasets.MNIST(root="..//data//",
                            transform=transform,
                            train=True,
                            download=True)

data_test = datasets.MNIST(root="..//data//",
                           transform=transform,
                           train=False,
                           download=True)
# 裝載數(shù)據(jù)
data_loader_train = torch.utils.data.DataLoader(dataset=data_train,
                                                batch_size=64,
                                                shuffle=True)

data_loader_test = torch.utils.data.DataLoader(dataset=data_test,
                                               batch_size=64,
                                               shuffle=True)

2. 定義MLP層

下面定義一個(gè)有三個(gè)層的MLP。
對(duì)于這個(gè)MLP，它接收一個(gè)num_i的輸入，輸出為num_o的預(yù)測(cè)值。 隱藏層有2層，每層大小為num_h。
層的定義如下：

• self.linear1：輸入層到第一層隱藏層的線性轉(zhuǎn)換，其中num_i為輸入的特征數(shù)，num_h為第一層隱藏層的特征數(shù)。
• self.relu：第一層隱藏層的激活函數(shù)，采用ReLU。
• self.linear2：第一層隱藏層到第二層隱藏層的線性轉(zhuǎn)換，其中num_h為第一層隱藏層的特征數(shù)，num_h為第二層隱藏層的特征數(shù)。
• self.relu2：第二層隱藏層的激活函數(shù)，采用ReLU。
• self.linear3：第二層隱藏層到輸出層的線性轉(zhuǎn)換，其中num_h為第二層隱藏層的特征數(shù)，num_o為輸出的特征數(shù)（或者說(shuō)類別數(shù)）。

class MLP(torch.nn.Module):

    def __init__(self, num_i, num_h, num_o):
        super(MLP, self).__init__()

        self.linear1 = torch.nn.Linear(num_i, num_h)
        self.relu = torch.nn.ReLU()
        self.linear2 = torch.nn.Linear(num_h, num_h)  # 2個(gè)隱層
        self.relu2 = torch.nn.ReLU()
        self.linear3 = torch.nn.Linear(num_h, num_o)

3. 前向傳播

def forward(self, x):
        x = self.linear1(x)
        x = self.relu(x)
        x = self.linear2(x)
        x = self.relu2(x)
        x = self.linear3(x)
        return x

在前向傳播時(shí)，輸入x先通過(guò)第一層的線性轉(zhuǎn)換，然后經(jīng)過(guò)第一層隱藏層的激活函數(shù)，
再通過(guò)第二層的線性轉(zhuǎn)換，再經(jīng)過(guò)第二層隱藏層的激活函數(shù)，
最后輸出預(yù)測(cè)值。

4. 優(yōu)化器

本文將使用PyTorch的優(yōu)化器工具用于反向傳播 。
優(yōu)化器(optimizer)是一個(gè)用于更新模型參數(shù)的工具，根據(jù)訓(xùn)練集的損失函數(shù)(loss function)和反向傳播算法(backpropagation algorithm)計(jì)算梯度，并使用梯度下降算法(gradient descent algorithm)更新模型參數(shù)，以最小化損失函數(shù)的值。

PyTorch提供了許多常用的優(yōu)化器，如隨機(jī)梯度下降法(SGD)、Adam、Adagrad、RMSprop等。
這些優(yōu)化器使用不同的更新策略，根據(jù)不同的訓(xùn)練任務(wù)和數(shù)據(jù)集選擇合適的優(yōu)化器可以提高訓(xùn)練效率和性能。

5. 反向傳播

本文使用和PyTorch優(yōu)化器的一個(gè)實(shí)例： torch.optim.Adam()，它使用反向傳播算法計(jì)算梯度并更新模型的權(quán)重，從而調(diào)整模型參數(shù)以最小化損失函數(shù)。

三、訓(xùn)練

def train(model):

    cost = torch.nn.CrossEntropyLoss()
    optimizer = torch.optim.Adam(model.parameters())
    # 設(shè)置迭代次數(shù)
    epochs = 5
    for epoch in range(epochs):
        sum_loss = 0
        train_correct = 0
        for data in data_loader_train:
            # 獲取數(shù)據(jù)和標(biāo)簽
            inputs, labels = data  # inputs 維度：[64,1,28,28]
            # 將輸入數(shù)據(jù)展平為一維向量
            inputs = torch.flatten(inputs, start_dim=1)  # 展平數(shù)據(jù)，轉(zhuǎn)化為[64,784]
            # 計(jì)算輸出
            outputs = model(inputs)
            # 將梯度清零
            optimizer.zero_grad()
            # 計(jì)算損失函數(shù)
            loss = cost(outputs, labels)
            # 反向傳播計(jì)算梯度
            loss.backward()
            # 使用優(yōu)化器更新模型參數(shù)
            optimizer.step()

			# 返回 outputs 張量每行中的最大值和對(duì)應(yīng)的索引，1表示從行維度中找到最大值
            _, id = torch.max(outputs.data, 1)
            # 將每個(gè)小批次的損失值 loss 累加，用于最后計(jì)算平均損失
            sum_loss += loss.data
            # 計(jì)算每個(gè)小批次正確分類的圖像數(shù)量
            train_correct += torch.sum(id == labels.data)
        print('[%d/%d] loss:%.3f, correct:%.3f%%, time:%s' %
              (epoch + 1, epochs, sum_loss / len(data_loader_train),
               100 * train_correct / len(data_train),
               time.strftime('%Y-%m-%d %H:%M:%S', time.localtime())))
    model.eval()

四、測(cè)試與預(yù)測(cè)

# 測(cè)試模型
def test(model, test_loader):
    test_correct = 0
    for data in test_loader:
        inputs, lables = data
        inputs, lables = Variable(inputs).cpu(), Variable(lables).cpu()
        inputs = torch.flatten(inputs, start_dim=1)  # 展并數(shù)據(jù)
        outputs = model(inputs)
        _, id = torch.max(outputs.data, 1)
        test_correct += torch.sum(id == lables.data)
    print(f'Accuracy on test set: {100 * test_correct / len(data_test):.3f}%')

五、預(yù)測(cè)

在神經(jīng)網(wǎng)絡(luò)模型的推斷（inference）階段中，我們不需要進(jìn)行反向傳播，也不需要計(jì)算梯度，使用 with torch.no_grad(): 上下文管理器可以有效地減少內(nèi)存消耗和計(jì)算時(shí)間

def predict(model, data):
    model.eval()
    with torch.no_grad():
        output = model(data)
        pred = output.data.max(1, keepdim=True)[1]
    return pred

1234567

• output是模型在給定輸入數(shù)據(jù)后的輸出結(jié)果，每一行對(duì)應(yīng)一個(gè)輸入數(shù)據(jù)樣本，每一列對(duì)應(yīng)一個(gè)可能的輸出類別。
• output.data提取出了output中的數(shù)據(jù)部分，然后使用max()函數(shù)沿著第1個(gè)維度(即列)找到每一行中最大的值以及對(duì)應(yīng)的索引。
• keepdim=True參數(shù)使得輸出結(jié)果保持和輸入數(shù)據(jù)output相同的維度。 因此，pred包含每個(gè)輸入樣本的預(yù)測(cè)類別，是一個(gè)包含預(yù)測(cè)標(biāo)簽索引的一維張量

六、完整代碼

import torch
from torchvision import datasets, transforms
from torch.autograd import Variable
import time
import matplotlib.pyplot as plt

# 定義ToTensor和Normalize的transform
to_tensor = transforms.ToTensor()
normalize = transforms.Normalize((0.5,), (0.5,))

# 定義Compose的transform
transform = transforms.Compose([
    to_tensor,  # 轉(zhuǎn)換為張量
    normalize  # 標(biāo)準(zhǔn)化
])

# 下載數(shù)據(jù)集
data_train = datasets.MNIST(root="..//data//",
                            transform=transform,
                            train=True,
                            download=True)

data_test = datasets.MNIST(root="..//data//",
                           transform=transform,
                           train=False,
                           download=True)
# 裝載數(shù)據(jù)
data_loader_train = torch.utils.data.DataLoader(dataset=data_train,
                                                batch_size=64,
                                                shuffle=True)

data_loader_test = torch.utils.data.DataLoader(dataset=data_test,
                                               batch_size=64,
                                               shuffle=True)


class MLP(torch.nn.Module):

    def __init__(self, num_i, num_h, num_o):
        super(MLP, self).__init__()

        self.linear1 = torch.nn.Linear(num_i, num_h)
        self.relu = torch.nn.ReLU()
        self.linear2 = torch.nn.Linear(num_h, num_h)  # 2個(gè)隱層
        self.relu2 = torch.nn.ReLU()
        self.linear3 = torch.nn.Linear(num_h, num_o)

    def forward(self, x):
        x = self.linear1(x)
        x = self.relu(x)
        x = self.linear2(x)
        x = self.relu2(x)
        x = self.linear3(x)
        return x


def train(model):
    # 損失函數(shù)，它將網(wǎng)絡(luò)的輸出和目標(biāo)標(biāo)簽進(jìn)行比較，并計(jì)算它們之間的差異。在訓(xùn)練期間，我們嘗試最小化損失函數(shù)，以使輸出與標(biāo)簽更接近
    cost = torch.nn.CrossEntropyLoss()
    # 優(yōu)化器的一個(gè)實(shí)例，用于調(diào)整模型參數(shù)以最小化損失函數(shù)。
    # 使用反向傳播算法計(jì)算梯度并更新模型的權(quán)重。在這里，我們使用Adam優(yōu)化器來(lái)優(yōu)化模型。model.parameters()提供了要優(yōu)化的參數(shù)。
    optimizer = torch.optim.Adam(model.parameters())
    # 設(shè)置迭代次數(shù)
    epochs = 2
    for epoch in range(epochs):
        sum_loss = 0
        train_correct = 0
        for data in data_loader_train:
            inputs, labels = data  # inputs 維度：[64,1,28,28]
            #     print(inputs.shape)
            inputs = torch.flatten(inputs, start_dim=1)  # 展平數(shù)據(jù)，轉(zhuǎn)化為[64,784]
            #     print(inputs.shape)
            outputs = model(inputs)
            optimizer.zero_grad()
            loss = cost(outputs, labels)
            loss.backward()
            optimizer.step()

            _, id = torch.max(outputs.data, 1)
            sum_loss += loss.data
            train_correct += torch.sum(id == labels.data)
        print('[%d/%d] loss:%.3f, correct:%.3f%%, time:%s' %
              (epoch + 1, epochs, sum_loss / len(data_loader_train),
               100 * train_correct / len(data_train),
               time.strftime('%Y-%m-%d %H:%M:%S', time.localtime())))
    model.train()


# 測(cè)試模型
def test(model, test_loader):
    model.eval()
    test_correct = 0
    for data in test_loader:
        inputs, lables = data
        inputs, lables = Variable(inputs).cpu(), Variable(lables).cpu()
        inputs = torch.flatten(inputs, start_dim=1)  # 展并數(shù)據(jù)
        outputs = model(inputs)
        _, id = torch.max(outputs.data, 1)
        test_correct += torch.sum(id == lables.data)
    print(f'Accuracy on test set: {100 * test_correct / len(data_test):.3f}%')


# 預(yù)測(cè)模型
def predict(model, data):
    model.eval()
    with torch.no_grad():
        output = model(data)
        pred = output.data.max(1, keepdim=True)[1]
    return pred


num_i = 28 * 28  # 輸入層節(jié)點(diǎn)數(shù)
num_h = 100  # 隱含層節(jié)點(diǎn)數(shù)
num_o = 10  # 輸出層節(jié)點(diǎn)數(shù)
batch_size = 64

model = MLP(num_i, num_h, num_o)
train(model)
test(model, data_loader_test)

# 預(yù)測(cè)圖片，這里取測(cè)試集前10張圖片
for i in range(10):
    # 獲取測(cè)試數(shù)據(jù)中的第一張圖片
    test_image = data_test[i][0]
    # 展平圖片
    test_image = test_image.flatten()
    # 增加一維作為 batch 維度
    test_image = test_image.unsqueeze(0)
    # 顯示圖片
    plt.imshow(test_image.view(28, 28), cmap='gray')
    plt.show()
    pred = predict(model, test_image)
    print('Prediction:', pred.item())