假设我们的基础模型就是y = wx + b
,其中w和b均为参数,我们使用y = 3x+0.8
来构造数据x、y,所以最后通过模型应该能够得出w和b应该分别接近3和0.8。
步骤如下:
- 准备数据
- 计算预测值
- 计算损失,把参数的梯度置为0,进行反向传播
- 更新参数
方式一
该方式没有用pytorch
的模型api
,手动实现
import torch,numpy
import matplotlib.pyplot as plt
# 1、准备数据
learning_rate = 0.01
#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)
# 3、通过循环,反向传播,更新参数
for i in range(500):
# 4、计算loss
y_predict = torch.matmul(x,w) + b
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
# 每50次输出一下结果
if i%50==0:
print("w,b,loss",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),c="r")
plt.show()
循环500
次的效果
循环2000
次的结果
方式二
方式一的方式虽然已经购简便了,但是还是有些许繁琐,所以我们可以采用pytorch
的api
来实现。
nn.Module
是torch.nn
提供的一个类,是pytorch
中我们自定义网络的一个基类,在这个类中定义了很多有用的方法,让我们在继承这个类定义网络的时候非常简单。
当我们自定义网络的时候,有两个方法需要特别注意:
1.__init__
需要调用super
方法,继承父类的属性和方法
2. forward
方法必须实现,用来定义我们的网络的向前计算的过程用前面的y = wx+b
的模型举例如下:
#定义模型
from torch import nn
class Lr(nn.Module): #继承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
全部代码如下:
#!/usr/bin/env python
# -*- coding:utf-8 -*-
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*3 + 0.8
#定义模型
class Lr(nn.Module): #继承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
#2、实例化模型、loss函数以及优化器
model = Lr()
criterion = nn.MSELoss() #损失函数
optimizer = optim.SGD(model.parameters(),lr=1e-3) #优化器
#3、训练模型
for i in range(3000):
out = model(x)# 获取预测值
loss = criterion(y,out) #计算损失
optimizer.zero_grad() #梯度归零
loss.backward() #计算梯度
optimizer.step() #更新梯度
if(i+1) % 20 ==0:
print('Epoch[{}/{}],loss:{:.6f}'.format(i,500,loss.data))
#4、模型评估
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()
注意:
model.eval()
表示设置模型为评估模式,即预测模式
model.train(mode=True)
表示设置模型为训练模式
在当前的线性回归中,上述并无区别
但是在其他的一些模型中,训练的参数和预测的参数会不相同,到时候就需要具体告诉程序我们是在进行训练还是预测,比如模型中存在Dropout,BatchNorm的时候
循环2000
次的结果:
循环30000
次的结果: