code: def get_yolov3(
      name,
      stages,
      filters,
      anchors,
      strides,
      classes,
      dataset,
      pretrained=False,
      ctx=mx.cpu(),
      root=os.path.join("~", ".mxnet", "models"),
      **kwargs,
  ):
      """Get YOLOV3 models.
      Parameters
      ----------
      name : str or None
          Model name, if `None` is used, you must specify `features` to be a `HybridBlock`.
      stages : 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 YOLOV3 detection network.
      """
      net = YOLOV3(
          stages, filters, anchors, strides, classes=classes, **kwargs
      )
      if pretrained:
          from ..model_store import get_model_file
  
          full_name = "_".join(("yolo3", name, dataset))
          net.load_parameters(
              get_model_file(full_name, tag=pretrained, root=root),
              ctx=ctx,
          )
      return net
  
imports: from __future__ import absolute_import
  from __future__ import division
  import os
  import warnings
  import numpy
  import mxnet
  from mxnet import gluon
  from mxnet import autograd
  from mxnet.gluon import nn
  from mxnet.gluon.nn import BatchNorm
  from .darknet import _conv2d, darknet53
  from ..mobilenet import get_mobilenet
  from .yolo_target import YOLOV3TargetMerger
  from ...loss import YOLOV3Loss
label_desc: Use image node_id 2 for calling a global function with example usage: get_yolov3(name, stages, filters, anchors, strides, classes, dataset, pretrained, ctx, root) and returns: net