PyTorch: nn#

创建日期：2020 年 12 月 03 日 | 最后更新：2025 年 09 月 29 日 | 最后验证：2024 年 11 月 05 日

一个三阶多项式，通过最小化欧几里得距离平方，从 \(-\pi\) 到 \(\pi\) 训练以预测 \(y=\sin(x)\)。

此实现使用 PyTorch 的 nn 包来构建网络。PyTorch 的 autograd 使得定义计算图和计算梯度变得容易，但原始的 autograd 对于定义复杂的神经网络来说可能过于底层；这就是 nn 包可以提供帮助的地方。nn 包定义了一组 Modules，您可以将它们看作是神经网络层，它们根据输入产生输出，并且可能包含一些可训练的权重。

289.04107666015625
197.71018981933594
136.2671661376953
94.89392852783203
67.00952911376953
48.198585510253906
35.49624252319336
26.91018295288086
21.100711822509766
17.165796279907227
14.497730255126953
12.686685562133789
11.456018447875977
10.618821144104004
10.048646926879883
9.659878730773926
9.394503593444824
9.213150024414062
9.089075088500977
9.004087448120117
Result: y = 0.011030223220586777 + 0.848137617111206 x + -0.0019028971437364817 x^2 + -0.0921066552400589 x^3

import torch
import math


# Create Tensors to hold input and outputs.
x = torch.linspace(-math.pi, math.pi, 2000)
y = torch.sin(x)

# For this example, the output y is a linear function of (x, x^2, x^3), so
# we can consider it as a linear layer neural network. Let's prepare the
# tensor (x, x^2, x^3).
p = torch.tensor([1, 2, 3])
xx = x.unsqueeze(-1).pow(p)

# In the above code, x.unsqueeze(-1) has shape (2000, 1), and p has shape
# (3,), for this case, broadcasting semantics will apply to obtain a tensor
# of shape (2000, 3)

# Use the nn package to define our model as a sequence of layers. nn.Sequential
# is a Module which contains other Modules, and applies them in sequence to
# produce its output. The Linear Module computes output from input using a
# linear function, and holds internal Tensors for its weight and bias.
# The Flatten layer flatens the output of the linear layer to a 1D tensor,
# to match the shape of `y`.
model = torch.nn.Sequential(
    torch.nn.Linear(3, 1),
    torch.nn.Flatten(0, 1)
)

# The nn package also contains definitions of popular loss functions; in this
# case we will use Mean Squared Error (MSE) as our loss function.
loss_fn = torch.nn.MSELoss(reduction='sum')

learning_rate = 1e-6
for t in range(2000):

    # Forward pass: compute predicted y by passing x to the model. Module objects
    # override the __call__ operator so you can call them like functions. When
    # doing so you pass a Tensor of input data to the Module and it produces
    # a Tensor of output data.
    y_pred = model(xx)

    # Compute and print loss. We pass Tensors containing the predicted and true
    # values of y, and the loss function returns a Tensor containing the
    # loss.
    loss = loss_fn(y_pred, y)
    if t % 100 == 99:
        print(t, loss.item())

    # Zero the gradients before running the backward pass.
    model.zero_grad()

    # Backward pass: compute gradient of the loss with respect to all the learnable
    # parameters of the model. Internally, the parameters of each Module are stored
    # in Tensors with requires_grad=True, so this call will compute gradients for
    # all learnable parameters in the model.
    loss.backward()

    # Update the weights using gradient descent. Each parameter is a Tensor, so
    # we can access its gradients like we did before.
    with torch.no_grad():
        for param in model.parameters():
            param -= learning_rate * param.grad

# You can access the first layer of `model` like accessing the first item of a list
linear_layer = model[0]

# For linear layer, its parameters are stored as `weight` and `bias`.
print(f'Result: y = {linear_layer.bias.item()} + {linear_layer.weight[:, 0].item()} x + {linear_layer.weight[:, 1].item()} x^2 + {linear_layer.weight[:, 2].item()} x^3')

脚本总运行时间： (0 分钟 0.559 秒)

PyTorch: nn#

文档

教程

资源