WDSVMOcas.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) 2007-2008 Vojtech Franc
 * Written (W) 2007-2009 Soeren Sonnenburg
 * Copyright (C) 2007-2009 Fraunhofer Institute FIRST and Max-Planck-Society
 */

#ifndef _WDSVMOCAS_H___
#define _WDSVMOCAS_H___

#include <shogun/lib/common.h>
#include <shogun/machine/Machine.h>
#include <shogun/classifier/svm/SVMOcas.h>
#include <shogun/features/StringFeatures.h>
#include <shogun/labels/Labels.h>

namespace shogun
{
template <class ST> class CStringFeatures;

class CWDSVMOcas : public CMachine
{
    public:
        MACHINE_PROBLEM_TYPE(PT_BINARY);

        CWDSVMOcas();

        CWDSVMOcas(E_SVM_TYPE type);

        CWDSVMOcas(
            float64_t C, int32_t d, int32_t from_d,
            CStringFeatures<uint8_t>* traindat, CLabels* trainlab);
        virtual ~CWDSVMOcas();

        virtual EMachineType get_classifier_type() { return CT_WDSVMOCAS; }

        inline void set_C(float64_t c_neg, float64_t c_pos) { C1=c_neg; C2=c_pos; }

        inline float64_t get_C1() { return C1; }

        inline float64_t get_C2() { return C2; }

        inline void set_epsilon(float64_t eps) { epsilon=eps; }

        inline float64_t get_epsilon() { return epsilon; }

        inline void set_features(CStringFeatures<uint8_t>* feat)
        {
            SG_UNREF(features);
            SG_REF(feat);
            features=feat;
        }

        inline CStringFeatures<uint8_t>* get_features()
        {
            SG_REF(features);
            return features;
        }

        inline void set_bias_enabled(bool enable_bias) { use_bias=enable_bias; }

        inline bool get_bias_enabled() { return use_bias; }

        inline void set_bufsize(int32_t sz) { bufsize=sz; }

        inline int32_t get_bufsize() { return bufsize; }

        inline void set_degree(int32_t d, int32_t from_d)
        {
            degree=d;
            from_degree=from_d;
        }

        inline int32_t get_degree() { return degree; }

        virtual CBinaryLabels* apply_binary(CFeatures* data=NULL);
        
        virtual CRegressionLabels* apply_regression(CFeatures* data=NULL);

        virtual float64_t apply_one(int32_t num)
        {
            ASSERT(features);
            if (!wd_weights)
                set_wd_weights();

            int32_t len=0;
            float64_t sum=0;
            bool free_vec;
            uint8_t* vec=features->get_feature_vector(num, len, free_vec);
            //SG_INFO("len %d, string_length %d\n", len, string_length);
            ASSERT(len==string_length);

            for (int32_t j=0; j<string_length; j++)
            {
                int32_t offs=w_dim_single_char*j;
                int32_t val=0;
                for (int32_t k=0; (j+k<string_length) && (k<degree); k++)
                {
                    val=val*alphabet_size + vec[j+k];
                    sum+=wd_weights[k] * w[offs+val];
                    offs+=w_offsets[k];
                }
            }
            features->free_feature_vector(vec, num, free_vec);
            return sum/normalization_const;
        }

        inline void set_normalization_const()
        {
            ASSERT(features);
            normalization_const=0;
            for (int32_t i=0; i<degree; i++)
                normalization_const+=(string_length-i)*wd_weights[i]*wd_weights[i];

            normalization_const=CMath::sqrt(normalization_const);
            SG_DEBUG("normalization_const:%f\n", normalization_const);
        }

        inline float64_t get_normalization_const() { return normalization_const; }


    protected:

        SGVector<float64_t> apply_get_outputs(CFeatures* data);

        int32_t set_wd_weights();

        static void compute_W(
            float64_t *sq_norm_W, float64_t *dp_WoldW, float64_t *alpha,
            uint32_t nSel, void* ptr );

        static float64_t update_W(float64_t t, void* ptr );

        static void* add_new_cut_helper(void* ptr);

        static int add_new_cut(
            float64_t *new_col_H, uint32_t *new_cut, uint32_t cut_length,
            uint32_t nSel, void* ptr );

        static void* compute_output_helper(void* ptr);

        static int compute_output( float64_t *output, void* ptr );

        static int sort( float64_t* vals, float64_t* data, uint32_t size);

        static inline void print(ocas_return_value_T value)
        {
              return;
        }


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

    protected:
        virtual bool train_machine(CFeatures* data=NULL);

    protected:
        CStringFeatures<uint8_t>* features;
        bool use_bias;
        int32_t bufsize;
        float64_t C1;
        float64_t C2;
        float64_t epsilon;
        E_SVM_TYPE method;

        int32_t degree;
        int32_t from_degree;
        float32_t* wd_weights;
        int32_t num_vec;
        int32_t string_length;
        int32_t alphabet_size;

        float64_t normalization_const;

        float64_t bias;
        float64_t old_bias;
        int32_t* w_offsets;
        int32_t w_dim;
        int32_t w_dim_single_char;
        float32_t* w;
        float32_t* old_w;
        float64_t* lab;

        float32_t** cuts;
        float64_t* cp_bias;
};
}
#endif