code: def _convert_conv(node, graph, err):
      weight_name = node.inputs[1]
      input_name = str(node.inputs[0])
      output_name = str(node.outputs[0])
      node_name = node.name
      W = None
      if weight_name in node.input_tensors:
          W = node.input_tensors[weight_name]
      else:
          err.missing_initializer(
              node,
              "Weight tensor: {} not found in the graph initializer".format(
                  weight_name,
              ),
          )
      is_deconv = False
      if node.op_type.endswith("Transpose"):
          is_deconv = True
      bias_flag = False
      bias = None
      if len(node.inputs) > 2:
          bias = node.input_tensors[node.inputs[2]]
          bias_flag = True
      dilations = node.attrs.get("dilations", [1, 1])
      # groups = 1
      groups = node.attrs.get("group", 1)
      kernel_shape = node.attrs["kernel_shape"]
      pads = node.attrs.get("pads", [0, 0, 0, 0])
      strides = node.attrs["strides"]
  
      layer = myf(
          "Convolution",
          node_name,
          [input_name],
          [output_name],
          kernel_h=kernel_shape[0],
          kernel_w=kernel_shape[1],
          stride_h=strides[0],
          stride_w=strides[1],
          group=groups,
          pad_h=pads[0],
          pad_w=pads[1],
          num_output=W.shape[0],
          dilation=dilations[0],
          bias_term=bias_flag,
      )
  
      graph.channel_dims[output_name] = W.shape[0]
      return layer
  
imports: from __future__ import absolute_import
  from __future__ import division
  from __future__ import print_function
  from __future__ import unicode_literals
  from caffe import params
  import math
  import numpy
  from ._graph import Node, Graph
  from MyCaffe import Function
label_desc: Use image node_id 3 for calling a global function with example usage: _convert_conv(node, graph, err) and returns: layer