code: def conv(attrs, inputs, proto_obj):
      
      new_attrs = translation_utils._fix_attribute_names(attrs, {'kernel_shape' : 'kernel',
                                                                 'strides' : 'stride',
                                                                 'pads': 'pad',
                                                                 'dilations': 'dilate',
                                                                 'group': 'num_group'})
      new_attrs = translation_utils._add_extra_attributes(new_attrs, {'num_group' : 1})
      new_attrs = translation_utils._fix_bias('Convolution', new_attrs, len(inputs))
  
      new_attrs = translation_utils._fix_channels('Convolution', new_attrs, inputs, proto_obj)
      kernel = new_attrs['kernel']
      stride = new_attrs['stride'] if 'stride' in new_attrs else []
      padding = new_attrs['pad'] if 'pad' in new_attrs else []
      dilations = new_attrs['dilate'] if 'dilate' in new_attrs else []
      num_filter = new_attrs['num_filter']
      num_group = new_attrs['num_group']
      no_bias = new_attrs['no_bias'] if 'no_bias' in new_attrs else 0
      bias = None if no_bias is True else inputs[2]
  
      # Unlike ONNX, MXNet's convolution operator does not support asymmetric padding, so we first
      # use 'Pad' operator, which supports asymmetric padding. Then use the convolution operator.
      pad_width = (0, 0, 0, 0) + translation_utils._pad_sequence_fix(padding, kernel_dim=len(kernel))
      pad_op = symbol.pad(inputs[0], mode='constant', pad_width=pad_width)
  
      conv_op = symbol.Convolution(pad_op, inputs[1], bias,
                                   kernel=kernel, stride=stride, dilate=dilations,
                                   num_filter=num_filter, num_group=num_group, no_bias=no_bias)
  
      return conv_op, new_attrs, inputs
docs: Compute N-D convolution on (N+2)-D input.