torchvision.models¶

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

分类¶

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

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

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_v2 = models.mobilenet_v2()
mobilenet_v3_large = models.mobilenet_v3_large()
mobilenet_v3_small = models.mobilenet_v3_small()
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_v2 = models.mobilenet_v2(pretrained=True)
mobilenet_v3_large = models.mobilenet_v3_large(pretrained=True)
mobilenet_v3_small = models.mobilenet_v3_small(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）

型	Acc@1	Acc@5
亚历克斯网络	56.522	79.066
VGG-11型	69.020	88.628
VGG-13型	69.928	89.246
VGG-16型	71.592	90.382
VGG-19型	72.376	90.876
VGG-11 批量归一化	70.370	89.810
VGG-13 批量归一化	71.586	90.374
VGG-16 批量归一化	73.360	91.516
VGG-19 批量归一化	74.218	91.842
ResNet-18 系列	69.758	89.078
ResNet-34 的	73.314	91.420
ResNet-50 系列	76.130	92.862
ResNet-101 系列	77.374	93.546
ResNet-152 系列	78.312	94.046
SqueezeNet 1.0	58.092	80.420
SqueezeNet 1.1	58.178	80.624
Densenet-121 系列	74.434	91.972
登网-169	75.600	92.806
Densenet-201 系列	76.896	93.370
登网-161	77.138	93.560
初始 v3	77.294	93.450
谷歌网络	69.778	89.530
随机播放网 V2 x1.0	69.362	88.316
随机播放网 V2 x0.5	60.552	81.746
移动网络 V2	71.878	90.286
MobileNet V3 大型版	74.042	91.340
MobileNet V3 小型版	67.668	87.402
ResNeXt-50-32x4d	77.618	93.698
ResNeXt-101-32x8d	79.312	94.526
宽 ResNet-50-2	78.468	94.086
宽网-101-2	78.848	94.284
MNASNet 1.0	73.456	91.510
MNASNet 0.5	67.734	87.490

亚历克斯内特¶

torchvision.models.alexnet(预训练：bool = False，进度：bool = True，**kwargs） → torchvision.models.alexnet.AlexNet[来源]¶

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

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

VGG的¶

torchvision.models.vgg11(预训练：bool = False，进度：bool = True，**kwargs） → torchvision.models.vgg.VGG[来源]¶

VGG 11 层模型（配置“A”），摘自“用于大规模图像识别的甚深卷积网络”<https://arxiv.org/pdf/1409.1556.pdf>._

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

torchvision.models.vgg11_bn(预训练：bool = False，进度：bool = True，**kwargs） → torchvision.models.vgg.VGG[来源]¶

VGG 11 层模型（配置 “A”），具有批量归一化 “用于大规模图像识别的甚深度卷积网络” <https://arxiv.org/pdf/1409.1556.pdf>._

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

torchvision.models.vgg13(预训练：bool = False，进度：bool = True，**kwargs） → torchvision.models.vgg.VGG[来源]¶

VGG 13 层模型（配置 “B”） “用于大规模图像识别的甚深卷积网络” <https://arxiv.org/pdf/1409.1556.pdf>._

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

torchvision.models.vgg13_bn(预训练：bool = False，进度：bool = True，**kwargs） → torchvision.models.vgg.VGG[来源]¶

VGG 13 层模型（配置“B”），具有批量归一化“用于大规模图像识别的甚深卷积网络”<https://arxiv.org/pdf/1409.1556.pdf>._

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

torchvision.models.vgg16(预训练：bool = False，进度：bool = True，**kwargs） → torchvision.models.vgg.VGG[来源]¶

VGG 16 层模型（配置 “D”） “用于大规模图像识别的甚深卷积网络” <https://arxiv.org/pdf/1409.1556.pdf>._

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

torchvision.models.vgg16_bn(预训练：bool = False，进度：bool = True，**kwargs） → torchvision.models.vgg.VGG[来源]¶

VGG 16 层模型（配置“D”），具有批量归一化“用于大规模图像识别的甚深度卷积网络”<https://arxiv.org/pdf/1409.1556.pdf>._

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

torchvision.models.vgg19(预训练：bool = False，进度：bool = True，**kwargs） → torchvision.models.vgg.VGG[来源]¶

VGG 19 层模型（配置 “E”） “用于大规模图像识别的甚深卷积网络” <https://arxiv.org/pdf/1409.1556.pdf>._

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

torchvision.models.vgg19_bn(预训练：bool = False，进度：bool = True，**kwargs） → torchvision.models.vgg.VGG[来源]¶

VGG 19 层模型（配置 'E'），具有批量归一化 “用于大规模图像识别的甚深度卷积网络” <https://arxiv.org/pdf/1409.1556.pdf>._

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

ResNet 公司¶

torchvision.models.resnet18(预训练：bool = False，进度：bool = True，**kwargs） → torchvision.models.resnet.ResNet[来源]¶

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

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

torchvision.models.resnet34(预训练：bool = False，进度：bool = True，**kwargs） → torchvision.models.resnet.ResNet[来源]¶

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

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

torchvision.models.resnet50(预训练：bool = False，进度：bool = True，**kwargs） → torchvision.models.resnet.ResNet[来源]¶

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

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

torchvision.models.resnet101(预训练：bool = False，进度：bool = True，**kwargs） → torchvision.models.resnet.ResNet[来源]¶

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

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

torchvision.models.resnet152(预训练：bool = False，进度：bool = True，**kwargs） → torchvision.models.resnet.ResNet[来源]¶

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

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

SqueezeNet （挤压网）¶

torchvision.models.squeezenet1_0(预训练：bool = False，进度：bool = True，**kwargs） → torchvision.models.squeezenet.SqueezeNet[来源]¶

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

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

torchvision.models.squeezenet1_1(预训练：bool = False，进度：bool = True，**kwargs） → torchvision.models.squeezenet.SqueezeNet[来源]¶

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

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

密集网¶

torchvision.models.densenet121(预训练：bool = False，进度：bool = True，**kwargs） → torchvision.models.densenet.DenseNet[来源]¶

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

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

torchvision.models.densenet169(预训练：bool = False，进度：bool = True，**kwargs） → torchvision.models.densenet.DenseNet[来源]¶

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

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

torchvision.models.densenet161(预训练：bool = False，进度：bool = True，**kwargs） → torchvision.models.densenet.DenseNet[来源]¶

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

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

torchvision.models.densenet201(预训练：bool = False，进度：bool = True，**kwargs） → torchvision.models.densenet.DenseNet[来源]¶

Densenet-201 模型。

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

初始 v3¶

torchvision.models.inception_v3(预训练：bool = False，进度：bool = True，**kwargs） → torchvision.models.inception.Inception3[来源]¶

“重新思考计算机视觉的 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(预训练：bool = False，进度：bool = True，**kwargs） → torchvision.models.googlenet.GoogLeNet[来源]¶

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(预训练：bool = False，进度：bool = True，**kwargs） → torchvision.models.shufflenetv2.ShuffleNetV2[来源]¶

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

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

torchvision.models.shufflenet_v2_x1_0(预训练：bool = False，进度：bool = True，**kwargs） → torchvision.models.shufflenetv2.ShuffleNetV2[来源]¶

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

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

torchvision.models.shufflenet_v2_x1_5(预训练：bool = False，进度：bool = True，**kwargs） → torchvision.models.shufflenetv2.ShuffleNetV2[来源]¶

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

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

torchvision.models.shufflenet_v2_x2_0(预训练：bool = False，进度：bool = True，**kwargs） → torchvision.models.shufflenetv2.ShuffleNetV2[来源]¶

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

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

MobileNet v2 版本¶

torchvision.models.mobilenet_v2(预训练：bool = False，进度：bool = True，**kwargs） → torchvision.models.mobilenetv2.MobileNetV2[来源]¶

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

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

MobileNet v3 版本¶

torchvision.models.mobilenet_v3_large(预训练：bool = False，进度：bool = True，**kwargs） → torchvision.models.mobilenetv3.MobileNetV3[来源]¶

从 “Searching for MobileNetV3” 构建一个大型 MobileNetV3 架构。

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

torchvision.models.mobilenet_v3_small(预训练：bool = False，进度：bool = True，**kwargs） → torchvision.models.mobilenetv3.MobileNetV3[来源]¶

从 “Searching for MobileNetV3” 构建一个小型的 MobileNetV3 架构。

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

Res下一页¶

torchvision.models.resnext50_32x4d(预训练：bool = False，进度：bool = True，**kwargs） → torchvision.models.resnet.ResNet[来源]¶

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

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

torchvision.models.resnext101_32x8d(预训练：bool = False，进度：bool = True，**kwargs） → torchvision.models.resnet.ResNet[来源]¶

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

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

宽 ResNet¶

torchvision.models.wide_resnet50_2(预训练：bool = False，进度：bool = True，**kwargs） → torchvision.models.resnet.ResNet[来源]¶

来自 “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(预训练：bool = False，进度：bool = True，**kwargs） → torchvision.models.resnet.ResNet[来源]¶

来自 “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(预训练：bool = False，进度：bool = True，**kwargs） → torchvision.models.mnasnet.MNASNet[来源]¶

来自“MnasNet：移动平台感知神经架构搜索”的深度乘数为 0.5 的 MNASNet。

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

torchvision.models.mnasnet0_75(预训练：bool = False，进度：bool = True，**kwargs） → torchvision.models.mnasnet.MNASNet[来源]¶

来自“MnasNet：移动平台感知神经架构搜索”的深度乘数为 0.75 的 MNASNet。

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

torchvision.models.mnasnet1_0(预训练：bool = False，进度：bool = True，**kwargs） → torchvision.models.mnasnet.MNASNet[来源]¶

来自“MnasNet：移动平台感知神经架构搜索”的深度乘数为 1.0 的 MNASNet。

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

torchvision.models.mnasnet1_3(预训练：bool = False，进度：bool = True，**kwargs） → torchvision.models.mnasnet.MNASNet[来源]¶

来自“MnasNet：移动平台感知神经架构搜索”的深度乘数为 1.3 的 MNASNet。

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

量化模型¶

以下架构支持 INT8 量化模型。您可以获得通过调用其构造函数来获得具有随机权重的模型：

import torchvision.models as models
googlenet = models.quantization.googlenet()
inception_v3 = models.quantization.inception_v3()
mobilenet_v2 = models.quantization.mobilenet_v2()
mobilenet_v3_large = models.quantization.mobilenet_v3_large()
resnet18 = models.quantization.resnet18()
resnet50 = models.quantization.resnet50()
resnext101_32x8d = models.quantization.resnext101_32x8d()
shufflenet_v2_x0_5 = models.quantization.shufflenet_v2_x0_5()
shufflenet_v2_x1_0 = models.quantization.shufflenet_v2_x1_0()
shufflenet_v2_x1_5 = models.quantization.shufflenet_v2_x1_5()
shufflenet_v2_x2_0 = models.quantization.shufflenet_v2_x2_0()

只需几行代码即可获得预训练的量化模型：

import torchvision.models as models
model = models.quantization.mobilenet_v2(pretrained=True, quantize=True)
model.eval()
# run the model with quantized inputs and weights
out = model(torch.rand(1, 3, 224, 224))

我们为以下模型提供预训练的量化权重：

型	Acc@1	Acc@5
移动网络 V2	71.658	90.150
MobileNet V3 大型版	73.004	90.858
随机播放网 V2	68.360	87.582
ResNet 18 系列	69.494	88.882
ResNet 50 系列	75.920	92.814
ResNext 101 32x8d	78.986	94.480
初始版本 V3	77.176	93.354
谷歌网络	69.826	89.404

语义分割¶

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

与图像分类模型一样，所有预先训练的模型都希望输入图像以相同的方式进行标准化。必须将图像加载到一个范围内，然后使用和进行标准化。他们已经接受了调整大小的图像的训练，因此其最小大小为 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
DeepLabV3 MobileNetV3-大型	60.3	91.2
LR-ASPP MobileNetV3-Large	57.9	91.2

全卷积网络¶

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 的进度条 num_classes （int） – 模型的输出类数量（包括背景） aux_loss （bool） – 如果为 True，则使用辅助损失

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 的进度条 num_classes （int） – 模型的输出类数量（包括背景） aux_loss （bool） – 如果为 True，则使用辅助损失

深度实验室 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 的进度条 num_classes （int） – 模型的输出类数量（包括背景） aux_loss （bool） – 如果为 True，则使用辅助损失

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 的进度条 num_classes （int） – 类的数量 aux_loss （bool） – 如果为 True，则包含辅助分类器

torchvision.models.segmentation.deeplabv3_mobilenet_v3_large(pretrained=False， progress=True， num_classes=21， aux_loss=None， **kwargs）[来源]¶

构建具有 MobileNetV3-Large 主干的 DeepLabV3 模型。

参数：	pretrained （bool） – 如果为 True，则返回在 COCO train2017 上预训练的模型，该模型包含与 Pascal VOC 相同的类 progress （bool） – 如果为 True，则显示下载到 stderr 的进度条 num_classes （int） – 模型的输出类数量（包括背景） aux_loss （bool） – 如果为 True，则使用辅助损失

LR-ASPP 型¶

torchvision.models.segmentation.lraspp_mobilenet_v3_large(pretrained=False， progress=True， num_classes=21， **kwargs）[来源]¶

构建一个具有 MobileNetV3-Large 主干网的 Lite R-ASPP 网络模型。

参数：	pretrained （bool） – 如果为 True，则返回在 COCO train2017 上预训练的模型，该模型包含与 Pascal VOC 相同的类 progress （bool） – 如果为 True，则显示下载到 stderr 的进度条 num_classes （int） – 模型的输出类数量（包括背景）

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

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

用于检测、实例分割和关键点检测使用分类模型进行初始化在 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
更快的 R-CNN ResNet-50 FPN	37.0
更快的 R-CNN MobileNetV3-Large FPN	32.8
更快的 R-CNN MobileNetV3-Large 320 FPN	22.8
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
更快的 R-CNN MobileNetV3-Large FPN	0.1020	0.0415	1.0
更快的 R-CNN MobileNetV3-Large 320 FPN	0.0978	0.0376	0.6
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=None， **kwargs）[来源]¶

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

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

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

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

框（）：格式为和的真实框。FloatTensor[N, 4][x1, y1, x2, y2]0 <= x1 < x2 <= W0 <= y1 < y2 <= H

labels （）：每个 ground-truth 框的类标签Int64Tensor[N]

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

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

框（）：格式为和的预测框。FloatTensor[N, 4][x1, y1, x2, y2]0 <= x1 < x2 <= W0 <= y1 < y2 <= H

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 的进度条
num_classes （int） – 模型的输出类数量（包括背景）
pretrained_backbone （bool） – 如果为 True，则返回在 Imagenet 上预训练了主干的模型
trainable_backbone_layers （int） – 从最终块开始的可训练（未冻结）resnet 层的数量。有效值介于 0 和 5 之间，其中 5 表示所有主干层都是可训练的。

torchvision.models.detection.fasterrcnn_mobilenet_v3_large_fpn(pretrained=False， progress=True， num_classes=91， pretrained_backbone=True， trainable_backbone_layers=None， **kwargs）[来源]¶

使用 MobileNetV3-Large FPN 主干构建高分辨率 Faster R-CNN 模型。它的工作原理类似于带有 ResNet-50 FPN 主干的 Faster R-CNN。有关详细信息，请参阅 fasterrcnn_resnet50_fpn。

例：

>>> model = torchvision.models.detection.fasterrcnn_mobilenet_v3_large_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 的进度条
num_classes （int） – 模型的输出类数量（包括背景）
pretrained_backbone （bool） – 如果为 True，则返回在 Imagenet 上预训练了主干的模型
trainable_backbone_layers （int） – 从最终块开始的可训练（未冻结）resnet 层的数量。有效值介于 0 和 6 之间，其中 6 表示所有主干层都是可训练的。

torchvision.models.detection.fasterrcnn_mobilenet_v3_large_320_fpn(pretrained=False， progress=True， num_classes=91， pretrained_backbone=True， trainable_backbone_layers=None， **kwargs）[来源]¶

构建一个低分辨率更快的 R-CNN 模型，其中包含针对移动用例调整的 MobileNetV3-Large FPN 主干。它的工作原理类似于带有 ResNet-50 FPN 主干的 Faster R-CNN。有关详细信息，请参阅 fasterrcnn_resnet50_fpn。

例：

>>> model = torchvision.models.detection.fasterrcnn_mobilenet_v3_large_320_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 的进度条
num_classes （int） – 模型的输出类数量（包括背景）
pretrained_backbone （bool） – 如果为 True，则返回在 Imagenet 上预训练了主干的模型
trainable_backbone_layers （int） – 从最终块开始的可训练（未冻结）resnet 层的数量。有效值介于 0 和 6 之间，其中 6 表示所有主干层都是可训练的。

RetinaNet¶

torchvision.models.detection.retinanet_resnet50_fpn(pretrained=False， progress=True， num_classes=91， pretrained_backbone=True， trainable_backbone_layers=None， **kwargs）[来源]¶

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

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

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

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

框（）：格式为和的真实框。FloatTensor[N, 4][x1, y1, x2, y2]0 <= x1 < x2 <= W0 <= y1 < y2 <= H

labels （）：每个 ground-truth 框的类标签Int64Tensor[N]

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

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

框（）：格式为和的预测框。FloatTensor[N, 4][x1, y1, x2, y2]0 <= x1 < x2 <= W0 <= y1 < y2 <= H

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 的进度条
num_classes （int） – 模型的输出类数量（包括背景）
pretrained_backbone （bool） – 如果为 True，则返回在 Imagenet 上预训练了主干的模型
trainable_backbone_layers （int） – 从最终块开始的可训练（未冻结）resnet 层的数量。有效值介于 0 和 5 之间，其中 5 表示所有主干层都是可训练的。

掩码 R-CNN¶

torchvision.models.detection.maskrcnn_resnet50_fpn(pretrained=False， progress=True， num_classes=91， pretrained_backbone=True， trainable_backbone_layers=None， **kwargs）[来源]¶

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

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

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

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

框（）：格式为和的真实框。FloatTensor[N, 4][x1, y1, x2, y2]0 <= x1 < x2 <= W0 <= y1 < y2 <= H

labels （）：每个 ground-truth 框的类标签Int64Tensor[N]

masks （）：每个实例的分段二进制掩码UInt8Tensor[N, H, W]

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

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

框（）：格式为和的预测框。FloatTensor[N, 4][x1, y1, x2, y2]0 <= x1 < x2 <= W0 <= y1 < y2 <= H

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 的进度条
num_classes （int） – 模型的输出类数量（包括背景）
pretrained_backbone （bool） – 如果为 True，则返回在 Imagenet 上预训练了主干的模型
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=None， **kwargs）[来源]¶

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

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

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

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

框（）：格式为和的真实框。FloatTensor[N, 4][x1, y1, x2, y2]0 <= x1 < x2 <= W0 <= y1 < y2 <= H

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

框（）：格式为和的预测框。FloatTensor[N, 4][x1, y1, x2, y2]0 <= x1 < x2 <= W0 <= y1 < y2 <= H

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 的进度条
num_classes （int） – 模型的输出类数量（包括背景）
num_keypoints （int） – 关键点数量，默认为 17
pretrained_backbone （bool） – 如果为 True，则返回在 Imagenet 上预训练了主干的模型
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.模块

torchvision.models¶

分类¶

亚历克斯内特¶

VGG的¶

ResNet 公司¶

SqueezeNet （挤压网）¶

密集网¶

初始 v3¶

谷歌网¶

ShuffleNet v2 版本¶

MobileNet v2 版本¶

MobileNet v3 版本¶

Res下一页¶

宽 ResNet¶

MNASNet¶

量化模型¶

语义分割¶

全卷积网络¶

深度实验室 V3¶

LR-ASPP 型¶

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

运行时特性¶

更快的 R-CNN¶

RetinaNet¶

掩码 R-CNN¶

关键点 R-CNN¶

视频分类¶

ResNet 3D 分辨率¶

ResNet 混合卷积¶

ResNet （2+1）D¶

文档

教程

资源