MXNET:监督学习

时间:2022-07-02 03:55:21

线性回归

给定一个数据点集合 X 和对应的目标值 y,线性模型的目标就是找到一条使用向量 w 和位移 b

描述的线,来尽可能地近似每个样本X[i] 和 y[i]。

数学公式表示为\(\hat{y}=Xw+b\)

目标函数是最小化所有点的平方误差 \(\sum_{i=1}^{n} (\hat{y_i}-y_i)^2\)

⼀个神经⽹络就是⼀个由节点(神经元)和有向边组成的集合。我们⼀ 般把⼀些节点组成层,每⼀层先从下⾯⼀层的节点获取输⼊,然后输出给上⾯的层使⽤。要计算⼀ 个节点值,我们需要将输⼊节点值做加权和(权数值即w),然后再加上⼀个激活函数(activation function)。这里的激活函数是\(f(x)=x\)

创建数据集: \(y=2*x[0] - 3.4*x[1] + 4.2 +noise\)

# -*- coding: utf-8 -*-
from mxnet import ndarray as nd
from mxnet import autograd num_inputs = 2
num_examples = 1000 true_w = [2, -3.4]
true_b = 4.2 X = nd.random_normal(shape=(num_examples, num_inputs))
y = true_w[0] * X[:, 0] + true_w[1] * X[:, 1] + true_b
y += .01 * nd.random_normal(shape=y.shape) print 'dataset' import matplotlib.pyplot as plt
plt.scatter(X[:, 1].asnumpy(),y.asnumpy())
plt.show()

当我们开始训练神经⽹络的时候,我们需要不断读取数据块。这⾥我们定义⼀个函数它每次返回 batch_size 个随机的样本和对应的⽬标。

import random
batch_size = 10
def data_iter():
# 产⽣⼀个随机索引
idx = list(range(num_examples))
random.shuffle(idx)
for i in range(0, num_examples, batch_size):
j = nd.array(idx[i:min(i+batch_size,num_examples)])
yield nd.take(X, j), nd.take(y, j) for data, label in data_iter():
print(data, label)

随机初始化模型参数,之后训练时我们需要对这些参数求导来更新它们的值,使损失尽量减小;因此我们需要创建它们的梯度。

w = nd.random_normal(shape=(num_inputs, 1))
b = nd.zeros((1,))
params = [w, b] for param in params:
param.attach_grad()

定义网络

def net(X):
return nd.dot(X, w) + b

定义损失函数

def square_loss(yhat, y):
# 注意这⾥我们把 y 变形成 yhat 的形状来避免矩阵形状的⾃动转换
return (yhat - y.reshape(yhat.shape)) ** 2

定义优化方案,我们这⾥通过随机梯度下降来求解。每⼀步,我们将模型参数沿着梯度的反⽅向走特定距离,这个距离⼀般叫学习率(learning rate)lr

def SGD(params, lr):
for param in params:
param[:] = param - lr * param.grad

现在我们可以开始训练了。训练通常需要迭代数据数次,在这⾥使⽤ epochs表⽰迭代总次数; ⼀次迭代中,我们每次随机读取固定数个数据点,计算梯度并更新模型参数。

epochs = 5
learning_rate = .001
niter = 0
moving_loss = 0
smoothing_constant = .01
# 训练
for e in range(epochs):
total_loss = 0
for data, label in data_iter():
with autograd.record():
output = net(data)
loss = square_loss(output, label)
loss.backward()
SGD(params, learning_rate)
total_loss += nd.sum(loss).asscalar()
# 记录每读取⼀个数据点后,损失的移动平均值的变化;
niter +=1
curr_loss = nd.mean(loss).asscalar()
moving_loss = (1 - smoothing_constant) * moving_loss + (smoothing_constant * curr_loss)
if (niter + 1) % 100 == 0:
print("Epoch %d, batch %d. Average loss: %f" % (
epochs, niter, moving_loss))
print(params)
# output
[[ 1.99952257]
[-3.39969802]]
<NDArray 2x1 @cpu(0)>,
[ 4.19949913]
<NDArray 1 @cpu(0)>

线性回归-使用Gluon

这里我们将使用MXNet提供的Gluon接口更方便地实现线性回归的训练。

首先生成数据集

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)

读取数据,使用Gluon提供的data模块来读取数据。在每一次迭代中,我们将随机读取包含10个数据样本的小批量。

from mxnet.gluon import data as gdata
batch_size = 10
dataset = gdata.ArrayDataset(features, labels)
data_iter = gdata.DataLoader(dataset, batch_size, shuffle=True)

在前面我们需要定义模型参数,并使用它们一步步描述模型是怎样计算的。当模型结构变得更复杂时,这些步骤将变得更加繁琐。其实,Gluon提供了大量预定义的层,这使我们只需关注使用哪些层来构造模型。

首先,导入nn模块。我们先定义一个模型变量net,它是一个Sequential实例。在Gluon中,Sequential实例可以看做是一个串联各个层的容器。在构造模型时,我们在该容器中依次添加层。当给定输入数据时,容器中的每一层将依次计算并将输出作为下一层的输入。

线性回归的输出层又叫全连接层。在Gluon中,全连接层是一个Dense实例。我们定义该层输出个数为1。

from mxnet.gluon import nn
net = nn.Sequential()
net.add(nn.Dense(1))

值得一提的是,在Gluon中我们无需指定每一层输入的形状,例如线性回归的输入个数。当模型看见数据时,例如后面执行net(X)时,模型将自动推断出每一层的输入个数。

初始化模型参数,从MXNet中导入init模块,并通过init.Normal(sigma=0.01)指定权重参数每个元素将在初始化时随机采样于均值为0标准差为0.01的正态分布。偏差参数全部元素初始化为零。

from mxnet import init
net.initialize(init.Normal(sigma=0.01))

定义损失函数,从gluon引入loss模块

from mxnet.gluon import loss as gloss
loss = gloss.L2Loss()

定义优化算法,在导入Gluon后,我们可以创建一个Trainer实例,并且将模型参数传递给它。

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

训练模型,我们通过调用step函数来迭代模型参数。由于变量l是batch_size维的NDArray,执行l.backward()等价于l.sum().backward()。按照小批量随机梯度下降的定义,我们在step函数中提供batch_size,以确保小批量随机梯度是该批量中每个样本梯度的平均。

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)
print("epoch %d, loss: %f"
% (epoch, loss(net(features), labels).asnumpy().mean())) dense = net[0]
print true_w, dense.weight.data()
print true_b, dense.bias.data()

可以从net获得需要的层,并访问其权重和位移。学到的和真实的参数很接近。