code: def get_ssh_conv(data):
      """
      shared convolutional layers
      :param data: Symbol
      :return: Symbol
      """
      # group 1
      # conv1_1 = mx.symbol.Convolution(
      #    data=data, kernel=(3, 3), pad=(1, 1), num_filter=64, workspace=2048, name="conv1_1")
      # relu1_1 = mx.symbol.Activation(data=conv1_1, act_type="relu", name="relu1_1")
      relu1_1 = conv_act_layer(
          data,
          "conv1_1",
          64,
          kernel=(3, 3),
          pad=(1, 1),
          stride=(1, 1),
          act_type="relu",
      )
      # conv1_2 = mx.symbol.Convolution(
      #    data=relu1_1, kernel=(3, 3), pad=(1, 1), num_filter=64, workspace=2048, name="conv1_2")
      # relu1_2 = mx.symbol.Activation(data=conv1_2, act_type="relu", name="relu1_2")
      relu1_2 = conv_act_layer(
          relu1_1,
          "conv1_2",
          64,
          kernel=(3, 3),
          pad=(1, 1),
          stride=(1, 1),
          act_type="relu",
      )
      pool1 = mx.symbol.Pooling(
          data=relu1_2,
          pool_type="max",
          kernel=(2, 2),
          stride=(2, 2),
          name="pool1",
      )
      # group 2
      # conv2_1 = mx.symbol.Convolution(
      #    data=pool1, kernel=(3, 3), pad=(1, 1), num_filter=128, workspace=2048, name="conv2_1")
      # relu2_1 = mx.symbol.Activation(data=conv2_1, act_type="relu", name="relu2_1")
      relu2_1 = conv_act_layer(
          pool1,
          "conv2_1",
          128,
          kernel=(3, 3),
          pad=(1, 1),
          stride=(1, 1),
          act_type="relu",
      )
      # conv2_2 = mx.symbol.Convolution(
      #    data=relu2_1, kernel=(3, 3), pad=(1, 1), num_filter=128, workspace=2048, name="conv2_2")
      # relu2_2 = mx.symbol.Activation(data=conv2_2, act_type="relu", name="relu2_2")
      relu2_2 = conv_act_layer(
          relu2_1,
          "conv2_2",
          128,
          kernel=(3, 3),
          pad=(1, 1),
          stride=(1, 1),
          act_type="relu",
      )
      pool2 = mx.symbol.Pooling(
          data=relu2_2,
          pool_type="max",
          kernel=(2, 2),
          stride=(2, 2),
          name="pool2",
      )
      # group 3
      # conv3_1 = mx.symbol.Convolution(
      #    data=pool2, kernel=(3, 3), pad=(1, 1), num_filter=256, workspace=2048, name="conv3_1")
      # relu3_1 = mx.symbol.Activation(data=conv3_1, act_type="relu", name="relu3_1")
      relu3_1 = conv_act_layer(
          pool2,
          "conv3_1",
          256,
          kernel=(3, 3),
          pad=(1, 1),
          stride=(1, 1),
          act_type="relu",
      )
      # conv3_2 = mx.symbol.Convolution(
      #    data=relu3_1, kernel=(3, 3), pad=(1, 1), num_filter=256, workspace=2048, name="conv3_2")
      # relu3_2 = mx.symbol.Activation(data=conv3_2, act_type="relu", name="relu3_2")
      relu3_2 = conv_act_layer(
          relu3_1,
          "conv3_2",
          256,
          kernel=(3, 3),
          pad=(1, 1),
          stride=(1, 1),
          act_type="relu",
      )
      # conv3_3 = mx.symbol.Convolution(
      #    data=relu3_2, kernel=(3, 3), pad=(1, 1), num_filter=256, workspace=2048, name="conv3_3")
      # relu3_3 = mx.symbol.Activation(data=conv3_3, act_type="relu", name="relu3_3")
      relu3_3 = conv_act_layer(
          relu3_2,
          "conv3_3",
          256,
          kernel=(3, 3),
          pad=(1, 1),
          stride=(1, 1),
          act_type="relu",
      )
      pool3 = mx.symbol.Pooling(
          data=relu3_3,
          pool_type="max",
          kernel=(2, 2),
          stride=(2, 2),
          name="pool3",
      )
      # group 4
      # conv4_1 = mx.symbol.Convolution(
      #    data=pool3, kernel=(3, 3), pad=(1, 1), num_filter=512, workspace=2048, name="conv4_1")
      # relu4_1 = mx.symbol.Activation(data=conv4_1, act_type="relu", name="relu4_1")
      relu4_1 = conv_act_layer(
          pool3,
          "conv4_1",
          512,
          kernel=(3, 3),
          pad=(1, 1),
          stride=(1, 1),
          act_type="relu",
      )
      # conv4_2 = mx.symbol.Convolution(
      #    data=relu4_1, kernel=(3, 3), pad=(1, 1), num_filter=512, workspace=2048, name="conv4_2")
      # relu4_2 = mx.symbol.Activation(data=conv4_2, act_type="relu", name="relu4_2")
      relu4_2 = conv_act_layer(
          relu4_1,
          "conv4_2",
          512,
          kernel=(3, 3),
          pad=(1, 1),
          stride=(1, 1),
          act_type="relu",
      )
      # conv4_3 = mx.symbol.Convolution(
      #    data=relu4_2, kernel=(3, 3), pad=(1, 1), num_filter=512, workspace=2048, name="conv4_3")
      # relu4_3 = mx.symbol.Activation(data=conv4_3, act_type="relu", name="relu4_3")
      relu4_3 = conv_act_layer(
          relu4_2,
          "conv4_3",
          512,
          kernel=(3, 3),
          pad=(1, 1),
          stride=(1, 1),
          act_type="relu",
      )
      pool4 = mx.symbol.Pooling(
          data=relu4_3,
          pool_type="max",
          kernel=(2, 2),
          stride=(2, 2),
          name="pool4",
      )
      # group 5
      # conv5_1 = mx.symbol.Convolution(
      #    data=pool4, kernel=(3, 3), pad=(1, 1), num_filter=512, workspace=2048, name="conv5_1")
      # relu5_1 = mx.symbol.Activation(data=conv5_1, act_type="relu", name="relu5_1")
      relu5_1 = conv_act_layer(
          pool4,
          "conv5_1",
          512,
          kernel=(3, 3),
          pad=(1, 1),
          stride=(1, 1),
          act_type="relu",
      )
      # conv5_2 = mx.symbol.Convolution(
      #    data=relu5_1, kernel=(3, 3), pad=(1, 1), num_filter=512, workspace=2048, name="conv5_2")
      # relu5_2 = mx.symbol.Activation(data=conv5_2, act_type="relu", name="relu5_2")
      relu5_2 = conv_act_layer(
          relu5_1,
          "conv5_2",
          512,
          kernel=(3, 3),
          pad=(1, 1),
          stride=(1, 1),
          act_type="relu",
      )
      # conv5_3 = mx.symbol.Convolution(
      #    data=relu5_2, kernel=(3, 3), pad=(1, 1), num_filter=512, workspace=2048, name="conv5_3")
      # relu5_3 = mx.symbol.Activation(data=conv5_3, act_type="relu", name="relu5_3")
      relu5_3 = conv_act_layer(
          relu5_2,
          "conv5_3",
          512,
          kernel=(3, 3),
          pad=(1, 1),
          stride=(1, 1),
          act_type="relu",
      )
      m3_pool = mx.sym.Pooling(
          data=relu5_3,
          kernel=(2, 2),
          stride=(2, 2),
          pad=(0, 0),
          pool_type="max",
      )
      if config.SSH_MODE <= 5:
          # if FPN:
          #  relu4_3, relu5_3, m3_pool = get_feat_down([m3_pool, relu5_3, relu4_3])
  
          F1 = 256
          F2 = 128
          if config.SSH_MODE == 1:
              F2 = 256
          _bwm = 1.0
          conv4_128 = conv_act_layer(
              relu4_3,
              "ssh_m1_red_conv",
              F2,
              kernel=(1, 1),
              pad=(0, 0),
              stride=(1, 1),
              act_type="relu",
              bias_wd_mult=_bwm,
          )
          conv5_128 = conv_act_layer(
              relu5_3,
              "ssh_m2_red_conv",
              F2,
              kernel=(1, 1),
              pad=(0, 0),
              stride=(1, 1),
              act_type="relu",
              bias_wd_mult=_bwm,
          )
          conv5_128_up = mx.symbol.Deconvolution(
              data=conv5_128,
              num_filter=F2,
              kernel=(4, 4),
              stride=(2, 2),
              pad=(1, 1),
              num_group=F2,
              no_bias=True,
              attr={"__lr_mult__": "0.0", "__wd_mult__": "0.0"},
              name="ssh_m2_red_upsampling",
          )
          # conv5_128_up = mx.symbol.UpSampling(conv5_128, scale=2, sample_type='nearest', workspace=512, name='ssh_m2_red_up', num_args=1)
          conv4_128 = mx.symbol.Crop(*[conv4_128, conv5_128_up])
          # conv5_128_up = mx.symbol.Crop(*[conv5_128_up, conv4_128])
  
          conv_sum = conv4_128 + conv5_128_up
          # conv_sum = conv_1x1
  
          m1_conv = conv_act_layer(
              conv_sum,
              "ssh_m1_conv",
              F2,
              kernel=(3, 3),
              pad=(1, 1),
              stride=(1, 1),
              act_type="relu",
              bias_wd_mult=_bwm,
          )
          m1 = ssh_detection_module(m1_conv, F2, "ssh_m1_det")
          m2 = ssh_detection_module(relu5_3, F1, "ssh_m2_det")
          m3 = ssh_detection_module(m3_pool, F1, "ssh_m3_det")
          return {8: m1, 16: m2, 32: m3}
      else:
          F1 = 256
          F2 = 256
          _bwm = 1.0
          conv4_128 = conv_act_layer(
              relu4_3,
              "ssh_m1_red_conv",
              F2,
              kernel=(1, 1),
              pad=(0, 0),
              stride=(1, 1),
              act_type="relu",
              bias_wd_mult=_bwm,
          )
          conv5_128 = conv_act_layer(
              relu5_3,
              "ssh_m2_red_conv",
              F2,
              kernel=(1, 1),
              pad=(0, 0),
              stride=(1, 1),
              act_type="relu",
              bias_wd_mult=_bwm,
          )
          conv5_128_up = mx.symbol.Deconvolution(
              data=conv5_128,
              num_filter=F2,
              kernel=(4, 4),
              stride=(2, 2),
              pad=(1, 1),
              num_group=F2,
              no_bias=True,
              attr={"__lr_mult__": "0.0", "__wd_mult__": "0.0"},
              name="ssh_m2_red_upsampling",
          )
          # conv5_128_up = mx.symbol.UpSampling(conv5_128, scale=2, sample_type='nearest', workspace=512, name='ssh_m2_red_up', num_args=1)
          conv4_128 = mx.symbol.Crop(*[conv4_128, conv5_128_up])
          # conv5_128_up = mx.symbol.Crop(*[conv5_128_up, conv4_128])
  
          conv_sum = conv4_128 + conv5_128_up
          m1_conv = conv_act_layer(
              conv_sum,
              "ssh_m1_conv",
              F2,
              kernel=(3, 3),
              pad=(1, 1),
              stride=(1, 1),
              act_type="relu",
              bias_wd_mult=_bwm,
          )
          m1 = cpm(m1_conv, "ssh_m1_det")
          m2 = cpm(relu5_3, "ssh_m2_det")
          m3 = cpm(m3_pool, "ssh_m3_det")
          return {8: m1, 16: m2, 32: m3}
  
file_path: insightface/detection/retinaface/rcnn/symbol/symbol_ssh.py
imports: import mxnet
  import numpy
  from rcnn.config import config
  from rcnn.PY_OP import rpn_fpn_ohem3
label_desc: Use image node_id 7 for calling a global function with example usage: get_ssh_conv(data) and returns: dict, dict