Method _insertScale

tools/quantization/calibration.cpp:1110–1207

}

void Calibration::_insertScale() {
    for (const auto iter :  _scales) {
        std::unique_ptr<MNN::TensorDescribeT> describe(new MNN::TensorDescribeT);
        auto des = iter.first.lock();
        if (!des) {
            continue;
        }
        if (des->index < 0) {
            continue;
        }

        describe->index = des->index;
        describe->quantInfo.reset(new MNN::TensorQuantInfoT);
        describe->quantInfo->scale = iter.second.first;
        describe->quantInfo->zero = iter.second.second;
        describe->quantInfo->type = MNN::DataType_DT_INT8;
        describe->quantInfo->min = -1 * _featureClampValue;
        describe->quantInfo->max = 1 * _featureClampValue;
        auto dstiter = _tensorDescribes.find(des->index);
        if (dstiter == _tensorDescribes.end()) {
            _tensorDescribes.insert(std::make_pair(des->index, std::move(describe)));
        } else {
            dstiter->second->quantInfo = std::move(describe->quantInfo);
        }
    }
    for (auto& op : _originalModel->oplists) {
        const auto opType = op->type;

        std::vector<std::string>::iterator iter = std::find(_skip_quant_ops.begin(), _skip_quant_ops.end(), op->name);
        if (iter != _skip_quant_ops.end()) {
            continue;
        }

        if (opType != MNN::OpType_Convolution && opType != MNN::OpType_ConvolutionDepthwise && opType != MNN::OpType_Deconvolution) {
            continue;
        }
        if (op->inputIndexes.size() > 1) {
            continue;
        }
        if (_tensorMap[op->inputIndexes[0]].first.lock() == nullptr || _tensorMap[op->outputIndexes[0]].first.lock() == nullptr) {
            continue;
        }
        auto inputTensor = _tensorMap[op->inputIndexes[0]].second;
        auto outputTensor = _tensorMap[op->outputIndexes[0]].second;
        if (inputTensor == nullptr || outputTensor == nullptr) {
            continue;
        }
        // below is Conv/DepthwiseConv weight quant
        auto weakPtr0 = std::weak_ptr<Tensor::InsideDescribe::NativeInsideDescribe>(TensorUtils::getDescribeOrigin(inputTensor)->mContent);
        auto weakPtr1 = std::weak_ptr<Tensor::InsideDescribe::NativeInsideDescribe>(TensorUtils::getDescribeOrigin(outputTensor)->mContent);
        const float inputScale  = _scales[weakPtr0].first;
        const float outputScale = _scales[weakPtr1].first;
        const int inputChannel = inputTensor->channel();
        const int outputChannel = outputTensor->channel();
        auto param                = op->main.AsConvolution2D();
        param->common->inputCount = inputChannel;
        const int channles        = param->common->outputCount;
        param->symmetricQuan.reset(new MNN::QuantizedFloatParamT);