從頭開始了解PyTorch的簡單實現
來自專欄 機器之心
選自GitHub上,機器之心編譯。
本教程展示了如何從了解張量開始到使用PyTorch訓練簡單的神經網路,是非常基礎的PyTorch入門資源.PyTorch建立在Python和火炬庫之上,並提供了一種類似Numpy的抽象方法來表徵量(或多維數組),它還能利用GPU來提升性能。本教程的代碼並不完整,詳情請查看原Jupyter Notebook文檔。
PyTorch 使入門深度學習變得簡單,即使你這方面的背景知識不太充足。至少,知道多層神經網路模型可視為由權重連接的節點圖就是有幫助的,你可以基於前向和反向傳播,利用優化過程(如梯度計算)從數據中估計權重。
- 必備知識:該教程假設讀者熟悉 Python 和 NumPy。
- 必備軟體:在運行原 Jupyter Notebook 之前你需要安裝 PyTorch。原 Notebook 有代碼單元格可供驗證你是否做好準備。
- 必備硬體:你需要安裝 NVIDIA GPU 和 CUDA SDK。據報告此舉可能實現 10-100 的加速。當然,如果你沒有進行此設置,那麼你仍然可以在僅使用 CPU 的情況下運行 PyTorch。但是,記住,在訓練神經網路模型時,生命苦短!所以還是儘可能使用 GPU 吧!
項目地址:https://github.com/hpcgarage/accelerated_dl_pytorch
1. 必要的 PyTorch 背景
- PyTorch 是一個建立在 Torch 庫之上的 Python 包,旨在加速深度學習應用。
- PyTorch 提供一種類似 NumPy 的抽象方法來表徵張量(或多維數組),它可以利用 GPU 來加速訓練。
1.1 PyTorch 張量
PyTorch 的關鍵數據結構是張量,即多維數組。其功能與 NumPy 的 ndarray 對象類似,如下我們可以使用 torch.Tensor() 創建張量。
# Generate a 2-D pytorch tensor (i.e., a matrix)pytorch_tensor = torch.Tensor(10, 20)print("type: ", type(pytorch_tensor), " and size: ", pytorch_tensor.shape )
如果你需要一個兼容 NumPy 的表徵,或者你想從現有的 NumPy 對象中創建一個 PyTorch 張量,那麼就很簡單了。
# Convert the pytorch tensor to a numpy array:numpy_tensor = pytorch_tensor.numpy()print("type: ", type(numpy_tensor), " and size: ", numpy_tensor.shape)# Convert the numpy array to Pytorch Tensor:print("type: ", type(torch.Tensor(numpy_tensor)), " and size: ", torch.Tensor(numpy_tensor).shape)
1.2 PyTorch vs. NumPy
PyTorch 並不是 NumPy 的簡單替代品,但它實現了很多 NumPy 功能。其中有一個不便之處是其命名規則,有時候它和 NumPy 的命名方法相當不同。我們來舉幾個例子說明其中的區別:
1 張量創建
t = torch.rand(2, 4, 3, 5)a = np.random.rand(2, 4, 3, 5)
2 張量分割
t = torch.rand(2, 4, 3, 5)a = t.numpy()pytorch_slice = t[0, 1:3, :, 4]numpy_slice = a[0, 1:3, :, 4]print (Tensor[0, 1:3, :, 4]:
, pytorch_slice)print (NdArray[0, 1:3, :, 4]:
, numpy_slice)-------------------------------------------------------------------------Tensor[0, 1:3, :, 4]: 0.2032 0.1594 0.3114 0.9073 0.6497 0.2826[torch.FloatTensor of size 2x3]NdArray[0, 1:3, :, 4]: [[ 0.20322084 0.15935552 0.31143939] [ 0.90726137 0.64966112 0.28259504]]
3 張量 Masking
t = t - 0.5a = t.numpy()pytorch_masked = t[t > 0]numpy_masked = a[a > 0]
4 張量重塑
pytorch_reshape = t.view([6, 5, 4])numpy_reshape = a.reshape([6, 5, 4])
1.3 PyTorch 變數
- PyTorch 張量的簡單封裝
- 幫助建立計算圖
- Autograd(自動微分庫)的必要部分
- 將關於這些變數的梯度保存在 .grad 中
結構圖:
計算圖和變數:在 PyTorch 中,神經網路會使用相互連接的變數作為計算圖來表示。PyTorch 允許通過代碼構建計算圖來構建網路模型;之後 PyTorch 會簡化估計模型權重的流程,例如通過自動計算梯度的方式。
舉例來說,假設我們想構建兩層模型,那麼首先要為輸入和輸出創建張量變數。我們可以將 PyTorch Tensor 包裝進 Variable 對象中:
from torch.autograd import Variableimport torch.nn.functional as Fx = Variable(torch.randn(4, 1), requires_grad=False)y = Variable(torch.randn(3, 1), requires_grad=False)
我們把 requires_grad 設置為 True,表明我們想要自動計算梯度,這將用於反向傳播中以優化權重。
現在我們來定義權重:
w1 = Variable(torch.randn(5, 4), requires_grad=True)w2 = Variable(torch.randn(3, 5), requires_grad=True)
訓練模型:
def model_forward(x): return F.sigmoid(w2 @ F.sigmoid(w1 @ x))print (w1)print (w1.data.shape)print (w1.grad) # Initially, non-existent-------------------------------------------------------------------------Variable containing: 1.6068 -1.3304 -0.6717 -0.6097-0.3414 -0.5062 -0.2533 1.0260-0.0341 -1.2144 -1.5983 -0.1392-0.5473 0.0084 0.4054 0.0970 0.3596 0.5987 -0.0324 0.6116[torch.FloatTensor of size 5x4]torch.Size([5, 4])None
1.4 PyTorch 反向傳播
這樣我們有了輸入和目標、模型權重,那麼是時候訓練模型了。我們需要三個組件:
損失函數:描述我們模型的預測距離目標還有多遠;
import torch.nn as nncriterion = nn.MSELoss()
優化演算法:用於更新權重;
import torch.optim as optimoptimizer = optim.SGD([w1, w2], lr=0.001)
反向傳播步驟:
for epoch in range(10): loss = criterion(model_forward(x), y) optimizer.zero_grad() # Zero-out previous gradients loss.backward() # Compute new gradients optimizer.step() # Apply these gradientsprint (w1)-------------------------------------------------------------------------Variable containing: 1.6067 -1.3303 -0.6717 -0.6095-0.3414 -0.5062 -0.2533 1.0259-0.0340 -1.2145 -1.5983 -0.1396-0.5476 0.0085 0.4055 0.0976 0.3597 0.5986 -0.0324 0.6113[torch.FloatTensor of size 5x4]
1.5 PyTorch CUDA 介面
PyTorch 的優勢之一是為張量和 autograd 庫提供 CUDA 介面。使用 CUDA GPU,你不僅可以加速神經網路訓練和推斷,還可以加速任何映射至 PyTorch 張量的工作負載。
你可以調用 torch.cuda.is_available() 函數,檢查 PyTorch 中是否有可用 CUDA。
cuda_gpu = torch.cuda.is_available()if (cuda_gpu): print("Great, you have a GPU!")else: print("Life is short -- consider a GPU!")
很好,現在你有 GPU 了。
.cuda()
之後,使用 cuda 加速代碼就和調用一樣簡單。如果你在張量上調用 .cuda(),則它將執行從 CPU 到 CUDA GPU 的數據遷移。如果你在模型上調用 .cuda(),則它不僅將所有內部儲存移到 GPU,還將整個計算圖映射至 GPU。
要想將張量或模型複製回 CPU,比如想和 NumPy 交互,你可以調用 .cpu()。
if cuda_gpu: x = x.cuda() print(type(x.data))x = x.cpu()print(type(x.data))-------------------------------------------------------------------------<class torch.cuda.FloatTensor><class torch.FloatTensor>
我們來定義兩個函數(訓練函數和測試函數)來使用我們的模型執行訓練和推斷任務。該代碼同樣來自 PyTorch 官方教程,我們摘選了所有訓練/推斷的必要步驟。
對於訓練和測試網路,我們需要執行一系列動作,這些動作可直接映射至 PyTorch 代碼:
1. 我們將模型轉換到訓練/推斷模式;
2. 我們通過在數據集上成批獲取圖像,以迭代訓練模型;
3. 對於每一個批量的圖像,我們都要載入數據和標註,運行網路的前向步驟來獲取模型輸出;
4. 我們定義損失函數,計算每一個批量的模型輸出和目標之間的損失;
5. 訓練時,我們初始化梯度為零,使用上一步定義的優化器和反向傳播,來計算所有與損失有關的層級梯度;
6. 訓練時,我們執行權重更新步驟。
def train(model, epoch, criterion, optimizer, data_loader): model.train() for batch_idx, (data, target) in enumerate(data_loader): if cuda_gpu: data, target = data.cuda(), target.cuda() model.cuda() data, target = Variable(data), Variable(target) output = model(data) optimizer.zero_grad() loss = criterion(output, target) loss.backward() optimizer.step() if (batch_idx+1) % 400 == 0: print(Train Epoch: {} [{}/{} ({:.0f}%)] Loss: {:.6f}.format( epoch, (batch_idx+1) * len(data), len(data_loader.dataset), 100. * (batch_idx+1) / len(data_loader), loss.data[0]))def test(model, epoch, criterion, data_loader): model.eval() test_loss = 0 correct = 0 for data, target in data_loader: if cuda_gpu: data, target = data.cuda(), target.cuda() model.cuda() data, target = Variable(data), Variable(target) output = model(data) test_loss += criterion(output, target).data[0] pred = output.data.max(1)[1] # get the index of the max log-probability correct += pred.eq(target.data).cpu().sum() test_loss /= len(data_loader) # loss function already averages over batch size acc = correct / len(data_loader.dataset) print(
Test set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)
.format( test_loss, correct, len(data_loader.dataset), 100. * acc)) return (acc, test_loss)
現在介紹完畢,讓我們開始這次數據科學之旅吧!
2. 使用 PyTorch 進行數據分析
- 使用 torch.nn 庫構建模型
- 使用 torch.autograd 庫訓練模型
- 將數據封裝進 torch.utils.data.Dataset 庫
- 使用 NumPy interface 連接你的模型、數據和你最喜歡的工具
在查看複雜模型之前,我們先來看個簡單的:簡單合成數據集上的線性回歸,我們可以使用 sklearn 工具生成這樣的合成數據集。
from sklearn.datasets import make_regressionimport seaborn as snsimport pandas as pdimport matplotlib.pyplot as pltsns.set()x_train, y_train, W_target = make_regression(n_samples=100, n_features=1, noise=10, coef = True)df = pd.DataFrame(data = {X:x_train.ravel(), Y:y_train.ravel()})sns.lmplot(x=X, y=Y, data=df, fit_reg=True)plt.show()x_torch = torch.FloatTensor(x_train)y_torch = torch.FloatTensor(y_train)y_torch = y_torch.view(y_torch.size()[0], 1)
PyTorch 的 nn 庫中有大量有用的模塊,其中一個就是線性模塊。如名字所示,它對輸入執行線性變換,即線性回歸。
class LinearRegression(torch.nn.Module): def __init__(self, input_size, output_size): super(LinearRegression, self).__init__() self.linear = torch.nn.Linear(input_size, output_size) def forward(self, x): return self.linear(x)model = LinearRegression(1, 1)
要訓練線性回歸,我們需要從 nn 庫中添加合適的損失函數。對於線性回歸,我們將使用 MSELoss()——均方差損失函數。
我們還需要使用優化函數(SGD),並運行與之前示例類似的反向傳播。本質上,我們重複上文定義的 train() 函數中的步驟。不能直接使用該函數的原因是我們實現它的目的是分類而不是回歸,以及我們使用交叉熵損失和最大元素的索引作為模型預測。而對於線性回歸,我們使用線性層的輸出作為預測。
criterion = torch.nn.MSELoss()optimizer = torch.optim.SGD(model.parameters(), lr=0.1) for epoch in range(50): data, target = Variable(x_torch), Variable(y_torch) output = model(data) optimizer.zero_grad() loss = criterion(output, target) loss.backward() optimizer.step()predicted = model(Variable(x_torch)).data.numpy()
現在我們可以列印出原始數據和適合 PyTorch 的線性回歸。
plt.plot(x_train, y_train, o, label=Original data)plt.plot(x_train, predicted, label=Fitted line)plt.legend()plt.show()
為了轉向更複雜的模型,我們下載了 MNIST 數據集至「datasets」文件夾中,並測試一些 PyTorch 中可用的初始預處理。PyTorch 具備數據載入器和處理器,可用於不同的數據集。數據集下載好後,你可以隨時使用。你還可以將數據包裝進 PyTorch 張量,創建自己的數據載入器類別。
批大小(batch size)是機器學習中的術語,指一次迭代中使用的訓練樣本數量。批大小可以是以下三種之一:
- batch 模式:批大小等於整個數據集,因此迭代和 epoch 值一致;
- mini-batch 模式:批大小大於 1 但小於整個數據集的大小。通常,數量可以是能被整個數據集整除的值。
- 隨機模式:批大小等於 1。因此梯度和神經網路參數在每個樣本之後都要更新。
from torchvision import datasets, transformsbatch_num_size = 64train_loader = torch.utils.data.DataLoader( datasets.MNIST(data,train=True, download=True, transform=transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,)) ])), batch_size=batch_num_size, shuffle=True)test_loader = torch.utils.data.DataLoader( datasets.MNIST(data,train=False, transform=transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,)) ])), batch_size=batch_num_size, shuffle=True)
3. PyTorch 中的 LeNet 卷積神經網路(CNN)
現在我們從頭開始創建第一個簡單神經網路。該網路要執行圖像分類,識別 MNIST 數據集中的手寫數字。這是一個四層的卷積神經網路(CNN),一種分析 MNIST 數據集的常見架構。該代碼來自 PyTorch 官方教程,你可以在這裡(http://pytorch.org/tutorials/)找到更多示例。
我們將使用 torch.nn 庫中的多個模塊:
1. 線性層:使用層的權重對輸入張量執行線性變換;
2. Conv1 和 Conv2:卷積層,每個層輸出在卷積核(小尺寸的權重張量)和同樣尺寸輸入區域之間的點積;
3. Relu:修正線性單元函數,使用逐元素的激活函數 max(0,x);
4. 池化層:使用 max 運算執行特定區域的下採樣(通常 2x2 像素);
5. Dropout2D:隨機將輸入張量的所有通道設為零。當特徵圖具備強相關時,dropout2D 提升特徵圖之間的獨立性;
6. Softmax:將 Log(Softmax(x)) 函數應用到 n 維輸入張量,以使輸出在 0 到 1 之間。
class LeNet(nn.Module): def __init__(self): super(LeNet,self).__init__() self.conv1 = nn.Conv2d(1,10,kernel_size=5) self.conv2 = nn.Conv2d(10,20,kernel_size=5) self.conv2_drop = nn.Dropout2d() self.fc1 = nn.Linear(320,50) self.fc2 = nn.Linear(50,10) def forward(self,x): x = F.relu(F.max_pool2d(self.conv1(x),2)) x = F.relu(F.max_pool2d(self.conv2_drop(self.conv2(x)),2)) x = x.view(-1, 320) x = F.relu(self.fc1(x)) x = F.dropout(x, training=self.training) x = self.fc2(x) return F.log_softmax(x, dim=1)
創建 LeNet 類後,創建對象並移至 GPU:
model = LeNet()if cuda_gpu: model.cuda()print (MNIST_net model:
)print (model)-------------------------------------------------------------------------MNIST_net model:LeNet( (conv1): Conv2d(1, 10, kernel_size=(5, 5), stride=(1, 1)) (conv2): Conv2d(10, 20, kernel_size=(5, 5), stride=(1, 1)) (conv2_drop): Dropout2d(p=0.5) (fc1): Linear(in_features=320, out_features=50, bias=True) (fc2): Linear(in_features=50, out_features=10, bias=True))
要訓練該模型,我們需要使用帶動量的 SGD,學習率為 0.01,momentum 為 0.5。
criterion = nn.CrossEntropyLoss() optimizer = optim.SGD(model.parameters(),lr = 0.005, momentum = 0.9)
僅僅需要 5 個 epoch(一個 epoch 意味著你使用整個訓練數據集來更新訓練模型的權重),我們就可以訓練出一個相當準確的 LeNet 模型。這段代碼檢查可以確定文件中是否已有預訓練好的模型。有則載入;無則訓練一個並保存至磁碟。
import os epochs = 5if (os.path.isfile(pretrained/MNIST_net.t7)): print (Loading model) model.load_state_dict(torch.load(pretrained/MNIST_net.t7, map_location=lambda storage, loc: storage)) acc, loss = test(model, 1, criterion, test_loader)else: print (Training model) for epoch in range(1, epochs + 1): train(model, epoch, criterion, optimizer, train_loader) acc, loss = test(model, 1, criterion, test_loader) torch.save(model.state_dict(), pretrained/MNIST_net.t7)-------------------------------------------------------------------------Loading modelTest set: Average loss: 0.0471, Accuracy: 9859/10000 (99%)
現在我們來看下模型。首先,列印出該模型的信息。列印函數顯示所有層(如 Dropout 被實現為一個單獨的層)及其名稱和參數。同樣有一個迭代器在模型中所有已命名模塊之間運行。當你具備一個包含多個「內部」模型的複雜 DNN 時,這有所幫助。在所有已命名模塊之間的迭代允許我們創建模型解析器,可讀取模型參數、創建與該網路類似的模塊。
print (Internal models:)for idx, m in enumerate(model.named_modules()): print(idx, ->, m) print (-------------------------------------------------------------------------)#輸出:Internal models:0 -> (, LeNet( (conv1): Conv2d(1, 10, kernel_size=(5, 5), stride=(1, 1)) (conv2): Conv2d(10, 20, kernel_size=(5, 5), stride=(1, 1)) (conv2_drop): Dropout2d(p=0.5) (fc1): Linear(in_features=320, out_features=50, bias=True) (fc2): Linear(in_features=50, out_features=10, bias=True)))-------------------------------------------------------------------------1 -> (conv1, Conv2d(1, 10, kernel_size=(5, 5), stride=(1, 1)))-------------------------------------------------------------------------2 -> (conv2, Conv2d(10, 20, kernel_size=(5, 5), stride=(1, 1)))-------------------------------------------------------------------------3 -> (conv2_drop, Dropout2d(p=0.5))-------------------------------------------------------------------------4 -> (fc1, Linear(in_features=320, out_features=50, bias=True))-------------------------------------------------------------------------5 -> (fc2, Linear(in_features=50, out_features=10, bias=True))-------------------------------------------------------------------------
你可以使用 .cpu() 方法將張量移至 CPU(或確保它在那裡)。或者,當 GPU 可用時(torch.cuda. 可用),使用 .cuda() 方法將張量移至 GPU。你可以看到張量是否在 GPU 上,其類型為 torch.cuda.FloatTensor。如果張量在 CPU 上,則其類型為 torch.FloatTensor。
print (type(t.cpu().data))if torch.cuda.is_available(): print ("Cuda is available") print (type(t.cuda().data))else: print ("Cuda is NOT available")-------------------------------------------------------------------------<class torch.FloatTensor>Cuda is available<class torch.cuda.FloatTensor>
如果張量在 CPU 上,我們可以將其轉換成 NumPy 數組,其共享同樣的內存位置,改變其中一個就會改變另一個。
if torch.cuda.is_available(): try: print(t.data.numpy()) except RuntimeError as e: "you cant transform a GPU tensor to a numpy nd array, you have to copy your weight tendor to cpu and then get the numpy array"print(type(t.cpu().data.numpy()))print(t.cpu().data.numpy().shape)print(t.cpu().data.numpy())
現在我們了解了如何將張量轉換成 NumPy 數組,我們可以利用該知識使用 matplotlib 進行可視化!我們來列印出第一個卷積層的卷積濾波器。
data = model.conv1.weight.cpu().data.numpy()print (data.shape)print (data[:, 0].shape)kernel_num = data.shape[0]fig, axes = plt.subplots(ncols=kernel_num, figsize=(2*kernel_num, 2))for col in range(kernel_num): axes[col].imshow(data[col, 0, :, :], cmap=plt.cm.gray)plt.show()
以上是簡要的教程資源,還有更多的內容和實驗可以查看原項目了解更多。
推薦閱讀:
※起名字這個技術活,終於用Pytorch找到解決辦法了!
※一文搞定Pytorch+CNN講解
※pytorch實現線性回歸
※終於!大家心心念念的PyTorch Windows官方支持來了
※重磅系列課:Pytorch上的深度學習(首節免費試聽)