mir_interpreter::FullyConnectedImpl< uint8_t > Struct Reference

Static Public Member Functions
static void	run (const mir::TensorVariant &inputv, const mir::TensorVariant &weightsv, const mir::ops::FullyConnectedOp &op, mir::TensorVariant &res, const mir::TensorVariant *biasv)

Detailed Description

Definition at line 123 of file FullyConnected.cpp.

Member Function Documentation

run()

void mir_interpreter::FullyConnectedImpl< uint8_t >::run ( const mir::TensorVariant &  inputv, const mir::TensorVariant &  weightsv, const mir::ops::FullyConnectedOp &  op, mir::TensorVariant &  res, const mir::TensorVariant *  biasv  )

static

Definition at line 130 of file FullyConnected.cpp.

{
  if (!biasv)
  {
    throw std::runtime_error{"Quantized FullyConnected cannot be executed without fused bias"};
  }
 
  const auto &input_type = inputv.getType();
  const auto &weights_type = weightsv.getType();
  const auto &bias_type = biasv->getType();
  const auto &output_type = op.getOutput(0)->getType();
  (void)bias_type;
 
  assert(input_type.isQuantized());
  assert(weights_type.isQuantized());
  assert(bias_type.isQuantized());
  assert(output_type.isQuantized());
  assert(input_type.getElementType() == mir::DataType::UINT8);
  assert(weights_type.getElementType() == mir::DataType::UINT8);
  assert(bias_type.getElementType() == mir::DataType::INT32);
 
  int32_t input_offset = -input_type.getQuantization().getZeroPoint();
  int32_t weights_offset = -weights_type.getQuantization().getZeroPoint();
  int32_t output_offset = output_type.getQuantization().getZeroPoint();
 
  double input_scale = input_type.getQuantization().getScale();
  double weights_scale = weights_type.getQuantization().getScale();
  double output_scale = output_type.getQuantization().getScale();
 
  double real_multiplier = input_scale * weights_scale / output_scale;
  int32_t output_multiplier = 0;
  int output_shift = 0;
  QuantizeMultiplier(real_multiplier, &output_multiplier, &output_shift);
 
  const mir::Shape &in_shape = inputv.getShape();
  const mir::Shape &weights_shape = weightsv.getShape();
  const mir::Shape &out_shape = op.getOutputShape(0);
 
  const int32_t batches = in_shape.dim(0);
  assert(in_shape.rank() == 2);
  assert(weights_shape.rank() == 2);
  assert(in_shape.dim(1) == weights_shape.dim(0));
  const int32_t accum_depth = weights_shape.dim(0);
  const int32_t output_depth = weights_shape.dim(1);
 
  uint8_t *input_data = reinterpret_cast<uint8_t *>(inputv.atOffset(0));
  uint8_t *weights_data = reinterpret_cast<uint8_t *>(weightsv.atOffset(0));
  int32_t *bias_data = reinterpret_cast<int32_t *>(biasv->atOffset(0));
 
  uint8_t *output_data = reinterpret_cast<uint8_t *>(res.atOffset(0));
 
  int32_t output_min = std::numeric_limits<uint8_t>::min();
  int32_t output_max = std::numeric_limits<uint8_t>::max();
 
  for (int32_t b = 0; b < batches; ++b)
  {
    for (int32_t out_c = 0; out_c < output_depth; ++out_c)
    {
      int32_t acc = 0;
      for (int d = 0; d < accum_depth; ++d)
      {
        int32_t input_val = input_data[b * accum_depth + d];
        int32_t weights_val = weights_data[d * output_depth + out_c];
        acc += (weights_val + weights_offset) * (input_val + input_offset);
      }
      acc += bias_data[out_c];
      acc = MultiplyByQuantizedMultiplier(acc, output_multiplier, output_shift);
      acc += output_offset;
      acc = std::max(acc, output_min);
      acc = std::min(acc, output_max);
      output_data[out_c + output_depth * b] = static_cast<uint8_t>(acc);
    }
  }
}

References mir::TensorVariant::atOffset(), mir::Shape::dim(), mir::Operation::getOutput(), mir::Operation::getOutputShape(), mir::TensorVariant::getShape(), mir::Operation::Output::getType(), mir::TensorVariant::getType(), mir_interpreter::MultiplyByQuantizedMultiplier(), mir_interpreter::QuantizeMultiplier(), and mir::Shape::rank().

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

---

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

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