pytorch1.0中torch.nn.Conv2d用法详解

torch.nn.Conv2d是PyTorch中用于实现二维卷积操作的类。在本文中，我们将详细介绍torch.nn.Conv2d的用法，并提供两个示例。

1. `torch.nn.Conv2d`的参数

torch.nn.Conv2d的参数如下：

torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True)

其中：

in_channels：输入通道数。
out_channels：输出通道数。
kernel_size：卷积核大小。
stride：步长大小。
padding：填充大小。
dilation：膨胀率。
groups：分组卷积数。
bias：是否使用偏置。

2. `torch.nn.Conv2d`的使用

以下是一个使用torch.nn.Conv2d进行图像卷积的示例：

import torch
import torch.nn as nn

# 定义输入
x = torch.randn(1, 3, 32, 32)

# 定义卷积层
conv = nn.Conv2d(in_channels=3, out_channels=16, kernel_size=3, stride=1, padding=1)

# 进行卷积操作
out = conv(x)

# 输出结果
print(out.shape)

在这个示例中，我们首先定义了一个名为x的输入张量，它的大小为[1, 3, 32, 32]。然后，我们定义了一个名为conv的卷积层，它有3个输入通道，16个输出通道，卷积核大小为3，步长为1，填充大小为1。最后，我们使用conv对x进行卷积操作，并输出结果的大小。

以下是一个使用torch.nn.Conv2d进行图像分类的示例：

import torch
import torch.nn as nn
import torchvision.datasets as dsets
import torchvision.transforms as transforms

# 加载数据集
train_dataset = dsets.MNIST(root='./data', train=True, transform=transforms.ToTensor(), download=True)
test_dataset = dsets.MNIST(root='./data', train=False, transform=transforms.ToTensor())

# 加载数据集
train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=100, shuffle=True)
test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=100, shuffle=False)

# 定义模型
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(1, 32, kernel_size=5, padding=2)
        self.conv2 = nn.Conv2d(32, 64, kernel_size=5, padding=2)
        self.fc1 = nn.Linear(7*7*64, 1024)
        self.fc2 = nn.Linear(1024, 10)

    def forward(self, x):
        x = nn.functional.relu(self.conv1(x))
        x = nn.functional.max_pool2d(x, 2)
        x = nn.functional.relu(self.conv2(x))
        x = nn.functional.max_pool2d(x, 2)
        x = x.view(-1, 7*7*64)
        x = nn.functional.relu(self.fc1(x))
        x = nn.functional.dropout(x, training=self.training)
        x = self.fc2(x)
        return nn.functional.log_softmax(x, dim=1)

model = Net()

# 定义损失函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.01, momentum=0.5)

# 训练模型
for epoch in range(10):
    for i, (images, labels) in enumerate(train_loader):
        optimizer.zero_grad()
        outputs = model(images)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

        if (i+1) % 100 == 0:
            print ('Epoch [{}/{}], Step [{}/{}], Loss: {:.4f}'.format(epoch+1, 10, i+1, len(train_loader), loss.item()))

# 测试模型
with torch.no_grad():
    correct = 0
    total = 0
    for images, labels in test_loader:
        outputs = model(images)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

    print('Accuracy of the model on the 10000 test images: {} %'.format(100 * correct / total))

在这个示例中，我们首先加载了MNIST数据集。然后，我们定义了一个名为Net的卷积神经网络模型，它包含两个卷积层和两个全连接层。然后，我们定义了一个名为criterion的损失函数和一个名为optimizer的优化器。然后，我们使用训练数据对模型进行了训练，并在每个epoch结束时输出损失值。最后，我们使用测试数据对模型进行了测试，并输出了模型的准确率。