mxnet 线性模型

import mxnet.ndarray as nd

from mxnet import gluon

from mxnet import autograd

# create data

def set_data(true_w, true_b, num_examples, *args, **kwargs):

    num_inputs = len(true_w)

    X = nd.random_normal(shape=(num_examples, num_inputs))

    y = 0

    for num in range(num_inputs):

        # print(num)

        y += true_w[num] * X[:, num]

    y += true_b

    y += 0.1 * nd.random_normal(shape=y.shape)

    return X, y

# create data loader

def data_loader(batch_size, X, y, shuffle=False):

    data_set = gluon.data.ArrayDataset(X, y)

    data_iter = gluon.data.DataLoader(dataset=data_set, batch_size=batch_size, shuffle=shuffle)

    return data_iter

# create net

def set_net(node_num):

    net = gluon.nn.Sequential()

    net.add(gluon.nn.Dense(node_num))

    net.initialize()

    return net

# create trainer

def trainer(net, loss_method, learning_rate):

    trainer = gluon.Trainer(

        net.collect_params(), loss_method, {‘learning_rate‘: learning_rate}

    )

    return trainer

square_loss = gluon.loss.L2Loss()

# start train

def start_train(epochs, batch_size, data_iter, net, loss_method, tariner, num_examples):

    for e in range(epochs):

        total_loss = 0

        for data, label in data_iter:

            with autograd.record():

                output = net(data)

                loss = loss_method(output, label)

            loss.backward()

            trainer.step(batch_size)

            total_loss += nd.sum(loss).asscalar()

        print("第 %d次训练, 平均损失: %f" % (e, total_loss / 1000))

    dense = net[0]

    print(dense.weight.data())

    print(dense.bias.data())

    return dense.weight.data(), dense.bias.data()

true_w = [5, 8, 6]

true_b = 6

X, y = set_data(true_w=true_w, true_b=true_b, num_examples=1000)

data_iter = data_loader(batch_size=10, X=X, y=y, shuffle=True)

net = set_net(1)

trainer = trainer(net=net, loss_method=‘sgd‘, learning_rate=0.1)

start_train(epochs=5, batch_size=10, data_iter=data_iter, net=net, loss_method=square_loss, tariner=trainer,

            num_examples=1000)