Kaggle-猫狗图像分类全流程实践（支持迁移学习和其他分类任务迁移）

最新推荐文章于 2024-06-06 15:05:29 发布
最新推荐文章于 2024-06-06 15:05:29 发布
阅读量901 收藏 7
点赞数 3
分类专栏： 竞赛之神 文章标签： 迁移学习 深度学习 图像分类
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014297502/article/details/127680246
版权

1、insatll environment|安装环境

!pip install torchtoolbox
!pip install torchsummary

2、import package|导入三方库

# 基础库
import os
import time
import random
import shutil
import pandas as pd
import csv
from math import exp
from PIL import Image
import numpy as np
import math
import cv2
from tqdm import tqdm
import matplotlib.pyplot as plt
import matplotlib.image as mpimg
from mpl_toolkits.axes_grid1 import ImageGrid
%matplotlib inline
# torch
import torch
import torch.nn as nn
import torch.optim as optim
from torch.optim import lr_scheduler
from torch.autograd import Variable
import torchvision
from torchvision import datasets, models, transforms
import torch.nn.functional as F
from torchsummary import summary
# 混合精度
from torch.optim.lr_scheduler import CosineAnnealingLR
scaler = torch.cuda.amp.GradScaler()
# Kaggle文件下载
from IPython.display import FileLink
# 其他数据增强
from torchtoolbox.tools import mixup_data, mixup_criterion
from torchtoolbox.transform import Cutout

3、set random seed|固定随机种子

The random seed is the initial value used in the pseudo-random number generator to generate pseudo-random numbers. For a pseudo-random number generator, starting from the same random number seed, the same random number sequence can be obtained. Set a random seed so that the same training effect can be produced later.

随机数种子（random seed)是在伪随机数生成器中用于生成伪随机数的初始数值。对于一个伪随机数生成器，从相同的随机数种子出发，可以得到相同的随机数序列。设置随机种子，便于后期产生相同的训练效果。

def seed_torch(seed=3407):
    random.seed(seed)
    os.environ['PYTHONHASHSEED'] = str(seed)
    np.random.seed(seed)
    torch.manual_seed(seed)
    torch.cuda.manual_seed(seed)
    torch.cuda.manual_seed_all(seed) # if you are using multi-GPU.
    torch.backends.cudnn.benchmark = False
    torch.backends.cudnn.deterministic = True
seed_torch()

4、split datastes|划分数据集

The dataset is divided into training set, validation set and test set. The training set is used for model training, the validation set is used to verify the training effect of the model, used for parameter adjustment, etc., and the test set is used to test the prediction ability of the final model.This part divides the training and validation ratio as 8:2.

数据集分为训练集、验证集和测试集。训练集用于模型训练，验证集用于验证模型的训练效果，用于参数调整等，测试集用于测试最终模型的预测能力。本部分划分训练、验证比例为8:2。

# 指定数据集路径
ori_dataset_path = '../input/comp6101-assignment2-group2/train'
dataset_path = './'
# 验证集比例
test_frac = 0.2
classes = os.listdir(ori_dataset_path)
# 创建 train 文件夹
if not os.path.exists(os.path.join(dataset_path, 'train')):
    os.makedirs(os.path.join(dataset_path, 'train'))
# 创建 val 文件夹
if not os.path.exists(os.path.join(dataset_path, 'val')):
    os.makedirs(os.path.join(dataset_path, 'val'))
# 在 train 和 val 文件夹中创建各类别子文件夹
for label in classes:
    if not os.path.exists(os.path.join(dataset_path, 'train', label)):
        os.makedirs(os.path.join(dataset_path, 'train', label))
    if not os.path.exists(os.path.join(dataset_path, 'val', label)):
        os.makedirs(os.path.join(dataset_path, 'val', label))
df = pd.DataFrame()
print('{:^18} {:^18} {:^18}'.format('类别', '训练集数据个数', '测试集数据个数'))
for sigle_label in classes: # 遍历每个类别
    # 读取该类别的所有图像文件名
    old_dir = os.path.join(ori_dataset_path, sigle_label)
    images_filename = os.listdir(old_dir)
    random.shuffle(images_filename) # 随机打乱
    # 划分训练集和验证集
    testset_numer = int(len(images_filename) * test_frac) # 验证集图像个数
    testset_images = images_filename[:testset_numer]      # 获取拟移动至 val 目录的测试集图像文件名
    trainset_images = images_filename[testset_numer:]     # 获取拟移动至 train 目录的训练集图像文件名
    # 移动图像至 val 目录
    for image in testset_images:
        old_img_path = os.path.join(ori_dataset_path, sigle_label, image)         # 获取原始文件路径
        new_test_path = os.path.join(dataset_path, 'val', sigle_label, image) # 获取 val 目录的新文件路径
        shutil.copy(old_img_path, new_test_path) # 移动文件
    # 移动图像至 train 目录
    for image in trainset_images:
        old_img_path = os.path.join(ori_dataset_path, sigle_label, image)           # 获取原始文件路径
        new_train_path = os.path.join(dataset_path, 'train', sigle_label, image) # 获取 train 目录的新文件路径
        shutil.copy(old_img_path, new_train_path) # 移动文件
    # 工整地输出每一类别的数据个数
    print('{:^18} {:^18} {:^18}'.format(sigle_label, len(trainset_images), len(testset_images)))

5、visual some datasets|可视化部分数据

folder_path = './train/cat/'
# 可视化图像的个数
N = 36
# n 行 n 列
n = math.floor(np.sqrt(N))
# 获取数据
images = []
for each_img in os.listdir(folder_path)[:N]:
    img_path = os.path.join(folder_path, each_img)
    img_bgr = cv2.imread(img_path)
    img_rgb = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2RGB)
    images.append(img_rgb)
# 可视化
fig = plt.figure(figsize=(10, 10))
grid = ImageGrid(fig, 111,  # 类似绘制子图 subplot(111)
                 nrows_ncols=(n, n),  # 创建 n 行 m 列的 axes 网格
                 axes_pad=0.02,  # 网格间距
                 share_all=True
                 )
# 遍历每张图像
for ax, im in zip(grid, images):
    ax.imshow(im)
    ax.axis('off')
plt.tight_layout()
plt.show()

6、data preprocessing|数据预处理

It mainly includes data enhancement and DataLoader loading.

主要包括数据增强和DataLoader装载。

# 基于imagenet上的std和mean
std_nums = [0.229, 0.224, 0.225]
mean_nums = [0.485, 0.456, 0.406]
# 训练集上进行的数据增强
train_dataTrans = transforms.Compose([
            transforms.Resize(256),
            transforms.CenterCrop(224),
            #Cutout(),
            #transforms.RandomHorizontalFlip(),  # 水平翻转
            #transforms.RandomVerticalFlip(),  # 垂直翻转
            #transforms.RandomRotation(5),
            #transforms.GaussianBlur(kernel_size=(5, 5), sigma=(0.1, 1)),
            #transforms.ColorJitter(brightness=0.5, contrast=0.5, hue=0.5),
            #transforms.RandomHorizontalFlip(0.5),
            transforms.ToTensor(),
            transforms.Normalize(mean_nums, std_nums)
])
# 验证集上进行的数据增强
val_dataTrans = transforms.Compose([
            transforms.Resize(256),
            transforms.CenterCrop(224),
            transforms.ToTensor(),
            transforms.Normalize(mean_nums, std_nums)
])

# 数据装载
train_data_dir = './train'
val_data_dir = './val'
train_dataset = datasets.ImageFolder(train_data_dir, train_dataTrans)
val_dataset = datasets.ImageFolder(val_data_dir, val_dataTrans)

image_datasets = {'train':train_dataset,'val':val_dataset}
shuff = {'train':True,'val':False}

dataloders = {x: torch.utils.data.DataLoader(image_datasets[x],
                                             batch_size=32,
                                             num_workers=2,
                                             shuffle=shuff[x]) for x in ['train', 'val']}

train_loader = torch.utils.data.DataLoader(train_dataset,
                                             batch_size=32,
                                             num_workers=2,
                                             shuffle=True)

val_loader = torch.utils.data.DataLoader(val_dataset,
                                             batch_size=32,
                                             num_workers=2,
                                             shuffle=True)

dataset_sizes = {x: len(image_datasets[x]) for x in ['train', 'val']}

print(dataset_sizes)

7、trian model|训练模型

7.1、自设计模型

class CNN(nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        self.relu = nn.ReLU()
        self.sigmoid = nn.Sigmoid()
        self.conv1 = nn.Sequential(
            nn.Conv2d(
                in_channels=3,
                out_channels=16,
                kernel_size=3,
                stride=2,),
            nn.BatchNorm2d(16),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2),)
        self.conv2 = nn.Sequential(
            nn.Conv2d(
                in_channels=16,
                out_channels=32,
                kernel_size=3,
                stride=2,),
            nn.BatchNorm2d(32),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2),)
        self.conv3 = nn.Sequential(
            nn.Conv2d(
                in_channels=32,
                out_channels=64,
                kernel_size=3,
                stride=2,
            ),
            nn.BatchNorm2d(64),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2),)
        self.fc1 = nn.Linear(3 * 3 * 64, 64)
        self.fc2 = nn.Linear(64, 10)
        self.out = nn.Linear(10, 2)

    def forward(self, x):
        x = self.conv1(x)
        x = self.conv2(x)
        x = self.conv3(x)
        # print(x.size())
        x = x.view(x.shape[0], -1)
        x = self.relu(self.fc1(x))
        x = self.relu(self.fc2(x))
        x = self.out(x)
        x = F.log_softmax(x, dim=1)
        return x

# 打印网络
CNN().to('cuda')

7.2、迁移学习

# 迁移学习
DEVICE = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model_ft = models.resnet50(pretrained=True)
num_ftrs = model_ft.fc.in_features
model_ft.fc = nn.Linear(num_ftrs, 2)
model_ft.to(DEVICE)

Downloading: "https://download.pytorch.org/models/resnet50-0676ba61.pth" to /root/.cache/torch/hub/checkpoints/resnet50-0676ba61.pth



  0%|          | 0.00/97.8M [00:00<?, ?B/s]





ResNet(
  (conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)
  (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  (relu): ReLU(inplace=True)
  (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)
  (layer1): Sequential(
    (0): Bottleneck(
      (conv1): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (downsample): Sequential(
        (0): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (1): Bottleneck(
      (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
    )
    (2): Bottleneck(
      (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
    )
  )
  (layer2): Sequential(
    (0): Bottleneck(
      (conv1): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (downsample): Sequential(
        (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)
        (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (1): Bottleneck(
      (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
    )
    (2): Bottleneck(
      (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
    )
    (3): Bottleneck(
      (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
    )
  )
  (layer3): Sequential(
    (0): Bottleneck(
      (conv1): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (downsample): Sequential(
        (0): Conv2d(512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False)
        (1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (1): Bottleneck(
      (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
    )
    (2): Bottleneck(
      (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
    )
    (3): Bottleneck(
      (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
    )
    (4): Bottleneck(
      (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
    )
    (5): Bottleneck(
      (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
    )
  )
  (layer4): Sequential(
    (0): Bottleneck(
      (conv1): Conv2d(1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (downsample): Sequential(
        (0): Conv2d(1024, 2048, kernel_size=(1, 1), stride=(2, 2), bias=False)
        (1): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (1): Bottleneck(
      (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
    )
    (2): Bottleneck(
      (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
    )
  )
  (avgpool): AdaptiveAvgPool2d(output_size=(1, 1))
  (fc): Linear(in_features=2048, out_features=2, bias=True)
)

# 设置全局参数
modellr = 1e-4
BATCH_SIZE = 32
EPOCHS = 6
DEVICE = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
alpha=0.2

# 实例化模型并且移动到GPU
criterion = nn.CrossEntropyLoss()
# 自定义模型
#model_ft = CNN()
#model_ft.to(DEVICE)
optimizer = optim.Adam(model_ft.parameters(), lr=modellr)
cosine_schedule = optim.lr_scheduler.CosineAnnealingLR(optimizer=optimizer,T_max=2,eta_min=1e-9)

train_loss_list = []
val_loss_list = []
val_acc_list = []

# 定义训练过程
def train(model, device, train_loader, optimizer, epoch):
    print('=====train====')
    model.train()
    sum_loss = 0
    total_num = len(train_loader.dataset)
    for batch_idx, (data, target) in enumerate(train_loader):
        data, target = data.to(device, non_blocking=True), target.to(device, non_blocking=True)
        data, labels_a, labels_b, lam = mixup_data(data, target, alpha)
        optimizer.zero_grad()
        output = model(data)
        loss = mixup_criterion(criterion, output, labels_a, labels_b, lam)
        # 普通训练
        loss.backward()
        optimizer.step()
        # 混合精度训练
        #scaler.scale(loss).backward()
        #scaler.step(optimizer)
        #scaler.update()
        lr = optimizer.state_dict()['param_groups'][0]['lr']
        print_loss = loss.data.item()
        sum_loss += print_loss
        if (batch_idx + 1) % 100 == 0:
            print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}\tLR:{:.9f}'.format(
                epoch, (batch_idx + 1) * len(data), len(train_loader.dataset),
                       100. * (batch_idx + 1) / len(train_loader), loss.item(),lr))
    ave_loss = sum_loss / len(train_loader)
    print('epoch:{},loss:{}'.format(epoch, ave_loss))
    train_loss_list.append(ave_loss)

ACC=0
# 验证过程
def val(model, device, test_loader):
    global ACC
    print('=====valid====')
    model.eval()
    test_loss = 0
    correct = 0
    total_num = len(test_loader.dataset)
    with torch.no_grad():
        for data, target in test_loader:
            data, target = Variable(data).to(device), Variable(target).to(device)
            output = model(data)
            loss = criterion(output, target)
            _, pred = torch.max(output.data, 1)
            correct += torch.sum(pred == target)
            print_loss = loss.data.item()
            test_loss += print_loss
        correct = correct.data.item()
        acc = correct / total_num
        avgloss = test_loss / len(test_loader)
        val_loss_list.append(avgloss)
        print('\nVal set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(
            avgloss, correct, len(test_loader.dataset), 100 * acc))
        val_acc_list.append(acc)
        if acc > ACC:
            torch.save(model_ft.state_dict(), '66model_' + str(epoch) + '_' + str(round(acc, 3)) + '.pth')
            ACC = acc
            print('当前最好模型精度:{}%'.format(ACC*100))

# 迭代训练
for epoch in range(1, EPOCHS + 1):
    train(model_ft, DEVICE, train_loader, optimizer, epoch)
    cosine_schedule.step()
    val(model_ft, DEVICE, val_loader)

plt.plot(val_loss_list, label='loss')
plt.plot(val_acc_list, label='accuracy')
plt.legend()
plt.title('Valid loss and accuracy')
plt.show()

8、visual inference|可视化推理

infer_transformation = transforms.Compose([
    transforms.Resize(256),
    transforms.CenterCrop(224),
    transforms.ToTensor(),
    transforms.Normalize(mean_nums, std_nums)
])

IMAGES_KEY = 'images'
MODEL_INPUT_KEY = 'images'
LABEL_OUTPUT_KEY = 'predicted_label'
MODEL_OUTPUT_KEY = 'scores'

def decode_image(file_content):
    image = Image.open(file_content)
    image = image.convert('RGB')
    return image

def cnn(model_path):
    model = CNN()
    model.load_state_dict(torch.load(model_path,map_location ='cuda:0'))
    return model

def trans_learning(model_path):
    model = models.resnet50(pretrained=False)
    num_ftrs = model.fc.in_features
    model.fc = nn.Linear(num_ftrs, 2)
    model.load_state_dict(torch.load(model_path,map_location ='cuda:0'))
    model.eval()

    return model


def predict(file_name):
    LABEL_LIST = ['cat', 'dog']
    # 迁移学习模型
    model = trans_learning('../input/weightsresnet/model_2_0.992.pth')
    # 自定义模型
    #model = cnn('./55model_9_0.837.pth')
    
    image1 = decode_image(file_name)
    
    input_img = infer_transformation(image1)
    input_img = torch.autograd.Variable(torch.unsqueeze(input_img, dim=0).float(), requires_grad=False)

    logits_list =  model(input_img)[0].detach().numpy().tolist()
    maxlist=max(logits_list)

    z_exp = [exp(i-maxlist) for i in  logits_list]

    sum_z_exp = sum(z_exp)
    softmax = [round(i / sum_z_exp, 3) for i in z_exp]
    labels_to_logits = {
        LABEL_LIST[i]: s for i, s in enumerate(softmax)
    }
    
    predict_result = {
        LABEL_OUTPUT_KEY: max(labels_to_logits, key=labels_to_logits.get),
        MODEL_OUTPUT_KEY: labels_to_logits
    }

    return predict_result

file_name = '../input/comp6101-assignment2-group2/test/test/7.jpg'
result = predict(file_name)
import matplotlib.pyplot as plt

plt.figure(figsize=(10,10))
img = decode_image(file_name)
plt.imshow(img)
plt.show()

print('结果:',result)

​
在这里插入图片描述

​

结果: {'predicted_label': 'cat', 'scores': {'cat': 0.987, 'dog': 0.013}}

9、inference and submission|推理和提交

import csv
from tqdm import tqdm

for i  in range(2):
    headers = ['id','category']
    f = open('results.csv','w', newline='')
    writer = csv.writer(f)
    writer.writerow(headers)

    for i in tqdm(range(5000)):
        file_name='../input/comp6101-assignment2-group2/test/test/'+str(i)+'.jpg'
        result = predict(file_name)
        if result['predicted_label']=='cat':
            value=0
        if result['predicted_label']=='dog':
            value=1
        writer.writerow([str(i),int(value)])

100%|██████████| 5000/5000 [52:24<00:00,  1.59it/s] 
100%|██████████| 5000/5000 [51:26<00:00,  1.62it/s] 

FileLink('results.csv')

results.csv

FileLink('./66model_2_0.992.pth')
模型预训练lr优化器损失函数学习率训轮次验证集ACC线上提交ACC权重下载CSV结果ACC-Loss图
自设计CNN-CosineAnnealingLRCrossEntropyLoss1e-3100.836750.7336【点击查看】【点击查看】【点击查看】
Resnet50是CosineAnnealingLRCrossEntropyLoss1e-460.9920.98880【点击查看】【点击查看】【点击查看】

10、Summarize|总结

本次作业，该.ipynb实现了以下内容：

  1. 构建了一个简单的CNN模型，在训练ACC上上达到0.83准确率，线上提交分数在0.73；
  2. 引入：Resize、CenterCrop、Cutout、RandomHorizontalFlip、RandomVerticalFlip等众多增强方案；
  3. 引入mixup_data、mixup_criterion等方法，提升训练精度；
  4. 内嵌torch.cuda.amp.GradScaler混合精度训练，不影响精度下加速模型训练过程；
  5. 引入迁移学习，多种torchvision.models模型任意调用，并在Resnet50迁移学习上达到0.988的成绩；
  6. 任意模型结构可视化，任意模型权重保存与加载；
  7. 训练和验证ACC与loss图输出对比，模型效果简单直观；
  8. 完整流程：数据划分->部分数据可视化->数据预处理->模型构建->模型训练->可视化推理->批量推理；
落难Coder
关注
  • 3
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 5
    评论
专栏目录
kaggle猫狗大战分类数据集
11-10
这是kaggle竞赛的猫狗大战公开数据集，包含train和test及一个csv说明文件，因为kaggle注册比较麻烦，并且下载速度很慢，需要的可以从这里下载。代码获取可以关注《Python与人工智能》回复 猫狗分类 获取
【迁移网络学习实战】- Kaggle猫狗分类大赛 – 单模型测试 – 前7.8%
01-20
【迁移网络学习】- Kaggle猫狗分类大赛 – 前7.8% 数据集下载： 链接：https://pan.baidu.com/s/1AIj0FhdCQPeAWg4Sw7DEOQ 提取码：aejj 一、内容 想要将深度学习应用于小型图像数据集，一种常用且非常高效的方法是...
kaggle猫狗分类
qq_45022743的博客
04-23 3965
本文介绍使用CNN卷积神经网络完成猫狗图像识别，数据集来源于kaggle：[猫狗分类数据集]。主要包括以下三部分： 数据创建与预处理 神经网络模型搭建 数据增强实现减小正则化 数据处理 数据集包含25000张图片，猫和狗各有12500张；创建每个类别1000个样本的训练集、500个样本的验证集和500个样本的测试集（只使用部分数据进行建模） import os import shutil current_dir = %pwd current_dir #当前目录 base_dir = current_
kaggle猫狗图像识别97%准确率
最新发布
m0_73542617的博客
06-06 568
这个只需注册一个kaggle账号，但这个比赛已经结束了，无法提交成绩。
卷积神经网络之狗猫数据集的分类实验
qq_43678923的博客
05-27 4630
文章目录一、环境配置二、猫狗数据集（一）制作数据集（二）卷积神经网络CNN1. 网络模型搭建2. 图像生成器读取文件中数据3. 开始训练4. 保存模型5. 结果可视化（三）根据基准模型进行调整1. 图像增强方法2. 模型调整 一、环境配置 配置tensorflow、keras 打开anaconda3命令行，用管理员身份运行 新建conda环境 conda create -n tensorflow python=3.7 激活环境 activate tendorflow 安装tensorflo
【深度学习】经典案例：猫狗大战（kaggle实战完整流程：数据集分割、预处理、模型搭建、模型参数保存、acc/loss可视化）
weixin_44820505的博客
05-31 7735
基于`tensorFlow`框架搭建神经网络，从零开始一步步完成数据读取、网络构建、模型训练和模型测试等过程，最终实现一个可以进行猫狗图像分类的分类器；并借助数据增强技术，例如旋转、翻转、缩放等，来增加数据集的多样性，从而提高模型的泛化能力和鲁棒性。
Kaggle猫狗分类Pytorch CNN
农夫果园好好喝的博客
05-20 1937
猫狗分类来源于Kaggle上的一个入门竞赛。
基于kaggle数据集的猫狗识别(超详细版本)
热门推荐
ximu__l的博客
07-20 1万+
基于kaggle数据集的猫狗识别(超详细版本)，包含利用数据增强生成器显示图像、利用数据增强生成器训练卷积神经网络，直接可实现编译的完整代码
Kaggle猫狗大战dogs-vs-cats数据集全套以及图像分类代码
03-23
有猫狗大战数据集，其中有训练集20000张，验证集5000张，测试集...并且配套有迁移学习的代码可以对猫狗数据集进行运行图像分类 运行方法很简答，可以利用命令行运行，不需要构建模型，自动利用pytorch内置模型简单方便
利用VGG16对kaggle比赛提供的猫狗图片进行迁移学习-PyTorch版本
03-30
利用VGG16对kaggle比赛提供的猫狗图片进行迁移学习-PyTorch版本 1.已改写为gpu-cpu通用 2.数据集处理参考注释；含后续训练、训练集/验证集accuracy计算，图片测试 3.数据集请参考...
基于基础的CNN和迁移学习分别实现的kaggle猫狗图片分类（源码+项目说明）.zip
02-28
基于基础的CNN和迁移学习分别实现的kaggle猫狗图片分类（源码+项目说明）.zip 包含全部项目源码、该项目可以直接使用、项目都经过严格调试，下载即用确保可以运行！ 基于基础的CNN和迁移学习分别实现的kaggle猫狗...
基于传统机器学习方法SVM对kaggle猫狗图片分类
11-09
<项目介绍> 该资源内项目源码是个人的毕设，代码都测试ok，都是运行成功后才上传资源，答辩评审平均分达到96分，放心下载使用！ 1、该资源内项目代码都经过测试运行成功，功能ok的情况下才上传的，请放心下载使用！ 2、本项目适合计算机相关专业(如计科、人工智能、通信工程、自动化、电子信息等)的在校学生、老师或者企业员工下载学习，也适合小白学习进阶，当然也可作为毕设项目、课程设计、作业、项目初期立项演示等。 3、如果基础还行，也可在此代码基础上进行修改，以实现其他功能，也可用于毕设、课设、作业等。 下载后请首先打开README.md文件（如有），仅供学习参考, 切勿用于商业用途。 -------- ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
深度学习解决(Kaggle)猫/狗分类问题
06-03
深度学习解决(Kaggle)猫/狗分类问题 by Roelof Pieters。
VGG分类实战：猫狗分类
m0_62919535的博客
08-16 1874
VGG分类实战：猫狗分类。数据集选择的是Kaggle上的Cat and Dog，猫狗图片数量上达到了上万张。你可以通过这里进入Kaggle下载数据集。在我的Github仓库当中也放了猫狗图片各666张。VGG的主要特点是使用了一系列具有相同尺寸 3x3 大小的卷积核进行多次卷积操作。这种结构的一个优势是可以堆叠更多的卷积层，使得网络能够学习到更复杂的特征。让我们来探究一下在2014年的ImageNet图像分类竞赛中取得显著成绩的VGG模型效果如何。
使用卷积神经网络实现猫狗分类任务
大彤小忆的博客
05-23 4237
一、数据集下载链接   使用卷积神经网络在猫狗分类数据集上实现分类任务。 一、数据集下载链接   猫狗分类数据集
人工智能实验——猫狗分类MindSpore
weixin_51735061的博客
07-12 5053
人工智能实验——猫狗分类MindSpore
卷积神经网络|猫狗分类系列--导入kaggle猫狗数据集
m0_57569438的博客
01-08 1167
解决任何真实问题的重要一步是获取数据，Kaggle提供了大量不同数据科学问题的竞赛。
（深度学习）手把手搭建深度学习二分类任务（猫狗识别任务）CNN神经网络，代码直接复制可用，全过程以遇到的问题解答（肯定看得懂系列）
GaoFeng535的博客
06-01 8744
从零开始——手把手搭建 深度学习二分类任务（猫狗识别任务）CNN神经网络1.环境部分用到的工具环境和包的下载以搭建2.开始实现1.将数据集加载进来2.搭建CNN神经网络模型3.CNN神经网络模型其他参数设置4.训练模型3.计算准确率4.使用网上随便找的图片来测试模型5.遇到的问题解决 本篇从新手开始，手把手搭建CNN深度学习网络，用于猫狗识别或其他二分类任务，请仔细阅读 1.环境部分 用到的工具 系统：win10 环境部分：anaconda 语言：python3.6 框架：keras 数据：数据集下载
实战 Kaggle 比赛：图像分类 （CIFAR-10）深度学习模型框图
07-13
对于Kaggle比赛中的图像分类任务，你可以使用深度学习模型来解决。下面是一个常见的深度学习模型框图，用于处理CIFAR-10数据集的图像分类任务： ``` 输入图像 (32x32x3) | 卷积层 (滤波器数目，过滤器大小，步幅，填充方式) | 批量归一化 | ReLU激活函数 | 池化层 (池化大小，步幅) | ... | 全连接层 | ... | 输出层 (类别数) | Softmax激活函数 | 输出预测结果 ``` 具体地，你可以使用多个卷积层和池化层的组合来提取图像的特征。然后，通过全连接层将提取的特征映射到预测类别的空间。最后，使用Softmax激活函数将输出转化为每个类别的概率分布。 请注意，上述框图仅为示意，具体的模型架构可以根据需要进行调整和优化。你可以尝试不同的卷积层、池化层、全连接层的配置，并进行超参数调优，以获得更好的性能。在实践中，你还可以考虑使用一些常见的深度学习模型，如ResNet、VGG、Inception等，它们在图像分类任务上具有较好的表现。 希望这个模型框图能给你提供一些启发，祝你在Kaggle比赛中取得好成绩！
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

落难Coder

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值