mir_interpreter::Conv2DImpl< T > Struct Template Reference

Static Public Member Functions
static void	run (const TensorVariant &input, const TensorVariant &kernel, const Conv2DOpAttributes &attributes, TensorVariant &result, const TensorVariant *fused_bias)

Detailed Description

template<typename T>
struct mir_interpreter::Conv2DImpl< T >

Definition at line 37 of file Conv2D.cpp.

Member Function Documentation

run()

template<typename T >

void mir_interpreter::Conv2DImpl< T >::run ( const TensorVariant &  input, const TensorVariant &  kernel, const Conv2DOpAttributes &  attributes, TensorVariant &  result, const TensorVariant *  fused_bias  )

static

Definition at line 45 of file Conv2D.cpp.

{
  const auto *input_data = reinterpret_cast<const T *>(input.atOffset(0));
  const auto *kernel_data = reinterpret_cast<const T *>(kernel.atOffset(0));
  auto *result_data = reinterpret_cast<T *>(result.atOffset(0));
 
  const Shape &input_shape = input.getShape();
  const Shape &output_shape = result.getShape();
  const Shape &kernel_shape = kernel.getShape();
 
  const std::vector<std::int32_t> &strides = attributes.strides;
  const std::vector<std::int32_t> &padding_before = attributes.padding_before;
  const std::int32_t num_groups = attributes.num_groups;
  assert(attributes.data_format == DataFormat::NHWC);
 
  const std::int32_t batch_size = output_shape.dim(0);
  const std::int32_t output_height = output_shape.dim(1);
  const std::int32_t output_width = output_shape.dim(2);
  const std::int32_t kernel_height = kernel_shape.dim(1);
  const std::int32_t kernel_width = kernel_shape.dim(2);
  const std::int32_t input_height = input_shape.dim(1);
  const std::int32_t input_width = input_shape.dim(2);
 
  const std::int32_t num_in_channels = input_shape.dim(3);
  const std::int32_t num_out_channels = output_shape.dim(3);
 
  assert(num_in_channels % num_groups == 0);
  assert(num_out_channels % num_groups == 0);
 
  const std::int32_t out_group_size = num_out_channels / num_groups;
  const std::int32_t in_group_size = num_in_channels / num_groups;
 
  assert(kernel_shape.dim(3) == in_group_size);
  assert(kernel_shape.dim(0) == num_out_channels);
 
  for (std::int32_t batch = 0; batch < batch_size; ++batch)
  {
    for (std::int32_t out_y = 0; out_y < output_height; ++out_y)
    {
      for (std::int32_t out_x = 0; out_x < output_width; ++out_x)
      {
        for (std::int32_t group = 0; group < num_groups; ++group)
        {
          const std::int32_t out_group_offset = group * out_group_size;
          const std::int32_t in_group_offset = group * in_group_size;
 
          for (std::int32_t out_c = 0; out_c < out_group_size; ++out_c)
          {
            const std::int32_t in_y_origin = (out_y * strides[0]) - padding_before[0];
            const std::int32_t in_x_origin = (out_x * strides[1]) - padding_before[1];
 
            T sum = 0.0f;
 
            for (std::int32_t kernel_y = 0; kernel_y < kernel_height; ++kernel_y)
            {
              for (std::int32_t kernel_x = 0; kernel_x < kernel_width; ++kernel_x)
              {
                for (std::int32_t in_c = 0; in_c < in_group_size; ++in_c)
                {
                  const std::int32_t in_y = in_y_origin + kernel_y;
                  const std::int32_t in_x = in_x_origin + kernel_x;
 
                  if ((in_y >= 0 && in_y < input_height) && (in_x >= 0 && in_x < input_width))
                  {
                    const std::int32_t in_offset =
                      calcOffset(input_shape, batch, in_y, in_x, in_group_offset + in_c);
                    const std::int32_t kernel_offset =
                      calcOffset(kernel_shape, out_group_offset + out_c, kernel_y, kernel_x, in_c);
                    const T input_val = input_data[in_offset];
                    const T kernel_val = kernel_data[kernel_offset];
                    sum += kernel_val * input_val;
                  }
                }
              }
            }
 
            const std::int32_t out_offset =
              calcOffset(output_shape, batch, out_y, out_x, out_group_offset + out_c);
            result_data[out_offset] = sum;
          }
        }
      }
    }
  }
}

References mir::TensorVariant::atOffset(), mir::Conv2DOpAttributes::data_format, mir::Shape::dim(), mir::TensorVariant::getShape(), mir::Conv2DOpAttributes::num_groups, output_shape, mir::Conv2DOpAttributes::padding_before, and mir::Conv2DOpAttributes::strides.

Referenced by package.infer.session::inference().

---

The documentation for this struct was generated from the following file:

• compiler/mir-interpreter/src/ops/Conv2D.cpp