用pytorch和lenet实现猫狗分类

好的，下面是基于PyTorch和LeNet模型实现猫狗分类的代码。我们将使用一个包含猫和狗的数据集，其中有25000张训练图像和12500张测试图像。

首先，我们需要安装PyTorch和torchvision库：

!pip install torch torchvision

然后，我们需要下载数据集并将其拆分为训练集和测试集。你可以使用以下代码下载数据集：

!wget https://www.dropbox.com/s/0yzyf7bojd8xu9w/cat_dog_dataset.zip
!unzip cat_dog_dataset.zip

接下来，我们将使用以下代码来加载数据集并进行必要的预处理：

import torch
import torchvision.transforms as transforms
from torchvision.datasets import ImageFolder

#设置数据预处理
transform = transforms.Compose([
    transforms.Resize((32, 32)),
    transforms.ToTensor(),
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])

#加载数据集
train_dataset = ImageFolder('cat_dog_dataset/train', transform=transform)
test_dataset = ImageFolder('cat_dog_dataset/test', transform=transform)

#设置批量大小
batch_size = 32

#创建数据加载器
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=batch_size, shuffle=False)

现在我们已经准备好开始构建模型了。我们将使用经典的LeNet-5模型，该模型适用于图像分类任务。下面是LeNet-5模型的实现：

import torch.nn as nn
import torch.nn.functional as F

class LeNet(nn.Module):
    def __init__(self):
        super(LeNet, self).__init__()
        self.conv1 = nn.Conv2d(3, 6, 5)
        self.pool1 = nn.MaxPool2d(2)
        self.conv2 = nn.Conv2d(6, 16, 5)
        self.pool2 = nn.MaxPool2d(2)
        self.fc1 = nn.Linear(16 * 5 * 5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 2)

    def forward(self, x):
        x = F.relu(self.conv1(x))
        x = self.pool1(x)
        x = F.relu(self.conv2(x))
        x = self.pool2(x)
        x = x.view(-1, 16 * 5 * 5)
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x

我们定义了一个包含两个卷积层和三个全连接层的LeNet类。我们使用ReLU激活函数来增加非线性性，并且使用最大池化层来减少空间维度。

现在，我们将实例化LeNet类并定义我们想要使用的优化器和损失函数：

#实例化模型
model = LeNet()

#定义优化器和损失函数
learning_rate = 0.001
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)

我们使用Adam优化器和交叉熵损失函数进行训练。现在，我们可以开始训练模型：

#设置训练参数
num_epochs = 10
total_step = len(train_loader)

#训练模型
for epoch in range(num_epochs):
    for i, (images, labels) in enumerate(train_loader):
        #前向传播
        outputs = model(images)
        loss = criterion(outputs, labels)

        #反向传播和优化
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        #记录训练状态
        if (i+1) % 100 == 0:
            print('Epoch [{}/{}], Step [{}/{}], Loss: {:.4f}'
                  .format(epoch+1, num_epochs, i+1, total_step, loss.item()))

在每个epoch中，我们遍历训练数据加载器并执行前向传播、反向传播和优化步骤。我们还打印了在每个epoch中的损失值以进行训练状态的记录。

现在，我们已经训练好了模型，我们可以在测试集上测试它的性能：

#测试模型
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('Test Accuracy of the model on the test images: {} %'.format(100 * correct / total))

我们计算了模型在测试集上的准确率。现在，我们已经实现了一个基于PyTorch和LeNet模型的猫狗分类器。