请帮我用pytorch框架写一个双并行的卷积神经网络

以下是一个使用双并行的卷积神经网络的示例代码：

import torch
from torch import nn
from torch.nn.parallel import DataParallel


class ConvNet(nn.Module):
    def __init__(self):
        super(ConvNet, self).__init__()
        self.conv1 = nn.Conv2d(3, 16, kernel_size=5, padding=2)
        self.bn1 = nn.BatchNorm2d(16)
        self.pool1 = nn.MaxPool2d(kernel_size=2, stride=2)
        self.conv2 = nn.Conv2d(16, 32, kernel_size=5, padding=2)
        self.bn2 = nn.BatchNorm2d(32)
        self.pool2 = nn.MaxPool2d(kernel_size=2, stride=2)
        self.fc1 = nn.Linear(32 * 8 * 8, 100)
        self.fc2 = nn.Linear(100, 10)

    def forward(self, x):
        x = self.conv1(x)
        x = self.bn1(x)
        x = nn.functional.relu(x)
        x = self.pool1(x)
        x = self.conv2(x)
        x = self.bn2(x)
        x = nn.functional.relu(x)
        x = self.pool2(x)
        x = x.view(-1, 32 * 8 * 8)
        x = self.fc1(x)
        x = nn.functional.relu(x)
        x = self.fc2(x)
        return x


if __name__ == '__main__':
    device = torch.device('cuda:0')
    model = ConvNet()
    model = DataParallel(model)
    model.to(device)
    loss_fn = nn.CrossEntropyLoss()
    optimizer = torch.optim.SGD(model.parameters(), lr=0.1)

    # training loop
    for i in range(100):
        x = torch.randn(16, 3, 32, 32).to(device)
        y = torch.randint(0, 10, (16,)).to(device)
        y_pred = model(x)
        loss = loss_fn(y_pred, y)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        if i % 10 == 0:
            print(f'Epoch {i}: Loss = {loss.item()}')

本代码中，我们使用了一个典型的卷积神经网络，使用`DataParallel`将模型并行化，以在多个GPU上训练模型。在该模型中，我们使用了两个卷积层、两个池化层和两个全连接层。我们还定义了一些训练循环，包括定义优化器、损失函数以及在每个训练步骤中执行的前向传递、反向传递和优化步骤。