线性回归简洁实现 （Gluon实现）

导入必要的包

from mxnet import nd
import mxnet.autograd as ag
from mxnet.gluon import data as gdata,loss as gloss
from mxnet.gluon import nn

生成数据集

#使用人工模拟的数据
num_input = 2
num_examples = 1000

true_w = [1.8,-8.9]
true_b = 8.3

features = nd.random.normal(shape=(num_examples,num_input))
labels = nd.dot(features,nd.array(true_w).reshape(-1,1))+true_b
labels += nd.random.normal(scale=0.01,shape=labels.shape)

#显示数据
features[0],labels[0]

(
 [-0.59328866  0.36333823]
 <NDArray 2 @cpu(0)>, 
 [3.9829042]
 <NDArray 1 @cpu(0)>)

读取数据

#设置小批量大小
batch_size = 10

#运用gluon中的data包里面的函数进行数据集的封装
#将所有的特征值和标签值进行封装
dataset = gdata.ArrayDataset(features,labels)

#再调用gluon.data中的Dataloader加载小批量数据
data_iter = gdata.DataLoader(dataset,batch_size,shuffle=True)

#查看小批量数据是否载入成功
for feature,label in data_iter:
    print(feature,label)
    break

[[-0.04164214 -0.66353106]
 [-0.7578126   0.6890422 ]
 [-1.4695461  -0.14895555]
 [-0.6372913   0.4833494 ]
 [ 0.9826811  -0.18151674]
 [-0.618963   -1.3532845 ]
 [-0.04518233 -0.81526893]
 [-0.7801847   0.12058286]
 [ 1.3179002   2.0065207 ]
 [-0.37118936 -0.46292105]]
<NDArray 10x2 @cpu(0)> 
[[14.135831  ]
 [ 0.79448044]
 [ 6.981569  ]
 [ 2.827113  ]
 [11.675564  ]
 [19.23338   ]
 [15.475199  ]
 [ 5.813657  ]
 [-7.205659  ]
 [11.741881  ]]
<NDArray 10x1 @cpu(0)>

定义模型

#新建存放神经网络的容器，这个容器可以将多个神经网络层串起来
net = nn.Sequential()
print("可以看到一开始这个容器上什么也没有:\n",net)

#加入一层一个节点的输出层
net.add(nn.Dense(1))
print("这个时候我们再输出，可以看里面添加了一层：\n",net)

#注意我们并不需要定义我们输入层的输入节点是多少，该容器默认会自动识别输入层

可以看到一开始这个容器上什么也没有:
 Sequential(

)
这个时候我们再输出，可以看里面添加了一层：
 Sequential(
  (0): Dense(None -> 1, linear)
)

初始化模型参数

#容器会自动初始化权重w和bias这些参数，并不需要我们先定义
net.initialize()

定义损失函数

square_loss = gloss.L2Loss()

优化函数

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

训练

#训练和之前的差不多，只不过优化函数不是使用sgd而是使用trainer.step()
epochs = 5
batch_size = 10
for e in range(1,epochs+1):
    total_loss = 0
    for data,label in data_iter:
        with ag.record():
            output = net(data)
            l = square_loss(output,label)
        l.backward()
        trainer.step(batch_size)
        total_loss = nd.sum(l).asscalar()
    print("Epoch %d , average loss %f" % (e,total_loss/num_examples))

Epoch 1 , average loss 0.000001
Epoch 2 , average loss 0.000000
Epoch 3 , average loss 0.000001
Epoch 4 , average loss 0.000000
Epoch 5 , average loss 0.000000

对比训练出来的准确度

true_w,net[0].weight.data()

([1.8, -8.9], 
 [[ 1.8001785 -8.899426 ]]
 <NDArray 1x2 @cpu(0)>)

true_b,net[0].bias.data()

(8.3, 
 [8.300419]
 <NDArray 1 @cpu(0)>)