Function initGetThreshold

tools/cpp/getLinearInput.hpp:130–185

inline void initGetThreshold(const std::string& thresholdFileName, float targetSparsity) {
    initThresholdFile(thresholdFileName);
    
    static bool registered = false;
    if (!registered) {
        std::atexit(cleanupAtExit);
        registered = true;
    }

    MNN::TensorCallBackWithInfo beforeCallBack = [targetSparsity](const std::vector<MNN::Tensor*>& ntensors, const MNN::OperatorInfo* info) {
        auto opName = info->name();
        if (info->type() == "Copy") {
            return true;
        }
        if (opName.find("Linear") == std::string::npos || opName.find("raster") != std::string::npos) {
            return true;
        }
        for (int i = 0; i < ntensors.size(); ++i) {
            auto ntensor = ntensors[i];
            auto outDimType = ntensor->getDimensionType();
            std::shared_ptr<MNN::Tensor> expectTensor(new MNN::Tensor(ntensor, outDimType));
            bool res = ntensor->copyToHostTensor(expectTensor.get());
            if (res) {
                ntensor = expectTensor.get();
            }
            {
                auto ninput = MNN::Express::Variable::create(MNN::Express::Expr::create(ntensor));
                if (nullptr == ninput->getInfo()) {
                    MNN_ERROR("Alloc memory or compute size error\n");
                    return false;
                }
                ninput = MNN::Express::_Convert(ninput, MNN::Express::NHWC);
                ninput = MNN::Express::_Abs(ninput);
                ninput = MNN::Express::_Reshape(ninput, {-1});

                auto totalNum = ninput->getInfo()->dim[0];
                int keepNum = totalNum * (1 - targetSparsity);

                auto kv = MNN::Express::_TopKV2(ninput, MNN::Express::_Scalar<int>(keepNum));
                auto values = kv[0];

                auto threshold = MNN::Express::_Gather(values, MNN::Express::_Scalar<int>(keepNum - 1));
                auto thresholdValue = threshold->readMap<float>()[0];

                writeThresholdRealtime(opName, thresholdValue);
            }
        }
        return true;
    };

    MNN::TensorCallBackWithInfo callBack = [](const std::vector<MNN::Tensor*>& ntensors, const MNN::OperatorInfo* info) {
        return true;
    };

    MNN::Express::ExecutorScope::Current()->setCallBack(std::move(beforeCallBack), std::move(callBack));
}

inline void initGetMaxValue(const std::string& maxValueFileName) {