96 lines
4.1 KiB
C++
96 lines
4.1 KiB
C++
#include "channel_quant.hpp"
|
|
#include <algorithm>
|
|
namespace channel_quant {
|
|
namespace {
|
|
int validate(const std::vector<QuantParam> ¶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<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> ¶ms,
|
|
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> ¶ms,
|
|
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> ¶ms,
|
|
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;
|
|
}
|
|
}
|