Pytorch中如何调用forward()函数

PyTorch是深度学习领域非常流行的一种开源深度学习框架，实现了动态计算图机制。在PyTorch中，forward()函数是神经网络模型中的核心函数之一，它负责对输入数据进行前向计算，即将输入数据经过一系列的神经网络层进行计算，输出网络的预测值。

调用forward()函数的步骤如下：

1.定义模型类

在PyTorch中，我们需要首先定义神经网络的模型类，并继承自nn.Module类。在模型类中，我们需要实现__init__()方法和forward()方法，并在__init__()方法中定义各个神经网络层的参数和超参数，如下所示：

import torch.nn as nn

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(1, 32, 3, 1)
        self.conv2 = nn.Conv2d(32, 64, 3, 1)
        self.dropout1 = nn.Dropout2d(0.25)
        self.dropout2 = nn.Dropout2d(0.5)
        self.fc1 = nn.Linear(9216, 128)
        self.fc2 = nn.Linear(128, 10)

    def forward(self, x):
        x = self.conv1(x)
        x = F.relu(x)
        x = self.conv2(x)
        x = F.relu(x)
        x = F.max_pool2d(x, 2)
        x = self.dropout1(x)
        x = torch.flatten(x, 1)
        x = self.fc1(x)
        x = F.relu(x)
        x = self.dropout2(x)
        x = self.fc2(x)
        output = F.log_softmax(x, dim=1)
        return output

在__init__()方法中，我们定义了卷积层、池化层、全连接层、dropout层等，这些层的参数和超参数可以根据不同的网络结构进行设置。而在forward()方法中，我们先利用卷积层和ReLU激活函数进行计算，然后是MaxPooling池化层，再利用dropout进行特征提取，最后是全连接层和softmax激活函数的输出。

2.加载数据和模型

调用forward()函数之前，我们需要通过DataLoader加载数据和通过Net加载预训练模型。

import torch
import torchvision
import torchvision.transforms as transforms

# Load data
transform = transforms.Compose(
    [transforms.ToTensor(),
     transforms.Normalize((0.5,), (0.5,))])

trainset = torchvision.datasets.MNIST(root='./data', train=True,
                                        download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=64,
                                          shuffle=True, num_workers=2)

# Load model
net = Net()
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(net.parameters(), lr=0.001, momentum=0.9)

以上代码加载了一个MNIST数据集作为训练集，创建了一个批次大小为64的DataLoader，并通过Net加载了我们定义的神经网络模型。同时，我们定义了损失函数和优化器。

3.前向计算

完成以上步骤后，我们就可以进行前向计算了。具体方法是将数据传入模型，然后调用forward()方法。

import torch.nn.functional as F

# Forward
for i, data in enumerate(trainloader, 0):
    # Get the inputs; data is a list of [inputs, labels]
    inputs, labels = data

    # Zero the parameter gradients
    optimizer.zero_grad()

    # Forward + backward + optimize
    outputs = net(inputs)
    loss = criterion(outputs, labels)
    loss.backward()
    optimizer.step()

在上述代码中，我们利用DataLoader获取了批次数据，然后利用optimizer将其映射到模型输入，最后通过调用net的forward()方法即可完成前向计算。

示例1：使用自定义module实现前向计算

import torch

class MyLinear(torch.nn.Module):
    def __init__(self, in_features, out_features):
        super(MyLinear, self).__init__()
        self.w = torch.nn.Parameter(torch.randn(out_features, in_features))
        self.b = torch.nn.Parameter(torch.randn(out_features))

    def forward(self, x):
        x = x @ torch.transpose(self.w, 0, 1) + self.b
        return x

model = MyLinear(10, 5)
x = torch.randn(32, 10)
out = model(x)
print(out.shape) # (32, 5)

上述代码中，我们定义了一个MyLinear的module， 实现了线性变换操作。在forward()方法中，我们利用@运算符将输入数据x和权重w进行矩阵相乘，并加上偏置项b，输出结果即为变换后的结果out。最后，我们利用x作为初始化输入，调用model的forward()方法，即可输出结果。

示例2：使用默认的nn.Linear实现前向计算

import torch.nn as nn
import torch

class Net(nn.Module):

    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(784, 10)
        self.fc2 = nn.Linear(10, 5)

    def forward(self, x):
        x = self.fc1(x)
        x = torch.sigmoid(x)
        x = self.fc2(x)
        return x

model = Net()
x = torch.randn(32, 28*28)
out = model(x)
print(out.shape) # (32, 5)

上述代码中，我们仍然定义了Net的module，利用默认的nn.Linear实现了两层全连接层。在forward()方法中，我们首先通过第一层的nn.Linear实现了输入数据x到10维的变换，然后通过sigmoid函数进行激活。然后我们通过第二层nn.Linear将10维的向量转化为5维，最后输出结果即可。