96 lines
4.1 KiB
C++

#include "channel_quant.hpp"
#include <algorithm>
namespace channel_quant {
namespace {
int validate(const std::vector<QuantParam> &params, 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 &parameter) {
return static_cast<int>(std::max<std::int64_t>(parameter.qmin,std::min<std::int64_t>(parameter.qmax,value)));
}
int prepare(const Tensor &tensor, int axis, const std::vector<QuantParam> &params,
std::vector<std::int64_t> &values, std::vector<std::size_t> &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<QuantParam> &params,
std::vector<int> &out) {
std::vector<std::int64_t> values;
std::vector<std::size_t> channels;
int error = prepare(tensor,axis,params,values,channels);
if (error) return error;
std::vector<int> 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<std::int64_t>(p.denominator), static_cast<std::int64_t>(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<QuantParam> &params,
std::vector<std::int64_t> &out) {
std::vector<std::int64_t> values;
std::vector<std::size_t> channels;
int error = prepare(tensor,axis,params,values,channels);
if (error) return error;
std::vector<std::int64_t> 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<std::int64_t>(p.numerator),static_cast<std::int64_t>(p.denominator)));
}
out.swap(result);
return 0;
}
int requantize(const Tensor &tensor, int axis,
const std::vector<QuantParam> &source,
const std::vector<QuantParam> &destination,
std::vector<int> &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<std::int64_t> values;
std::vector<std::size_t> channels;
error = gather(tensor,axis,values,channels);
if (error) return error;
std::vector<int> 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<std::int64_t>(from.numerator) * static_cast<std::int64_t>(to.denominator);
auto denominator = static_cast<std::int64_t>(from.denominator) * static_cast<std::int64_t>(to.numerator);
result.push_back(clip(nearest(numerator,denominator) + to.zero,to));
}
out.swap(result);
return 0;
}
}