1.0 深度学习回顾与PyTorch简介

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=W1Xh=W_1Xh=W1X

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

y^=W2a\hat{y}=W_2ay^=W2a

这一实现完全使用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)，所以支持所有的元组操作。

加法操作