Torch学习 线性回归

线性回归

线性回归的基本要素

 模型定义
 模型训练（训练数据  损失函数  优化算法）
 模型预测

线性回归的表示方法

  神经网络图（单层神经网络）
  矢量计算表达式

import torch
from time import time
a=torch.ones(1000)#定义两个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.008514165878295898
#向量相加的另一种方法是，将这两个向量直接做矢量加法
start=time()
d=a+b
print(time()-start)
0.0
𝑦̂ (1)=𝑥(1)1𝑤1+𝑥(1)2𝑤2+𝑏, 𝑦̂ (2)=𝑥(2)1𝑤1+𝑥(2)2𝑤2+𝑏, 𝑦̂ (3)=𝑥(3)1𝑤1+𝑥(3)2𝑤2+𝑏.
a=torch.ones(3)
b=10
print(a+b)
tensor([11., 11., 11.])
广义上讲，当数据样本数为n ，特征数为d时，线性回归的矢量计算表达式为
𝒚̂ =𝑿𝒘+𝑏
其中模型输出 批量数据样本特征 ，权重 ， 偏差 。相应地，批量数据样本标签 。设模型参数 ，我们可以重写损失函数为
ℓ(𝜽)=12𝑛(𝒚̂ −𝒚)⊤(𝒚̂ −𝒚)
小批量随机梯度下降的迭代步骤将相应地改写为
𝜽←𝜽−𝜂||∑𝑖∈∇𝜽ℓ(𝑖)(𝜽),
其中梯度是损失有关3个为标量的模型参数的偏导数组成的向量：
∇𝜽ℓ(𝑖)(𝜽)=[∂ℓ(𝑖)(𝑤1,𝑤2,𝑏)∂𝑤1 ∂ℓ(𝑖)(𝑤1,𝑤2,𝑏)∂𝑤2 ∂ℓ(𝑖)(𝑤1,𝑤2,𝑏)∂𝑏]=[𝑥(𝑖)1(𝑥(𝑖)1𝑤1+𝑥(𝑖)2𝑤2+𝑏−𝑦(𝑖)) 𝑥(𝑖)2(𝑥(𝑖)1𝑤1+𝑥(𝑖)2𝑤2+𝑏−𝑦(𝑖)) 𝑥(𝑖)1𝑤1+𝑥(𝑖)2𝑤2+𝑏−𝑦(𝑖)]=[𝑥(𝑖)1 𝑥(𝑖)2 1](𝑦̂ (𝑖)−𝑦(𝑖))

导入相应的包

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

生成数据集

num_inputs=2
num_examples=1000
true_w=[2,-3.4]
true_b=4.2
features=torch.randn(num_examples,num_inputs,dtype=torch.float32)#features的每一行是一个长度为2的向量
lables=true_w[0]*features[:,0]+true_w[1]*features[:,1]+true_b #而labels的每一行是一个长度为1的向量（标量）
lables+=torch.tensor(np.random.normal(0,0.01,size=lables.size()),dtype=torch.float32)

通过生成第二个特征features[:, 1]和标签 labels 的散点图，可以更直观地观察两者间的线性关系

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
set_figsize()
plt.scatter(features[:,1].numpy(),lables.numpy(),1)

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

读取数据

def data_iter(batch_size,features,lables):
    num_examples=len(features)
    
    indices=list(range(num_examples))
    random.shuffle(indices) #样本的读取顺序是随机的
    for i in range(0,num_examples,batch_size):
        j=torch.LongTensor(indices[i:min(i+batch_size,num_examples)])#最后一次可能不足一个batch
        yield features.index_select(0,j),lables.index_select(0,j) #类似于return
print(len(features))#1000
#print(list(range(num_examples)))
batch_size=10
for X,y in data_iter(batch_size,features,lables):
    print(X,y)
    break

1000
tensor([[ 0.6548,  2.2605],
        [ 0.8679,  0.1193],
        [ 1.3492, -1.1745],
        [ 1.3660,  0.0285],
        [-0.7478, -0.3729],
        [-0.4992,  1.0377],
        [-0.1807,  0.0948],
        [ 2.7915,  1.6959],
        [-0.1898,  0.8638],
        [-2.5307, -0.4977]]) tensor([-2.1744,  5.5229, 10.9083,  6.8452,  3.9655, -0.3173,  3.4836,  4.0163,
         0.8760,  0.8343])

初始化模型参数

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

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

之后的模型训练中，需要对这些参数求梯度来迭代参数的值，因此我们要让它们的requires_grad=True.

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

定义模型

def linreg(X,w,b):
    return torch.mm(X,w)+b

定义损失函数

def squared_loss(y_hat,y):
    #注意这里返回的是向量，另外，pytorch里的MSELoss并没有除以2
    return (y_hat-y.view(y_hat.size()))**2/2

定义优化算法¶

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

def sgd(params,lr,batch_size):
    
    with torch.no_grad():
        for param in params:
            param-=lr*param.grad/batch_size
            param.grad.zero_()
#TypeError: unsupported operand type(s) for *: 'float' and 'NoneType'

训练模型¶

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

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

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

epoch 1, loss 0.047959
epoch 2, loss 0.000202
epoch 3, loss 0.000056
print(true_w,'\n',w)
print(true_b,'\n',b)
[2, -3.4] 
 tensor([[ 2.0001],
        [-3.3995]], requires_grad=True)
4.2 
 tensor([4.1996], requires_grad=True)