code: def get_network(name, batch_size, dtype="float32"):
      """Get the symbol definition and random weight of a network
  
      Parameters
      ----------
      name: str
          The name of the network, can be 'resnet-18', 'resnet-50', 'vgg-16', 'inception_v3', 'mobilenet', ...
      batch_size: int
          batch size
      dtype: str
          Data type
  
      Returns
      -------
      net: tvm.IRModule
          The relay function of network definition
      params: dict
          The random parameters for benchmark
      input_shape: tuple
          The shape of input tensor
      output_shape: tuple
          The shape of output tensor
      """
      input_shape = (batch_size, 3, 224, 224)
      output_shape = (batch_size, 1000)
  
      if name == "mobilenet":
          net, params = testing.mobilenet.get_workload(
              batch_size=batch_size, dtype=dtype
          )
      elif name == "inception_v3":
          input_shape = (batch_size, 3, 299, 299)
          net, params = testing.inception_v3.get_workload(
              batch_size=batch_size, dtype=dtype
          )
      elif "resnet" in name:
          n_layer = int(name.split("-")[1])
          net, params = testing.resnet.get_workload(
              num_layers=n_layer, batch_size=batch_size, dtype=dtype
          )
      elif "vgg" in name:
          n_layer = int(name.split("-")[1])
          net, params = testing.vgg.get_workload(
              num_layers=n_layer, batch_size=batch_size, dtype=dtype
          )
      elif "densenet" in name:
          n_layer = int(name.split("-")[1])
          net, params = testing.densenet.get_workload(
              densenet_size=n_layer, batch_size=batch_size, dtype=dtype
          )
      elif "squeezenet" in name:
          version = name.split("_v")[1]
          net, params = testing.squeezenet.get_workload(
              batch_size=batch_size, version=version, dtype=dtype
          )
      elif name == "mxnet":
          # an example for mxnet model
          from mxnet.gluon.model_zoo.vision import get_model
  
          block = get_model("resnet18_v1", pretrained=True)
          net, params = relay.frontend.from_mxnet(
              block, shape={"data": input_shape}, dtype=dtype
          )
          net = net["main"]
          net = relay.Function(
              net.params,
              relay.nn.softmax(net.body),
              None,
              net.type_params,
              net.attrs,
          )
          net = tvm.IRModule.from_expr(net)
      else:
          raise ValueError("Unsupported network: " + name)
  
      return net, params, input_shape, output_shape
  
file_path: tvm/apps/benchmark/adreno/adreno_gpu_bench_clml.py
imports: import argparse
  import numpy
  import os
  import sys
  import tvm
  from tvm import te
  from tvm.relay import testing
  from tvm.contrib.utils import tempdir
  from tvm.relay.op.contrib import clml
  import tvm.contrib.graph_executor
  from tvm import relay
  from tvm import autotvm
  from tvm.contrib import utils, ndk
label_desc: Use image node_id 1 for calling a global function with example usage: get_network(name, batch_size, dtype) and returns: net,  params,  input_shape,  output_shape