线性回归实现示例

假设我们的基础模型是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

learning_rate = 0.01

#1.准备数据
#y = 3x + 0.8
x = torch.rand([500,1])
y_true = x*3 + 0.8

#2.通过模型计算y_predict
w = torch.rand([1,1],requires_grad=True)
b = torch.tensor(0,requires_grad=True,dtype=torch.float32)

#4.通过循环，反向传播，更新参数
for i in range(5000):
    # 通过模型计算y_predict
    y_predict = torch.matmul(x,w) + b  # x*w + b
    loss = (y_true - y_predict).pow(2).mean()

    loss.backward()  #反向传播
    w.data = w.data - learning_rate * w.grad  #根据梯度取新的值
    b.data = b.data - learning_rate * b.grad

    if w.grad is not None:
        w.grad.data.zero_()  # 重置
    if b.grad is not None:
        b.grad.data.zero_()  # 重置b

    if i%50 == 0:
        print("w.grad,w,b,loss ",w.grad,w.item(),b.item(),loss.item())

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()

运行结果：

可以看到w,b无限接近3和0.8,损失函数也变得极小

二、通过pytorch API实现

import torch
import torch.nn as nn
from torch.optim import  SGD  #优化器

#0.准备数据
x = torch.rand([500,1])
y_true = 3*x + 0.8
learning_rate = 0.01 #学习率

#1.定义模型
class MyLinear(nn.Module):
    def __init__(self):
        #继承父类的init
        super(MyLinear,self).__init__()
        self.linear =  nn.Linear(1,1)

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

#2.实例化模型，优化器类实例化，loss实例化
myLinear = MyLinear()
optimizer = SGD(myLinear.parameters(),learning_rate)
loss_fn = nn.MSELoss()

#3.循环，进行梯度下降，参数的更新
for i in range(10000):
    #得到预测值
    y_predict = myLinear(x)
    loss = loss_fn(y_predict,y_true)  #计算损失
    #梯度置为0
    optimizer.zero_grad()
    #反向传播、计算梯度
    loss.backward()
    #参数的更新
    optimizer.step()
    if i%50 == 0:
        params = list(myLinear.parameters())
        print(loss.item(),params[0].item(),params[1].item())