FactorGraphModel.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_GRAPH_MODEL_H__
#define __FACTOR_GRAPH_MODEL_H__

#include <shogun/lib/config.h>

#include <shogun/lib/SGString.h>
#include <shogun/lib/DynamicObjectArray.h>
#include <shogun/structure/StructuredModel.h>
#include <shogun/structure/FactorType.h>
#include <shogun/structure/MAPInference.h>

namespace shogun
{

class CFactorGraphModel : public CStructuredModel
{
public:
    CFactorGraphModel();

    CFactorGraphModel(CFeatures* features, CStructuredLabels* labels,
        EMAPInferType inf_type = TREE_MAX_PROD, bool verbose = false);

    ~CFactorGraphModel();

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

    void add_factor_type(CFactorType* ftype);

    void del_factor_type(const int32_t ftype_id);

    CDynamicObjectArray* get_factor_types() const;

    CFactorType* get_factor_type(const int32_t ftype_id) const;

    SGVector<int32_t> get_global_params_mapping() const;

    SGVector<int32_t> get_params_mapping(const int32_t ftype_id);

    SGVector<float64_t> fparams_to_w();

    void w_to_fparams(SGVector<float64_t> w);

    virtual SGVector< float64_t > get_joint_feature_vector(int32_t feat_idx, CStructuredData* y);

    virtual CResultSet* argmax(SGVector< float64_t > w, int32_t feat_idx, bool const training = true);

    virtual float64_t delta_loss(CStructuredData* y1, CStructuredData* y2);

    virtual void init_training();

    virtual void init_primal_opt(
            float64_t regularization,
            SGMatrix< float64_t > & A,  SGVector< float64_t > a,
            SGMatrix< float64_t > B,  SGVector< float64_t > & b,
            SGVector< float64_t > & lb, SGVector< float64_t > & ub,
            SGMatrix < float64_t >  & C);

    virtual int32_t get_dim() const;

private:
    void init();

protected:
    CDynamicObjectArray* m_factor_types;

    SGVector<int32_t> m_w_map;

    SGVector<float64_t> m_w_cache;

    EMAPInferType m_inf_type;

    bool m_verbose;
};

}

#endif