code: def _alter_conv2d_layout(attrs, inputs, tinfos, out_type):
      target = tvm.target.Target.current(allow_none=False)
      dispatch_ctx = autotvm.task.DispatchContext.current
      if isinstance(dispatch_ctx, autotvm.task.ApplyGraphBest):
          cfg = dispatch_ctx.query(target, None)
          workload = cfg.workload
      else:
          _, outs = relay.backend.te_compiler.select_implementation(
              relay.op.get("nn.conv2d"), attrs, tinfos, out_type, target
          )
          workload = autotvm.task.get_workload(outs)
          if workload is None:
              # The best implementation is not an AutoTVM template,
              # we then assume it's not necessary to alter this op.
              return None
          cfg = dispatch_ctx.query(target, workload)
  
      topi_tmpl = workload[0]
      new_attrs = {k: attrs[k] for k in attrs.keys()}
  
      padding = attrs.get_int_tuple("padding")
      strides = attrs.get_int_tuple("strides")
      dilation = attrs.get_int_tuple("dilation")
      data_layout = attrs["data_layout"]
      kernel_layout = attrs["kernel_layout"]
      data_tensor, kernel_tensor = tinfos
      data_dtype = data_tensor.dtype
      kernel_dtype = kernel_tensor.dtype
      out_dtype = out_type.dtype
  
      if topi_tmpl == "conv2d_NCHWc.intel_graphics":
          assert data_layout == "NCHW" and kernel_layout == "OIHW"
          if cfg.is_fallback:
              _get_default_config(
                  cfg,
                  data_tensor,
                  kernel_tensor,
                  strides,
                  padding,
                  out_dtype,
                  False,
              )
          batch_size, in_channel, height, width = get_const_tuple(
              data_tensor.shape
          )
          out_channel, _, kh, kw = get_const_tuple(kernel_tensor.shape)
          ic_bn = (
              cfg["tile_ic"].val
              if hasattr(cfg["tile_ic"], "val")
              else cfg["tile_ic"].size[-1]
          )
          oc_bn = (
              cfg["tile_oc"].val
              if hasattr(cfg["tile_oc"], "val")
              else cfg["tile_oc"].size[-1]
          )
  
          # update new attrs
          new_attrs["channels"] = out_channel
          new_attrs["data_layout"] = f"NCHW{ic_bn}c"
          # (oc, ic, h, w) -> (OC, IC, h, w, ic, oc)
          new_attrs["kernel_layout"] = f"OIHW{ic_bn}i{oc_bn}o"
          new_attrs["out_layout"] = f"NCHW{oc_bn}c"
  
          # Store altered operator's config
          new_data = te.placeholder(
              (batch_size, in_channel // ic_bn, height, width, ic_bn),
              dtype=data_dtype,
          )
          new_kernel = te.placeholder(
              (
                  out_channel // oc_bn,
                  in_channel // ic_bn,
                  kh,
                  kw,
                  ic_bn,
                  oc_bn,
              ),
              dtype=kernel_dtype,
          )
          new_workload = autotvm.task.args_to_workload(
              [
                  new_data,
                  new_kernel,
                  strides,
                  padding,
                  dilation,
                  new_attrs["data_layout"],
                  new_attrs["out_layout"],
                  out_dtype,
              ],
              "conv2d_NCHWc.intel_graphics",
          )
          dispatch_ctx.update(target, new_workload, cfg)
          return relay.nn.contrib_conv2d_nchwc(*inputs, **new_attrs)
  
      return None
  
file_path: tvm/python/tvm/topi/intel_graphics/conv2d_alter_op.py
imports: import tvm
  from tvm import te
  from tvm import relay
  from tvm import autotvm
  from ..utils import get_const_tuple
  from ..nn import conv2d_alter_layout, conv2d_infer_layout
  from .conv2d import _get_default_config
label_desc: Use image node_id 1 for calling a global function with example usage: _alter_conv2d_layout(attrs, inputs, tinfos, out_type) and returns: None, relay, None