Cifar100数据集基于Renet18分类

Cifar100数据集分类

训练环境：

 python3.8

 CPU Intel(R) Core(TM) i7-9750H CPU

1.cifar100数据集介绍

　　这个数据集与CIFAR-10类似，它有100个类，每个类包含600个图像。每类各有500个训练图像和100个测试图像。CIFAR-100中的100个类被分成20个超类。每个图像都带有一个“精细”标签（它所属的类）和一个“粗糙”标签（它所属的超类）
以下是CIFAR-100中的类别列表：

文件介绍：

                (下载文件如图)

 

　　meta：类名的序列保存位置

　　train:训练集

　　test：测试集

 

　　

超类（粗分）	类别（细分）
水生哺乳动物	海狸，海豚，水獭，海豹，鲸鱼
鱼	水族馆的鱼，比目鱼，射线，鲨鱼，鳟鱼
花卉	兰花，罂粟花，玫瑰，向日葵，郁金香
食品容器	瓶子，碗，罐子，杯子，盘子
水果和蔬菜	苹果，蘑菇，橘子，梨，甜椒
家用电器	时钟，电脑键盘，台灯，电话机，电视机
家用家具	床，椅子，沙发，桌子，衣柜
昆虫	蜜蜂，甲虫，蝴蝶，毛虫，蟑螂
大型食肉动物	熊，豹，狮子，老虎，狼
大型人造户外用品	桥，城堡，房子，路，摩天大楼
大自然的户外场景	云，森林，山，平原，海
大杂食动物和食草动物	骆驼，牛，黑猩猩，大象，袋鼠
中型哺乳动物	狐狸，豪猪，负鼠，浣熊，臭鼬
非昆虫无脊椎动物	螃蟹，龙虾，蜗牛，蜘蛛，蠕虫
人	宝贝，男孩，女孩，男人，女人
爬行动物	鳄鱼，恐龙，蜥蜴，蛇，乌龟
小型哺乳动物	仓鼠，老鼠，兔子，母老虎，松鼠
树木	枫树，橡树，棕榈，松树，柳树
车辆1	自行车，公共汽车，摩托车，皮卡车，火车
车辆2	割草机，火箭，有轨电车，坦克，拖拉机

2.renet18/残差神经网络(基于pytorch)

ResNet（Residual Neural Network）来源于微软研究院的Kaiming He等人的论文《Deep Residual Learning for Image Recognition》。ResNet-18的网络简图如下图（假设网络的输入的张量的形状为3 × 64 × 64 3\times 64\times 643×64×64）

 resnet18:
　　

 代码简介

1.用到的库

import collections

import math

import os

import shutil

import pandas as pd

import torch

import torchvision

from torch import nn

from d2l import torch as d2l

from torchvision import transforms

2.导入数据

trans = transforms.ToTensor()
train = torchvision.datasets.CIFAR100(
root="../data1", train=True, transform=trans, download=True)
test = torchvision.datasets.CIFAR100(
root="../data1", train=False, transform=trans, download=True)

 

 

 

 3.标签匹配

 

 4.renet18（利用pytorch）

 

 

 5.训练优化-SGD(随机梯度下降)

 

 6.训练代码

def train(net, train_iter, valid_iter, num_epochs, lr, wd, devices, lr_period,

          lr_decay):

    trainer = torch.optim.SGD(net.parameters(), lr=lr, momentum=0.9,

                              weight_decay=wd)

    scheduler = torch.optim.lr_scheduler.StepLR(trainer, lr_period, lr_decay)

    num_batches, timer = len(train_iter), d2l.Timer()

    legend = ['train loss', 'train acc']

    if valid_iter is not None:

        legend.append('valid acc')

    animator = d2l.Animator(xlabel='epoch', xlim=[1, num_epochs],

                            legend=legend)

    net = nn.DataParallel(net, device_ids=devices).to(devices[0])

    for epoch in range(num_epochs):

        net.train()

        metric = d2l.Accumulator(3)

        for i, (features, labels) in enumerate(train_iter):

            timer.start()

            l, acc = d2l.train_batch_ch13(net, features, labels,

                                          loss, trainer, devices)

            metric.add(l, acc, labels.shape[0])

            timer.stop()

            if (i + 1) % (num_batches // 5) == 0 or i == num_batches - 1:

                animator.add(epoch + (i + 1) / num_batches,

                             (metric[0] / metric[2], metric[1] / metric[2],

                              None))

        if valid_iter is not None:

            valid_acc = d2l.evaluate_accuracy_gpu(net, valid_iter)

            animator.add(epoch + 1, (None, None, valid_acc))

        scheduler.step()

    measures = (f'train loss {metric[0] / metric[2]:.3f}, '

                f'train acc {metric[1] / metric[2]:.3f}')

    if valid_iter is not None:

        measures += f', valid acc {valid_acc:.3f}'

    print(measures + f'\n{metric[2] * num_epochs / timer.sum():.1f}'

          f' examples/sec on {str(devices)}')

 

valid 和train 均来自原始训练集，在对train训练后，现在valid进行测试，之后再到test上进行测试

结果

1.num_epochs, lr, wd = 2,2e-4, 5e-4，

    

 

 

参数：num_epochs, lr, wd = 3,2e-4, 5e-4，

　　

 

 参数：num_epochs, lr, wd =5,2e-4, 5e-4，

 参数：num_epochs, lr, wd =6,2e-4, 5e-4，