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/lib/config.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(&std_dev, "std_dev",
                    "Standard deviation of cross-validation folds", MS_NOT_AVAILABLE);

            mean = 0;
            std_dev = 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()
        {
            SG_SPRINT("%f+-%f\n", mean, std_dev);
        }

    public:
        float64_t mean;
        float64_t std_dev;
};

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);

    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;

    CList* m_xval_outputs;
};

}

#endif /* __CROSSVALIDATION_H_ */