图像分类算法的实现与性能优化

📝分享的所有项目源码均包含（前端+后台+数据库），可做毕业设计或课程设计，欢迎留言分享问题，交流经验，白嫖勿扰🍅更多优质项目👇🏻👇🏻可评论留言获取！！

图像分类算法的实现与性能优化

摘要

图像分类是计算机视觉领域的基础任务之一，其目的是将输入图像分配到预定义的类别中。随着深度学习技术的快速发展，基于深度学习的图像分类算法取得了显著的成果，在各种基准数据集上的准确率不断刷新记录。本文主要研究图像分类算法的实现与性能优化，设计并实现了一种基于ResNet的改进图像分类模型。

本文首先介绍了图像分类的研究背景、意义和现状，阐述了传统图像分类方法和基于深度学习的图像分类方法的基本原理。然后，详细设计了基于ResNet的改进图像分类模型，该模型采用残差学习、注意力机制和知识蒸馏等技术，能够有效提高图像分类的准确率和效率。接着，实现了该模型的训练和测试流程，并在常用的图像分类数据集上进行了实验。最后，对实验结果进行了分析和比较，验证了所提模型的有效性。

实验结果表明，本文设计的改进ResNet图像分类模型在CIFAR-10、CIFAR-100和ImageNet等数据集上均取得了优异的性能，比原始ResNet模型的准确率提高了1.5%-2.5%，同时模型的计算效率也得到了显著提升。本文的研究为图像分类技术的发展提供了新的思路和方法。

关键词：图像分类；深度学习；ResNet；残差学习；注意力机制；知识蒸馏

目录

1. 绪论

1.1 研究背景与意义

图像分类是计算机视觉领域的核心任务之一，其目的是根据图像的内容将图像分类到预定义的类别中。图像分类技术在许多领域都有广泛的应用，如自动驾驶、安防监控、医疗诊断、智能零售等。随着互联网和移动设备的普及，图像数据量呈爆炸式增长，如何高效、准确地对这些图像进行分类成为了一个重要的研究课题。

传统的图像分类方法主要基于手工特征提取和机器学习分类器，如SIFT、HOG等特征提取方法和SVM、KNN等分类器。这些方法虽然在特定场景下取得了一定的效果，但它们依赖于手工设计的特征，难以适应复杂的图像场景和多样化的图像内容。

近年来，随着深度学习技术的快速发展，基于深度学习的图像分类方法取得了突破性的进展。深度卷积神经网络（CNN）能够自动学习图像的深层特征，避免了手工特征提取的局限性，在各种图像分类任务中都取得了优异的性能。例如，AlexNet、VGG、GoogLeNet、ResNet等模型在ImageNet数据集上的准确率不断刷新记录，推动了图像分类技术的快速发展。

1.2 国内外研究现状

1.2.1 传统图像分类方法

传统的图像分类方法主要包括特征提取和分类器设计两个阶段。

传统图像分类方法的优点是计算复杂度低，易于实现，但缺点是依赖于手工设计的特征，难以适应复杂的图像场景和多样化的图像内容。

1.2.2 基于深度学习的图像分类方法

基于深度学习的图像分类方法主要采用深度卷积神经网络（CNN），通过多层卷积和池化操作自动学习图像的深层特征。自2012年AlexNet在ImageNet竞赛中取得突破性成果以来，基于深度学习的图像分类方法得到了快速发展，出现了许多经典的模型，如：

1.3 研究内容与组织结构

本文主要研究图像分类算法的实现与性能优化，设计并实现了一种基于ResNet的改进图像分类模型。具体研究内容包括：

本文的组织结构如下：

第1章：绪论。介绍图像分类的研究背景、意义和现状，阐述本文的研究内容和组织结构。

第2章：相关技术基础。介绍图像分类的基本概念、深度学习的基础理论和常用的深度学习框架。

第3章：图像分类算法设计。详细设计基于ResNet的改进图像分类模型，包括模型结构、损失函数、训练策略等。

第4章：算法实现。介绍模型的实现过程，包括数据集预处理、模型搭建、训练和测试流程等。

第5章：实验与结果分析。介绍实验环境、数据集、评价指标，分析实验结果，比较所提模型与其他方法的性能。

第6章：结论与展望。总结本文的研究工作，指出存在的问题和未来的研究方向。

2. 相关技术基础

2.1 图像分类的基本概念

2.1.1 图像分类的定义

图像分类是指将输入图像分配到预定义类别的过程。形式化地，给定一个图像集合 D = (x_i, y_i) _{i=1}^N ，其中 x_i 是输入图像， y_i 是对应的类别标签，图像分类的目标是学习一个分类函数 f: X ightarrow Y ，将输入图像 x 映射到类别标签 y ，其中 X 是图像空间， Y 是类别空间。

2.1.2 图像分类的评价指标

图像分类的评价指标主要包括：

2.2 深度学习基础理论

2.2.1 卷积神经网络

卷积神经网络（CNN）是一种专门用于处理具有网格结构数据的深度学习模型，如图像、视频等。CNN的主要组成部分包括：

2.2.2 残差学习

残差学习是一种用于解决深层网络训练困难的技术，由He等人在ResNet中提出。残差学习的核心思想是通过跳跃连接（Skip Connection）将输入直接传递到输出，学习残差函数 F(x) = H(x) – x ，其中 H(x) 是期望的映射函数。

残差学习的优点是：

2.2.3 注意力机制

注意力机制是一种模拟人类注意力的技术，能够使模型关注输入中最重要的部分。在图像分类中，注意力机制可以帮助模型关注图像中的关键区域，提高分类准确率。

常见的注意力机制包括：

2.2.4 知识蒸馏

知识蒸馏是一种模型压缩技术，由Hinton等人提出。知识蒸馏的核心思想是将一个大型模型（教师模型）的知识传递给一个小型模型（学生模型），使学生模型能够达到与教师模型相当的性能，同时具有更小的模型尺寸和更快的推理速度。

知识蒸馏的优点是：

2.3 常用深度学习框架

常用的深度学习框架包括TensorFlow、PyTorch、Keras等。这些框架提供了丰富的API和工具，方便用户搭建和训练深度学习模型。

3. 图像分类算法设计

3.1 模型设计思路

基于深度学习的图像分类算法的核心是设计一个能够有效提取图像特征并进行分类的深度学习模型。本文采用ResNet作为基础模型，结合注意力机制和知识蒸馏等技术，设计了一种改进的图像分类模型。

ResNet是一种非常成功的图像分类模型，通过残差学习解决了深层网络的梯度消失问题，能够训练到非常深的层数。然而，ResNet在处理复杂图像时仍然存在一些局限性，如对图像中的关键区域关注不够、模型参数量大等。

为了克服这些局限性，本文提出了以下改进策略：

3.2 模型结构

本文设计的改进ResNet图像分类模型的结构如图3-1所示。模型主要包括输入层、注意力残差块、全局平均池化层和全连接层四部分。

3.2.1 注意力残差块

注意力残差块是改进ResNet模型的核心组件，结合了残差学习和注意力机制。注意力残差块的结构如图3-2所示，主要包括以下部分：

注意力残差块的工作流程如下：

3.2.2 完整模型结构

改进ResNet模型的完整结构如表3-1所示。模型采用了分层设计，从输入层到输出层，特征图的通道数逐渐增加，空间维度逐渐减小。

3.3 损失函数

图像分类的损失函数主要包括交叉熵损失、均方误差损失等。本文采用交叉熵损失和知识蒸馏损失的组合作为损失函数，具体定义如下：

L = (1 – lpha) L_{CE}(y, at{y}) + lpha L_{KD}(T(y_t), T(at{y}))

其中， L_{CE} 是交叉熵损失， L_{KD} 是知识蒸馏损失， lpha 是权重参数，用于平衡两种损失的重要性， T 是温度参数，用于控制知识蒸馏的软化程度， y 是真实标签， at{y} 是学生模型的预测结果， y_t 是教师模型的预测结果。

3.4 训练策略

本文采用以下训练策略：

4. 算法实现

4.1 开发环境

本文的开发环境如下：

4.2 数据集预处理

本文使用ImageNet数据集作为训练集，CIFAR-10和CIFAR-100数据集作为测试集。数据集预处理的步骤如下：

下面是数据集预处理的代码示例：

import torch
import torchvision
import torchvision.transforms as transforms
from torch.utils.data import DataLoader

# 图像归一化参数
mean = [0.485, 0.456, 0.406]
std = [0.229, 0.224, 0.225]

# 训练数据转换
train_transform = transforms.Compose([
transforms.RandomResizedCrop(224), # 随机裁剪
transforms.RandomHorizontalFlip(), # 随机水平翻转
transforms.RandomRotation(10), # 随机旋转
transforms.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2, hue=0.1), # 颜色抖动
transforms.ToTensor(), # 转换为Tensor
transforms.Normalize(mean, std) # 归一化
])

# 测试数据转换
test_transform = transforms.Compose([
transforms.Resize(256), # 缩放
transforms.CenterCrop(224), # 中心裁剪
transforms.ToTensor(), # 转换为Tensor
transforms.Normalize(mean, std) # 归一化
])

# 加载ImageNet数据集
train_dataset = torchvision.datasets.ImageNet(root='./data/imagenet', split='train', transform=train_transform)
test_dataset = torchvision.datasets.ImageNet(root='./data/imagenet', split='val', transform=test_transform)

# 加载CIFAR-10数据集
train_dataset_cifar10 = torchvision.datasets.CIFAR10(root='./data/cifar10', train=True, download=True, transform=train_transform)
test_dataset_cifar10 = torchvision.datasets.CIFAR10(root='./data/cifar10', train=False, download=True, transform=test_transform)

# 加载CIFAR-100数据集
train_dataset_cifar100 = torchvision.datasets.CIFAR100(root='./data/cifar100', train=True, download=True, transform=train_transform)
test_dataset_cifar100 = torchvision.datasets.CIFAR100(root='./data/cifar100', train=False, download=True, transform=test_transform)

# 创建数据加载器
train_loader = DataLoader(train_dataset, batch_size=256, shuffle=True, num_workers=8)
test_loader = DataLoader(test_dataset, batch_size=256, shuffle=False, num_workers=8)

train_loader_cifar10 = DataLoader(train_dataset_cifar10, batch_size=256, shuffle=True, num_workers=8)
test_loader_cifar10 = DataLoader(test_dataset_cifar10, batch_size=256, shuffle=False, num_workers=8)

train_loader_cifar100 = DataLoader(train_dataset_cifar100, batch_size=256, shuffle=True, num_workers=8)
test_loader_cifar100 = DataLoader(test_dataset_cifar100, batch_size=256, shuffle=False, num_workers=8)

4.3 模型实现

本文使用PyTorch框架实现改进的ResNet图像分类模型。模型实现的步骤如下：

下面是模型实现的代码示例：

import torch
import torch.nn as nn
import torch.nn.functional as F
import torchvision.models as models

class AttentionModule(nn.Module):
def __init__(self, in_channels):
super(AttentionModule, self).__init__()
# 通道注意力
self.channel_attention = nn.Sequential(
nn.AdaptiveAvgPool2d(1),
nn.Conv2d(in_channels, in_channels // 16, kernel_size=1, stride=1, padding=0),
nn.ReLU(inplace=True),
nn.Conv2d(in_channels // 16, in_channels, kernel_size=1, stride=1, padding=0),
nn.Sigmoid()
)

# 空间注意力
self.spatial_attention = nn.Sequential(
nn.Conv2d(2, 1, kernel_size=7, stride=1, padding=3),
nn.Sigmoid()
)

def forward(self, x):
# 通道注意力
channel_att = self.channel_attention(x)
x_channel_att = x * channel_att

# 空间注意力
avg_pool = torch.mean(x_channel_att, dim=1, keepdim=True)
max_pool, _ = torch.max(x_channel_att, dim=1, keepdim=True)
spatial_att = self.spatial_attention(torch.cat([avg_pool, max_pool], dim=1))
x_out = x_channel_att * spatial_att

return x_out

class AttentionResidualBlock(nn.Module):
def __init__(self, in_channels, out_channels, stride=1, downsample=None):
super(AttentionResidualBlock, self).__init__()
self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=stride, padding=1, bias=False)
self.bn1 = nn.BatchNorm2d(out_channels)
self.relu = nn.ReLU(inplace=True)
self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size=3, stride=1, padding=1, bias=False)
self.bn2 = nn.BatchNorm2d(out_channels)
self.attention = AttentionModule(out_channels)
self.downsample = downsample

def forward(self, x):
residual = x

out = self.conv1(x)
out = self.bn1(out)
out = self.relu(out)

out = self.conv2(out)
out = self.bn2(out)
out = self.attention(out)

if self.downsample:
residual = self.downsample(residual)

out += residual
out = self.relu(out)

return out

class ImprovedResNet(nn.Module):
def __init__(self, block, layers, num_classes=1000):
super(ImprovedResNet, self).__init__()
self.in_channels = 64
self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3, bias=False)
self.bn1 = nn.BatchNorm2d(64)
self.relu = nn.ReLU(inplace=True)
self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)

# 注意力残差组
self.layer1 = self._make_layer(block, 64, layers[0])
self.layer2 = self._make_layer(block, 128, layers[1], stride=2)
self.layer3 = self._make_layer(block, 256, layers[2], stride=2)
self.layer4 = self._make_layer(block, 512, layers[3], stride=2)

self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
self.fc = nn.Linear(512, num_classes)

def _make_layer(self, block, out_channels, blocks, stride=1):
downsample = None
if stride != 1 or self.in_channels != out_channels:
downsample = nn.Sequential(
nn.Conv2d(self.in_channels, out_channels, kernel_size=1, stride=stride, bias=False),
nn.BatchNorm2d(out_channels)
)

layers = []
layers.append(block(self.in_channels, out_channels, stride, downsample))
self.in_channels = out_channels
for _ in range(1, blocks):
layers.append(block(out_channels, out_channels))

return nn.Sequential(*layers)

def forward(self, x):
x = self.conv1(x)
x = self.bn1(x)
x = self.relu(x)
x = self.maxpool(x)

x = self.layer1(x)
x = self.layer2(x)
x = self.layer3(x)
x = self.layer4(x)

x = self.avgpool(x)
x = torch.flatten(x, 1)
x = self.fc(x)

return x

# 创建改进的ResNet-50模型
def improved_resnet50(num_classes=1000):
return ImprovedResNet(AttentionResidualBlock, [3, 4, 6, 3], num_classes)

# 加载教师模型（ResNet-152）
teacher_model = models.resnet152(pretrained=True)
teacher_model.eval()

# 创建学生模型（改进的ResNet-50）
student_model = improved_resnet50(num_classes=1000)

4.4 训练过程实现

本文使用PyTorch框架实现模型的训练过程。训练过程的步骤如下：

下面是训练过程实现的代码示例：

import torch
import torch.optim as optim
from torch.optim.lr_scheduler import CosineAnnealingLR
import os

# 设备设置
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

# 模型加载
teacher_model = teacher_model.to(device)
student_model = student_model.to(device)

# 损失函数
criterion_ce = nn.CrossEntropyLoss()

def criterion_kd(outputs, targets, teacher_outputs, T=10, alpha=0.5):
# 交叉熵损失
ce_loss = criterion_ce(outputs, targets)

# 知识蒸馏损失
soft_targets = F.softmax(teacher_outputs / T, dim=1)
soft_outputs = F.log_softmax(outputs / T, dim=1)
kd_loss = F.kl_div(soft_outputs, soft_targets, reduction='batchmean') * (T * T)

# 总损失
loss = (1 – alpha) * ce_loss + alpha * kd_loss
return loss

# 优化器
optimizer = optim.SGD(student_model.parameters(), lr=0.1, momentum=0.9, weight_decay=1e-4)

# 学习率调度器
scheduler = CosineAnnealingLR(optimizer, T_max=100)

# 训练参数
epochs = 100
best_acc = 0.0
save_dir = "models"
if not os.path.exists(save_dir):
os.makedirs(save_dir)

# 训练循环
for epoch in range(epochs):
student_model.train()
train_loss = 0.0
train_correct = 0
train_total = 0

for batch_idx, (images, targets) in enumerate(train_loader):
images = images.to(device)
targets = targets.to(device)

# 教师模型预测
with torch.no_grad():
teacher_outputs = teacher_model(images)

# 学生模型预测
outputs = student_model(images)

# 损失计算
loss = criterion_kd(outputs, targets, teacher_outputs, T=10, alpha=0.5)

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

train_loss += loss.item()

# 计算训练准确率
_, predicted = outputs.max(1)
train_total += targets.size(0)
train_correct += predicted.eq(targets).sum().item()

# 打印训练信息
if (batch_idx + 1) % 100 == 0:
print(f"Epoch [{epoch+1}/{epochs}], Batch [{batch_idx+1}/{len(train_loader)}], Loss: {loss.item():.6f}, Acc: {100.*train_correct/train_total:.2f}%")

# 学习率衰减
scheduler.step()

# 计算平均训练损失和准确率
avg_train_loss = train_loss / len(train_loader)
avg_train_acc = 100. * train_correct / train_total
print(f"Epoch [{epoch+1}/{epochs}], Average Train Loss: {avg_train_loss:.6f}, Average Train Acc: {avg_train_acc:.2f}%")

# 测试模型
student_model.eval()
test_correct = 0
test_total = 0

with torch.no_grad():
for images, targets in test_loader:
images = images.to(device)
targets = targets.to(device)

# 学生模型预测
outputs = student_model(images)

# 计算测试准确率
_, predicted = outputs.max(1)
test_total += targets.size(0)
test_correct += predicted.eq(targets).sum().item()

# 计算平均测试准确率
avg_test_acc = 100. * test_correct / test_total
print(f"Epoch [{epoch+1}/{epochs}], Test Acc: {avg_test_acc:.2f}%")

# 保存最佳模型
if avg_test_acc > best_acc:
best_acc = avg_test_acc
torch.save(student_model.state_dict(), os.path.join(save_dir, "best_model.pth"))
print(f"Best model saved with Acc: {best_acc:.2f}%")

4.5 测试过程实现

本文使用PyTorch框架实现模型的测试过程。测试过程的步骤如下：

下面是测试过程实现的代码示例：

import torch
import torchvision.transforms as transforms
from PIL import Image
import os

# 设备设置
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

# 模型加载
model = improved_resnet50(num_classes=1000)
model.load_state_dict(torch.load("models/best_model.pth"))
model.to(device)
model.eval()

# 图像预处理
mean = [0.485, 0.456, 0.406]
std = [0.229, 0.224, 0.225]
transform = transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize(mean, std)
])

# 类别标签
with open("imagenet_classes.txt", "r") as f:
classes = [line.strip() for line in f.readlines()]

# 测试图像路径
test_image_paths = ["test/image1.jpg", "test/image2.jpg", "test/image3.jpg"]
result_dir = "results"
if not os.path.exists(result_dir):
os.makedirs(result_dir)

# 测试循环
for image_path in test_image_paths:
# 读取图像
image = Image.open(image_path).convert("RGB")

# 图像预处理
image_tensor = transform(image).unsqueeze(0).to(device)

# 图像分类
with torch.no_grad():
outputs = model(image_tensor)
probabilities = F.softmax(outputs, dim=1)
_, predicted = outputs.max(1)

# 输出分类结果
class_name = classes[predicted.item()]
confidence = probabilities[0][predicted.item()].item()

print(f"Image: {os.path.basename(image_path)}")
print(f"Predicted Class: {class_name}")
print(f"Confidence: {confidence:.4f}")
print("—")

# 保存结果
# 这里可以添加保存结果的代码，如保存分类标签、置信度等

5. 实验与结果分析

5.1 实验环境与数据集

5.1.1 实验环境

本文的实验环境如下：

5.1.2 数据集

本文使用以下数据集进行实验：

5.2 实验设置

5.2.1 评价指标

本文使用以下评价指标评估图像分类的性能：

5.2.2 对比方法

本文将所提的改进ResNet模型与以下几种常用的图像分类方法进行对比：

5.3 实验结果与分析

5.3.1 ImageNet数据集上的实验结果

表5-1展示了在ImageNet数据集上，不同方法的Top-1准确率和Top-5准确率。从表中可以看出：

从表中可以看出：

这说明改进ResNet-50模型在保持参数量和计算量基本不变的情况下，显著提高了分类准确率，接近更深层的ResNet-152模型的性能。

5.3.2 CIFAR-10和CIFAR-100数据集上的实验结果

表5-2和表5-3分别展示了在CIFAR-10和CIFAR-100数据集上，不同方法的准确率。从表中可以看出：

表5-2 CIFAR-10数据集上的实验结果

表5-3 CIFAR-100数据集上的实验结果

从表中可以看出：

这进一步验证了改进ResNet模型的有效性，在不同的数据集上均能取得优异的性能。

5.3.3 注意力机制的有效性分析

为了验证注意力机制的有效性，我们进行了消融实验，比较了不同模型的性能。表5-4展示了消融实验的结果。

表5-4 注意力机制的消融实验结果

从表中可以看出：

这说明注意力机制能够有效地提高模型的分类准确率，而通道注意力和空间注意力的结合能够进一步提高模型的性能。

5.3.4 知识蒸馏的有效性分析

为了验证知识蒸馏的有效性，我们比较了使用知识蒸馏和不使用知识蒸馏的模型性能。表5-5展示了知识蒸馏的实验结果。

表5-5 知识蒸馏的实验结果

从表中可以看出，使用知识蒸馏的改进ResNet-50模型的Top-1准确率为77.89%，比不使用知识蒸馏的模型提高了0.37%。这说明知识蒸馏能够进一步提高模型的分类准确率，是一种有效的性能优化技术。

5.3.5 模型计算效率分析

为了分析模型的计算效率，我们比较了不同方法的参数量和计算量。表5-6展示了不同方法的参数量和计算量。

表5-6 不同方法的参数量和计算量

从表中可以看出：

这说明改进ResNet-50模型在提高分类准确率的同时，并没有显著增加模型的参数量、计算量和推理时间，保持了较高的计算效率。

5.4 实验结论

通过以上实验，本文得出以下结论：

6. 结论与展望

6.1 研究结论

本文主要研究了图像分类算法的实现与性能优化，设计并实现了一种基于ResNet的改进图像分类模型。通过实验验证，该模型在图像分类任务中表现出色，具有以下优点：

本文的研究成果为图像分类技术的发展提供了新的思路和方法，具有一定的理论意义和实际应用价值。

6.2 研究不足与展望

尽管本文的研究取得了一定的成果，但仍存在一些不足之处，需要在未来的研究中进一步改进：

总之，图像分类技术仍有很大的发展空间，未来的研究可以从多个方向进行探索，进一步提高图像分类的准确率和效率，推动图像分类技术在更多领域的应用。

参考文献

[1] Krizhevsky A, Sutskever I, Hinton G E. ImageNet Classification with Deep Convolutional Neural Networks[C]. Advances in Neural Information Processing Systems, 2012: 1097-1105.

[2] Simonyan K, Zisserman A. Very Deep Convolutional Networks for Large-Scale Image Recognition[C]. International Conference on Learning Representations, 2015.

[3] Szegedy C, Liu W, Jia Y, et al. Going Deeper with Convolutions[C]. IEEE Conference on Computer Vision and Pattern Recognition, 2015: 1-9.

[4] He K, Zhang X, Ren S, et al. Deep Residual Learning for Image Recognition[C]. IEEE Conference on Computer Vision and Pattern Recognition, 2016: 770-778.

[5] Huang G, Liu Z, Van Der Maaten L, et al. Densely Connected Convolutional Networks[C]. IEEE Conference on Computer Vision and Pattern Recognition, 2017: 4700-4708.

[6] Tan M, Le Q V. EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks[C]. International Conference on Machine Learning, 2019: 6105-6114.

[7] Hu J, Shen L, Sun G. Squeeze-and-Excitation Networks[C]. IEEE Conference on Computer Vision and Pattern Recognition, 2018: 7132-7141.

[8] Woo S, Park J, Lee J Y, et al. CBAM: Convolutional Block Attention Module[C]. European Conference on Computer Vision, 2018: 3-19.

[9] Vaswani A, Shazeer N, Parmar N, et al. Attention Is All You Need[C]. Advances in Neural Information Processing Systems, 2017: 5998-6008.

[10] Hinton G, Vinyals O, Dean J. Distilling the Knowledge in a Neural Network[J]. arXiv preprint arXiv:1503.02531, 2015.

[11] Li H, Kadav A, Durdanovic I, et al. Pruning Filters for Efficient ConvNets[C]. International Conference on Learning Representations, 2017.

[12] Jacob B, Kligys S, Chen B, et al. Quantization and Training of Neural Networks for Efficient Integer-Arithmetic-Only Inference[C]. IEEE Conference on Computer Vision and Pattern Recognition, 2018: 2704-2713.

[13] Chen L C, Zhu Y, Papandreou G, et al. Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation[C]. European Conference on Computer Vision, 2018: 801-818.

[14] Redmon J, Divvala S, Girshick R, et al. You Only Look Once: Unified, Real-Time Object Detection[C]. IEEE Conference on Computer Vision and Pattern Recognition, 2016: 779-788.

[15] Ren S, He K, Girshick R, et al. Faster R-CNN: Towards Real-Time Object Detection with Region Proposal Networks[C]. Advances in Neural Information Processing Systems, 2015: 91-99.

[16] He K, Zhang X, Ren S, et al. Identity Mappings in Deep Residual Networks[C]. European Conference on Computer Vision, 2016: 630-645.

[17] Zhang K, Zhang L, Li Z, et al. Image Super-Resolution Using Very Deep Residual Channel Attention Networks[C]. European Conference on Computer Vision, 2018: 286-301.

[18] Johnson J, Alahi A, Fei-Fei L. Perceptual Losses for Real-Time Style Transfer and Super-Resolution[C]. European Conference on Computer Vision, 2016: 694-711.

[19] Goodfellow I, Pouget-Abadie J, Mirza M, et al. Generative Adversarial Nets[C]. Advances in Neural Information Processing Systems, 2014: 2672-2680.

[20] Carion N, Massa F, Synnaeve G, et al. End-to-End Object Detection with Transformers[C]. European Conference on Computer Vision, 2020: 213-229.