Method writeExtraDescribeTensor

tools/cpp/revertMNNModel.cpp:79–131

}

void Revert::writeExtraDescribeTensor(float* scale, float* offset) {
    int opCounts = static_cast<int32_t>(mMNNNet->oplists.size());
    for (int opIndex = 0; opIndex < opCounts; ++opIndex) {
        std::unique_ptr<MNN::TensorDescribeT> describe(new MNN::TensorDescribeT);
        describe->index = opIndex;
        describe->quantInfo.reset(new MNN::TensorQuantInfoT);
        describe->quantInfo->scale = *scale;
        describe->quantInfo->zero = *offset;
        describe->quantInfo->min = -127;
        describe->quantInfo->max = 127;
        describe->quantInfo->type = MNN::DataType_DT_INT8;
        mMNNNet->extraTensorDescribe.emplace_back(std::move(describe));
    }
    for (const auto& op: mMNNNet->oplists) {
        const auto opType = op->type;
        if (opType != MNN::OpType_Convolution && opType != MNN::OpType_ConvolutionDepthwise && opType != MNN::OpType_Deconvolution) {
            continue;
        }
        // Conv/ConvDepthwise/Deconv weight quant.
        const float inputScale = *scale;
        const float outputScale = *scale;
        const int outputChannel = static_cast<int32_t>(op->outputIndexes.size());

        auto param = op->main.AsConvolution2D();
        float* originWeight = param->weight.data();
        const int channels = param->common->outputCount;
        param->symmetricQuan.reset(new MNN::QuantizedFloatParamT);
        param->symmetricQuan->nbits = 8;
        const int weightSize = static_cast<int32_t>(param->weight.size());
        param->common->inputCount = weightSize / (channels * param->common->kernelX * param->common->kernelY);
        std::vector<int8_t> quantizedWeight(weightSize);
        std::vector<float> quantizedWeightScale(channels);

        if (originWeight[0] == 0.f && originWeight[1] == 0.f) { // Process weight is null.
            // Initialize originWeight
            std::uniform_real_distribution<double> u(-200, 200);
            std::default_random_engine e(time(NULL));
            for (int i = 0; i < weightSize; ++i) {
                originWeight[i] = u(e);
            }
        }

        SymmetricQuantizeWeight(originWeight, weightSize, quantizedWeight.data(), quantizedWeightScale.data(), channels, 127.0f);
        param->quanParameter = IDSTEncoder::encode(param->weight.data(), quantizedWeightScale, weightSize/channels, channels, false, quantizedWeight.data(), -127.0f);
        param->quanParameter->scaleIn = *scale;
        param->quanParameter->scaleOut = *scale;
        if (param->common->relu6) {
            param->common->relu  = true;
            param->common->relu6 = false;
        }
        param->weight.clear();
    }
}

void Revert::packMNNNet() {
    flatbuffers::FlatBufferBuilder builder(1024);