ra8_npu_quant.c

Go to the documentation of this file.

 
#include "ra8_npu_quant.h"
 
#include <stddef.h>
#include <stdint.h>
 
#include "ra8_attributes.h"
#include "ra8_check.h"
#include "ra8_err.h"
#include "ra8_log.h"

static const char* s_tag = "NPUQ";

static const float s_quant_round_cap = 1.0e6F;

static const float s_quant_half = 0.5F;

RA8_INTERNAL static int32_t
internal_quant_round_clamp(float scaled, int32_t zero_point, int32_t qmin, int32_t qmax)
{
  float rounded = (scaled >= 0.0F) ? (scaled + s_quant_half) : (scaled - s_quant_half);
  if (rounded > s_quant_round_cap) {
    rounded = s_quant_round_cap;
  }
  if (rounded < -s_quant_round_cap) {
    rounded = -s_quant_round_cap;
  }
  int32_t q = (int32_t)rounded + zero_point;
  if (q < qmin) {
    q = qmin;
  }
  if (q > qmax) {
    q = qmax;
  }
  return q;
}
 
ra8_err_t
ra8_npu_quantize_i8(const float* in, int8_t* out, size_t count, float scale, int32_t zero_point)
{
  RA8_CHECK_NULL_PTR(in, s_tag, "quantize_i8: in must not be nullptr");
  RA8_CHECK_NULL_PTR(out, s_tag, "quantize_i8: out must not be nullptr");
  if (scale <= 0.0F) {
    ra8_log_error(s_tag, "quantize_i8: scale must be > 0");
    return k_ra8_err_invalid_arg;
  }
  for (size_t i = 0U; i < count; i++) {
    const int32_t q = internal_quant_round_clamp(in[i] / scale,
                                                 zero_point,
                                                 (int32_t)k_ra8_npu_quant_i8_min,
                                                 (int32_t)k_ra8_npu_quant_i8_max);
    out[i]          = (int8_t)q;
  }
  return k_ra8_ok;
}
 
ra8_err_t
ra8_npu_dequantize_i8(const int8_t* in, float* out, size_t count, float scale, int32_t zero_point)
{
  RA8_CHECK_NULL_PTR(in, s_tag, "dequantize_i8: in must not be nullptr");
  RA8_CHECK_NULL_PTR(out, s_tag, "dequantize_i8: out must not be nullptr");
  for (size_t i = 0U; i < count; i++) {
    out[i] = scale * (float)((int32_t)in[i] - zero_point);
  }
  return k_ra8_ok;
}
 
ra8_err_t
ra8_npu_quantize_u8(const float* in, uint8_t* out, size_t count, float scale, int32_t zero_point)
{
  RA8_CHECK_NULL_PTR(in, s_tag, "quantize_u8: in must not be nullptr");
  RA8_CHECK_NULL_PTR(out, s_tag, "quantize_u8: out must not be nullptr");
  if (scale <= 0.0F) {
    ra8_log_error(s_tag, "quantize_u8: scale must be > 0");
    return k_ra8_err_invalid_arg;
  }
  for (size_t i = 0U; i < count; i++) {
    const int32_t q = internal_quant_round_clamp(in[i] / scale,
                                                 zero_point,
                                                 (int32_t)k_ra8_npu_quant_u8_min,
                                                 (int32_t)k_ra8_npu_quant_u8_max);
    out[i]          = (uint8_t)q;
  }
  return k_ra8_ok;
}
 
ra8_err_t
ra8_npu_dequantize_u8(const uint8_t* in, float* out, size_t count, float scale, int32_t zero_point)
{
  RA8_CHECK_NULL_PTR(in, s_tag, "dequantize_u8: in must not be nullptr");
  RA8_CHECK_NULL_PTR(out, s_tag, "dequantize_u8: out must not be nullptr");
  for (size_t i = 0U; i < count; i++) {
    out[i] = scale * (float)((int32_t)in[i] - zero_point);
  }
  return k_ra8_ok;
}