263 lines
6.2 KiB
C++
263 lines
6.2 KiB
C++
#include "channel_quant.hpp"
|
|
#include <algorithm>
|
|
#include <cstdint>
|
|
#include <utility>
|
|
|
|
namespace channel_quant {
|
|
namespace {
|
|
constexpr int INVALID = -22;
|
|
constexpr int RANGE_ERROR = -34;
|
|
constexpr int NO_DEVICE = -19;
|
|
constexpr int NO_ENTRY = -2;
|
|
constexpr int NO_DATA = -61;
|
|
|
|
Range empty_range()
|
|
{
|
|
return Range{0, 0, 0};
|
|
}
|
|
|
|
void include(Range &range, std::int64_t value)
|
|
{
|
|
if (range.count == 0) {
|
|
range.minimum = value;
|
|
range.maximum = value;
|
|
} else {
|
|
range.minimum = std::min(range.minimum, value);
|
|
range.maximum = std::max(range.maximum, value);
|
|
}
|
|
++range.count;
|
|
}
|
|
|
|
Range combine(const Range &left, const Range &right)
|
|
{
|
|
if (left.count == 0) {
|
|
return right;
|
|
}
|
|
if (right.count == 0) {
|
|
return left;
|
|
}
|
|
return Range{
|
|
left.count + right.count,
|
|
std::min(left.minimum, right.minimum),
|
|
std::max(left.maximum, right.maximum)
|
|
};
|
|
}
|
|
|
|
std::uint64_t magnitude(std::int64_t value)
|
|
{
|
|
return value < 0 ? static_cast<std::uint64_t>(-value) :
|
|
static_cast<std::uint64_t>(value);
|
|
}
|
|
|
|
std::uint64_t rounded_ratio(std::uint64_t numerator, std::uint64_t denominator)
|
|
{
|
|
const std::uint64_t whole = numerator / denominator;
|
|
const std::uint64_t remainder = numerator % denominator;
|
|
const bool above = remainder > denominator - remainder;
|
|
const bool tie = remainder == denominator - remainder;
|
|
return whole + (above || (tie && (whole & 1u)) ? 1 : 0);
|
|
}
|
|
|
|
QuantParam symmetric(const Range &range)
|
|
{
|
|
const std::uint64_t maximum = std::max(magnitude(range.minimum),
|
|
magnitude(range.maximum));
|
|
if (maximum == 0) {
|
|
return QuantParam{1, 1, 0, -127, 127};
|
|
}
|
|
return QuantParam{maximum, 127, 0, -127, 127};
|
|
}
|
|
|
|
QuantParam affine(const Range &range)
|
|
{
|
|
const std::int64_t low = std::min<std::int64_t>(0, range.minimum);
|
|
const std::int64_t high = std::max<std::int64_t>(0, range.maximum);
|
|
const std::uint64_t span = static_cast<std::uint64_t>(high - low);
|
|
if (span == 0) {
|
|
return QuantParam{1, 1, 0, 0, 255};
|
|
}
|
|
const std::uint64_t numerator = static_cast<std::uint64_t>(-low) * 255;
|
|
const int zero = static_cast<int>(rounded_ratio(numerator, span));
|
|
return QuantParam{span, 255, std::clamp(zero, 0, 255), 0, 255};
|
|
}
|
|
}
|
|
|
|
Calibrator::Calibrator()
|
|
{
|
|
reset();
|
|
}
|
|
|
|
void Calibrator::reset()
|
|
{
|
|
configured_ = false;
|
|
mode_ = -1;
|
|
ranges_.clear();
|
|
saved_ = false;
|
|
checkpoint_.clear();
|
|
}
|
|
|
|
int Calibrator::configure(std::size_t channels, int mode)
|
|
{
|
|
if (channels < 1 || channels > 16 ||
|
|
(mode != SYMMETRIC && mode != AFFINE)) {
|
|
return INVALID;
|
|
}
|
|
std::vector<Range> replacement(channels, empty_range());
|
|
configured_ = true;
|
|
mode_ = mode;
|
|
ranges_.swap(replacement);
|
|
saved_ = false;
|
|
checkpoint_.clear();
|
|
return 0;
|
|
}
|
|
|
|
int Calibrator::update(const Tensor &tensor, int axis)
|
|
{
|
|
if (!configured_) {
|
|
return NO_DEVICE;
|
|
}
|
|
Layout layout;
|
|
const int layout_result = inspect_layout(tensor, axis, layout);
|
|
if (layout_result != 0) {
|
|
return layout_result;
|
|
}
|
|
if (layout.channels != ranges_.size()) {
|
|
return INVALID;
|
|
}
|
|
std::vector<std::int64_t> values;
|
|
std::vector<std::size_t> selected;
|
|
const int gathered = gather(tensor, axis, values, selected);
|
|
if (gathered != 0) {
|
|
return gathered;
|
|
}
|
|
std::vector<std::uint64_t> additions(ranges_.size(), 0);
|
|
for (std::size_t channel : selected) {
|
|
++additions[channel];
|
|
}
|
|
for (std::size_t channel = 0; channel < ranges_.size(); ++channel) {
|
|
if (additions[channel] > COUNT_LIMIT - ranges_[channel].count) {
|
|
return RANGE_ERROR;
|
|
}
|
|
}
|
|
std::vector<Range> replacement = ranges_;
|
|
for (std::size_t index = 0; index < values.size(); ++index) {
|
|
include(replacement[selected[index]], values[index]);
|
|
}
|
|
ranges_.swap(replacement);
|
|
return 0;
|
|
}
|
|
|
|
int Calibrator::merge(const Calibrator &other)
|
|
{
|
|
if (!configured_ || !other.configured_) {
|
|
return NO_DEVICE;
|
|
}
|
|
if (ranges_.size() != other.ranges_.size() || mode_ != other.mode_) {
|
|
return INVALID;
|
|
}
|
|
for (std::size_t channel = 0; channel < ranges_.size(); ++channel) {
|
|
if (other.ranges_[channel].count > COUNT_LIMIT - ranges_[channel].count) {
|
|
return RANGE_ERROR;
|
|
}
|
|
}
|
|
std::vector<Range> replacement;
|
|
replacement.reserve(ranges_.size());
|
|
for (std::size_t channel = 0; channel < ranges_.size(); ++channel) {
|
|
replacement.push_back(combine(ranges_[channel], other.ranges_[channel]));
|
|
}
|
|
ranges_.swap(replacement);
|
|
return 0;
|
|
}
|
|
|
|
int Calibrator::checkpoint()
|
|
{
|
|
if (!configured_) {
|
|
return NO_DEVICE;
|
|
}
|
|
checkpoint_ = ranges_;
|
|
saved_ = true;
|
|
return 0;
|
|
}
|
|
|
|
int Calibrator::restore()
|
|
{
|
|
if (!configured_) {
|
|
return NO_DEVICE;
|
|
}
|
|
if (!saved_) {
|
|
return NO_ENTRY;
|
|
}
|
|
ranges_ = checkpoint_;
|
|
return 0;
|
|
}
|
|
|
|
int Calibrator::clear()
|
|
{
|
|
if (!configured_) {
|
|
return NO_DEVICE;
|
|
}
|
|
std::fill(ranges_.begin(), ranges_.end(), empty_range());
|
|
return 0;
|
|
}
|
|
|
|
int Calibrator::discard_checkpoint()
|
|
{
|
|
if (!configured_) {
|
|
return NO_DEVICE;
|
|
}
|
|
saved_ = false;
|
|
checkpoint_.clear();
|
|
return 0;
|
|
}
|
|
|
|
int Calibrator::query(std::size_t channel, Range &out) const
|
|
{
|
|
if (!configured_) {
|
|
return NO_DEVICE;
|
|
}
|
|
if (channel >= ranges_.size()) {
|
|
return INVALID;
|
|
}
|
|
out = ranges_[channel];
|
|
return 0;
|
|
}
|
|
|
|
int Calibrator::parameters(std::vector<QuantParam> &out) const
|
|
{
|
|
if (!configured_) {
|
|
return NO_DEVICE;
|
|
}
|
|
for (const Range &range : ranges_) {
|
|
if (range.count == 0) {
|
|
return NO_DATA;
|
|
}
|
|
}
|
|
std::vector<QuantParam> result;
|
|
result.reserve(ranges_.size());
|
|
for (const Range &range : ranges_) {
|
|
result.push_back(mode_ == SYMMETRIC ? symmetric(range) : affine(range));
|
|
}
|
|
out.swap(result);
|
|
return 0;
|
|
}
|
|
|
|
std::size_t Calibrator::channels() const
|
|
{
|
|
return configured_ ? ranges_.size() : 0;
|
|
}
|
|
|
|
int Calibrator::mode() const
|
|
{
|
|
return mode_;
|
|
}
|
|
|
|
std::uint64_t Calibrator::total() const
|
|
{
|
|
std::uint64_t total = 0;
|
|
for (const Range &range : ranges_) {
|
|
total += range.count;
|
|
}
|
|
return total;
|
|
}
|
|
}
|