NICE_VisLearning/math/kernels/KernelData.h

/**
* @file KernelData.h
* @author Erik Rodner
* @date 01/19/2010

*/
#ifndef _NICE_OBJREC_KERNELDATAINCLUDE
#define _NICE_OBJREC_KERNELDATAINCLUDE

#include "core/basics/Config.h"
#include "core/algebra/CholeskyRobust.h"
#include "core/vector/MatrixT.h"

namespace OBJREC {

/** @class KernelData
 * caching some kernel data
 *
 * @author Erik Rodner
 */
class KernelData
{
public:
    enum {
        QUADRATIC_DISTANCES = 0
    };

protected:
    bool verbose;

    NICE::CholeskyRobust *cr;

protected:
    NICE::Matrix kernelMatrix;

    NICE::Matrix inverseKernelMatrix;

    NICE::Matrix choleskyMatrix;

    std::map<int, NICE::Matrix *> cachedMatrices;

    double logdet;

    void initFromConfig ( const NICE::Config *conf, const std::string & section );

    NICE::Matrix B;
    NICE::Matrix U;
    NICE::Matrix V;
    NICE::Matrix F;
    NICE::Matrix F_inv;

public:

    /** standard stuff */
    KernelData();

    /** copy constructor */
    KernelData( const KernelData & src );

    /** simple constructor using config settings for numerical details */
    KernelData( const NICE::Config *conf, const std::string & section = "Kernel" );

    /** the config contains information about numerical setting of the cholesky factorization etc. */
    KernelData( const NICE::Config *conf, const NICE::Matrix & kernelMatrix, const std::string & section = "Kernel", bool updateCholesky = true );

    /** simple destructor */
    virtual ~KernelData();

    /** update the cholesky factorization necessary to use computeInverseKernelMultiply */
    virtual void updateCholeskyFactorization ();

    /** in nearly all cases computeInverseKernelMultiply can be used instead */
    virtual void updateInverseKernelMatrix ();

    /** compute K^{-1} * x */
    virtual void computeInverseKernelMultiply ( const NICE::Vector & x, NICE::Vector & result ) const;

    /** standard const and non-const get functions */
    virtual const NICE::Matrix & getKernelMatrix() const;
    virtual NICE::Matrix & getKernelMatrix();
    virtual const NICE::Matrix & getInverseKernelMatrix() const;
    virtual NICE::Matrix & getInverseKernelMatrix();
    virtual const NICE::Matrix & getCholeskyMatrix() const;

    /** get the logdet of the current kernel matrix (cholesky factorization has to be computed in advance) */
    double getLogDetKernelMatrix () const {
        return logdet;
    };

    /** get the numbers of rows (and columns) of the kernel matrix */
    virtual uint getKernelMatrixSize () const;

    /** get a pre-cached matrix */
    const NICE::Matrix & getCachedMatrix (int i) const;
    /** set a pre-cached matrix */
    void setCachedMatrix (int i, NICE::Matrix *m);

    /** did we already start updateCholeskyFactorization() */
    bool hasCholeskyFactorization () const {
        return (choleskyMatrix.rows() == kernelMatrix.rows());
    };

    /** get efficient GP regression loo estimates and corresponding variances, which can be used
      * to perform model selection (cf. Rasmussen and Williams) */
    void getLooEstimates ( const NICE::Vector & y, NICE::Vector & muLoo, NICE::Vector & sigmaLoo ) const;

    /** clone this object */
    virtual KernelData *clone(void) const;

    void getGPLikelihoodWithOneNewRow( const NICE::Vector & y, const double & oldLogdetK, const int & rowIndex, const NICE::Vector & newRow, const NICE::Vector & oldAlpha, NICE::Vector & newAlpha, double & loglike);

    void getGPLikelihoodWithOneNewRow_FirstPart( const int & rowIndex, const NICE::Vector & newRow);

    void getGPLikelihoodWithOneNewRow_SecondPart( const NICE::Vector & y, const double & oldLogdetK, const NICE::Vector & oldAlpha, NICE::Vector & newAlpha, double & loglike);

    void perform_Rank_2_Update(const int & rowIndex, const NICE::Vector & newRow);
    void perform_Rank_2k_Update(const std::vector<int> & rowIndices, const std::vector<NICE::Vector> & newRows);
    void delete_one_row(const int & rowIndex);
    void delete_multiple_rows(std::vector<int> & indices);

    void setKernelMatrix(const NICE::Matrix & k_matrix);

    void increase_size_by_One();
    void increase_size_by_k(const uint & k);

    void set_verbose(const bool & _verbose) {
        verbose = _verbose;
    };
    bool get_verbose() {
        return verbose;
    };
};

}

#endif