mir_interpreter::ConcatImpl< uint8_t > Struct Reference

Static Public Member Functions
static void	run (const std::vector< std::reference_wrapper< const mir::TensorVariant > > &inputs, int axis, mir::TensorVariant &output)

Detailed Description

Definition at line 86 of file Concat.cpp.

Member Function Documentation

run()

void mir_interpreter::ConcatImpl< uint8_t >::run ( const std::vector< std::reference_wrapper< const mir::TensorVariant > > &  inputs, int  axis, mir::TensorVariant &  output  )

static

Definition at line 92 of file Concat.cpp.

{
  const size_t inputs_count = inputs.size();
  std::vector<int32_t> input_zeropoints(inputs_count);
  std::vector<float> input_scales(inputs_count);
  const auto &output_shape = output.getShape();
  const int32_t concat_dimensions = output_shape.rank();
  int64_t concat_size = 0;
  for (size_t i = 0; i < inputs_count; i++)
  {
    const auto &input_type = inputs[i].get().getType();
    assert(input_type.isQuantized());
    assert(input_type.getElementType() == mir::DataType::UINT8);
    const auto &input_shape = input_type.getShape();
    assert(input_shape.rank() == concat_dimensions);
 
    for (int32_t j = 0; j < concat_dimensions; j++)
      if (j != axis)
        assert(input_shape.dim(j) == output_shape.dim(j));
 
    concat_size += input_shape.dim(axis);
    input_zeropoints[i] = input_type.getQuantization().getZeroPoint();
    input_scales[i] = input_type.getQuantization().getScale();
  }
  assert(concat_size == output_shape.dim(axis));
 
  const auto &output_type = output.getType();
  assert(output_type.isQuantized());
  int32_t output_zeropoint = output_type.getQuantization().getZeroPoint();
  float output_scale = output_type.getQuantization().getScale();
 
  // Outer size before axis
  int32_t outer_size = 1;
  for (int32_t i = 0; i < axis; i++)
    outer_size *= output_shape.dim(i);
  // Inner size after axis
  int32_t base_inner_size = 1;
  for (int32_t i = axis + 1; i < concat_dimensions; i++)
    base_inner_size *= output_shape.dim(i);
  // flatten = outer_size * dim(axis) * base_inner_size;
 
  uint8_t *output_ptr = reinterpret_cast<uint8_t *>(output.atOffset(0));
 
  const float inverse_output_scale = 1.f / output_scale;
  for (int k = 0; k < outer_size; k++)
  {
    for (size_t i = 0; i < inputs_count; ++i)
    {
      const mir::TensorVariant &input = inputs[i];
      const int copy_size = input.getShape().dim(axis) * base_inner_size;
      const char *input_data = input.atOffset(0) + k * copy_size;
      const uint8_t *input_ptr = reinterpret_cast<const uint8_t *>(input_data);
      if (input_zeropoints[i] == output_zeropoint && input_scales[i] == output_scale)
      {
        std::memcpy(output_ptr, input_ptr, copy_size);
      }
      else
      {
        const float scale = input_scales[i] * inverse_output_scale;
        const float bias = -input_zeropoints[i] * scale;
        for (int j = 0; j < copy_size; ++j)
        {
          const int32_t value =
            static_cast<int32_t>(std::round(input_ptr[j] * scale + bias)) + output_zeropoint;
          output_ptr[j] = static_cast<uint8_t>(std::max(std::min(255, value), 0));
        }
      }
      output_ptr += copy_size;
    }
  }
}

References output_shape.

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

---

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

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