code: def get_ssd(
      name,
      base_size,
      features,
      filters,
      sizes,
      ratios,
      steps,
      classes,
      dataset,
      pretrained=False,
      pretrained_base=True,
      ctx=mx.cpu(),
      root=os.path.join("~", ".mxnet", "models"),
      anchor_generator=SSDAnchorGenerator,
      **kwargs,
  ):
      """Get SSD models.
  
      Parameters
      ----------
      name : str or None
          Model name, if `None` is used, you must specify `features` to be a `HybridBlock`.
      base_size : int
          Base image size for training, this is fixed once training is assigned.
          A fixed base size still allows you to have variable input size during test.
      features : iterable of str or `HybridBlock`
          List of network internal output names, in order to specify which layers are
          used for predicting bbox values.
          If `name` is `None`, `features` must be a `HybridBlock` which generate multiple
          outputs for prediction.
      filters : iterable of float or None
          List of convolution layer channels which is going to be appended to the base
          network feature extractor. If `name` is `None`, this is ignored.
      sizes : iterable fo float
          Sizes of anchor boxes, this should be a list of floats, in incremental order.
          The length of `sizes` must be len(layers) + 1. For example, a two stage SSD
          model can have ``sizes = [30, 60, 90]``, and it converts to `[30, 60]` and
          `[60, 90]` for the two stages, respectively. For more details, please refer
          to original paper.
      ratios : iterable of list
          Aspect ratios of anchors in each output layer. Its length must be equals
          to the number of SSD output layers.
      steps : list of int
          Step size of anchor boxes in each output layer.
      classes : iterable of str
          Names of categories.
      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.
      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 : mxnet.Context
          Context such as mx.cpu(), mx.gpu(0).
      root : str
          Model weights storing path.
      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`.
  
      Returns
      -------
      HybridBlock
          A SSD detection network.
      """
      pretrained_base = False if pretrained else pretrained_base
      base_name = None if callable(features) else name
      net = SSD(
          base_name,
          base_size,
          features,
          filters,
          sizes,
          ratios,
          steps,
          pretrained=pretrained_base,
          classes=classes,
          ctx=ctx,
          root=root,
          minimal_opset=pretrained,
          anchor_generator=anchor_generator,
          **kwargs,
      )
      if pretrained:
          from ..model_store import get_model_file
  
          full_name = "_".join(("ssd", str(base_size), name, dataset))
          net.load_parameters(
              get_model_file(full_name, tag=pretrained, root=root),
              ctx=ctx,
          )
      return net
  
imports: from __future__ import absolute_import
  import os
  import warnings
  import mxnet
  from mxnet import autograd
  from mxnet.gluon import nn
  from mxnet.gluon import HybridBlock
  from ...nn.feature import FeatureExpander
  from .anchor import SSDAnchorGenerator
  from ...nn.predictor import ConvPredictor
  from ...nn.coder import MultiPerClassDecoder, NormalizedBoxCenterDecoder
  from .vgg_atrous import vgg16_atrous_300, vgg16_atrous_512
label_desc: Use image node_id 1 for calling a global function with example usage: get_ssd(name, base_size, features, filters, sizes, ratios, steps, classes, dataset, pretrained, pretrained_base, ctx, root, anchor_generator) and returns: net