Method quantize

tools/converter/source/common/HQQQuantizer.cpp:60–111

}

HQQQuantizer::QuantizationResult HQQQuantizer::quantize(
    const std::vector<float>& weights) {
    
    QuantizationResult result;
    result.config = mConfig;
    
    int total_elements = weights.size();
    result.elementSize = total_elements;

    // 计算分组数量
    int num_groups = (total_elements + mConfig.group_size - 1) / mConfig.group_size;
    std::shared_ptr<MNN::Tensor> wrap(Tensor::create<float>({num_groups, mConfig.group_size}, (void*)weights.data()));
    auto ctx = Global<modelConfig>::Get()->compressInfo;
    ctx->startOptimize();
    auto W = Variable::create(Express::Expr::create(wrap.get(), false));
    // TODO: Optimize Express Interface to avoid extra operation
    if (ctx->accelerateType != MNN_FORWARD_CPU) {
        // Turn VARP to GPU
        W = W + _Scalar<float>(0.0f);
        W.fix(VARP::CONSTANT);
    }
    auto minW = _ReduceMin(W, {1}, true);
    auto maxW = _ReduceMax(W, {1}, true);
    int qmin = 0;
    int qmax = (1 << (mConfig.bits)) - 1;
    auto threadHold = _Scalar<float>(1.0f / (float)(qmax - qmin));
    auto scale = _Relu6((maxW-minW)*threadHold, 0.0000001f, std::numeric_limits<float>::max());
    auto scaleRev = _Scalar<float>(1.0f) / scale;
    auto zero = scaleRev * _Negative(minW);
    Variable::compute({scaleRev, zero});
    scaleRev.fix(VARP::CONSTANT);
    zero.fix(VARP::CONSTANT);
    if (mConfig.optimize) {
        optimize(scaleRev, zero, W);
    }
    // Turn uint -> int, sub 1<<(bit-1)
    scale = _Reciprocal(scaleRev);
    minW = _Negative(zero * scale);
    qmin = -(1 << (mConfig.bits-1));
    qmax = (1 << (mConfig.bits-1)) - 1;
    auto qw = (W - minW) * scaleRev + _Scalar<float>((float)qmin);
    qw = _Relu6(_Round(qw), qmin, qmax);
    qw = _Cast<int8_t>(qw);
    result.SZ = _Concat({minW, scale}, -1);
    result.QW = qw;
    Variable::compute({result.SZ, result.QW});
    result.SZ.fix(VARP::CONSTANT);
    result.QW.fix(VARP::CONSTANT);
    ctx->endOptimize();

    return result;
}

void HQQQuantizer::optimize(MNN::Express::VARP& S, MNN::Express::VARP& Z, VARP WF) {
    int qmin = 0;