CCChenhao997

Pytorch-Linear_Regression

原文链接：http://chenhao.space/post/7f30013.html

线性回归

import torch
from time import time

print(torch.__version__)

1.1.0

a = torch.ones(1000)
b = torch.ones(1000)

将这两个向量按元素逐一做标量加法：

start = time()
c = torch.zeros(1000)
for i in range(1000):
    c[i] = a[i] + b[i]
print(time() - start)

0.014781951904296875

将这两个向量直接做矢量加法：

start = time()
d = a + b
print(time() - start)

0.0003459453582763672

结果很明显，后者比前者更省时。因此，我们应该尽可能采用矢量计算，以提升计算效率。

广播机制例子：

a = torch.ones(3)
b = 10
print(a + b)

tensor([11., 11., 11.])

线性回归从零开始实现

设房屋的面积为 x1 ，房龄为 x2 ，售出价格为 y 。我们需要建立基于输入 x1 和 x2 来计算输出 y 的表达式，也就是模型（model）。顾名思义，线性回归假设输出与各个输入之间是线性关系：
$ŷ =x_1w_1+x_2w_2+b,$
其中 w1 和 w2 是权重（weight）， b 是偏差（bias），且均为标量。

%matplotlib inline
import torch
from IPython import display
from matplotlib import pyplot as plt
import numpy as np
import random

print(torch.__version__)
torch.set_default_tensor_type('torch.FloatTensor')

1.1.0

生成数据集

num_inputs = 2
num_examples = 1000
true_w = [2, -3.4]
true_b = 4.2
features = torch.randn(num_examples, num_inputs)
labels = true_w[0] * features[:, 0] + true_w[1] * features[:, 1] + true_b
labels += torch.tensor(np.random.normal(0, 0.01, size=labels.size()), dtype=torch.float)

# torch.tensor(np.random.normal(0, 0.01, size=labels.size()), dtype=torch.float)
# 是增加的随机噪声，噪声代表了数据集中无意义的干扰

# 注意，features的每一行是一个长度为2的向量，而labels的每一行是一个长度为1的向量（标量）。

print(features[0], labels[0])
print(labels.size())

tensor([1.0796, 0.3098]) tensor(5.3111)
torch.Size([1000])

def use_svg_display():
    # 用矢量图显示
    display.set_matplotlib_formats('svg')
    
def set_figsize(figsize=(3.5, 2.5)):
    use_svg_display()
    
    # 设置图的尺寸
    plt.rcParams['figure.figsize'] = figsize
    
# # 在../d2lzh_pytorch里面添加上面两个函数后就可以这样导入
# import sys
# sys.path.append("..")
# from d2lzh_pytorch import * 

set_figsize()
plt.scatter(features[:, 1].numpy(), labels.numpy(), 1);

读取数据

"""
在训练模型的时候，我们需要遍历数据集并不断读取小批量数据样本。
这里我们定义一个函数：它每次返回batch_size（批量大小）个随机样本的特征和标签。
"""

# 本函数已保存在d21zh中方便以后使用
def data_iter(batch_size, features, labels):
    num_examples = len(features)
    indices = list(range(num_examples))
    random.shuffle(indices)  # 样本的读取顺序是随机的
    for i in range(0, num_examples, batch_size):
        # 最后一次可能不足一个batch
        j = torch.LongTensor(indices[i: min(i + batch_size, num_examples)])
        yield features.index_select(0, j), labels.index_select(0, j)

让我们读取第一个小批量数据样本并打印。每个批量的特征形状为(10, 2)，分别对应批量大小和输入个数；标签形状为批量大小。

batch_size = 10

for X, y in data_iter(batch_size, features, labels):
    print(X, '\n', y)
    break

tensor([[ 0.0758, -0.3826],
        [-0.0732, -2.8249],
        [-0.7557,  0.7309],
        [-0.6299, -0.1189],
        [-0.9627,  0.0947],
        [ 1.3580,  1.2370],
        [-0.3616,  0.3718],
        [-0.5052, -1.4169],
        [-1.4944, -1.5984],
        [-0.2773, -0.4932]]) 
 tensor([ 5.6482, 13.6693,  0.2113,  3.3605,  1.9548,  2.7224,  2.2263,  7.9824,
         6.6399,  5.3169])

初始化模型参数

我们将权重初始化成均值为0、标准差为0.01的正态随机数，偏差则初始化成0。

w = torch.tensor(np.random.normal(0, 0.01, (num_inputs, 1)), dtype=torch.float)
b = torch.zeros(1)

之后的模型训练中，需要对这些参数求梯度来迭代参数的值，因此我们需要创建它们的梯度。

w.requires_grad_(requires_grad=True)
b.requires_grad_(requires_grad=True)

tensor([0.], requires_grad=True)

定义模型

使用mm()函数做矩阵乘法

# 本函数已保存在d21zh包中方便以后使用
def linreg(X, w, b):   
    return torch.mm(X, w) + b

定义损失函数

我们需要把真实值 y 变形成预测值 y_hat 的形状。以下函数返回的结果也将和 y_hat 的形状相同。

# 本函数已保存在pytorch_d2lzh包中方便以后使用
def squared_loss(y_hat, y):  
    return (y_hat - y.view(y_hat.size())) ** 2 /2

定义优化算法

以下的sgd函数实现了小批量随机梯度下降算法。它通过不断迭代模型参数来优化损失函数。这里自动求梯度模块计算得来的梯度是一个批量样本的梯度和。我们将它除以批量大小来得到平均值。

# 本函数已保存在pytorch_d2lzh包中方便以后使用
def sgd(params, lr, batch_size):
    for param in params:
        # 注意这里更改param时用的param.data
        param.data -= lr * param.grad / batch_size

训练模型

在训练中，我们将多次迭代模型参数。在每次迭代中，我们根据当前读取的小批量数据样本（特征X和标签y），通过调用反向函数backward计算小批量随机梯度，并调用优化算法sgd迭代模型参数。由于我们之前设批量大小batch_size为10，每个小批量的损失l的形状为(10, 1)。回忆一下“自动求梯度”一节。由于变量l并不是一个标量，运行l.backward()将对l中元素求和得到新的变量，再求该变量有关模型参数的梯度。

在一个迭代周期（epoch）中，我们将完整遍历一遍data_iter函数，并对训练数据集中所有样本都使用一次（假设样本数能够被批量大小整除）。这里的迭代周期个数num_epochs和学习率lr都是超参数，分别设3和0.03。在实践中，大多超参数都需要通过反复试错来不断调节。虽然迭代周期数设得越大模型可能越有效，但是训练时间可能过长。

lr = 0.03
num_epochs = 3
net = linreg
loss = squared_loss

# 训练模型一共需要num_epochs个迭代周期
for epoch in range(num_epochs): 
    # 在每一个迭代周期中，会使用训练数据集中所有样本一次（假设样本数能够被批量大小整除）。
    # X和y分别是小批量样本的特征和标签
    for X, y in data_iter(batch_size, features, labels):
        l = loss(net(X, w, b), y).sum()  # l是有关小批量X和y的损失
        l.backward()   # 小批量的损失对模型参数求梯度
        sgd([w, b], lr, batch_size)  # 使用小批量随机梯度下降迭代模型参数
        
        # 不要忘了梯度清零
        w.grad.data.zero_()
        b.grad.data.zero_()
        
    train_l = loss(net(features, w, b), labels)
    print('epoch %d, loss %f' % (epoch + 1, train_l.mean().item()))

epoch 1, loss 0.000051
epoch 2, loss 0.000051
epoch 3, loss 0.000050

print(true_w, '\n', w)
print(true_b, '\n', b)

[2, -3.4] 
 tensor([[ 1.9999],
        [-3.3999]], requires_grad=True)
4.2 
 tensor([4.2008], requires_grad=True)

线性回归的简洁实现

import torch
from torch import nn
import numpy as np
torch.manual_seed(1)

print(torch.__version__)
torch.set_default_tensor_type('torch.FloatTensor')

1.1.0