Skip to content

Commit

Permalink
added sparse matrix under parameter framework
Browse files Browse the repository at this point in the history
  • Loading branch information
@lambday
lambday committed Jul 9, 2013
1 parent aef8ebc commit d78cca8
Show file tree
Hide file tree
Showing 4 changed files with 492 additions and 6 deletions.
159 changes: 154 additions & 5 deletions src/shogun/base/Parameter.cpp
View file
Expand Up @@ -1643,6 +1643,127 @@ void Parameter::add(SGMatrix<SGSparseVector<complex64_t> >* param,
&param->num_cols);
add_type(&type, &param->matrix, name, description);
}

void Parameter::add(SGSparseMatrix<bool>* param,
const char* name, const char* description)
{
TSGDataType type(CT_SGMATRIX, ST_SPARSE, PT_BOOL, &param->num_vectors,
&param->num_features);
add_type(&type, &param->sparse_matrix, name, description);
}

void Parameter::add(SGSparseMatrix<char>* param,
const char* name, const char* description)
{
TSGDataType type(CT_SGMATRIX, ST_SPARSE, PT_CHAR, &param->num_vectors,
&param->num_features);
add_type(&type, &param->sparse_matrix, name, description);
}

void Parameter::add(SGSparseMatrix<int8_t>* param,
const char* name, const char* description)
{
TSGDataType type(CT_SGMATRIX, ST_SPARSE, PT_INT8, &param->num_vectors,
&param->num_features);
add_type(&type, &param->sparse_matrix, name, description);
}

void Parameter::add(SGSparseMatrix<uint8_t>* param,
const char* name, const char* description)
{
TSGDataType type(CT_SGMATRIX, ST_SPARSE, PT_UINT8, &param->num_vectors,
&param->num_features);
add_type(&type, &param->sparse_matrix, name, description);
}

void Parameter::add(SGSparseMatrix<int16_t>* param,
const char* name, const char* description)
{
TSGDataType type(CT_SGMATRIX, ST_SPARSE, PT_INT16, &param->num_vectors,
&param->num_features);
add_type(&type, &param->sparse_matrix, name, description);
}

void Parameter::add(SGSparseMatrix<uint16_t>* param,
const char* name, const char* description)
{
TSGDataType type(CT_SGMATRIX, ST_SPARSE, PT_UINT16, &param->num_vectors,
&param->num_features);
add_type(&type, &param->sparse_matrix, name, description);
}

void Parameter::add(SGSparseMatrix<int32_t>* param,
const char* name, const char* description)
{
TSGDataType type(CT_SGMATRIX, ST_SPARSE, PT_INT32, &param->num_vectors,
&param->num_features);
add_type(&type, &param->sparse_matrix, name, description);
}

void Parameter::add(SGSparseMatrix<uint32_t>* param,
const char* name, const char* description)
{
TSGDataType type(CT_SGMATRIX, ST_SPARSE, PT_UINT32, &param->num_vectors,
&param->num_features);
add_type(&type, &param->sparse_matrix, name, description);
}

void Parameter::add(SGSparseMatrix<int64_t>* param,
const char* name, const char* description)
{
TSGDataType type(CT_SGMATRIX, ST_SPARSE, PT_INT64, &param->num_vectors,
&param->num_features);
add_type(&type, &param->sparse_matrix, name, description);
}

void Parameter::add(SGSparseMatrix<uint64_t>* param,
const char* name, const char* description)
{
TSGDataType type(CT_SGMATRIX, ST_SPARSE, PT_UINT64, &param->num_vectors,
&param->num_features);
add_type(&type, &param->sparse_matrix, name, description);
}

void Parameter::add(SGSparseMatrix<float32_t>* param,
const char* name, const char* description)
{
TSGDataType type(CT_SGMATRIX, ST_SPARSE, PT_FLOAT32, &param->num_vectors,
&param->num_features);
add_type(&type, &param->sparse_matrix, name, description);
}

void Parameter::add(SGSparseMatrix<float64_t>* param,
const char* name, const char* description)
{
TSGDataType type(CT_SGMATRIX, ST_SPARSE, PT_FLOAT64, &param->num_vectors,
&param->num_features);
add_type(&type, &param->sparse_matrix, name, description);
}

void Parameter::add(SGSparseMatrix<floatmax_t>* param,
const char* name, const char* description)
{
TSGDataType type(CT_SGMATRIX, ST_SPARSE, PT_FLOATMAX, &param->num_vectors,
&param->num_features);
add_type(&type, &param->sparse_matrix, name, description);
}

void Parameter::add(SGSparseMatrix<complex64_t>* param,
const char* name, const char* description)
{
TSGDataType type(CT_SGMATRIX, ST_SPARSE, PT_COMPLEX64, &param->num_vectors,
&param->num_features);
add_type(&type, &param->sparse_matrix, name, description);
}

void Parameter::add(SGSparseMatrix<CSGObject*>* param,
const char* name, const char* description)
{
TSGDataType type(CT_SGMATRIX, ST_SPARSE, PT_SGOBJECT, &param->num_vectors,
&param->num_features);
add_type(&type, &param->sparse_matrix, name, description);
}

/* **************************************************************** */
/* End of wrappers */

Expand Down Expand Up @@ -3019,7 +3140,17 @@ bool TParameter::equals(TParameter* other, float64_t accuracy)
index_t x=0;
SG_SDEBUG("length_y: %d\n", *m_datatype.m_length_y)
SG_SDEBUG("length_x: %d\n", *m_datatype.m_length_x)
int64_t length=(*m_datatype.m_length_y) * (*m_datatype.m_length_x);
int64_t length=0;

/* For ST_SPARSE, we just need to loop over the rows and compare_stype
* does the comparison for one whole row vector at once. For ST_NONE,
* however, we need to loop over all elements.
*/
if (m_datatype.m_stype==ST_SPARSE)
length=(*m_datatype.m_length_y);
else
length=(*m_datatype.m_length_y) * (*m_datatype.m_length_x);

for (index_t i=0; i<length; ++i)
{
SG_SDEBUG("comparing element %d which is %d byes from start\n",
Expand All @@ -3036,7 +3167,11 @@ bool TParameter::equals(TParameter* other, float64_t accuracy)
return false;
}

x=x+(m_datatype.sizeof_ptype());
/* For ST_SPARSE, the iteration is on the pointer of SGSparseVectors */
if (m_datatype.m_stype==ST_SPARSE)
x=x+(m_datatype.sizeof_stype());
else
x=x+(m_datatype.sizeof_ptype());
}

break;
Expand Down Expand Up @@ -3844,7 +3979,12 @@ bool TParameter::copy(TParameter* target)
if (*(char**)target->m_parameter==NULL)
{
SG_SDEBUG("allocating memory for target vector\n");
size_t num_bytes=*m_datatype.m_length_y *
size_t num_bytes=0;
/* for ST_SPARSE allocate only for a vector of m_length_y */
if (m_datatype.m_stype==ST_SPARSE)
num_bytes=*m_datatype.m_length_y * m_datatype.sizeof_stype();
else
num_bytes=*m_datatype.m_length_y *
(*m_datatype.m_length_y) * m_datatype.sizeof_stype();
*(char**)target->m_parameter=SG_MALLOC(char, num_bytes);

Expand All @@ -3861,7 +4001,12 @@ bool TParameter::copy(TParameter* target)
index_t x=0;
SG_SDEBUG("length_y: %d\n", *m_datatype.m_length_y)
SG_SDEBUG("length_x: %d\n", *m_datatype.m_length_x)
int64_t length=(*m_datatype.m_length_y) * (*m_datatype.m_length_x);
int64_t length=0;
/* for ST_SPARSE allocate iterate over a vector of m_length_y */
if (m_datatype.m_stype==ST_SPARSE)
length=(*m_datatype.m_length_y);
else
length=(*m_datatype.m_length_y) * (*m_datatype.m_length_x);
for (index_t i=0; i<length; ++i)
{
SG_SDEBUG("copying element %d which is %d byes from start\n",
Expand All @@ -3878,7 +4023,11 @@ bool TParameter::copy(TParameter* target)
return false;
}

x=x+(m_datatype.sizeof_ptype());
/* For ST_SPARSE, the iteration is on the pointer of SGSparseVectors */
if (m_datatype.m_stype==ST_SPARSE)
x=x+(m_datatype.sizeof_stype());
else
x=x+(m_datatype.sizeof_ptype());
}

break;
Expand Down
106 changes: 106 additions & 0 deletions src/shogun/base/Parameter.h
View file
Expand Up @@ -16,6 +16,7 @@
#include <shogun/lib/DataType.h>
#include <shogun/lib/SGVector.h>
#include <shogun/lib/SGMatrix.h>
#include <shogun/lib/SGSparseMatrix.h>
#include <shogun/io/SerializableFile.h>
#include <shogun/base/DynArray.h>

Expand Down Expand Up @@ -1933,6 +1934,111 @@ class Parameter
void add(SGMatrix<SGSparseVector<complex64_t> >* param,
const char* name, const char* description="");

/** add matrix param
* @param param parameter matrix itself
* @param name name of parameter
* @param description description of parameter
*/
void add(SGSparseMatrix<bool>* param,
const char* name, const char* description="");
/** add matrix param
* @param param parameter matrix itself
* @param name name of parameter
* @param description description of parameter
*/
void add(SGSparseMatrix<char>* param,
const char* name, const char* description="");
/** add matrix param
* @param param parameter matrix itself
* @param name name of parameter
* @param description description of parameter
*/
void add(SGSparseMatrix<int8_t>* param,
const char* name, const char* description="");
/** add matrix param
* @param param parameter matrix itself
* @param name name of parameter
* @param description description of parameter
*/
void add(SGSparseMatrix<uint8_t>* param,
const char* name, const char* description="");
/** add matrix param
* @param param parameter matrix itself
* @param name name of parameter
* @param description description of parameter
*/
void add(SGSparseMatrix<int16_t>* param,
const char* name, const char* description="");
/** add matrix param
* @param param parameter matrix itself
* @param name name of parameter
* @param description description of parameter
*/
void add(SGSparseMatrix<uint16_t>* param,
const char* name, const char* description="");
/** add matrix param
* @param param parameter matrix itself
* @param name name of parameter
* @param description description of parameter
*/
void add(SGSparseMatrix<int32_t>* param,
const char* name, const char* description="");
/** add matrix param
* @param param parameter matrix itself
* @param name name of parameter
* @param description description of parameter
*/
void add(SGSparseMatrix<uint32_t>* param,
const char* name, const char* description="");
/** add matrix param
* @param param parameter matrix itself
* @param name name of parameter
* @param description description of parameter
*/
void add(SGSparseMatrix<int64_t>* param,
const char* name, const char* description="");
/** add matrix param
* @param param parameter matrix itself
* @param name name of parameter
* @param description description of parameter
*/
void add(SGSparseMatrix<uint64_t>* param,
const char* name, const char* description="");
/** add matrix param
* @param param parameter matrix itself
* @param name name of parameter
* @param description description of parameter
*/
void add(SGSparseMatrix<float32_t>* param,
const char* name, const char* description="");
/** add matrix param
* @param param parameter matrix itself
* @param name name of parameter
* @param description description of parameter
*/
void add(SGSparseMatrix<float64_t>* param,
const char* name, const char* description="");
/** add matrix param
* @param param parameter matrix itself
* @param name name of parameter
* @param description description of parameter
*/
void add(SGSparseMatrix<floatmax_t>* param,
const char* name, const char* description="");
/** add matrix param
* @param param parameter matrix itself
* @param name name of parameter
* @param description description of parameter
*/
void add(SGSparseMatrix<complex64_t>* param,
const char* name, const char* description="");
/** add matrix param
* @param param parameter matrix itself
* @param name name of parameter
* @param description description of parameter
*/
void add(SGSparseMatrix<CSGObject*>* param,
const char* name, const char* description="");
protected:

/** array of parameters */
Expand Down
2 changes: 1 addition & 1 deletion src/shogun/features/SparseFeatures.h
View file
Expand Up @@ -196,7 +196,7 @@ template <class ST> class CSparseFeatures : public CDotFeatures
* @return sparse matrix
*
*/
SGSparseMatrix<ST> get_sparse_feature_matrix();
SGSparseMatrix<ST> get_sparse_feature_matrix();

/** get a transposed copy of the features
*
Expand Down

0 comments on commit d78cca8

Please sign in to comment.