InferenceMethod.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 CINFERENCEMETHOD_H_
#define CINFERENCEMETHOD_H_
#ifdef HAVE_EIGEN3
#include <shogun/kernel/Kernel.h>
#include <shogun/base/SGObject.h>
#include <shogun/features/DotFeatures.h>
#include <shogun/labels/Labels.h>
#include <shogun/regression/gp/LikelihoodModel.h>
#include <shogun/regression/gp/MeanFunction.h>
#include <shogun/evaluation/DifferentiableFunction.h>
#include <shogun/labels/RegressionLabels.h>


namespace shogun
{

class CInferenceMethod : public CDifferentiableFunction
{
  
public:

    CInferenceMethod();

    CInferenceMethod(CKernel* kernel, CFeatures* features,
            CMeanFunction* mean, CLabels* labels, CLikelihoodModel* model);

    virtual ~CInferenceMethod();

    virtual float64_t get_negative_marginal_likelihood() = 0;

    virtual CMap<TParameter*, SGVector<float64_t> >
        get_marginal_likelihood_derivatives(
        CMap<TParameter*, CSGObject*>& para_dict) = 0;

    virtual SGVector<float64_t> get_alpha() = 0;

    virtual SGMatrix<float64_t> get_cholesky() = 0;

    virtual SGVector<float64_t> get_diagonal_vector() = 0;

    virtual void set_features(CFeatures* feat);

    virtual CFeatures* get_features()
    {
        SG_REF(m_features);
        return m_features;
    }

    virtual CKernel* get_kernel() { SG_REF(m_kernel); return m_kernel; }

    virtual void set_kernel(CKernel* kern);

    virtual CMeanFunction* get_mean() { SG_REF(m_mean); return m_mean; }

    virtual void set_mean(CMeanFunction* m);

    virtual CLabels* get_labels() { SG_REF(m_labels); return m_labels; }

    virtual void set_labels(CLabels* lab);

    CLikelihoodModel* get_model() {SG_REF(m_model); return m_model; }

    virtual void set_model(CLikelihoodModel* mod);

    virtual void set_scale(float64_t s);

    virtual float64_t get_scale() { return m_scale; }

    virtual void set_latent_features(CFeatures* feat);

    virtual CFeatures* get_latent_features()
    {
        SG_REF(m_latent_features);
        return m_latent_features;
    }


protected:

    virtual void update_alpha() {}

    virtual void update_chol() {}

    virtual void update_train_kernel() {}

    virtual void update_data_means();

private:
    void init();

protected:

    CKernel* m_kernel;

    CFeatures* m_features;

    SGMatrix<float64_t> m_feature_matrix;

    SGVector<float64_t> m_data_means;

    SGVector<float64_t> m_label_vector;


    CLabels* m_labels;

    CMeanFunction* m_mean;

    CFeatures* m_latent_features;

    CLikelihoodModel* m_model;

    SGVector< float64_t > m_alpha;

    SGMatrix<float64_t> m_L;

    float64_t m_scale;

    SGMatrix<float64_t> m_ktrtr;

    SGMatrix<float64_t> m_latent_matrix;

};

}
#endif /* HAVE_EIGEN3 */
#endif /* CInferenceMethod_H_ */