code: def pattern_table():
      """Returns list of triples describing the name, dataflow pattern and predicate for all
      the CUTLASS-supported operators."""
      dense_pat = (
          "cutlass.dense",
          make_gemm_pattern(False, None),
          check_gemm,
      )
      dense_bias_pat = (
          "cutlass.dense_bias",
          make_gemm_pattern(True, None),
          check_gemm,
      )
      dense_bias_relu_pat = (
          "cutlass.dense_bias_relu",
          make_gemm_pattern(True, "relu"),
          check_gemm,
      )
      dense_bias_gelu_fp16_pat = (
          "cutlass.dense_bias_gelu_fp16",
          make_gemm_pattern(True, "gelu"),
          check_gemm,
      )
      dense_bias_gelu_fp32_pat = (
          "cutlass.dense_bias_gelu_fp32",
          make_gemm_pattern(True, "gelu", out_dtype="float32"),
          check_gemm,
      )
  
      dense_patterns = [
          dense_bias_gelu_fp16_pat,
          dense_bias_gelu_fp32_pat,
          dense_bias_relu_pat,
          dense_bias_pat,
          dense_pat,
          (
              "cutlass.batch_matmul",
              make_batch_matmul_pattern(),
              check_batch_matmul,
          ),
      ]
  
      conv2d_patterns = [
          (
              "cutlass.conv2d_bias_hardswish",
              make_conv2d_pattern(with_bias=True, with_act="hardswish"),
              check_conv2d,
          ),
          (
              "cutlass.conv2d_bias_silu",
              make_conv2d_pattern(with_bias=True, with_act="silu"),
              check_conv2d,
          ),
          (
              "cutlass.conv2d_bias_relu",
              make_conv2d_pattern(with_bias=True, with_act="relu"),
              check_conv2d,
          ),
          (
              "cutlass.conv2d_bias_sigmoid",
              make_conv2d_pattern(with_bias=True, with_act="sigmoid"),
              check_conv2d,
          ),
          (
              "cutlass.conv2d_bias",
              make_conv2d_pattern(with_bias=True),
              check_conv2d,
          ),
          ("cutlass.conv2d", make_conv2d_pattern(), check_conv2d),
      ]
  
      # For now, no fusion for grad kernels
      conv2d_grad_patterns = [
          (
              "cutlass.conv2d_transpose",
              make_conv2d_transpose_pattern(),
              check_conv2d_transpose,
          ),
          (
              "cutlass.conv2d_backward_weight",
              make_conv2d_backward_weight_pattern(),
              check_conv2d_backward_weight,
          ),
      ]
  
      residual_block_patterns = []
  
      for with_act, postfix in [("relu", "_relu"), (None, "")]:
          for name, pat, _ in conv2d_patterns[:-1]:
              for bin_op in ["add", "multiply"]:
                  residual_block_patterns.append(
                      (
                          name + "_residual_" + bin_op + postfix,
                          make_residual_block_pattern(
                              pat, bin_op, with_act=with_act
                          ),
                          partial(
                              check_conv2d_residual, binary_op=bin_op
                          ),
                      )
                  )
  
      return (
          residual_block_patterns
          + dense_patterns
          + conv2d_patterns
          + conv2d_grad_patterns
      )
  
imports: from functools import partial
  from tvm import relay
  from tvm.ir.transform import PassContext, Sequential
  from tvm.relay import transform
  from tvm.relay.build_module import bind_params_by_name
  from tvm.relay.op.contrib.register import register_pattern_table
  from ...dataflow_pattern import is_constant, is_op, wildcard
label_desc: Use image node_id 18 for calling a global function with example usage: pattern_table() and returns: unknown