Method BuildDataSet

catboost/cuda/gpu_data/feature_parallel_dataset_builder.cpp:9–282

namespace NCatboostCuda {
    TFeatureParallelDataSetsHolder TFeatureParallelDataSetHoldersBuilder::BuildDataSet(const ui32 permutationCount,
                                                                                       NPar::ILocalExecutor* localExecutor) {
        TFeatureParallelDataSetsHolder dataSetsHolder(DataProvider,
                                                      FeaturesManager);

        Y_ASSERT(dataSetsHolder.CompressedIndex);
        TSharedCompressedIndexBuilder<TDataSetLayout> compressedIndexBuilder(*dataSetsHolder.CompressedIndex,
                                                                             localExecutor);

        dataSetsHolder.CtrTargets = BuildCtrTarget(FeaturesManager,
                                                   DataProvider,
                                                   LinkedTest);
        auto& ctrsTarget = *dataSetsHolder.CtrTargets;

        {
            dataSetsHolder.LearnCatFeaturesDataSet = MakeHolder<TCompressedCatFeatureDataSet>(CatFeaturesStorage);
            BuildCompressedCatFeatures(DataProvider,
                                       *dataSetsHolder.LearnCatFeaturesDataSet,
                                       localExecutor);

            if (LinkedTest) {
                dataSetsHolder.TestCatFeaturesDataSet = MakeHolder<TCompressedCatFeatureDataSet>(CatFeaturesStorage);
                BuildCompressedCatFeatures(*LinkedTest,
                                           *dataSetsHolder.TestCatFeaturesDataSet,
                                           localExecutor);
            }
        }

        TAtomicSharedPtr<TPermutationScope> permutationIndependentScope = new TPermutationScope;

        dataSetsHolder.PermutationDataSets.resize(permutationCount);

        const auto learnWeights = NCB::GetWeights(*DataProvider.TargetData);

        const bool isTrivialLearnWeights = AreEqualTo(learnWeights, 1.0f);
        {
            const auto learnMapping = NCudaLib::TMirrorMapping(ctrsTarget.LearnSlice.Size());

            if (isTrivialLearnWeights == ctrsTarget.IsTrivialWeights()) {
                dataSetsHolder.DirectWeights = ctrsTarget.Weights.SliceView(ctrsTarget.LearnSlice);
            } else {
                dataSetsHolder.DirectWeights.Reset(learnMapping);
                dataSetsHolder.DirectWeights.Write(learnWeights);
            }
            if (isTrivialLearnWeights && ctrsTarget.IsTrivialWeights()) {
                dataSetsHolder.DirectTarget = ctrsTarget.WeightedTarget.SliceView(ctrsTarget.LearnSlice);
            } else {
                dataSetsHolder.DirectTarget.Reset(learnMapping);
                dataSetsHolder.DirectTarget.Write(*DataProvider.TargetData->GetOneDimensionalTarget());
            }
        }

        for (ui32 permutationId = 0; permutationId < permutationCount; ++permutationId) {
            TDataPermutation permutation = NCatboostCuda::GetPermutation(DataProvider,
                                                                         permutationId,
                                                                         DataProviderPermutationBlockSize);

            const auto targetsMapping = NCudaLib::TMirrorMapping(ctrsTarget.LearnSlice.Size());