mir_interpreter::DeConv2DImpl< T > Struct Template Reference

Static Public Member Functions
static void	run (const TensorVariant &input, const TensorVariant &kernel, const Deconv2DOpAttributes &attributes, TensorVariant &output)

Detailed Description

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

Definition at line 36 of file DeConv2D.cpp.

Member Function Documentation

run()

template<typename T >

void mir_interpreter::DeConv2DImpl< T >::run ( const TensorVariant &  input, const TensorVariant &  kernel, const Deconv2DOpAttributes &  attributes, TensorVariant &  output  )

static

Definition at line 43 of file DeConv2D.cpp.

{
  // [H, W, Co, Ci] -> [Ci, H, W, Co]
  TensorVariant transposed_kernel = transposeTensor<3, 0, 1, 2>(kernel);
 
  const auto *input_data = reinterpret_cast<const T *>(input.atOffset(0));
  const auto *kernel_data = reinterpret_cast<const T *>(transposed_kernel.atOffset(0));
  auto *output_data = reinterpret_cast<T *>(output.atOffset(0));
 
  const Shape &input_shape = input.getShape();
  const Shape &output_shape = output.getShape();
  const Shape &kernel_shape = transposed_kernel.getShape();
 
  const std::vector<int32_t> &strides = attributes.strides;
  const std::vector<int32_t> &padding_before = attributes.padding_before;
  assert(attributes.data_format == DataFormat::NHWC);
 
  const int32_t batch_size = output_shape.dim(0);
  const int32_t output_height = output_shape.dim(1);
  const int32_t output_width = output_shape.dim(2);
  const int32_t kernel_height = kernel_shape.dim(1);
  const int32_t kernel_width = kernel_shape.dim(2);
  const int32_t input_height = input_shape.dim(1);
  const int32_t input_width = input_shape.dim(2);
 
  const int32_t num_in_channels = input_shape.dim(3);
  const int32_t num_out_channels = output_shape.dim(3);
 
  assert(kernel_shape.dim(0) == num_in_channels);
  assert(kernel_shape.dim(3) == num_out_channels);
 
  erase<T>(output);
 
  for (int32_t batch = 0; batch < batch_size; ++batch)
  {
    for (int32_t in_y = 0; in_y < input_height; ++in_y)
    {
      for (int32_t in_x = 0; in_x < input_width; ++in_x)
      {
        for (int32_t in_c = 0; in_c < num_in_channels; ++in_c)
        {
          const T input_val = input_data[calcOffset(input_shape, batch, in_y, in_x, in_c)];
          const int32_t out_y_origin = in_y * strides[0] - padding_before[0];
          const int32_t out_x_origin = in_x * strides[1] - padding_before[1];
 
          for (int32_t kernel_y = 0; kernel_y < kernel_height; ++kernel_y)
          {
            for (int32_t kernel_x = 0; kernel_x < kernel_width; ++kernel_x)
            {
              const int32_t out_y = out_y_origin + kernel_y;
              const int32_t out_x = out_x_origin + kernel_x;
 
              if ((out_y >= 0 && out_y < output_height) && (out_x >= 0 && out_x < output_width))
              {
                for (int32_t out_c = 0; out_c < num_out_channels; ++out_c)
                {
                  const int32_t kernel_offset =
                    calcOffset(kernel_shape, in_c, kernel_y, kernel_x, out_c);
                  const int32_t output_offset =
                    calcOffset(output_shape, batch, out_y, out_x, out_c);
                  const T kernel_val = kernel_data[kernel_offset];
                  output_data[output_offset] += input_val * kernel_val;
                }
              }
            }
          }
        }
      }
    }
  }
}

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

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

---

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

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