Factor.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) 2013 Shell Hu 
 * Copyright (C) 2013 Shell Hu 
 */

#ifndef __FACTOR_RELATED_H__
#define __FACTOR_RELATED_H__

#include <shogun/base/SGObject.h>
#include <shogun/lib/SGVector.h>
#include <shogun/lib/SGSparseVector.h>
#include <shogun/structure/FactorType.h>

namespace shogun 
{

class CFactorDataSource : public CSGObject
{
public:
    CFactorDataSource();

    CFactorDataSource(SGVector<float64_t> dense);

    CFactorDataSource(SGSparseVector<float64_t> sparse);

    virtual ~CFactorDataSource();

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

    virtual bool is_sparse() const;

    virtual SGVector<float64_t> get_data() const;

    virtual SGSparseVector<float64_t> get_data_sparse() const;

    virtual void set_data(SGVector<float64_t> dense);

    virtual void set_data_sparse(SGSparseVectorEntry<float64_t>* sparse, int32_t dlen);

private:
    void init();

private:
    SGVector<float64_t> m_dense;

    SGSparseVector<float64_t> m_sparse;
};

class CFactor : public CSGObject
{
public:
    CFactor();

    CFactor(CTableFactorType* ftype, SGVector<int32_t> var_index, SGVector<float64_t> data);

    CFactor(CTableFactorType* ftype, SGVector<int32_t> var_index,
        SGSparseVector<float64_t> data_sparse);

    CFactor(CTableFactorType* ftype, SGVector<int32_t> var_index,
        CFactorDataSource* data_source);

    virtual ~CFactor();

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

    CTableFactorType* get_factor_type() const;

    void set_factor_type(CTableFactorType* ftype);

    const SGVector<int32_t> get_variables() const;

    void set_variables(SGVector<int32_t> vars);

    const SGVector<int32_t> get_cardinalities() const;

    SGVector<float64_t> get_data() const;

    SGSparseVector<float64_t> get_data_sparse() const;

    void set_data(SGVector<float64_t> data_dense);

    void set_data_sparse(SGSparseVectorEntry<float64_t>* data_sparse, int32_t dlen);

    bool is_data_dependent() const;

    bool is_data_sparse() const;

    SGVector<float64_t> get_energies() const;

    SGVector<float64_t> get_energies();

    float64_t get_energy(int32_t index) const;

    void set_energies(SGVector<float64_t> ft_energies);

    void set_energy(int32_t ei, float64_t value);

    float64_t evaluate_energy(const SGVector<int32_t> state) const;

    void compute_energies();

    void compute_gradients(const SGVector<float64_t> marginals,
        SGVector<float64_t>& parameter_gradient, double mult = 1.0) const;

protected:
    CTableFactorType* m_factor_type;

    SGVector<int32_t> m_var_index;

    SGVector<float64_t> m_energies;

    CFactorDataSource* m_data_source;

    SGVector<float64_t> m_data;

    SGSparseVector<float64_t> m_data_sparse;

    bool m_is_data_dep;

private:
    void init();
};

}

#endif