code: def test_cuda_tensor_core(model_name, input_shape):
      """Integration tests of auto tensorization with CUDA tensor core"""
      target = tvm.target.Target("nvidia/geforce-rtx-3070")
      dev = tvm.cuda()
      if model_name.startswith("bert"):
          data = tvm.nd.array(
              np.random.randint(0, 30521, size=input_shape), dev
          )  # embedding size
      else:
          data = tvm.nd.array(
              np.random.randn(*input_shape).astype("float32"), dev
          )
      mod, params, (input_name, _, _) = relay_workload.get_network(
          model_name, input_shape
      )
      seq = tvm.transform.Sequential(
          [
              relay.transform.ToMixedPrecision(),
          ]
      )
      with tvm.transform.PassContext(opt_level=3):
          mod = seq(mod)
  
      def convert_layout(mod):
          seq = tvm.transform.Sequential(
              [
                  relay.transform.ConvertLayout(
                      {"nn.conv2d": ["NHWC", "OHWI"]}
                  )
              ]
          )
          with tvm.transform.PassContext(opt_level=3):
              mod = seq(mod)
          return mod
  
      with tempfile.TemporaryDirectory() as work_dir:
          with ms.Profiler() as profiler:
              converted_mod = convert_layout(mod)
              database = ms.relay_integration.tune_relay(
                  mod=converted_mod,
                  target=target,
                  work_dir=work_dir,
                  max_trials_global=3000,
                  params=params,
              )
              rt_mod1 = ms.relay_integration.compile_relay(
                  database=database,
                  mod=converted_mod,
                  target=target,
                  params=params,
              )
          print(profiler.table())
  
          # Compile without MetaSchedule for correctness check
          with tvm.transform.PassContext(opt_level=0):
              rt_mod2 = relay.build(mod, target=target, params=params)
  
          def get_output(data, lib):
              module = tvm.contrib.graph_executor.GraphModule(
                  lib["default"](dev)
              )
              module.set_input(input_name, data)
              module.run()
              return module.get_output(0).numpy()
  
          # Check correctness
          actual_output = get_output(data, rt_mod1)
          expected_output = get_output(data, rt_mod2)
          assert np.allclose(
              actual_output, expected_output, rtol=1e-2, atol=2e-2
          )
  
imports: import tempfile
  import numpy
  import pytest
  import tvm
  import tvm.testing
  import tvm.topi.testing
  from tvm import meta_schedule
  from tvm import relay
  from tvm.meta_schedule.testing import relay_workload
  from tvm.meta_schedule.testing.tlcbench import load_quantized_bert_base
  from tvm.tir.tensor_intrin.arm_cpu import DP4A_INTRIN
  from tvm.tir.tensor_intrin.rocm import AMDGPU_SDOT4_INTRIN
  from tvm.tir.tensor_intrin.x86 import VNNI_DOT_16x4_INTRIN
  from tvm.tir.tensor_intrin.x86 import AVX512_DOT_16x4_INTRIN
label_desc: Use image node_id 16 for calling a global function with example usage: test_cuda_tensor_core(model_name, input_shape) and returns: mod, module