LinearHMM.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) 1999-2009 Soeren Sonnenburg
 * Written (W) 1999-2008 Gunnar Raetsch
 * Copyright (C) 1999-2009 Fraunhofer Institute FIRST and Max-Planck-Society
 */

#ifndef _LINEARHMM_H__
#define _LINEARHMM_H__

#include <shogun/lib/config.h>

#include <shogun/features/StringFeatures.h>
#include <shogun/labels/Labels.h>
#include <shogun/distributions/Distribution.h>

namespace shogun
{
class CLinearHMM : public CDistribution
{
    public:
        CLinearHMM();

        CLinearHMM(CStringFeatures<uint16_t>* f);

        CLinearHMM(int32_t p_num_features, int32_t p_num_symbols);

        virtual ~CLinearHMM();

        virtual bool train(CFeatures* data=NULL);

        bool train(
            const int32_t* indizes, int32_t num_indizes,
            float64_t pseudo_count);

        float64_t get_log_likelihood_example(uint16_t* vector, int32_t len);

        float64_t get_likelihood_example(uint16_t* vector, int32_t len);

        float64_t get_likelihood_example(int32_t num_example);

        virtual float64_t get_log_likelihood_example(int32_t num_example);

        virtual float64_t get_log_derivative(
            int32_t num_param, int32_t num_example);

        virtual float64_t get_log_derivative_obsolete(
            uint16_t obs, int32_t pos)
        {
            return 1.0/transition_probs[pos*num_symbols+obs];
        }

        virtual float64_t get_derivative_obsolete(
            uint16_t* vector, int32_t len, int32_t pos)
        {
            ASSERT(pos<len)
            return get_likelihood_example(vector, len)/transition_probs[pos*num_symbols+vector[pos]];
        }

        virtual int32_t get_sequence_length() { return sequence_length; }

        virtual int32_t get_num_symbols() { return num_symbols; }

        virtual int32_t get_num_model_parameters() { return num_params; }

        virtual float64_t get_positional_log_parameter(
            uint16_t obs, int32_t position)
        {
            return log_transition_probs[position*num_symbols+obs];
        }

        virtual float64_t get_log_model_parameter(int32_t num_param)
        {
            ASSERT(log_transition_probs)
            ASSERT(num_param<num_params)

            return log_transition_probs[num_param];
        }

        virtual SGVector<float64_t> get_log_transition_probs();

        virtual bool set_log_transition_probs(const SGVector<float64_t> probs);

        virtual SGVector<float64_t> get_transition_probs();

        virtual bool set_transition_probs(const SGVector<float64_t> probs);

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

    protected:
        virtual void load_serializable_post() throw (ShogunException);

    private:
        void init();

    protected:
        int32_t sequence_length;
        int32_t num_symbols;
        int32_t num_params;
        float64_t* transition_probs;
        float64_t* log_transition_probs;
};
}
#endif