code: def schedule_bitserial_dense(cfg, outs):
      """Schedule for bitserial_dense.
  
      Parameters
      ----------
      outs: Array of Tensor
          The computation graph description of bitserial dense operator.
          in the format of an array of tensors.
  
      Returns
      -------
      s: Schedule
          The computation schedule for bitserial_dense.
      """
      outs = [outs] if isinstance(outs, te.tensor.Tensor) else outs
      s = te.create_schedule([x.op for x in outs])
  
      def _schedule(cfg, s, data_vec, weight_vec, output):
          s[data_vec].parallel(s[data_vec].op.axis[0])
          s[weight_vec].parallel(s[weight_vec].op.axis[0])
  
          y, x = s[output].op.axis
          wb, db, k = s[output].op.reduce_axis
  
          yo, yi = cfg["tile_y"].apply(s, output, y)
          xo, xi = cfg["tile_x"].apply(s, output, x)
          ko, ki = cfg["tile_k"].apply(s, output, k)
  
          cfg["reorder_0"].apply(
              s, output, [yo, xo, ko, yi, wb, db, ki, xi]
          )
          cfg["ann_reduce"].apply(
              s,
              output,
              [db, wb],
              axis_lens=[
                  get_const_int(db.dom.extent),
                  get_const_int(wb.dom.extent),
              ],
              max_unroll=8,
              cfg=cfg,
          )
          cfg["ann_spatial"].apply(
              s,
              output,
              [yi, xi],
              axis_lens=[
                  cfg["tile_y"].size[-1],
                  cfg["tile_x"].size[-1],
              ],
              max_unroll=8,
              cfg=cfg,
          )
          s[output].vectorize(xi)
          s[output].parallel(yo)
          return s
  
      def traverse(op):
          """Internal traverse function"""
          # inline all one-to-one-mapping operators except the last stage (output)
          if tag.is_broadcast(op.tag) or "elemwise" in op.tag:
              if op not in s.outputs:
                  s[op].compute_inline()
              for tensor in op.input_tensors:
                  if isinstance(tensor.op, tvm.te.ComputeOp):
                      traverse(tensor.op)
  
          elif (
              op.tag == "bitserial_dense" or "bitserial_dense_unipolar"
          ):
              output = op.output(0)
              weight_vec = op.input_tensors[0]
  
              data_vec = op.input_tensors[1]
              data = data_vec.op.input_tensors[0]
              if "QuantizeInput" in data.op.name:
                  data = data.op.input_tensors[0]
              _schedule(cfg, s, data_vec, weight_vec, output)
          else:
              raise RuntimeError(f"Unsupported operator: {op.tag}")
  
      traverse(outs[0].op)
      return s
  
file_path: tvm/python/tvm/topi/x86/bitserial_dense.py
imports: from __future__ import absolute_import
  import tvm
  from tvm import te
  from tvm import autotvm
  from tvm.topi.utils import get_const_int, get_const_tuple
  from ..None import tag
  from ..nn.bitserial_util import bitpack, binary_op_multiplier
label_desc: Use image node_id 2 for calling a global function with example usage: schedule_bitserial_dense(cfg, outs) and returns: s, s