Pytorch学习 11 神经网络的学习

2021-04-03

梯度下降基本流程：① 在目标函数（损失函数）上随机选择一个初始点。② 通过迭代运算，一步步逼近（损失）函数最小值点。怎么找到最小值的：找到梯度和步长，一步步迭代；像盲人下山一样，用拐棍试探着下。

w(t+1) = w(t) - η( ∂(l) / ∂(w) )

梯度：目标函数对所有偏导数的向量；步长：学习率 * 梯度

一、梯度下降中的两个关键问题

梯度下降目的：

流程：

1.1 怎么找出梯度向量的方向和大小

1.2 让坐标点动起来

注意：

梯度的方向总是比整体函数少一个维度！

二、找出距离和方向：反向传播

2.1 反向传播理论

求导不影响加和，可以先加和再求导，也可以先求导再加和，所以可以先将Σ拿出来。

正向传播：计算损失函数（SSE 或其他）（计算过程中算出 z σ w ）

反向传播：算梯度值——偏导数（链式法则需要正向传播时计算出的 z σ w ）

2.2 Pytorch实现反向传播

2.2.1 正向传播

结合以前正向传播的内容，实现反向传播的例子

上面这一段是以前正向传播的全部内容

2.2.2 反向传播

loss.backward(retain_graph = True)

参数表示：默认False ，True 表示运行反向传播后不销毁计算图，即可以重复运行反向传播

2.2.3 迭代w

为什么是 net.linear1.weight.data 而不是 net.linear1.weight 因为后者有一些附加信息，前者才是纯数据。

2.2.4 加速迭代动量法Momentum

学习率低的时候，迭代速度非常慢，有什么好的办法加速迭代吗？

自己实现

Pytorch 自带模块实现

2.3 总结：实现一轮梯度下降的全流程

# 1.导入库
# 2.确定数据、超参数的确定（lr，gamma）
# 3.定义神经网络的架构类Model，类Model需要输入的参数
# 4.实例化神经网络类 - 让神经网络准备好进行正向传播
# 5.定义损失函数
# 6.定义优化算法

import torch
import torch.nn as nn
import torch.optim as optim
from torch.nn import CrossEntropyLoss as CEL
from torch.nn import functional as F

# 确定数据
torch.random.manual_seed(420)
X = torch.rand((500, 20), dtype = torch.float32) * 100
y = torch.randint(low = 0, high = 3, size = (500,), dtype = torch.float32)

# 确定超参数
lr = 0.1
gamma = 0.9

# 定义神经网络的架构类Model，类Model需要输入的参数
class Model(nn.Module):
    def __init__(self, in_features = 10, out_features = 2):
        super().__init__()
        self.linear1 = nn.Linear(in_features, 13, bias = False)  
        self.linear2 = nn.Linear(13, 8, bias = False)
        self.output = nn.Linear(8, out_features, bias = True)
        
    def forward(self, x):
        sigma1 = torch.relu(self.linear1(x))
        sigma2 = torch.sigmoid(self.linear2(sigma1))
        #zhat = F.softmax(self.output(sigma2), dim = 1)
        zhat = self.output(sigma2)
        return zhat
    
input_ = X.shape[1]  # 特征的数目
output_ = len(y.unique())  # 分类的数目

# 实例化神经网络类 - 让神经网络准备好进行正向传播
torch.manual_seed(420)
net = Model(in_features = input_, out_features = output_)

# 定义损失函数
criterion = CEL()

# 定义优化算法
opt = optim.SGD(net.parameters()#需要进行迭代的权重
                ,lr = lr #学习率
                ,momentum = gamma #动量参数
                )

# 实现一轮梯度下降
zhat = net.forward(X) # 最后一个线性层的输出结果，向前传播
loss = criterion(zhat, y.reshape(500).long()) # 计算损失函数
loss.backward()
opt.step() # 步子，走一步 w -= ，更新权重w，更新动量v
opt.zero_grad()

print(loss)
print(net.linear1.weight.data[0][:10])

梯度下降的流程：

向前传播

本轮向前传播的损失函数值

反向传播

更新权重（和动量）

清空梯度 - 清除原来计算出来的，基于上一个点的坐标计算的梯度

三、开始迭代：batch_size与epoches

小批量梯度下降 (mini-batchSGD)

梯度下降法缺点：只能找到一个局部极小值，每次更新参数都需要使用所有的样本，如果对所有的样本均计算一次，当样本总数量特别大时，对算法的速度影响非常大。

因此便有了随机梯度下降 (SGD) ，它是对梯度下降算法的一种改进，且每次只随机取一部分样本进行优化，一般是2的整数次幂，范围是 32~256 ，以保证计算精度的同时提升计算速度，是优化深度学习网络中最常用的一类算法。

在深度学习中，SGD 通常指 小批量随机梯度下降 (mini-batchSGD)

为什么说 mini-batchSGD 更容易找到全局最优呢？

自问：为什么 SGD 可能会跳过局部最优，不会跳过全局最优吗？

3.1 Tensordataset 与 DataLoader

Tensordataset

作用：数据打包

条件：被合并对象第一维度上的值相等

导包：from torch.utils.data import TensorDataset

用法：TensorDataset(a,b,c)

Dataloader

作用：用来切割小批量的类

导包：from torch.utils.data import DataLoader

用法：Dataloader(data)

参数

处理后的结构

用 Sklearn 导入后怎么变成神经网络能够读取的小批量数据

用Pandas 导入后怎么变成神经网络能够读取的小批量数据

四、在MNIST-FASHION上实现神经网络的学习流程

4.1 流程

设置超参数：步长lr、动量值gamma、迭代次数epochs、batch_size 等信息，（如果需要）设置初始权重w0

导入数据，将数据切分成 batches

定义神经网络架构

定义损失函数L(w) ，如果需要的话，将损失函数调整成凸函数，以便求解最小值

定义所使用的优化算法

开始在 epoches 和 batch 上循环，执行优化算法：

调整数据结构，确定数据能够够在神经网络、损失函数和优化算法中顺利进行

完成向前传播，计算初始损失

利用反向传播，在损失函数L(w)上对每一个w求偏导数

迭代当前权重

清空本轮梯度

完成模型进度与效果监控 #损失loss、准确率accuracy

输出结果

#实例化数据
mnist = torchvision.datasets.FashionMNIST(root = "E:\PythonWork\DEEP_LEARNING\Datasets" #计算机某个目录，如果有数据就直接用，
                                                                                        #如果没有就自动下载到该目录
                                         , download = True #如果没有找到要不要下载
                                         , train = True #是不是用来训练的数据？ 数据集：训练--大数据集  测试--小数据集
                                         , transform = transforms.ToTensor()#有些数据并不能直接跑，需要进行统一处理
                                                                           #这里的意思是请把我的数据变成tensor
                                         )

4.2 代码

import torch
from torch import nn
from torch import optim
from torch.nn import functional as F
from torch.utils.data import DataLoader, TensorDataset
import torchvision
import torchvision.transforms as transforms

# 1.设置超参数
lr = 0.15
gamma = 0
epochs = 10   # 全部数据学习几次
bs = 128  # batch_size 小批量大小，常用数128

# 2. 导入数据
mnist = torchvision.datasets.FashionMNIST(root = "E:\PythonWork\DEEP_LEARNING\Datasets" #计算机某个目录，如果有数据就直接用，
                                                                                        #如果没有就自动下载到该目录
                                         , download = False #如果没有找到要不要下载
                                         , train = True #是不是用来训练的数据？ 数据集：训练--大数据集  测试--小数据集
                                         , transform = transforms.ToTensor()#有些数据并不能直接跑，需要进行统一处理
                                                                           #这里的意思是请把我的数据变成tensor
                                         )

# 批量划分
batchdata = DataLoader(mnist
                       , batch_size = bs
                       , shuffle = True)

# 准备实例化所需要的参数
input_ = mnist.data[0].numel()   #请问这个张量中 总共有多少个元素呢？
output_ = output_ = len(mnist.targets.unique())


# 3. 定义神经网络架构
class Model(nn.Module):
    def __init__(self, in_features=100, out_features=10):
        super().__init__()
        self.linear1 = nn.Linear(in_features, 128, bias=False)
        self.output = nn.Linear(128, out_features, bias=False)

    def forward(self, x):
        # x 输入的结构的第二个值必须是 28*28
        x = x.view(-1, 28 * 28)
        # view(-1,)的用法，需要对数据结构进行改变，-1作为占位符，表示请pytorch帮助我们自动计算-1这个位置的维度是多少
        sigma1 = torch.relu(self.linear1(x))
        sigma2 = F.log_softmax(self.output(sigma1), dim=1)
        return sigma2


# 定义训练函数（包含损失函数、优化算法、梯度下降的流程）
def fit(net, bachtdata, lr=0.01, epochs=5, gamma=0):
    criterion = nn.NLLLoss()
    opt = optim.SGD(net.parameters(), lr=lr, momentum=gamma)
    samples = 0  # 循环开始之前，模型一个样本都没见过
    correct = 0  # 循环开始之前，预测正确值为0
    for epoch in range(epochs):
        for batch_idx, (x, y) in enumerate(batchdata):
            y = y.view(x.shape[0])  # 降成一维，对于本例中因为 y 本身就是一维的,可以不写
            sigma = net.forward(x)  # 正向传播
            loss = criterion(sigma, y)
            loss.backward()
            opt.step()
            opt.zero_grad()

            # 求解准确率，全部判断正确的样本数量 / 已经看过的总样本量
            yhat = torch.max(sigma, 1)[1]  # torch.max 函数结果中的索引为1的部分，相当于预测标签
            correct += torch.sum(yhat == y)
            samples += x.shape[0]  # 每训练一个batch的数据，模型见过的数据就会增加 x.shape[0]

            if (batch_idx + 1) % 125 == 0 or batch_idx == len(batchdata) - 1:  # 每 N 个 batch 我就打印一次
                # 查看进度
                print("Epoch{}:[{}/{}({:.0f}%) Loss:{:.6f},Accuracy:{:.3f}%]".format(
                    epoch + 1
                    , samples
                    , epochs * len(batchdata.dataset)
                    , 100 * samples / (epochs * len(batchdata.dataset))
                    # 分子代表：已经查看过的数据有多少
                    # 分母代表：在现有epochs数据下，模型一共需要查看多少数据
                    , loss.data.item()
                    , float(100 * correct / samples)))
    print("Finish!")

torch.manual_seed(420)
net = Model(in_features = input_, out_features = output_)
fit(net, batchdata, lr = lr, epochs = epochs, gamma = gamma)

Gavin

Pytorch学习 11 神经网络的学习

一、梯度下降中的两个关键问题

1.1 怎么找出梯度向量的方向和大小

1.2 让坐标点动起来

二、找出距离和方向：反向传播

2.1 反向传播理论

2.2 Pytorch实现反向传播

2.2.1 正向传播

2.2.2 反向传播

2.2.3 迭代w

2.2.4 加速迭代动量法Momentum

2.3 总结：实现一轮梯度下降的全流程

三、开始迭代：batch_size与epoches

3.1 Tensordataset 与 DataLoader

Tensordataset

Dataloader

四、在MNIST-FASHION上实现神经网络的学习流程

4.1 流程

4.2 代码

4.3 运行结果

一、梯度下降中的两个关键问题

1.1 怎么找出梯度向量的方向和大小

1.2 让坐标点动起来

二、找出距离和方向：反向传播

2.1 反向传播理论

2.2 Pytorch实现反向传播

2.2.1 正向传播

2.2.2 反向传播

2.2.3 迭代w

2.2.4 加速迭代 动量法Momentum

2.3 总结：实现一轮梯度下降的全流程

三、开始迭代：batch_size与epoches

3.1 Tensordataset 与 DataLoader

Tensordataset

Dataloader

四、在MNIST-FASHION上实现神经网络的学习流程

4.1 流程

4.2 代码

4.3 运行结果

2.2.4 加速迭代动量法Momentum