.. _sec_linear_concise:
线性回归的简洁实现
==================
在过去的几年里，出于对深度学习强烈的兴趣，
许多公司、学者和业余爱好者开发了各种成熟的开源框架。
这些框架可以自动化基于梯度的学习算法中重复性的工作。 在
:numref:`sec_linear_scratch`\ 中，我们只运用了：
（1）通过张量来进行数据存储和线性代数； （2）通过自动微分来计算梯度。
实际上，由于数据迭代器、损失函数、优化器和神经网络层很常用，
现代深度学习库也为我们实现了这些组件。
本节将介绍如何通过使用深度学习框架来简洁地实现
:numref:`sec_linear_scratch`\ 中的线性回归模型。
生成数据集
----------
与 :numref:`sec_linear_scratch`\ 中类似，我们首先生成数据集。
.. raw:: html
.. raw:: html
.. raw:: latex
\diilbookstyleinputcell
.. code:: python
import mindspore
import mindspore.dataset as ds
import mindspore.ops as ops
from d2l import mindspore as d2l
mindspore.set_context(mode=mindspore.PYNATIVE_MODE)
true_w = mindspore.tensor([2, -3.4])
true_b = 4.2
features, labels = d2l.synthetic_data(true_w, true_b, 1000)
.. raw:: html
.. raw:: html
.. raw:: latex
\diilbookstyleinputcell
.. code:: python
import torch
from torch.utils import data
from d2l import torch as d2l
true_w = torch.tensor([2, -3.4])
true_b = 4.2
features, labels = d2l.synthetic_data(true_w, true_b, 1000)
.. raw:: html
.. raw:: html
.. raw:: html
.. raw:: latex
\diilbookstyleinputcell
.. code:: python
def load_array(data_arrays, column_names, batch_size, is_train=True):
"""构造一个MindSpore数据迭代器。"""
dataset = ds.GeneratorDataset(data_arrays, column_names, shuffle=is_train)
return dataset.batch(batch_size)
batch_size = 10
data_iter = load_array(zip(features, labels), ['features', 'labels'], batch_size)
.. raw:: html
.. raw:: html
.. raw:: latex
\diilbookstyleinputcell
.. code:: python
def load_array(data_arrays, batch_size, is_train=True): #@save
"""构造一个PyTorch数据迭代器"""
dataset = data.TensorDataset(*data_arrays)
return data.DataLoader(dataset, batch_size, shuffle=is_train)
batch_size = 10
data_iter = load_array((features, labels), batch_size)
.. raw:: html
.. raw:: html
.. raw:: html
.. raw:: latex
\diilbookstyleinputcell
.. code:: python
next(iter(data_iter))
.. raw:: latex
\diilbookstyleoutputcell
.. parsed-literal::
:class: output
[Tensor(shape=[10, 2], dtype=Float32, value=
[[ 1.65597070e-02, 1.09879293e-01],
[ 2.54358053e-02, -7.86421955e-01],
[ 7.19841480e-01, -3.52500439e-01],
...
[ 4.26252604e-01, 3.66635740e-01],
[ 7.47478962e-01, -9.23398256e-01],
[-4.04680893e-02, 9.72729206e-01]]),
Tensor(shape=[10, 1], dtype=Float32, value=
[[ 3.84782410e+00],
[ 6.92022371e+00],
[ 6.83041763e+00],
...
[ 3.81002951e+00],
[ 8.83636093e+00],
[ 7.88963497e-01]])]
.. raw:: html
.. raw:: html
.. raw:: latex
\diilbookstyleinputcell
.. code:: python
next(iter(data_iter))
.. raw:: latex
\diilbookstyleoutputcell
.. parsed-literal::
:class: output
[tensor([[-0.8980, -0.4514],
[-2.3376, 0.0919],
[-1.1232, -0.2705],
[-0.5255, -0.9050],
[ 1.1392, 0.7053],
[-0.4683, 1.2195],
[ 0.1309, 0.0988],
[ 0.1023, 0.0337],
[-1.3015, 0.8458],
[-1.3969, 1.7490]]),
tensor([[ 3.9318],
[-0.7963],
[ 2.8712],
[ 6.2378],
[ 4.0747],
[-0.8918],
[ 4.1326],
[ 4.3039],
[-1.2762],
[-4.5644]])]
.. raw:: html
.. raw:: html
.. raw:: html
对于标准深度学习模型，我们可以使用框架的预定义好的层。这使我们只需关注使用哪些层来构造模型，而不必关注层的实现细节。
我们首先定义一个模型变量\ ``net``\ ，它是一个\ ``SequentialCell``\ 类的实例。
``SequentialCell``\ 类将多个层串联在一起。
当给定输入数据时，\ ``SequentialCell``\ 实例将数据传入到第一层，
然后将第一层的输出作为第二层的输入，以此类推。
在下面的例子中，我们的模型只包含一个层，因此实际上不需要\ ``SequentialCell``\ 。
但是由于以后几乎所有的模型都是多层的，在这里使用\ ``SequentialCell``\ 会让你熟悉“标准的流水线”。
回顾 :numref:`fig_single_neuron`\ 中的单层网络架构，
这一单层被称为\ *全连接层*\ （fully-connected layer），
因为它的每一个输入都通过矩阵-向量乘法得到它的每个输出。
在MindSpore中，全连接层在\ ``Dense``\ 类中定义。
值得注意的是，我们将两个参数传递到\ ``nn.Dense``\ 中。
第一个指定输入特征形状，即2，第二个指定输出特征形状，输出特征形状为单个标量，因此为1。
.. raw:: latex
\diilbookstyleinputcell
.. code:: python
# nn是神经网络的缩写
from mindspore import nn
from mindspore.common.initializer import Normal, initializer
net = nn.SequentialCell([nn.Dense(2, 1)])
.. raw:: html
.. raw:: html
对于标准深度学习模型，我们可以使用框架的预定义好的层。这使我们只需关注使用哪些层来构造模型，而不必关注层的实现细节。
我们首先定义一个模型变量\ ``net``\ ，它是一个\ ``Sequential``\ 类的实例。
``Sequential``\ 类将多个层串联在一起。
当给定输入数据时，\ ``Sequential``\ 实例将数据传入到第一层，
然后将第一层的输出作为第二层的输入，以此类推。
在下面的例子中，我们的模型只包含一个层，因此实际上不需要\ ``Sequential``\ 。
但是由于以后几乎所有的模型都是多层的，在这里使用\ ``Sequential``\ 会让你熟悉“标准的流水线”。
回顾 :numref:`fig_single_neuron`\ 中的单层网络架构，
这一单层被称为\ *全连接层*\ （fully-connected layer），
因为它的每一个输入都通过矩阵-向量乘法得到它的每个输出。
在PyTorch中，全连接层在\ ``Linear``\ 类中定义。
值得注意的是，我们将两个参数传递到\ ``nn.Linear``\ 中。
第一个指定输入特征形状，即2，第二个指定输出特征形状，输出特征形状为单个标量，因此为1。
.. raw:: latex
\diilbookstyleinputcell
.. code:: python
# nn是神经网络的缩写
from torch import nn
net = nn.Sequential(nn.Linear(2, 1))
.. raw:: html
.. raw:: html
.. raw:: html
正如我们在构造\ ``nn.Dense``\ 时指定输入和输出尺寸一样，
现在我们能直接访问参数以设定它们的初始值。
我们通过\ ``net[0]``\ 选择网络中的第一个图层，
然后使用\ ``weight``\ 和\ ``bias``\ 方法访问参数。
我们可以通过调用\ ``initializer(init, shape, dtype)``\ 来指定初始化权重的方法。
其中，\ ``init``\ 可以是常数，也可以是某种分布，比如正态分布\ ``Normal(sigma=0.01, mean=0.0)``
.. raw:: latex
\diilbookstyleinputcell
.. code:: python
net[0].weight = initializer(Normal(), net[0].weight.shape, mindspore.float32)
net[0].bias = initializer('zero', net[0].bias.shape, mindspore.float32)
.. raw:: html
.. raw:: html
正如我们在构造\ ``nn.Linear``\ 时指定输入和输出尺寸一样，
现在我们能直接访问参数以设定它们的初始值。
我们通过\ ``net[0]``\ 选择网络中的第一个图层，
然后使用\ ``weight.data``\ 和\ ``bias.data``\ 方法访问参数。
我们还可以使用替换方法\ ``normal_``\ 和\ ``fill_``\ 来重写参数值。
.. raw:: latex
\diilbookstyleinputcell
.. code:: python
net[0].weight.data.normal_(0, 0.01)
net[0].bias.data.fill_(0)
.. raw:: latex
\diilbookstyleoutputcell
.. parsed-literal::
:class: output
tensor([0.])
.. raw:: html
.. raw:: html
.. raw:: html
.. raw:: latex
\diilbookstyleinputcell
.. code:: python
loss = nn.MSELoss()
.. raw:: html
.. raw:: html
.. raw:: latex
\diilbookstyleinputcell
.. code:: python
loss = nn.MSELoss()
.. raw:: html
.. raw:: html
.. raw:: html
小批量随机梯度下降算法是一种优化神经网络的标准工具，
MindSpore在\ ``nn``\ 模块中实现了该算法的许多变种。
当我们实例化一个\ ``SGD``\ 实例时，我们要指定优化的参数
（可通过\ ``net.trainable_params()``\ 从我们的模型中获得）以及优化算法所需的超参数字典。
小批量随机梯度下降只需要设置\ ``lr``\ 值，这里设置为0.03。
.. raw:: latex
\diilbookstyleinputcell
.. code:: python
optimizer = nn.SGD(net.trainable_params(), learning_rate=0.03)
.. raw:: html
.. raw:: html
小批量随机梯度下降算法是一种优化神经网络的标准工具，
PyTorch在\ ``optim``\ 模块中实现了该算法的许多变种。
当我们实例化一个\ ``SGD``\ 实例时，我们要指定优化的参数
（可通过\ ``net.parameters()``\ 从我们的模型中获得）以及优化算法所需的超参数字典。
小批量随机梯度下降只需要设置\ ``lr``\ 值，这里设置为0.03。
.. raw:: latex
\diilbookstyleinputcell
.. code:: python
trainer = torch.optim.SGD(net.parameters(), lr=0.03)
.. raw:: html
.. raw:: html
.. raw:: html
.. raw:: latex
\diilbookstyleinputcell
.. code:: python
# 构造前向网络
def forward_fn(x, y):
y_hat = net(x)
l = loss(y_hat, y)
return l
grad_fn = mindspore.value_and_grad(forward_fn, grad_position=None, weights=optimizer.parameters)
num_epochs = 3
for epoch in range(num_epochs):
for X, y in data_iter:
l, grads = grad_fn(X, y)
optimizer(grads)
l = forward_fn(mindspore.tensor(features), mindspore.tensor(labels))
print(f'epoch {epoch + 1}, loss {l.asnumpy():f}')
.. raw:: latex
\diilbookstyleoutputcell
.. parsed-literal::
:class: output
[WARNING] UTILS(2921970,7a6c56a85740,python3.11):2026-05-21-02:30:29.353.596 [mindspore/ccsrc/utils/signal_util.cc:51] RegisterGlobalSignalHandler] MSCONTEXT_REGISTER_INIT_FUNC register int handler
[WARNING] UTILS(2921970,7a6c56a85740,python3.11):2026-05-21-02:30:29.353.607 [mindspore/ccsrc/utils/signal_util.cc:57] RegisterGlobalSignalHandler] The signal has been registered
epoch 1, loss 0.000168
epoch 2, loss 0.000101
epoch 3, loss 0.000100
.. raw:: html
.. raw:: html
.. raw:: latex
\diilbookstyleinputcell
.. code:: python
num_epochs = 3
for epoch in range(num_epochs):
for X, y in data_iter:
l = loss(net(X) ,y)
trainer.zero_grad()
l.backward()
trainer.step()
l = loss(net(features), labels)
print(f'epoch {epoch + 1}, loss {l:f}')
.. raw:: latex
\diilbookstyleoutputcell
.. parsed-literal::
:class: output
epoch 1, loss 0.000405
epoch 2, loss 0.000108
epoch 3, loss 0.000108
.. raw:: html
.. raw:: html
.. raw:: html
.. raw:: latex
\diilbookstyleinputcell
.. code:: python
w = net[0].weight.data
print('w的估计误差：', true_w - w.reshape(true_w.shape))
b = net[0].bias.data
print('b的估计误差：', true_b - b)
.. raw:: latex
\diilbookstyleoutputcell
.. parsed-literal::
:class: output
w的估计误差： [-8.4877014e-05 3.1447411e-04]
b的估计误差： [0.0003109]
.. raw:: html
.. raw:: html
.. raw:: latex
\diilbookstyleinputcell
.. code:: python
w = net[0].weight.data
print('w的估计误差：', true_w - w.reshape(true_w.shape))
b = net[0].bias.data
print('b的估计误差：', true_b - b)
.. raw:: latex
\diilbookstyleoutputcell
.. parsed-literal::
:class: output
w的估计误差： tensor([ 7.0453e-05, -2.0099e-04])
b的估计误差： tensor([-0.0007])
.. raw:: html
.. raw:: html
.. raw:: html
- 我们可以使用MindSpore的高级API更简洁地实现模型。
- 在MindSpore中，\ ``data``\ 模块提供了数据处理工具，\ ``nn``\ 模块定义了大量神经网络层和常见损耗函数。
- MindSpore的\ ``initializers``\ 模块提供了多种模型参数初始化方法。
.. raw:: html
.. raw:: html
- 我们可以使用PyTorch的高级API更简洁地实现模型。
- 在PyTorch中，\ ``data``\ 模块提供了数据处理工具，\ ``nn``\ 模块定义了大量的神经网络层和常见损失函数。
- 我们可以通过\ ``_``\ 结尾的方法将参数替换，从而初始化参数。
.. raw:: html
.. raw:: html
.. raw:: html
`讨论 `__
.. raw:: html
.. raw:: html
`讨论 `__
.. raw:: html
.. raw:: html