code: def test_dot_real(data_dict):
      """Dot operator testing with real datasets"""
      data_dir = os.path.join(os.getcwd(), "data")
  
      path = os.path.join(data_dir, data_dict["data_name"])
      if not os.path.exists(path):
          get_bz2_data(
              data_dir,
              data_dict["data_name"],
              data_dict["url"],
              data_dict["data_origin_name"],
          )
          assert os.path.exists(path)
  
      k = data_dict["feature_dim"]
      m = data_dict["m"]
      batch_size_list = data_dict["batch_size"]
  
      default_output_index = data_dict["default_index"]["output_dim"]
      default_batch_size_index = data_dict["default_index"][
          "batch_size"
      ]
      density = estimate_density(path, data_dict["feature_dim"])
      num_batches = data_dict["num_batches"]
  
      assert default_batch_size_index < len(batch_size_list)
      assert default_output_index < len(m)
      if ARGS.verbose:
          print(
              f"Running Benchmarking on {repr(data_dict['data_mini'])} data"
          )
      print(
          "{:>15} {:>10} {:>10} {:>10} {:>20} {:>15} {:>15} {:>10} {:>10}".format(
              "density(%)",
              "n",
              "m",
              "k",
              "t_dense/t_sparse",
              "t_dense(ms)",
              "t_sparse(ms)",
              "is_transpose",
              "rhs_rsp",
          )
      )
  
      for output_dim in m:
          _compare_sparse_dense(
              data_dir,
              data_dict["data_name"],
              data_dict["data_mini"],
              k,
              output_dim,
              density,
              batch_size_list[default_batch_size_index],
              num_batches,
          )
          _compare_sparse_dense(
              data_dir,
              data_dict["data_name"],
              data_dict["data_mini"],
              k,
              output_dim,
              density,
              batch_size_list[default_batch_size_index],
              num_batches,
              transpose=True,
          )
          _compare_sparse_dense(
              data_dir,
              data_dict["data_name"],
              data_dict["data_mini"],
              k,
              output_dim,
              density,
              batch_size_list[default_batch_size_index],
              num_batches,
              rsp=True,
          )
  
      for batch_size in batch_size_list:
          _compare_sparse_dense(
              data_dir,
              data_dict["data_name"],
              data_dict["data_mini"],
              k,
              m[default_output_index],
              density,
              batch_size,
              num_batches,
          )
          _compare_sparse_dense(
              data_dir,
              data_dict["data_name"],
              data_dict["data_mini"],
              k,
              m[default_output_index],
              density,
              batch_size,
              num_batches,
              transpose=True,
          )
          _compare_sparse_dense(
              data_dir,
              data_dict["data_name"],
              data_dict["data_mini"],
              k,
              output_dim,
              density,
              batch_size_list[default_batch_size_index],
              num_batches,
              rsp=True,
          )
  
file_path: mxnet/benchmark/python/sparse/dot.py
imports: import ctypes
  import os
  import time
  import argparse
  import subprocess
  import scipy.sparse
  import mxnet
  import numpy
  import numpy.random
  from mxnet.test_utils import rand_ndarray, set_default_device, assert_almost_equal, get_bz2_data
  from mxnet.base import check_call, _LIB
  from util import estimate_density
label_desc: Use image node_id 5 for calling a global function with example usage: test_dot_real(data_dict) without return types