Function PushBackEvalPrinters

catboost/libs/eval_result/column_printer.cpp:13–67

namespace NCB {

    void PushBackEvalPrinters(
        const TVector<TVector<TVector<double>>>& rawValues,
        const EPredictionType predictionType,
        const TString& lossFunctionName,
        const TMaybe<TString>& modelName,
        bool isMultiTarget,
        size_t ensemblesCount,
        const TExternalLabelsHelper& visibleLabelsHelper,
        TMaybe<std::pair<size_t, size_t>> evalParameters,
        TVector<THolder<IColumnPrinter>>* result,
        NPar::ILocalExecutor* executor,
        double binClassLogitThreshold
    ) {
        int begin = 0;
        const bool callMakeExternalApprox
            = visibleLabelsHelper.IsInitialized()
              && (visibleLabelsHelper.GetExternalApproxDimension() > 1)
              && !IsUncertaintyPredictionType(predictionType);
        for (const auto& raws : rawValues) {
            const auto& approx = callMakeExternalApprox ? MakeExternalApprox(raws, visibleLabelsHelper) : raws;
            auto approxes = PrepareEval(
                predictionType,
                ensemblesCount,
                lossFunctionName,
                approx,
                executor,
                binClassLogitThreshold
            );
            const auto& headers = CreatePredictionTypeHeader(
                approx.size(),
                isMultiTarget,
                predictionType,
                visibleLabelsHelper,
                lossFunctionName,
                modelName,
                ensemblesCount,
                begin,
                evalParameters.Get()
            );
            if (!lossFunctionName.empty() && IsMultiLabelObjective(lossFunctionName)) {
                for (int i = 0; i < approxes.ysize(); ++i) {
                    result->push_back(MakeHolder<TArrayPrinter<double>>(std::move(approxes[i]), headers[i]));
                }
            } else {
                for (int i = 0; i < approxes.ysize(); ++i) {
                    result->push_back(
                        MakeHolder<TEvalPrinter>(predictionType, headers[i], approxes[i], visibleLabelsHelper)
                    );
                }
            }
            if (evalParameters) {
                begin += evalParameters->first;
            }
        }
    }

    TVector<TString> CreatePredictionTypeHeaderForUncertainty(
        EPredictionType predictionType,