def get_center_net(name, dataset, pretrained=False, ctx=mx.cpu(), root=os.path.join('~', '.mxnet', 'models'), **kwargs): """Get a center net instance. Parameters ---------- name : str or None Model name, if `None` is used, you must specify `features` to be a `HybridBlock`. dataset : str Name of dataset. This is used to identify model name because models trained on different datasets are going to be very different. pretrained : bool or str Boolean value controls whether to load the default pretrained weights for model. String value represents the hashtag for a certain version of pretrained weights. ctx : mxnet.Context Context such as mx.cpu(), mx.gpu(0). root : str Model weights storing path. Returns ------- HybridBlock A CenterNet detection network. """ # pylint: disable=unused-variable net = CenterNet(**kwargs) if pretrained: from gluoncv.model_zoo.model_store import get_model_file full_name = '_'.join(('center_net', name, dataset)) net.load_parameters(get_model_file(full_name, tag=pretrained, root=root), ctx=ctx) else: with warnings.catch_warnings(record=True) as w: warnings.simplefilter("always") net.initialize() for v in net.collect_params().values(): try: v.reset_ctx(ctx) except ValueError: pass return net
def get_mobilenet_v2(multiplier, pretrained=False, ctx=cpu(), root='~/.mxnet/models', **kwargs): r"""MobileNetV2 model from the `"Inverted Residuals and Linear Bottlenecks: Mobile Networks for Classification, Detection and Segmentation" <https://arxiv.org/abs/1801.04381>`_ paper. Parameters ---------- multiplier : float The width multiplier for controling the model size. Only multipliers that are no less than 0.25 are supported. The actual number of channels is equal to the original channel size multiplied by this multiplier. pretrained : bool or str Boolean value controls whether to load the default pretrained weights for model. String value represents the hashtag for a certain version of pretrained weights. ctx : Context, default CPU The context in which to load the pretrained weights. root : str, default $MXNET_HOME/models Location for keeping the model parameters. """ net = MobileNetV2(multiplier, **kwargs) if pretrained: from .model_store import get_model_file version_suffix = '{0:.2f}'.format(multiplier) if version_suffix in ('1.00', '0.50'): version_suffix = version_suffix[:-1] net.load_parameters(get_model_file('mobilenetv2_%s' % version_suffix, tag=pretrained, root=root), ctx=ctx) from ..data import ImageNet1kAttr attrib = ImageNet1kAttr() net.synset = attrib.synset net.classes = attrib.classes net.classes_long = attrib.classes_long return net
def resnet34_v1b(pretrained=False, root='~/.mxnet/models', ctx=cpu(0), **kwargs): """Constructs a ResNetV1b-34 model. Parameters ---------- pretrained : bool or str Boolean value controls whether to load the default pretrained weights for model. String value represents the hashtag for a certain version of pretrained weights. root : str, default '~/.mxnet/models' Location for keeping the model parameters. ctx : Context, default CPU The context in which to load the pretrained weights. dilated: bool, default False Whether to apply dilation strategy to ResNetV1b, yielding a stride 8 model. norm_layer : object Normalization layer used (default: :class:`mxnet.gluon.nn.BatchNorm`) Can be :class:`mxnet.gluon.nn.BatchNorm` or :class:`mxnet.gluon.contrib.nn.SyncBatchNorm`. last_gamma : bool, default False Whether to initialize the gamma of the last BatchNorm layer in each bottleneck to zero. use_global_stats : bool, default False Whether forcing BatchNorm to use global statistics instead of minibatch statistics; optionally set to True if finetuning using ImageNet classification pretrained models. """ model = ResNetV1b(BasicBlockV1b, [3, 4, 6, 3], name_prefix='resnetv1b_', **kwargs) if pretrained: from .model_store import get_model_file model.load_parameters(get_model_file('resnet%d_v%db' % (34, 1), tag=pretrained, root=root), ctx=ctx) from ..data import ImageNet1kAttr attrib = ImageNet1kAttr() model.synset = attrib.synset model.classes = attrib.classes model.classes_long = attrib.classes_long return model
def get_efficientnet(model_name, pretrained=False, ctx=mx.cpu(), root='~/.mxnet/models', norm_layer=nn.BatchNorm, norm_kwargs=None, **kwargs): width, depth, res, dropout = efficientnet_params(model_name) net = EfficientNet(width, depth, dropout=dropout, norm_layer=norm_layer, norm_kwargs=norm_kwargs, **kwargs) if pretrained: from gluoncv.model_zoo.model_store import get_model_file net.load_parameters(get_model_file(model_name, tag=pretrained, root=root), ctx=ctx) return net
def get_vgg_extractor(num_layers, pretrained=False, ctx=mx.cpu(), root='/home/kevin/vgg_params', **kwargs): """Get VGG feature extractor networks Parameters ---------- num_layers : int VGG types,can be 11,13,16,19 pretrained : bool or str Boolean value controls whether to load the default pretrained weights for model. String value represents the hashtag for a certain version of pretrained weights. ctx : mx.Context Context such as mx.cpu(), mx.gpu(0). root : str Model weights storing path. Returns ------- mxnet.gluon.HybridBlock The returned network. """ layers, filters = vgg_spec[num_layers] net = VGGExtractor(layers, filters, extra_spec, **kwargs) if pretrained: from gluoncv.model_zoo.model_store import get_model_file batch_norm_suffix = '_bn' if kwargs.get('batch_norm') else '' net.initialize(ctx=ctx) assert num_layers >= 16, "current import_params only support vgg 16 or 19, but got {}".format( num_layers) net.import_params(get_model_file('vgg%d%s' % (num_layers, batch_norm_suffix), tag=pretrained, root=root), ctx=ctx) return net
def resnet101_v1e(pretrained=False, root='~/.mxnet/models', ctx=cpu(0), **kwargs): """Constructs a ResNetV1e-50 model. Parameters ---------- pretrained : bool or str Boolean value controls whether to load the default pretrained weights for model. String value represents the hashtag for a certain version of pretrained weights. root : str, default '~/.mxnet/models' Location for keeping the model parameters. ctx : Context, default CPU The context in which to load the pretrained weights. dilated: bool, default False Whether to apply dilation strategy to ResNetV1b, yielding a stride 8 model. norm_layer : object Normalization layer used (default: :class:`mxnet.gluon.nn.BatchNorm`). Can be :class:`mxnet.gluon.nn.BatchNorm` or :class:`mxnet.gluon.contrib.nn.SyncBatchNorm`. """ model = ResNetV1b(BottleneckV1b, [3, 4, 23, 3], deep_stem=True, avg_down=True, stem_width=64, name_prefix='resnetv1e_', **kwargs) if pretrained: from .model_store import get_model_file model.load_parameters(get_model_file('resnet%d_v%dd' % (101, 1), tag=pretrained, root=root), ctx=ctx) from ..data import ImageNet1kAttr attrib = ImageNet1kAttr() model.synset = attrib.synset model.classes = attrib.classes model.classes_long = attrib.classes_long return model
def get_vgg(num_layers, strides=[(2, 2), (2, 2), (2, 2), (2, 2), (2, 2)], pretrained=False, ctx=cpu(), root='~/.mxnet/models', **kwargs): r"""VGG model from the `"Very Deep Convolutional Networks for Large-Scale Image Recognition" <https://arxiv.org/abs/1409.1556>`_ paper. Parameters ---------- num_layers : int Number of layers for the variant of densenet. Options are 11, 13, 16, 19. pretrained : bool or str Boolean value controls whether to load the default pretrained weights for model. String value represents the hashtag for a certain version of pretrained weights. ctx : Context, default CPU The context in which to load the pretrained weights. root : str, default $MXNET_HOME/models Location for keeping the model parameters. """ layers, filters = vgg_spec[num_layers] net = VGG(layers, filters, strides, **kwargs) if pretrained: from gluoncv.model_zoo.model_store import get_model_file batch_norm_suffix = '_bn' if kwargs.get('batch_norm') else '' net.load_parameters(get_model_file('vgg%d%s' % (num_layers, batch_norm_suffix), tag=pretrained, root=root), ctx=ctx) from gluoncv.data import ImageNet1kAttr attrib = ImageNet1kAttr() net.synset = attrib.synset net.classes = attrib.classes net.classes_long = attrib.classes_long return net
def get_resnet(version, num_layers, pretrained=False, ctx=cpu(), root='~/.mxnet/models', use_se=False, **kwargs): r"""ResNet V1 model from `"Deep Residual Learning for Image Recognition" <http://arxiv.org/abs/1512.03385>`_ paper. ResNet V2 model from `"Identity Mappings in Deep Residual Networks" <https://arxiv.org/abs/1603.05027>`_ paper. Parameters ---------- version : int Version of ResNet. Options are 1, 2. num_layers : int Numbers of layers. Options are 18, 34, 50, 101, 152. pretrained : bool or str Boolean value controls whether to load the default pretrained weights for model. String value represents the hashtag for a certain version of pretrained weights. ctx : Context, default CPU The context in which to load the pretrained weights. root : str, default $MXNET_HOME/models Location for keeping the model parameters. use_se : bool, default False Whether to use Squeeze-and-Excitation module norm_layer : object Normalization layer used (default: :class:`ssd.group_batch_norm.GroupBatchNorm`) norm_kwargs : dict Additional `batch_norm_layer` arguments, for example `bn_group=4` for :class:`ssd.group_batch_norm.GroupBatchNorm`. """ assert num_layers in resnet_spec, \ "Invalid number of layers: %d. Options are %s"%( num_layers, str(resnet_spec.keys())) block_type, layers, channels = resnet_spec[num_layers] assert 1 <= version <= 2, \ "Invalid resnet version: %d. Options are 1 and 2."%version resnet_class = resnet_net_versions[version - 1] block_class = resnet_block_versions[version - 1][block_type] net = resnet_class(block_class, layers, channels, **kwargs) if pretrained: from gluoncv.model_zoo.model_store import get_model_file if not use_se: net.load_parameters(get_model_file('resnet%d_v%d' % (num_layers, version), tag=pretrained, root=root), ctx=ctx) else: net.load_parameters(get_model_file('se_resnet%d_v%d' % (num_layers, version), tag=pretrained, root=root), ctx=ctx) from gluoncv.data import ImageNet1kAttr attrib = ImageNet1kAttr() net.synset = attrib.synset net.classes = attrib.classes net.classes_long = attrib.classes_long return net
def get_resnext(num_layers, strides=[(2, 2), (1, 1), (2, 2), (2, 2), (2, 2)], cardinality=32, bottleneck_width=4, use_se=False, deep_stem=False, avg_down=False, pretrained=False, ctx=cpu(), root=os.path.join('~', '.mxnet', 'models'), **kwargs): r"""ResNext model from `"Aggregated Residual Transformations for Deep Neural Network" <http://arxiv.org/abs/1611.05431>`_ paper. Parameters ---------- num_layers : int Numbers of layers. Options are 50, 101. cardinality: int Number of groups bottleneck_width: int Width of bottleneck block pretrained : bool or str Boolean value controls whether to load the default pretrained weights for model. String value represents the hashtag for a certain version of pretrained weights. ctx : Context, default CPU The context in which to load the pretrained weights. root : str, default '~/.mxnet/models' Location for keeping the model parameters. norm_layer : object Normalization layer used (default: :class:`mxnet.gluon.nn.BatchNorm`) Can be :class:`mxnet.gluon.nn.BatchNorm` or :class:`mxnet.gluon.contrib.nn.SyncBatchNorm`. norm_kwargs : dict Additional `norm_layer` arguments, for example `num_devices=4` for :class:`mxnet.gluon.contrib.nn.SyncBatchNorm`. """ assert num_layers in resnext_spec, \ "Invalid number of layers: %d. Options are %s" % ( num_layers, str(resnext_spec.keys())) layers = resnext_spec[num_layers] net = ResNext(layers, cardinality, bottleneck_width, strides, use_se=use_se, deep_stem=deep_stem, avg_down=avg_down, **kwargs) if pretrained: from gluoncv.model_zoo.model_store import get_model_file if not use_se: net.load_parameters( get_model_file('resnext%d_%dx%dd' % (num_layers, cardinality, bottleneck_width), tag=pretrained, root=root), ctx=ctx) else: net.load_parameters( get_model_file('se_resnext%d_%dx%dd' % (num_layers, cardinality, bottleneck_width), tag=pretrained, root=root), ctx=ctx) from gluoncv.data import ImageNet1kAttr attrib = ImageNet1kAttr() net.synset = attrib.synset net.classes = attrib.classes net.classes_long = attrib.classes_long return net
from gluoncv.data.transforms.presets.imagenet import transform_eval from mxnet import nd, image from gluoncv.model_zoo.model_store import get_model_file from numpy.testing import assert_array_almost_equal if __name__ == "__main__": ctx = mx.gpu(0) input_pic = '../gluon-cv/street.jpg' img = image.imread(input_pic) img = transform_eval(img).as_in_context(ctx) print(img.shape) for num_layers in [16, 19]: for bn in [False, True]: _bn = '_bn' if bn else '' name = 'vgg{}{}'.format(num_layers, _bn) model = get_model_file(name, tag=True, root='models') print('--------------- {} -------------'.format(model)) layers, filters = vgg_spec[num_layers] vgg = VGG(layers, filters, batch_norm=bn) vgg.initialize(ctx=ctx) vgg.load_parameters(model, ctx, ignore_extra=True) vggbase = VGGBase(layers, filters, batch_norm=bn) vggbase.initialize(ctx=ctx) vggbase.import_params(model, ctx) pred1 = vgg(img) pred2 = vggbase(img) print('pred1 shape:', pred1.shape) print('pred2 shape:', pred2.shape) assert_array_almost_equal(pred1.asnumpy(), pred2.asnumpy())
def get_hrnet(model_name, stage_interp_type='nearest', purpose='cls', pretrained=False, ctx=cpu(), root='~/.mxnet/models', norm_layer=BatchNorm, norm_kwargs=None, num_classes=1000, **kwargs): r"""HRNet model from the `"Deep High-Resolution Representation Learning for Visual Recognition" <https://arxiv.org/pdf/1908.07919>`_ paper. Parameters ---------- model_name : string The name of hrnet models: w18_small_v1/w18_small_v2/w30/w32/w40/w42/w48. stage_interp_type : string The interpolation type for upsample in each stage, nearest, bilinear and bilinear_like are supported. purpose: string The purpose of model, cls and seg are supported. pretrained : bool or str Boolean value controls whether to load the default pretrained weights for model. String value represents the hashtag for a certain version of pretrained weights. ctx : Context, default CPU The context in which to load the pretrained weights. root : str, default $MXNET_HOME/models Location for keeping the model parameters. norm_layer : object Normalization layer used (default: :class:`mxnet.gluon.nn.BatchNorm`) Can be :class:`mxnet.gluon.nn.BatchNorm` or :class:`mxnet.gluon.contrib.nn.SyncBatchNorm`. norm_kwargs : dict Additional `norm_layer` arguments, for example `num_devices=4` for :class:`mxnet.gluon.contrib.nn.SyncBatchNorm`. """ if model_name not in HRNET_SPEC.keys(): raise NotImplementedError spec = HRNET_SPEC[model_name] if purpose == 'cls': net = HighResolutionClsNet(spec, stage_interp_type, norm_layer, norm_kwargs, num_classes, **kwargs) from gluoncv.data import ImageNet1kAttr attrib = ImageNet1kAttr() net.synset = attrib.synset net.classes = attrib.classes net.classes_long = attrib.classes_long elif purpose == 'seg': net = HighResolutionSegNet(spec, stage_interp_type, norm_layer, norm_kwargs, num_classes, **kwargs) else: raise NotImplementedError if pretrained: from gluoncv.model_zoo.model_store import get_model_file net.load_parameters(get_model_file('hrnet_%s_%s' % (model_name, purpose), tag=pretrained, root=root), ctx=ctx, ignore_extra=True) return net
def get_mobilenet_v3(model_name, strides=[(2, 2), (2, 2), (2, 2), (2, 2)], multiplier=1., pretrained=False, ctx=cpu(), root='~/.mxnet/models', norm_layer=BatchNorm, norm_kwargs=None, **kwargs): r"""MobileNet model from the `"Searching for MobileNetV3" <https://arxiv.org/abs/1905.02244>`_ paper. Parameters ---------- model_name : string The name of mobilenetv3 models, large and small are supported. multiplier : float The width multiplier for controlling the model size. Only multipliers that are no less than 0.25 are supported. The actual number of channels is equal to the original channel size multiplied by this multiplier. pretrained : bool or str Boolean value controls whether to load the default pretrained weights for model. String value represents the hashtag for a certain version of pretrained weights. ctx : Context, default CPU The context in which to load the pretrained weights. root : str, default $MXNET_HOME/models Location for keeping the model parameters. norm_layer : object Normalization layer used (default: :class:`mxnet.gluon.nn.BatchNorm`) Can be :class:`mxnet.gluon.nn.BatchNorm` or :class:`mxnet.gluon.contrib.nn.SyncBatchNorm`. norm_kwargs : dict Additional `norm_layer` arguments, for example `num_devices=4` for :class:`mxnet.gluon.contrib.nn.SyncBatchNorm`. """ if model_name == "large": cfg = [ # k, exp, c, se, nl, s, [3, 16, 16, False, 'relu', (1, 1)], [3, 64, 24, False, 'relu', strides[0]], [3, 72, 24, False, 'relu', (1, 1)], [5, 72, 40, True, 'relu', strides[1]], [5, 120, 40, True, 'relu', (1, 1)], [5, 120, 40, True, 'relu', (1, 1)], [3, 240, 80, False, 'hard_swish', strides[2]], [3, 200, 80, False, 'hard_swish', (1, 1)], [3, 184, 80, False, 'hard_swish', (1, 1)], [3, 184, 80, False, 'hard_swish', (1, 1)], [3, 480, 112, True, 'hard_swish', (1, 1)], [3, 672, 112, True, 'hard_swish', (1, 1)], [5, 672, 160, True, 'hard_swish', strides[3]], [5, 960, 160, True, 'hard_swish', (1, 1)], [5, 960, 160, True, 'hard_swish', (1, 1)], ] cls_ch_squeeze = 960 cls_ch_expand = 1280 elif model_name == "small": cfg = [ # k, exp, c, se, nl, s, [3, 16, 16, True, 'relu', strides[0]], [3, 72, 24, False, 'relu', strides[1]], [3, 88, 24, False, 'relu', (1, 1)], [5, 96, 40, True, 'hard_swish', strides[2]], [5, 240, 40, True, 'hard_swish', (1, 1)], [5, 240, 40, True, 'hard_swish', (1, 1)], [5, 120, 48, True, 'hard_swish', (1, 1)], [5, 144, 48, True, 'hard_swish', (1, 1)], [5, 288, 96, True, 'hard_swish', strides[3]], [5, 576, 96, True, 'hard_swish', (1, 1)], [5, 576, 96, True, 'hard_swish', (1, 1)], ] cls_ch_squeeze = 576 cls_ch_expand = 1280 else: raise NotImplementedError net = _MobileNetV3(cfg, cls_ch_squeeze, \ cls_ch_expand, multiplier=multiplier, \ final_drop=0.2, norm_layer=norm_layer, **kwargs) if pretrained: from gluoncv.model_zoo.model_store import get_model_file net.load_parameters(get_model_file('mobilenetv3_%s' % model_name, tag=pretrained, root=root), ctx=ctx) from gluoncv.data import ImageNet1kAttr attrib = ImageNet1kAttr() net.synset = attrib.synset net.classes = attrib.classes net.classes_long = attrib.classes_long return net
def get_darknet(pretrained=False, ctx=mx.cpu(), root=os.path.join('models', 'definitions', 'darknet', 'weights'), conv_types=[2, 2, 2, 2, 2, 2], return_features=False, channels_factor=1, **kwargs): """ get a 2D or 2+1D or 3D darknet model with correct transfer of imagenet pretrained weights Args: pretrained: boolean - use imagenet weights ctx: cpu or gpu context? root: the root to store / load the pretrained weights conv_types: a list of len=6 with either 2, 21, or 3 for the conv layer type for layers upto and not including: [2, 5, 10, 27, 44, 53-1] **kwargs: Returns: net: the network """ layers = [1, 2, 8, 8, 4] assert channels_factor in [1, 2, 4, 8, 16] if channels_factor > 1: pretrained = False channels = [ int(n / channels_factor) for n in [32, 64, 128, 256, 512, 1024] ] net = Darknet3D(layers, channels, conv_types, return_features=return_features, **kwargs) net.initialize() if pretrained: if 3 not in conv_types and 21 not in conv_types: net.load_parameters( get_model_file('darknet53', tag=pretrained, root=root), ctx=ctx, ignore_extra=return_features) # we won't have the dense layers return net # transfer weights from 2D base_net = Darknet3D(layers, channels, [2, 2, 2, 2, 2, 2], return_features=return_features, **kwargs) base_net.load_parameters( get_model_file('darknet53', tag=pretrained, root=root), ctx=ctx, ignore_extra=return_features) # we won't have the dense layers base_params = base_net.collect_params() net_params = net.collect_params() if 3 in conv_types: assert 21 not in conv_types for layer_name in net_params: if len(net_params[layer_name].shape) == 5: repetitions = net_params[layer_name].shape[-3] base_layer_name = layer_name.replace( net_params.prefix, base_net.prefix) base_weight = base_params[base_layer_name].data() base_weight = base_weight / repetitions new_weight = mx.nd.repeat(mx.nd.expand_dims(base_weight, axis=-3), repetitions, axis=-3) net.collect_params()[layer_name].set_data(new_weight) else: base_layer_name = layer_name.replace( net_params.prefix, base_net.prefix) new_weight = base_params[base_layer_name].data() net.collect_params()[layer_name].set_data(new_weight) elif 21 in conv_types: assert 3 not in conv_types conv_layer_num = -1 for layer_name in net_params: if len(net_params[layer_name].shape) == 5: if net_params[layer_name].shape[-3] == 3 and net_params[ layer_name].shape[-1] == 1: # the temp conv repetitions = net_params[layer_name].shape[-3] out_channels = net_params[layer_name].shape[0] new_weight = mx.nd.ones(shape=( out_channels, 1, repetitions, 1, 1)) / repetitions net.collect_params()[layer_name].set_data(new_weight) else: # the spatial conv conv_layer_num += 1 repetitions = net_params[layer_name].shape[-3] base_layer_name = layer_name.replace( net_params.prefix, base_net.prefix) base_layer_name = base_layer_name.split( '_')[0] + '_conv' + str(conv_layer_num) + '_weight' base_weight = base_params[base_layer_name].data() base_weight = base_weight / repetitions new_weight = mx.nd.expand_dims(base_weight, axis=-3) net.collect_params()[layer_name].set_data(new_weight) else: if 'conv' in layer_name: conv_layer_num += 1 base_layer_name = layer_name.replace( net_params.prefix, base_net.prefix) base_layer_name = base_layer_name.split( '_')[0] + '_conv' + str(conv_layer_num) + '_weight' else: base_layer_name = layer_name.replace( net_params.prefix, base_net.prefix) new_weight = base_params[base_layer_name].data() net.collect_params()[layer_name].set_data(new_weight) net.collect_params().reset_ctx(ctx) return net
def generate_models(model_name, nclass=400, pretrained=False, pretrained_base=True, use_tsn=False, partial_bn=False, num_segments=1, num_crop=1, root='~/.mxnet/models', ctx=mx.cpu(), **kwargs): r"""ResNet18 model trained on Kinetics400 dataset. Parameters ---------- nclass : int. Number of categories in the dataset. pretrained : bool or str. Boolean value controls whether to load the default pretrained weights for model. String value represents the hashtag for a certain version of pretrained weights. pretrained_base : bool or str, optional, default is True. Load pretrained base network, the extra layers are randomized. Note that if pretrained is `True`, this has no effect. ctx : Context, default CPU. The context in which to load the pretrained weights. root : str, default $MXNET_HOME/models Location for keeping the model parameters. num_segments : int, default is 1. Number of segments used to evenly divide a video. num_crop : int, default is 1. Number of crops used during evaluation, choices are 1, 3 or 10. partial_bn : bool, default False. Freeze all batch normalization layers during training except the first layer. """ modality = kwargs['modality'] in_channels = 3 if modality == 'rgb' else 20 model = ActionRecResNetV1bCustom(depth=18, nclass=nclass, partial_bn=partial_bn, num_segments=num_segments, num_crop=num_crop, dropout_ratio=0.5, init_std=0.01, modality=modality, in_channels=in_channels) if pretrained: from gluoncv.model_zoo.model_store import get_model_file params_dict = mx.nd.load( get_model_file('resnet18_v1b_kinetics400', tag=pretrained, root=root)) if modality == 'tvl1_flow': params_dict = change_key_names(params_dict, in_channels=20) model.load_dict(params_dict, ctx=ctx) from gluoncv.data import Kinetics400Attr attrib = Kinetics400Attr() model.classes = attrib.classes model.collect_params().reset_ctx(ctx) return model
import os import mxnet as mx from gluoncv.model_zoo.model_store import get_model_file mxnet_gluon_repo = os.environ.get("MXNET_GLUON_REPO", None) if not mxnet_gluon_repo: os.environ["MXNET_GLUON_REPO"] = "https://apache-mxnet.s3.cn-north-1.amazonaws.com.cn" num_layers = 50 version = 1 pretrained = True root = "./pretrained" file_path = get_model_file('resnet%d_v%d' % (num_layers, version), tag=pretrained, root=root) print("models is saved in {}".format(file_path)) gcv_params = mx.nd.load(file_path) cvt_params = dict() for k in gcv_params: if not k.startswith("features"): continue k_list = k.split(".") if k_list[1] == "0": cvt_k = "arg:conv0_" + k_list[2] cvt_params[cvt_k] = gcv_params[k] elif k_list[1] == "1": if k_list[-1].endswith("running_mean"): cvt_k = "aux:bn0_moving_mean" elif k_list[-1].endswith("running_var"): cvt_k = "aux:bn0_moving_var" else: