Function QualityBenchmark

library/cpp/linear_regression/benchmark/main.cpp:13–67

template <typename TLRSolver>
void QualityBenchmark(const TPool& originalPool) {
    auto measure = [&](const double injureFactor, const double injureOffset) {
        TPool injuredPool = originalPool.InjurePool(injureFactor, injureOffset);

        static const size_t runsCount = 10;
        static const size_t foldsCount = 10;

        TMeanCalculator determinationCoefficientCalculator;

        TPool::TCVIterator learnIterator = injuredPool.CrossValidationIterator(foldsCount, TPool::LearnIterator);
        TPool::TCVIterator testIterator = injuredPool.CrossValidationIterator(foldsCount, TPool::TestIterator);

        for (size_t runNumber = 0; runNumber < runsCount; ++runNumber) {
            for (size_t foldNumber = 0; foldNumber < foldsCount; ++foldNumber) {
                learnIterator.ResetShuffle();
                learnIterator.SetTestFold(foldNumber);
                testIterator.ResetShuffle();
                testIterator.SetTestFold(foldNumber);

                TLRSolver solver;
                for (; learnIterator.IsValid(); ++learnIterator) {
                    solver.Add(learnIterator->Features, learnIterator->Goal, learnIterator->Weight);
                }
                TLinearModel model = solver.Solve();

                TDeviationCalculator goalsCalculator;
                TKahanAccumulator<double> errorsCalculator;
                for (; testIterator.IsValid(); ++testIterator) {
                    const double prediction = model.Prediction(testIterator->Features);
                    const double goal = testIterator->Goal;
                    const double weight = testIterator->Weight;
                    const double error = goal - prediction;

                    goalsCalculator.Add(goal, weight);
                    errorsCalculator += error * error * weight;
                }

                const double determinationCoefficient = 1 - errorsCalculator.Get() / goalsCalculator.GetDeviation();
                determinationCoefficientCalculator.Add(determinationCoefficient);
            }
        }

        return determinationCoefficientCalculator.GetMean();
    };

    Cout << TypeName<TLRSolver>() << ":\n";
    Cout << "\t" << Sprintf("base    : %.10lf\n", measure(1., 0.));
    Cout << "\t" << Sprintf("injure1 : %.10lf\n", measure(1e-1, 1e+1));
    Cout << "\t" << Sprintf("injure2 : %.10lf\n", measure(1e-3, 1e+4));
    Cout << "\t" << Sprintf("injure3 : %.10lf\n", measure(1e-3, 1e+5));
    Cout << "\t" << Sprintf("injure4 : %.10lf\n", measure(1e-3, 1e+6));
    Cout << "\t" << Sprintf("injure5 : %.10lf\n", measure(1e-4, 1e+6));
    Cout << "\t" << Sprintf("injure6 : %.10lf\n", measure(1e-4, 1e+7));
    Cout << Endl;
}

template <typename TLRSolver>
void SpeedBenchmark(const TPool& originalPool) {