实现线性回归

一、线性回归的基本要素

1.模型：设为$y=w_1{x}_1+w_2{x}_2+b$
2.数据集：已知一些样本，每一个样本由$x_1$，$x_2$，$y$组成，希望通过训练这些样本得到模型中参数$w_1$，$w_2$，$b$的值。
$x_1$，$x_2$称为特征（feature），$y$称为标签（label）。
3.损失函数：采用平方函数。
4.优化函数：采用小批量随机梯度下降法（mini-batch stochastic gradient descent）：数据集中一部分样本做训练，修正模型参数。

二、线性回归的从零开始的实现

1.使用autograd模块自动求梯度

对函数$y=2x^{T}x$求关于列向量的梯度，容易知道结果是$4x$，可以检验代码的正确性：

from mxnet import autograd,nd
#定义要求导的函数
def f(x):
    y=2*nd.dot(x.T,x)
    return y

x=nd.arange(4).reshape(4,1)#x为4行1列的向量
print("x:%s"%x)
x.attach_grad()#申请存储梯度所需要的内存
with autograd.record():#record()函数记录与求梯度有关的计算
    y=f(x)
y.backward()#调用backward()函数自动求梯度。如果y不是标量，则返回的是对y求和以后的变量关于x的梯度
x_grad=x.grad#y关于x的梯度
print("y关于x的梯度：%s"%x_grad)
"""x:
[[0.]
 [1.]
 [2.]
 [3.]]
<NDArray 4x1 @cpu(0)>
y关于x的梯度：
[[ 0.]
 [ 4.]
 [ 8.]
 [12.]]
<NDArray 4x1 @cpu(0)>"""

2.生成数据集

from mxnet import nd
num_inputs=2
num_examples=1000
true_w=[2,-3.4]
true_b=4.2
features=nd.random.normal(loc=0,scale=1,shape=(num_examples,num_inputs))
labels=nd.dot(features,nd.array(true_w).reshape(2,1))+nd.array([true_b])#参数转换成NDArray类型再做矩阵乘法
labels+=nd.random.normal(loc=0,scale=0.01,shape=labels.shape)
print(features[0],labels[0])
#[ 1.4642214 -1.3058136]
#<NDArray 2 @cpu(0)> 
#[11.562276]
#<NDArray 1 @cpu(0)>

3.读取数据

import random
def data_iter(batch_size,features,labels):
    """将数据集打乱，再分批读取出来
    batch_size:每次输出的样本的个数；
    features:样本的输入值，是NDArray类型；
    labels:样本的输出值，是NDArray类型"""
    num_examples=len(features)
    indices=list(range(num_examples))
    random.shuffle(indices)#获取样本的下标是乱序的
    for i in range(0,num_examples,batch_size):
        j=indices[i:min(i+batch_size,num_examples)]
        j=nd.array(j)#由于输入、输出都是NDArray类型，使用的下标也必须是NDArray类型
        yield features.take(j),labels.take(j)

4.定义模型、损失函数、优化函数

def linreg(X,w,b):
    """线性函数
    X:样本的输入值构成的矩阵，NDArray类型；
    w:权重，NDArray类型；
    b:偏差，NDArray类型"""
    return nd.dot(X,w)+b
def squared_loss(y_hat,y):
    """平方损失函数
    y_hat:预测值，NDArray类型；
    y:真实输出值，NDArray类型"""
    return (y_hat-y)**2/2
def sgd(params,lr,batch_size):
    """小批量随机梯度下降法
    params:待更新的参数；
    lr:学习率；
    batch_size:小批量的量具体数值"""
    for param in params:
        param-=lr*param.grad/batch_size

5.训练模型

batch_size=10#小批量的量的具体数值
w=nd.random.normal(scale=0.01,shape=(num_inputs,1))
b=nd.zeros(shape=(1,))
w.attach_grad()#申请存储梯度所需要的内存，写在循环里面很不理智
b.attach_grad()
num_epochs=3#训练次数
lr=0.03#学习率
net=linreg
loss=squared_loss
for epoch in range(num_epochs):
    for X,y in data_iter(batch_size,features,labels):
        with autograd.record():
            l=loss(net(X,w,b),y)#NDArray类型，shape为（bach_size,1）
        l.backward()#loss不是标量，会自动求loss的sum()函数，对于它求关于参数的梯度
        sgd([w,b],lr,batch_size)
    train_l=loss(net(features,w,b),labels)
    print("epoch %d,loss %f"%(epoch+1,train_l.asnumpy().sum()/len(train_l)))
#epoch 1,loss 0.035605
#epoch 2,loss 0.000127
#epoch 3,loss 0.000050

参数结果与真实值比较：

true_w,w
#([2, -3.4],
#[[ 2.0003219]
#  [-3.3994198]]
# <NDArray 2x1 @cpu(0)>)

true_b,b
#([4.2], 
# [4.19918]
# <NDArray 1 @cpu(0)>)