MXnet 线性回归实现

                  目录

单层神经网络--线性回归

线性回归的表示方式

---

单层神经网络--线性回归

        线性回归：顾名思义就是输出与输入是一个线性的关系，可以从以下等式体现：

        

        y是预测的输出，x是输入，也叫特征，w是比例系数，也可以叫做权重，b是偏差，也叫偏置或者位移。

        损失函数：在训练的时候，我们需要一个衡量预测值与真实输出的误差标准，一般这个误差是正数，通常选择平方函数，表达式为：

        

        以上函数我们称为损失函数，也叫平方损失（square loss）。

        算法的优化：类似以上这种较为简单的损失函数，一般可以直接表达，称为解析解。但大多数情况下，深度学习的模型没有解析解，一般通过有限次的迭代模型参数来降低损失函数的值，这种解叫做数值解。

        本次讨论线性回归模型时，迭代方式通过以下方式迭代（w1，w2，b等同迭代）：

        

        是权重，是学习率，为批次大小（batch size），为所有样本误差关于的偏导数的和，也称作变化率的和

线性回归的表示方式

        神经网络图：

                        

        输入分别是x1，x2，因此输入层个数为2，输入个数也被称作特征数或特征向量维度。网络的输出为y，输入层不涉及计算，所以以上神经网络的层数为1，线性回归中，y的计算依赖于x1和x2，输出层中的神经元和输入层各个输入连接，我们把这样的输出层称为全连接层（full-connected layer）或稠密层(dense layer)。

        矢量计算表达式：一般我们进行处理数据的时候经常会用到矢量计算。矢量计算的速度要比标量计算快很多。在jupyte notebook中运行以下代码可以进行计算时间比较

        

from mxnet import nd
from time import time

a = nd.ones(shape=1000)
b = nd.ones(shape=1000)

start = time()
c = nd.zeros(shape=1000)
for i in range(1000):
    c[i] = a[i] + b[i]#标量加法
time()-start

start = time()
d = a+b  #矢量相加，比按元素的标量加法快很多
time()-start

0.16213703155517578

0.000997304916381836

        线性回归实现：有了以上的了解，我们就可以开始进行线性回归的小试牛刀了

        1.首先是进行固定权重与偏置与生成数据集

%matplotlib inline
from IPython import display
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 #y=w1x1+w2x2+b 1000*1
labels += nd.random.normal(scale = 0.01,shape=labels.shape) #随机噪声，均值为0，标准差为0.01

features[0], labels[0]#查看预测值与实际值

        2.将生成features结果以图形式打印出来

def use_svg_display():
    display.set_matplotlib_formats('svg')
def set_figsize(figsize=(3.5,2.5)):
    use_svg_display()
    plt.rcParams['figure.figsize'] = figsize#设置图的尺寸
set_figsize()
plt.scatter(features[:,1].asnumpy(),labels.asnumpy(),1)

      

        3.然后是读取数据集并返回batch_size大小

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)#take函数根据索引返回对应元素

batch_size = 10

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

  输出结果：

[[ 1.5835911   1.6650606 ]
 [ 0.6839749  -1.7341288 ]
 [-2.4322338  -1.3077108 ]
 [ 2.4174292   0.7307968 ]
 [-1.739327    1.1138114 ]
 [-0.0041589  -2.0201764 ]
 [ 0.19716702 -0.54311603]
 [ 0.4916877   1.0208001 ]
 [-0.867172   -0.7658711 ]
 [ 1.6920192   0.4531655 ]]
<NDArray 10x2 @cpu(0)> 
[ 1.700413  11.46015    3.795412   6.53538   -3.069857  11.065431
  6.4376583  1.7027123  5.062301   6.032969 ]
<NDArray 10 @cpu(0)>

        5.接下来，我们将权重初始化为均值为0，标准差为0.01的正太随机数，偏置初始化为0 

        

#初始化模型参数
w = nd.random.normal(scale=0.01, shape=(num_inputs,1))#均值为0，标准差为0.01
b = nd.zeros(shape=(1,))
#求取参数的梯度
w.attach_grad()
b.attach_grad()
#定义模型
def linreg(X,w,b):
    return nd.dot(X,w) + b #矩阵乘法
#定义损失函数
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.001
num_epochs=10
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)
    print('epoch %d,loss %f' %(epoch+1, train_l.mean().asnumpy()))

   输出结果：

epoch 1,loss 0.000231
epoch 2,loss 0.000199
epoch 3,loss 0.000172
epoch 4,loss 0.000151
epoch 5,loss 0.000133
epoch 6,loss 0.000118
epoch 7,loss 0.000107
epoch 8,loss 0.000097
epoch 9,loss 0.000089
epoch 10,loss 0.000083

          我们可以通过查看学习到的参数和用于生成数据集的参数进行比较 ,得到的结果应该是相近的       

true_w,w

true_b, b