#include "channel_quant.hpp" #include namespace channel_quant { namespace { int validate(const std::vector ¶ms, std::size_t channels) { if (params.size() != channels) return -22; for (const auto &p : params) { if (p.numerator < 1 || p.numerator > 2000000000ULL || p.denominator < 1 || p.denominator > 255) return -22; if (!((p.qmin == -127 && p.qmax == 127) || (p.qmin == 0 && p.qmax == 255))) return -22; if (p.zero < p.qmin || p.zero > p.qmax) return -22; } return 0; } std::int64_t nearest(std::int64_t numerator, std::int64_t denominator) { bool negative = numerator < 0; auto absolute = negative ? -numerator : numerator; auto quotient = absolute / denominator; auto remainder = absolute % denominator; if (remainder * 2 > denominator || (remainder * 2 == denominator && quotient % 2)) ++quotient; return negative ? -quotient : quotient; } int clip(std::int64_t value, const QuantParam ¶meter) { return static_cast(std::max(parameter.qmin,std::min(parameter.qmax,value))); } int prepare(const Tensor &tensor, int axis, const std::vector ¶ms, std::vector &values, std::vector &channels) { Layout layout{}; int error = inspect_layout(tensor,axis,layout); if (error) return error; error = validate(params,layout.channels); if (error) return error; return gather(tensor,axis,values,channels); } } int quantize(const Tensor &tensor, int axis, const std::vector ¶ms, std::vector &out) { std::vector values; std::vector channels; int error = prepare(tensor,axis,params,values,channels); if (error) return error; std::vector result; result.reserve(values.size()); for (std::size_t i = 0; i < values.size(); ++i) { const auto &p = params[channels[i]]; auto rounded = nearest(values[i] * static_cast(p.denominator), static_cast(p.numerator)); result.push_back(clip(rounded + p.zero,p)); } out.swap(result); return 0; } int dequantize(const Tensor &tensor, int axis, const std::vector ¶ms, std::vector &out) { std::vector values; std::vector channels; int error = prepare(tensor,axis,params,values,channels); if (error) return error; std::vector result; result.reserve(values.size()); for (std::size_t i = 0; i < values.size(); ++i) { const auto &p = params[channels[i]]; if (values[i] < p.qmin || values[i] > p.qmax) return -34; result.push_back(nearest((values[i] - p.zero) * static_cast(p.numerator),static_cast(p.denominator))); } out.swap(result); return 0; } int requantize(const Tensor &tensor, int axis, const std::vector &source, const std::vector &destination, std::vector &out) { Layout layout{}; int error = inspect_layout(tensor,axis,layout); if (error) return error; error = validate(source,layout.channels); if (error) return error; error = validate(destination,layout.channels); if (error) return error; std::vector values; std::vector channels; error = gather(tensor,axis,values,channels); if (error) return error; std::vector result; result.reserve(values.size()); for (std::size_t i = 0; i < values.size(); ++i) { const auto &from = source[channels[i]]; const auto &to = destination[channels[i]]; if (values[i] < from.qmin || values[i] > from.qmax) return -34; auto numerator = (values[i] - from.zero) * static_cast(from.numerator) * static_cast(to.denominator); auto denominator = static_cast(from.denominator) * static_cast(to.numerator); result.push_back(clip(nearest(numerator,denominator) + to.zero,to)); } out.swap(result); return 0; } }