猫的 12 类分类：使用 ResNet 神经网络进行训练和预测

使用 Python 代码完成神经网络（ResNet）猫的十二分类，最终结果形式为形成一个 CSV 文件和可视化

本教程将演示如何使用 Python 和 ResNet 模型实现猫的 12 类分类，并生成预测结果 CSV 文件和训练过程的可视化。

1. 数据集

/kaggle/input/cat111/cat_12_train/cat_12_train：训练图像目录
/kaggle/input/cat111/cat_12_test/cat_12_test：测试图像目录
/kaggle/input/cat111/train_list.txt：训练图像文件列表，每行包含文件名和标签

2. 训练集和验证集

训练集将占 80%，验证集将占 20%。

3. 模型定义（ResNet）和训练

我们将使用预训练的 ResNet18 模型，并添加一个新的全连接层用于分类。

4. 结果可视化和预测可视化

最终将生成一个包含预测结果的 CSV 文件，并提供训练过程中损失和准确率的可视化图表。

由于数据集来源不清楚，我们无法提供完整的代码，但以下是一个基本的框架，可以帮助您开始构建自己的神经网络模型。

首先，需要导入必要的库：

import torch
import torch.nn as nn
import torch.optim as optim
import os
import numpy as np
from torchvision import transforms, datasets
import pandas as pd
import matplotlib.pyplot as plt

接下来，定义一些超参数，例如批次大小、学习率、迭代次数等：

batch_size = 32
learning_rate = 0.001
n_epochs = 10

然后，加载数据集并将其分成训练集和验证集：

data_transforms = {
    'train': transforms.Compose([
        transforms.Resize(256),
        transforms.CenterCrop(224),
        transforms.RandomHorizontalFlip(),
        transforms.ToTensor(),
        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
    ]),
    'val': transforms.Compose([
        transforms.Resize(256),
        transforms.CenterCrop(224),
        transforms.ToTensor(),
        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
    ]),
}

train_list = pd.read_csv('/kaggle/input/cat111/train_list.txt', header=None, sep=' ')
train_list.columns = ['filename', 'label']
train_data = datasets.ImageFolder('/kaggle/input/cat111/cat_12_train/cat_12_train', transform=data_transforms['train'])
train_loader = torch.utils.data.DataLoader(train_data, batch_size=batch_size, shuffle=True)

val_data = datasets.ImageFolder('/kaggle/input/cat111/cat_12_test/cat_12_test', transform=data_transforms['val'])
val_loader = torch.utils.data.DataLoader(val_data, batch_size=batch_size, shuffle=True)

接下来，定义 ResNet 模型：

class ResNet(nn.Module):
    def __init__(self, num_classes=12):
        super(ResNet, self).__init__()
        self.resnet = torchvision.models.resnet18(pretrained=True)
        self.fc = nn.Linear(512, num_classes)

    def forward(self, x):
        x = self.resnet(x)
        x = self.fc(x)
        return x

model = ResNet()

然后，定义损失函数和优化器：

criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=learning_rate)

现在可以进行训练了：

train_losses = []
val_losses = []
train_accs = []
val_accs = []

for epoch in range(n_epochs):
    train_loss = 0.0
    val_loss = 0.0
    train_acc = 0.0
    val_acc = 0.0
    
    # training
    model.train()
    for i, (inputs, targets) in enumerate(train_loader):
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, targets)
        loss.backward()
        optimizer.step()
        
        train_loss += loss.item() * inputs.size(0)
        _, preds = torch.max(outputs, 1)
        train_acc += torch.sum(preds == targets.data)
        
    train_loss /= len(train_loader.dataset)
    train_losses.append(train_loss)
    train_acc /= len(train_loader.dataset)
    train_accs.append(train_acc)
    
    # validation
    model.eval()
    with torch.no_grad():
        for inputs, targets in val_loader:
            outputs = model(inputs)
            loss = criterion(outputs, targets)
            
            val_loss += loss.item() * inputs.size(0)
            _, preds = torch.max(outputs, 1)
            val_acc += torch.sum(preds == targets.data)
            
        val_loss /= len(val_loader.dataset)
        val_losses.append(val_loss)
        val_acc /= len(val_loader.dataset)
        val_accs.append(val_acc)
        
    print('Epoch %d/%d, Train Loss: %.3f, Val Loss: %.3f, Train Acc: %.3f, Val Acc: %.3f'
         % (epoch+1, n_epochs, train_loss, val_loss, train_acc, val_acc))

最后，将预测结果保存为 CSV 文件并进行可视化。以下是一个示例：

# make predictions
model.eval()
test_data = datasets.ImageFolder('/kaggle/input/cat111/cat_12_test/cat_12_test', transform=data_transforms['val'])
test_loader = torch.utils.data.DataLoader(test_data, batch_size=batch_size, shuffle=False)

test_preds = []
with torch.no_grad():
    for inputs, _ in test_loader:
        outputs = model(inputs)
        _, preds = torch.max(outputs, 1)
        test_preds.extend(preds.tolist())

# save predictions as CSV
test_filenames = [os.path.basename(f) for f in test_data.imgs]
df = pd.DataFrame({'Filename': test_filenames, 'Prediction': test_preds})
df.to_csv('predictions.csv', index=False)

# plot losses and accuracies
fig, ax = plt.subplots(figsize=(8,6))
ax.plot(train_losses, label='Training Loss')
ax.plot(val_losses, label='Validation Loss')
ax.plot(train_accs, label='Training Accuracy')
ax.plot(val_accs, label='Validation Accuracy')
ax.legend()
plt.show()