【PyTorch】PyTorch深度学习实践|视频学习笔记|P1-P5

PyTorch深度学习实践

线性模型

1. 课堂例题——穷举可视化y=w·x关于权重w取值的情况

①对给定数据训练一个线性模型，但是不知道权重w取什么值训练效果更好
——穷举法，在一个确定的范围内，按照一定间隔对权重w进行采样并计算不同情况下的损失值
绘制出误差值和权重值之间的函数曲线，就可以判断最优权重值的取值

②绘图法在深度学习中常用来确定算法中的超参数值，如epoch；
也会利用可视化工具来检查当前模型的训练程度，来判断是否出现过拟合或欠拟合的状况

import numpy as np
import matplotlib.pyplot as plt

#实现定义好数据集的x值和y值
x_data = [1.0,2.0,3.0]
y_data = [2.0,4.0,6.0]

#定义预测函数，因为是要确定损失值随着w的变化情况
#后续会给定w的值，所以参数只有x
def forward(x):
    return x*w

#定义损失函数的计算方式，仅针对一个样本而言
def loss(x,y):
    y_pred = forward(x)
    return (y-y_pred) * (y-y_pred)

# 程序的目的是为了比较mse和w之间的关系，所以要把其二者的结果对应放入列表中
w_list = []
mse_list = []

#根据老师说的【穷举法】思想，在一个确定的范围找到mse和w之间的关系
for w in np.arange(0.0,4.1,0.1):
    print('w = ',w)
    l_sum = 0#存放所有样本的损失函数值
    for x_val,y_val in zip(x_data,y_data):
        y_pred_val = format(x_val)
        loss_val = loss(x_val,y_val)
        l_sum += loss_val
        print('\t',x_val,y_val,y_pred_val,loss_val)
    print('MSE=',l_sum / 3)
    w_list.append(w)
    mse_list.append(l_sum / 3)

plt.plot(w_list,mse_list)
plt.ylabel('Loss')
plt.xlabel('w')
plt.show()

2. 课后习题——穷举并可视化y=w·x+b关于权重对(w,b)的情况

【note】
①np.meshgrid()就是将给定的x轴和y轴分别的一维向量，转换生成所包含的二维平面区域的二维向量，生成两个二维向量，都是[y_dim,x_dim]大小的，其中依次从两个二维向量取出坐标组成的点优先按照x轴进行变化。

②三维函数绘制模板：
fig = plt.figure()
ax = Axes3D(fig
ax.plot_surface(x,y,z)

import numpy as np
import matplotlib.pyplot as plt
from matplotlib import cm
from mpl_toolkits.mplot3d import Axes3D

#实现定义好数据集的x值和y值
x_data = [1.0,2.0,3.0]
y_data = [2.0,4.0,6.0]

#定义预测函数，因为是要确定损失值随着w的变化情况
#后续会给定w,b的值，所以参数只有x
def forward(x):
    return x*w+b

#定义损失函数的计算方式，仅针对一个样本而言
def loss(x,y):
    y_pred = forward(x)
    return (y-y_pred) * (y-y_pred)

# 程序的目的是为了比较mse和w之间的关系，所以要把其二者的结果对应放入列表中
w_list = np.arange(0.0,4.1,0.1)
b_list = np.arange(-2.0,2.1,0.1)
mse_list = []
ww,bb = np.meshgrid(w_list,b_list)
#根据老师说的【穷举法】思想，在一个确定的范围找到mse和w、b之间的关系
for b in b_list:
    for w in w_list:
        print('w ={0},b = {0}'.format(w, b))
        l_sum = 0  # 存放所有样本的损失函数值
        for x_val, y_val in zip(x_data, y_data):
            y_pred_val = forward(x_val)
            loss_val = loss(x_val, y_val)
            l_sum += loss_val
            print('\t', x_val, y_val, y_pred_val, loss_val)
        print('MSE=', l_sum / 3)
        mse_list.append(l_sum / 3)
mse = np.array(mse_list).reshape(w_list.shape[0],b_list.shape[0])

#h = plt.contourf(w_list,b_list,mse)#绘制二维等高线图
fig = plt.figure()
ax = Axes3D(fig)
plt.ylabel('b')
plt.xlabel('w')
ax.plot_surface(ww,bb,mse,rstride=1, cstride=1, cmap=cm.viridis)

plt.show()

梯度下降算法

1. 穷举法的弊端

按照上面一讲，我们使用穷举法罗列出所有可能的权重取值情况，然后通过可视化工具来寻找其中的最优解，这是有很多弊端的：

• 其一，随着权重个数的增多，搜素的空间会呈指数型增长
• 其二，最优解的分布与权重的关系可能很复杂，不能用简单的线性搜索去解决

2. 分治法的弊端

按照我们传统算法设计思路，我么也会联想到用分治法：

• 其一，在现在深度学习网络中，权重参数实在过多，分治法也很难应付；
• 其二，分治法很容易陷入局部最优的困境中

3. 贪心法

所谓梯度下降法，就是在每一步权重更新时，沿着当前负梯度方向（最小化问题）按照规定的步长进行下一步搜寻。

• 本质就是贪心算法——也就是按照当前最优的策略进行搜寻；
• 贪心算法并不一定能得到最优结果，梯度下降算法也是一样，不一定总能找到全局最优解；
• 虽然梯度下降算法存在着这样的问题，但是它依然被广泛应用于深度学习之中，因为在深度学习模型所使用的激活函数中“局部最优”的问题并不显著，反而更应该关注“鞍点”梯度消失的问题。

4. 梯度下降与随机梯度下降

①比较其二者的权重更新公式

• 所谓随机梯度下降，就是每次只随机取一个数据点计算其损失值，并根据这一个样本的损失值进行梯度求解，权重更新；
• 随机梯度下降和梯度下降都是batch-梯度下降的特况
  

②随机梯度下降的特点

• 可以辅助解决“鞍点”的问题，因为在真实场景中采集到的数据都是有噪声的，噪声带进来的随机偏差就有可能帮助训练走出“梯度消失”的困境；
• 但是因为每两个数据点之间的训练是相互关联的，所以随机梯度下降算法中对于不同数据点函数值的计算不可以采取并行的技术；
• batch-梯度下降的提出就可以很好地兼顾梯度下降的并行化技术和随机梯度下降的优化性能

'''
梯度下降代码示例（含绘图）
'''
import numpy as np
import matplotlib.pyplot as plt
from matplotlib import cm
from mpl_toolkits.mplot3d import Axes3D

#实现定义好数据集的x值和y值
x_data = [1.0,2.0,3.0]
y_data = [2.0,4.0,6.0]

#定义好初始权重
w = 1.0

#定义预测函数，因为是要确定损失值随着w的变化情况
#后续会根据计算的梯度值来动态更新权重w
def forward(x):
    return x*w

#定义损失函数的计算方式，使用梯度下降算法，计算数据集内所有样本的损失MSE
def cost(x,y):
    cost = 0
    for x_i,y_i in zip(x,y):
        y_i_p = forward(x_i)
        cost += (y_i_p-y_i) ** 2
    return cost / len(x)

#d定义梯度的计算方式，根据MSE的公式得到梯度的一般表达式
def gradient(x,y):
    grad = 0
    for x_i,y_i in zip(x,y):
        grad += 2 * x_i * (x_i * w - y_i)
    return grad / len(x)

print('Predict (before training)',4,forward(4))
epochs = []
costs = []
#按照梯度下降算法进行训练
for epoch in range(100):
    epochs.append(epoch)
    cost_val = cost(x_data,y_data)
    costs.append(cost_val)#如果对用于绘制表格的数据也使用round操作，则图形的锯齿形会很明显不平滑
    grad_val = gradient(x_data,y_data)
    w -= 0.01 * grad_val
    print('Epoch:',epoch,'w=',round(w,2),'loss=',round(cost_val,2))
print('Predict (after training)',4,round(forward(4),2))

plt.plot(epochs,costs)
plt.ylabel('Cost')
plt.xlabel('Epoch')
plt.show()

'''
随机梯度下降代码示例（含绘图）
'''
import numpy as np
import random
import matplotlib.pyplot as plt
from matplotlib import cm
from mpl_toolkits.mplot3d import Axes3D

#实现定义好数据集的x值和y值
x_data = [1.0,2.0,3.0]
y_data = [2.0,4.0,6.0]

#定义好初始权重
w = 1.0

#定义预测函数，因为是要确定损失值随着w的变化情况
#后续会根据计算的梯度值来动态更新权重w
def forward(x):
    return x*w

#定义损失函数的计算方式，使用梯度下降算法，计算传入的某一样本的损失MSE
def loss(x,y):
    y_pred = forward(x)
    return (y-y_pred)**2

#d定义梯度的计算方式，根据MSE的公式得到梯度的一般表达式
def gradient(x,y):
    return 2 * x * (x * w - y)

print('Predict (before training)',4,forward(4))
epochs = []
costs = []
#按照梯度下降算法进行训练
for epoch in range(100):
    index = random.randint(0,2)#随机抽取数据集中的样本
    x = x_data[index]
    y = y_data[index]
    grad = gradient(x,y)
    w -= 0.01 * grad
    print('\tgrad：',x,y,round(grad,2))
    l = loss(x,y)#其实本质来说，只要能推导出梯度计算的一般公式，以及对权重进行更新,loss的计算只是为了输出而已
    epochs.append(epoch)
    costs.append(l)
    print('Epoch:',epoch,'w=',round(w,2),'loss=',round(l,2))
print('Predict (after training)',4,round(forward(4),2))

plt.plot(epochs,costs)
plt.ylabel('Cost')
plt.xlabel('Epoch')
plt.show()

反向传播

1. 使用Pytorch进行线性模型y=w*x的训练（有关Pytorch的一些tips）

• 在定义forward函数、loss函数的过程实质上就是在定义和绘制一个计算图
• 在计算loss的过程中，因为w是一个需要记录梯度的tensor，所以计算过程中梯度就保存下来了
• 每一次运行backward实质上就是计算图的释放过程，所以下一次再计算loss的时候，实质上是重新绘制了一个计算图；之所以采用这种机制，是因为在神经网络训练过程中每一次的计算图并不一定是与前一次保持一致的
• 权重tensor中含有这个权重的数据data以及损失函数关于这个权重的梯度grad，但是梯度grad本身也是一个tensor类——tensor类直接进行数学运算，数学符号会进行重载，是在进行张量之间的运算，实质上是在构建计算图；
  要想直接对数据进行运算，则需要取出其中的data（tensor.data）来进行；因为对权重进行数值更新的这一过程，将来不需要利用这个过程计算梯度，因此也不需要保留相应的计算图；
  同理对标量的取出是用tensor.item，防止产生计算图；在训练的过程中如果把数值操作写成张量操作，则很有可能导致计算图模型不断累加，从而撑爆内存。
• 虽然每一次后向传播可以取得更新的梯度值，并且会将计算图瓦解，但框架会一直保留张量中的梯度值，所以每次对权重更新完，进行下一次迭代之前都要先将梯度值清零

import numpy as np
import torch
import random
import matplotlib.pyplot as plt
from matplotlib import cm
from mpl_toolkits.mplot3d import Axes3D

#实现定义好数据集的x值和y值
x_data = [1.0,2.0,3.0]
y_data = [2.0,4.0,6.0]

#定义好初始权重,使用张量;为了使用计算图的反向传播，需要记录梯度值
w = torch.Tensor([1.0])
w.requires_grad = True

#定义前向计算过程，实质上是构建计算图，使用张量运算
def forward(x):
    return x*w

#定义损失函数的计算方式，构建计算图，为后续BP做准备，也是针对某一个数据点而言的
def loss(x,y):
    y_pred = forward(x)
    return (y-y_pred)**2


print('Predict (before training)',4,forward(4).item())
epochs = []
costs = []
#使用计算图模型，按照BP算法计算梯度并更新权值
for epoch in range(100):
    epochs.append(epoch)
    for x,y in zip(x_data,y_data):
        l = loss(x,y)
        l.backward()
        print('\tgrad：', x, y, round(w.grad.item(), 2))
        w.data -= 0.01 * w.grad.item()

        w.grad.data.zero_()#每一次对权重更新完后都需要将梯度清零
    costs.append(l.item())
    print('progress:',epoch,l.item())

print('Predict (after training)',4,round(forward(4).item(),2))

plt.plot(epochs,costs)
plt.ylabel('Cost')
plt.xlabel('Epoch')
plt.show()

反向传播就是网络加深版的梯度下降，其过程：
①先计算整个模型的损失（前向传播）
②反向传播，得到梯度值
③对权重进行更新
pytorch框架相当于把梯度计算函数（对loss函数进行求导，以及多层嵌套函数的求导链式法则）给提前封装好进行调用了

p.s. 因此在实际应用中使用梯BP算法，我们只需要根据实际问题定义好损失函数即可

2. 课后作业——使用PyTorch训练二次多项式：y=w₁x²+w₂x+b

• 计算图模型
  
• python程序

import numpy as np
import torch
import random
import matplotlib.pyplot as plt
from matplotlib import cm
from mpl_toolkits.mplot3d import Axes3D

#实现定义好数据集的x值和y值
x_data = [1.0,2.0,3.0]
y_data = [2.0,4.0,6.0]

#定义好初始权重,使用张量;为了使用计算图的反向传播，需要记录梯度值
w_1 = torch.Tensor([1.0])
w_2 = torch.Tensor([1.0])
b = torch.Tensor([1.0])
w_1.requires_grad = True
w_2.requires_grad = True
b.requires_grad = True

#定义前向计算过程，实质上是构建计算图，使用张量运算
def forward(x):
    return x ** 2 * w_1 + x * w_2 + b

#定义损失函数的计算方式，构建计算图，为后续BP做准备，也是针对某一个数据点而言的
def loss(x,y):
    y_pred = forward(x)
    return (y-y_pred)**2


print('Predict (before training)',4,round(forward(4).item(),2))
epochs = []
costs = []
#使用计算图模型，按照BP算法计算梯度并更新权值
for epoch in range(100):
    epochs.append(epoch)
    for x,y in zip(x_data,y_data):
        l = loss(x,y)
        l.backward()
        print('\tgrad：', x, y, round(w_1.grad.item(), 2),round(w_2.grad.item(), 2),round(b.grad.item(), 2))
        w_1.data -= 0.01 * w_1.grad.item()
        w_2.data -= 0.01 * w_2.grad.item()
        b.data -= 0.01 * b.grad.item()

        w_1.grad.data.zero_()#每一次对权重更新完后都需要将梯度清零
        w_2.grad.data.zero_()
        b.grad.data.zero_()
    costs.append(l.item())
    print('progress:',epoch,l.item())

print('Predict (after training)',4,round(forward(4).item(),2))

plt.plot(epochs,costs)
plt.ylabel('Cost')
plt.xlabel('Epoch')
plt.show()

用PyTorch实现线性回归

流程与代码实现

• 使用PyTorch构建训练模型的一般步骤：
  ①准备数据集
  ②使用相关类构建模型，用以计算预测值
  ③使用PyTorch的应用接口来构建损失函数和优化器
  ④编写循环迭代的训练过程——前向计算，反向传播和梯度更新，训练过程如下——
  • 根据前向计算计算y^hat
  • 使用损失函数类计算损失函数值
  • 进行反向传播，注意梯度清零
  • 权重更新

• 任务重点发生变化：
  ①以前手动写训练过程代码时，关键在于计算损失函数的梯度值的一般表达式
  ②现在使用pytorch包构建模型时，关键在于构建计算图

• 数据维度处理
  ①输入和输出都需要构建成矩阵形式；
  ②在神经网络模型的构建中，最重要的结构就是线性单元，其中要想确定权重w和偏置项b的维度，首先需要明确输入值x和输出值y^hat的输出维度；
  ③根据问题的不同形式，x和y的形状各异，这也导致了最终得到的损失函数可能是标量，向量或矩阵；但不管loss是什么形式，最后进行反向传播前，都要计算出loss的一个标量值。
  p.s. 比如对loss向量的每一个单元求和，如果不取标量出来，就会对计算图进行累加操作，从而使得内存被撑爆。

import numpy as np
import torch
import random
import matplotlib.pyplot as plt
from matplotlib import cm
from mpl_toolkits.mplot3d import Axes3D

#实现定义好数据集的x值和y值
x_data = torch.tensor([[1.0],[2.0],[3.0]])
y_data = torch.tensor([[2.0],[4.0],[6.0]])


#构建训练模型
class LinearModel(torch.nn.Module):
    def __init__(self):
        super(LinearModel,self).__init__()#继承父类
        self.linear = torch.nn.Linear(1,1)#定义一个线性计算单元，继承Module块，也可以自主实现反向传播

    def forward(self,x):
        y_pred = self.linear(x)#可调用对象，进行了相应的forward计算
        return y_pred

model = LinearModel()#对实现的模型类进行实例化，同样也是可调用的

#构建损失函数的计算和优化器
criterion = torch.nn.MSELoss(size_average = False)#计算均值与否本质上只是线性系数的差别
optimizer = torch.optim.SGD(model.parameters(),lr = 0.01)#调用所继承父类的函数找到当前需要训练的参数列表

epochs = []
costs = []
#训练过程
for epoch in range(100):
    epochs.append(epoch)
    y_pred = model(x_data)
    loss = criterion(y_pred,y_data)
    costs.append(loss.item())
    print(epoch,loss)#因为这里loss是个对象，print在调用的时候会自动进行__str__()的解析

    optimizer.zero_grad()#一定要注意梯度归零
    loss.backward()
    optimizer.step()#进行梯度的更新，对参数列表中包含的参数使用预先设置的学习率进行更新

#对训练结果进行输出
print('w = ',model.linear.weight.item())
print('b = ',model.linear.bias.item())#使用.item()因为w和b都是张量对象

#进行模型测试
x_test = torch.Tensor([[4.0]])
y_test = model(x_test)
print('y_pred = ',y_test.data)

#训练过程可视化
plt.plot(epochs,costs)
plt.ylabel('Cost')
plt.xlabel('Epoch')
plt.show()

PyTorch相关知识

①nn.Linear类中对__call()__方法进行了实现，且其内部有对函数forward()的调用，故在定义模型时需要对forward()函数进行实现。

②nn.Linear类相当于是对线性计算单元的封装，里面包含两个张量类型的成员：权重和偏置项


③根据下图所示按照MSE规则计算损失函数的过程，它也是一个计算图，是需要继承自nn.Module模块的，我们所调用的nn.MSELoss就是继承自该模块的类。


④代码中模型与类之间的关系：

课后作业

比较不同优化器下的线性回归并可视化
p.s.因为LBFGS的setp()调用方法具有特殊性，以下并未对LBFGS进行实现

import numpy as np
import torch
import random
import matplotlib.pyplot as plt
from matplotlib import cm
from mpl_toolkits.mplot3d import Axes3D

#实现定义好数据集的x值和y值
x_data = torch.tensor([[1.0],[2.0],[3.0]])
y_data = torch.tensor([[2.0],[4.0],[6.0]])


#构建训练模型
class LinearModel(torch.nn.Module):
    def __init__(self):
        super(LinearModel,self).__init__()#继承父类
        self.linear = torch.nn.Linear(1,1)#定义一个线性计算单元，继承Module块，也可以自主实现反向传播

    def forward(self,x):
        y_pred = self.linear(x)#可调用对象，进行了相应的forward计算
        return y_pred

model1 = LinearModel()  # 定义的模型结构初始化
model2 = LinearModel()
model3 = LinearModel()
model4 = LinearModel()
model5 = LinearModel()
#model6 = LinearModel()
model7 = LinearModel()
model8 = LinearModel()
models = [model1,model2,model3,model4,model5,model7,model8]
#构建损失函数的计算和优化器
criterion = torch.nn.MSELoss(size_average = False)

op1 = torch.optim.SGD(model1.parameters(),lr = 0.01)#以下分别尝试不同的优化器
op2 = torch.optim.Adagrad(model2.parameters(),lr = 0.01)
op3 = torch.optim.Adam(model3.parameters(),lr = 0.01)
op4 = torch.optim.Adamax(model4.parameters(),lr = 0.01)
op5 = torch.optim.ASGD(model5.parameters(),lr = 0.01)
#op6 = torch.optim.LBFGS(model6.parameters(),lr = 0.01)
op7 = torch.optim.RMSprop(model7.parameters(),lr = 0.01)
op8 = torch.optim.Rprop(model8.parameters(),lr = 0.01)
ops = [op1,op2,op3,op4,op5,op7,op8]

titles = ['SGD','Adagrad','Adam','Adamax','ASGD','RNSprop','Rprop']

fig,ax = plt.subplots(2,4,figsize = (20,10),dpi = 100)
#ax[0][0].imshow()
#训练过程，对每个优化器都进行尝试
index = 0
for item in zip(ops,models):#分别尝试每个优化器
    epochs = []
    costs = []

    model = item[1]
    op = item[0]

    for epoch in range(100):
        epochs.append(epoch)
        y_pred = model(x_data)
        loss = criterion(y_pred, y_data)
        costs.append(loss.item())
        print(epoch, loss)

        op.zero_grad()
        loss.backward()
        op.step()

    # 对训练结果进行输出
    print('w = ', model.linear.weight.item())
    print('b = ', model.linear.bias.item())

    # 进行模型测试
    x_test = torch.Tensor([[4.0]])
    y_test = model(x_test)
    print('y_pred = ', y_test.data)

    # 训练过程可视化
    #plt.subplots(2,1,index)
    a = int(index /4)
    b = int(index % 4)
    ax[a][b].set_ylabel('Cost')
    ax[a][b].set_xlabel('Epoch')
    ax[a][b].set_title(titles[index])
    ax[a][b].plot(epochs, costs)
    index += 1
plt.show()