目录
目录

torchvision.models

模型子包包含了针对不同任务定义的模型，包括：图像分类、像素级语义分割、目标检测、实例分割、人体关键点检测和视频分类。

注意

向后兼容性保证了加载序列化的 state_dict 到使用旧版本 PyTorch 创建的模型。 相反，加载整个保存的模型或序列化的 ScriptModules（使用旧版本的 PyTorch 序列化） 可能无法保留历史行为。请参阅以下 文档

分类

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

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

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()
efficientnet_b0 = models.efficientnet_b0()
efficientnet_b1 = models.efficientnet_b1()
efficientnet_b2 = models.efficientnet_b2()
efficientnet_b3 = models.efficientnet_b3()
efficientnet_b4 = models.efficientnet_b4()
efficientnet_b5 = models.efficientnet_b5()
efficientnet_b6 = models.efficientnet_b6()
efficientnet_b7 = models.efficientnet_b7()
regnet_y_400mf = models.regnet_y_400mf()
regnet_y_800mf = models.regnet_y_800mf()
regnet_y_1_6gf = models.regnet_y_1_6gf()
regnet_y_3_2gf = models.regnet_y_3_2gf()
regnet_y_8gf = models.regnet_y_8gf()
regnet_y_16gf = models.regnet_y_16gf()
regnet_y_32gf = models.regnet_y_32gf()
regnet_x_400mf = models.regnet_x_400mf()
regnet_x_800mf = models.regnet_x_800mf()
regnet_x_1_6gf = models.regnet_x_1_6gf()
regnet_x_3_2gf = models.regnet_x_3_2gf()
regnet_x_8gf = models.regnet_x_8gf()
regnet_x_16gf = models.regnet_x_16gf()
regnet_x_32gf = models.regnet_x_32gf()

我们提供预训练模型，使用PyTorch torch.utils.model_zoo。 这些可以通过传递pretrained=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)
efficientnet_b0 = models.efficientnet_b0(pretrained=True)
efficientnet_b1 = models.efficientnet_b1(pretrained=True)
efficientnet_b2 = models.efficientnet_b2(pretrained=True)
efficientnet_b3 = models.efficientnet_b3(pretrained=True)
efficientnet_b4 = models.efficientnet_b4(pretrained=True)
efficientnet_b5 = models.efficientnet_b5(pretrained=True)
efficientnet_b6 = models.efficientnet_b6(pretrained=True)
efficientnet_b7 = models.efficientnet_b7(pretrained=True)
regnet_y_400mf = models.regnet_y_400mf(pretrained=True)
regnet_y_800mf = models.regnet_y_800mf(pretrained=True)
regnet_y_1_6gf = models.regnet_y_1_6gf(pretrained=True)
regnet_y_3_2gf = models.regnet_y_3_2gf(pretrained=True)
regnet_y_8gf = models.regnet_y_8gf(pretrained=True)
regnet_y_16gf = models.regnet_y_16gf(pretrained=True)
regnet_y_32gf = models.regnet_y_32gf(pretrained=True)
regnet_x_400mf = models.regnet_x_400mf(pretrained=True)
regnet_x_800mf = models.regnet_x_800mf(pretrained=True)
regnet_x_1_6gf = models.regnet_x_1_6gf(pretrained=True)
regnet_x_3_2gf = models.regnet_x_3_2gf(pretrained=True)
regnet_x_8gf = models.regnet_x_8gf(pretrained=True)
regnet_x_16gf = models.regnet_x_16gf(pretrainedTrue)
regnet_x_32gf = models.regnet_x_32gf(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]范围内，然后使用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))

不幸的是，所使用的具体 subset 已经丢失。有关更多信息，请参见 此讨论 或 这些实验。

EfficientNet模型的大小取决于变体。有关确切的输入大小，请点击此处

ImageNet 单crop 错误率

模型

Acc@1

Acc@5

AlexNet

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

Densenet-169

75.600

92.806

Densenet-201

76.896

93.370

Densenet-161

77.138

93.560

Inception V3模型

77.294

93.450

GoogleNet

69.778

89.530

ShuffleNet V2 x1.0

69.362

88.316

ShuffleNet V2 x0.5

60.552

81.746

MobileNet 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

宽残差网络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

EfficientNet-B0

77.692

93.532

EfficientNet-B1

78.642

94.186

EfficientNet-B2

80.608

95.310

EfficientNet-B3

82.008

96.054

EfficientNet-B4

83.384

96.594

EfficientNet-B5

83.444

96.628

EfficientNet-B6

84.008

96.916

EfficientNet-B7

84.122

96.908

regnet_x_400mf

72.834

90.950

regnet_x_800mf

75.212

92.348

regnet_x_1_6gf

77.040

93.440

regnet_x_3_2gf

78.364

93.992

regnet_x_8gf

79.344

94.686

regnet_x_16gf

80.058

94.944

regnet_x_32gf

80.622

95.248

regnet_y_400mf

74.046

91.716

regnet_y_800mf

76.420

93.136

regnet_y_1_6gf

77.950

93.966

regnet_y_3_2gf

78.948

94.576

regnet_y_8gf

80.032

95.048

regnet_y_16gf

80.424

95.240

regnet_y_32gf

80.878

95.340

Alexnet

torchvision.models.alexnet(pretrained: bool = False, progress: bool = True, **kwargs: Any) → torchvision.models.alexnet.AlexNet[source]

AlexNet模型架构来自 “一个奇怪的技巧…” 论文。 该模型所需的最小输入尺寸为63x63。

Parameters

  • 预训练模型 (bool) – 如果为 True，则返回在 ImageNet 上预训练的模型

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

VGG

torchvision.models.vgg11(pretrained: bool = False, progress: bool = True, **kwargs: Any) → torchvision.models.vgg.VGG[source]

VGG 11层模型（配置“A”）来自 “非常深的卷积网络用于大规模图像识别”。 该模型所需的最小输入尺寸为32x32。

Parameters

  • 预训练模型 (bool) – 如果为 True，则返回在 ImageNet 上预训练的模型

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

torchvision.models.vgg11_bn(pretrained: bool = False, progress: bool = True, **kwargs: Any) → torchvision.models.vgg.VGG[source]

VGG 11层模型（配置“A”）带有批量归一化 “非常深的卷积网络用于大规模图像识别”。 该模型所需的最小输入尺寸为32x32。

Parameters

  • 预训练模型 (bool) – 如果为 True，则返回在 ImageNet 上预训练的模型

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

torchvision.models.vgg13(pretrained: bool = False, progress: bool = True, **kwargs: Any) → torchvision.models.vgg.VGG[source]

VGG 13层模型（配置“B”） “用于大规模图像识别的非常深的卷积网络”。 该模型所需的最小输入尺寸为32x32。

Parameters

  • 预训练模型 (bool) – 如果为 True，则返回在 ImageNet 上预训练的模型

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

torchvision.models.vgg13_bn(pretrained: bool = False, progress: bool = True, **kwargs: Any) → torchvision.models.vgg.VGG[source]

VGG 13层模型（配置“B”）带批量归一化 “非常深的卷积网络用于大规模图像识别”. 该模型所需的最小输入尺寸为32x32。

Parameters

  • 预训练模型 (bool) – 如果为 True，则返回在 ImageNet 上预训练的模型

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

torchvision.models.vgg16(pretrained: bool = False, progress: bool = True, **kwargs: Any) → torchvision.models.vgg.VGG[source]

VGG 16层模型（配置“D”） “用于大规模图像识别的非常深的卷积网络”。 该模型所需的最小输入尺寸为32x32。

Parameters

  • 预训练模型 (bool) – 如果为 True，则返回在 ImageNet 上预训练的模型

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

torchvision.models.vgg16_bn(pretrained: bool = False, progress: bool = True, **kwargs: Any) → torchvision.models.vgg.VGG[source]

VGG 16层模型（配置“D”）带批量归一化 “非常深的卷积网络用于大规模图像识别”。 该模型所需的最小输入尺寸为32x32。

Parameters

  • 预训练模型 (bool) – 如果为 True，则返回在 ImageNet 上预训练的模型

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

torchvision.models.vgg19(pretrained: bool = False, progress: bool = True, **kwargs: Any) → torchvision.models.vgg.VGG[source]

VGG 19层模型（配置“E”） “用于大规模图像识别的非常深的卷积网络”。 该模型所需的最小输入尺寸为32x32。

Parameters

  • 预训练模型 (bool) – 如果为 True，则返回在 ImageNet 上预训练的模型

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

torchvision.models.vgg19_bn(pretrained: bool = False, progress: bool = True, **kwargs: Any) → torchvision.models.vgg.VGG[source]

VGG 19层模型（配置‘E’）带有批量归一化 “非常深的卷积网络用于大规模图像识别”. 该模型所需的最小输入尺寸为32x32。

Parameters

  • 预训练模型 (bool) – 如果为 True，则返回在 ImageNet 上预训练的模型

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

ResNet

torchvision.models.resnet18(pretrained: bool = False, progress: bool = True, **kwargs: Any) → torchvision.models.resnet.ResNet[source]

ResNet-18模型来自 “深度残差学习用于图像识别”。

Parameters

  • 预训练模型 (bool) – 如果为 True，则返回在 ImageNet 上预训练的模型

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

使用 resnet18 的示例:

torchvision.models.resnet34(pretrained: bool = False, progress: bool = True, **kwargs: Any) → torchvision.models.resnet.ResNet[source]

ResNet-34模型来自 “深度残差学习用于图像识别”。

Parameters

  • 预训练模型 (bool) – 如果为 True，则返回在 ImageNet 上预训练的模型

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

torchvision.models.resnet50(pretrained: bool = False, progress: bool = True, **kwargs: Any) → torchvision.models.resnet.ResNet[source]

ResNet-50模型来自 “深度残差学习用于图像识别”。

Parameters

  • 预训练模型 (bool) – 如果为 True，则返回在 ImageNet 上预训练的模型

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

torchvision.models.resnet101(pretrained: bool = False, progress: bool = True, **kwargs: Any) → torchvision.models.resnet.ResNet[source]

ResNet-101模型来自 “深度残差学习用于图像识别”。

Parameters

  • 预训练模型 (bool) – 如果为 True，则返回在 ImageNet 上预训练的模型

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

torchvision.models.resnet152(pretrained: bool = False, progress: bool = True, **kwargs: Any) → torchvision.models.resnet.ResNet[source]

ResNet-152模型来自 “深度残差学习用于图像识别”。

Parameters

  • 预训练模型 (bool) – 如果为 True，则返回在 ImageNet 上预训练的模型

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

SqueezeNet

torchvision.models.squeezenet1_0(pretrained: bool = False, progress: bool = True, **kwargs: Any) → torchvision.models.squeezenet.SqueezeNet[source]

SqueezeNet模型架构来自“SqueezeNet: 与AlexNet相当的准确性，但参数减少50倍且模型大小<0.5MB”论文。 该模型所需的最小输入尺寸为21x21。

Parameters

  • 预训练模型 (bool) – 如果为 True，则返回在 ImageNet 上预训练的模型

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

torchvision.models.squeezenet1_1(pretrained: bool = False, progress: bool = True, **kwargs: Any) → torchvision.models.squeezenet.SqueezeNet[source]

SqueezeNet 1.1 模型来自 官方 SqueezeNet 仓库。 SqueezeNet 1.1 的计算量比 SqueezeNet 1.0 少 2.4 倍，参数也略少， 但不牺牲准确性。 该模型所需的最小输入尺寸为 17x17。

Parameters

  • 预训练模型 (bool) – 如果为 True，则返回在 ImageNet 上预训练的模型

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

DenseNet

torchvision.models.densenet121(pretrained: bool = False, progress: bool = True, **kwargs: Any) → torchvision.models.densenet.DenseNet[source]

Densenet-121模型来自 “密集连接的卷积网络”。 该模型所需的最小输入尺寸为29x29。

Parameters

  • 预训练模型 (bool) – 如果为 True，则返回在 ImageNet 上预训练的模型

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

  • 内存高效 (bool) – 但速度较慢。默认值：False。参见“论文”。

torchvision.models.densenet169(pretrained: bool = False, progress: bool = True, **kwargs: Any) → torchvision.models.densenet.DenseNet[source]

Densenet-169 模型来自 “密集连接的卷积网络”。 该模型所需的最小输入尺寸为 29x29。

Parameters

  • 预训练模型 (bool) – 如果为 True，则返回在 ImageNet 上预训练的模型

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

  • 内存高效 (bool) –

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

torchvision.models.densenet161(pretrained: bool = False, progress: bool = True, **kwargs: Any) → torchvision.models.densenet.DenseNet[source]

Densenet-161模型来自 “密集连接的卷积网络”。 该模型所需的最小输入尺寸为29x29。

Parameters

  • 预训练模型 (bool) – 如果为 True，则返回在 ImageNet 上预训练的模型

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

  • 内存高效 (bool) –

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

torchvision.models.densenet201(pretrained: bool = False, progress: bool = True, **kwargs: Any) → torchvision.models.densenet.DenseNet[source]

Densenet-201模型来自 “密集连接的卷积网络”。 该模型所需的最小输入尺寸为29x29。

Parameters

  • 预训练模型 (bool) – 如果为 True，则返回在 ImageNet 上预训练的模型

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

  • 内存高效 (bool) –

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

Inception v3

torchvision.models.inception_v3(pretrained: bool = False, progress: bool = True, **kwargs: Any) → torchvision.models.inception.Inception3[source]

Inception v3 模型架构来自 “重新思考计算机视觉中的 Inception 架构”。 该模型所需的最小输入尺寸为 75x75。

注意

重要：与其它模型不同，inception_v3 模型期望张量的大小为 N x 3 x 299 x 299，因此请确保您的图片尺寸与此相符。

Parameters

  • 预训练模型 (bool) – 如果为 True，则返回在 ImageNet 上预训练的模型

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

  • aux_logits (bool) – 如果为 True，则添加一个可以改善训练的辅助分支。 默认值：True

  • transform_input (bool) – 如果为 True，则根据其在 ImageNet 上训练的方法预处理输入。默认值：False

注意

这需要安装scipy

GoogLeNet

torchvision.models.googlenet(pretrained: bool = False, progress: bool = True, **kwargs: Any) → torchvision.models.googlenet.GoogLeNet[source]

GoogLeNet (Inception v1) 模型架构来自 “通过卷积网络深入研究”。 该模型所需的最小输入尺寸为 15x15。

Parameters

  • 预训练模型 (bool) – 如果为 True，则返回在 ImageNet 上预训练的模型

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

  • aux_logits (bool) – 如果为 True，则添加两个辅助分支，这可以改善训练。 默认值：当 pretrained 为 True 时为 False，否则为 True

  • transform_input (bool) – 如果为 True，则根据其在 ImageNet 上训练的方法预处理输入。默认值：False

注意

这需要安装scipy

ShuffleNet v2

torchvision.models.shufflenet_v2_x0_5(pretrained: bool = False, progress: bool = True, **kwargs: Any) → torchvision.models.shufflenetv2.ShuffleNetV2[source]

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

Parameters

  • 预训练模型 (bool) – 如果为 True，则返回在 ImageNet 上预训练的模型

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

torchvision.models.shufflenet_v2_x1_0(pretrained: bool = False, progress: bool = True, **kwargs: Any) → torchvision.models.shufflenetv2.ShuffleNetV2[source]

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

Parameters

  • 预训练模型 (bool) – 如果为 True，则返回在 ImageNet 上预训练的模型

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

torchvision.models.shufflenet_v2_x1_5(pretrained: bool = False, progress: bool = True, **kwargs: Any) → torchvision.models.shufflenetv2.ShuffleNetV2[source]

构建了一个具有1.5倍输出通道的ShuffleNetV2，如在 “ShuffleNet V2：高效CNN架构设计的实际指南”中所述。

Parameters

  • 预训练模型 (bool) – 如果为 True，则返回在 ImageNet 上预训练的模型

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

torchvision.models.shufflenet_v2_x2_0(pretrained: bool = False, progress: bool = True, **kwargs: Any) → torchvision.models.shufflenetv2.ShuffleNetV2[source]

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

Parameters

  • 预训练模型 (bool) – 如果为 True，则返回在 ImageNet 上预训练的模型

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

MobileNet v2

torchvision.models.mobilenet_v2(pretrained: bool = False, progress: bool = True, **kwargs: Any) → torchvision.models.mobilenetv2.MobileNetV2[source]

构建了MobileNetV2架构，源自 “MobileNetV2：倒置残差和线性瓶颈”。

Parameters

  • 预训练模型 (bool) – 如果为 True，则返回在 ImageNet 上预训练的模型

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

MobileNet v3

torchvision.models.mobilenet_v3_large(pretrained: bool = False, progress: bool = True, **kwargs: Any) → torchvision.models.mobilenetv3.MobileNetV3[source]

构建一个大型的MobileNetV3架构，来自 “搜索MobileNetV3”。

Parameters

  • 预训练模型 (bool) – 如果为 True，则返回在 ImageNet 上预训练的模型

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

torchvision.models.mobilenet_v3_small(pretrained: bool = False, progress: bool = True, **kwargs: Any) → torchvision.models.mobilenetv3.MobileNetV3[source]

构建了一个小型的MobileNetV3架构，来自 “搜索MobileNetV3”。

Parameters

  • 预训练模型 (bool) – 如果为 True，则返回在 ImageNet 上预训练的模型

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

ResNext

torchvision.models.resnext50_32x4d(pretrained: bool = False, progress: bool = True, **kwargs: Any) → torchvision.models.resnet.ResNet[source]

ResNeXt-50 32x4d 模型来自 “聚合残差变换用于深度神经网络”。

Parameters

  • 预训练模型 (bool) – 如果为 True，则返回在 ImageNet 上预训练的模型

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

torchvision.models.resnext101_32x8d(pretrained: bool = False, progress: bool = True, **kwargs: Any) → torchvision.models.resnet.ResNet[source]

ResNeXt-101 32x8d 模型来自 “聚合残差变换用于深度神经网络”。

Parameters

  • 预训练模型 (bool) – 如果为 True，则返回在 ImageNet 上预训练的模型

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

宽残差网络

torchvision.models.wide_resnet50_2(pretrained: bool = False, progress: bool = True, **kwargs: Any) → torchvision.models.resnet.ResNet[source]

Wide ResNet-50-2 模型来自 “宽残差网络”。

该模型与ResNet相同，除了每个模块中的瓶颈通道数是其两倍。外部1x1卷积层的通道数保持不变，例如，ResNet-50的最后一层模块有2048-512-2048个通道，在Wide ResNet-50-2中则为2048-1024-2048。

Parameters

  • 预训练模型 (bool) – 如果为 True，则返回在 ImageNet 上预训练的模型

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

torchvision.models.wide_resnet101_2(pretrained: bool = False, progress: bool = True, **kwargs: Any) → torchvision.models.resnet.ResNet[source]

Wide ResNet-101-2 模型来自 “宽残差网络”。

该模型与ResNet相同，除了每个模块中的瓶颈通道数是其两倍。外部1x1卷积层的通道数保持不变，例如，ResNet-50的最后一层模块有2048-512-2048个通道，在Wide ResNet-50-2中则为2048-1024-2048。

Parameters

  • 预训练模型 (bool) – 如果为 True，则返回在 ImageNet 上预训练的模型

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

MNASNet

torchvision.models.mnasnet0_5(pretrained: bool = False, progress: bool = True, **kwargs: Any) → torchvision.models.mnasnet.MNASNet[source]

MNASNet 与深度乘数为 0.5 的模型来自 “MnasNet: Platform-Aware Neural Architecture Search for Mobile”。

Parameters

  • 预训练模型 (bool) – 如果为 True，则返回在 ImageNet 上预训练的模型

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

torchvision.models.mnasnet0_75(pretrained: bool = False, progress: bool = True, **kwargs: Any) → torchvision.models.mnasnet.MNASNet[source]

MNASNet 与深度乘数为 0.75 的模型来自 “MnasNet: Platform-Aware Neural Architecture Search for Mobile”。

Parameters

  • 预训练模型 (bool) – 如果为 True，则返回在 ImageNet 上预训练的模型

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

torchvision.models.mnasnet1_0(pretrained: bool = False, progress: bool = True, **kwargs: Any) → torchvision.models.mnasnet.MNASNet[source]

MNASNet 与深度乘数为 1.0 的模型来自 “MnasNet: Platform-Aware Neural Architecture Search for Mobile”。

Parameters

  • 预训练模型 (bool) – 如果为 True，则返回在 ImageNet 上预训练的模型

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

torchvision.models.mnasnet1_3(pretrained: bool = False, progress: bool = True, **kwargs: Any) → torchvision.models.mnasnet.MNASNet[source]

MNASNet，深度乘数为1.3，来自 “MnasNet: Platform-Aware Neural Architecture Search for Mobile”。

Parameters

  • 预训练模型 (bool) – 如果为 True，则返回在 ImageNet 上预训练的模型

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

EfficientNet

torchvision.models.efficientnet_b0(pretrained: bool = False, progress: bool = True, **kwargs: Any) → torchvision.models.efficientnet.EfficientNet[source]

构建EfficientNet B0架构，源自 “EfficientNet：重新思考卷积神经网络的模型缩放”。

Parameters

  • 预训练模型 (bool) – 如果为 True，则返回在 ImageNet 上预训练的模型

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

torchvision.models.efficientnet_b1(pretrained: bool = False, progress: bool = True, **kwargs: Any) → torchvision.models.efficientnet.EfficientNet[source]

构建EfficientNet B1架构，源自 “EfficientNet：重新思考卷积神经网络的模型缩放”。

Parameters

  • 预训练模型 (bool) – 如果为 True，则返回在 ImageNet 上预训练的模型

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

torchvision.models.efficientnet_b2(pretrained: bool = False, progress: bool = True, **kwargs: Any) → torchvision.models.efficientnet.EfficientNet[source]

构建EfficientNet B2架构，源自 “EfficientNet: 重新思考卷积神经网络的模型缩放”。

Parameters

  • 预训练模型 (bool) – 如果为 True，则返回在 ImageNet 上预训练的模型

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

torchvision.models.efficientnet_b3(pretrained: bool = False, progress: bool = True, **kwargs: Any) → torchvision.models.efficientnet.EfficientNet[source]

构建EfficientNet B3架构，源自 “EfficientNet：重新思考卷积神经网络的模型缩放”。

Parameters

  • 预训练模型 (bool) – 如果为 True，则返回在 ImageNet 上预训练的模型

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

torchvision.models.efficientnet_b4(pretrained: bool = False, progress: bool = True, **kwargs: Any) → torchvision.models.efficientnet.EfficientNet[source]

构建EfficientNet B4架构，源自 “EfficientNet：重新思考卷积神经网络的模型缩放”。

Parameters

  • 预训练模型 (bool) – 如果为 True，则返回在 ImageNet 上预训练的模型

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

torchvision.models.efficientnet_b5(pretrained: bool = False, progress: bool = True, **kwargs: Any) → torchvision.models.efficientnet.EfficientNet[source]

构建EfficientNet B5架构，源自 “EfficientNet：重新思考卷积神经网络的模型缩放”。

Parameters

  • 预训练模型 (bool) – 如果为 True，则返回在 ImageNet 上预训练的模型

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

torchvision.models.efficientnet_b6(pretrained: bool = False, progress: bool = True, **kwargs: Any) → torchvision.models.efficientnet.EfficientNet[source]

构建EfficientNet B6架构，源自 “EfficientNet：重新思考卷积神经网络的模型缩放”。

Parameters

  • 预训练模型 (bool) – 如果为 True，则返回在 ImageNet 上预训练的模型

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

torchvision.models.efficientnet_b7(pretrained: bool = False, progress: bool = True, **kwargs: Any) → torchvision.models.efficientnet.EfficientNet[source]

构建EfficientNet B7架构，源自 “EfficientNet：重新思考卷积神经网络的模型缩放”。

Parameters

  • 预训练模型 (bool) – 如果为 True，则返回在 ImageNet 上预训练的模型

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

RegNet

torchvision.models.regnet_y_400mf(pretrained: bool = False, progress: bool = True, **kwargs: Any) → torchvision.models.regnet.RegNet[source]

构建了一个来自“设计网络设计空间”的RegNetY_400MF架构。

Parameters

  • 预训练模型 (bool) – 如果为 True，则返回在 ImageNet 上预训练的模型

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

torchvision.models.regnet_y_800mf(pretrained: bool = False, progress: bool = True, **kwargs: Any) → torchvision.models.regnet.RegNet[source]

构建了一个来自“设计网络设计空间”的RegNetY_800MF架构。

Parameters

  • 预训练模型 (bool) – 如果为 True，则返回在 ImageNet 上预训练的模型

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

torchvision.models.regnet_y_1_6gf(pretrained: bool = False, progress: bool = True, **kwargs: Any) → torchvision.models.regnet.RegNet[source]

构建了一个来自“设计网络设计空间”的RegNetY_1.6GF架构。

Parameters

  • 预训练模型 (bool) – 如果为 True，则返回在 ImageNet 上预训练的模型

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

torchvision.models.regnet_y_3_2gf(pretrained: bool = False, progress: bool = True, **kwargs: Any) → torchvision.models.regnet.RegNet[source]

从“设计网络设计空间”构建RegNetY_3.2GF架构。

Parameters

  • 预训练模型 (bool) – 如果为 True，则返回在 ImageNet 上预训练的模型

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

torchvision.models.regnet_y_8gf(pretrained: bool = False, progress: bool = True, **kwargs: Any) → torchvision.models.regnet.RegNet[source]

从“设计网络设计空间”构建RegNetY_8GF架构。

Parameters

  • 预训练模型 (bool) – 如果为 True，则返回在 ImageNet 上预训练的模型

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

torchvision.models.regnet_y_16gf(pretrained: bool = False, progress: bool = True, **kwargs: Any) → torchvision.models.regnet.RegNet[source]

构建了一个来自“设计网络设计空间”的RegNetY_16GF架构。

Parameters

  • 预训练模型 (bool) – 如果为 True，则返回在 ImageNet 上预训练的模型

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

torchvision.models.regnet_y_32gf(pretrained: bool = False, progress: bool = True, **kwargs: Any) → torchvision.models.regnet.RegNet[source]

从“设计网络设计空间”构建RegNetY_32GF架构。

Parameters

  • 预训练模型 (bool) – 如果为 True，则返回在 ImageNet 上预训练的模型

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

torchvision.models.regnet_x_400mf(pretrained: bool = False, progress: bool = True, **kwargs: Any) → torchvision.models.regnet.RegNet[source]

构建一个来自“设计网络设计空间”的RegNetX_400MF架构。

Parameters

  • 预训练模型 (bool) – 如果为 True，则返回在 ImageNet 上预训练的模型

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

torchvision.models.regnet_x_800mf(pretrained: bool = False, progress: bool = True, **kwargs: Any) → torchvision.models.regnet.RegNet[source]

构建一个来自“设计网络设计空间”的RegNetX_800MF架构。

Parameters

  • 预训练模型 (bool) – 如果为 True，则返回在 ImageNet 上预训练的模型

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

torchvision.models.regnet_x_1_6gf(pretrained: bool = False, progress: bool = True, **kwargs: Any) → torchvision.models.regnet.RegNet[source]

构建了一个来自“设计网络设计空间”的RegNetX_1.6GF架构。

Parameters

  • 预训练模型 (bool) – 如果为 True，则返回在 ImageNet 上预训练的模型

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

torchvision.models.regnet_x_3_2gf(pretrained: bool = False, progress: bool = True, **kwargs: Any) → torchvision.models.regnet.RegNet[source]

构建一个来自“设计网络设计空间”的RegNetX_3.2GF架构。

Parameters

  • 预训练模型 (bool) – 如果为 True，则返回在 ImageNet 上预训练的模型

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

torchvision.models.regnet_x_8gf(pretrained: bool = False, progress: bool = True, **kwargs: Any) → torchvision.models.regnet.RegNet[source]

构建一个来自“设计网络设计空间”的RegNetX_8GF架构。

Parameters

  • 预训练模型 (bool) – 如果为 True，则返回在 ImageNet 上预训练的模型

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

torchvision.models.regnet_x_16gf(pretrained: bool = False, progress: bool = True, **kwargs: Any) → torchvision.models.regnet.RegNet[source]

构建一个来自“设计网络设计空间”的RegNetX_16GF架构。

Parameters

  • 预训练模型 (bool) – 如果为 True，则返回在 ImageNet 上预训练的模型

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

torchvision.models.regnet_x_32gf(pretrained: bool = False, progress: bool = True, **kwargs: Any) → torchvision.models.regnet.RegNet[source]

构建一个来自“设计网络设计空间”的RegNetX_32GF架构。

Parameters

  • 预训练模型 (bool) – 如果为 True，则返回在 ImageNet 上预训练的模型

  • 进度 (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

MobileNet V2

71.658

90.150

MobileNet V3 大型版

73.004

90.858

ShuffleNet V2

68.360

87.582

ResNet 18模型

69.494

88.882

ResNet 50模型

75.920

92.814

ResNeXt 101 32x8d

78.986

94.480

Inception V3模型

77.176

93.354

GoogleNet

69.826

89.404

语义分割

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

与图像分类模型一样，所有预训练模型都期望输入图像以相同的方式进行归一化。 图像需要加载到[0, 1]的范围内，然后使用 mean = [0.485, 0.456, 0.406]和std = [0.229, 0.224, 0.225]进行归一化。 它们是在最小尺寸为520的调整大小的图像上进行训练的。

有关如何绘制此类模型的掩码，请参阅 语义分割模型。

预训练模型是在COCO train2017数据集的一个子集上进行训练的，该子集包含了Pascal VOC数据集中存在的20个类别。您可以在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上评估的预训练模型的准确率如下所示：

网络

平均交并比

全局像素级精度

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 移动网V3-Large

60.3

91.2

LR-ASPP 移动网 V3 大型版

57.9

91.2

全卷积网络

torchvision.models.segmentation.fcn_resnet50(pretrained: bool = False, progress: bool = True, num_classes: int = 21, aux_loss: Optional[bool] = None, **kwargs: Any) → torch.nn.modules.module.Module[source]

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

Parameters

  • 预训练模型 (bool) – 如果为 True，则返回在 COCO train2017 上预训练的模型，该模型包含与 Pascal VOC 相同的类别

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

  • num_classes (int) – 模型的输出类别数（包括背景）

  • aux_loss (bool) – 如果为 True，则使用辅助损失

使用 fcn_resnet50 的示例:

torchvision.models.segmentation.fcn_resnet101(pretrained: bool = False, progress: bool = True, num_classes: int = 21, aux_loss: Optional[bool] = None, **kwargs: Any) → torch.nn.modules.module.Module[source]

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

Parameters

  • 预训练模型 (bool) – 如果为 True，则返回在 COCO train2017 上预训练的模型，该模型包含与 Pascal VOC 相同的类别

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

  • num_classes (int) – 模型的输出类别数（包括背景）

  • aux_loss (bool) – 如果为 True，则使用辅助损失

DeepLabV3

torchvision.models.segmentation.deeplabv3_resnet50(pretrained: bool = False, progress: bool = True, num_classes: int = 21, aux_loss: Optional[bool] = None, **kwargs: Any) → torch.nn.modules.module.Module[source]

构建一个具有 ResNet-50 主干网络的 DeepLabV3 模型。

Parameters

  • 预训练模型 (bool) – 如果为 True，则返回在 COCO train2017 上预训练的模型，该模型包含与 Pascal VOC 相同的类别

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

  • num_classes (int) – 模型的输出类别数（包括背景）

  • aux_loss (bool) – 如果为 True，则使用辅助损失

使用 deeplabv3_resnet50 的示例:

torchvision.models.segmentation.deeplabv3_resnet101(pretrained: bool = False, progress: bool = True, num_classes: int = 21, aux_loss: Optional[bool] = None, **kwargs: Any) → torch.nn.modules.module.Module[source]

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

Parameters

  • 预训练模型 (bool) – 如果为 True，则返回在 COCO train2017 上预训练的模型，该模型包含与 Pascal VOC 相同的类别

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

  • num_classes (int) – 类别的数量

  • aux_loss (bool) – 如果为 True，则包含一个辅助分类器

torchvision.models.segmentation.deeplabv3_mobilenet_v3_large(pretrained: bool = False, progress: bool = True, num_classes: int = 21, aux_loss: Optional[bool] = None, **kwargs: Any) → torch.nn.modules.module.Module[source]

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

Parameters

  • 预训练模型 (bool) – 如果为 True，则返回在 COCO train2017 上预训练的模型，该模型包含与 Pascal VOC 相同的类别

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

  • num_classes (int) – 模型的输出类别数（包括背景）

  • aux_loss (bool) – 如果为 True，则使用辅助损失

LR-ASPP

torchvision.models.segmentation.lraspp_mobilenet_v3_large(pretrained: bool = False, progress: bool = True, num_classes: int = 21, **kwargs: Any) → torch.nn.modules.module.Module[source]

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

Parameters

  • 预训练模型 (bool) – 如果为 True，则返回在 COCO train2017 上预训练的模型，该模型包含与 Pascal VOC 相同的类别

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

  • num_classes (int) – 模型的输出类别数（包括背景）

使用 lraspp_mobilenet_v3_large 的示例:

目标检测、实例分割和人体关键点检测

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

用于检测、实例分割和关键点检测的预训练模型由 torchvision 中的分类模型初始化。

模型期望一个 Tensor[C, H, W] 的列表，范围在 0-1 之间。 模型内部会调整图像大小，但行为因模型而异。 有关更多信息，请检查模型的构造函数。此类模型的输出格式如 实例分割模型 所示。

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

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上评估的模型准确率的总结。

网络

边界框 AP0.5

待翻译文本似乎不完整或有误，请提供完整的待翻译文本以便准确翻译。

关键点 AP3

更快的R-CNN ResNet-50 FPN

37.0

更快的R-CNN MobileNetV3-Large FPN

32.8

更快的 R-CNN 移动网 V3-Large 320 FPN

22.8

RetinaNet ResNet-50 FPN

36.4

SSD300 VGG16模型

25.1

SSDlite320 MobileNetV3 大型版本

21.3

带掩码的R-CNN基于ResNet-50 FPN模型

37.9

34.6

对于人体关键点检测，预训练模型的准确率如下所示

网络

边界框 AP0.5

待翻译文本似乎不完整或有误，请提供完整的待翻译文本以便准确翻译。

关键点 AP3

关键点 R-CNN 带 ResNet-50 和 FPN

54.6

65.0

对于人体关键点检测，预训练模型以以下顺序返回关键点：

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块GPU来报告结果。在训练过程中，对于所有模型，每块GPU的批处理大小为2，除了SSD模型使用4，SSD lite模型使用24。在测试过程中，批处理大小为1。

在测试时，我们报告模型评估和后处理（包括在图像中粘贴掩码）的时间，但不包括计算精确率-召回率的时间。

网络

训练时间（秒/迭代）

测试时间（秒/次）

内存（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 移动网 V3-Large 320 FPN

0.0978

0.0376

0.6

RetinaNet ResNet-50 FPN

0.2514

0.0939

4.1

SSD300 VGG16模型

0.2093

0.0744

1.5

SSDlite320 MobileNetV3 大型版本

0.1773

0.0906

1.5

带掩码的R-CNN基于ResNet-50 FPN模型

0.2728

0.0903

5.4

关键点 R-CNN 带 ResNet-50 和 FPN

0.3789

0.1242

6.8

Faster R-CNN

torchvision.models.detection.fasterrcnn_resnet50_fpn(pretrained=False, progress=True, num_classes=91, pretrained_backbone=True, trainable_backbone_layers=None, **kwargs)[source]

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

参考： “Faster R-CNN: 通过区域建议网络实现实时目标检测”。

模型的输入预期为张量列表，每个张量的形状为[C, H, W]，对应每一张图片，并且应在0-1范围内。不同的图片可以有不同的尺寸。

模型的行为会根据它是在训练模式还是评估模式而变化。

在训练过程中，模型期望输入张量以及目标（字典列表），包含：

  • boxes (FloatTensor[N, 4]): the ground-truth boxes in [x1, y1, x2, y2] format, with 0 <= x1 < x2 <= W and 0 <= y1 < y2 <= H.

  • labels (Int64Tensor[N]): the class label for each ground-truth box

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

在推理过程中，模型只需要输入张量，并返回每个输入图像的后处理预测结果，结果是一个包含List[Dict[Tensor]]字段的列表。其中Dict字段的内容如下，N表示检测到的目标数量：

  • boxes (FloatTensor[N, 4]): the predicted boxes in [x1, y1, x2, y2] format, with 0 <= x1 < x2 <= W and 0 <= y1 < y2 <= H.

  • labels (Int64Tensor[N]): the predicted labels for each detection

  • scores (Tensor[N]): the scores of each detection

有关输出的更多详细信息，请参阅 实例分割模型。

Faster R-CNN 可以导出为 ONNX，适用于批量大小固定且输入图像尺寸固定的场景。

Example:

>>> 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)
Parameters

  • 预训练模型 (bool) – 如果为True，返回在COCO train2017上预训练的模型

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

  • num_classes (int) – 模型的输出类别数（包括背景）

  • 预训练骨干网络 (bool) – 如果为 True，返回在 ImageNet 上预训练的骨干网络模型

  • trainable_backbone_layers (int) – 可训练（未冻结）的ResNet层的数量，从最终块开始。 有效值介于0和5之间，其中5表示所有骨干层都是可训练的。

使用 fasterrcnn_resnet50_fpn 的示例:

torchvision.models.detection.fasterrcnn_mobilenet_v3_large_fpn(pretrained=False, progress=True, num_classes=91, pretrained_backbone=True, trainable_backbone_layers=None, **kwargs)[source]

构建一个高分辨率的Faster R-CNN模型，使用MobileNetV3-Large FPN主干网络。 它与使用ResNet-50 FPN主干网络的Faster R-CNN工作方式类似。有关更多详细信息，请参见 fasterrcnn_resnet50_fpn()。

Example:

>>> 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)
Parameters

  • 预训练模型 (bool) – 如果为True，返回在COCO train2017上预训练的模型

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

  • num_classes (int) – 模型的输出类别数（包括背景）

  • 预训练骨干网络 (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)[source]

构建一个低分辨率的Faster R-CNN模型，采用针对移动应用场景优化的MobileNetV3-Large FPN主干网络。 它与使用ResNet-50 FPN主干网络的Faster R-CNN工作方式类似。有关更多详细信息，请参见 fasterrcnn_resnet50_fpn()。

Example:

>>> 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)
Parameters

  • 预训练模型 (bool) – 如果为True，返回在COCO train2017上预训练的模型

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

  • num_classes (int) – 模型的输出类别数（包括背景）

  • 预训练骨干网络 (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)[source]

构建一个具有 ResNet-50-FPN 主干网络的 RetinaNet 模型。

参考文献： “Focal Loss for Dense Object Detection”.

模型的输入预期为张量列表，每个张量的形状为[C, H, W]，对应每一张图片，并且应在0-1范围内。不同的图片可以有不同的尺寸。

模型的行为会根据它是在训练模式还是评估模式而变化。

在训练过程中，模型期望输入张量以及目标（字典列表），包含：

  • boxes (FloatTensor[N, 4]): the ground-truth boxes in [x1, y1, x2, y2] format, with 0 <= x1 < x2 <= W and 0 <= y1 < y2 <= H.

  • labels (Int64Tensor[N]): the class label for each ground-truth box

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

在推理过程中，模型只需要输入张量，并返回每个输入图像的后处理预测结果，结果是一个包含List[Dict[Tensor]]字段的列表。其中Dict字段的内容如下，N表示检测到的目标数量：

  • boxes (FloatTensor[N, 4]): the predicted boxes in [x1, y1, x2, y2] format, with 0 <= x1 < x2 <= W and 0 <= y1 < y2 <= H.

  • labels (Int64Tensor[N]): the predicted labels for each detection

  • scores (Tensor[N]): the scores of each detection

有关输出的更多详细信息，请参阅 实例分割模型。

Example:

>>> 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)
Parameters

  • 预训练模型 (bool) – 如果为True，返回在COCO train2017上预训练的模型

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

  • num_classes (int) – 模型的输出类别数（包括背景）

  • 预训练骨干网络 (bool) – 如果为 True，返回在 ImageNet 上预训练的骨干网络模型

  • trainable_backbone_layers (int) – 可训练（未冻结）的ResNet层的数量，从最终块开始。 有效值介于0和5之间，其中5表示所有骨干层都是可训练的。

使用 retinanet_resnet50_fpn 的示例:

SSD

torchvision.models.detection.ssd300_vgg16(pretrained: bool = False, progress: bool = True, num_classes: int = 91, pretrained_backbone: bool = True, trainable_backbone_layers: Optional[int] = None, **kwargs: Any)[source]

构建一个输入大小为 300x300 并基于 VGG16 主干网络的 SSD 模型。

参考： “SSD: Single Shot MultiBox Detector”。

模型的输入预期为张量列表，每个张量的形状为 [C, H, W]，对应每一张图像，并且应在 0-1 范围内。不同的图像可以有不同的尺寸，但在传递给骨干网络之前会被调整为固定大小。

模型的行为会根据它是在训练模式还是评估模式而变化。

在训练过程中，模型期望输入张量以及目标（字典列表），包含：

  • boxes (FloatTensor[N, 4]): the ground-truth boxes in [x1, y1, x2, y2] format, with 0 <= x1 < x2 <= W and 0 <= y1 < y2 <= H.

  • labels (Int64Tensor[N]): the class label for each ground-truth box

该模型在训练过程中返回一个包含分类和回归损失的 Dict[Tensor]。

在推理过程中，模型只需要输入张量，并返回后处理过的预测结果，作为List[Dict[Tensor]]，每个输入图像对应一个。字典中的字段如下所示，其中N是检测的数量：

  • boxes (FloatTensor[N, 4]): the predicted boxes in [x1, y1, x2, y2] format, with 0 <= x1 < x2 <= W and 0 <= y1 < y2 <= H.

  • labels (Int64Tensor[N]): the predicted labels for each detection

  • scores (Tensor[N]): the scores for each detection

示例

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

  • 预训练模型 (bool) – 如果为True，返回在COCO train2017上预训练的模型

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

  • num_classes (int) – 模型的输出类别数（包括背景）

  • 预训练骨干网络 (bool) – 如果为 True，返回在 ImageNet 上预训练的骨干网络模型

  • trainable_backbone_layers (int) – 可训练（未冻结）的ResNet层的数量，从最终块开始。 有效值介于0和5之间，其中5表示所有骨干层都是可训练的。

使用 ssd300_vgg16 的示例:

SSDlite

torchvision.models.detection.ssdlite320_mobilenet_v3_large(pretrained: bool = False, progress: bool = True, num_classes: int = 91, pretrained_backbone: bool = False, trainable_backbone_layers: Optional[int] = None, norm_layer: Optional[Callable[[…], torch.nn.modules.module.Module]] = None, **kwargs: Any)[source]

构建一个输入大小为320x320的SSDlite模型，并使用MobileNetV3 Large作为主干网络，如 “搜索MobileNetV3” 和 “MobileNetV2：倒置残差和线性瓶颈”。

详见 ssd300_vgg16() 以获取更多详细信息。

示例

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

  • 预训练模型 (bool) – 如果为True，返回在COCO train2017上预训练的模型

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

  • num_classes (int) – 模型的输出类别数（包括背景）

  • 预训练骨干网络 (bool) – 如果为 True，返回在 ImageNet 上预训练的骨干网络模型

  • trainable_backbone_layers (int) – 可训练（未冻结）的ResNet层的数量，从最终块开始。 有效值介于0和6之间，其中6表示所有骨干层都是可训练的。

  • norm_layer (可调用对象,可选) – 指定要使用的归一化层模块。

使用 ssdlite320_mobilenet_v3_large 的示例:

Mask R-CNN

torchvision.models.detection.maskrcnn_resnet50_fpn(pretrained=False, progress=True, num_classes=91, pretrained_backbone=True, trainable_backbone_layers=None, **kwargs)[source]

构建一个带有 ResNet-50-FPN 主干网络的 Mask R-CNN 模型。

参考文献： “Mask R-CNN”.

模型的输入预期为张量列表，每个张量的形状为[C, H, W]，对应每一张图片，并且应在0-1范围内。不同的图片可以有不同的尺寸。

模型的行为会根据它是在训练模式还是评估模式而变化。

在训练过程中，模型期望输入张量以及目标（字典列表），包含：

  • boxes (FloatTensor[N, 4]): the ground-truth boxes in [x1, y1, x2, y2] format, with 0 <= x1 < x2 <= W and 0 <= y1 < y2 <= H.

  • labels (Int64Tensor[N]): the class label for each ground-truth box

  • masks (UInt8Tensor[N, H, W]): the segmentation binary masks for each instance

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

在推理过程中，模型只需要输入张量，并返回每个输入图像的后处理预测结果，即一个包含List[Dict[Tensor]]的数组。Dict字段如下所示，其中N是检测到的实例数量：

  • boxes (FloatTensor[N, 4]): the predicted boxes in [x1, y1, x2, y2] format, with 0 <= x1 < x2 <= W and 0 <= y1 < y2 <= H.

  • labels (Int64Tensor[N]): the predicted labels for each instance

  • scores (Tensor[N]): the scores or each instance

  • masks (UInt8Tensor[N, 1, H, W]): the predicted masks for each instance, in 0-1 range. In order to obtain the final segmentation masks, the soft masks can be thresholded, generally with a value of 0.5 (mask >= 0.5)

有关输出和如何绘制掩码的更多详细信息，请参阅 实例分割模型。

Mask R-CNN 可以导出为 ONNX，用于批量大小固定且输入图像尺寸固定的场景。

Example:

>>> 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)
Parameters

  • 预训练模型 (bool) – 如果为True，返回在COCO train2017上预训练的模型

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

  • num_classes (int) – 模型的输出类别数（包括背景）

  • 预训练骨干网络 (bool) – 如果为 True，返回在 ImageNet 上预训练的骨干网络模型

  • trainable_backbone_layers (int) – 可训练（未冻结）的ResNet层的数量，从最终块开始。 有效值介于0和5之间，其中5表示所有骨干层都是可训练的。

使用 maskrcnn_resnet50_fpn 的示例:

关键点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)[source]

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

参考文献： “Mask R-CNN”.

模型的输入预期为张量列表，每个张量的形状为[C, H, W]，对应每一张图片，并且应在0-1范围内。不同的图片可以有不同的尺寸。

模型的行为会根据它是在训练模式还是评估模式而变化。

在训练过程中，模型期望输入张量以及目标（字典列表），包含：

  • boxes (FloatTensor[N, 4]): the ground-truth boxes in [x1, y1, x2, y2] format, with 0 <= x1 < x2 <= W and 0 <= y1 < y2 <= H.

  • labels (Int64Tensor[N]): the class label for each ground-truth box

  • keypoints (FloatTensor[N, K, 3]): the K keypoints location for each of the N instances, in the format [x, y, visibility], where visibility=0 means that the keypoint is not visible.

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

在推理过程中，模型只需要输入张量，并返回每个输入图像的后处理预测结果，即一个包含List[Dict[Tensor]]的数组。Dict字段如下所示，其中N是检测到的实例数量：

  • boxes (FloatTensor[N, 4]): the predicted boxes in [x1, y1, x2, y2] format, with 0 <= x1 < x2 <= W and 0 <= y1 < y2 <= H.

  • labels (Int64Tensor[N]): the predicted labels for each instance

  • scores (Tensor[N]): the scores or each instance

  • keypoints (FloatTensor[N, K, 3]): the locations of the predicted keypoints, in [x, y, v] format.

有关输出的更多详细信息，请参阅 实例分割模型。

Keypoint R-CNN 可以导出为 ONNX，适用于批量大小固定且输入图像尺寸固定的场景。

Example:

>>> 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)
Parameters

  • 预训练模型 (bool) – 如果为True，返回在COCO train2017上预训练的模型

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

  • num_classes (int) – 模型的输出类别数（包括背景）

  • num_keypoints (int) – 关键点数量，默认为17

  • 预训练骨干网络 (bool) – 如果为 True，返回在 ImageNet 上预训练的骨干网络模型

  • trainable_backbone_layers (int) – 可训练（未冻结）的ResNet层的数量，从最终块开始。 有效值介于0和5之间，其中5表示所有骨干层都是可训练的。

使用 keypointrcnn_resnet50_fpn 的示例:

视频分类

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

所有预训练模型都期望输入图像以相同的方式进行归一化处理，即每批包含3个通道的RGB视频，形状为(3 x T x H x W)，其中H和W预期为112，T是一个剪辑中的视频帧数。图像必须加载到[0, 1]范围内，然后使用mean = [0.43216, 0.394666, 0.37645]和std = [0.22803, 0.22145, 0.216989]进行归一化。

注意

归一化参数与图像分类的不同对应于来自Kinetics-400的均值和标准差。

注意

目前，归一化代码可以在references/video_classification/transforms.py中找到， 参见其中的Normalize函数。请注意，它与标准图像归一化不同， 因为它假设视频是4维的。

Kinetics 数据集 1-crop 准确率（剪辑长度为 16 帧，16x112x112）

网络

剪裁准确率@1

剪裁准确率 top-5

三维残差网络 18 层

52.75

75.45

ResNet 18 多卡版本

53.90

76.29

(2+1)D ResNet

57.50

78.81

三维残差网络 ResNet

torchvision.models.video.r3d_18(pretrained: bool = False, progress: bool = True, **kwargs: Any) → torchvision.models.video.resnet.VideoResNet[source]

构建具有18层的Resnet3D模型，参见 https://arxiv.org/abs/1711.11248

Parameters

  • 预训练模型 (bool) – 如果为 True，返回在 Kinetics-400 上预训练的模型

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

Returns

R3D-18 网络模型

Return type

nn.Module

ResNet 混合卷积

torchvision.models.video.mc3_18(pretrained: bool = False, progress: bool = True, **kwargs: Any) → torchvision.models.video.resnet.VideoResNet[source]

构建具有18层混合卷积网络，详情参见 https://arxiv.org/abs/1711.11248

Parameters

  • 预训练模型 (bool) – 如果为 True，返回在 Kinetics-400 上预训练的模型

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

Returns

MC3 网络定义

Return type

nn.Module

ResNet (2+1)D

torchvision.models.video.r2plus1d_18(pretrained: bool = False, progress: bool = True, **kwargs: Any) → torchvision.models.video.resnet.VideoResNet[source]

构造18层深R(2+1)D网络，如 https://arxiv.org/abs/1711.11248

Parameters

  • 预训练模型 (bool) – 如果为 True，返回在 Kinetics-400 上预训练的模型

  • 进度 (bool) – 如果为True，则在stderr中显示下载进度条

Returns

R(2+1)D-18 网络

Return type

nn.Module

文档

访问 PyTorch 的全面开发人员文档

查看文档

教程

获取面向初学者和高级开发人员的深入教程

查看教程

资源

查找开发资源并解答您的问题

查看资源