code: def parametrize(param_name, params):
      """Decorator for benchmarking over a set of parameters.
  
      Parameters
      ----------
      param_name : str
          Parameter name. Must be one of the arguments of the decorated function.
      params : list[any]
          List of values to benchmark for the given parameter name. Recommend
          to use Python's native object type (e.g., int, str, list[int]) because
          ASV will display them on the plot.
  
      Examples
      --------
  
      Benchmark function `foo` when argument `x` is equal to 10 or 20.
  
      .. code::
          @benchmark('time')
          @parametrize('x', [10, 20]):
          def foo(x):
              pass
  
      Benchmark function with multiple parametrizations. It will run the function
      with all possible combinations. The example below generates 6 benchmarks.
  
      .. code::
          @benchmark('time')
          @parametrize('x', [10, 20]):
          @parametrize('y', [-1, -2, -3]):
          def foo(x, y):
              pass
  
      When using multiple parametrizations, it can have arbitrary order. The example
      below is the same as the above one.
  
      .. code::
          @benchmark('time')
          @parametrize('y', [-1, -2, -3]):
          @parametrize('x', [10, 20]):
          def foo(x, y):
              pass
      """
  
      def _wrapper(func):
          sig_params = inspect.signature(func).parameters.keys()
          num_params = len(sig_params)
          if getattr(func, "params", None) is None:
              func.params = [None] * num_params
          if getattr(func, "param_names", None) is None:
              func.param_names = [None] * num_params
          found_param = False
          for i, sig_param in enumerate(sig_params):
              if sig_param == param_name:
                  func.params[i] = params
                  func.param_names[i] = param_name
                  found_param = True
                  break
          if not found_param:
              raise ValueError("Invalid parameter name:", param_name)
          return func
  
      return _wrapper
  
imports: import inspect
  import json
  import os
  import pickle
  import shutil
  import time
  import zipfile
  from functools import partial, reduce, wraps
  from timeit import default_timer
  import dgl
  import numpy
  import pandas
  import requests
  import torch
  from ogb.nodeproppred import DglNodePropPredDataset
  import traceback
  from _thread import start_new_thread
  import torch.multiprocessing
label_desc: Use image node_id 15 for calling a global function with example usage: parametrize(param_name, params) and returns: _wrapper, func