P1 深度學習回顧與PyTorch簡介

視頻課程地址：點我 fly~~~

本節課主要偏向于NLP，因為作者本人是做NLP方向NLP

預訓練三種模型：

BERT

OpenAI GPT

ELMo

【NLP】OpenAI GPT算法理解

【NLP】OpenAI GPT2詳解

如何成為PyTorch大神？

• 學好深度學習的基礎知識
• 學習PyTorch官方tutorial https://pytorch.org/docs/stable/index.html
• 學習Github以及各種博客上的教程（別人創建好的list）
• 閱讀documentation，使用論壇 https://discuss.pytorch.org
• 跑通以及學習開源PyTorch項目
• 閱讀深度學習模型paper，學習別人的模型實現
• 通過閱讀paper，自己實現模型
• 自己創造模型（也可以寫paper）

課程安排

• PyTorch框架與autograd入門，簡單前向神經網絡
• 詞向量
• 圖像分類，CNN，遷移學習
• 語言模型，情感分類，RNN，LSTM，GRU
• 閱讀理解，EIMo，BERT，GPT-2
• 聊天機器人
• GAN，Face generation，Style Transfer

什么是PyTorch？

PyTorch是一個基于Python的科學計算庫，它有以下特點：

• 類似于numpy，但可以使用GPU
• 可以用它定義深度學習模型，可以靈活地進行深度學習模型的訓練和使用

Tensor

Tensor類似于Numpy的ndarray，唯一的區別是Tensor可以在GPU加速運算

tensor本質上是一個高維度數據

之后所講內容為官方中文教程 點我 fly~~~

if torch.cuda.is_available():device = torch.device("cuda")y = torch.ones_like(x, device=device)x = x.to(device)z = x + yprint(z)print(z.to("cpu", torch.double))

默認產生tensor是在cpu，之后搬運到gpu進行運行。如果tensor運行在GPU上，需要和numpy結合，那還需要將tensor轉移到cpu上，因為numpy是在cpu上運行的的此段知識是視頻 56’ 位置

熱身項目：用numpy實現兩層神經網絡

一個全連接ReLU神經網絡，一個隱藏層，沒有bias。用來從x預測y，使用L2 Loss。

$$h=W_{1}X$$

$$a=max(0,h)$$

$$\hat{y}=W_{2}a$$

這一實現完全使用numpy來計算前向神經網絡，loss，和反向傳播

• forward pass
• loss
• backward pass

numpy ndarray是一個普通的n維array。它不知道任何關于深度學習或者梯度（gradient）的知識，也不知道計算圖（Computation graph），只是一種用來計算數學運算的數據結構。因此，非常適合鞏固初學者對網絡的計算過程的理解。代碼如下：

import numpy as np import torchN, D_in, H, D_out = 64, 1000, 100, 10# 隨機創建一些訓練數據 # x = np.random.randn(N, D_in) # y = np.random.randn(N, D_out) x = torch.randn(N, D_in) y = torch.randn(N, D_out) # w1 = np.random.randn(D_in, H) w1 = torch.randn(D_in, H) b1 = 0 # w2 = np.random.randn(H, D_out) w2 = torch.randn(H, D_out) b2 = 0learning_rate = 1e-6 for iteration in range(500):# Forward pass# h = x.dot(w1) + b1h = x.mm(w1) + b1# h_relu = np.maximum(h, 0)h_relu = h.clamp(min=0)# y_pred = h.dot(w2) + b2y_pred = h_relu.mm(w2) + b2# Compute loss# loss = np.square(y_pred - y).sum()loss = (y_pred - y).pow(2).sum().item()print(iteration, loss)# Backward pass# Compute gradientgrad_y_pred = 2.0 * (y_pred - y)# grad_w2 = h_relu.T.dot(grad_y_pred)grad_w2 = h_relu.t().mm(grad_y_pred)# grad_h_relu = grad_y_pred.dot(w2.T)grad_h_relu = grad_y_pred.mm(w2.t())# grad_h = grad_h_relu.copy()grad_h = grad_h_relu.clone()grad_h[h<0] = 0# grad_w1 = x.T.dot(grad_h)grad_w1 = x.t().mm(grad_h)# Update weights of w1 and w2w1 -= learning_rate * grad_w1w2 -= learning_rate * grad_w2

如果需要在gpu上運行，需要將tensor搬運到gpu
代碼如下：

x = torch.randn(2,3).gpu() x = torch.randn(2,3).cuda() x = torch.randn(2,3).to("cuda:0")

PyTorch：Tensor和autograd

PyTorch的一個重要功能就是autograd，只要定義了forward pass，計算loos之后，PyTorch可以自動求導計算模型的所有參數的梯度。
一個PyTorch的Tensor表示計算圖中的一個節點。如果x是一個Tensor并且x.requires_grad=True，那么x.grad就是另一個存儲著x當前梯度（相對于一個scalar，常常是loss）的向量。

import numpy as np import torchN, D_in, H, D_out = 64, 1000, 100, 10# 隨機創建一些訓練數據 x = torch.randn(N, D_in) y = torch.randn(N, D_out)w1 = torch.randn(D_in, H, requires_grad=True) b1 = 0 w2 = torch.randn(H, D_out, requires_grad=True) b2 = 0learning_rate = 1e-6 for iteration in range(500):# Forward passy_pred = x.mm(w1).clamp(min=0).mm(w2)# Compute lossloss = (y_pred - y).pow(2).sum() # Computation graphprint(iteration, loss.item())# Backward passloss.backward()# Update weights of w1 and w2with torch.no_grad():grad_w1 = w1.gradw1 -= learning_rate * w1.gradw2 -= learning_rate * w2.gradw1.grad.zero_()w2.grad.zero_()

Pytorch：nn

使用PyTorch中的nn這個庫來構建網絡。用PyTorch autograd來構建計算圖和計算gradient，然后PyTorch會幫我們自動計算gradient。

import numpy as np import torch import torch.nn as nnN, D_in, H, D_out = 64, 1000, 100, 10# 隨機創建一些訓練數據 x = torch.randn(N, D_in) y = torch.randn(N, D_out)model = torch.nn.Sequential(torch.nn.Linear(D_in, H, bias=False), # w_1 * x + b_1torch.nn.ReLU(),torch.nn.Linear(H, D_out), )torch.nn.init.normal_(model[0].weight) torch.nn.init.normal_(model[2].weight)# model = model.cuda() loss_fn = nn.MSELoss(reduction='sum')learning_rate = 1e-6 for iteration in range(500):# Forward passy_pred = model(x) # model.forward() w1, w2# Compute lossloss = loss_fn(y_pred, y) # Computation graphprint(iteration, loss.item())model.zero_grad()# Backward passloss.backward()# Update weights of w1 and w2with torch.no_grad():for param in model.parameters():param -= learning_rate * param.grad

錯誤解決：vscode中解決Module ‘torch’ has no ‘randn’ member
解決方法： https://blog.csdn.net/yinizhilianlove/article/details/105560705

PyTorch：optim

這次不再手動更新模型的weights，而是使用optim這個包來幫助我們更新參數。optim這個package提供了各種不同的模型優化方法，包括SGD+momentum，RMSProp，Adam等

import numpy as np import torch import torch.nn as nnN, D_in, H, D_out = 64, 1000, 100, 10# 隨機創建一些訓練數據 x = torch.randn(N, D_in) y = torch.randn(N, D_out)model = torch.nn.Sequential(torch.nn.Linear(D_in, H, bias=False), # w_1 * x + b_1torch.nn.ReLU(),torch.nn.Linear(H, D_out), )torch.nn.init.normal_(model[0].weight) torch.nn.init.normal_(model[2].weight)# model = model.cuda() loss_fn = nn.MSELoss(reduction='sum')# learning_rate = 1e-4 # optimizer = torch.optim.Adam(model.parameters(), lr = learning_rate)learning_rate = 1e-6 optimizer = torch.optim.SGD(model.parameters(), lr = learning_rate)learning_rate = 1e-6 for iteration in range(500):# Forward passy_pred = model(x) # model.forward() w1, w2# Compute lossloss = loss_fn(y_pred, y) # Computation graphprint(iteration, loss.item())optimizer.zero_grad()# Backward passloss.backward()# Update model parametersoptimizer.step()

PyTorch：自定義 nn Modules

我們可以定義一個模型，這個模型繼承自nn.Module類。如果需要定義一個比Sequential模型更加復雜的模型，就需要定義nn.Module模型。

import numpy as np import torch import torch.nn as nnN, D_in, H, D_out = 64, 1000, 100, 10# 隨機創建一些訓練數據 x = torch.randn(N, D_in) y = torch.randn(N, D_out)class TwoLayerNet(torch.nn.Module):def __init__(self, D_in, H, D_out):super(TwoLayerNet, self).__init__()self.linear1 = torch.nn.Linear(D_in, H, bias=False)self.linear2 = torch.nn.Linear(H, D_out, bias=False)def forward(self, x):y_pred = self.linear2(self.linear1(x).clamp(min=0))return y_predmodel = TwoLayerNet(D_in, H, D_out)# model = model.cuda() loss_fn = nn.MSELoss(reduction='sum')learning_rate = 1e-4 optimizer = torch.optim.Adam(model.parameters(), lr = learning_rate)learning_rate = 1e-6 for iteration in range(500):# Forward passy_pred = model(x) # model.forward() w1, w2# Compute lossloss = loss_fn(y_pred, y) # Computation graphprint(iteration, loss.item())optimizer.zero_grad()# Backward passloss.backward()# Update model parametersoptimizer.step()

---

PyTorch官方指導書

官方Tutorial：Fly~~~~

導入torch模塊

from __future__ import print_function import torch

創建一個5x3的空矩陣

x = torch.empty(5, 3) print(x)

輸出：

tensor([[8.9082e-39, 5.9694e-39, 8.9082e-39],[1.0194e-38, 9.1837e-39, 4.6837e-39],[9.9184e-39, 9.0000e-39, 1.0561e-38],[1.0653e-38, 4.1327e-39, 8.9082e-39],[9.8265e-39, 9.4592e-39, 1.0561e-38]])

創建一個5x3的隨機初始化矩陣

x = torch.rand(5, 3) print(x)

輸出：

tensor([[0.4371, 0.6971, 0.4599],[0.3556, 0.6624, 0.2540],[0.3188, 0.3508, 0.3638],[0.6647, 0.5225, 0.7168],[0.3429, 0.7412, 0.1596]])

創建一個5x3的零矩陣

x = torch.zeros(5,3, dtype=torch.long) print(x)

輸出：

tensor([[0, 0, 0],[0, 0, 0],[0, 0, 0],[0, 0, 0],[0, 0, 0]])

直接創建一個數據矩陣

x = torch.tensor([5.5, 3]) print(x)

輸出：

tensor([5.5000, 3.0000])

使用 new_* 方法在已存在張量的基礎上創建一個新的張量。這個方法將會重復使用輸入張量的屬性，除非用戶提供新的屬性值。

x = x.new_ones(5, 3, dtype=torch.double) # new_* methods take in sizes print(x)x = torch.randn_like(x, dtype=torch.float) # override dtype! print(x) # result has the same size

輸出：

tensor([[1., 1., 1.],[1., 1., 1.],[1., 1., 1.],[1., 1., 1.],[1., 1., 1.]], dtype=torch.float64) tensor([[ 0.6503, -0.5242, 0.7353],[-0.5807, -0.4139, 0.1632],[-1.1790, 0.1280, 0.8522],[-0.8748, -1.4256, -0.1768],[-0.5329, 1.9356, -1.0310]])

獲得尺寸

print(x.size())

輸出：

torch.Size([5, 3])

提示：torch.Size本質上是一個元組(tuple)，所以支持所有的元組操作。

加法操作

總結

以上是生活随笔為你收集整理的1.0 深度学习回顾与PyTorch简介 - PyTorch学习笔记的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。