四天速成！香港科技大學 PyTorch 課件分享

 2017-10-09 12:49:00.0

原標題：四天速成！香港科技大學 PyTorch 課件分享

機器之心整理

參與：黃小天、蔣思源

前天，香港科技大學計算機系教授 Sung Kim 在 Google Drive 分享了一個 3 天速成的 TensorFlow 極簡入門教程；接着，他在 GitHub 上又分享了一個 3 至 4 日的速成教程，教大家如何使用 PyTorch 進行機器學習／深度學習。Sung Kim 共享了該教程的代碼和 PPT 資源，機器之心對其做了扼要介紹。資源鏈接請見文中。

  • 代碼：https://github.com/hunkim/PyTorchZeroToAll

  • PPT：http://bit.ly/PyTorchZeroAll

  • 百度雲盤：https://pan.baidu.com/s/1cpoyXw

PyTorch 開源於今年一月份，它是使用 GPU 和 CPU 優化的深度學習張量庫，也是一個 Python 工具包，爲目前最流行的深度學習框架之一；它具有兩個高階功能：

  • 帶有強大的 GPU 加速的張量計算（類似 NumPy）

  • 構建在基於 tape 的 autograd 系統之上的深度神經網絡

因此必要之時你可以再利用 Python 工具包比如 NumPy、SciPy 和 Cython 擴展 PyTorch。PyTorch 目前處於早期的 beta 版，還有待進一步完善與更新。通常來講，PyTorch 作爲庫主要包含以下組件：

1. Torch：類似於 NumPy 的張量庫，帶有強大的 GPU 支持

2. torch.autograd：一個基於 tape 的自動微分庫，支持 torch 中的所有的微分張量運算

3. torch.nn：一個專爲最大靈活性而設計、與 autograd 深度整合的神經網絡庫

4. torch.multiprocessing：Python 多運算，但在運算中帶有驚人的 torch 張量內存共享。這對數據加載和 Hogwild 訓練很有幫助。

5. torch.utils：數據加載器、訓練器以及其他便利的實用功能

6. torch.legacy(.nn/.optim)：出於後向兼容性原因而從 torch 移植而來的舊代碼

人們使用 PyTorch 一般出於兩個目的：

  • 代替 NumPy 從而可以使用強大的 GPU

  • PyTorch 作爲深度學習研究平臺提供了最大的靈活性與速度

PyTorch 是由若干個資深工程師和研究者共同發起的社區項目，目前主要的維護人員有 Adam Paszke、Sam Gross、Soumith Chintala 和 Gregory Chanan。

PyTorch 課程目錄

  • 概覽

  • 線性模型

  • 梯度下降

  • 反向傳播

  • PyTorch 線性迴歸

  • Logistic 迴歸

  • 寬&深

  • 數據加載器

  • Softmax 分類器

  • CNN

  • RNN

下面是整個課程的概述：

線性模型

如下爲線性模型的基本思想，我們希望能構建一個線性方程擬合現存的數據點。該線性了方程函數將根據數據點與其距離自動調整權重，權重調整的方法即使用優化算法最小化真實數據與預測數據的距離。

以下爲該線性模型的實現代碼，我們先定義特徵 x 與標註 y，然後將預測值與真實值差的平方作爲損失函數。隨後初始化模型權重並開始前向傳播。

  1. importnumpy asnp

  2. importmatplotlib.pyplot asplt

  4. x_data =[1.0,2.0,3.0]

  5. y_data =[2.0,4.0,6.0]

  8. # our model forward pass

  9. defforward(x):

  10. returnx *w

  13. # Loss function

  14. defloss(x,y):

  15. y_pred =forward(x)

  16. return(y_pred -y)*(y_pred -y)

  19. w_list =[]

  20. mse_list =[]

  22. forw innp.arange(0.0,4.1,0.1):

  23. print("w=",w)

  24. l_sum =0

  25. forx_val,y_val inzip(x_data,y_data):

  26. y_pred_val =forward(x_val)

  27. l =loss(x_val,y_val)

  28. l_sum +=l

  29. print("t",x_val,y_val,y_pred_val,l)

  30. print("NSE=",l_sum /3)

  31. w_list.append(w)

  32. mse_list.append(l_sum /3)

  34. plt.plot(w_list,mse_list)

  35. plt.ylabel('Loss')

  36. plt.xlabel('w')

  37. plt.show()

梯度下降

梯度下降在最優化中又稱之爲最速下降算法，以下爲該算法的基本概念。我們可以看到，若我們希望最小化的損失函數爲凸函數，那麼損失函數對各個權重的偏導數將指向該特徵的極小值。如下當初始權重處於損失函數遞增部分時，那麼一階梯度即損失函數在該點的斜率，且遞增函數的斜率爲正，那麼當前權重減去一個正數將變小，因此權重將沿遞增的反方向移動。同理可得當權重處於遞減函數的情況。

如下我們手動實現了簡單的梯度下降算法。前面還是先定義模型、損失函數，因爲我們已知損失函數的結構，那麼就可以手動對其求導以確定梯度函數的結構。得出了權重梯度的表達式後可以將其代入權重更新的循環語句以定義訓練。

  1. x_data =[1.0,2.0,3.0]

  2. y_data =[2.0,4.0,6.0]

  4. w =1.0# any random value

  7. # our model forward pass

  8. defforward(x):

  9. returnx *w

  12. # Loss function

  13. defloss(x,y):

  14. y_pred =forward(x)

  15. return(y_pred -y)*(y_pred -y)

  18. # compute gradient

  19. defgradient(x,y):# d_loss/d_w

  20. return2*x *(x *w -y)

  22. # Before training

  23. print("predict (before training)",4,forward(4))

  25. # Training loop

  26. forepoch inrange(10):

  27. forx_val,y_val inzip(x_data,y_data):

  28. grad =gradient(x_val,y_val)

  29. w =w -0.01*grad

  30. print("tgrad: ",x_val,y_val,grad)

  31. l =loss(x_val,y_val)

  33. print("progress:",epoch,l)

  35. # After training

  36. print("predict (after training)",4,forward(4))

反向傳播

下圖展示了反向傳播算法的鏈式求導法則與過程。對於反向傳播來說，給定權重下，我們先要計算前向傳播的結果，然後計算該結果與真實值的距離或誤差。隨後將該誤差沿誤差產生的路徑反向傳播以更新權重，在這個過程中誤差會根據求導的鏈式法則進行分配。

以下代碼實現了反向傳播算法，我們可以看到在 PyTorch 中反向傳播的語句爲「loss(x_val, y_val).backward()」，即將損失函數沿反向傳播。

  1. importtorch

  2. fromtorch importnn

  3. fromtorch.autograd importVariable

  6. x_data =[1.0,2.0,3.0]

  7. y_data =[2.0,4.0,6.0]

  9. w =Variable(torch.Tensor([1.0]),requires_grad=True)# Any random value

  11. # our model forward pass

  14. defforward(x):

  15. returnx *w

  17. # Loss function

  20. defloss(x,y):

  21. y_pred =forward(x)

  22. return(y_pred -y)*(y_pred -y)

  24. # Before training

  25. print("predict (before training)",4,forward(4).data[0])

  27. # Training loop

  28. forepoch inrange(10):

  29. forx_val,y_val inzip(x_data,y_data):

  30. l =loss(x_val,y_val)

  31. l.backward()

  32. print("tgrad: ",x_val,y_val,w.grad.data[0])

  33. w.data =w.data -0.01*w.grad.data

  35. # Manually zero the gradients after updating weights

  36. w.grad.data.zero_()

  38. print("progress:",epoch,l.data[0])

  40. # After training

  41. print("predict (after training)",4,forward(4).data[0])

PyTorch 線性迴歸

定義數據：

  1. importtorch

  2. fromtorch.autograd importVariable

  4. x_data =Variable(torch.Tensor([[1.0],[2.0],[3.0]]))

  5. y_data =Variable(torch.Tensor([[2.0],[4.0],[6.0]]))

定義模型，在 PyTorch 中，我們可以使用高級 API 來定義相關的模型或層級。如下定義了「torch.nn.Linear(1, 1)」，即一個輸入變量和一個輸出變量。

  1. classModel(torch.nn.Module):

  3. def__init__(self):

  4. """

  5. In the constructor we instantiate two nn.Linear module

  6. """

  7. super(Model,self).__init__()

  8. self.linear =torch.nn.Linear(1,1)# One in and one out

  10. defforward(self,x):

  11. """

  12. In the forward function we accept a Variable of input data and we must return

  13. a Variable of output data. We can use Modules defined in the constructor as

  14. well as arbitrary operators on Variables.

  15. """

  16. y_pred =self.linear(x)

  17. returny_pred

構建損失函數和優化器，構建損失函數也可以直接使用「torch.nn.MSELoss(size_average=False)」調用均方根誤差函數。優化器可以使用「torch.optim.SGD()」提到用隨機梯度下降，其中我們需要提供優化的目標和學習率等參數。

  1. # Construct our loss function and an Optimizer. The call to model.parameters()

  2. # in the SGD constructor will contain the learnable parameters of the two

  3. # nn.Linear modules which are members of the model.

  4. criterion =torch.nn.MSELoss(size_average=False)

  5. optimizer =torch.optim.SGD(model.parameters(),lr=0.01)

訓練模型，執行前向傳播計算損失函數，並優化參數：

  1. # Training loop

  2. forepoch inrange(500):

  3. # Forward pass: Compute predicted y by passing x to the model

  4. y_pred =model(x_data)

  6. # Compute and print loss

  7. loss =criterion(y_pred,y_data)

  8. print(epoch,loss.data[0])

  10. # Zero gradients, perform a backward pass, and update the weights.

  11. optimizer.zero_grad()

  12. loss.backward()

  13. optimizer.step()

Logistic 迴歸

以下展示了 Logistic 迴歸的基本要素和對應代碼。Logistic 迴歸的構建由以下三種函數組成：Sigmoid 函數、目標函數以及損失函數。下圖分別給出了三種函數的對應代碼。其中 Sigmoid 函數將線性模型演變爲 Logistic 迴歸模型，而損失函數負責創建標準以測量目標與輸出之間的二值交叉熵。

Softmax 分類

以下展示了 Softmax 分類的基本概念，其中最重要的是在最後一層使用了 Softmax 函數。我們可以使用 Softmax 函數將輸出值轉化爲和爲 1 的類別概率。

加載數據集與導入數據加載器：

  1. # MNIST Dataset

  2. train_dataset =datasets.MNIST(root='./data/',

  3. train=True,

  4. transform=transforms.ToTensor(),

  5. download=True)

  7. test_dataset =datasets.MNIST(root='./data/',

  8. train=False,

  9. transform=transforms.ToTensor())

  11. # Data Loader (Input Pipeline)

  12. train_loader =torch.utils.data.DataLoader(dataset=train_dataset,

  13. batch_size=batch_size,

  14. shuffle=True)

  16. test_loader =torch.utils.data.DataLoader(dataset=test_dataset,

  17. batch_size=batch_size,

  18. shuffle=False)

定義模型的架構，並選擇優化器。如下我們可以瞭解該 Softmax 分類模型在前面使用了五個全連接層，並在最後一層使用了 Softmax 函數。例如先使用「l1 = nn.Linear(784, 520)」定義全連接的輸入結點數與輸出結點數，784 爲 MNIST 的像素點數，再使用「F.relu(self.l1(x))」定義該全連接的激活函數爲 ReLU。

  1. classNet(nn.Module):

  3. def__init__(self):

  4. super(Net,self).__init__()

  5. self.l1 =nn.Linear(784,520)

  6. self.l2 =nn.Linear(520,320)

  7. self.l3 =nn.Linear(320,240)

  8. self.l4 =nn.Linear(240,120)

  9. self.l5 =nn.Linear(120,10)

  11. defforward(self,x):

  12. x =x.view(-1,784)# Flatten the data (n, 1, 28, 28)-> (n, 784)

  13. x =F.relu(self.l1(x))

  14. x =F.relu(self.l2(x))

  15. x =F.relu(self.l3(x))

  16. x =F.relu(self.l4(x))

  17. x =F.relu(self.l5(x))

  18. returnF.log_softmax(x)

  20. model =Net()

  22. optimizer =optim.SGD(model.parameters(),lr=0.01,momentum=0.5)

CNN

下圖展示了一個簡單的卷積神經網絡，它由輸入層、卷積層 1、池化層 1、卷積層 2、池化層 2、全連接層組成。其中卷積層 1、2 是二維的，其輸入通道爲 1，輸出通道爲 10，卷積核大小爲 5。其中池化層採用的是最大池化運算。

以下是上圖簡單卷積神經網絡的加載數據：

  1. # MNIST Dataset

  2. train_dataset =datasets.MNIST(root='./data/',

  3. train=True,

  4. transform=transforms.ToTensor(),

  5. download=True)

  7. test_dataset =datasets.MNIST(root='./data/',

  8. train=False,

  9. transform=transforms.ToTensor())

  11. # Data Loader (Input Pipeline)

  12. train_loader =torch.utils.data.DataLoader(dataset=train_dataset,

  13. batch_size=batch_size,

  14. shuffle=True)

  16. test_loader =torch.utils.data.DataLoader(dataset=test_dataset,

  17. batch_size=batch_size,

  18. shuffle=False)

以下代碼定義了上圖卷積神經網絡的架構，並定義了優化器。我們同樣可以使用高級 API 添加捲積層，例如「nn.Conv2d(1, 10, kernel_size=5)」可以添加捲積核爲 5 的卷積層。此外，在卷積層與全連接層之間，我們需要壓平張量，這裏使用的是「x.view(in_size, -1)」。

  1. classNet(nn.Module):

  3. def__init__(self):

  4. super(Net,self).__init__()

  5. self.conv1 =nn.Conv2d(1,10,kernel_size=5)

  6. self.conv2 =nn.Conv2d(10,20,kernel_size=5)

  7. self.mp =nn.MaxPool2d(2)

  8. self.fc =nn.Linear(320,10)

  10. defforward(self,x):

  11. in_size =x.size(0)

  12. x =F.relu(self.mp(self.conv1(x)))

  13. x =F.relu(self.mp(self.conv2(x)))

  14. x =x.view(in_size,-1)# flatten the tensor

  15. x =self.fc(x)

  16. returnF.log_softmax(x)

  19. model =Net()

  21. optimizer =optim.SGD(model.parameters(),lr=0.01,momentum=0.5)

本文爲機器之心整理，轉載請聯繫本公衆號獲得授權。

責任編輯：

文章來源：機器之心