jittor.models

这里是Jittor的骨干网络模块的API文档，您可以用此库创建各种经典backbone网络结构。

class jittor.models.AlexNet(num_classes=1000)[源代码]

AlexNet模型源于 ImageNet Classification with Deep Convolutional Neural Networks, 其架构来自于论文 One weird trick for parallelizing convolutional neural networks。

参数:

  • num_classes (int, optional): 分类任务中类别的数量, 默认值: 1000。

属性:

  • features (nn.Sequential): AlexNet模型的特征提取部分。

  • avgpool (nn.AdaptiveAvgPool2d): 用于将特征提取部分的输出转换为固定大小的特征图。

  • classifier (nn.Sequential): AlexNet模型的分类部分。

代码示例:
>>> import jittor as jt
>>> from jittor import nn
>>> from jittor.models import AlexNet  
>>> model = AlexNet(500) # 创建一个有500个类别的AlexNet模型
>>> x = jt.random([10, 3, 224, 224]) # 创建一个随机的图像数据批次
>>> y = model(x) # 得到模型的输出
>>> # y的形状将会是 [10, 500], 表示10幅图像在500个类别上的分类结果
class jittor.models.DenseNet(growth_rate=32, block_config=(6, 12, 24, 16), num_init_features=64, bn_size=4, drop_rate=0, num_classes=1000)[源代码]

DenseNet源自论文 Densely Connected Convolutional Networks, DenseNet的特点是每个层都与前面的层连接, 这种连接方式使得网络的特征传递更加高效, 同时也有助于解决梯度消失的问题。DenseNet的网络结构包含了多个DenseBlock和Transition层, 其中DenseBlock用于特征提取, Transition层用于特征维度的缩减。

参数:

  • growth_rate (int): 每层添加的过滤器数量(论文中的 k)。

  • block_config (list of 4 ints): 每个池化块中的层数。

  • num_init_features (int): 第一个卷积层学习的过滤器数量。

  • bn_size (int): 瓶颈层的数量的乘法因子(即瓶颈层中的特征数量为 bn_size * k)。

  • drop_rate (float): 每个密集层后的丢弃率。

  • num_classes (int): 分类类别数。

属性:

  • features (nn.Sequential): 特征提取层。

  • classifier (nn.Linear): 分类层。

代码示例:
>>> import jittor as jt
>>> from jittor.models.densenet import DenseNet
>>> model = DenseNet(growth_rate=32, block_config=(6, 12, 24, 16),
...                  num_init_features=64, bn_size=4, drop_rate=0.5,
...                  num_classes=1000)
>>> input = jt.randn(1, 3, 224, 224)
>>> output = model(input)
>>> output.shape
[1,1000,]
class jittor.models.GoogLeNet(num_classes=1000, aux_logits=True, init_weights=True, blocks=None)[源代码]

GoogLeNet源自论文 Going Deeper with Convolutions , 也称为Inception v1, 它由多个称为Inception模块的子网络构成。

注意:

  • 输入数据的维度应当是[batch_size, 3, height, width], 且height和width应该足够大, 以保证在网络结构中可以经历多次池化操作后依然保有空间分辨率。

  • 如果关闭了aux_logits, aux1和aux2的输出将为None。

参数:

  • num_classes (int, optional): 分类的类别数量, 默认值: 1000。

  • aux_logits (bool, optional): 若为True, 则添加辅助分支以帮助训练。默认值: 1000。

  • init_weights (bool, optional): 若为True, 则对模型的权重进行初始化。默认值: True。

  • blocks (list[nn.Module]): 由三个模块组成的列表, 依次为[conv_block, inception_block, inception_aux_block]。若为None, 则使用[BasicConv2d, Inception, InceptionAux]作为默认值。默认值: None。

属性:

  • conv1 (nn.Module): 输入层的卷积层。

  • maxpool1 (nn.Pool): 输入层的最大池化层。

  • conv2 (nn.Module): 第二个卷积层。

  • conv3 (nn.Module): 第三个卷积层。

  • maxpool2 (nn.Pool): 第二个最大池化层。

  • inception3a (nn.Module): 第一个Inception模块。

  • inception3b (nn.Module): 第二个Inception模块。

  • maxpool3 (nn.Pool): 第三个最大池化层。

  • inception4a (nn.Module): 第三个Inception模块。

  • inception4b (nn.Module): 第四个Inception模块。

  • inception4c (nn.Module): 第五个Inception模块。

  • inception4d (nn.Module): 第六个Inception模块。

  • inception4e (nn.Module): 第七个Inception模块。

  • maxpool4 (nn.Pool): 第四个最大池化层。

  • inception5a (nn.Module): 第八个Inception模块。

  • inception5b (nn.Module): 第九个Inception模块。

  • aux1 (nn.Module): 第一个辅助分类器。

  • aux2 (nn.Module): 第二个辅助分类器。

  • avgpool (nn.AdaptiveAvgPool2d): 全局平均池化层。

  • dropout (nn.Dropout): 丢弃层。

  • fc (nn.Linear): 全连接层。

代码示例:
>>> import jittor as jt
>>> from jittor.models.googlenet import GoogLeNet
>>> model = GoogLeNet(num_classes=1000, aux_logits=True, init_weights=True)
>>> input_tensor = jt.randn(1, 3, 224, 224)
>>> model(input_tensor).shape    
[1,1000,]
class jittor.models.Inception3(num_classes=1000, aux_logits=True, inception_blocks=None, init_weights=True)[源代码]

Inception v3源自论文 Rethinking the Inception Architecture for Computer Vision。inception模块通过不同尺寸的卷积核和池化层并行处理输入, 并合并输出, 旨在在不同的尺度上有效提取特征。

参数:

  • num_classes (int, optional): 分类的类别数目。默认值: 1000

  • aux_logits (bool, optional): 若为True, 则添加一个辅助分支, 可以改善训练。默认值: True

  • inception_blocks (List[nn.Module], optional): 模型的七个块的列表, 顺序为[conv_block, inception_a, inception_b, inception_c, inception_d, inception_e, inception_aux], 若为None, 则会使用默认的基础块 [BasicConv2d, InceptionA, InceptionB, InceptionC, InceptionD, InceptionE, InceptionAux]。默认值: None

  • init_weights (bool, optional): 是否初始化权重。默认值: True

属性:

  • Conv2d_1a_3x3 (nn.Module): 输入层的卷积层。

  • Conv2d_2a_3x3 (nn.Module): 第二个卷积层。

  • Conv2d_2b_3x3 (nn.Module): 第三个卷积层。

  • Conv2d_3b_1x1 (nn.Module): 第四个卷积层。

  • Conv2d_4a_3x3 (nn.Module): 第五个卷积层。

  • Mixed_5b (nn.Module): 第一个Inception模块。

  • Mixed_5c (nn.Module): 第二个Inception模块。

  • Mixed_5d (nn.Module): 第三个Inception模块。

  • Mixed_6a (nn.Module): 第四个Inception模块。

  • Mixed_6b (nn.Module): 第五个Inception模块。

  • Mixed_6c (nn.Module): 第六个Inception模块。

  • Mixed_6d (nn.Module): 第七个Inception模块。

  • Mixed_6e (nn.Module): 第八个Inception模块。

  • AuxLogits (nn.Module): 辅助分支。

  • Mixed_7a (nn.Module): 第九个Inception模块。

  • Mixed_7b (nn.Module): 第十个Inception模块。

  • Mixed_7c (nn.Module): 第十一个Inception模块。

  • fc (nn.Linear): 全连接层。

代码示例:
>>> import jittor as jt
>>> from jittor.models.inception import Inception3
>>> model = Inception3(num_classes=1000, aux_logits=True)
>>> inputs = jt.rand([1, 3, 299, 299])
>>> model(inputs).shape
[1,1000,]
class jittor.models.MNASNet(alpha, num_classes=1000, dropout=0.2)[源代码]

MnasNet源自论文 MnasNet: Platform-Aware Neural Architecture Search for Mobile, 其使用深度可分卷积和线性瓶颈层来减少计算复杂性, 同时仍然保持了表示能力。

在MNASNet中的深度可分离卷积操作可通过以下方式表达:

\[y = DConv(x) * PWConv(x)\]

其中 \(DConv\) 表示逐深度卷积, \(PWConv\) 表示点卷积操作。

参数:

  • alpha (float): 深度乘数, 用于控制网络层的深度缩放因子。在初始化时传入的 alpha 参数必须大于0。

  • num_classes (int, optional): 分类类别的数量。默认值: 1000。

  • dropout (float, optional): Dropout层的丢弃概率。默认值: 0.2。

属性:

  • layers (nn.Sequential): MNASNet的特征提取部分。

  • classifier (nn.Sequential): MNASNet的分类部分。

代码示例:
>>> import jittor as jt
>>> from jittor.models.mnasnet import MNASNet
>>> network = MNASNet(alpha=1.0, num_classes=1000, dropout=0.2)
>>> input = jt.randn(10, 3, 256, 256)  # 假设是一个形状为[批次大小, 通道数, 高度, 宽度]的张量
>>> network(input).shape
[10,1000,]
class jittor.models.MobileNetV2(num_classes=1000, width_mult=1.0, inverted_residual_setting=None, round_nearest=8, block=None)[源代码]

MobileNetV2源自论文 Mobilenetv2: Inverted residuals and linear bottlenecks。mobilenet_v2基于倒置残差结构, 其中使用线性瓶颈在压缩表示中传递消息。

参数:

  • num_classes (int, optional): 类别数。默认值: 1000。

  • width_mult (float, optional): 宽度乘数 - 按此比例调整每层中通道数。默认值: 1.0。

  • init_weights (bool, optional): 是否初始化权重。默认值: True。

  • inverted_residual_setting (List[List[int]], optional): 定义网络结构的参数列表, 其中每个元素是一个拥有4个整数的列表, 分别表示扩展因子(t)、输出通道数(c)、重复次数(n)和步幅(s)。默认值: None, 会自动采用MobileNetV2的标准配置。

  • round_nearest (int, optional): 将每层的通道数四舍五入为该数的倍数。设为1则取消四舍五入。默认值: 8。

  • block (callable[…, nn.Module], optional): 用于指定MobileNet中倒置残差构建块的模块。如果为None, 则使用InvertedResidual。默认值: None。

属性:

  • features (nn.Sequential): MobileNetV2的特征提取部分。

  • classifier (nn.Sequential): MobileNetV2的分类部分。

代码示例: 
>>> import jittor as jt
>>> from jittor.models.mobilenet import MobileNetV2
>>> model = MobileNetV2(num_classes=1000, width_mult=1.0)
>>> print(model)
MobileNetV2(
    features: Sequential(
        0: ConvBNReLU(
        ...)))
class jittor.models.ResNet(block, layers, num_classes=1000, zero_init_residual=False, groups=1, width_per_group=64, replace_stride_with_dilation=None, norm_layer=None)[源代码]

ResNet源自论文 Deep Residual Learning for Image Recognition, 其通过添加shortcut来改善梯度回传, 允许更深层次的网络有效训练。

参数:

  • block (nn.Module): 残差块的类, 用于建立 ResNet 的不同层。 block 参数通常是一个实现了特定类型残差块结构的类, 比如 ‘BasicBlock’ 或 ‘Bottleneck’。

  • layers (list[int]): 每个 ResNet 层中残差块的数量, 是一个由4个元素组成的列表

  • num_classes (int, optional): 分类任务中的类别数。默认值: 1000

  • zero_init_residual (bool, optional): 是否使用零初始化残差块。默认值: False

  • groups (int, optional): 分组卷积的组数量。1意味着不使用分组卷积。默认值: 1

  • width_per_group (int, optional): 每个分组的宽度。默认值: 64

  • replace_stride_with_dilation (list[bool], optional): 是否用空洞卷积替换某些层的步长。若不为None则应为包含三个布尔值的列表。默认值: None

  • norm_layer (nn.Module, optional): 使用的标准化层, 默认使用 ‘nn.BatchNorm’。默认值: None

属性:

  • conv1 (nn.Conv): ResNet 的第一个卷积层。

  • bn1 (nn.BatchNorm): ResNet 的第一个标准化层。

  • relu (nn.Relu): Relu激活函数。

  • maxpool (nn.Pool): 最大池化层。

  • layer1 (nn.Sequential): ResNet 的第一层。

  • layer2 (nn.Sequential): ResNet 的第二层。

  • layer3 (nn.Sequential): ResNet 的第三层。

  • layer4 (nn.Sequential): ResNet 的第四层。

  • avgpool (nn.AdaptiveAvgPool2d): 自适应平均池化层。

  • fc (nn.Linear): 全连接层。

代码示例: 
>>> import jittor as jt
>>> from jittor.models.resnet import Bottleneck, ResNet
>>> resnet = ResNet(Bottleneck, [3,4,6,3])
>>> print(resnet)
ResNet(
    conv1: Conv(3, 64, (7, 7), (2, 2), (3, 3), (1, 1), 1, None, None, Kw=None, fan=None, i=None, bound=None)
    ...)
jittor.models.Resnet101(pretrained=False, **kwargs)[源代码]

构建ResNet101模型

ResNet101模型源自论文 Deep Residual Learning for Image Recognition, 其通过添加shortcut来改善梯度回传, 允许更深层次的网络有效训练。

参数:

  • pretrained (bool): 表示是否加载预训练的ResNet101模型。默认为 False。如果设为 True, 函数会自动下载并加载预训练的ResNet101模型。

  • **kwargs: 可变参数, 允许用户传递额外的、自定义的参数给 _resnet 函数。

返回值:

  • 返回一个ResNet101模型实例。如果 pretrained=True, 则返回的模型将加载预训练权重；否则, 返回一个未经训练的ResNet101模型。

代码示例:
>>> import jittor as jt
>>> from jittor.models.resnet import *
>>> net = ResNet101(pretrained=True)
>>> x = jt.rand(1, 3, 224, 224)
>>> y = net(x)
>>> y.shape
[1, 1000]
jittor.models.Resnet152(pretrained=False, **kwargs)[源代码]

构建ResNet152模型

ResNet152模型源自论文 Deep Residual Learning for Image Recognition, 其通过添加shortcut来改善梯度回传, 允许更深层次的网络有效训练。

参数:

  • pretrained (bool): 表示是否加载预训练的ResNet152模型。默认为 False。如果设为 True, 函数会自动下载并加载预训练的ResNet152模型。

  • **kwargs: 可变参数, 允许用户传递额外的、自定义的参数给 _resnet 函数。

返回值:

  • 返回一个ResNet152模型实例。如果 pretrained=True, 则返回的模型将加载预训练权重；否则, 返回一个未经训练的ResNet152模型。

代码示例:
>>> import jittor as jt
>>> from jittor.models.resnet import *
>>> net = ResNet152(pretrained=True)
>>> x = jt.rand(1, 3, 224, 224)
>>> y = net(x)
>>> y.shape
[1, 1000]
jittor.models.Resnet18(pretrained=False, **kwargs)[源代码]

构建Resnet18模型

ResNet18模型源自论文 Deep Residual Learning for Image Recognition, 其通过添加shortcut来改善梯度回传, 允许更深层次的网络有效训练。

参数:

  • pretrained (bool): 表示是否加载预训练的ResNet18模型。默认为 False。如果设为 True, 函数会自动下载并加载预训练的ResNet18模型。

  • **kwargs: 可变参数, 允许用户传递额外的、自定义的参数给 _resnet 函数。

返回值:

  • 返回一个ResNet18模型实例。如果 pretrained=True, 则返回的模型将加载预训练权重；否则, 返回一个未经训练的ResNet18模型。

代码示例:
>>> import jittor as jt
>>> from jittor.models.resnet import *
>>> net = Resnet18(pretrained=True)
>>> x = jt.rand(1, 3, 224, 224)
>>> y = net(x)
>>> y.shape
[1, 1000]
jittor.models.Resnet26(pretrained=False, **kwargs)[源代码]

构建ResNet26模型

ResNet26模型源自论文 Deep Residual Learning for Image Recognition, 其通过添加shortcut来改善梯度回传, 允许更深层次的网络有效训练。

参数:

  • pretrained (bool): 表示是否加载预训练的ResNet26模型。默认为 False。如果设为 True, 函数会自动下载并加载预训练的ResNet26模型。

  • **kwargs: 可变参数, 允许用户传递额外的、自定义的参数给 _resnet 函数。

返回值:

  • 返回一个ResNet26模型实例。如果 pretrained=True, 则返回的模型将加载预训练权重；否则, 返回一个未经训练的ResNet26模型。

代码示例:
>>> import jittor as jt
>>> from jittor.models.resnet import *
>>> net = ResNet26(pretrained=True)
>>> x = jt.rand(1, 3, 224, 224)
>>> y = net(x)
>>> y.shape
[1, 1000]
jittor.models.Resnet34(pretrained=False, **kwargs)[源代码]

构建Resnet34模型

ResNet34模型源自论文 Deep Residual Learning for Image Recognition, 其通过添加shortcut来改善梯度回传, 允许更深层次的网络有效训练。

参数:

  • pretrained (bool): 表示是否加载预训练的ResNet34模型。默认为 False。如果设为 True, 函数会自动下载并加载预训练的ResNet34模型。

  • **kwargs: 可变参数, 允许用户传递额外的、自定义的参数给 _resnet 函数。

返回值:

  • 返回一个ResNet34模型实例。如果 pretrained=True, 则返回的模型将加载预训练权重；否则, 返回一个未经训练的ResNet34模型。

代码示例:
>>> import jittor as jt
>>> from jittor.models.resnet import *
>>> net = Resnet34(pretrained=True)
>>> x = jt.rand(1, 3, 224, 224)
>>> y = net(x)
>>> y.shape
[1, 1000]
jittor.models.Resnet38(pretrained=False, **kwargs)[源代码]

构建ResNet38模型

ResNet38模型源自论文 Deep Residual Learning for Image Recognition, 其通过添加shortcut来改善梯度回传, 允许更深层次的网络有效训练。

参数:

  • pretrained (bool): 表示是否加载预训练的ResNet38模型。默认为 False。如果设为 True, 函数会自动下载并加载预训练的ResNet38模型。

  • **kwargs: 可变参数, 允许用户传递额外的、自定义的参数给 _resnet 函数。

返回值:

  • 返回一个ResNet38模型实例。如果 pretrained=True, 则返回的模型将加载预训练权重；否则, 返回一个未经训练的ResNet38模型。

代码示例:
>>> import jittor as jt
>>> from jittor.models.resnet import *
>>> net = ResNet38(pretrained=True)
>>> x = jt.rand(1, 3, 224, 224)
>>> y = net(x)
>>> y.shape
[1, 1000]
jittor.models.Resnet50(pretrained=False, **kwargs)[源代码]

构建Resnet50模型

ResNet50模型源自论文 Deep Residual Learning for Image Recognition, 其通过添加shortcut来改善梯度回传, 允许更深层次的网络有效训练。

参数:

  • pretrained (bool): 表示是否加载预训练的ResNet50模型。默认为 False。如果设为 True, 函数会自动下载并加载预训练的ResNet50模型。

  • **kwargs: 可变参数, 允许用户传递额外的、自定义的参数给 _resnet 函数。

返回值:

  • 返回一个ResNet50模型实例。如果 pretrained=True, 则返回的模型将加载预训练权重；否则, 返回一个未经训练的ResNet50模型。

代码示例:
>>> import jittor as jt
>>> from jittor.models.resnet import *
>>> net = Resnet50(pretrained=True)
>>> x = jt.rand(1, 3, 224, 224)
>>> y = net(x)
>>> y.shape
[1, 1000]
jittor.models.Resnext101_32x8d(pretrained=False, **kwargs)[源代码]

构建一个Resnext101_32x8d模型

Resnext源自论文 Aggregated Residual Transformations for Deep Neural Networks。

参数:

  • pretrained (bool, optional): 表示是否预加载预训练模型。默认为 False。

返回值:

  • 返回构建好的Resnext101_32x8d模型实例。如果 pretrained 为 True, 则返回在ImageNet上预训练的模型。

代码示例:
>>> import jittor as jt
>>> from jittor.models.resnet import *
>>> net = Resnext101_32x8d(pretrained=False)
>>> x = jt.rand(1, 3, 224, 224)
>>> y = net(x)
>>> y.shape
[1, 1000]
jittor.models.Resnext50_32x4d(pretrained=False, **kwargs)[源代码]

构建一个Resnext50_32x4d模型

Resnext源自论文 Aggregated Residual Transformations for Deep Neural Networks。

参数:

  • pretrained (bool, optional): 表示是否预加载预训练模型。默认为 False。

返回值:

  • 返回构建好的Resnext50_32x4d模型实例。如果 pretrained 为 True, 则返回在ImageNet上预训练的模型。

代码示例:
>>> import jittor as jt
>>> from jittor.models.resnet import *
>>> net = Resnext50_32x4d(pretrained=False)
>>> x = jt.rand(1, 3, 224, 224)
>>> y = net(x)
>>> y.shape
[1, 1000]
class jittor.models.ShuffleNetV2(stages_repeats, stages_out_channels, num_classes=1000, inverted_residual=<class 'jittor.models.shufflenetv2.InvertedResidual'>)[源代码]

ShuffleNetV2源自论文 ShuffleNet V2: Practical Guidelines for Efficient CNN Architecture Design, 其核心思想在于统筹通道分割与通道打乱操作, 减少计算复杂度同时保持模型性能。

参数:

  • stages_repeats (list[int]): 每个阶段中InvertedResidual模块的重复次数, 长度应为3。

  • stages_out_channels (list[int]): 每个阶段最终输出通道数, 长度应为5。

  • num_classes (int, optional): 分类的类别数, 默认为1000。

  • inverted_residual (nn.Module, optional): 用于构建每个阶段的反转残差模块, 默认为InvertedResidual类。默认值: None

属性:

  • stages_repeats (list[int]): 每个阶段中InvertedResidual模块的重复次数。

  • stages_out_channels (list[int]): 每个阶段最终输出通道数。

  • num_classes (int): 分类的类别数。

  • inverted_residual (nn.Module): 用于构建每个阶段的反转残差模块。

代码示例: 
>>> import jittor as jt
>>> from jittor.models.shufflenetv2 import ShuffleNetV2
>>> stages_repeats = [4, 8, 4]
>>> stages_out_channels = [24, 48, 96, 192, 1024]
>>> net = ShuffleNetV2(stages_repeats, stages_out_channels, num_classes=1000)
>>> input = jt.randn(10, 3, 256, 256)  # 假设是一个形状为[批次大小, 通道数, 高度, 宽度]的张量
>>> net(input).shape
[10,1000,]
class jittor.models.SqueezeNet(version='1_0', num_classes=1000)[源代码]

Squeezenet源自论文 SqueezeNet: AlexNet-level accuracy with 50x fewer parameters and <0.5MB model size。

注意:
当 version 为 ‘1_0’ 时, 模型结构特定为:

Conv1 -> Relu -> Pool -> Fire(96, 16, 64, 64) -> … -> Fire(512, 64, 256, 256)

当 version 为 ‘1_1’ 时, 模型结构为:

Conv1 -> Relu -> Pool -> Fire(64, 16, 64, 64) -> … -> Fire(512, 64, 256, 256)

最终, 模型通过一个分类器进行类别判断, 分类器包含一个Dropout层、一个1x1卷积层和一个平均池化层。

参数:

  • version (str, optional): SqueezeNet的版本, 可以是’1_0’或’1_1’, 分别对应不同的网络结构配置。版本’1_0’使用7x7的卷积核进行第一层卷积, 版本’1_1’则使用更小的3x3卷积核以进一步减小模型大小。默认值: ‘1_0’。

  • num_classes (int, optional): 模型最后输出的类别数。默认值: 1000

代码示例: 
>>> import jittor as jt
>>> from jittor.models.squeezenet import SqueezeNet
>>> model = SqueezeNet(version='1_0', num_classes=1000)
>>> x = jt.rand([10, 3, 224, 224])
>>> output = model.execute(x)
>>> print(output.shape)
[10,1000,]
class jittor.models.VGG(features, num_classes=1000, init_weights=True)[源代码]

VGG模型源自 Very Deep Convolutional Networks for Large-Scale Image Recognition。

参数:

  • features (nn.Module): 用来构建VGG中的卷积层的模块

  • num_classes (int, optional): 分类的类别数量。默认值: 1000

  • drop_last (bool, optional): 是否初始化权重。默认值: True

属性:

  • features (nn.Module): VGG卷积层部分。

  • avgpool (nn.AdaptiveAvgPool2d): 自适应平均池化层, 输出固定为 7x7

  • classifier (nn.Sequential): 分类器部分, 包括三个完全连接层和激活/丢失层

代码示例: 
>>> import jittor as jt
>>> from jittor.models.vgg import VGG, vgg16_bn
>>> vgg_model = VGG(features=vgg16_bn().features, num_classes=1000, init_weights=True)
>>> input_tensor = jt.randn(1, 3, 224, 224)
>>> output = vgg_model(input_tensor)
jittor.models.Wide_resnet101_2(pretrained=False, **kwargs)[源代码]

构建一个Wide_resnet101_2模型

Wide_resnet源自论文 Wide Residual Networks, 是Resnet的一个变种, 其主要改进是增加了网络的宽度, 即增加了每层的通道数, 从而提高了网络的性能。

参数:

  • pretrained (bool, optional): 表示是否预加载预训练模型。默认为 False。

返回值:

  • 返回构建好的Wide_resnet101_2模型实例。如果 pretrained 为 True, 则返回在ImageNet上预训练的模型。

代码示例:
>>> import jittor as jt
>>> from jittor.models.resnet import *
>>> net = Wide_resnet101_2(pretrained=False)
>>> x = jt.rand(1, 3, 224, 224)
>>> y = net(x)
>>> y.shape
[1, 1000]
jittor.models.Wide_resnet50_2(pretrained=False, **kwargs)[源代码]

构建一个Wide_resnet50_2模型

Wide_resnet源自论文 Wide Residual Networks, 是Resnet的一个变种, 其主要改进是增加了网络的宽度, 即增加了每层的通道数, 从而提高了网络的性能。

参数:

  • pretrained (bool, optional): 表示是否预加载预训练模型。默认为 False。

返回值:

  • 返回构建好的Wide_resnet50_2模型实例。如果 pretrained 为 True, 则返回在ImageNet上预训练的模型。

代码示例:
>>> import jittor as jt
>>> from jittor.models.resnet import *
>>> net = Wide_resnet50_2(pretrained=False)
>>> x = jt.rand(1, 3, 224, 224)
>>> y = net(x)
>>> y.shape
[1, 1000]
jittor.models.alexnet(pretrained=False, **kwargs)[源代码]

构建一个AlexNet模型

AlexNet模型源于 ImageNet Classification with Deep Convolutional Neural Networks 。

参数:

  • pretrained (bool, optional): 表示是否预加载预训练模型。默认为 False。

  • **kwargs (dict, optional): AlexNet模型的其他参数。默认为 `None。

返回值:

  • 返回构建好的AlexNet模型实例。如果 pretrained 为 True, 则返回在ImageNet上预训练的模型。

代码示例:
>>> import jittor as jt
>>> from jittor.models.alexnet import *
>>> net = alexnet(pretrained=False)
>>> x = jt.rand(1, 3, 224, 224)
>>> y = net(x)
>>> y.shape
[1, 1000]
jittor.models.densenet121(pretrained=False, **kwargs)[源代码]

构建一个Densenet121模型

Densenet源自论文 Densely Connected Convolutional Networks, DenseNet的特点是每个层都与前面的层连接, 这种连接方式使得网络的特征传递更加高效, 同时也有助于解决梯度消失的问题。DenseNet的网络结构包含了多个DenseBlock和Transition层, 其中DenseBlock用于特征提取, Transition层用于特征维度的缩减。

参数:

  • pretrained (bool, optional): 如果为 True, 返回在ImageNet上预训练的模型。默认为 False。

  • **kwargs: 可变参数, 用于传递额外的配置选项。

返回值:

  • 返回构建好的Densenet121模型实例。如果 pretrained 为 True, 则返回在ImageNet上预训练的模型。

代码示例:
>>> import jittor as jt
>>> from jittor.models.densenet import *
>>> net = densenet121(pretrained=False)
>>> x = jt.rand(1, 3, 224, 224)
>>> y = net(x)
>>> y.shape
[1, 1000]
jittor.models.densenet161(pretrained=False, **kwargs)[源代码]

构建一个Densenet161模型

Densenet源自论文 Densely Connected Convolutional Networks , DenseNet的特点是每个层都与前面的层连接, 这种连接方式使得网络的特征传递更加高效, 同时也有助于解决梯度消失的问题。DenseNet的网络结构包含了多个DenseBlock和Transition层, 其中DenseBlock用于特征提取, Transition层用于特征维度的缩减。

参数:

  • pretrained (bool, optional): 如果为 True, 返回在ImageNet上预训练的模型。默认为 False。

  • **kwargs: 可变参数, 用于传递额外的配置选项。

返回值:

  • 返回构建好的Densenet161模型实例。如果 pretrained 为 True, 则返回在ImageNet上预训练的模型。

代码示例:
>>> import jittor as jt
>>> from jittor.models.densenet import *
>>> net = densenet161(pretrained=False)
>>> x = jt.rand(1, 3, 224, 224)
>>> y = net(x)
>>> y.shape
[1, 1000]
jittor.models.densenet169(pretrained=False, **kwargs)[源代码]

构建一个Densenet169模型

Densenet源自论文 Densely Connected Convolutional Networks , DenseNet的特点是每个层都与前面的层连接, 这种连接方式使得网络的特征传递更加高效, 同时也有助于解决梯度消失的问题。DenseNet的网络结构包含了多个DenseBlock和Transition层, 其中DenseBlock用于特征提取, Transition层用于特征维度的缩减。

参数:

  • pretrained (bool, optional): 如果为 True, 返回在ImageNet上预训练的模型。默认为 False。

  • **kwargs: 可变参数, 用于传递额外的配置选项。

返回值:

  • 返回构建好的Densenet169模型实例。如果 pretrained 为 True, 则返回在ImageNet上预训练的模型。

代码示例:
>>> import jittor as jt
>>> from jittor.models.densenet import *
>>> net = densenet169(pretrained=False)
>>> x = jt.rand(1, 3, 224, 224)
>>> y = net(x)
>>> y.shape
[1, 1000]
jittor.models.densenet201(pretrained=False, **kwargs)[源代码]

构建一个Densenet201模型

Densenet源自论文 Densely Connected Convolutional Networks , DenseNet的特点是每个层都与前面的层连接, 这种连接方式使得网络的特征传递更加高效, 同时也有助于解决梯度消失的问题。DenseNet的网络结构包含了多个DenseBlock和Transition层, 其中DenseBlock用于特征提取, Transition层用于特征维度的缩减。

参数:

  • pretrained (bool, optional): 如果为 True, 返回在ImageNet上预训练的模型。默认为 False。

  • **kwargs: 可变参数, 用于传递额外的配置选项。

返回值:

  • 返回构建好的Densenet201模型实例。如果 pretrained 为 True, 则返回在ImageNet上预训练的模型。

代码示例:
>>> import jittor as jt
>>> from jittor.models.densenet import *
>>> net = densenet201(pretrained=False)
>>> x = jt.rand(1, 3, 224, 224)
>>> y = net(x)
>>> y.shape
[1, 1000]
jittor.models.googlenet(pretrained=False, **kwargs)[源代码]

构建一个GoogLeNet模型

GoogLeNet源自论文 Going Deeper with Convolutions , 它由多个称为Inception模块的子网络构成。

参数:

  • pretrained (bool, optional): 表示是否预加载预训练模型。默认为 False。

  • kwargs: 其他optional参数。

返回值:

  • 返回构建好的googlenet模型实例。如果 pretrained 为 True, 则返回在ImageNet上预训练的模型。

代码示例:
>>> import jittor as jt
>>> from jittor.models.googlenet import *
>>> net = googlenet(pretrained=False)
>>> x = jt.rand(1, 3, 224, 224)
>>> y = net(x)
>>> y.shape
[1, 1000]
jittor.models.inception_v3(pretrained=False, progress=True, **kwargs)[源代码]

构建一个Inception v3模型

Inception v3源自论文 Rethinking the Inception Architecture for Computer Vision, inception模块通过不同尺寸的卷积核和池化层并行处理输入, 并合并输出, 旨在在不同的尺度上有效提取特征。

参数:

  • pretrained (bool, optional): 表示是否预加载预训练模型。默认为 False。

返回值:

  • 返回构建好的inception_v3模型实例。如果 pretrained 为 True, 则返回在ImageNet上预训练的模型。

代码示例:
>>> import jittor as jt
>>> from jittor.models.inception import *
>>> net = inception_v3(pretrained=False)
>>> x = jt.rand(1, 3, 224, 224)
>>> y = net(x)
>>> y.shape
[1, 1000]
jittor.models.mnasnet0_5(pretrained=False, **kwargs)[源代码]

构建一个MnasNet 0_5模型

MnasNet源自论文 MnasNet: Platform-Aware Neural Architecture Search for Mobile, 其使用深度可分卷积和线性瓶颈层来减少计算复杂性, 同时仍然保持了表示能力。

参数:

  • pretrained (bool, optional): 表示是否预加载预训练模型。默认为 False。

  • kwargs: 其他optional参数。

返回值:

  • 返回构建好的MnasNet 0_5模型实例。如果 pretrained 为 True, 则返回在ImageNet上预训练的模型。

代码示例:
>>> import jittor as jt
>>> from jittor.models.mnasnet import *
>>> net = mnasnet0_5(pretrained=False)
>>> x = jt.rand(1, 3, 224, 224)
>>> y = net(x)
>>> y.shape
[1, 1000]
jittor.models.mnasnet0_75(pretrained=False, **kwargs)[源代码]

构建一个MnasNet 0_75模型

MnasNet源自论文 MnasNet: Platform-Aware Neural Architecture Search for Mobile, 其使用深度可分卷积和线性瓶颈层来减少计算复杂性, 同时仍然保持了表示能力。

参数:

  • pretrained (bool, optional): 表示是否预加载预训练模型。默认为 False。

  • kwargs: 其他optional参数。

返回值:

  • 返回构建好的MnasNet 0_75模型实例。如果 pretrained 为 True, 则返回在ImageNet上预训练的模型。

代码示例:
>>> import jittor as jt
>>> from jittor.models.mnasnet import *
>>> net = mnasnet0_75(pretrained=False)
>>> x = jt.rand(1, 3, 224, 224)
>>> y = net(x)
>>> y.shape
[1, 1000]
jittor.models.mnasnet1_0(pretrained=False, **kwargs)[源代码]

构建一个MnasNet 1_0模型

MnasNet源自论文 《MnasNet: Platform-Aware Neural Architecture Search for Mobile》

参数:

  • pretrained (bool, optional): 表示是否预加载预训练模型。默认为 False。

  • kwargs: 其他optional参数。

返回值:

  • 返回构建好的MnasNet 1_0模型实例。如果 pretrained 为 True, 则返回在ImageNet上预训练的模型。

代码示例:
>>> import jittor as jt
>>> from jittor.models.mnasnet import *
>>> net = mnasnet1_0(pretrained=False)
>>> x = jt.rand(1, 3, 224, 224)
>>> y = net(x)
>>> y.shape
[1, 1000]
jittor.models.mnasnet1_3(pretrained=False, **kwargs)[源代码]

构建一个MnasNet 1_3模型

MnasNet源自论文 MnasNet: Platform-Aware Neural Architecture Search for Mobile, 其使用深度可分卷积和线性瓶颈层来减少计算复杂性, 同时仍然保持了表示能力。

参数:

  • pretrained (bool, optional): 表示是否预加载预训练模型。默认为 False。

  • kwargs: 其他optional参数。

返回值:

  • 返回构建好的MnasNet 1_3模型实例。如果 pretrained 为 True, 则返回在ImageNet上预训练的模型。

代码示例:
>>> import jittor as jt
>>> from jittor.models.mnasnet import *
>>> net = mnasnet1_3(pretrained=False)
>>> x = jt.rand(1, 3, 224, 224)
>>> y = net(x)
>>> y.shape
[1, 1000]
jittor.models.mobilenet_v2(pretrained=False)[源代码]

构建一个MobileNetV2模型

MobileNetV2源自论文 Mobilenetv2: Inverted residuals and linear bottlenecks。mobilenet_v2基于倒置残差结构, 其中使用线性瓶颈在压缩表示中传递消息。

参数:

  • pretrained (bool, optional): 表示是否预加载预训练模型。默认为 False。

返回值:

  • 返回构建好的MobileNetV2模型实例。如果 pretrained 为 True, 则返回在ImageNet上预训练的模型。

代码示例:
>>> import jittor as jt
>>> from jittor.models.mobilenet import *
>>> net = mobilenet_v2(pretrained=False)
>>> x = jt.rand(1, 3, 224, 224)
>>> y = net(x)
>>> y.shape
[1, 1000]
jittor.models.res2net101(pretrained=False, **kwargs)

构建一个Res2Net101_26w_4s模型

Res2Net101_26w_4s源自论文 Res2Net: A New Multi-scale Backbone Architecture, 是ResNet模型的一种变体。

参数:

  • pretrained (bool, optional): 如果为 True, 返回一个在ImageNet上预训练的模型。默认为 False。

  • **kwargs (dict, optional): 用于传递额外的关键字参数。

返回值:

  • 返回构建好的Res2Net101_26w_4s模型实例。如果 pretrained 为 True, 则返回在ImageNet上预训练的模型。

代码示例:
>>> import jittor as jt
>>> from jittor.models.res2net import *
>>> net = res2net101_26w_4s(pretrained=True)
>>> x = jt.rand(1, 3, 224, 224)
>>> y = net(x)
>>> y.shape
[1, 1000]
jittor.models.res2net50(pretrained=False, **kwargs)[源代码]

构建一个Res2Net50模型

Res2Net50源自论文 Res2Net: A New Multi-scale Backbone Architecture, 是ResNet模型的一种变体。

参数:

  • pretrained (bool, optional): 如果为 True, 返回一个在ImageNet上预训练的模型。默认为 False。

  • **kwargs (dict, optional): 用于传递额外的关键字参数。

返回值:

  • 返回构建好的Res2Net模型实例。如果 pretrained 为 True, 则返回在ImageNet上预训练的模型。

代码示例:
>>> import jittor as jt
>>> from jittor.models.res2net import *
>>> net = res2net50(pretrained=True)
>>> x = jt.rand(1, 3, 224, 224)
>>> y = net(x)
>>> y.shape
[1, 1000]
jittor.models.resnet101(pretrained=False, **kwargs)

构建ResNet101模型

ResNet101模型源自论文 Deep Residual Learning for Image Recognition, 其通过添加shortcut来改善梯度回传, 允许更深层次的网络有效训练。

参数:

  • pretrained (bool): 表示是否加载预训练的ResNet101模型。默认为 False。如果设为 True, 函数会自动下载并加载预训练的ResNet101模型。

  • **kwargs: 可变参数, 允许用户传递额外的、自定义的参数给 _resnet 函数。

返回值:

  • 返回一个ResNet101模型实例。如果 pretrained=True, 则返回的模型将加载预训练权重；否则, 返回一个未经训练的ResNet101模型。

代码示例:
>>> import jittor as jt
>>> from jittor.models.resnet import *
>>> net = ResNet101(pretrained=True)
>>> x = jt.rand(1, 3, 224, 224)
>>> y = net(x)
>>> y.shape
[1, 1000]
jittor.models.resnet152(pretrained=False, **kwargs)

构建ResNet152模型

ResNet152模型源自论文 Deep Residual Learning for Image Recognition, 其通过添加shortcut来改善梯度回传, 允许更深层次的网络有效训练。

参数:

  • pretrained (bool): 表示是否加载预训练的ResNet152模型。默认为 False。如果设为 True, 函数会自动下载并加载预训练的ResNet152模型。

  • **kwargs: 可变参数, 允许用户传递额外的、自定义的参数给 _resnet 函数。

返回值:

  • 返回一个ResNet152模型实例。如果 pretrained=True, 则返回的模型将加载预训练权重；否则, 返回一个未经训练的ResNet152模型。

代码示例:
>>> import jittor as jt
>>> from jittor.models.resnet import *
>>> net = ResNet152(pretrained=True)
>>> x = jt.rand(1, 3, 224, 224)
>>> y = net(x)
>>> y.shape
[1, 1000]
jittor.models.resnet18(pretrained=False, **kwargs)

构建Resnet18模型

ResNet18模型源自论文 Deep Residual Learning for Image Recognition, 其通过添加shortcut来改善梯度回传, 允许更深层次的网络有效训练。

参数:

  • pretrained (bool): 表示是否加载预训练的ResNet18模型。默认为 False。如果设为 True, 函数会自动下载并加载预训练的ResNet18模型。

  • **kwargs: 可变参数, 允许用户传递额外的、自定义的参数给 _resnet 函数。

返回值:

  • 返回一个ResNet18模型实例。如果 pretrained=True, 则返回的模型将加载预训练权重；否则, 返回一个未经训练的ResNet18模型。

代码示例:
>>> import jittor as jt
>>> from jittor.models.resnet import *
>>> net = Resnet18(pretrained=True)
>>> x = jt.rand(1, 3, 224, 224)
>>> y = net(x)
>>> y.shape
[1, 1000]
jittor.models.resnet26(pretrained=False, **kwargs)

构建ResNet26模型

ResNet26模型源自论文 Deep Residual Learning for Image Recognition, 其通过添加shortcut来改善梯度回传, 允许更深层次的网络有效训练。

参数:

  • pretrained (bool): 表示是否加载预训练的ResNet26模型。默认为 False。如果设为 True, 函数会自动下载并加载预训练的ResNet26模型。

  • **kwargs: 可变参数, 允许用户传递额外的、自定义的参数给 _resnet 函数。

返回值:

  • 返回一个ResNet26模型实例。如果 pretrained=True, 则返回的模型将加载预训练权重；否则, 返回一个未经训练的ResNet26模型。

代码示例:
>>> import jittor as jt
>>> from jittor.models.resnet import *
>>> net = ResNet26(pretrained=True)
>>> x = jt.rand(1, 3, 224, 224)
>>> y = net(x)
>>> y.shape
[1, 1000]
jittor.models.resnet34(pretrained=False, **kwargs)

构建Resnet34模型

ResNet34模型源自论文 Deep Residual Learning for Image Recognition, 其通过添加shortcut来改善梯度回传, 允许更深层次的网络有效训练。

参数:

  • pretrained (bool): 表示是否加载预训练的ResNet34模型。默认为 False。如果设为 True, 函数会自动下载并加载预训练的ResNet34模型。

  • **kwargs: 可变参数, 允许用户传递额外的、自定义的参数给 _resnet 函数。

返回值:

  • 返回一个ResNet34模型实例。如果 pretrained=True, 则返回的模型将加载预训练权重；否则, 返回一个未经训练的ResNet34模型。

代码示例:
>>> import jittor as jt
>>> from jittor.models.resnet import *
>>> net = Resnet34(pretrained=True)
>>> x = jt.rand(1, 3, 224, 224)
>>> y = net(x)
>>> y.shape
[1, 1000]
jittor.models.resnet38(pretrained=False, **kwargs)

构建ResNet38模型

ResNet38模型源自论文 Deep Residual Learning for Image Recognition, 其通过添加shortcut来改善梯度回传, 允许更深层次的网络有效训练。

参数:

  • pretrained (bool): 表示是否加载预训练的ResNet38模型。默认为 False。如果设为 True, 函数会自动下载并加载预训练的ResNet38模型。

  • **kwargs: 可变参数, 允许用户传递额外的、自定义的参数给 _resnet 函数。

返回值:

  • 返回一个ResNet38模型实例。如果 pretrained=True, 则返回的模型将加载预训练权重；否则, 返回一个未经训练的ResNet38模型。

代码示例:
>>> import jittor as jt
>>> from jittor.models.resnet import *
>>> net = ResNet38(pretrained=True)
>>> x = jt.rand(1, 3, 224, 224)
>>> y = net(x)
>>> y.shape
[1, 1000]
jittor.models.resnet50(pretrained=False, **kwargs)

构建Resnet50模型

ResNet50模型源自论文 Deep Residual Learning for Image Recognition, 其通过添加shortcut来改善梯度回传, 允许更深层次的网络有效训练。

参数:

  • pretrained (bool): 表示是否加载预训练的ResNet50模型。默认为 False。如果设为 True, 函数会自动下载并加载预训练的ResNet50模型。

  • **kwargs: 可变参数, 允许用户传递额外的、自定义的参数给 _resnet 函数。

返回值:

  • 返回一个ResNet50模型实例。如果 pretrained=True, 则返回的模型将加载预训练权重；否则, 返回一个未经训练的ResNet50模型。

代码示例:
>>> import jittor as jt
>>> from jittor.models.resnet import *
>>> net = Resnet50(pretrained=True)
>>> x = jt.rand(1, 3, 224, 224)
>>> y = net(x)
>>> y.shape
[1, 1000]
jittor.models.resnext101_32x8d(pretrained=False, **kwargs)

构建一个Resnext101_32x8d模型

Resnext源自论文 Aggregated Residual Transformations for Deep Neural Networks。

参数:

  • pretrained (bool, optional): 表示是否预加载预训练模型。默认为 False。

返回值:

  • 返回构建好的Resnext101_32x8d模型实例。如果 pretrained 为 True, 则返回在ImageNet上预训练的模型。

代码示例:
>>> import jittor as jt
>>> from jittor.models.resnet import *
>>> net = Resnext101_32x8d(pretrained=False)
>>> x = jt.rand(1, 3, 224, 224)
>>> y = net(x)
>>> y.shape
[1, 1000]
jittor.models.resnext50_32x4d(pretrained=False, **kwargs)

构建一个Resnext50_32x4d模型

Resnext源自论文 Aggregated Residual Transformations for Deep Neural Networks。

参数:

  • pretrained (bool, optional): 表示是否预加载预训练模型。默认为 False。

返回值:

  • 返回构建好的Resnext50_32x4d模型实例。如果 pretrained 为 True, 则返回在ImageNet上预训练的模型。

代码示例:
>>> import jittor as jt
>>> from jittor.models.resnet import *
>>> net = Resnext50_32x4d(pretrained=False)
>>> x = jt.rand(1, 3, 224, 224)
>>> y = net(x)
>>> y.shape
[1, 1000]
jittor.models.shufflenet_v2_x0_5(pretrained=False)[源代码]

构建一个shufflenet_v2_x0_5模型

ShuffleNetV2源自论文 ShuffleNet V2: Practical Guidelines for Efficient CNN Architecture Design, 其核心思想在于统筹通道分割与通道打乱操作, 减少计算复杂度同时保持模型性能。

参数:

  • pretrained (bool, optional): 表示是否预加载预训练模型。默认为 False。

返回值:

  • 返回构建好的shufflenet_v2_x0_5模型实例。如果 pretrained 为 True, 则返回在ImageNet上预训练的模型。

代码示例:
>>> import jittor as jt
>>> from jittor.models.shufflenetv2 import *
>>> net = shufflenet_v2_x0_5(pretrained=False)
>>> x = jt.rand(1, 3, 224, 224)
>>> y = net(x)
>>> y.shape
[1, 1000]
jittor.models.shufflenet_v2_x1_0(pretrained=False)[源代码]

构建一个shufflenet_v2_x1_0模型

ShuffleNetV2源自论文 ShuffleNet V2: Practical Guidelines for Efficient CNN Architecture Design, 其核心思想在于统筹通道分割与通道打乱操作, 减少计算复杂度同时保持模型性能。

参数:

  • pretrained (bool, optional): 表示是否预加载预训练模型。默认为 False。

返回值:

  • 返回构建好的shufflenet_v2_x1_0模型实例。如果 pretrained 为 True, 则返回在ImageNet上预训练的模型。

代码示例:
>>> import jittor as jt
>>> from jittor.models.shufflenetv2 import *
>>> net = shufflenet_v2_x1_0(pretrained=False)
>>> x = jt.rand(1, 3, 224, 224)
>>> y = net(x)
>>> y.shape
[1, 1000]
jittor.models.shufflenet_v2_x1_5(pretrained=False)[源代码]

构建一个shufflenet_v2_x1_5模型

ShuffleNetV2源自论文 ShuffleNet V2: Practical Guidelines for Efficient CNN Architecture Design, 其核心思想在于统筹通道分割与通道打乱操作, 减少计算复杂度同时保持模型性能。

参数:

  • pretrained (bool, optional): 表示是否预加载预训练模型。默认为 False。

返回值:

  • 返回构建好的shufflenet_v2_x1_5模型实例。如果 pretrained 为 True, 则返回在ImageNet上预训练的模型。

代码示例:
>>> import jittor as jt
>>> from jittor.models.shufflenetv2 import *
>>> net = shufflenet_v2_x1_5(pretrained=False)
>>> x = jt.rand(1, 3, 224, 224)
>>> y = net(x)
>>> y.shape
[1, 1000]
jittor.models.shufflenet_v2_x2_0(pretrained=False)[源代码]

构建一个shufflenet_v2_x2_0模型

ShuffleNetV2源自论文 ShuffleNet V2: Practical Guidelines for Efficient CNN Architecture Design, 其核心思想在于统筹通道分割与通道打乱操作, 减少计算复杂度同时保持模型性能。

参数:

  • pretrained (bool, optional): 表示是否预加载预训练模型。默认为 False。

返回值:

  • 返回构建好的shufflenet_v2_x2_0模型实例。如果 pretrained 为 True, 则返回在ImageNet上预训练的模型。

代码示例:
>>> import jittor as jt
>>> from jittor.models.shufflenetv2 import *
>>> net = shufflenet_v2_x2_0(pretrained=False)
>>> x = jt.rand(1, 3, 224, 224)
>>> y = net(x)
>>> y.shape
[1, 1000]
jittor.models.squeezenet1_0(pretrained=False, **kwargs)[源代码]

构建一个squeezenet1_0模型

Squeezenet源自论文 SqueezeNet: AlexNet-level accuracy with 50x fewer parameters and <0.5MB model size。

参数:

  • pretrained (bool, optional): 表示是否预加载预训练模型。默认为 False。

  • kwargs: 其他optional参数。

返回值:

  • 返回构建好的squeezenet1_0模型实例。如果 pretrained 为 True, 则返回在ImageNet上预训练的模型。

代码示例:
>>> import jittor as jt
>>> from jittor.models.squeezenet import *
>>> net = squeezenet1_0(pretrained=False)
>>> x = jt.rand(1, 3, 224, 224)
>>> y = net(x)
>>> y.shape
[1, 1000]
jittor.models.squeezenet1_1(pretrained=False, **kwargs)[源代码]

构建一个squeezenet1_1模型

Squeezenet源自论文 SqueezeNet: AlexNet-level accuracy with 50x fewer parameters and <0.5MB model size。

参数:

  • pretrained (bool, optional): 表示是否预加载预训练模型。默认为 False。

  • kwargs: 其他optional参数。

返回值:

  • 返回构建好的squeezenet1_1模型实例。如果 pretrained 为 True, 则返回在ImageNet上预训练的模型。

代码示例:
>>> import jittor as jt
>>> from jittor.models.squeezenet import *
>>> net = squeezenet1_1(pretrained=False)
>>> x = jt.rand(1, 3, 224, 224)
>>> y = net(x)
>>> y.shape
[1, 1000]
jittor.models.vgg11(pretrained=False, **kwargs)[源代码]

构建VGG11模型

VGG模型源自 Very Deep Convolutional Networks for Large-Scale Image Recognition。

参数:

  • pretrained (bool): 表示是否加载预训练的VGG11模型。默认为 False。如果设为 True, 函数会自动下载并加载预训练的VGG11模型。

  • **kwargs: 可变参数, 允许用户传递额外的、自定义的参数给 _vgg 函数。

代码示例:
>>> import jittor as jt
>>> from jittor.models.vgg import *
>>> net = vgg11(pretrained=True)
>>> x = jt.rand(1, 3, 224, 224)
>>> y = net(x)
>>> y.shape
[1,1000,]
返回值:

  • 返回一个VGG11模型实例。如果 pretrained=True, 则返回的模型将加载预训练权重；否则, 返回一个未经训练的VGG11模型。

jittor.models.vgg11_bn(pretrained=False, **kwargs)[源代码]

构建带有批量归一化的VGG11模型

VGG模型源自 Very Deep Convolutional Networks for Large-Scale Image Recognition。

参数:

  • pretrained (bool): 表示是否加载预训练的VGG11模型。默认为 False。如果设为 True, 函数会自动下载并加载预训练的VGG11模型。

  • **kwargs: 可变参数, 允许用户传递额外的、自定义的参数给 _vgg 函数。

返回值:

  • 返回一个VGG11_BN模型实例。如果 pretrained=True, 则返回的模型将加载预训练权重；否则, 返回一个未经训练的VGG11_BN模型。

代码示例:
>>> import jittor as jt
>>> from jittor.models.vgg import *
>>> net = vgg11_bn(pretrained=True)
>>> x = jt.rand(1, 3, 224, 224)
>>> y = net(x)
>>> y.shape
[1,1000,]
jittor.models.vgg13(pretrained=False, **kwargs)[源代码]

构建并返回VGG13模型

VGG模型源自 Very Deep Convolutional Networks for Large-Scale Image Recognition。

参数:

  • pretrained (bool): 表示是否加载预训练的VGG13模型。默认为 False。如果设为 True, 函数会自动下载并加载预训练的VGG13模型。

  • **kwargs: 可变参数, 允许用户传递额外的、自定义的参数给 _vgg 函数。

返回值:

  • 返回一个VGG13模型实例。如果 pretrained=True, 则返回的模型将加载预训练权重；否则, 返回一个未经训练的VGG13模型。

代码示例:
>>> import jittor as jt
>>> from jittor.models.vgg import *
>>> net = vgg13(pretrained=True)
>>> x = jt.rand(1, 3, 224, 224)
>>> y = net(x)
>>> y.shape
[1,1000,]
jittor.models.vgg13_bn(pretrained=False, **kwargs)[源代码]

构建带有批量归一化的VGG13模型

VGG模型源自 Very Deep Convolutional Networks for Large-Scale Image Recognition。

参数:

  • pretrained (bool): 表示是否加载预训练的VGG13模型。默认为 False。如果设为 True, 函数会自动下载并加载预训练的VGG13模型。

  • **kwargs: 可变参数, 允许用户传递额外的、自定义的参数给 _vgg 函数。

返回值:

  • 返回一个VGG13_BN模型实例。如果 pretrained=True, 则返回的模型将加载预训练权重；否则, 返回一个未经训练的VGG13_BN模型。

代码示例:
>>> import jittor as jt
>>> from jittor.models.vgg import *
>>> net = vgg13_bn(pretrained=True)
>>> x = jt.rand(1, 3, 224, 224)
>>> y = net(x)
>>> y.shape
[1,1000,]
jittor.models.vgg16(pretrained=False, **kwargs)[源代码]

构建VGG16模型

VGG模型源自 Very Deep Convolutional Networks for Large-Scale Image Recognition。

参数:

  • pretrained (bool): 表示是否加载预训练的VGG16模型。默认为 False。如果设为 True, 函数会自动下载并加载预训练的VGG16模型。

  • **kwargs: 可变参数, 允许用户传递额外的、自定义的参数给 _vgg 函数。

返回值:

  • 返回一个VGG16模型实例。如果 pretrained=True, 则返回的模型将加载预训练权重；否则, 返回一个未经训练的VGG16模型。

代码示例:
>>> import jittor as jt
>>> from jittor.models.vgg import *
>>> net = vgg16(pretrained=True)
>>> x = jt.rand(1, 3, 224, 224)
>>> y = net(x)
>>> y.shape
[1,1000,]
jittor.models.vgg16_bn(pretrained=False, **kwargs)[源代码]

构建带有批量归一化的VGG16模型

VGG模型源自 Very Deep Convolutional Networks for Large-Scale Image Recognition。

参数:

  • pretrained (bool): 表示是否加载预训练的VGG16模型。默认为 False。如果设为 True, 函数会自动下载并加载预训练的VGG16模型。

  • **kwargs: 可变参数, 允许用户传递额外的、自定义的参数给 _vgg 函数。

返回值:

  • 返回一个VGG16_BN模型实例。如果 pretrained=True, 则返回的模型将加载预训练权重；否则, 返回一个未经训练的VGG16_BN模型。

代码示例:
>>> import jittor as jt
>>> from jittor.models.vgg import *
>>> net = vgg16_bn(pretrained=True)
>>> x = jt.rand(1, 3, 224, 224)
>>> y = net(x)
>>> y.shape
[1,1000,]
jittor.models.vgg19(pretrained=False, **kwargs)[源代码]

构建VGG19模型

VGG模型源自 Very Deep Convolutional Networks for Large-Scale Image Recognition。

参数:

  • pretrained (bool): 表示是否加载预训练的VGG19模型。默认为 False。如果设为 True, 函数会自动下载并加载预训练的VGG19模型。

  • **kwargs: 可变参数, 允许用户传递额外的、自定义的参数给 _vgg 函数。

返回值:

  • 返回一个VGG19模型实例。如果 pretrained=True, 则返回的模型将加载预训练权重；否则, 返回一个未经训练的VGG19模型。

代码示例:
>>> import jittor as jt
>>> from jittor.models.vgg import *
>>> net = vgg19(pretrained=True)
>>> x = jt.rand(1, 3, 224, 224)
>>> y = net(x)
>>> y.shape
[1,1000,]
jittor.models.vgg19_bn(pretrained=False, **kwargs)[源代码]

构建带有批量归一化的VGG19模型

VGG模型源自 Very Deep Convolutional Networks for Large-Scale Image Recognition。

参数:

  • pretrained (bool): 表示是否加载预训练的VGG19模型。默认为 False。如果设为 True, 函数会自动下载并加载预训练的VGG19模型。

  • **kwargs: 可变参数, 允许用户传递额外的、自定义的参数给 _vgg 函数。

返回值:

  • 返回一个VGG19_BN模型实例。如果 pretrained=True, 则返回的模型将加载预训练权重；否则, 返回一个未经训练的VGG19_BN模型。

代码示例:
>>> import jittor as jt
>>> from jittor.models.vgg import *
>>> net = vgg19_bn(pretrained=True)
>>> x = jt.rand(1, 3, 224, 224)
>>> y = net(x)
>>> y.shape
[1,1000,]
jittor.models.wide_resnet101_2(pretrained=False, **kwargs)

构建一个Wide_resnet101_2模型

Wide_resnet源自论文 Wide Residual Networks, 是Resnet的一个变种, 其主要改进是增加了网络的宽度, 即增加了每层的通道数, 从而提高了网络的性能。

参数:

  • pretrained (bool, optional): 表示是否预加载预训练模型。默认为 False。

返回值:

  • 返回构建好的Wide_resnet101_2模型实例。如果 pretrained 为 True, 则返回在ImageNet上预训练的模型。

代码示例:
>>> import jittor as jt
>>> from jittor.models.resnet import *
>>> net = Wide_resnet101_2(pretrained=False)
>>> x = jt.rand(1, 3, 224, 224)
>>> y = net(x)
>>> y.shape
[1, 1000]
jittor.models.wide_resnet50_2(pretrained=False, **kwargs)

构建一个Wide_resnet50_2模型

Wide_resnet源自论文 Wide Residual Networks, 是Resnet的一个变种, 其主要改进是增加了网络的宽度, 即增加了每层的通道数, 从而提高了网络的性能。

参数:

  • pretrained (bool, optional): 表示是否预加载预训练模型。默认为 False。

返回值:

  • 返回构建好的Wide_resnet50_2模型实例。如果 pretrained 为 True, 则返回在ImageNet上预训练的模型。

代码示例:
>>> import jittor as jt
>>> from jittor.models.resnet import *
>>> net = Wide_resnet50_2(pretrained=False)
>>> x = jt.rand(1, 3, 224, 224)
>>> y = net(x)
>>> y.shape
[1, 1000]