Function TrainModelImpl

catboost/cuda/train_lib/train.cpp:220–265

    }

    TGpuTrainResult TrainModelImpl(const TTrainModelInternalOptions& internalOptions,
                                                                const NCatboostOptions::TCatBoostOptions& trainCatBoostOptions,
                                                                const NCatboostOptions::TOutputFilesOptions& outputOptions,
                                                                const TTrainingDataProvider& dataProvider,
                                                                const TTrainingDataProvider* testProvider,
                                                                const TFeatureEstimators& featureEstimators,
                                                                TBinarizedFeaturesManager& featuresManager,
                                                                ui32 approxDimension,
                                                                ITrainingCallbacks* trainingCallbacks,
                                                                NPar::ILocalExecutor* localExecutor,
                                                                TVector<TVector<double>>* testMultiApprox, // [dim][objectIdx]
                                                                TMetricsAndTimeLeftHistory* metricsAndTimeHistory,
                                                                const TMaybe<TCustomObjectiveDescriptor>& objectiveDescriptor,
                                                                const TMaybe<TCustomMetricDescriptor>& evalMetricDescriptor
                                                                ) {
        auto& profiler = NCudaLib::GetCudaManager().GetProfiler();
        ConfigureCudaProfiler(trainCatBoostOptions.IsProfile, &profiler);

        TGpuAwareRandom random(trainCatBoostOptions.RandomSeed);

        TGpuTrainResult model;

        const auto optimizationImplementation = GetTrainerFactoryKey(trainCatBoostOptions);

        if (TGpuTrainerFactory::Has(optimizationImplementation)) {
            THolder<IGpuTrainer> trainer(TGpuTrainerFactory::Construct(optimizationImplementation));
            model = trainer->TrainModel(featuresManager,
                                        internalOptions,
                                        trainCatBoostOptions,
                                        outputOptions,
                                        dataProvider,
                                        testProvider,
                                        featureEstimators,
                                        objectiveDescriptor,
                                        evalMetricDescriptor,
                                        random,
                                        approxDimension,
                                        trainingCallbacks,
                                        localExecutor,
                                        testMultiApprox,
                                        metricsAndTimeHistory);
        } else {
            ythrow TCatBoostException() << "Error: optimization scheme is not supported for GPU learning " << optimizationImplementation;
        }
        return model;
    }

    void ModelBasedEvalImpl(const NCatboostOptions::TCatBoostOptions& trainCatBoostOptions,
                            const NCatboostOptions::TOutputFilesOptions& outputOptions,