浅析PyTorch中nn.Linear的使用

介绍

在深度学习中，神经网络是一个重要的概念，神经网络模型通常由多个线性和非线性层构成。然而，在神经网络中，参数调节是一个关键问题。为了解决这个问题，使用反向传播算法来计算误差并调整网络参数是一种常见的方法。

PyTorch是一种基于Torch的开源机器学习库，它具有动态图的优势，可以方便地定义和训练神经网络模型。其中的nn.Linear是一个常用的线性层，本文将介绍如何使用它。

使用nn.Linear

PyTorch中的nn.Linear实现了一个全连接层，即线性变换层。它将输入特征的维度转换为输出特征的维度，并接受自己的权重和偏置向量。具体而言，如果输入具有形状(batch_size, input_size)，则输出具有形状(batch_size, output_size)。

使用nn.Linear只需要指定输入特征的大小和输出特征的大小即可。例如，下面是一个输入大小为10，输出大小为5的nn.Linear模块：

import torch
import torch.nn as nn

linear = nn.Linear(10, 5)

在从nn.Linear中获取输出时，我们可以将输入数据传递给它，然后它将计算输出，其中包括权重和偏置参数：

input = torch.randn(32, 10)
output = linear(input)

例如，这是一个使用nn.Linear的简单示例：

import torch
import torch.nn as nn

class Model(nn.Module):
    def __init__(self):
        super(Model, self).__init__()
        self.linear = nn.Linear(10, 5)

    def forward(self, x):
        out = self.linear(x)
        return out

model = Model()
input = torch.randn(32, 10)
output = model(input)
print(output.shape) # torch.Size([32, 5])

示例1：使用nn.Linear建立简单线性回归模型

以下是使用nn.Linear建立简单线性回归模型的示例：

import torch
import torch.nn as nn
import matplotlib.pyplot as plt

# 首先，创建一些测试数据。
x = torch.linspace(0, 10, 100)
y = x ** 2

# 确定模型和损失函数。
model = nn.Linear(1, 1)
criterion = nn.MSELoss()

# 确定优化器，这里使用随机梯度下降(SGD)。
optimizer = torch.optim.SGD(model.parameters(), lr=0.001)

# 开始训练，迭代10000次。
for i in range(10000):
    # 首先将x和y转换为模型需要的shape。
    x_ts = x.view(-1, 1)
    y_ts = y.view(-1, 1)

    # 将数据传递给模型并计算损失。
    y_pred = model(x_ts)
    loss = criterion(y_pred, y_ts)

    # 清除优化器的梯度然后反向传播并优化模型参数。
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

# 将结果可视化。
with torch.no_grad():
    y_pred = model(x.view(-1, 1)).numpy()

plt.plot(x.numpy(), y.numpy(), 'ro', label='Original data')
plt.plot(x.numpy(), y_pred, 'b-', label='Fitted line')
plt.legend()
plt.show()

上面的代码创建了一个简单的线性模型，该模型将x作为输入，将x^2作为输出。在模型训练之后，将结果可视化以显示模型拟合的数据。

示例2：使用nn.Linear建立简单分类模型

以下是使用nn.Linear建立简单二分类模型的示例：

import torch
import torch.nn as nn

# 创建一些测试数据。
X = torch.tensor([
    [0, 0],
    [0, 1],
    [1, 0],
    [1, 1]
], dtype=torch.float)

y = torch.tensor([
    [0],
    [1],
    [1],
    [0]
], dtype=torch.float)

# 创建模型和损失函数。
model = nn.Sequential(
    nn.Linear(2, 2),
    nn.Sigmoid(),
    nn.Linear(2, 1),
    nn.Sigmoid()
)
criterion = nn.BCELoss()

# 创建优化器，这里使用随机梯度下降(SGD)。
optimizer = torch.optim.SGD(model.parameters(), lr=0.1)

# 开始训练，迭代10000次。
for i in range(10000):
    # 将数据传递给模型并计算损失。
    y_pred = model(X)
    loss = criterion(y_pred, y)

    # 清除优化器的梯度然后反向传播并优化模型参数。
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

# 测试模型。
with torch.no_grad():
    y_test = model(X)

print(y_test.round())

在此示例中，我们创建了一个简单的二分类模型，将两个输入值作为输入，并输出一个值。在激活函数Sigmoid后，我们输出一个具有sigmoid激活的单个神经元。该模型经过训练可以对输入进行二分类，在最后输出处使用round()函数将输出四舍五入为0或1。