《动手学深度学习》学习记录01：Chapter03_1：linear regression

模型：

　　

　　其中w1和?2是权重（weight），?是偏差（bias），且均为标量。它们是线性回归模型的参数（parameter）。输出?̂ 是对真实价格?的预测（估计）。通常允许它们之间有一定误差。

 对于第 i 个训练数据来说，有：

　　

损失函数：

　　对于单个数据（乘1/2是为了求导后的形式更简单）：

　　

　　通常用其平均值衡量模型预测效果：

　　

　　所以，最终的目的为：

　　

优化算法：

　　B为总样本的一个小批量：

　　

矢量表示式：

　　有以下数据

 　　

　　则，线性回归的矢量计算表达式为：

　　

　　

　　

　　所以小批量随机梯度下降为：

　　

　　其中，

　　

 

　　　　　　　　　　　　　　代码实现　　　　　　　　　　　　　　

实现步骤：

1、生成数据

2、读取数据

3、定义模型

4、初始化模型

5、损失函数

6、优化算法

7、训练模型

#《动手学深度学习》学习记录01：Chapter03_1：linear regression 
#从零开始
from matplotlib import pyplot as plt
from mxnet import autograd,nd
import random

#生成数据
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)
# ~ plt.scatter(features[:,1].asnumpy(),labels.asnumpy())
# ~ plt.show()

#读取数据
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):
        j = nd.array( indices[i:min(i+batch_size,num_examples)] )
        yield features.take(j),labels.take(j) #索引集j对应元素

batch_size = 10
for X,y in data_iter(batch_size, features, labels):
    print(X,y)
    break

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

#初始化模型参数
w = nd.random.normal(scale=0.01, shape=(num_inputs,1))
b = nd.zeros(shape=(1,))
w.attach_grad()
b.attach_grad()

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

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

#训练模型
lr = 0.03
num_epochs = 3
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)
        l.backward()
        sgd([w,b],lr,batch_size)
    train_l = loss(net(features,w,b),labels)    #求整个训练集上的loss
    print('epoch %d, loss %f' % (epoch+1,train_l.mean().asnumpy()))


#结果输出
print(true_w,w)
print(true_b,b)

 

#《动手学深度学习》学习记录01：Chapter03_1：linear regression
#简洁版
from matplotlib import pyplot as plt
from mxnet import autograd,nd
import random

#生成数据
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)
# ~ plt.scatter(features[:,1].asnumpy(),labels.asnumpy())
# ~ plt.show()

#读取数据
from mxnet.gluon import data as gdata

batch_size = 10
dataset = gdata.ArrayDataset(features,labels)
data_iter = gdata.DataLoader(dataset,batch_size,shuffle=True)

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

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

#损失函数
from mxnet.gluon import loss as gloss
loss = gloss.L2Loss()

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

#训练模型
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()))

#结果
print(true_w,net[0].weight.data())
print(true_b,net[0].bias.data())