實現一個簡單的線性回歸(mxnet)

from mxnet import ndarray as nd
from mxnet import autograd
import matplotlib.pyplot as plt
import random
num_input=2#變量數
num_examples=1000#1000個樣例
true_w=[2,-3.4]#真實的系數W
true_b=4.2#真實的偏倚b
X=nd.random_normal(shape=(num_examples,num_input))#隨機產生數據
y=true_w[0]*X[:,0]+true_w[1]*X[:,1]+true_b#得到y值
y
 
+=0.01*nd.random_normal(shape=y.shape)#加噪聲
print(X[0],y[0])
plt.scatter(X[:,1].asnumpy(),y.asnumpy())#必須轉換為numpy才能繪圖
plt.show()
batch_size=10#batch大小

def data_iter():
    idx=list(range(num_examples))
    random.shuffle(idx)#打亂數組
    for i in range(0,num_examples,batch_size):#步長為10
        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():#從data_liter()中提取
    print(data,label)
    break

w=nd.random_normal(shape=(num_input,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):#設置損失函數
    
 
return (yhat-y.reshape(yhat.shape))**2
def SGD(params,lr):#隨機梯度下降函數
    for param in params:#對每個參數使用隨機梯度下降
        param[:]=param-lr*param.grad#param.grad是自動求導的值

def real_fn(X):#真實的函數
    return 2*X[:,0]-3.4*X[:,1]+4.2
def plot(losses,X,sample_size=100):#繪圖
    xs=list(range(len(losses)))
    f=plt.figure()
    fg1=f.add_subplot(121)
    fg2=f.add_subplot(122)
    fg1.set_title(‘Loss during training‘)
    fg1.plot(xs,losses,‘r‘)
    fg2.set_title(‘Estimated vs real function‘)
    fg2.plot(X[:sample_size,1].asnumpy(),net(X[:sample_size,:]).asnumpy(),‘or‘,label=‘Estimated‘)
    fg2.plot(X[:sample_size,1].asnumpy(),real_fn(X[:sample_size,:]).asnumpy(),‘*g‘,label=‘Real‘)
    fg2.legend()
    plt.show()
epochs = 5
learning_rate = .001
niter = 0
losses = []
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

        # correct the bias from the moving averages
        est_loss = moving_loss/(1-(1-smoothing_constant)**niter)

結果：

線性回歸 — 使用Gluon

from mxnet import ndarray as nd
from mxnet import autograd
from mxnet import gluon

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+=0.01*nd.random_normal(shape=y.shape)

#數據讀取
batch_size=10
dataset=gluon.data.ArrayDataset(X,y)
data_iter=gluon.data.DataLoader(dataset,batch_size,shuffle=True)

for data,label in data_iter:
    print(data,label)
    break

net=gluon.nn.Sequential()
net.add(gluon.nn.Dense(1))

net.initialize()
square_loss=gluon.loss.L2Loss()
trainer=gluon.Trainer(net.collect_params(),‘sgd‘,{‘learning_rate‘:0.1})

epoch=5
batch_size=10
for e in range(epoch):
    total_loss=0
    for data,label in data_iter:
        with autograd.record():
            output=net(data)
            loss=square_loss(output,label)
        loss.backward()
        trainer.step(batch_size)
        total_loss+=nd.sum(loss).asscalar()
    print("Epoch %d average loss:%f"%(e,total_loss/num_examples))

《動手學深度學習（李沐）》筆記1