深度学习笔记（6）---自学《动手学深度学习》----高维线性回归简单案例实现 内附代码片段及解释

高维线性回归

注：t.my_ones_packages是我自己根据《动手学深度学习》目前学习过程中出现的所有自定义函数进行集中得到的文档。
《动手学深度学习》也向读者提供了一个包含所有自定义函数的包“d2lzh”大家可以自行下载 侵删 链接如下 :link. 提取码: un5p 时间设置是永久的 如果失效可以联系我更新

import t.my_ones_packages as mop
from mxnet import autograd, gluon, init, nd
from mxnet.gluon import data as gdata, loss as gloss

num_train = 20
num_test = 100
num_inputs = 200

true_w = nd.ones((num_inputs, 1)) * 0.01  # 真实的w矩阵为 200*1的全1矩阵 然后数乘0.01
true_b = 0.05  # 真实的b为0.05

features = nd.random.normal(shape=(num_train + num_test, num_inputs))
labels = nd.dot(features, true_w) + true_b
labels += nd.random.normal(scale=0.01, shape=labels.shape)

train_features = features[:num_train, :]  # 设置训练的特征是特征矩阵的第0——20行
test_features = features[num_train:, :]   # 设置测试的特征是特征矩阵的21——最后一行

train_labels = labels[:num_train]  # 设置训练的标签是标签矩阵的第0——20行
test_labels = labels[num_train:]  # 设置测试的标签是标签矩阵的21——最后一行


# 定义模型
def init_params():
    w = nd.random.normal(scale=1, shape=(num_inputs, 1))
    b = nd.zeros(shape=(1,))
    w.attach_grad()
    b.attach_grad()
    return [w, b]


# 定义L2范数惩罚项
def l2_penatly(w):
    return (w**2).sum() / 2  # 对应 （w*w）/ 2


# 显示图像
def semilogy(x_val, y_val, x_lab, y_lab, x2_val=None, y2_val=None, legend=None, figsize=(7.5, 5.5)):
    mop.set_figsize(figsize)
    mop.plt.xlabel(x_lab)
    mop.plt.ylabel(y_lab)
    mop.plt.semilogy(x_val, y_val)

    if x2_val and y2_val:
        mop.plt.semilogy(x2_val, y2_val, linestyle=':')
        mop.plt.legend(legend)

    mop.plt.show()


# 定义训练和测试
batch_size = 1
num_epochs = 100  # 迭代周期100
lr = 0.003

net, loss = mop.linreg, mop.squared_loss

train_iter = gdata.DataLoader(gdata.ArrayDataset(train_features, train_labels), batch_size, shuffle=True)


def fit_and_plot(lambd):
    w, b = init_params()
    train_ls, test_ls = [], []
    for _ in range(num_epochs):
        for x, y in train_iter:

            with autograd.record():
                l = loss(net(x, w, b), y) + lambd * l2_penatly(w)  # L2范数损失加上L2惩罚项
            l.backward()
            mop.sgd([w, b], lr, batch_size)  # 对应 p - lr*p.grad / batch_size

        train_ls.append(loss(net(train_features, w, b), train_labels).mean().asscalar())
        test_ls.append(loss(net(test_features, w, b), test_labels).mean().asscalar())

    semilogy(range(1, num_epochs + 1), train_ls, 'epochs', 'loss',
                range(1, num_epochs + 1), test_ls, ['train', 'test'])  # 显示图像

    print('L2 norm of w: ', w.norm().asscalar())


# 观察过拟合 lambd = 0
'''
fit_and_plot(lambd=0)
'''

# 使用权重衰减
fit_and_plot(lambd=3)

使用Gluon实现高维线性回归

from mxnet import nd, init,gluon,autograd
import t.my_ones_packages as mop
from mxnet.gluon import nn, loss, data as gdata

num_train, num_test, num_inputs = 20, 100, 200

true_w, true_b = nd.ones((num_inputs, 1)) * 0.01, 0.05  # 真实的w矩阵为 200*1的全1矩阵 然后数乘0.01


features = nd.random.normal(shape=(num_train + num_test, num_inputs))
labels = nd.dot(features, true_w) + true_b
labels += nd.random.normal(scale=0.01, shape=labels.shape)

train_features, test_features = features[:num_train, :], features[num_train:, :]  # 设置训练的特征是特征矩阵的第0——20行，设置测试的特征是特征矩阵的21——最后一行

train_labels, test_labels = labels[:num_train], labels[num_train:]  # 设置训练的标签是标签矩阵的第0——20行，设置测试的标签是标签矩阵的21——最后一行


# 定义训练和测试
batch_size, num_epochs, lr = 1, 100, 0.003

net, loss = mop.linreg, mop.squared_loss # squared_loss 对应 (y1 - y0)**2 / 2

train_iter = gdata.DataLoader(gdata.ArrayDataset(train_features, train_labels), batch_size, shuffle=True)


def fit_and_plot_gluon(wd):
    net = nn.Sequential()
    net.add(nn.Dense(1))
    net.initialize(init.Normal(sigma=1))


    # 因为net.collect_params()的打印结果是
    '''sequential0_ (
    Parameter dense0_weight (shape=(1, 0), dtype=float32)
    Parameter dense0_bias (shape=(1,), dtype=float32)
    )'''
    # 所以使用net.collect_params('.*weight')和net.collect_params('.*bias') 可以分别将第一条和第二条分别进行传参
    trainer_w = gluon.Trainer(net.collect_params('.*weight'), 'sgd', {'learning_rate': lr, 'wd': wd})
    trainer_b = gluon.Trainer(net.collect_params('.*bias'), 'sgd', {'learning_rate': lr})

    train_ls, test_ls = [], []
    for _ in range(num_epochs):
        for x, y in train_iter:
            with autograd.record():
                l = loss(net(x), y)  # l是 net(x) 和 y的 L2范数损失
            l.backward()

            trainer_w.step(batch_size)  # 仅保存参数和超级参数 ，根据batch_size进行迭代，数据更新
            trainer_b.step(batch_size)

        train_ls.append(loss(net(train_features), train_labels).mean().asscalar())
        test_ls.append(loss(net(test_features), test_labels).mean().asscalar())

    mop.semilogy(range(1, num_epochs + 1), train_ls, 'epochs', 'loss',
                range(1, num_epochs + 1), test_ls, ['train', 'test'])

    print('L2 norm of w : ', net[0].weight.data().norm().asscalar())


# 观察过拟合 wd = 0
'''
fit_and_plot_gluon(wd=0)
'''


# 使用权重衰减
fit_and_plot_gluon(wd=3)