PS：要轉載請註明出處，本人版權所有。

PS: 這個只是基於《我自己》的理解，

如果和你的原則及想法相沖突，請諒解，勿噴。

前置說明

  本文作為本人csdn blog的主站的備份。（BlogID=110）

環境說明
  • Windows 10
  • VSCode
  • Python 3.8.10
  • Pytorch 1.8.1
  • Cuda 10.2

前言

  本文是此基礎補全計劃的最終篇，因為從我的角度來說，如果前面這些基礎知識都能夠了解及理解，再加上本文的這篇基礎知識，那麼我們算是小半隻腳踏入了大門。從這個時候，其實我們就已經可以做影象上的基本的分類任務了。除了分類任務，我們還有兩類重要的影象任務是目標檢測和影象分割，這兩項任務都和分類任務有一定的關聯，可以說，分類可以說是這兩類的基礎。

  卷積神經網路是一個專門為處理影象資料的網路。下面我們簡單的來看看卷積、池化的含義和怎麼計算的，然後我們通過一個LeNet5的經典網路，訓練一個分類模型。

卷積

  卷積是一種運算，類似加減乘除。卷積是一種運算，類似加減乘除。卷積是一種運算，類似加減乘除。重要的事情說三次。

  在數學上的定義是:連續n的情況\((f*g)(x) = \int f(n)g(x-n)dn\)， 離散n的情況\((f*g)(x) = \sum\limits_{n} f(n)g(x-n)\)。從這裡我們可以看到，卷積就是測量函式f和函式g的翻轉且平移x後的重疊。其二維離散a,b的表達是\((f*g)(x1,x2) = \sum\limits_{a}\sum\limits_{b} f(a, b)g(x1-a, x2-b)\)

  卷積是一種運算，類似加減乘除。卷積是一種運算，類似加減乘除。卷積是一種運算，類似加減乘除。重要的事情再說三次。

  我們再次想一想，在之前的文章中，我們普遍都建立了一種想法是，把輸入資料拉成一條直線輸入的，這就意味著我們在之前的任務裡面只建立了相鄰輸入資料之間的左右關聯。但是我們可以想一想，是不是所有的資料只建立左右關聯就行了呢？顯而易見的，並不是這樣的，比如我們圖片，可能上下左右4個畫素加起來才是一個貓，如果我們只關聯了左右，那麼它可能是狗或者貓。那麼我們應該通過什麼樣的方式來對圖片畫素的這種二維關聯性進行描述或者計算呢？這種方法就是卷積運算。

  卷積網上有許許多多的介紹，大家都做了許多詳細的解答，包含訊號分析、複利、概率以及影象濾波等等方面的解釋。我個人認為我們可以拋開這些方面，從資料之間的關聯性來看這個問題可能是最好理解的，因為我們之前只關注了資料之間左右關聯，我們應該同時關注上下左右的關聯才對，我們要從空間的角度來考慮資料之間的關聯性。而卷積作為一種數學運算，他恰好是計算了資料的上下左右關聯性，因此卷積這種數學運算很適合拿來代替之前的一條線的線性運算。

  下面我們來看一下一個基本的卷積計算過程是什麼樣子的。

影象邊緣檢測例項

  計算程式碼如下：

  1. def corr2d(X, K): #@save
  2.     """計算⼆維互相關運算。"""
  3.     h, w = K.shape
  4.     Y = np.zeros((X.shape[0] - h + 1, X.shape[1] - w + 1))
  6.     for i in range(Y.shape[0]):
  7.         for j in range(Y.shape[1]):
  8.             Y[i, j] = (X[i:i + h, j:j + w] * K).sum()
  10.     return Y
  12. _X = np.ones((6, 8))
  13. _X[0:2, 2:6] = 0
  14. _X[3:, 2:6] = 0
  15. print(_X)
  16. _K = np.array([[1.0, -1.0]])
  17. _Y = corr2d(_X, _K)
  18. print(_Y)
  19. _Y = corr2d(_X, _K.T)
  20. print(_Y)

  結果如圖：

  我們可以分別的看到，影象邊緣的數值在經過我們手動構造的濾波器後，成功的檢測到邊緣資訊。

  在實際情況中，我們可能要學習邊緣，角點等等特徵，這個時候我們不可能手動去構造我們的濾波器，那麼我們可不可以通過學習的方式把濾波器學習出來呢？下面通過例項來演示：

  1. _X = np.ones((6, 8))
  2. _X[0:2, 2:6] = 0
  3. _X[3:, 2:6] = 0
  4. print(_X)
  5. _K = np.array([[1.0, -1.0]])
  6. _Y = corr2d(_X, _K)
  7. print(_Y)
  8. # _Y = corr2d(_X, _K.T)
  9. # print(_Y)
  11. X = torch.from_numpy(_X)
  12. X.requires_grad = True
  13. X = X.to(dtype=torch.float32)
  14. X = X.reshape(1, 1, 6, 8)
  16. Y = torch.from_numpy(_Y)
  17. Y.requires_grad = True
  19. conv2d = torch.nn.Conv2d(1, 1, (1, 2), bias=False)
  21. for i in range(20):
  22.     y_train = conv2d(X)
  23.     l = (y_train - Y)**2
  25.     conv2d.zero_grad()
  27.     # print(l.shape)
  28.     l.backward(torch.ones_like(l))
  30.     # print(conv2d.weight)
  31.     with torch.no_grad():
  32.         # print('grad = ', conv2d.weight.grad)
  33.         conv2d.weight[:] -= 0.02 * conv2d.weight.grad
  34.     # print(conv2d.weight)
  35.     # print(conv2d.weight.shape)
  36.     if (i + 1) % 2 == 0:
  37.         print(f'batch {i+1}, loss {float(l.sum()):.3f}')
  39. print(conv2d.weight)

  結果如圖：

  我們通過corr2d函式構造出特徵Y，然後我們通過訓練特徵Y，我們可以看到最終卷積層的權重就是接近與1和-1，恰好等於我們構造的特殊濾波器。

  這個例項說明了，我們可以通過學習的方式來學習出一個我們想要的濾波器，不需要手動構造。

  此外卷積還有卷積核、步長、填充等等資料，我就不造輪子了，網上有很多大佬寫的很好的，大家去看看。此外這裡有個公式非常有用：N=(W-K+2P)/S+1。

池化

  我們在上文知道了卷積的輸出結果代表了一片上下左右資料的關聯性，比如一個畫素和之前的9個畫素有關聯，比如一個\(9*9\)的圖，經過一個卷積後，假如還是\(9*9\)，這個時候輸出的\(9*9\)裡面的每個畫素我們已經和之前對應位置的一片畫素建立了關聯。但是某些時候，我們希望這種關聯性聚合起來，通過求最大值或者平均等等，這就是池化的概念。以之前例子為例：卷積輸出了\(9*9\)的畫素，經過池化之後，假如變成了\(3*3\)，我們可以看到池化輸出的每個畫素代表之前卷積輸出的\(3*3\)個畫素，這代表我們的資訊聚集了，因為一個畫素代表了上一層的多個畫素。

  注意池化，我們還可以從視野的角度來看待，還是和上面的例子一樣，假如原圖上的貓是\(9*9\)的畫素，經過卷積池化之後，假如變成了\(3*3\)， 這意味著我們從畫素的角度來說，之前81個畫素代表貓，現在9個畫素就可以代表了，也就是之前的一個畫素和現在的一個畫素代表的原圖視野不一樣了，形成了視野放大的感覺。但是有一個缺點就是，這可能導致小目標丟失了，這個在目標檢測裡面會關注到。

一個經典神經網路LeNet5

  在2017年12月份，我的這篇文章中《LeNet-5 論文及原理分析(笨鳥角度)》 （ https://blog.csdn.net/u011728480/article/details/78799672 ）其實當時我為了學習一些基本知識，也對LeNet5的論文中網路結構部分做了細緻的分析。

  注意本文中的C3層和論文中的C3層不一樣。本文的C3層是\(16*6*(5*5+1) = 2496\)個引數。論文原文是\(6*(3*5*5+1)+6*(4*5*5+1)+3*(4*5*5+1)+1* (6*5*5+1)=1516\)個引數。

  訓練程式碼如下：

  1. import numpy as np
  2. from numpy.lib.utils import lookfor
  3. import torch
  5. from torchvision.transforms import ToTensor
  6. import os
  7. import torch
  8. from torch import nn
  9. from torch.nn.modules import activation
  10. from torch.nn.modules import linear
  11. from torch.nn.modules.linear import Linear
  12. from torch.utils.data import DataLoader
  13. from torchvision import datasets, transforms
  15. import visdom
  17. vis = visdom.Visdom(env='main')
  19. title = 'LeNet5 on ' + 'FashionMNIST'
  20. legend = ['TrainLoss', 'TestLoss', 'TestAcc']
  22. epoch_plot_window = vis.line(
  23.         X=torch.zeros((1, 3)).cpu(),
  24.         Y=torch.zeros((1, 3)).cpu(),
  25.         win='epoch_win',
  26.         opts=dict(
  27.             xlabel='Epoch',
  28.             ylabel='Loss/Acc',
  29.             title=title,
  30.             legend=legend
  31.         ))
  33. def corr2d(X, W): #@save
  34.     """計算⼆維互相關運算。"""
  35.     h, w = W.shape
  36.     Y = np.zeros((X.shape[0] - h + 1, X.shape[1] - w + 1))
  38.     for i in range(Y.shape[0]):
  39.         for j in range(Y.shape[1]):
  40.             Y[i, j] = (X[i:i + h, j:j + w] * W).sum()
  42.     return Y
  44. def TrainConv2d():
  45.     _X = np.ones((6, 8))
  46.     _X[0:2, 2:6] = 0
  47.     _X[3:, 2:6] = 0
  48.     print(_X)
  49.     _K = np.array([[1.0, -1.0]])
  50.     _Y = corr2d(_X, _K)
  51.     print(_Y)
  52.     # _Y = corr2d(_X, _K.T)
  53.     # print(_Y)
  55.     X = torch.from_numpy(_X)
  56.     X.requires_grad = True
  57.     X = X.to(dtype=torch.float32)
  58.     X = X.reshape(1, 1, 6, 8)
  60.     Y = torch.from_numpy(_Y)
  61.     Y.requires_grad = True
  63.     conv2d = torch.nn.Conv2d(1, 1, (1, 2), bias=False)
  65.     for i in range(20):
  66.         y_train = conv2d(X)
  67.         l = (y_train - Y)**2
  69.         conv2d.zero_grad()
  71.         # print(l.shape)
  72.         l.backward(torch.ones_like(l))
  74.         # print(conv2d.weight)
  75.         with torch.no_grad():
  76.             # print('grad = ', conv2d.weight.grad)
  77.             conv2d.weight[:] -= 0.02 * conv2d.weight.grad
  78.         # print(conv2d.weight)
  79.         # print(conv2d.weight.shape)
  80.         if (i + 1) % 2 == 0:
  81.             print(f'batch {i+1}, loss {float(l.sum()):.3f}')
  83.     print(conv2d.weight)
  85. class NeuralNetwork(nn.Module):
  86.     def __init__(self):
  87.         super(NeuralNetwork, self).__init__()
  88.         self.lenet5 = nn.Sequential(
  89.             # 6*28*28---->6*28*28
  90.             nn.Conv2d(1, 6, (5, 5), stride=1, padding=2),
  91.             nn.Sigmoid(),
  93.             # 6*28*28----->6*14*14
  94.             nn.AvgPool2d((2, 2), stride=2, padding=0),
  96.             # 6*14*14----->16*10*10
  97.             nn.Conv2d(6, 16, (5, 5), stride=1),
  98.             nn.Sigmoid(),
  100.             # 16*10*10------>16*5*5
  101.             nn.AvgPool2d((2, 2), stride=2, padding=0),
  103.             nn.Flatten(),
  105.             nn.Linear(16*5*5, 1*120),
  106.             nn.Sigmoid(),
  108.             nn.Linear(1*120, 1*84),
  109.             nn.Sigmoid(),
  111.             nn.Linear(1*84, 1*10)
  112.         )
  114.     def forward(self, x):
  115.         logits = self.lenet5(x)
  116.         return logits
  118. def LoadFashionMNISTByTorchApi():
  119.     # 60000*28*28
  120.     training_data = datasets.FashionMNIST(
  121.         root="..\data",
  122.         train=True,
  123.         download=True,
  124.         transform=ToTensor()
  125.     )
  127.     # 10000*28*28
  128.     test_data = datasets.FashionMNIST(
  129.         root="..\data",
  130.         train=False,
  131.         download=True,
  132.         transform=ToTensor()
  133.     )
  135.     # labels_map = {
  136.     #     0: "T-Shirt",
  137.     #     1: "Trouser",
  138.     #     2: "Pullover",
  139.     #     3: "Dress",
  140.     #     4: "Coat",
  141.     #     5: "Sandal",
  142.     #     6: "Shirt",
  143.     #     7: "Sneaker",
  144.     #     8: "Bag",
  145.     #     9: "Ankle Boot",
  146.     # }
  147.     # figure = plt.figure(figsize=(8, 8))
  148.     # cols, rows = 3, 3
  149.     # for i in range(1, cols * rows + 1):
  150.     #     sample_idx = torch.randint(len(training_data), size=(1,)).item()
  151.     #     img, label = training_data[sample_idx]
  152.     #     figure.add_subplot(rows, cols, i)
  153.     #     plt.title(labels_map[label])
  154.     #     plt.axis("off")
  155.     #     plt.imshow(img.squeeze(), cmap="gray")
  156.     # plt.show()
  157.     return training_data, test_data
  159. def train_loop(dataloader, model, loss_fn, optimizer):
  160.     size = len(dataloader.dataset)
  161.     num_batches = len(dataloader)
  162.     loss_sum = 0
  163.     for batch, (X, y) in enumerate(dataloader):
  164.         # move X, y to gpu
  165.         if torch.cuda.is_available():
  166.             X = X.to('cuda')
  167.             y = y.to('cuda')
  168.         # Compute prediction and loss
  169.         pred = model(X)
  170.         loss = loss_fn(pred, y)
  172.         # Backpropagation
  173.         optimizer.zero_grad()
  174.         loss.backward()
  175.         optimizer.step()
  177.         loss_sum += loss.item()
  178.         if batch % 100 == 0:
  179.             loss1, current = loss.item(), batch * len(X)
  180.             print(f"loss: {loss1:>7f}  [{current:>5d}/{size:>5d}]")
  182.     return loss_sum/num_batches
  184. def test_loop(dataloader, model, loss_fn):
  185.     size = len(dataloader.dataset)
  186.     num_batches = len(dataloader)
  187.     test_loss, correct = 0, 0
  189.     with torch.no_grad():
  190.         for X, y in dataloader:
  191.             # move X, y to gpu
  192.             if torch.cuda.is_available():
  193.                 X = X.to('cuda')
  194.                 y = y.to('cuda')
  195.             pred = model(X)
  196.             test_loss += loss_fn(pred, y).item()
  197.             correct += (pred.argmax(1) == y).type(torch.float).sum().item()
  199.     test_loss /= num_batches
  200.     correct /= size
  201.     print(f"Test Error: \n Accuracy: {(100*correct):>0.1f}%, Avg loss: {test_loss:>8f} \n")
  203.     return test_loss, correct
  205. if __name__ == '__main__':
  206.     # TrainConv2d()
  208.     device = 'cuda' if torch.cuda.is_available() else 'cpu'
  209.     print('Using {} device'.format(device))
  211.     def init_weights(m):
  212.         if type(m) == nn.Linear or type(m) == nn.Conv2d:
  213.             nn.init.xavier_uniform_(m.weight)
  215.     model = NeuralNetwork()
  216.     model.apply(init_weights)
  217.     model = model.to(device)
  218.     print(model)
  220.     batch_size = 200
  221.     learning_rate = 0.9
  223.     training_data, test_data = LoadFashionMNISTByTorchApi()
  224.     train_dataloader = DataLoader(training_data, batch_size, shuffle=True)
  225.     test_dataloader = DataLoader(test_data, batch_size, shuffle=True)
  226.     loss_fn = nn.CrossEntropyLoss()
  227.     optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)
  229.     epochs = 1000
  231.     model.train()
  232.     for t in range(epochs):
  233.         print(f"Epoch {t+1}\n-------------------------------")
  234.         train_loss = train_loop(train_dataloader, model, loss_fn, optimizer)
  235.         test_loss, test_acc = test_loop(test_dataloader, model, loss_fn)
  237.         vis.line(np.array([train_loss, test_loss, test_acc]).reshape(1, 3),
  238.             np.ones((1, 3))*t,
  239.             win='epoch_win',
  240.             update=None if t == 0 else 'append',
  241.             opts=dict(
  242.                 xlabel='Epoch',
  243.                 ylabel='Loss/Acc',
  244.                 title=title,
  245.                 legend=legend
  246.             )
  247.         )
  248.     print("Done!")
  250.     # only save param
  251.     torch.save(model.state_dict(), 'lenet5.pth')
  253.     # save param and net
  254.     torch.save(model, 'lenet5-all.pth')
  256.     # export onnx
  257.     input_image = torch.zeros((1,1,28,28))
  258.     input_image = input_image.to(device)
  259.     torch.onnx.export(model, input_image, 'model.onnx')

  結果如圖：

  我們從訓練視覺化介面上可以看到，我們的模型確實是收斂了，但是不幸的是準確率大概有90%左右，而且存在過擬合現象。注意這裡我們這個模型，由於有Sigmoid層，導致了很容易出現梯度消失的情況，為了加快訓練，所以學習率設定的很大。

後記

  整理本系列的基礎知識的原因是需要加深對深度學習的理解。同時跟著參考資料，重複試驗，重複執行。對我個人而言，只有真實的寫了程式碼之後，才能夠理解的更加透徹。

  本文也是此係列的終篇，以後更新隨緣。

參考文獻

打賞、訂閱、收藏、丟香蕉、硬幣，請關注公眾號（攻城獅的搬磚之路）

PS: 請尊重原創，不喜勿噴。

PS: 要轉載請註明出處，本人版權所有。

PS: 有問題請留言，看到後我會第一時間回覆。