PyTorch 线性回归

2019年8月14日

意见反馈

线性回归

数学中的回归是指，现实中的变量之间存在一种函数关系，通过一批样本数据找出这个函数关系，即通过样本数据回归到真实的函数关系。

线性回归/Linear Regression是指，一些变量之间存在线性关系，通过一批样本数据找出这个关系，线性关系函数的图形是一条直线。

线性函数的方程如下：

$y = wx + b$

线性回归就是根据一批样本数据，确定这个方程，即确定权重 $w$ 和偏置 $b$ 。

因此，要创建线性模型，需要:

应变量(y)
斜率或权重变量(w)
截距或偏置(b)
自变量(x)

PyTorch 线性回归例子

例如，有一家汽车公司，如果汽车价格低，汽车销量高，如果汽车价格高，汽车销量少。现在要看一下，这两者之间的确切关系，然后根据这个关系，就可以预测不同价格时的销量。

我们从以前的销售中收集了一些数据，现在把这些数据可视化：

# 导入 numpy 
import numpy as np
# 导入 pytorch 库
import torch

# 作为一家汽车公司，我们从以前的销售中收集这些数据
# 定义汽车价格
car_prices_array = [3,4,5,6,7,8,9]
car_price_np = np.array(car_prices_array,dtype=np.float32)
car_price_np = car_price_np.reshape(-1,1)
car_price_tensor = Variable(torch.from_numpy(car_price_np))

# 定义汽车销售量
number_of_car_sell_array = [ 7.5, 7, 6.5, 6.0, 5.5, 5.0, 4.5]
number_of_car_sell_np = np.array(number_of_car_sell_array,dtype=np.float32)
number_of_car_sell_np = number_of_car_sell_np.reshape(-1,1)
number_of_car_sell_tensor = Variable(torch.from_numpy(number_of_car_sell_np))

# 将数据可视化
import matplotlib.pyplot as plt
plt.scatter(car_prices_array, number_of_car_sell_array)
plt.xlabel("Car Price $")
plt.ylabel("Number of Car Sell")
plt.title("Car Price$ VS Number of Car Sell")
plt.show()

为找出价格和销量的关系，我们需要使用线性回归。

线性回归步骤

创建LinearRegression类
从这个线性回归类定义模型
计算均方误差
优化(SGD: 随机梯度下降)
反向传播
预测

让我们用Pytorch实现它

# Pytorch线性回归

# 导入库
import torch      
from torch.autograd import Variable     
import torch.nn as nn 
import warnings
warnings.filterwarnings("ignore")

# 创建LinearRegression类
class LinearRegression(nn.Module):
    def __init__(self,input_size,output_size):
        # 超级函数，继承自nn.Module
        super(LinearRegression,self).__init__()
        # 线性函数
        self.linear = nn.Linear(input_dim,output_dim)

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

# 定义模型
input_dim = 1
output_dim = 1
model = LinearRegression(input_dim,output_dim) # 输入和输出大小为1

# MSE/均方差
mse = nn.MSELoss()

# 优化(找到最小化差值的参数)
learning_rate = 0.02   # 学习率, 达到最佳参数的速度有多快
optimizer = torch.optim.SGD(model.parameters(),lr = learning_rate)

# 训练模型
loss_list = []
iteration_number = 1001
for iteration in range(iteration_number):

    # 优化
    optimizer.zero_grad() 

    # 计算模型输出
    results = model(car_price_tensor)

    # 计算损失/差值
    loss = mse(results, number_of_car_sell_tensor)

    # 反向传播
    loss.backward()

    # 更新参数
    optimizer.step()

    # 保存损失/差值
    loss_list.append(loss.data)

    # 打印损失
    if(iteration % 50 == 0):
        print('epoch {}, loss {}'.format(iteration, loss.data))

plt.plot(range(iteration_number),loss_list)
plt.xlabel("Number of Iterations")
plt.ylabel("Loss")
plt.show()

输出

epoch 0, loss 8.957218170166016
epoch 50, loss 5.3334503173828125
epoch 100, loss 3.6040360927581787
epoch 150, loss 2.4353976249694824
epoch 200, loss 1.6456999778747559
epoch 250, loss 1.1120679378509521
epoch 300, loss 0.7514711022377014
epoch 350, loss 0.5078008770942688
epoch 400, loss 0.34314244985580444
epoch 450, loss 0.23187577724456787
epoch 500, loss 0.15668821334838867
epoch 550, loss 0.10588079690933228
epoch 600, loss 0.07154809683561325
epoch 650, loss 0.04834824800491333
epoch 700, loss 0.032670602202415466
epoch 750, loss 0.022076968103647232
epoch 800, loss 0.014918360859155655
epoch 850, loss 0.010080925188958645
epoch 900, loss 0.0068122632801532745
epoch 950, loss 0.004603386856615543
epoch 1000, loss 0.0031107566319406033

如上图所示，迭代次数为1000，当迭代1000次后，损失几乎为0了，表明模型已经训练好。

现在可以使用模型来预测汽车的销量了：

# 预测汽车价格
predicted = model(car_price_tensor).data.numpy()
plt.scatter(car_prices_array,number_of_car_sell_array,label = "original data",color ="red")
plt.scatter(car_prices_array,predicted,label = "predicted data",color ="blue")

# 预测一下，如果汽车的价格是10美元，那么汽车的销量会是多少
# predicted_10 = model(torch.from_numpy(np.array([10]))).data.numpy()
# plt.scatter(10,predicted_10.data,label = "car price 10$",color ="green")
plt.legend()
plt.xlabel("Car Price $")
plt.ylabel("Number of Car Sell")
plt.title("Original vs Predicted values")
plt.show()