SparseFeatures.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-2010 Soeren Sonnenburg
 * Written (W) 1999-2008 Gunnar Raetsch
 * Written (W) 2011-2012 Heiko Strathmann
 * Copyright (C) 1999-2009 Fraunhofer Institute FIRST and Max-Planck-Society
 * Copyright (C) 2010 Berlin Institute of Technology
 */

#ifndef _SPARSEFEATURES__H__
#define _SPARSEFEATURES__H__

#include <shogun/lib/config.h>

#include <shogun/lib/common.h>
#include <shogun/features/DenseFeatures.h>
#include <shogun/features/DotFeatures.h>
#include <shogun/lib/SGMatrix.h>
#include <shogun/lib/SGSparseMatrix.h>
#include <shogun/lib/SGVector.h>
#include <shogun/lib/SGSparseVector.h>

namespace shogun
{

class CFile;
class CLibSVMFile;
class CFeatures;
template <class ST> class CDenseFeatures;
template <class T> class CCache;

template <class ST> class CSparseFeatures : public CDotFeatures
{
    public:
        CSparseFeatures(int32_t size=0);

        CSparseFeatures(SGSparseMatrix<ST> sparse);

        CSparseFeatures(SGMatrix<ST> dense);

        CSparseFeatures(const CSparseFeatures & orig);

        CSparseFeatures(CFile* loader);

        virtual ~CSparseFeatures();

        void free_sparse_feature_matrix();

        void free_sparse_features();

        virtual CFeatures* duplicate() const;

        ST get_feature(int32_t num, int32_t index);

        SGVector<ST> get_full_feature_vector(int32_t num);

        virtual int32_t get_nnz_features_for_vector(int32_t num);

        SGSparseVector<ST> get_sparse_feature_vector(int32_t num);

        ST dense_dot(ST alpha, int32_t num, ST* vec, int32_t dim, ST b);

        void add_to_dense_vec(float64_t alpha, int32_t num,
                float64_t* vec, int32_t dim, bool abs_val=false);

        void free_sparse_feature_vector(int32_t num);

        SGSparseVector<ST>* get_sparse_feature_matrix(int32_t &num_feat, int32_t &num_vec);

        SGSparseMatrix<ST> get_sparse_feature_matrix();

        CSparseFeatures<ST>* get_transposed();

        SGSparseVector<ST>* get_transposed(int32_t &num_feat, int32_t &num_vec);

        void set_sparse_feature_matrix(SGSparseMatrix<ST> sm);

        SGMatrix<ST> get_full_feature_matrix();

        virtual void set_full_feature_matrix(SGMatrix<ST> full);

        virtual bool apply_preprocessor(bool force_preprocessing=false);

        void obtain_from_simple(CDenseFeatures<ST>* sf);

        virtual int32_t get_num_vectors() const;

        int32_t get_num_features() const;

        int32_t set_num_features(int32_t num);

        virtual EFeatureClass get_feature_class() const;

        virtual EFeatureType get_feature_type() const;

        void free_feature_vector(int32_t num);

        int64_t get_num_nonzero_entries();

        float64_t* compute_squared(float64_t* sq);

        float64_t compute_squared_norm(CSparseFeatures<float64_t>* lhs,
                float64_t* sq_lhs, int32_t idx_a,
                CSparseFeatures<float64_t>* rhs, float64_t* sq_rhs,
                int32_t idx_b);

        void load(CFile* loader);

        SGVector<float64_t> load_with_labels(CLibSVMFile* loader);

        void save(CFile* writer);

        void save_with_labels(CLibSVMFile* writer, SGVector<float64_t> labels);

        void sort_features();

        virtual int32_t get_dim_feature_space() const;

        virtual float64_t dot(int32_t vec_idx1, CDotFeatures* df, int32_t vec_idx2);

        virtual float64_t dense_dot(int32_t vec_idx1, const float64_t* vec2, int32_t vec2_len);

        #ifndef DOXYGEN_SHOULD_SKIP_THIS

        struct sparse_feature_iterator
        {
            SGSparseVector<ST> sv;

            int32_t vector_index;

            int32_t index;

            void print_info()
            {
                SG_SPRINT("sv=%p, vidx=%d, num_feat_entries=%d, index=%d\n",
                        sv.features, vector_index, sv.num_feat_entries, index);
            }
        };
        #endif

        virtual void* get_feature_iterator(int32_t vector_index);

        virtual bool get_next_feature(int32_t& index, float64_t& value, void* iterator);

        virtual void free_feature_iterator(void* iterator);

        virtual CFeatures* copy_subset(SGVector<index_t> indices);

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

    protected:
        virtual SGSparseVectorEntry<ST>* compute_sparse_feature_vector(int32_t num,
            int32_t& len, SGSparseVectorEntry<ST>* target=NULL);

    private:
        void init();

    protected:

        SGSparseMatrix<ST> sparse_feature_matrix;

        CCache< SGSparseVectorEntry<ST> >* feature_cache;
};
}
#endif /* _SPARSEFEATURES__H__ */