pytorch实现猫狗识别 python代码

很好，下面是一份简单的 PyTorch 代码实现猫狗识别：

import torch 
import torch.nn as nn 
import torchvision 
import torchvision.transforms as transforms 

# 定义神经网络
class Net(nn.Module): 
    def __init__(self): 
        super(Net, self).__init__() 
        self.conv1 = nn.Conv2d(3, 6, 5) 
        self.pool = nn.MaxPool2d(2, 2) 
        self.conv2 = nn.Conv2d(6, 16, 5) 
        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 = self.pool(torch.relu(self.conv1(x))) 
        x = self.pool(torch.relu(self.conv2(x))) 
        x = x.view(-1, 16 * 5 * 5) 
        x = torch.relu(self.fc1(x)) 
        x = torch.relu(self.fc2(x)) 
        x = self.fc3(x) 
        return x 

# 加载数据集
transform = transforms.Compose([transforms.RandomResizedCrop(224), 
                                transforms.ToTensor(), 
                                transforms.Normalize([0.485, 0.456, 0.406], 
                                                     [0.229, 0.224, 0.225])]) 

trainset = torchvision.datasets.ImageFolder("train", transform=transform) 
trainloader = torch.utils.data.DataLoader(trainset, batch_size=4, 
                                          shuffle=True, num_workers=2) 

# 定义优化器和损失函数
net = Net() 
criterion = nn.CrossEntropyLoss() 
optimizer = torch.optim.SGD(net.parameters(), lr=0.001, momentum=0.9) 

# 训练神经网络
for epoch in range(2): 

    running_loss = 0.0 
    for i, data in enumerate(trainloader, 0): 
        inputs, labels = data 
        optimizer.zero_grad() 
        outputs = net(inputs) 
        loss = criterion(outputs, labels) 
        loss.backward() 
        optimizer.step() 
        running_loss += loss.item() 
        if i % 2000 == 1999: 
            print("[{}, {}] loss: {:.3f}".format(epoch+1, i+1, 
                                                  running_loss/2000)) 
            running_loss = 0.0 

print("Finished Training") 

请注意，此代码仅供参考，您可能需要针对自己的具体需求进行修改。