236 lines
9.2 KiB
C++
236 lines
9.2 KiB
C++
#include "channel_quant.hpp"
|
|
#include <charconv>
|
|
#include <iostream>
|
|
#include <limits>
|
|
#include <sstream>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
namespace {
|
|
using U64 = std::uint64_t;
|
|
using I64 = std::int64_t;
|
|
using channel_quant::Tensor;
|
|
using channel_quant::QuantParam;
|
|
|
|
class Arguments {
|
|
public:
|
|
explicit Arguments(const std::vector<std::string> &words) : words_(words) {}
|
|
template<class Number>
|
|
bool next(Number &value)
|
|
{
|
|
if (position_ == words_.size()) return false;
|
|
const std::string &token = words_[position_++];
|
|
const auto result = std::from_chars(token.data(), token.data() + token.size(), value);
|
|
return result.ec == std::errc{} && result.ptr == token.data() + token.size();
|
|
}
|
|
bool done() const { return position_ == words_.size(); }
|
|
private:
|
|
const std::vector<std::string> &words_;
|
|
std::size_t position_ = 1;
|
|
};
|
|
|
|
std::vector<std::string> words(const std::string &line)
|
|
{
|
|
std::istringstream stream(line);
|
|
std::vector<std::string> result;
|
|
std::string token;
|
|
while (stream >> token) result.push_back(token);
|
|
return result;
|
|
}
|
|
|
|
template<class Number>
|
|
void csv(const std::vector<Number> &values)
|
|
{
|
|
if (values.empty()) std::cout << '-';
|
|
for (std::size_t index = 0; index < values.size(); ++index) {
|
|
if (index != 0) std::cout << ',';
|
|
std::cout << values[index];
|
|
}
|
|
}
|
|
|
|
void parameters(const std::vector<QuantParam> ¶ms)
|
|
{
|
|
if (params.empty()) std::cout << '-';
|
|
for (std::size_t index = 0; index < params.size(); ++index) {
|
|
if (index != 0) std::cout << ';';
|
|
const QuantParam &p = params[index];
|
|
std::cout << p.numerator << ',' << p.denominator << ',' << p.zero << ',' << p.qmin << ',' << p.qmax;
|
|
}
|
|
}
|
|
|
|
void hash_word(U64 &hash, U64 word)
|
|
{
|
|
for (unsigned byte = 0; byte < 8; ++byte) {
|
|
hash ^= (word >> (byte * 8)) & 255;
|
|
hash *= 1099511628211ULL;
|
|
}
|
|
}
|
|
|
|
template<class Number>
|
|
void hash_vector(U64 &hash, const std::vector<Number> &values)
|
|
{
|
|
hash_word(hash, static_cast<U64>(values.size()));
|
|
for (Number value : values) hash_word(hash, static_cast<U64>(value));
|
|
}
|
|
|
|
U64 tensor_hash(const Tensor &tensor)
|
|
{
|
|
U64 hash = 14695981039346656037ULL;
|
|
hash_vector(hash, tensor.shape);
|
|
hash_vector(hash, tensor.strides);
|
|
hash_word(hash, static_cast<U64>(tensor.origin));
|
|
hash_vector(hash, tensor.storage);
|
|
return hash;
|
|
}
|
|
|
|
U64 params_hash(const std::vector<QuantParam> ¶ms)
|
|
{
|
|
U64 hash = 14695981039346656037ULL;
|
|
hash_word(hash, params.size());
|
|
for (const QuantParam &p : params) {
|
|
hash_word(hash, p.numerator);
|
|
hash_word(hash, p.denominator);
|
|
hash_word(hash, static_cast<U64>(p.zero));
|
|
hash_word(hash, static_cast<U64>(p.qmin));
|
|
hash_word(hash, static_cast<U64>(p.qmax));
|
|
}
|
|
return hash;
|
|
}
|
|
|
|
bool view(Arguments &args, Tensor &tensor, int &axis)
|
|
{
|
|
unsigned rank = 0;
|
|
unsigned strides = 0;
|
|
std::size_t count = 0;
|
|
Tensor replacement;
|
|
int next_axis = 0;
|
|
if (!args.next(rank) || !args.next(strides) || !args.next(next_axis) ||
|
|
!args.next(replacement.origin) || !args.next(count) || rank > 5 || strides > 5 || count > 10000) return false;
|
|
replacement.shape.resize(rank);
|
|
replacement.strides.resize(strides);
|
|
replacement.storage.resize(count);
|
|
for (std::size_t &value : replacement.shape) if (!args.next(value)) return false;
|
|
for (std::size_t &value : replacement.strides) if (!args.next(value)) return false;
|
|
for (I64 &value : replacement.storage) if (!args.next(value)) return false;
|
|
if (!args.done()) return false;
|
|
tensor = std::move(replacement);
|
|
axis = next_axis;
|
|
return true;
|
|
}
|
|
|
|
bool load_params(Arguments &args, std::vector<QuantParam> (¶ms)[2])
|
|
{
|
|
unsigned target = 0;
|
|
unsigned count = 0;
|
|
if (!args.next(target) || !args.next(count) || target > 1 || count > 16) return false;
|
|
std::vector<QuantParam> replacement(count);
|
|
for (QuantParam &p : replacement) {
|
|
if (!args.next(p.numerator) || !args.next(p.denominator) || !args.next(p.zero) ||
|
|
!args.next(p.qmin) || !args.next(p.qmax)) return false;
|
|
}
|
|
if (!args.done()) return false;
|
|
params[target].swap(replacement);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
int main()
|
|
{
|
|
channel_quant::Calibrator banks[2];
|
|
unsigned selected = 0;
|
|
Tensor tensor{{1}, {1}, 0, {0}};
|
|
int axis = 0;
|
|
std::vector<QuantParam> params[2];
|
|
std::string line;
|
|
while (std::getline(std::cin, line)) {
|
|
const std::vector<std::string> fields = words(line);
|
|
if (fields.empty() || fields[0][0] == '#') continue;
|
|
const std::string &op = fields[0];
|
|
Arguments args(fields);
|
|
channel_quant::Calibrator &bank = banks[selected];
|
|
int number = 0;
|
|
std::size_t index = 0;
|
|
if (op == "V") {
|
|
if (!view(args, tensor, axis)) return 2;
|
|
std::cout << "V 0\n";
|
|
} else if (op == "F") {
|
|
if (!load_params(args, params)) return 2;
|
|
std::cout << "F 0\n";
|
|
} else if (op == "U" || op == "M") {
|
|
unsigned other = 0;
|
|
if (!args.next(other) || !args.done() || other > 1) return 2;
|
|
if (op == "U") {
|
|
selected = other;
|
|
std::cout << "U " << selected << '\n';
|
|
} else {
|
|
std::cout << "R " << bank.merge(banks[other]) << '\n';
|
|
}
|
|
} else if (op == "C") {
|
|
if (!args.next(index) || !args.next(number) || !args.done()) return 2;
|
|
std::cout << "R " << bank.configure(index, number) << '\n';
|
|
} else if (op == "Z" && args.done()) {
|
|
bank.reset();
|
|
std::cout << "R 0\n";
|
|
} else if (op == "A" && args.done()) {
|
|
std::cout << "R " << bank.update(tensor, axis) << '\n';
|
|
} else if (op == "B" && args.done()) {
|
|
std::cout << "R " << bank.checkpoint() << '\n';
|
|
} else if (op == "R" && args.done()) {
|
|
std::cout << "R " << bank.restore() << '\n';
|
|
} else if (op == "X" && args.done()) {
|
|
std::cout << "R " << bank.clear() << '\n';
|
|
} else if (op == "D" && args.done()) {
|
|
std::cout << "R " << bank.discard_checkpoint() << '\n';
|
|
} else if (op == "S" && args.done()) {
|
|
std::cout << "S " << bank.channels() << ' ' << bank.mode() << ' ' << bank.total() << '\n';
|
|
} else if (op == "I" && args.done()) {
|
|
std::cout << "I " << tensor_hash(tensor) << ' ' << params_hash(params[0]) << ' ' << params_hash(params[1]) << '\n';
|
|
} else if (op == "L" || op == "G" || op == "P") {
|
|
if (!args.next(number) || !args.done() || number < 0) return 2;
|
|
const std::size_t size = static_cast<std::size_t>(number);
|
|
if (op == "L") {
|
|
channel_quant::Layout out{{size}, {size}, size, number, size, size};
|
|
const int result = channel_quant::inspect_layout(tensor, axis, out);
|
|
std::cout << "L " << result << ' ' << out.axis << ' ' << out.origin << ' ' << out.elements << ' ' << out.channels << ' ';
|
|
csv(out.shape); std::cout << ' '; csv(out.strides); std::cout << '\n';
|
|
} else if (op == "G") {
|
|
std::vector<I64> values{number};
|
|
std::vector<std::size_t> channels{size};
|
|
const int result = channel_quant::gather(tensor, axis, values, channels);
|
|
std::cout << "G " << result << ' '; csv(values); std::cout << ' '; csv(channels); std::cout << '\n';
|
|
} else {
|
|
std::vector<QuantParam> values{{size, size, number, number, number}};
|
|
const int result = bank.parameters(values);
|
|
std::cout << "P " << result << ' '; parameters(values); std::cout << '\n';
|
|
}
|
|
} else if (op == "E" || op == "Q") {
|
|
if (!args.next(index) || !args.next(number) || !args.done() || number < 0) return 2;
|
|
if (op == "E") {
|
|
I64 value = number;
|
|
std::size_t channel = static_cast<std::size_t>(number);
|
|
const int result = channel_quant::element(tensor, axis, index, value, channel);
|
|
std::cout << "E " << result << ' ' << value << ' ' << channel << '\n';
|
|
} else {
|
|
channel_quant::Range range{static_cast<U64>(number), number, number};
|
|
const int result = bank.query(index, range);
|
|
std::cout << "Q " << result << ' ' << range.count << ' ' << range.minimum << ' ' << range.maximum << '\n';
|
|
}
|
|
} else if (op == "T" || op == "H") {
|
|
if (!args.next(number) || !args.done()) return 2;
|
|
std::vector<int> out{number};
|
|
const int result = op == "T" ? channel_quant::quantize(tensor, axis, params[0], out) :
|
|
channel_quant::requantize(tensor, axis, params[0], params[1], out);
|
|
std::cout << op << ' ' << result << ' '; csv(out); std::cout << '\n';
|
|
} else if (op == "O") {
|
|
I64 nonce = 0;
|
|
if (!args.next(nonce) || !args.done()) return 2;
|
|
std::vector<I64> out{nonce};
|
|
const int result = channel_quant::dequantize(tensor, axis, params[0], out);
|
|
std::cout << "O " << result << ' '; csv(out); std::cout << '\n';
|
|
} else {
|
|
return 2;
|
|
}
|
|
}
|
|
return std::cin.bad() ? 2 : 0;
|
|
}
|