SGSparseMatrix.cpp

Go to the documentation of this file.

#include <shogun/lib/SGMatrix.h>
#include <shogun/lib/SGSparseMatrix.h>
#include <shogun/lib/SGSparseVector.h>
#include <shogun/io/File.h>
#include <shogun/io/SGIO.h>
#include <shogun/io/LibSVMFile.h>

namespace shogun {

template <class T>
SGSparseMatrix<T>::SGSparseMatrix() : SGReferencedData()
{
    init_data();
}

template <class T>
SGSparseMatrix<T>::SGSparseMatrix(SGSparseVector<T>* vecs, index_t num_feat,
        index_t num_vec, bool ref_counting) :
    SGReferencedData(ref_counting),
    num_vectors(num_vec), num_features(num_feat),
    sparse_matrix(vecs)
{
}

template <class T>
SGSparseMatrix<T>::SGSparseMatrix(index_t num_feat, index_t num_vec, bool ref_counting) :
    SGReferencedData(ref_counting),
    num_vectors(num_vec), num_features(num_feat)
{
    sparse_matrix=SG_MALLOC(SGSparseVector<T>, num_vectors);
}

template <class T>
SGSparseMatrix<T>::SGSparseMatrix(SGMatrix<T> dense) : SGReferencedData()
{
    from_dense(dense);
}

template <class T>
SGSparseMatrix<T>::SGSparseMatrix(const SGSparseMatrix &orig) : SGReferencedData(orig)
{
    copy_data(orig);
}

template <class T>
SGSparseMatrix<T>::~SGSparseMatrix()
{
    unref();
}

template <> template <>
const SGVector<complex128_t> SGSparseMatrix<complex128_t>::operator*(
    SGVector<float64_t> v) const
{
    SGVector<complex128_t> result(num_vectors);
    REQUIRE(v.vlen==num_features,
        "Dimension mismatch! %d vs %d\n",
        v.vlen, num_features);
    for (index_t i=0; i<num_vectors; ++i)
        result[i]=sparse_matrix[i].dense_dot(v);
    return result;
}

template <> template <>
const SGVector<complex128_t> SGSparseMatrix<complex128_t>::operator*(
    SGVector<int32_t> v) const
{
    SGVector<complex128_t> result(num_vectors);
    REQUIRE(v.vlen==num_features,
        "Dimension mismatch! %d vs %d\n",
        v.vlen, num_features);
    for (index_t i=0; i<num_vectors; ++i)
        result[i]=sparse_matrix[i].dense_dot(v);
    return result;
}

template <> template <>
const SGVector<float64_t> SGSparseMatrix<float64_t>::operator*(
    SGVector<int32_t> v) const
{
    SGVector<float64_t> result(num_vectors);
    REQUIRE(v.vlen==num_features,
        "Dimension mismatch! %d vs %d\n",
        v.vlen, num_features);
    for (index_t i=0; i<num_vectors; ++i)
        result[i]=sparse_matrix[i].dense_dot(v);
    return result;
}

template<class T>
void SGSparseMatrix<T>::load(CFile* loader)
{
    ASSERT(loader)
    unref();

    SG_SET_LOCALE_C;
    loader->get_sparse_matrix(sparse_matrix, num_features, num_vectors);
    SG_RESET_LOCALE;
}

template<>
void SGSparseMatrix<complex128_t>::load(CFile* loader)
{
    SG_SERROR("SGSparseMatrix::load():: Not supported for complex128_t");
}

template<class T> SGVector<float64_t> SGSparseMatrix<T>::load_with_labels(CLibSVMFile* file, bool do_sort_features)
{
    ASSERT(file)

    float64_t* raw_labels;
    file->get_sparse_matrix(sparse_matrix, num_features, num_vectors,
                    raw_labels, true);

    SGVector<float64_t> labels(raw_labels, num_vectors);

    if (do_sort_features)
        sort_features();

    return labels;
}

template<> SGVector<float64_t> SGSparseMatrix<complex128_t>::load_with_labels(CLibSVMFile* file, bool do_sort_features) { return SGVector<float64_t>(); }


template<class T>
void SGSparseMatrix<T>::save(CFile* saver)
{
    ASSERT(saver)

    SG_SET_LOCALE_C;
    saver->set_sparse_matrix(sparse_matrix, num_features, num_vectors);
    SG_RESET_LOCALE;
}

template<>
void SGSparseMatrix<complex128_t>::save(CFile* saver)
{
    SG_SERROR("SGSparseMatrix::save():: Not supported for complex128_t");
}

template<class T> void SGSparseMatrix<T>::save_with_labels(CLibSVMFile* file,
        SGVector<float64_t> labels)
{
    ASSERT(file)
    int32_t num=labels.vlen;
    ASSERT(num>0)
    ASSERT(num==num_vectors)

    float64_t* raw_labels=labels.vector;
    file->set_sparse_matrix(sparse_matrix, num_features, num_vectors,
            raw_labels);
}

template <> void SGSparseMatrix<complex128_t>::save_with_labels(CLibSVMFile* saver, SGVector<float64_t> labels) { }


template <class T>
void SGSparseMatrix<T>::copy_data(const SGReferencedData& orig)
{
    sparse_matrix = ((SGSparseMatrix*)(&orig))->sparse_matrix;
    num_vectors = ((SGSparseMatrix*)(&orig))->num_vectors;
    num_features = ((SGSparseMatrix*)(&orig))->num_features;
}

template <class T>
void SGSparseMatrix<T>::init_data()
{
    sparse_matrix = NULL;
    num_vectors = 0;
    num_features = 0;
}

template <class T>
void SGSparseMatrix<T>::free_data()
{
    SG_FREE(sparse_matrix);
    num_vectors = 0;
    num_features = 0;
}

template<class T> SGSparseMatrix<T> SGSparseMatrix<T>::get_transposed()
{
    SGSparseMatrix<T> sfm(num_vectors, num_features);

    int32_t* hist=SG_CALLOC(int32_t, num_features);

    // count the lengths of future feature vectors
    for (int32_t v=0; v<num_vectors; v++)
    {
        SGSparseVector<T> sv=sparse_matrix[v];

        for (int32_t i=0; i<sv.num_feat_entries; i++)
            hist[sv.features[i].feat_index]++;
    }

    for (int32_t v=0; v<num_features; v++)
        sfm[v]=SGSparseVector<T>(hist[v]);

    SG_FREE(hist);

    int32_t* index=SG_CALLOC(int32_t, num_features);

    // fill future feature vectors with content
    for (int32_t v=0; v<num_vectors; v++)
    {
        SGSparseVector<T> sv=sparse_matrix[v];

        for (int32_t i=0; i<sv.num_feat_entries; i++)
        {
            int32_t vidx=sv.features[i].feat_index;
            int32_t fidx=v;
            sfm[vidx].features[index[vidx]].feat_index=fidx;
            sfm[vidx].features[index[vidx]].entry=sv.features[i].entry;
            index[vidx]++;
        }
    }

    SG_FREE(index);
    return sfm;
}


template<class T> void SGSparseMatrix<T>::sort_features()
{
    for (int32_t i=0; i<num_vectors; i++)
    {
        sparse_matrix[i].sort_features();
    }
}

template<class T> void SGSparseMatrix<T>::from_dense(SGMatrix<T> full)
{
    T* src=full.matrix;
    int32_t num_feat=full.num_rows;
    int32_t num_vec=full.num_cols;

    REQUIRE(num_vec>0, "Matrix should have > 0 vectors!\n");

    SG_SINFO("converting dense feature matrix to sparse one\n")
        int32_t* num_feat_entries=SG_MALLOC(int, num_vec);


    int64_t num_total_entries=0;

    // count nr of non sparse features
    for (int32_t i=0; i<num_vec; i++)
    {
        num_feat_entries[i]=0;
        for (int32_t j=0; j<num_feat; j++)
        {
            if (src[i*((int64_t) num_feat) + j] != static_cast<T>(0))
                num_feat_entries[i]++;
        }
    }

    num_features=num_feat;
    num_vectors=num_vec;
    sparse_matrix=SG_MALLOC(SGSparseVector<T>,num_vec);

    for (int32_t i=0; i< num_vec; i++)
    {
        sparse_matrix[i]=SGSparseVector<T>(num_feat_entries[i]);
        int32_t sparse_feat_idx=0;

        for (int32_t j=0; j< num_feat; j++)
        {
            int64_t pos= i*num_feat + j;

            if (src[pos] != static_cast<T>(0))
            {
                sparse_matrix[i].features[sparse_feat_idx].entry=src[pos];
                sparse_matrix[i].features[sparse_feat_idx].feat_index=j;
                sparse_feat_idx++;
                num_total_entries++;
            }
        }
    }

    SG_SINFO("sparse feature matrix has %ld entries (full matrix had %ld, sparsity %2.2f%%)\n",
            num_total_entries, int64_t(num_feat)*num_vec, (100.0*num_total_entries)/(int64_t(num_feat)*num_vec));
    SG_FREE(num_feat_entries);
}

template class SGSparseMatrix<bool>;
template class SGSparseMatrix<char>;
template class SGSparseMatrix<int8_t>;
template class SGSparseMatrix<uint8_t>;
template class SGSparseMatrix<int16_t>;
template class SGSparseMatrix<uint16_t>;
template class SGSparseMatrix<int32_t>;
template class SGSparseMatrix<uint32_t>;
template class SGSparseMatrix<int64_t>;
template class SGSparseMatrix<uint64_t>;
template class SGSparseMatrix<float32_t>;
template class SGSparseMatrix<float64_t>;
template class SGSparseMatrix<floatmax_t>;
template class SGSparseMatrix<complex128_t>;
}