code: def get_network(
      model_name,
      ctx_l,
      dropout=0.1,
      checkpoint_path=None,
      backbone_path=None,
      dtype="float32",
  ):
      """
      Get the network that fine-tune the Question Answering Task
  
      Parameters
      ----------
      model_name : str
          The model name of the backbone model
      ctx_l :
          Context list of training device like [mx.gpu(0), mx.gpu(1)]
      dropout : float
          Dropout probability of the task specified layer
      checkpoint_path: str
          Path to a Fine-tuned checkpoint
      backbone_path: str
          Path to the backbone model to be loaded in qa_net
  
      Returns
      -------
      cfg
      tokenizer
      qa_net
      use_segmentation
      """
      # Create the network
      use_segmentation = (
          "roberta" not in model_name and "xlmr" not in model_name
      )
      Model, cfg, tokenizer, download_params_path, _ = get_backbone(
          model_name, load_backbone=not backbone_path
      )
      backbone = Model.from_cfg(cfg, use_pooler=False, dtype=dtype)
      # Load local backbone parameters if backbone_path provided.
      # Otherwise, download backbone parameters from gluon zoo.
  
      backbone_params_path = (
          backbone_path if backbone_path else download_params_path
      )
      if checkpoint_path is None:
          backbone.load_parameters(
              backbone_params_path,
              ignore_extra=True,
              ctx=ctx_l,
              cast_dtype=True,
          )
          num_params, num_fixed_params = count_parameters(
              deduplicate_param_dict(backbone.collect_params())
          )
          logging.info(
              "Loading Backbone Model from {}, with total/fixd parameters={}/{}".format(
                  backbone_params_path, num_params, num_fixed_params
              )
          )
      qa_net = ModelForQAConditionalV1(
          backbone=backbone,
          dropout_prob=dropout,
          use_segmentation=use_segmentation,
          weight_initializer=TruncNorm(stdev=0.02),
      )
      if checkpoint_path is None:
          # Ignore the UserWarning during initialization,
          # There is no need to re-initialize the parameters of backbone
          qa_net.initialize(ctx=ctx_l)
      else:
          qa_net.load_parameters(
              checkpoint_path, ctx=ctx_l, cast_dtype=True
          )
      qa_net.hybridize()
  
      return cfg, tokenizer, qa_net, use_segmentation
  
imports: import os
  import json
  import time
  import logging
  import argparse
  import ast
  import functools
  import collections
  import dataclasses
  from dataclasses import dataclass
  from multiprocessing import Pool, cpu_count
  import mxnet
  import numpy
  from mxnet.lr_scheduler import PolyScheduler
  import gluonnlp.data.batchify
  from models import ModelForQABasic, ModelForQAConditionalV1
  from eval_utils import squad_eval
  from squad_utils import SquadFeature, get_squad_examples, convert_squad_example_to_feature
  from gluonnlp.models import get_backbone
  from gluonnlp.utils.misc import repeat, grouper, set_seed, init_comm, logging_config, parse_ctx
  from gluonnlp.initializer import TruncNorm
  from gluonnlp.data.sampler import SplitSampler
  from gluonnlp.utils.parameter import grad_global_norm, clip_grad_global_norm, count_parameters, deduplicate_param_dict
label_desc: Use image node_id 3 for calling a global function with example usage: get_network(model_name, ctx_l, dropout, checkpoint_path, backbone_path, dtype) and returns: cfg,  tokenizer,  qa_net,  use_segmentation