动手深度学习--线性回归--4

3.1. 线性回归

线性回归从零开始

第一步、生成数据集
下面的代码生成一个1000*2的数据集，有1000个样本，特征个数为2。

首先随机生成一个1000*2的矩阵，每个元素根据正态分布随机取值。
然后根据已给的真实权重和偏差计算随机生成的数据集中每个样本对应的标签。
最后给标签加上一点噪声。
其中features保存了每个样本数据，labels保存了每个样本对应的标签。

#线性回归从0开始实现
print('线性回归从零开始实现')
from matplotlib import pyplot as plt
from mxnet import autograd,nd
import random

# 1. 生成数据集
num_inputs=2 #设置特征个数为2
num_examples=1000#设置有1000个样本
true_w=[2,-3.4]#设置真实的权重
true_b=4.2#设置真是的偏差
features=nd.random.normal(scale=1,shape=(num_examples,num_inputs))#随机生成大小为1000*2的矩阵，也就是随机生成了样本
labels=true_w[0]*features[:,0]+true_w[1]*features[:,1]+true_b     #根据上面随机生成的样本，结合真是的权重和偏差，计算标签，这个标签是准确的
labels+=nd.random.normal(scale=0.01,shape=labels.shape)#加上随机生成的噪声干扰

读取数据集。
由于要采用小批量随机梯度下降法，所以每次迭代仅需少量的数据。
首先生成一个indcies列表，其中元素为0-999,按顺序排列。
其次将indcies的元素随机排列。
循环，每次将indcies中的batch_size个元素赋值给j，这里是按照列表下标顺序给出的。当到indices末尾时，仅给出小于等于batch_size数量的元素。

# 2. 读取数据
# 在训练模型的时候，我们需要遍历数据集并不断读取小批量数据样本。
def data_iter(batch_size,features,labels):
    num_examples=len(features)
    indices=list(range(num_examples))
    random.shuffle(indices)#随机打乱indices列表中的元素
    for i in range(0,num_examples,batch_size):
        j=nd.array(indices[i:min(i+batch_size,num_examples)])#获取小批量数据集，这里的min是为了防止数组越界
        yield features.take(j),labels.take(j)  #take函数根据索引返回对应元素

初始化权重和偏差。

# 3. 初始化模型参数
#将权重初始化为均值为0、标准差为0.01的正态随机数，偏差初始化为0
w=nd.random.normal(scale=0.01,shape=(num_inputs,1))
b=nd.zeros(shape=(1,))
#我们要求关于w和b的梯度，这里申请这两个梯度的内存空间
w.attach_grad()
b.attach_grad()

定义模型
模型为y=w*x+b，线性回归模型

# 4. 定义模型
def linreg(X,w,b):
    return nd.dot(X,w)+b

损失函数
为平方损失函数

# 5. 定义损失函数
def squared_loss(y_hat,y):
    return (y_hat-y.reshape(y_hat.shape))**2/2

优化算法
params为模型权重和偏差，lr为学习率，batch_size为每次训练样本个数，这里为params的行数。
执行随机梯度下降法，执行迭代,w=w-learning_rate*grad/batch_size。
这里的params为一个大小为(batch_size,3)的矩阵

# 6. 定义优化算法
def sgd(params,lr,batch_size):
    for param in params:
        param[:]=param-lr*param.grad/batch_size

训练模型

# 7. 训练模型
lr=0.03
num_epochs=3
net=linreg
loss=squared_loss
batch_size=10

for epoch in range(num_epochs):# 训练模型一共需要num_epochs个迭代周期
    # 在每一个迭代周期中，会使用训练数据集中所有样本一次（假设样本数能够被批量大小整除）。X
    # X和y分别是小批量样本的特征和标签
    for X,y in data_iter(batch_size,features,labels):#每次从数据集中得出小于等于batch_size个样本
        with autograd.record():#使用record记录有关梯度的计算
            l=loss(net(X,w,b),y)
        l.backward()
        sgd([w,b],lr,batch_size)#根据w和b的梯度，进行sgd迭代
    train_l=loss(net(features,w,b),labels)#根据迭代后的权重w和偏差b，计算样本误差
    print('epoch %d, loss %f' % (epoch + 1, train_l.mean().asnumpy()))

print(true_w,w)

使用mxnet更简洁的实现线性回归

print('线性回归的简洁实现')
from mxnet import autograd,nd
# 1.生成数据集，和之前一样
num_inputs = 2
num_examples = 1000
true_w = [2, -3.4]
true_b = 4.2
features = nd.random.normal(scale=1, shape=(num_examples, num_inputs))
labels = true_w[0] * features[:, 0] + true_w[1] * features[:, 1] + true_b
labels += nd.random.normal(scale=0.01, shape=labels.shape)

# 2. 读取数据集
from mxnet.gluon import data as gdata
batch_size=10
dataset=gdata.ArrayDataset(features,labels)# 将训练数据的特征和标签组合
data_iter=gdata.DataLoader(dataset,batch_size,shuffle=True)# 随机读取小批量

# 3. 定义模型
from mxnet.gluon import nn
net=nn.Sequential()
net.add(nn.Dense(1))

# 4. 初始化模型参数
from mxnet import init
net.initialize(init.Normal(sigma=0.01))

# 5. 定义损失函数
from mxnet.gluon import loss as gloss
loss=gloss.L2Loss()#平方损失

# 6.优化算法
from mxnet import gluon
trainer=gluon.Trainer(net.collect_params(),'sgd',{'learning_rate':0.03})

# 7. 训练模型
num_epochs=3
for epoch in range(1,num_epochs+1):
    for X,y in data_iter:
        with autograd.record():
            l=loss(net(X),y)
        l.backward()
        trainer.step(batch_size)
    l=loss(net(features),labels)
    print('epoch %d, loss: %f' % (epoch, l.mean().asnumpy()))

dense=net[0]
print(true_w,dense.weight.data())
print(true_b,dense.bias.data())