torchvision.models

models 子包包含用于寻址的模型的定义 不同的任务，包括：图像分类、像素语义 分割、对象检测、实例分割、人员 关键点检测和视频分类。

分类

models 子包包含以下模型的定义 图像分类架构：

• 亚历克斯网络
• VGG的
• ResNet 公司
• SqueezeNet （挤压网）
• 密集网
• 初始 v3
• 谷歌网
• ShuffleNet v2 版本
• MobileNet v2 版本
• ResNeXt
• 宽 ResNet
• MNASNet

您可以通过调用其构造函数来构造具有随机权重的模型：

import torchvision.models as models
resnet18 = models.resnet18()
alexnet = models.alexnet()
vgg16 = models.vgg16()
squeezenet = models.squeezenet1_0()
densenet = models.densenet161()
inception = models.inception_v3()
googlenet = models.googlenet()
shufflenet = models.shufflenet_v2_x1_0()
mobilenet = models.mobilenet_v2()
resnext50_32x4d = models.resnext50_32x4d()
wide_resnet50_2 = models.wide_resnet50_2()
mnasnet = models.mnasnet1_0()

我们使用 PyTorch 提供预训练模型。 这些可以通过传递 ：torch.utils.model_zoopretrained=True

import torchvision.models as models
resnet18 = models.resnet18(pretrained=True)
alexnet = models.alexnet(pretrained=True)
squeezenet = models.squeezenet1_0(pretrained=True)
vgg16 = models.vgg16(pretrained=True)
densenet = models.densenet161(pretrained=True)
inception = models.inception_v3(pretrained=True)
googlenet = models.googlenet(pretrained=True)
shufflenet = models.shufflenet_v2_x1_0(pretrained=True)
mobilenet = models.mobilenet_v2(pretrained=True)
resnext50_32x4d = models.resnext50_32x4d(pretrained=True)
wide_resnet50_2 = models.wide_resnet50_2(pretrained=True)
mnasnet = models.mnasnet1_0(pretrained=True)

实例化预先训练的模型会将其权重下载到缓存目录。 可以使用 TORCH_MODEL_ZOO 环境变量设置此目录。有关详细信息，请参阅。torch.utils.model_zoo.load_url()

一些模型使用具有不同训练和评估的模块 行为，例如批量规范化。要在这些模式之间切换，请根据需要使用 或。有关详细信息，请参阅 或 。model.train()model.eval()train()eval()

所有预训练模型都期望以相同的方式对输入图像进行归一化。 即形状为 （3 x H x W） 的 3 通道 RGB 图像的小批量， 其中 H 和 W 预计至少为 224。 图像必须加载到 [0， 1] 范围内，然后进行标准化 using 和 . 您可以使用以下转换进行规范化：mean = [0.485, 0.456, 0.406]std = [0.229, 0.224, 0.225]

normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
                                 std=[0.229, 0.224, 0.225])

这种归一化的示例可以在 imagenet 示例中找到

获取 mean 和 std 值的过程大致相等 自：

import torch
from torchvision import datasets, transforms as T

transform = T.Compose([T.Resize(256), T.CenterCrop(224), T.ToTensor()])
dataset = datasets.ImageNet(".", split="train", transform=transform)

means = []
stds = []
for img in subset(dataset):
    means.append(torch.mean(img))
    stds.append(torch.std(img))

mean = torch.mean(torch.tensor(means))
std = torch.mean(torch.tensor(stds))

遗憾的是，使用的具体子集丢失了。了解更多 信息请参阅此讨论或这些实验。

ImageNet 1 裁剪错误率 （224x224）

网络	Top-1 错误	前 5 个错误
亚历克斯网络	43.45	20.91
VGG-11型	30.98	11.37
VGG-13型	30.07	10.75
VGG-16型	28.41	9.62
VGG-19型	27.62	9.12
VGG-11 批量归一化	29.62	10.19
VGG-13 批量归一化	28.45	9.63
VGG-16 批量归一化	26.63	8.50
VGG-19 批量归一化	25.76	8.15
ResNet-18 系列	30.24	10.92
ResNet-34 的	26.70	8.58
ResNet-50 系列	23.85	7.13
ResNet-101 系列	22.63	6.44
ResNet-152 系列	21.69	5.94
SqueezeNet 1.0	41.90	19.58
SqueezeNet 1.1	41.81	19.38
Densenet-121 系列	25.35	7.83
登网-169	24.00	7.00
Densenet-201 系列	22.80	6.43
登网-161	22.35	6.20
初始 v3	22.55	6.44
谷歌网络	30.22	10.47
随机播放网 V2	30.64	11.68
移动网络 V2	28.12	9.71
ResNeXt-50-32x4d	22.38	6.30
ResNeXt-101-32x8d	20.69	5.47
宽 ResNet-50-2	21.49	5.91
宽网-101-2	21.16	5.72
MNASNet 1.0	26.49	8.456

亚历克斯内特

torchvision.models.alexnet(pretrained=False， progress=True， **kwargs）

AlexNet 模型架构，摘自“One weird trick...”论文。

参数：

• pretrained （bool） – 如果为 True，则返回在 ImageNet 上预训练的模型
• progress （bool） – 如果为 True，则显示下载到 stderr 的进度条

VGG的

torchvision.models.vgg11(pretrained=False， progress=True， **kwargs）

VGG 11 层模型（配置 “A”），来自 “Very Deep Convolutional Networks For Large-Scale Image Recognition”

参数：

• pretrained （bool） – 如果为 True，则返回在 ImageNet 上预训练的模型
• progress （bool） – 如果为 True，则显示下载到 stderr 的进度条

torchvision.models.vgg11_bn(pretrained=False， progress=True， **kwargs）

VGG 11 层模型（配置 “A”），具有批量归一化“用于大规模图像识别的甚深度卷积网络”

参数：

• pretrained （bool） – 如果为 True，则返回在 ImageNet 上预训练的模型
• progress （bool） – 如果为 True，则显示下载到 stderr 的进度条

torchvision.models.vgg13(pretrained=False， progress=True， **kwargs）

VGG 13 层模型（配置 “B”） “用于大规模图像识别的甚深卷积网络”

参数：

• pretrained （bool） – 如果为 True，则返回在 ImageNet 上预训练的模型
• progress （bool） – 如果为 True，则显示下载到 stderr 的进度条

torchvision.models.vgg13_bn(pretrained=False， progress=True， **kwargs）

VGG 13 层模型（配置 “B”），具有批量归一化“用于大规模图像识别的甚深卷积网络”

参数：

• pretrained （bool） – 如果为 True，则返回在 ImageNet 上预训练的模型
• progress （bool） – 如果为 True，则显示下载到 stderr 的进度条

torchvision.models.vgg16(pretrained=False， progress=True， **kwargs）

VGG 16 层模型（配置 “D”） “用于大规模图像识别的甚深卷积网络”

参数：

• pretrained （bool） – 如果为 True，则返回在 ImageNet 上预训练的模型
• progress （bool） – 如果为 True，则显示下载到 stderr 的进度条

torchvision.models.vgg16_bn(pretrained=False， progress=True， **kwargs）

VGG 16 层模型（配置“D”），具有批量归一化“用于大规模图像识别的甚深卷积网络”

参数：

• pretrained （bool） – 如果为 True，则返回在 ImageNet 上预训练的模型
• progress （bool） – 如果为 True，则显示下载到 stderr 的进度条

torchvision.models.vgg19(pretrained=False， progress=True， **kwargs）

VGG 19 层模型（配置 “E”） “用于大规模图像识别的甚深卷积网络”

参数：

• pretrained （bool） – 如果为 True，则返回在 ImageNet 上预训练的模型
• progress （bool） – 如果为 True，则显示下载到 stderr 的进度条

torchvision.models.vgg19_bn(pretrained=False， progress=True， **kwargs）

VGG 19 层模型（配置 'E'），具有批量归一化 “Very Deep Convolutional Networks For Large-Scale Image Recognition”

参数：

• pretrained （bool） – 如果为 True，则返回在 ImageNet 上预训练的模型
• progress （bool） – 如果为 True，则显示下载到 stderr 的进度条

ResNet 公司

torchvision.models.resnet18(pretrained=False， progress=True， **kwargs）

来自 “Deep Residual Learning for Image Recognition” 的 ResNet-18 模型

参数：

• pretrained （bool） – 如果为 True，则返回在 ImageNet 上预训练的模型
• progress （bool） – 如果为 True，则显示下载到 stderr 的进度条

torchvision.models.resnet34(pretrained=False， progress=True， **kwargs）

来自“Deep Residual Learning for Image Recognition”的 ResNet-34 模型

参数：

• pretrained （bool） – 如果为 True，则返回在 ImageNet 上预训练的模型
• progress （bool） – 如果为 True，则显示下载到 stderr 的进度条

torchvision.models.resnet50(pretrained=False， progress=True， **kwargs）

来自 “Deep Residual Learning for Image Recognition” 的 ResNet-50 模型

参数：

• pretrained （bool） – 如果为 True，则返回在 ImageNet 上预训练的模型
• progress （bool） – 如果为 True，则显示下载到 stderr 的进度条

torchvision.models.resnet101(pretrained=False， progress=True， **kwargs）

来自 “Deep Residual Learning for Image Recognition” 的 ResNet-101 模型

参数：

• pretrained （bool） – 如果为 True，则返回在 ImageNet 上预训练的模型
• progress （bool） – 如果为 True，则显示下载到 stderr 的进度条

torchvision.models.resnet152(pretrained=False， progress=True， **kwargs）

来自 “Deep Residual Learning for Image Recognition” 的 ResNet-152 模型

参数：

• pretrained （bool） – 如果为 True，则返回在 ImageNet 上预训练的模型
• progress （bool） – 如果为 True，则显示下载到 stderr 的进度条

SqueezeNet （挤压网）

torchvision.models.squeezenet1_0(pretrained=False， progress=True， **kwargs）

SqueezeNet 模型架构来自“SqueezeNet：AlexNet 级别 精度，参数减少 50 倍，<0.5MB 模型大小“纸张。

参数：

• pretrained （bool） – 如果为 True，则返回在 ImageNet 上预训练的模型
• progress （bool） – 如果为 True，则显示下载到 stderr 的进度条

torchvision.models.squeezenet1_1(pretrained=False， progress=True， **kwargs）

SqueezeNet 1.1 模型。 SqueezeNet 1.1 的计算量减少了 2.4 倍，参数也略少 比 SqueezeNet 1.0 更可靠。

参数：

• pretrained （bool） – 如果为 True，则返回在 ImageNet 上预训练的模型
• progress （bool） – 如果为 True，则显示下载到 stderr 的进度条

密集网

torchvision.models.densenet121(pretrained=False， progress=True， **kwargs）

来自 “Densely Connected Convolutional Networks” 的 Densenet-121 模型

参数：

• pretrained （bool） – 如果为 True，则返回在 ImageNet 上预训练的模型
• progress （bool） – 如果为 True，则显示下载到 stderr 的进度条
• memory_efficient （bool） – 但速度较慢。默认值：False。参见 “论文”

torchvision.models.densenet169(pretrained=False， progress=True， **kwargs）

来自 “Densely Connected Convolutional Networks” 的 Densenet-169 模型

参数：

• pretrained （bool） – 如果为 True，则返回在 ImageNet 上预训练的模型
• progress （bool） – 如果为 True，则显示下载到 stderr 的进度条
• memory_efficient （布尔值） –

  但速度较慢。默认值：False。参见 “论文”

torchvision.models.densenet161(pretrained=False， progress=True， **kwargs）

来自 “Densely Connected Convolutional Networks” 的 Densenet-161 模型

参数：

• pretrained （bool） – 如果为 True，则返回在 ImageNet 上预训练的模型
• progress （bool） – 如果为 True，则显示下载到 stderr 的进度条
• memory_efficient （布尔值） –

  但速度较慢。默认值：False。参见 “论文”

torchvision.models.densenet201(pretrained=False， progress=True， **kwargs）

来自 “Densely Connected Convolutional Networks” 的 Densenet-201 模型

参数：

• pretrained （bool） – 如果为 True，则返回在 ImageNet 上预训练的模型
• progress （bool） – 如果为 True，则显示下载到 stderr 的进度条
• memory_efficient （布尔值） –

  但速度较慢。默认值：False。参见 “论文”

初始 v3

torchvision.models.inception_v3(pretrained=False， progress=True， **kwargs）

“重新思考计算机视觉的 Inception 体系结构”中的 Inception v3 模型体系结构。

注意

重要提示：与其他模型相比，inception_v3 期望的张量大小为 N x 3 x 299 x 299，因此请确保您的图像大小相应。

参数：

• pretrained （bool） – 如果为 True，则返回在 ImageNet 上预训练的模型
• progress （bool） – 如果为 True，则显示下载到 stderr 的进度条
• aux_logits （bool） – 如果为 True，则添加可以改进训练的辅助分支。 默认值：True
• transform_input （bool） – 如果为 True，则根据输入的方法对输入进行预处理 在 ImageNet 上进行训练。默认值：False

注意

这需要安装 scipy

谷歌网

torchvision.models.googlenet(pretrained=False， progress=True， **kwargs）

GoogLeNet （Inception v1） 模型架构，来自 “Going Deeper with Convolutions” 的模型架构。

参数：

• pretrained （bool） – 如果为 True，则返回在 ImageNet 上预训练的模型
• progress （bool） – 如果为 True，则显示下载到 stderr 的进度条
• aux_logits （bool） – 如果为 True，则添加两个可以改进训练的辅助分支。 默认值：当预训练为 True 时为 False，否则为 True
• transform_input （bool） – 如果为 True，则根据输入的方法对输入进行预处理 在 ImageNet 上进行训练。默认值：False

注意

这需要安装 scipy

ShuffleNet v2 版本

torchvision.models.shufflenet_v2_x0_5(pretrained=False， progress=True， **kwargs）

构造具有 0.5x 输出通道的 ShuffleNetV2，如“ShuffleNet V2：高效 CNN 架构设计的实用指南”中所述。

参数：

• pretrained （bool） – 如果为 True，则返回在 ImageNet 上预训练的模型
• progress （bool） – 如果为 True，则显示下载到 stderr 的进度条

torchvision.models.shufflenet_v2_x1_0(pretrained=False， progress=True， **kwargs）

构造具有 1.0x 输出通道的 ShuffleNetV2，如“ShuffleNet V2：高效 CNN 架构设计的实用指南”中所述。

参数：

• pretrained （bool） – 如果为 True，则返回在 ImageNet 上预训练的模型
• progress （bool） – 如果为 True，则显示下载到 stderr 的进度条

torchvision.models.shufflenet_v2_x1_5(pretrained=False， progress=True， **kwargs）

构造具有 1.5x 输出通道的 ShuffleNetV2，如“ShuffleNet V2：高效 CNN 架构设计的实用指南”中所述。

参数：

• pretrained （bool） – 如果为 True，则返回在 ImageNet 上预训练的模型
• progress （bool） – 如果为 True，则显示下载到 stderr 的进度条

torchvision.models.shufflenet_v2_x2_0(pretrained=False， progress=True， **kwargs）

构造具有 2.0x 输出通道的 ShuffleNetV2，如“ShuffleNet V2：高效 CNN 体系结构设计的实用指南”中所述。

参数：

• pretrained （bool） – 如果为 True，则返回在 ImageNet 上预训练的模型
• progress （bool） – 如果为 True，则显示下载到 stderr 的进度条

MobileNet v2 版本

torchvision.models.mobilenet_v2(pretrained=False， progress=True， **kwargs）

根据 “MobileNetV2： Inverted Residuals and Linear Bottlenecks” 构建 MobileNetV2 架构。

参数：

• pretrained （bool） – 如果为 True，则返回在 ImageNet 上预训练的模型
• progress （bool） – 如果为 True，则显示下载到 stderr 的进度条

Res下一页

torchvision.models.resnext50_32x4d(pretrained=False， progress=True， **kwargs）

来自 “Aggregated Residual Transformation for Deep Neural Networks” 的 ResNeXt-50 32x4d 模型

参数：

• pretrained （bool） – 如果为 True，则返回在 ImageNet 上预训练的模型
• progress （bool） – 如果为 True，则显示下载到 stderr 的进度条

torchvision.models.resnext101_32x8d(pretrained=False， progress=True， **kwargs）

ResNeXt-101 32x8d 模型，来自 “Aggregated Residual Transformation for Deep Neural Networks”

参数：

• pretrained （bool） – 如果为 True，则返回在 ImageNet 上预训练的模型
• progress （bool） – 如果为 True，则显示下载到 stderr 的进度条

宽 ResNet

torchvision.models.wide_resnet50_2(pretrained=False， progress=True， **kwargs）

来自 “Wide Residual Networks” 的 Wide ResNet-50-2 模型

该模型与 ResNet 相同，只是通道数存在瓶颈 在每个区块中，它的大小是两倍。外部 1x1 中的通道数 卷积是相同的，例如 ResNet-50 中的最后一个块有 2048-512-2048 频道，在 Wide ResNet-50-2 中有 2048-1024-2048。

参数：

• pretrained （bool） – 如果为 True，则返回在 ImageNet 上预训练的模型
• progress （bool） – 如果为 True，则显示下载到 stderr 的进度条

torchvision.models.wide_resnet101_2(pretrained=False， progress=True， **kwargs）

来自 “Wide Residual Networks” 的 Wide ResNet-101-2 模型

该模型与 ResNet 相同，只是通道数存在瓶颈 在每个区块中，它的大小是两倍。外部 1x1 中的通道数 卷积是相同的，例如 ResNet-50 中的最后一个块有 2048-512-2048 频道，在 Wide ResNet-50-2 中有 2048-1024-2048。

参数：

• pretrained （bool） – 如果为 True，则返回在 ImageNet 上预训练的模型
• progress （bool） – 如果为 True，则显示下载到 stderr 的进度条

MNASNet

torchvision.models.mnasnet0_5(pretrained=False， progress=True， **kwargs）

来自“MnasNet：移动平台感知神经架构搜索”的深度乘数为 0.5 的 MNASNet。 :p aram pretrained：如果为 True，则返回在 ImageNet 上预训练的模型 ：type pretrained： bool :p aram progress：如果为 True，则显示下载到 stderr 的进度条 ：type progress： bool

torchvision.models.mnasnet0_75(pretrained=False， progress=True， **kwargs）

来自“MnasNet：移动平台感知神经架构搜索”的深度乘数为 0.75 的 MNASNet。 :p aram pretrained：如果为 True，则返回在 ImageNet 上预训练的模型 ：type pretrained： bool :p aram progress：如果为 True，则显示下载到 stderr 的进度条 ：type progress： bool

torchvision.models.mnasnet1_0(pretrained=False， progress=True， **kwargs）

来自“MnasNet：移动平台感知神经架构搜索”的深度乘数为 1.0 的 MNASNet。 :p aram pretrained：如果为 True，则返回在 ImageNet 上预训练的模型 ：type pretrained： bool :p aram progress：如果为 True，则显示下载到 stderr 的进度条 ：type progress： bool

torchvision.models.mnasnet1_3(pretrained=False， progress=True， **kwargs）

来自“MnasNet：移动平台感知神经架构搜索”的深度乘数为 1.3 的 MNASNet。 :p aram pretrained：如果为 True，则返回在 ImageNet 上预训练的模型 ：type pretrained： bool :p aram progress：如果为 True，则显示下载到 stderr 的进度条 ：type progress： bool

语义分割

models 子包包含以下模型的定义 语义分割的架构：

• FCN ResNet50、ResNet101
• DeepLabV3 ResNet50、ResNet101

与图像分类模型一样，所有预先训练的模型都希望输入图像以相同的方式进行标准化。 必须将图像加载到一个范围内，然后使用 和 进行标准化。 他们已经接受了调整大小的图像的训练，因此其最小大小为 520。[0, 1]mean = [0.485, 0.456, 0.406]std = [0.229, 0.224, 0.225]

预训练模型已在 COCO train2017 的一个子集上进行了训练，训练了 20 个类别，这些类别是 存在于 Pascal VOC 数据集中。您可以在 中查看有关如何选择子集的更多信息。预训练模型输出的类如下： 挨次：references/segmentation/coco_utils.py

['__background__', 'aeroplane', 'bicycle', 'bird', 'boat', 'bottle', 'bus',
 'car', 'cat', 'chair', 'cow', 'diningtable', 'dog', 'horse', 'motorbike',
 'person', 'pottedplant', 'sheep', 'sofa', 'train', 'tvmonitor']

在 COCO val2017 上评估的预训练模型的准确性如下

网络	均值 IoU	全局像素 ACC
FCN ResNet50	60.5	91.4
FCN ResNet101	63.7	91.9
DeepLabV3 ResNet50	66.4	92.4
DeepLabV3 ResNet101	67.4	92.4

全卷积网络

torchvision.models.segmentation.fcn_resnet50(pretrained=False， progress=True， num_classes=21， aux_loss=None， **kwargs）

构建具有 ResNet-50 主干的全卷积网络模型。

参数：

• pretrained （bool） – 如果为 True，则返回在 COCO train2017 上预训练的模型，该模型 包含与 Pascal VOC 相同的类
• progress （bool） – 如果为 True，则显示下载到 stderr 的进度条

torchvision.models.segmentation.fcn_resnet101(pretrained=False， progress=True， num_classes=21， aux_loss=None， **kwargs）

构建一个具有 ResNet-101 主干的全卷积网络模型。

参数：

• pretrained （bool） – 如果为 True，则返回在 COCO train2017 上预训练的模型，该模型 包含与 Pascal VOC 相同的类
• progress （bool） – 如果为 True，则显示下载到 stderr 的进度条

深度实验室 V3

torchvision.models.segmentation.deeplabv3_resnet50(pretrained=False， progress=True， num_classes=21， aux_loss=None， **kwargs）

构建具有 ResNet-50 主干的 DeepLabV3 模型。

参数：

• pretrained （bool） – 如果为 True，则返回在 COCO train2017 上预训练的模型，该模型 包含与 Pascal VOC 相同的类
• progress （bool） – 如果为 True，则显示下载到 stderr 的进度条

torchvision.models.segmentation.deeplabv3_resnet101(pretrained=False， progress=True， num_classes=21， aux_loss=None， **kwargs）

构建具有 ResNet-101 主干的 DeepLabV3 模型。

参数：

• pretrained （bool） – 如果为 True，则返回在 COCO train2017 上预训练的模型，该模型 包含与 Pascal VOC 相同的类
• progress （bool） – 如果为 True，则显示下载到 stderr 的进度条

对象检测、实例分割和人员关键点检测

models 子包包含以下模型的定义 检测架构：

• 更快的 R-CNN ResNet-50 FPN
• 掩码 R-CNN ResNet-50 FPN

用于检测、实例分割和 关键点检测使用分类模型进行初始化 在 TorchVision 中。

模型需要 范围 中的 ， 列表。 模型在内部调整图像的大小，以便它们具有最小大小 之。可以通过将选项传递给模型的构造函数来更改此选项。Tensor[C, H, W]0-1800min_size

对于对象检测和实例分割，预训练的 模型返回以下类的预测：

COCO_INSTANCE_CATEGORY_NAMES = [
    '__background__', 'person', 'bicycle', 'car', 'motorcycle', 'airplane', 'bus',
    'train', 'truck', 'boat', 'traffic light', 'fire hydrant', 'N/A', 'stop sign',
    'parking meter', 'bench', 'bird', 'cat', 'dog', 'horse', 'sheep', 'cow',
    'elephant', 'bear', 'zebra', 'giraffe', 'N/A', 'backpack', 'umbrella', 'N/A', 'N/A',
    'handbag', 'tie', 'suitcase', 'frisbee', 'skis', 'snowboard', 'sports ball',
    'kite', 'baseball bat', 'baseball glove', 'skateboard', 'surfboard', 'tennis racket',
    'bottle', 'N/A', 'wine glass', 'cup', 'fork', 'knife', 'spoon', 'bowl',
    'banana', 'apple', 'sandwich', 'orange', 'broccoli', 'carrot', 'hot dog', 'pizza',
    'donut', 'cake', 'chair', 'couch', 'potted plant', 'bed', 'N/A', 'dining table',
    'N/A', 'N/A', 'toilet', 'N/A', 'tv', 'laptop', 'mouse', 'remote', 'keyboard', 'cell phone',
    'microwave', 'oven', 'toaster', 'sink', 'refrigerator', 'N/A', 'book',
    'clock', 'vase', 'scissors', 'teddy bear', 'hair drier', 'toothbrush'
]

以下是 上训练的模型的准确度摘要 COCO train2017 的实例集，并在 COCO val2017 上评估。

网络	盒式 AP	掩码 AP	关键点 AP
更快的 R-CNN ResNet-50 FPN	37.0
RetinaNet ResNet-50 FPN	36.4
掩码 R-CNN ResNet-50 FPN	37.9	34.6

对于人员关键点检测，预训练的 型号如下

网络	盒式 AP	掩码 AP	关键点 AP
关键点 R-CNN ResNet-50 FPN	54.6		65.0

对于人员关键点检测，预训练模型返回 keypoints 按以下顺序排列：

COCO_PERSON_KEYPOINT_NAMES = [
    'nose',
    'left_eye',
    'right_eye',
    'left_ear',
    'right_ear',
    'left_shoulder',
    'right_shoulder',
    'left_elbow',
    'right_elbow',
    'left_wrist',
    'right_wrist',
    'left_hip',
    'right_hip',
    'left_knee',
    'right_knee',
    'left_ankle',
    'right_ankle'
]

运行时特性

对象检测、实例分割模型的实现 和关键点检测都非常高效。

在下表中，我们使用 8 个 V100 GPU，其中 CUDA 10.0 和 CUDNN 7.4 到 报告结果。在训练期间，我们为每个 GPU 使用 2 个批量大小，并且 在测试期间，使用批量大小 1。

对于测试时间，我们报告模型评估和后处理的时间 （包括图像中的蒙版粘贴），但不包括计算 precision-recall 调用。

网络	火车时间 （S / IT）	考试时间 （S / It）	内存 （GB）
更快的 R-CNN ResNet-50 FPN	0.2288	0.0590	5.2
RetinaNet ResNet-50 FPN	0.2514	0.0939	4.1
掩码 R-CNN ResNet-50 FPN	0.2728	0.0903	5.4
关键点 R-CNN ResNet-50 FPN	0.3789	0.1242	6.8

更快的 R-CNN

torchvision.models.detection.fasterrcnn_resnet50_fpn(pretrained=False， progress=True， num_classes=91， pretrained_backbone=True， trainable_backbone_layers=3， **kwargs）

构建一个具有 ResNet-50-FPN 主干的 Faster R-CNN 模型。

模型的输入应是一个张量列表，每个张量的形状为 ，每个张量对应一个 image 的 URL，并且应该在范围内。不同的图像可以具有不同的大小。[C, H, W]0-1

模型的行为会发生变化，具体取决于它是处于训练模式还是评估模式。

在训练期间，模型需要输入张量以及目标（字典列表）、 含：

• boxes （） （）：格式为真实框，值为 between 和 值，值为 between 和FloatTensor[N, 4][x1, y1, x2, y2]x0Wy0H
• labels （）：每个 ground-truth 框的类标签Int64Tensor[N]

模型在训练期间返回一个，其中包含分类和回归 RPN 和 R-CNN 的损失。Dict[Tensor]

在推理过程中，模型只需要输入张量，并返回后处理的 predictions 作为 ，每个输入图像对应一个。的字段为 遵循：List[Dict[Tensor]]Dict

• boxes （） （）：格式中的预测框，其值为 between 和 以及 between 和 的值 between 和FloatTensor[N, 4][x1, y1, x2, y2]x0Wy0H
• labels （）：每张图片的预测标签Int64Tensor[N]
• scores （）：分数或每个预测Tensor[N]

更快的 R-CNN 可导出到 ONNX，以获得固定的批量大小，并带有固定大小的输入图像。

例：

>>> model = torchvision.models.detection.fasterrcnn_resnet50_fpn(pretrained=True)
>>> # For training
>>> images, boxes = torch.rand(4, 3, 600, 1200), torch.rand(4, 11, 4)
>>> labels = torch.randint(1, 91, (4, 11))
>>> images = list(image for image in images)
>>> targets = []
>>> for i in range(len(images)):
>>>     d = {}
>>>     d['boxes'] = boxes[i]
>>>     d['labels'] = labels[i]
>>>     targets.append(d)
>>> output = model(images, targets)
>>> # For inference
>>> model.eval()
>>> x = [torch.rand(3, 300, 400), torch.rand(3, 500, 400)]
>>> predictions = model(x)
>>>
>>> # optionally, if you want to export the model to ONNX:
>>> torch.onnx.export(model, x, "faster_rcnn.onnx", opset_version = 11)

参数：

• pretrained （bool） – 如果为 True，则返回在 COCO train2017 上预训练的模型
• progress （bool） – 如果为 True，则显示下载到 stderr 的进度条
• pretrained_backbone （bool） – 如果为 True，则返回在 Imagenet 上预训练了主干的模型
• num_classes （int） – 模型的输出类数量（包括背景）
• trainable_backbone_layers （int） – 从最终块开始的可训练（未冻结）resnet 层的数量。 有效值介于 0 和 5 之间，其中 5 表示所有主干层都是可训练的。

RetinaNet

torchvision.models.detection.retinanet_resnet50_fpn(pretrained=False， progress=True， num_classes=91， pretrained_backbone=True， **kwargs）

构建具有 ResNet-50-FPN 主干的 RetinaNet 模型。

模型的输入应是一个张量列表，每个张量的形状为 ，每个张量对应一个 image 的 URL，并且应该在范围内。不同的图像可以具有不同的大小。[C, H, W]0-1

模型的行为会发生变化，具体取决于它是处于训练模式还是评估模式。

在训练期间，模型需要输入张量以及目标（字典列表）、 含：

• boxes （） （）：格式为 real-truth 的框，其中包含值 介于 和 和 和 之间FloatTensor[N, 4][x1, y1, x2, y2]0H0W
• labels （）：每个 ground-truth 框的类标签Int64Tensor[N]

模型在训练期间返回一个，其中包含分类和回归 损失。Dict[Tensor]

在推理过程中，模型只需要输入张量，并返回后处理的 predictions 作为 ，每个输入图像对应一个。的字段为 遵循：List[Dict[Tensor]]Dict

• boxes （） （）：格式为预测的框，值介于 和 之间FloatTensor[N, 4][x1, y1, x2, y2]0H0W
• labels （）：每张图片的预测标签Int64Tensor[N]
• scores （）：分数或每个预测Tensor[N]

例：

>>> model = torchvision.models.detection.retinanet_resnet50_fpn(pretrained=True)
>>> model.eval()
>>> x = [torch.rand(3, 300, 400), torch.rand(3, 500, 400)]
>>> predictions = model(x)

参数：

• pretrained （bool） – 如果为 True，则返回在 COCO train2017 上预训练的模型
• progress （bool） – 如果为 True，则显示下载到 stderr 的进度条

掩码 R-CNN

torchvision.models.detection.maskrcnn_resnet50_fpn(pretrained=False， progress=True， num_classes=91， pretrained_backbone=True， trainable_backbone_layers=3， **kwargs）

构建具有 ResNet-50-FPN 主干的掩码 R-CNN 模型。

模型的输入应是一个张量列表，每个张量的形状为 ，每个张量对应一个 image 的 URL，并且应该在范围内。不同的图像可以具有不同的大小。[C, H, W]0-1

模型的行为会发生变化，具体取决于它是处于训练模式还是评估模式。

在训练期间，模型需要输入张量以及目标（字典列表）、 含：

• boxes （） （）：格式为真实框，值为 between 和 值，值为 between 和FloatTensor[N, 4][x1, y1, x2, y2]x0Wy0H
• labels （）：每个 ground-truth 框的类标签Int64Tensor[N]
• masks （）：每个实例的分段二进制掩码UInt8Tensor[N, H, W]

模型在训练期间返回一个，其中包含分类和回归 RPN 和 R-CNN 的损失，以及掩码损失。Dict[Tensor]

在推理过程中，模型只需要输入张量，并返回后处理的 predictions 作为 ，每个输入图像对应一个。的字段为 遵循：List[Dict[Tensor]]Dict

• boxes （） （）：格式中的预测框，其值为 between 和 以及 between 和 的值 between 和FloatTensor[N, 4][x1, y1, x2, y2]x0Wy0H
• labels （）：每张图片的预测标签Int64Tensor[N]
• scores （）：分数或每个预测Tensor[N]
• masks （）：范围内每个实例的预测掩码。为了 获取最终的分割掩码，通常可以对软掩码进行阈值处理 值为 0.5 （UInt8Tensor[N, 1, H, W]0-1mask >= 0.5)

掩码 R-CNN 可导出到 ONNX，以获得固定的批量大小和固定大小的输入图像。

例：

>>> model = torchvision.models.detection.maskrcnn_resnet50_fpn(pretrained=True)
>>> model.eval()
>>> x = [torch.rand(3, 300, 400), torch.rand(3, 500, 400)]
>>> predictions = model(x)
>>>
>>> # optionally, if you want to export the model to ONNX:
>>> torch.onnx.export(model, x, "mask_rcnn.onnx", opset_version = 11)

参数：

• pretrained （bool） – 如果为 True，则返回在 COCO train2017 上预训练的模型
• progress （bool） – 如果为 True，则显示下载到 stderr 的进度条
• pretrained_backbone （bool） – 如果为 True，则返回在 Imagenet 上预训练了主干的模型
• num_classes （int） – 模型的输出类数量（包括背景）
• trainable_backbone_layers （int） – 从最终块开始的可训练（未冻结）resnet 层的数量。 有效值介于 0 和 5 之间，其中 5 表示所有主干层都是可训练的。

关键点 R-CNN

torchvision.models.detection.keypointrcnn_resnet50_fpn(pretrained=False， progress=True， num_classes=2， num_keypoints=17， pretrained_backbone=True， trainable_backbone_layers=3， **kwargs）

构建具有 ResNet-50-FPN 主干的关键点 R-CNN 模型。

模型的输入应是一个张量列表，每个张量的形状为 ，每个张量对应一个 image 的 URL，并且应该在范围内。不同的图像可以具有不同的大小。[C, H, W]0-1

模型的行为会发生变化，具体取决于它是处于训练模式还是评估模式。

在训练期间，模型需要输入张量以及目标（字典列表）、 含：

• boxes （） （）：格式为真实框，值为 between 和 值，值为 between 和FloatTensor[N, 4][x1, y1, x2, y2]x0Wy0H
• labels （）：每个 ground-truth 框的类标签Int64Tensor[N]
• 关键点 （）：每个实例的关键点位置，位于 format ，其中 key point 不可见。FloatTensor[N, K, 3]KN[x, y, visibility]visibility=0

模型在训练期间返回一个，其中包含分类和回归 RPN 和 R-CNN 的损失，以及关键点的损失。Dict[Tensor]

在推理过程中，模型只需要输入张量，并返回后处理的 predictions 作为 ，每个输入图像对应一个。的字段为 遵循：List[Dict[Tensor]]Dict

• boxes （） （）：格式中的预测框，其值为 between 和 以及 between 和 的值 between 和FloatTensor[N, 4][x1, y1, x2, y2]x0Wy0H
• labels （）：每张图片的预测标签Int64Tensor[N]
• scores （）：分数或每个预测Tensor[N]
• 关键点 （）：预测关键点的位置，格式为。FloatTensor[N, K, 3][x, y, v]

Keypoint R-CNN 可导出到 ONNX，以获得固定的批量大小，并带有固定大小的输入图像。

例：

>>> model = torchvision.models.detection.keypointrcnn_resnet50_fpn(pretrained=True)
>>> model.eval()
>>> x = [torch.rand(3, 300, 400), torch.rand(3, 500, 400)]
>>> predictions = model(x)
>>>
>>> # optionally, if you want to export the model to ONNX:
>>> torch.onnx.export(model, x, "keypoint_rcnn.onnx", opset_version = 11)

参数：

• pretrained （bool） – 如果为 True，则返回在 COCO train2017 上预训练的模型
• progress （bool） – 如果为 True，则显示下载到 stderr 的进度条
• pretrained_backbone （bool） – 如果为 True，则返回在 Imagenet 上预训练了主干的模型
• num_classes （int） – 模型的输出类数量（包括背景）
• trainable_backbone_layers （int） – 从最终块开始的可训练（未冻结）resnet 层的数量。 有效值介于 0 和 5 之间，其中 5 表示所有主干层都是可训练的。

视频分类

我们提供在 Kinetics-400 上预训练的动作识别模型。 他们都已使用 中提供的脚本进行了训练。references/video_classification

所有预训练模型都期望以相同的方式对输入图像进行归一化。 即形状为 （3 x T x H x W） 的 3 通道 RGB 视频的小批量， 其中 H 和 W 应为 112，T 是剪辑中的视频帧数。 图像必须加载到 [0， 1] 范围内，然后进行标准化 using 和 .mean = [0.43216, 0.394666, 0.37645]std = [0.22803, 0.22145, 0.216989]

注意

归一化参数与图像分类参数不同，并对应 到 Kinetics-400 的平均值和 std。

注意

目前，规范化代码可以在 中找到。 请参阅那里的函数。请注意，它与 图像，因为它假定视频是 4D 的。references/video_classification/transforms.pyNormalize

剪辑长度 16 （16x112x112） 的 Kinetics 1-crop 精度

网络	剪辑acc@1	剪辑acc@5
ResNet 3D 18	52.75	75.45
ResNet MC 18 系列	53.90	76.29
ResNet （2+1）D	57.50	78.81

ResNet 3D 分辨率

torchvision.models.video.r3d_18(pretrained=False， progress=True， **kwargs）

构建 18 层 Resnet3D 模型，如 https://arxiv.org/abs/1711.11248

参数：

• pretrained （bool） – 如果为 True，则返回在 Kinetics-400 上预训练的模型
• progress （bool） – 如果为 True，则显示下载到 stderr 的进度条

返回：

R3D-18 网络

返回类型：

nn.模块

ResNet 混合卷积

torchvision.models.video.mc3_18(pretrained=False， progress=True， **kwargs）

18 层混合卷积网络的构造函数，如 https://arxiv.org/abs/1711.11248

参数：

• pretrained （bool） – 如果为 True，则返回在 Kinetics-400 上预训练的模型
• progress （bool） – 如果为 True，则显示下载到 stderr 的进度条

返回：

MC3 网络定义

返回类型：

nn.模块

ResNet （2+1）D

torchvision.models.video.r2plus1d_18(pretrained=False， progress=True， **kwargs）

18 层深度 R（2+1）D 网络的构造函数，如 https://arxiv.org/abs/1711.11248

参数：

• pretrained （bool） – 如果为 True，则返回在 Kinetics-400 上预训练的模型
• progress （bool） – 如果为 True，则显示下载到 stderr 的进度条

返回：

R（2+1）D-18 网络

返回类型：

nn.模块