Function CalcShapValuesForDocumentMulti

catboost/libs/fstr/shap_values.cpp:859–1056

}

void CalcShapValuesForDocumentMulti(
    const TFullModel& model,
    const TShapPreparedTrees& preparedTrees,
    const NCB::NModelEvaluation::IQuantizedData* binarizedFeaturesForBlock,
    const TMaybe<TFixedFeatureParams>& fixedFeatureParams,
    int featuresCount,
    TConstArrayRef<NModelEvaluation::TCalcerIndexType> docIndices,
    size_t documentIdxInBlock,
    TVector<TVector<double>>* shapValues,
    ECalcTypeShapValues calcType,
    size_t documentIdx
) {
    const TString lossFunctionName = model.GetLossFunctionName();
    TMaybe<ELossFunction> lossFunction = Nothing();
    if (lossFunctionName) {
        lossFunction = FromString<ELossFunction>(lossFunctionName);
    }
    const bool isRMSEWithUncertainty = lossFunction == ELossFunction::RMSEWithUncertainty;
    const int approxDimension = isRMSEWithUncertainty ? 1 : model.GetDimensionsCount();
    shapValues->assign(approxDimension, TVector<double>(featuresCount + 1, 0.0));
    const TModelTrees& forest = *model.ModelTrees;
    const auto& binFeatureCombinationClass = preparedTrees.BinFeatureCombinationClass;
    const bool isIndependent = (calcType == ECalcTypeShapValues::Independent);
    const auto& independentTreeShapParams = preparedTrees.IndependentTreeShapParams;
    TVector<TVector<TVector<double>>> shapValuesForAllReferences;
    if (isIndependent) {
        const size_t referenceCount = independentTreeShapParams->ReferenceLeafIndicesForAllTrees[0].size();
        const size_t classCount = preparedTrees.CombinationClassFeatures.size();
        shapValuesForAllReferences.resize(referenceCount);
        for (size_t referenceIdx = 0; referenceIdx < referenceCount; ++referenceIdx) {
            shapValuesForAllReferences[referenceIdx].assign(approxDimension, TVector<double>(classCount + 1, 0.0));
        }
    }
    const size_t treeCount = model.GetTreeCount();
    for (size_t treeIdx = 0; treeIdx < treeCount; ++treeIdx) {
        const size_t leafCount = (size_t(1) << forest.GetModelTreeData()->GetTreeSizes()[treeIdx]);
        if (preparedTrees.CalcShapValuesByLeafForAllTrees && model.IsOblivious()) {
            if (isIndependent) {
                const auto& binFeatureCombinationClassByDepth =
                    GetBinFeatureCombinationClassByDepth(forest, binFeatureCombinationClass, treeIdx);
                Y_ASSERT(docIndices[treeIdx] < independentTreeShapParams->ShapValueByDepthBetweenLeavesForAllTrees[treeIdx].size());
                AddValuesToShapValuesByAllReferences(
                    independentTreeShapParams->ShapValueByDepthBetweenLeavesForAllTrees[treeIdx][docIndices[treeIdx]],
                    independentTreeShapParams->ReferenceLeafIndicesForAllTrees[treeIdx],
                    binFeatureCombinationClassByDepth,
                    &shapValuesForAllReferences
                );
            } else {
                Y_ASSERT(docIndices[treeIdx] < preparedTrees.ShapValuesByLeafForAllTrees[treeIdx].size());
                AddValuesToShapValues(
                    preparedTrees.ShapValuesByLeafForAllTrees[treeIdx][docIndices[treeIdx]],
                    approxDimension,
                    shapValues
                );
            }
        } else {
            TVector<TShapValue> shapValuesByLeaf;
            TVector<TVector<TVector<double>>> shapValueByDepthBetweenLeaves;