深度学习 | 【04】Pytorch实现简单的线性回归

Bertha 。 2023-01-21 11:20 20阅读 0赞

### 文章目录 ###

*   *  常用API
     *   *   *  1、nn.Module
             *  2、优化器类
             *  3、损失函数
             *  4、预测与训练
             *  4、完整代码
             *  5、GPU上运行代码

## 常用API ##

#### 1、nn.Module ####

> `nn.Modul` 是 `torch.nn` 提供的一个类，是pytorch中自定义网络的一个基类。
> 
>  *  需要继承父类的`属性`和`方法`；
>  *  `farword`必须实现，用来定义我们的网络的`向前计算`的过程。

**注意**

>  *  `nn.Linear` 为torch预定义好的线性模型 - 【全连接层】，传入的参数为输入的数量，输出的数量`(in_features, out_feature)`，是不算(`batch_size`的列数)
>  *  `nn.Module` 定义了`__call__` 方法，实现的就是调用`foeward` 方法，即`Lr` 的实例，能够直接被传入参数调用，实际上调用的是`foeward`方法并传入参数。

#### 2、优化器类 ####

>  *  `优化器( optimizer)`，可以理解为torch为我们封装的用来进行`更新参数`的方法，比如常见的随机梯度下降(stochastic gradient descent,sGD )
>  *  优化器类都是由`torch. optim`提供的，例如
>     
>      *  `torch.optim.SGD(参数，学习率)`
>      *  `torch.optim.Adam(参数，学习率)`
> 
> **注意:**
> 
>  *  1.参数可以使用`model.parameters()`来获取，获取模型中所有`requires_grad=True`的参数
>  *  2.优化类的使用方法Ⅰ
>     
>      *  实例化：`optimizer = optim.SGD(model.parameters(), lr=le03)`
>      *  所有参数的梯度，将其值置为0：`optimizer.zero_grad()`
>      *  反向传播计算梯度：`loss.backward()`
>      *  更新参数值：`optimizer.step()`

#### 3、损失函数 ####

>  *  均方误差：`nn.MSELoss()` 分类问题；
>  *  交叉熵损失：`nn.CrossEntropyLoss()` 逻辑回归。

#### 4、预测与训练 ####

>  *  `model.eval()`表示为评估模式，【预测模式】
>  *  `model.train(mode=true)`训练模式
>  *  在线性回归中，他们并没有区别。但在其他的模型训练中参数会各不相同。

model = Lr() # 1. 实例化模型
    criterion = nn.MSELoss() # 2.实例化损失函数
    optimizer = optim.SGD(model.parameters(), lr=le-3)	# 3. 实例化优化器类
    for i in range(50):
    	y_pre = model(x_true) # 4. 向前计算预测值
    	loss = criterion(y_true, y_pre) #5. 调用损失函数传入真实值和预测值，得到损失结果
    	optimizer.zero_grad() # 6. 当前循环参数梯度置为0
    	loss.backward() # 7. 计算梯度
    	optimizer.step() # 8. 更新参数的值

#### 4、完整代码 ####

# -*- coding: utf-8 -*-
    """ @Time : 2021/5/16 10:35 @Author : XXX @Site : @File : Demolinear.py @Software: PyCharm """
    import torch
    from torch import nn
    from torch import optim
    import numpy as np
    from matplotlib import pyplot as plt
    
    # 1. 构建数据
    x = torch.rand([50, 1])
    y = x*4 + 0.3
    
    # 2. 定义模型
    class Lr(nn.Module):
    
        def __init__(self):
            super(Lr, self).__init__()
            self.linear = nn.Linear(1,1)
    
        def forward(self, x):
            out = self.linear(x)
    
            return out
    
    # 3.创建模型实例，损失函数，优化器
    model = Lr()
    criterion = nn.MSELoss()
    optimizer = optim.SGD(model.parameters(), lr=1e-3)
    
    # 4.训练模型
    for i in range(31000):
        out = model(x)  # 获取预测值
        loss = criterion(y, out)    # 计算损失值
        optimizer.zero_grad()       # 梯度归0
        loss.backward()         # 反向传播
        optimizer.step()        # 更新梯度
    
        if i%50 == 0:
            print("Epoch[{}/{}], loss: {}".format(i,31000, loss.data))
    
    # 5.模型评估
    model.eval()
    pre = model(x)  # 预测值
    pre = pre.data.numpy()
    plt.scatter(x.data.numpy(), y.data.numpy(), c='r')
    plt.plot(x.data.numpy(), pre)
    plt.show()

**运行结果**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTkyNjU0Nw_size_16_color_FFFFFF_t_70]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTkyNjU0Nw_size_16_color_FFFFFF_t_70 1]

#### 5、GPU上运行代码 ####

> 当`模型太大`，或者`参数太多`的情况下，为了加快训练速度，就会使用GPU来训练模型。

>  *  判断GPU是否可用

torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

>  *  把`模型参数`和`input数据`转化为cuda的支持类型

model.to(device)
    x_true.to(device)

>  *  在GPU上计算结果也为cuda的数据类型，需要转化为`numpy`或者torch的`cpu的tensor类型`

predict = predict().cpu().datach().numpy()
    # datach为深拷贝
    # data为浅拷贝

**GPU类型代码**

# -*- coding: utf-8 -*-
    """ @Time : 2021/5/16 10:35 @Author : XXX @Site : @File : Demolinear.py @Software: PyCharm """
    import torch
    from torch import nn
    from torch import optim
    import numpy as np
    from matplotlib import pyplot as plt
    
    device = torch,device("cuda:0" if torch.cuda.is_available() else "cpu")	
    # 1. 构建数据
    x = torch.rand([50, 1]).to(device)
    y = x*4 + 0.3
    
    # 2. 定义模型
    class Lr(nn.Module):
    
        def __init__(self):
            super(Lr, self).__init__()
            self.linear = nn.Linear(1,1)
    
        def forward(self, x):
            out = self.linear(x)
    
            return out
    
    # 3.创建模型实例，损失函数，优化器
    model = Lr().to(device)
    criterion = nn.MSELoss()
    optimizer = optim.SGD(model.parameters(), lr=1e-3)
    
    # 4.训练模型
    for i in range(31000):
        out = model(x)  # 获取预测值
        loss = criterion(y, out)    # 计算损失值
        optimizer.zero_grad()       # 梯度归0
        loss.backward()         # 反向传播
        optimizer.step()        # 更新梯度
    
        if i%50 == 0:
            print("Epoch[{}/{}], loss: {}".format(i,31000, loss.data))
    
    # 5.模型评估
    model.eval()
    pre = model(x)  # 预测值
    pre = pre.data.numpy()
    plt.scatter(x.data.numpy(), y.data.numpy(), c='r')
    plt.plot(x.data.numpy(), pre)
    plt.show()

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTkyNjU0Nw_size_16_color_FFFFFF_t_70]: /images/20221020/0b18083682f4435da909992d62a1c9eb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTkyNjU0Nw_size_16_color_FFFFFF_t_70 1]: /images/20221020/6034a813e4c64a6091c8c0379887f05a.png