GaussianProcessRegression.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.
 *
 * Copyright (C) 2012 Jacob Walker
 */

#ifndef _GAUSSIANPROCESSREGRESSION_H__
#define _GAUSSIANPROCESSREGRESSION_H__

#include <shogun/lib/config.h>
#ifdef HAVE_EIGEN3
#ifdef HAVE_LAPACK

#include <shogun/regression/Regression.h>
#include <shogun/machine/Machine.h>
#include <shogun/features/DenseFeatures.h>
#include <shogun/regression/gp/InferenceMethod.h>

namespace shogun
{

class CInferenceMethod;
class CFeatures;
class CLabels;

class CGaussianProcessRegression : public CMachine
{

    public:
        MACHINE_PROBLEM_TYPE(PT_REGRESSION);

        enum EGPReturnType
        {
            GP_RETURN_MEANS,
            GP_RETURN_COV,
            GP_RETURN_BOTH
        };

        CGaussianProcessRegression(CInferenceMethod* inf,
                       CFeatures* data, CLabels* lab);

        CGaussianProcessRegression();

        virtual ~CGaussianProcessRegression();
        
        virtual void set_features(CFeatures* feat)
        {
            SG_UNREF(m_features);
            SG_REF(feat);
            m_features = feat;
            update_kernel_matrices();
        }
        
        virtual CFeatures* get_features()
        {
            SG_REF(m_features);
            return m_features;
        }
        
        inline void set_method(CInferenceMethod* inf)
        {
            SG_UNREF(m_method);
            SG_REF(inf);
            m_method = inf;
        };
        
        inline CInferenceMethod* get_method()
        {
            SG_REF(m_method);
            return m_method;
        };
            
        virtual bool load(FILE* srcfile);
        
        virtual bool save(FILE* dstfile);

        void set_kernel(CKernel* k);
        
        CKernel* get_kernel();
        
        virtual CRegressionLabels* apply_regression(CFeatures* data = NULL);
        
        virtual EMachineType get_classifier_type()
        {
          return CT_GAUSSIANPROCESSREGRESSION;
        }
        
        SGVector<float64_t> get_covariance_vector();
        
        SGVector<float64_t> get_mean_vector();

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

        inline void set_return_type(EGPReturnType t)
        {
            m_return = t;
        };

        inline EGPReturnType get_return_type()
        {
            return m_return;
        };

    
    protected:
        virtual bool train_machine(CFeatures* data = NULL);
    private:

        void init();

        /* Update kernel matrices */
        void update_kernel_matrices();

    private:

        CFeatures* m_features;
        
        CFeatures* m_data;

        /*Kernel matrix from testing and training
         * features
         */
        SGMatrix<float64_t> m_k_trts;

        /*Kernel matrix from testing
         * features
         */
        SGMatrix<float64_t> m_k_tsts;

        CInferenceMethod* m_method;

        /*What should apply_regression return?*/
        EGPReturnType m_return;
};

}

#endif 
#endif
#endif /* _GAUSSIANPROCESSREGRESSION_H__ */