Function ApplyModelMulti

catboost/private/libs/algo/apply.cpp:137–206

TVector<TVector<double>> ApplyModelMulti(
    const TFullModel& model,
    const TObjectsDataProvider& objectsData,
    const EPredictionType predictionType,
    int begin, /*= 0*/
    int end,   /*= 0*/
    ILocalExecutor* executor,
    const NCB::TMaybeData<TConstArrayRef<TConstArrayRef<float>>>& baseline)
{
    if (baseline) {
        // TODO: only one dimension of baseline is checked, what about others?
        CB_ENSURE(
            baseline->size() == model.GetDimensionsCount(),
            "Baseline should have the same dimension count as model: expected " << model.GetDimensionsCount()
                                                                                << " got " << baseline->size()
        );
    }

    const int docCount = SafeIntegerCast<int>(objectsData.GetObjectCount());
    const int approxesDimension = model.GetDimensionsCount();
    TVector<double> approxesFlat(docCount * approxesDimension);
    if (docCount > 0) {
        FixupTreeEnd(model.GetTreeCount(), begin, &end);
        PrepareObjectsDataProviderForEvaluation(objectsData);

        const int executorThreadCount = executor ? executor->GetThreadCount() : 0;
        auto blockParams = GetBlockParams(executorThreadCount, docCount, end - begin);

        TApplyVisitor visitor(model, begin, end, 0, approxesFlat);

        const ui32 subBlockSize = ui32(NModelEvaluation::FORMULA_EVALUATION_BLOCK_SIZE * 64);

        const auto applyOnBlock = [&](int blockId) {
            const int blockFirstIdx = blockParams.FirstId + blockId * blockParams.GetBlockSize();
            const int blockLastIdx = Min(blockParams.LastId, blockFirstIdx + blockParams.GetBlockSize());

            BlockedEvaluation(model, objectsData, (ui32)blockFirstIdx, (ui32)blockLastIdx, subBlockSize, &visitor);
        };
        if (executor) {
            executor->ExecRangeWithThrow(applyOnBlock, 0, blockParams.GetBlockCount(), ILocalExecutor::WAIT_COMPLETE);
        } else {
            applyOnBlock(0);
        }
    }

    TVector<TVector<double>> approxes(approxesDimension);
    if (approxesDimension == 1) { //shortcut
        approxes[0].swap(approxesFlat);
    } else {
        for (int dim = 0; dim < approxesDimension; ++dim) {
            approxes[dim].yresize(docCount);
            for (int doc = 0; doc < docCount; ++doc) {
                approxes[dim][doc] = approxesFlat[approxesDimension * doc + dim];
            };
        }
    }
    if (baseline) {
        for (int i = 0; i < approxesDimension; ++i) {