StreamingSimpleFeatures.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) 2011 Shashwat Lal Das
 * Copyright (C) 2011 Berlin Institute of Technology and Max-Planck-Society
 */
#ifndef _STREAMING_SIMPLEFEATURES__H__
#define _STREAMING_SIMPLEFEATURES__H__

#include <shogun/lib/common.h>
#include <shogun/mathematics/Math.h>
#include <shogun/features/StreamingDotFeatures.h>
#include <shogun/lib/DataType.h>
#include <shogun/io/StreamingFileFromSimpleFeatures.h>
#include <shogun/io/InputParser.h>

namespace shogun
{
template <class T> class CStreamingSimpleFeatures : public CStreamingDotFeatures
{
public:

    CStreamingSimpleFeatures()
        : CStreamingDotFeatures()
    {
        set_read_functions();
        init();
        parser.set_free_vector_after_release(false);
    }

    CStreamingSimpleFeatures(CStreamingFile* file,
                 bool is_labelled,
                 int32_t size)
        : CStreamingDotFeatures()
    {
        init(file, is_labelled, size);
        set_read_functions();
        parser.set_free_vector_after_release(false);
    }

    CStreamingSimpleFeatures(CSimpleFeatures<T>* simple_features,
                 float64_t* lab=NULL)
        : CStreamingDotFeatures()
    {
        CStreamingFileFromSimpleFeatures<T>* file;
        bool is_labelled;
        int32_t size = 1024;

        if (lab)
        {
            is_labelled = true;
            file = new CStreamingFileFromSimpleFeatures<T>(simple_features, lab);
        }
        else
        {
            is_labelled = false;
            file = new CStreamingFileFromSimpleFeatures<T>(simple_features);
        }

        SG_REF(file);

        init(file, is_labelled, size);
        set_read_functions();
        parser.set_free_vector_after_release(false);
        parser.set_free_vectors_on_destruct(false);
        seekable=true;
    }

    ~CStreamingSimpleFeatures()
    {
        parser.end_parser();
    }

    virtual void set_vector_reader();

    virtual void set_vector_and_label_reader();

    virtual void start_parser();

    virtual void end_parser();

    virtual void reset_stream()
    {
        if (seekable)
        {
            ((CStreamingFileFromSimpleFeatures<T>*) working_file)->reset_stream();
            parser.exit_parser();
            parser.init(working_file, has_labels, 1);
            parser.set_free_vector_after_release(false);
            parser.start_parser();
        }
    }

    virtual bool get_next_example();

    SGVector<T> get_vector();

    virtual float64_t get_label();

    virtual void release_example();

    virtual int32_t get_dim_feature_space() const;

    virtual float32_t dot(SGVector<T> vec);

    virtual float32_t dot(CStreamingDotFeatures *df);

    virtual float32_t dense_dot(const float32_t* vec2, int32_t vec2_len)
    {
        ASSERT(vec2_len==current_length);
        float32_t result=0;

        for (int32_t i=0; i<current_length; i++)
            result+=current_vector[i]*vec2[i];

        return result;
    }

    virtual float64_t dense_dot(const float64_t* vec2, int32_t vec2_len)
    {
        ASSERT(vec2_len==current_length);
        float64_t result=0;

        for (int32_t i=0; i<current_length; i++)
            result+=current_vector[i]*vec2[i];

        return result;
    }

    virtual void add_to_dense_vec(float32_t alpha, float32_t* vec2, int32_t vec2_len , bool abs_val=false)
    {
        ASSERT(vec2_len==current_length);

        if (abs_val)
        {
            for (int32_t i=0; i<current_length; i++)
                vec2[i]+=alpha*CMath::abs(current_vector[i]);
        }
        else
        {
            for (int32_t i=0; i<current_length; i++)
                vec2[i]+=alpha*current_vector[i];
        }
    }

    virtual void add_to_dense_vec(float64_t alpha, float64_t* vec2, int32_t vec2_len , bool abs_val=false)
    {
        ASSERT(vec2_len==current_length);

        if (abs_val)
        {
            for (int32_t i=0; i<current_length; i++)
                vec2[i]+=alpha*CMath::abs(current_vector[i]);
        }
        else
        {
            for (int32_t i=0; i<current_length; i++)
                vec2[i]+=alpha*current_vector[i];
        }
    }

    virtual inline int32_t get_nnz_features_for_vector()
    {
        return current_length;
    }

    int32_t get_num_features();

    virtual inline EFeatureType get_feature_type();

    virtual EFeatureClass get_feature_class();

    virtual CFeatures* duplicate() const
    {
        return new CStreamingSimpleFeatures<T>(*this);
    }

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

    inline virtual int32_t get_num_vectors() const
    {
        if (current_vector)
            return 1;
        return 0;
    }

    virtual int32_t get_size() { return sizeof(T); }

private:
    void init();

    void init(CStreamingFile *file, bool is_labelled, int32_t size);

protected:

    float32_t combined_weight;

    CInputParser<T> parser;

    SGVector<T> current_sgvector;

    T* current_vector;

    float64_t current_label;

    int32_t current_length;
};

template <class T> void CStreamingSimpleFeatures<T>::set_vector_reader()
{
    parser.set_read_vector(&CStreamingFile::get_vector);
}

template <class T> void CStreamingSimpleFeatures<T>::set_vector_and_label_reader()
{
    parser.set_read_vector_and_label(&CStreamingFile::get_vector_and_label);
}

#define GET_FEATURE_TYPE(f_type, sg_type)               \
template<> inline EFeatureType CStreamingSimpleFeatures<sg_type>::get_feature_type() \
{                                   \
    return f_type;                          \
}

GET_FEATURE_TYPE(F_BOOL, bool)
GET_FEATURE_TYPE(F_CHAR, char)
GET_FEATURE_TYPE(F_BYTE, uint8_t)
GET_FEATURE_TYPE(F_BYTE, int8_t)
GET_FEATURE_TYPE(F_SHORT, int16_t)
GET_FEATURE_TYPE(F_WORD, uint16_t)
GET_FEATURE_TYPE(F_INT, int32_t)
GET_FEATURE_TYPE(F_UINT, uint32_t)
GET_FEATURE_TYPE(F_LONG, int64_t)
GET_FEATURE_TYPE(F_ULONG, uint64_t)
GET_FEATURE_TYPE(F_SHORTREAL, float32_t)
GET_FEATURE_TYPE(F_DREAL, float64_t)
GET_FEATURE_TYPE(F_LONGREAL, floatmax_t)
#undef GET_FEATURE_TYPE


template <class T>
void CStreamingSimpleFeatures<T>::init()
{
    working_file=NULL;
    current_vector=NULL;
    seekable=false;
    current_length=-1;
}

template <class T>
void CStreamingSimpleFeatures<T>::init(CStreamingFile* file,
                    bool is_labelled,
                    int32_t size)
{
    init();
    has_labels = is_labelled;
    working_file = file;
    parser.init(file, is_labelled, size);
    seekable=false;
}

template <class T>
void CStreamingSimpleFeatures<T>::start_parser()
{
    if (!parser.is_running())
        parser.start_parser();
}

template <class T>
void CStreamingSimpleFeatures<T>::end_parser()
{
    parser.end_parser();
}

template <class T>
bool CStreamingSimpleFeatures<T>::get_next_example()
{
    bool ret_value;
    ret_value = (bool) parser.get_next_example(current_vector,
                           current_length,
                           current_label);

    return ret_value;
}

template <class T>
SGVector<T> CStreamingSimpleFeatures<T>::get_vector()
{
    current_sgvector.vector=current_vector;
    current_sgvector.vlen=current_length;

    return current_sgvector;
}

template <class T>
float64_t CStreamingSimpleFeatures<T>::get_label()
{
    ASSERT(has_labels);

    return current_label;
}

template <class T>
void CStreamingSimpleFeatures<T>::release_example()
{
    parser.finalize_example();
}

template <class T>
int32_t CStreamingSimpleFeatures<T>::get_dim_feature_space() const
{
    return current_length;
}

template <class T>
    float32_t CStreamingSimpleFeatures<T>::dot(CStreamingDotFeatures* df)
{
    ASSERT(df);
    ASSERT(df->get_feature_type() == get_feature_type());
    ASSERT(df->get_feature_class() == get_feature_class());
    CStreamingSimpleFeatures<T>* sf = (CStreamingSimpleFeatures<T>*) df;

    SGVector<T> other_vector=sf->get_vector();

    float32_t result = CMath::dot(current_vector, other_vector.vector, current_length);

    return result;
}

template <class T>
float32_t CStreamingSimpleFeatures<T>::dot(SGVector<T> sgvec1)
{
    int32_t len1;
    len1=sgvec1.vlen;

    if (len1 != current_length)
        SG_ERROR("Lengths %d and %d not equal while computing dot product!\n", len1, current_length);

    float32_t result=CMath::dot(current_vector, sgvec1.vector, len1);
    return result;
}

template <class T>
int32_t CStreamingSimpleFeatures<T>::get_num_features()
{
    return current_length;
}

template <class T>
EFeatureClass CStreamingSimpleFeatures<T>::get_feature_class()
{
    return C_STREAMING_SIMPLE;
}

}
#endif // _STREAMING_SIMPLEFEATURES__H__