【李沐动手学深度学习】视频课程笔记与重点总结 01-18，从线性回归到pytorch代码

正在努力的鼠鼠

已于 2024-08-20 12:43:09 修改

阅读量897

点赞数 22

文章标签：机器学习深度学习笔记

于 2024-08-15 15:18:24 首次发布

本文链接：https://blog.csdn.net/qq_52589927/article/details/141156454

版权

前言

此文章适用于正在看李沐老师视频课程的同学，按照课程的顺序，简单的总结一下跟李沐学AI的个人空间-跟李沐学AI个人主页-哔哩哔哩视频 (bilibili.com)https://space.bilibili.com/1567748478/channel/seriesdetail?sid=358497更详细的部分可以看如下文档链接（含代码），老师写的非常全面

《动手学深度学习》 — 动手学深度学习 2.0.0 documentationhttps://zh.d2l.ai/

01-06的课程就不赘述了，就是讲了讲数组向量矩阵啥的，以及在python中的实现，所以我个人认为，需要有些数学基础和python语法基础。但我懒得学了，到时候不会再现查吧，有需要可以看上面提到的文档。

线性回归

线性回归：是对n维输入的加权，外加偏差
使用平方损失来衡量预测值和真实值的差异
线性回归：有显示解
线性回归：可以看作单层神经网络

基础优化算法

梯度下降

挑选一个初始值，重复迭代参数（不断沿梯度反方向更新参数）
沿梯度方向：将增加损失函数值
学习率：步长的超参数（选太小墨迹，选太大震荡）

我们最常用的是：小批量随机梯度下降，介绍如下：

深度学习默认求解算法
随机采样 b 个样本来近似整个样本的损失
b：批量大小（太小不好利用，太大消耗资源）

softmax回归

回归

单连续数值输出

自然区间R

跟真实值的区别作为损失

分类

通常多个输出

输出i是预测为第i类的置信度

这儿我没看懂，所以写不出东西，不过应该问题不大

损失函数

y：真实值 y'：预测值

表达了真实值和预测值之间的差距，loss要不断变小，模型训练的越来越好

主要的两种计算loss的方法

L2 Loss公式如下：

L1 Loss公式如下：

这儿也没看懂，貌似还需要链式法则和反向传播的知识

多层感知机

感知机

给定输入x，权重w，和偏移b，感知机输出：

分类效果：只能产生线性的分割面

多层感知机

多个感知机进行融合......
使用隐藏层和激活函数来得到非线性模型
常用激标题三活函数有sigmoid，Tanh，ReLU
使用softmax来处理多分类
超参数：每层隐藏层的大小，隐藏层数

简单实现

单隐藏层单分类

输入：n维向量，隐藏层有m个，输出：单个类别
超参数：隐藏层的大小

单隐藏层多分类

和单分类的区别：输出是k个，对output还要做一次softmax

多隐藏层

超参数：每层隐藏层的大小隐藏层数

非线性激活函数

保证输出结果非线性，避免线性，如果线性，相当于没有隐藏层

sigmoid 激活函数：将输入投影到（0 , 1）

Tanh 激活函数：将输入投影到（-1 , 1）

ReLU 激活函数：将输入投影到（0 , +∞）

模型选择

训练误差：模型在训练数据上的误差
泛化误差：模型在新数据上的误差

训练数据集：训练模型（训练模型参数）
验证数据集：评估模型好坏（选择模型超参数）
测试数据集：只用一次

通常采用：k-则交叉验证

即：在没有足够数据时使用，将训练数据分为k块，没一块分别作为验证集，其余作为训练集

过拟合和欠拟合

模型和数据的关系

模型容量\数据	简单	复杂
低	正常	欠拟合
高	过拟合	正常

模型和误差的关系

权重衰退

权重衰退：最广泛使用的正则化技术之一，也被称为L2正则化
目的：对权重的数值大小进行约束（权重过大过拟合，过小效果差）
正则项：控制模型复杂度的超参数（抵消过拟合的方法）

+ 号左侧是loss，右侧作为惩罚项加到最小化损失的问题中，增加 λ ，控制模型复杂度

丢弃法

即为dropout，将一些输出项随机置0
也是一种正则项，增加鲁棒性（一个好的模型需要对输入数据的扰动鲁棒）和L2正则一样都是在模型训练时使用，只会对权重产生影响
常作用于：多层感知机的隐藏层输出（层之间）
丢弃概率：控制模型复杂度的超参数

无偏差的加入噪音：
对向量的每个元素操作，每个元素都是p的概率变为0，又有 1-p 的概率变为它的 1 / (1-p)，这样才能保持期望不变，即E[h′]=h

使用dropout

数值稳定性

梯度爆炸

梯度消失

权重 = 梯度 * 学习率

目标：让梯度值在合理范围内（让训练更加稳定）

方法：

让乘法变加法：ResNet，LSTM
归一化：梯度归一化，梯度裁剪
合理的权重初始和激活函数

这儿也没看懂，貌似还需要链式法则和反向传播的知识

实战：房价预测

来不及实战了，先欠着

pytorch

如下部分均使用python语言、pytorch模型实现，代码主要是提供样例，想直接运行还需要稍作需修改哦，比如，不要忘记导包

import torch
import torch.nn.functional as F
from torch import nn
.......

模型构造

在下方的代码中，许多地方都用到了nn.module，它是一个已经被写好的大类，常见的一些层，都是它的子类。我们只需要自定义类，继承nn.module就好了

自定义网络

此处讲述如何定义和设计模块，主要分三种方式来介绍

# ----------自定义块----------
class MLP(nn.Module):
    # 定义模型参数(层)。这里，我们声明两个全连接的层
    def __init__(self):
        # 调用MLP的父类Module的构造函数来执行必要的初始化。
        # 这样，在类实例化时也可以指定其他函数参数，例如模型参数params（稍后将介绍）
        super().__init__()
        self.hidden = nn.Linear(20, 256)  # 隐藏层（输入20输出256）
        self.out = nn.Linear(256, 10)  # 输出层（输入256输出10）
    # 定义模型的前向传播，即如何根据输入X返回所需的模型输出
    def forward(self, X):
        # 注意，这里我们使用ReLU的函数版本，其在nn.functional模块中定义。
        return self.out(F.relu(self.hidden(X)))
# 实例化多层感知机，然后在每次调用正向传播函数时调用这些层
net = MLP() # 实例化类
net(X)


# ----------顺序块----------
class MySequential(nn.Module):
    def __init__(self, *args):# *args：相当于把若干个参数打包传入(nn.Linear(20, 256), nn.ReLU(), nn.Linear(256, 10))
        super().__init__() # 调用父类初始化函数
        for idx, module in enumerate(args):
            # 这里，module是Module子类的一个实例。我们把参数保存在'Module'类的成员
            # 变量_modules中。_module的类型是OrderedDict
            self._modules[str(idx)] = module
    def forward(self, X):
        # OrderedDict保证了按照成员添加的顺序遍历它们
        for block in self._modules.values():
            X = block(X)
        return X
# 设计一个简单的单层神经网络，一个线性层，一个ReLU，一个线性层
# input维度：20，output维度：10
net = MySequential(nn.Linear(20, 256), nn.ReLU(), nn.Linear(256, 10))
net(X)


# ----------混合搭配各种组合块（套娃）----------
class NestMLP(nn.Module):
    def __init__(self):
        super().__init__()
        self.net = nn.Sequential(nn.Linear(20, 64), nn.ReLU(),
                                 nn.Linear(64, 32), nn.ReLU())
        self.linear = nn.Linear(32, 16)
    def forward(self, X):
        return self.linear(self.net(X))
chimera = nn.Sequential(NestMLP(), nn.Linear(16, 20), FixedHiddenMLP())
chimera(X)

在正向传播中执行代码，在init和forward中可以做计算

class FixedHiddenMLP(nn.Module):
    def __init__(self):
        super().__init__()
        # 不计算梯度的随机权重参数。因此其在训练期间保持不变
        self.rand_weight = torch.rand((20, 20), requires_grad=False)
        self.linear = nn.Linear(20, 20)

    def forward(self, X):
        X = self.linear(X)
        # 使用创建的常量参数以及relu和mm函数
        X = F.relu(torch.mm(X, self.rand_weight) + 1)
        # 复用全连接层。这相当于两个全连接层共享参数
        X = self.linear(X)
        # 控制流
        while X.abs().sum() > 1:
            X /= 2
        return X.sum()

参数管理

参数的访问

定义好类之后，参数如何访问，包含四种访问方式

net = nn.Sequential(nn.Linear(4, 8), nn.ReLU(), nn.Linear(8, 1))
X = torch.rand(size=(2, 4))
net(X)
# ----------参数的访问，例如 nn.Linear(8, 1)----------
print(net[2].state_dict()) # 第三个参数的weight权重和bias偏差


# ----------具体参数的访问，例如 最后一层的偏移----------
print(type(net[2].bias))
print(net[2].bias)
print(net[2].bias.data)


# ----------一次访问所有参数 整个网络的全部参数----------
print(*[(name, param.shape) for name, param in net.named_parameters()])


# ----------嵌套访问，block2嵌套了4个block1----------
def block1():
    return nn.Sequential(nn.Linear(4, 8), nn.ReLU(),
                         nn.Linear(8, 4), nn.ReLU())
def block2():
    net = nn.Sequential()
    for i in range(4):
        # 在这里嵌套
        net.add_module(f'block {i}', block1())
    return net
rgnet = nn.Sequential(block2(), nn.Linear(4, 1))
rgnet(X)

内置初始化

如何初始化参数，即修改默认初始化

感觉用处不大，先欠着

参数绑定

即在不同网络之间共享权重

无论权重怎样更新，shared的权重都相同。可以理解为同一个moudle用了多次

# 我们需要给共享层一个名称，以便可以引用它的参数
shared = nn.Linear(8, 8)
net = nn.Sequential(nn.Linear(4, 8), nn.ReLU(),
                    shared, nn.ReLU(),
                    shared, nn.ReLU(),
                    nn.Linear(8, 1))
net(X)
# 检查参数是否相同
print(net[2].weight.data[0] == net[4].weight.data[0])
net[2].weight.data[0, 0] = 100
# 确保它们实际上是同一个对象，而不只是有相同的值
print(net[2].weight.data[0] == net[4].weight.data[0])

自定义层

构造神经网络中的层，有两种方式

# ----------构造一个没有参数的层----------
class CenteredLayer(nn.Module):
    def __init__(self):
        super().__init__()
    def forward(self, X):
        return X - X.mean()
# 向该层提供一些数据
layer = CenteredLayer()
layer(torch.FloatTensor([1, 2, 3, 4, 5]))
# 将其作为组件合并到复杂模型中
net = nn.Sequential(nn.Linear(8, 128), CenteredLayer())
Y = net(torch.rand(4, 8))
Y.mean()


# ----------构造一个有参数的层----------
class MyLinear(nn.Module):
    def __init__(self, in_units, units):
        super().__init__()
        # 随机初始化后，放入Parameter
        self.weight = nn.Parameter(torch.randn(in_units, units))
        self.bias = nn.Parameter(torch.randn(units,))
    def forward(self, X):
        linear = torch.matmul(X, self.weight.data) + self.bias.data
        return F.relu(linear)
linear = MyLinear(5, 3)
linear.weight

使用自定义层，实现不同目的

# 前向计算
linear(torch.rand(2, 5))

# 构建模型
net = nn.Sequential(MyLinear(64, 8), MyLinear(8, 1))
net(torch.rand(2, 64))

读写文件

加载和保存张量tensor

# 构造一个长为4的向量，并将其存在'x-file'文件中
x = torch.arange(4)
torch.save(x, 'x-file')

# 读回内存
x2 = torch.load('x-file')

# 也可以存储一个张量list (x,y)
y = torch.zeros(4)
torch.save([x, y],'x-files')
x2, y2 = torch.load('x-files')

加载和保存模型参数

train模式：net.train() eval模式：net.eval() 一般情况下相同

class MLP(nn.Module):
    def __init__(self):
        super().__init__()
        self.hidden = nn.Linear(20, 256)
        self.output = nn.Linear(256, 10)
    def forward(self, x):
        return self.output(F.relu(self.hidden(x)))
net = MLP()
X = torch.randn(size=(2, 20))
Y = net(X)


# 讲模型的参数存储为一个叫做“mlp.params”的文件中
torch.save(net.state_dict(), 'mlp.params')

# 实例化，读取文件中存储的参数
clone = MLP()
clone.load_state_dict(torch.load('mlp.params'))
clone.eval() # 开始评估函数

# 两个实例的模型参数相同 clone(X)和Y
Y_clone = clone(X)
Y_clone == Y

GPU的使用

关于如何使用GPU，服务器等问题，可以参考这篇文章

【新手小白】在Linux服务器或本地IDE，跑深度学习代码指南（不断更新）_深度学习跑代码-CSDN博客https://blog.csdn.net/qq_52589927/article/details/131744235?spm=1001.2014.3001.5502接下来讲解有关代码的部分

所有深度学习框架都是默认在CPU上计算的，所以我们需要让它用GPU

# 用cpu  用第0个GPU  用第1个GPU
torch.device('cpu'), torch.device('cuda'), torch.device('cuda:1')


# 查询可用GPU数量
torch.cuda.device_count()


# GPU不存在时运行代码
def try_gpu(i=0):  #@save
    """如果存在，则返回gpu(i)，否则返回cpu()"""
    if torch.cuda.device_count() >= i + 1:
        return torch.device(f'cuda:{i}')
    return torch.device('cpu')

def try_all_gpus():  #@save
    """返回所有可用的GPU，如果没有GPU，则返回[cpu(),]"""
    devices = [torch.device(f'cuda:{i}')
             for i in range(torch.cuda.device_count())]
    return devices if devices else [torch.device('cpu')]

try_gpu(), try_gpu(10), try_all_gpus()


# 在GPU上创建tensor
X = torch.ones(2, 3, device=try_gpu())


# 在第二个GPU上创建一个随机张量
Y = torch.rand(2, 3, device=try_gpu(1))


# 在GPU之间复制张量
Z = X.cuda(1) # 把X移到第二个GPU
Y + Z # 计算 X + Y


# 神经网络在GPU中做计算
net = nn.Sequential(nn.Linear(3, 1))
net = net.to(device=try_gpu()) # 把net的所有参数放到第0个GPU上
net(X) #计算
net[0].weight.data.device # 输出device(type='cuda', index=0)

下期预告

剩下的内容还没看，当前的内容也还没巩固，也许之后还会有更新和改动，准备重开一篇文章继续写！下章才到卷积，不知道啥时候才能学完啊啊啊 ——2024.8.15

接下来讲的是：关于卷积神经网络的介绍，非常全面

【动手学深度学习】视频课程笔记与重点总结 19-24，卷积神经网络大全-CSDN博客https://blog.csdn.net/qq_52589927/article/details/141222674?spm=1001.2014.3001.5501

正在努力的鼠鼠

关注

22
点赞
踩
25

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

【李沐 动手学深度学习】视频课程笔记与重点总结 01-18，从线性回归到pytorch代码

前言

线性回归

基础优化算法

梯度下降

softmax回归

损失函数

多层感知机

感知机

多层感知机

简单实现

非线性激活函数

模型选择

过拟合和欠拟合

权重衰退

丢弃法

数值稳定性

实战：房价预测

pytorch

模型构造

自定义网络

参数管理

参数的访问

内置初始化

参数绑定

自定义层

读写文件

GPU的使用

下期预告

【李沐动手学深度学习】视频课程笔记与重点总结 01-18，从线性回归到pytorch代码