【学习系列4】线性回归的实现

假设我们的基础模型就是y = wx+b，其中w和b均为参数，我们使用y = 3x+0.8来构造数据x、y，所以最后通过模型应该能够得出w和b应该分别接近3和0.8
1.准备数据
2.计算预测值
3.计算损失，把参数的梯度置为0，进行反向传播
4.更新参数

import torch
import matplotlib.pyplot as plt
import os

os.environ["KMP_DUPLICATE_LIB_OK"] = "TRUE"

learning_rate = 0.01

# 1. 准备数据
x = torch.rand([500, 1])
y_true = 3 * x + 0.8
# 2. 设计模型
w = torch.rand([1, 1], requires_grad=True)
b = torch.tensor(1, requires_grad=True, dtype=torch.float32)

# 4. 反向传播
for i in range(6000):
    y_predict = torch.matmul(x, w) + b
    # 3. 计算 loss
    loss = (y_true - y_predict).pow(2).mean()
    if w.grad is not None:
        w.grad.data.zero_()
    if b.grad is not None:
        b.grad.data.zero_()

    loss.backward()

    w.data = w.data - learning_rate * w.grad
    b.data = b.data - learning_rate * b.grad

print(b.data, w.data)

plt.figure(figsize=(20, 8))
plt.scatter(x.numpy().reshape(-1), y_true.numpy().reshape(-1))
y_predict = torch.matmul(x, w) + b
plt.plot(x.numpy().reshape(-1), y_predict.detach().numpy().reshape(-1))
plt.show()

1.1 nn .Module

nn.Modul 是torch.nn提供的一个类，是pytorch中我们自定义网络的一个基类，在这个类中定义了很多有用的方法，让我们在继承这个类定义网络的时候非常简单
当我们自定义网络的时候，有两个方法需要特别注意:

_init_需要调用super方法，继承父类的属性和方法
farward方法必须实现，用来定义我们的网络的向前计算的过程

用前面的y=wx+b的模型举例如下:

from torch import nn


class Lr(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear = nn.Linear(1, 1)

    def forward(self, x):
        out = self.linear(x)
        return out

注意：

1.nn.Linear为torch预定义好的线性模型，也被称为全链接层，传入的参数为输入的数量，输出的数量(in_features,out features)是不算(batch_size的列数)

2nn.Modue定义了_call_方法，实现的就是调用forward方法，即Lr的实例，能够直按被传入参数调用，实际上调用的是forward方法并传入参数

#实例化模型
model = Lr()
# 传入数据，计算结果
predict = model(x)

1.2 优化类

优化器(optimizer)，可以理解为torch为我们封装的用来进行更新参数的方法，比如常见的随机梯度下降(stochastic gradient descent,SGD)
优化器类都是由torch.optim提供的，例如
1.torch.optim.SGD(参数，学习率)
2.torch.optim.Adam(参数，学习率)

注意:
1参数可以使用mode1.parameters0来获取，获取横型中所有requires_grad=True的参数
2.优化类的使用方法
1.实例化
2.所有参数的梯度，将具值置为0
3.反向传计算梯度
4更新参数值
示例如下:

optimizer = optim.SGD(model.parameters(), lr=1e-3)  # 1.实例化
optimizer.zero_grad()  # 2，梯度置为0
loss.backward  # 3.计算梯底
optimizer.step()  # 4，更新参教的信

1.3 损失函数

前面的例了是一个回归问题，torch中也预测了很多损失函数
1.均方误差:nn.MSEloss0常用语分类问题
2.交叉煽损失: nn.crossEntropyLoss()，常用语逻辑回归
使用方法

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

1.4 Pytorch线性回归的实现

import torch
from torch import nn, optim
from matplotlib import pyplot as plt

# 1. 定义数据
x = torch.rand([50, 1])
y = x * 3 + 0.8


# 2. 定义模型
class Lr(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear = nn.Linear(1, 1)

    def forward(self, x):
        out = self.linear(x)
        return out


# 3. 实例化模型 loss 优化器
model = Lr()
criterion = nn.MSELoss()
optimizer = optim.SGD(model.parameters(), lr=1e-2)

# 4. 训练模型
for i in range(20000):
    out = model(x)
    loss = criterion(y, out)
    optimizer.zero_grad()
    loss.backward()

    optimizer.step()
    if (i + 1) % 20 == 0:
        print(
            f'epoch {i} , loss {loss.data:.3f}, {list(model.parameters())[0].item()}, {list(model.parameters())[1].item()}')

# 5. 模型评估
model.eval()  # 设置模型为评估模式，即预测模式
predict = model(x)
predict = predict.data.numpy()
plt.scatter(x.data.numpy(), y.data.numpy(), c='r')
plt.plot(x.data.numpy(), predict)
plt.show()