code: def createConvFunc(op_type):
      assert op_type in [
          "cv",
          "cd",
          "ad",
          "rd",
      ], "unknown op type: %s" % str(op_type)
      if op_type == "cv":
          return F.conv2d
  
      if op_type == "cd":
  
          def func(
              x,
              weights,
              bias=None,
              stride=1,
              padding=0,
              dilation=1,
              groups=1,
          ):
              assert dilation in [
                  1,
                  2,
              ], "dilation for cd_conv should be in 1 or 2"
              assert (
                  weights.size(2) == 3 and weights.size(3) == 3
              ), "kernel size for cd_conv should be 3x3"
              assert (
                  padding == dilation
              ), "padding for cd_conv set wrong"
  
              weights_c = weights.sum(dim=[2, 3], keepdim=True)
              yc = F.conv2d(
                  x, weights_c, stride=stride, padding=0, groups=groups
              )
              y = F.conv2d(
                  x,
                  weights,
                  bias,
                  stride=stride,
                  padding=padding,
                  dilation=dilation,
                  groups=groups,
              )
              return y - yc
  
          return func
      elif op_type == "ad":
  
          def func(
              x,
              weights,
              bias=None,
              stride=1,
              padding=0,
              dilation=1,
              groups=1,
          ):
              assert dilation in [
                  1,
                  2,
              ], "dilation for ad_conv should be in 1 or 2"
              assert (
                  weights.size(2) == 3 and weights.size(3) == 3
              ), "kernel size for ad_conv should be 3x3"
              assert (
                  padding == dilation
              ), "padding for ad_conv set wrong"
  
              shape = weights.shape
              weights = weights.view(shape[0], shape[1], -1)
              weights_conv = (
                  weights - weights[:, :, [3, 0, 1, 6, 4, 2, 7, 8, 5]]
              ).view(
                  shape
              )  # clock-wise
              y = F.conv2d(
                  x,
                  weights_conv,
                  bias,
                  stride=stride,
                  padding=padding,
                  dilation=dilation,
                  groups=groups,
              )
              return y
  
          return func
      elif op_type == "rd":
  
          def func(
              x,
              weights,
              bias=None,
              stride=1,
              padding=0,
              dilation=1,
              groups=1,
          ):
              assert dilation in [
                  1,
                  2,
              ], "dilation for rd_conv should be in 1 or 2"
              assert (
                  weights.size(2) == 3 and weights.size(3) == 3
              ), "kernel size for rd_conv should be 3x3"
              padding = 2 * dilation
  
              shape = weights.shape
              buffer = torch.zeros(
                  shape[0],
                  shape[1],
                  5 * 5,
                  device=weights.device,
                  dtype=weights.dtype,
              )
              weights = weights.view(shape[0], shape[1], -1)
              buffer[:, :, [0, 2, 4, 10, 14, 20, 22, 24]] = weights[
                  :, :, 1:
              ]
              buffer[:, :, [6, 7, 8, 11, 13, 16, 17, 18]] = -weights[
                  :, :, 1:
              ]
              buffer[:, :, 12] = 0
              buffer = buffer.view(shape[0], shape[1], 5, 5)
              y = F.conv2d(
                  x,
                  buffer,
                  bias,
                  stride=stride,
                  padding=padding,
                  dilation=dilation,
                  groups=groups,
              )
              return y
  
          return func
      else:
          print("impossible to be here unless you force that")
          return None
  
imports: import os
  import math
  import torch
  import numpy
  import torch.nn
  import torch.nn.functional
  from typing import Optional
  from cftool.cv import to_uint8
  from ....parameters import OPT
label_desc: Use image node_id 1 for calling a global function with example usage: createConvFunc(op_type) and returns: F, func, unknown, func, y, func, None, y