CrossValidation.h

Go to the documentation of this file.

/*
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * Written (W) 2011-2012 Heiko Strathmann
 * Copyright (C) 2011 Berlin Institute of Technology and Max-Planck-Society
 */

#ifndef __CROSSVALIDATION_H_
#define __CROSSVALIDATION_H_

#include <shogun/evaluation/EvaluationResult.h>
#include <shogun/evaluation/MachineEvaluation.h>

namespace shogun
{

class CMachineEvaluation;
class CCrossValidationOutput;
class CList;

class CCrossValidationResult : public CEvaluationResult
{
    public:
        CCrossValidationResult()
        {
            SG_ADD(&mean, "mean", "Mean of results", MS_NOT_AVAILABLE);
            SG_ADD(&has_conf_int, "has_conf_int", "Has confidence intervals?",
                    MS_NOT_AVAILABLE);
            SG_ADD(&conf_int_low, "conf_int_low", "Lower confidence bound",
                    MS_NOT_AVAILABLE);
            SG_ADD(&conf_int_up, "conf_int_up", "Upper confidence bound",
                        MS_NOT_AVAILABLE);

            SG_ADD(&conf_int_alpha, "conf_int_alpha",
                    "Alpha of confidence interval", MS_NOT_AVAILABLE);

            mean = 0;
            has_conf_int = 0;
            conf_int_low = 0;
            conf_int_up = 0;
            conf_int_alpha = 0;
        }

        virtual EEvaluationResultType get_result_type() const
        {
            return CROSSVALIDATION_RESULT;
        }

        virtual const char* get_name() const { return "CrossValidationResult"; }

        static CCrossValidationResult* obtain_from_generic(
                CEvaluationResult* eval_result)
        {
            if (!eval_result)
                return NULL;

            REQUIRE(eval_result->get_result_type()==CROSSVALIDATION_RESULT,
                    "CrossValidationResult::obtain_from_generic(): argument is"
                    "of wrong type!\n");

            SG_REF(eval_result);
            return (CCrossValidationResult*) eval_result;
        }

        virtual void print_result()
        {
            if (has_conf_int)
            {
                SG_SPRINT("[%f,%f] with alpha=%f, mean=%f\n", conf_int_low,
                        conf_int_up, conf_int_alpha, mean);
            }
            else
                SG_SPRINT("%f\n", mean)
        }

    public:
        float64_t mean;
        bool has_conf_int;
        float64_t conf_int_low;
        float64_t conf_int_up;
        float64_t conf_int_alpha;

};

class CCrossValidation: public CMachineEvaluation
{
public:
    CCrossValidation();

    CCrossValidation(CMachine* machine, CFeatures* features, CLabels* labels,
            CSplittingStrategy* splitting_strategy,
            CEvaluation* evaluation_criterion, bool autolock=true);

    CCrossValidation(CMachine* machine, CLabels* labels,
            CSplittingStrategy* splitting_strategy,
            CEvaluation* evaluation_criterion, bool autolock=true);

    virtual ~CCrossValidation();

    void set_num_runs(int32_t num_runs);

    void set_conf_int_alpha(float64_t m_conf_int_alpha);

    virtual CEvaluationResult* evaluate();

    void add_cross_validation_output(
            CCrossValidationOutput* cross_validation_output);

    virtual const char* get_name() const
    {
        return "CrossValidation";
    }

private:
    void init();

protected:
    virtual float64_t evaluate_one_run();

    int32_t m_num_runs;
    float64_t m_conf_int_alpha;

    CList* m_xval_outputs;
};

}

#endif /* __CROSSVALIDATION_H_ */